diff --git a/.gitattributes b/.gitattributes index 8df7db2b7ea9de84d88c2940389c0e4c03fd0f24..9d6e1ba57b9e749b4773f23aa1158e8c264ac3d9 100644 --- a/.gitattributes +++ b/.gitattributes @@ -405,3 +405,30 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text .venv/lib/python3.12/site-packages/setuptools/_vendor/more_itertools/__pycache__/more.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text .venv/lib/python3.12/site-packages/setuptools/command/__pycache__/easy_install.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text .venv/lib/python3.12/site-packages/setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/core.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/core.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_query.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_sums_products.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/__pycache__/expr.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/__pycache__/function.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/__pycache__/numbers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_args.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expr.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_function.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_numbers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/crypto.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/numbers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/hyperbolic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/trigonometric.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bessel.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text +.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/polygon.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/METADATA b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..83299c05e2e3fec725c891d7615a076292987010 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/METADATA @@ -0,0 +1,141 @@ +Metadata-Version: 2.4 +Name: setuptools +Version: 78.1.0 +Summary: Easily download, build, install, upgrade, and uninstall Python packages +Author-email: Python Packaging Authority +Project-URL: Source, https://github.com/pypa/setuptools +Project-URL: Documentation, https://setuptools.pypa.io/ +Project-URL: Changelog, https://setuptools.pypa.io/en/stable/history.html +Keywords: CPAN PyPI distutils eggs package management +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: System :: Archiving :: Packaging +Classifier: Topic :: System :: Systems Administration +Classifier: Topic :: Utilities +Requires-Python: >=3.9 +Description-Content-Type: text/x-rst +License-File: LICENSE +Provides-Extra: test +Requires-Dist: pytest!=8.1.*,>=6; extra == "test" +Requires-Dist: virtualenv>=13.0.0; extra == "test" +Requires-Dist: wheel>=0.44.0; extra == "test" +Requires-Dist: pip>=19.1; extra == "test" +Requires-Dist: packaging>=24.2; extra == "test" +Requires-Dist: jaraco.envs>=2.2; extra == "test" +Requires-Dist: pytest-xdist>=3; extra == "test" +Requires-Dist: jaraco.path>=3.7.2; extra == "test" +Requires-Dist: build[virtualenv]>=1.0.3; extra == "test" +Requires-Dist: filelock>=3.4.0; extra == "test" +Requires-Dist: ini2toml[lite]>=0.14; extra == "test" +Requires-Dist: tomli-w>=1.0.0; extra == "test" +Requires-Dist: pytest-timeout; extra == "test" +Requires-Dist: pytest-perf; sys_platform != "cygwin" and extra == "test" +Requires-Dist: jaraco.develop>=7.21; (python_version >= "3.9" and sys_platform != "cygwin") and extra == "test" +Requires-Dist: pytest-home>=0.5; extra == "test" +Requires-Dist: pytest-subprocess; extra == "test" +Requires-Dist: pyproject-hooks!=1.1; extra == "test" +Requires-Dist: jaraco.test>=5.5; extra == "test" +Provides-Extra: doc +Requires-Dist: sphinx>=3.5; extra == "doc" +Requires-Dist: jaraco.packaging>=9.3; extra == "doc" +Requires-Dist: rst.linker>=1.9; extra == "doc" +Requires-Dist: furo; extra == "doc" +Requires-Dist: sphinx-lint; extra == "doc" +Requires-Dist: jaraco.tidelift>=1.4; extra == "doc" +Requires-Dist: pygments-github-lexers==0.0.5; extra == "doc" +Requires-Dist: sphinx-favicon; extra == "doc" +Requires-Dist: sphinx-inline-tabs; extra == "doc" +Requires-Dist: sphinx-reredirects; extra == "doc" +Requires-Dist: sphinxcontrib-towncrier; extra == "doc" +Requires-Dist: sphinx-notfound-page<2,>=1; extra == "doc" +Requires-Dist: pyproject-hooks!=1.1; extra == "doc" +Requires-Dist: towncrier<24.7; extra == "doc" +Provides-Extra: ssl +Provides-Extra: certs +Provides-Extra: core +Requires-Dist: packaging>=24.2; extra == "core" +Requires-Dist: more_itertools>=8.8; extra == "core" +Requires-Dist: jaraco.text>=3.7; extra == "core" +Requires-Dist: importlib_metadata>=6; python_version < "3.10" and extra == "core" +Requires-Dist: tomli>=2.0.1; python_version < "3.11" and extra == "core" +Requires-Dist: wheel>=0.43.0; extra == "core" +Requires-Dist: platformdirs>=4.2.2; extra == "core" +Requires-Dist: jaraco.functools>=4; extra == "core" +Requires-Dist: more_itertools; extra == "core" +Provides-Extra: check +Requires-Dist: pytest-checkdocs>=2.4; extra == "check" +Requires-Dist: pytest-ruff>=0.2.1; sys_platform != "cygwin" and extra == "check" +Requires-Dist: ruff>=0.8.0; sys_platform != "cygwin" and extra == "check" +Provides-Extra: cover +Requires-Dist: pytest-cov; extra == "cover" +Provides-Extra: enabler +Requires-Dist: pytest-enabler>=2.2; extra == "enabler" +Provides-Extra: type +Requires-Dist: pytest-mypy; extra == "type" +Requires-Dist: mypy==1.14.*; extra == "type" +Requires-Dist: importlib_metadata>=7.0.2; python_version < "3.10" and extra == "type" +Requires-Dist: jaraco.develop>=7.21; sys_platform != "cygwin" and extra == "type" +Dynamic: license-file + +.. |pypi-version| image:: https://img.shields.io/pypi/v/setuptools.svg + :target: https://pypi.org/project/setuptools + +.. |py-version| image:: https://img.shields.io/pypi/pyversions/setuptools.svg + +.. |test-badge| image:: https://github.com/pypa/setuptools/actions/workflows/main.yml/badge.svg + :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22 + :alt: tests + +.. |ruff-badge| image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json + :target: https://github.com/astral-sh/ruff + :alt: Ruff + +.. |docs-badge| image:: https://img.shields.io/readthedocs/setuptools/latest.svg + :target: https://setuptools.pypa.io + +.. |skeleton-badge| image:: https://img.shields.io/badge/skeleton-2025-informational + :target: https://blog.jaraco.com/skeleton + +.. |codecov-badge| image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white + :target: https://codecov.io/gh/pypa/setuptools + +.. |tidelift-badge| image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat + :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme + +.. |discord-badge| image:: https://img.shields.io/discord/803025117553754132 + :target: https://discord.com/channels/803025117553754132/815945031150993468 + :alt: Discord + +|pypi-version| |py-version| |test-badge| |ruff-badge| |docs-badge| |skeleton-badge| |codecov-badge| |discord-badge| + +See the `Quickstart `_ +and the `User's Guide `_ for +instructions on how to use Setuptools. + +Questions and comments should be directed to `GitHub Discussions +`_. +Bug reports and especially tested patches may be +submitted directly to the `bug tracker +`_. + + +Code of Conduct +=============== + +Everyone interacting in the setuptools project's codebases, issue trackers, +chat rooms, and fora is expected to follow the +`PSF Code of Conduct `_. + + +For Enterprise +============== + +Available as part of the Tidelift Subscription. + +Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. + +`Learn more `_. diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/RECORD b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..d929510cc5bb41d8dde979b656cb441aa71fb5f0 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/RECORD @@ -0,0 +1,872 @@ +_distutils_hack/__init__.py,sha256=34HmvLo07j45Uvd2VR-2aRQ7lJD91sTK6zJgn5fphbQ,6755 +_distutils_hack/__pycache__/__init__.cpython-312.pyc,, +_distutils_hack/__pycache__/override.cpython-312.pyc,, +_distutils_hack/override.py,sha256=Eu_s-NF6VIZ4Cqd0tbbA5wtWky2IZPNd8et6GLt1mzo,44 +distutils-precedence.pth,sha256=JjjOniUA5XKl4N5_rtZmHrVp0baW_LoHsN0iPaX10iQ,151 +pkg_resources/__init__.py,sha256=-rh7XOnTxdGuC-_9FAyu5D6s8BL1UsBehxUtj7a-IVo,126203 +pkg_resources/__pycache__/__init__.cpython-312.pyc,, +pkg_resources/api_tests.txt,sha256=XEdvy4igHHrq2qNHNMHnlfO6XSQKNqOyLHbl6QcpfAI,12595 +pkg_resources/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pkg_resources/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pkg_resources/tests/__pycache__/__init__.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_find_distributions.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_integration_zope_interface.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_markers.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_pkg_resources.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_resources.cpython-312.pyc,, +pkg_resources/tests/__pycache__/test_working_set.cpython-312.pyc,, +pkg_resources/tests/data/my-test-package-source/__pycache__/setup.cpython-312.pyc,, +pkg_resources/tests/data/my-test-package-source/setup.cfg,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pkg_resources/tests/data/my-test-package-source/setup.py,sha256=1VobhAZbMb7M9mfhb_NE8PwDsvukoWLs9aUAS0pYhe8,105 +pkg_resources/tests/data/my-test-package-zip/my-test-package.zip,sha256=AYRcQ39GVePPnMT8TknP1gdDHyJnXhthESmpAjnzSCI,1809 +pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO,sha256=JvWv9Io2PAuYwEEw2fBW4Qc5YvdbkscpKX1kmLzsoHk,187 +pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt,sha256=4ClkH8eTovZrdVrJFsVuxdbMEF--lBVSuKonDAPE5Jc,208 +pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1 +pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg,sha256=ZTlMGxjRGiKDNkiA2c75jbQH2TWIteP00irF9gvczbo,843 +pkg_resources/tests/test_find_distributions.py,sha256=U91cov5L1COAIWLNq3Xy4plU7_MnOE1WtXMu6iV2waM,1972 +pkg_resources/tests/test_integration_zope_interface.py,sha256=nzVoK557KZQN0V3DIQ1sVeaCOgt4Kpl-CODAWsO7pmc,1652 +pkg_resources/tests/test_markers.py,sha256=0orKg7UMDf7fnuNQvRMOc-EF9EAP_JTQnk4mtGgbW50,241 +pkg_resources/tests/test_pkg_resources.py,sha256=5Mt4bJQhLCL8j8cC46Uv32Np2Xc1TTxLGawIfET55Fk,17111 +pkg_resources/tests/test_resources.py,sha256=K0LqMAUGpRQ9pUb9K0vyI7GesvtlQvTH074m-E2VQlo,31252 +pkg_resources/tests/test_working_set.py,sha256=lRtGJWIixSwSMSbjHgRxeJEQiLMRXcz3xzJL2qL7eXY,8602 +setuptools-78.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools-78.1.0.dist-info/METADATA,sha256=RESmtUmo67AuFzn0N1r3dWyEH5bwwxB3oYMnPHRivRA,6599 +setuptools-78.1.0.dist-info/RECORD,, +setuptools-78.1.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91 +setuptools-78.1.0.dist-info/entry_points.txt,sha256=zkgthpf_Fa9NVE9p6FKT3Xk9DR1faAcRU4coggsV7jA,2449 +setuptools-78.1.0.dist-info/licenses/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools-78.1.0.dist-info/top_level.txt,sha256=d9yL39v_W7qmKDDSH6sT4bE0j_Ls1M3P161OGgdsm4g,41 +setuptools/__init__.py,sha256=AQsMeRFWz9CQ9aBtcSkbB4Dn8t2w86-GPriklpoAjew,10406 +setuptools/__pycache__/__init__.cpython-312.pyc,, +setuptools/__pycache__/_core_metadata.cpython-312.pyc,, +setuptools/__pycache__/_entry_points.cpython-312.pyc,, +setuptools/__pycache__/_imp.cpython-312.pyc,, +setuptools/__pycache__/_importlib.cpython-312.pyc,, +setuptools/__pycache__/_itertools.cpython-312.pyc,, +setuptools/__pycache__/_normalization.cpython-312.pyc,, +setuptools/__pycache__/_path.cpython-312.pyc,, +setuptools/__pycache__/_reqs.cpython-312.pyc,, +setuptools/__pycache__/_shutil.cpython-312.pyc,, +setuptools/__pycache__/_static.cpython-312.pyc,, +setuptools/__pycache__/archive_util.cpython-312.pyc,, +setuptools/__pycache__/build_meta.cpython-312.pyc,, +setuptools/__pycache__/depends.cpython-312.pyc,, +setuptools/__pycache__/discovery.cpython-312.pyc,, +setuptools/__pycache__/dist.cpython-312.pyc,, +setuptools/__pycache__/errors.cpython-312.pyc,, +setuptools/__pycache__/extension.cpython-312.pyc,, +setuptools/__pycache__/glob.cpython-312.pyc,, +setuptools/__pycache__/installer.cpython-312.pyc,, +setuptools/__pycache__/launch.cpython-312.pyc,, +setuptools/__pycache__/logging.cpython-312.pyc,, +setuptools/__pycache__/modified.cpython-312.pyc,, +setuptools/__pycache__/monkey.cpython-312.pyc,, +setuptools/__pycache__/msvc.cpython-312.pyc,, +setuptools/__pycache__/namespaces.cpython-312.pyc,, +setuptools/__pycache__/package_index.cpython-312.pyc,, +setuptools/__pycache__/sandbox.cpython-312.pyc,, +setuptools/__pycache__/unicode_utils.cpython-312.pyc,, +setuptools/__pycache__/version.cpython-312.pyc,, +setuptools/__pycache__/warnings.cpython-312.pyc,, +setuptools/__pycache__/wheel.cpython-312.pyc,, +setuptools/__pycache__/windows_support.cpython-312.pyc,, +setuptools/_core_metadata.py,sha256=T7Tjp-WSoN881adev3R1wzXCPnkDHqbC2MgylN1yjS8,11978 +setuptools/_distutils/__init__.py,sha256=xGYuhWwLG07J0Q49BVnEjPy6wyDcd6veJMDJX7ljlyM,359 +setuptools/_distutils/__pycache__/__init__.cpython-312.pyc,, +setuptools/_distutils/__pycache__/_log.cpython-312.pyc,, +setuptools/_distutils/__pycache__/_macos_compat.cpython-312.pyc,, +setuptools/_distutils/__pycache__/_modified.cpython-312.pyc,, +setuptools/_distutils/__pycache__/_msvccompiler.cpython-312.pyc,, +setuptools/_distutils/__pycache__/archive_util.cpython-312.pyc,, +setuptools/_distutils/__pycache__/ccompiler.cpython-312.pyc,, +setuptools/_distutils/__pycache__/cmd.cpython-312.pyc,, +setuptools/_distutils/__pycache__/core.cpython-312.pyc,, +setuptools/_distutils/__pycache__/cygwinccompiler.cpython-312.pyc,, +setuptools/_distutils/__pycache__/debug.cpython-312.pyc,, +setuptools/_distutils/__pycache__/dep_util.cpython-312.pyc,, +setuptools/_distutils/__pycache__/dir_util.cpython-312.pyc,, +setuptools/_distutils/__pycache__/dist.cpython-312.pyc,, +setuptools/_distutils/__pycache__/errors.cpython-312.pyc,, +setuptools/_distutils/__pycache__/extension.cpython-312.pyc,, +setuptools/_distutils/__pycache__/fancy_getopt.cpython-312.pyc,, +setuptools/_distutils/__pycache__/file_util.cpython-312.pyc,, +setuptools/_distutils/__pycache__/filelist.cpython-312.pyc,, +setuptools/_distutils/__pycache__/log.cpython-312.pyc,, +setuptools/_distutils/__pycache__/spawn.cpython-312.pyc,, +setuptools/_distutils/__pycache__/sysconfig.cpython-312.pyc,, +setuptools/_distutils/__pycache__/text_file.cpython-312.pyc,, +setuptools/_distutils/__pycache__/unixccompiler.cpython-312.pyc,, +setuptools/_distutils/__pycache__/util.cpython-312.pyc,, +setuptools/_distutils/__pycache__/version.cpython-312.pyc,, +setuptools/_distutils/__pycache__/versionpredicate.cpython-312.pyc,, +setuptools/_distutils/__pycache__/zosccompiler.cpython-312.pyc,, +setuptools/_distutils/_log.py,sha256=i-lNTTcXS8TmWITJ6DODGvtW5z5tMattJQ76h8rZxQU,42 +setuptools/_distutils/_macos_compat.py,sha256=JzUGhF4E5yIITHbUaPobZEWjGHdrrcNV63z86S4RjBc,239 +setuptools/_distutils/_modified.py,sha256=RF1n1CexyDYV3lvGbeXS0s-XCJVboDOIUbA8wEQqYTY,3211 +setuptools/_distutils/_msvccompiler.py,sha256=9PSfSHxvJnHnQL6Sqz4Xcz7iaBIT62p6BheQzGsSlwo,335 +setuptools/_distutils/archive_util.py,sha256=Qw2z-Pt-NV8lNUQrzjs3XDGWCWHMPnqHLyt8TiD2XEA,8884 +setuptools/_distutils/ccompiler.py,sha256=FKVjqzGJ7c-FtouNjhLiaMPm5LKMZHHAruXf8LU216c,524 +setuptools/_distutils/cmd.py,sha256=hXtaRaH7QBnfNOIqEvCt47iwZzD9MVvBdhhdQctHsxM,22186 +setuptools/_distutils/command/__init__.py,sha256=GfFAzbBqk1qxSH4BdaKioKS4hRRnD44BAmwEN85C4u8,386 +setuptools/_distutils/command/__pycache__/__init__.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/_framework_compat.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/bdist.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/bdist_dumb.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/bdist_rpm.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/build.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/build_clib.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/build_ext.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/build_py.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/build_scripts.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/check.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/clean.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/config.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install_data.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install_egg_info.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install_headers.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install_lib.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/install_scripts.cpython-312.pyc,, +setuptools/_distutils/command/__pycache__/sdist.cpython-312.pyc,, +setuptools/_distutils/command/_framework_compat.py,sha256=0iZdSJYzGRWCCvzRDKE-R0-_yaAYvFMd1ylXb2eYXug,1609 +setuptools/_distutils/command/bdist.py,sha256=jWtk61R7fWNUUNxJV0thTZzU5n80L3Ay1waSiP9kiLA,5854 +setuptools/_distutils/command/bdist_dumb.py,sha256=Hx1jAqoZNxYIy4N5TLzUp6J5fi8Ls18py7UlLNFhO2E,4631 +setuptools/_distutils/command/bdist_rpm.py,sha256=nxcXXv5a7B-1ntWu4DbGmCtES4EBINrJaBQcRNAYCJI,21785 +setuptools/_distutils/command/build.py,sha256=SpHlagf0iNaKVyIhxDfhPFZ8X1-LAWOCQACy-yt2K0w,5923 +setuptools/_distutils/command/build_clib.py,sha256=aMqZcUfCbOAu_xr-A9iW-Q9YZHzpDGLRTezOgMQJmSQ,7777 +setuptools/_distutils/command/build_ext.py,sha256=zrrsu9HXnzV6bXYbJuZCK4SwVZMjKnl4pG1o3bNcxtc,32710 +setuptools/_distutils/command/build_py.py,sha256=Vfq-INemoMbg6f003BTy_Ufp8bjOZhmFIhpKMcfXLgs,16696 +setuptools/_distutils/command/build_scripts.py,sha256=tUpEzwTsnrP8qrNory3ldPB240QDCFkMp-pdYPs2wTk,5118 +setuptools/_distutils/command/check.py,sha256=yoNe2MPY4JcTM7rwoIQdfZ75q5Ri058I2coi-Gq9CjM,4946 +setuptools/_distutils/command/clean.py,sha256=dQAacOabwBXU9JoZ-1GFusq3eFltDaeXJFSYncqGbvE,2644 +setuptools/_distutils/command/config.py,sha256=BuUdPu91Vo9w44xzD1RQfiyXfSfVcNpeX3aeoKcGAOw,12818 +setuptools/_distutils/command/install.py,sha256=-JenB-mua4hc2RI_-W8F9PnP_J-OaFO7E0PJGKxLo1o,30072 +setuptools/_distutils/command/install_data.py,sha256=GzBlUWWKubTYJlP-L0auUriq9cL-5RKOcoyHTttKj0Q,2875 +setuptools/_distutils/command/install_egg_info.py,sha256=ffiLoU1ivQJ8q2_WL7ZygZbUcOsgdFLKL7otEIJWWkI,2868 +setuptools/_distutils/command/install_headers.py,sha256=5ciKCj8c3XKsYNKdkdMvnypaUCKcoWCDeeZij3fD-Z4,1272 +setuptools/_distutils/command/install_lib.py,sha256=2s9-m5-b1qKm51F28lB5L39Z6vv_GHMlv9dNBSupok0,8588 +setuptools/_distutils/command/install_scripts.py,sha256=M0pPdiaqB7TGmqTMujpGGeiL0Iq_CTeGjMFtrmDmwzM,2002 +setuptools/_distutils/command/sdist.py,sha256=cRIF6Ht1hJ6ayOOFVycMFBUNxjo94e_rFYPx4Hi8Ahc,19151 +setuptools/_distutils/compat/__init__.py,sha256=J20aXGjJ86Rg41xFLIWlcWCgZ9edMdJ9vvdNEQ87vPQ,522 +setuptools/_distutils/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_distutils/compat/__pycache__/numpy.cpython-312.pyc,, +setuptools/_distutils/compat/__pycache__/py39.cpython-312.pyc,, +setuptools/_distutils/compat/numpy.py,sha256=UFgneZw9w97g4c-yGoAIOyLxUOWQ-fPRIhhfMs7_Ouc,167 +setuptools/_distutils/compat/py39.py,sha256=hOsD6lwZLqZoMnacNJ3P6nUA-LJQhEpVtYTzVH0o96M,1964 +setuptools/_distutils/compilers/C/__pycache__/base.cpython-312.pyc,, +setuptools/_distutils/compilers/C/__pycache__/cygwin.cpython-312.pyc,, +setuptools/_distutils/compilers/C/__pycache__/errors.cpython-312.pyc,, +setuptools/_distutils/compilers/C/__pycache__/msvc.cpython-312.pyc,, +setuptools/_distutils/compilers/C/__pycache__/unix.cpython-312.pyc,, +setuptools/_distutils/compilers/C/__pycache__/zos.cpython-312.pyc,, +setuptools/_distutils/compilers/C/base.py,sha256=XR1rBCStCquqm7QOYXD41-LfvsFcPpGxrwxeXzJyn_w,54876 +setuptools/_distutils/compilers/C/cygwin.py,sha256=DUlwQSb55aj7OdcmcddrmCmVEjEaxIiJ5hHUO3GBPNs,11844 +setuptools/_distutils/compilers/C/errors.py,sha256=sKOVzJajMUmNdfywo9UM_QQGsKFcclDhtI5TlCiXMLc,573 +setuptools/_distutils/compilers/C/msvc.py,sha256=elzG8v9jN5QytLMwLCdUdSuZ3eZ3R98VUvnm9Y2PBCA,21404 +setuptools/_distutils/compilers/C/tests/__pycache__/test_base.cpython-312.pyc,, +setuptools/_distutils/compilers/C/tests/__pycache__/test_cygwin.cpython-312.pyc,, +setuptools/_distutils/compilers/C/tests/__pycache__/test_mingw.cpython-312.pyc,, +setuptools/_distutils/compilers/C/tests/__pycache__/test_msvc.cpython-312.pyc,, +setuptools/_distutils/compilers/C/tests/__pycache__/test_unix.cpython-312.pyc,, +setuptools/_distutils/compilers/C/tests/test_base.py,sha256=rdhHc56bhXtm5NnN9BSHwr6c69UqzMItZQzlw2AsdMc,2706 +setuptools/_distutils/compilers/C/tests/test_cygwin.py,sha256=UgV2VgUXj3VulcbDc0UBWfEyJDx42tgSwS4LzHix3mY,2701 +setuptools/_distutils/compilers/C/tests/test_mingw.py,sha256=hCmwyywISpRoyOySbFHBL4TprWRV0mUWDKmOLO8XBXE,1900 +setuptools/_distutils/compilers/C/tests/test_msvc.py,sha256=DlGjmZ1mBSMXIgmlu80BKc7V-EJOZuYucwJwFh5dn28,4151 +setuptools/_distutils/compilers/C/tests/test_unix.py,sha256=ErbYWio7ejY2ZqQmPk4AwOu1HFW4-_-aZdUvGa1W2Fw,11834 +setuptools/_distutils/compilers/C/unix.py,sha256=l7CxY4rDJAECJo-vcv6io0SBmmPJ9JmN5mSmZcin2VU,16502 +setuptools/_distutils/compilers/C/zos.py,sha256=vnNeWLRZkdIkdZ-YyBnL8idTUfcCOn0tLMW5OBJ0ScU,6586 +setuptools/_distutils/core.py,sha256=GEHKaFC48T3o-_SmH4864GvKyx1IgbVC6ISIPVlx7a4,9364 +setuptools/_distutils/cygwinccompiler.py,sha256=mG_cU8SVZ4amD_VtF5vH6BXP0-kghGsDPbDSXrQ963c,594 +setuptools/_distutils/debug.py,sha256=N6MrTAqK6l9SVk6tWweR108PM8Ol7qNlfyV-nHcLhsY,139 +setuptools/_distutils/dep_util.py,sha256=xN75p6ZpHhMiHEc-rpL2XilJQynHnDNiafHteaZ4tjU,349 +setuptools/_distutils/dir_util.py,sha256=DXPUlfVVGsg9B-Jgg4At_j9T7vM60OgwNXkQHqTo7-I,7236 +setuptools/_distutils/dist.py,sha256=gW598UE0WMkzXQQ31Nr-8L7MPw0oIOz5OSSRzYZlwrM,55794 +setuptools/_distutils/errors.py,sha256=PPE2oDRh5y9Q1beKK9rhdvDaCzQhi4HCXs4KcqfqgZY,3092 +setuptools/_distutils/extension.py,sha256=Foyu4gULcPqm1_U9zrYYHxNk4NqglXv1rbsOk_QrSds,11155 +setuptools/_distutils/fancy_getopt.py,sha256=PjdO-bWCW0imV_UN-MGEw9R2GP2OiE8pHjITgmTAY3Q,17895 +setuptools/_distutils/file_util.py,sha256=YFQL_pD3hLuER9II_H6-hDC_YIGEookdd4wedLuiTW0,7978 +setuptools/_distutils/filelist.py,sha256=MBeSRJmPcKmDv8ooZgSU4BiQPZ0Khwv8l_jhD50XycI,15337 +setuptools/_distutils/log.py,sha256=VyBs5j7z4-K6XTEEBThUc9HyMpoPLGtQpERqbz5ylww,1200 +setuptools/_distutils/spawn.py,sha256=zseCh9sEifyp0I5Vg719JNIASlROJ2ehXqQnHlpt89Q,4086 +setuptools/_distutils/sysconfig.py,sha256=KeI8OHbMuEzHJ8Q0cBez9KZny8iRy6Z6Y0AkMz1jlsU,19728 +setuptools/_distutils/tests/__init__.py,sha256=j-IoPZEtQv3EOPuqNTwalr6GLyRjzCC-OOaNvZzmHsI,1485 +setuptools/_distutils/tests/__pycache__/__init__.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/support.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_archive_util.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_bdist.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_bdist_dumb.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_bdist_rpm.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_build.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_build_clib.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_build_ext.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_build_py.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_build_scripts.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_check.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_clean.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_cmd.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_config_cmd.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_core.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_dir_util.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_dist.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_extension.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_file_util.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_filelist.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_install.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_install_data.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_install_headers.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_install_lib.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_install_scripts.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_log.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_modified.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_sdist.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_spawn.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_sysconfig.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_text_file.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_util.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_version.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/test_versionpredicate.cpython-312.pyc,, +setuptools/_distutils/tests/__pycache__/unix_compat.cpython-312.pyc,, +setuptools/_distutils/tests/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_distutils/tests/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_distutils/tests/compat/__pycache__/py39.cpython-312.pyc,, +setuptools/_distutils/tests/compat/py39.py,sha256=t0GBTM-30jX-9zCfkwlNBFtzzabemx6065mJ0d9_VRw,1026 +setuptools/_distutils/tests/support.py,sha256=tjsYsyxvpTK4NrkCseh2ujvDIGV0Mf_b5SI5fP2T0yM,4099 +setuptools/_distutils/tests/test_archive_util.py,sha256=jozimSwPBF-JoJfN_vDaiVGZp66BNcWZGh34FlW57DQ,11787 +setuptools/_distutils/tests/test_bdist.py,sha256=xNHxUsLlHsZQRwkzLb_iSD24s-9Mk-NX2ffBWwOyPyc,1396 +setuptools/_distutils/tests/test_bdist_dumb.py,sha256=QF05MHNhPOdZyh88Xpw8KsO64s7pRFkl8KL-RoV4XK0,2247 +setuptools/_distutils/tests/test_bdist_rpm.py,sha256=Hdm-pwWgyaoGdGbEcGZa8cRhGU45y8gHK8umOanTjik,3932 +setuptools/_distutils/tests/test_build.py,sha256=JJY5XpOZco25ZY0pstxl-iI8mHsWP0ujf5o8aOtuZYY,1742 +setuptools/_distutils/tests/test_build_clib.py,sha256=Mo1ZFb4C1VXBYOGvnallwN7YCnTtr24akLDO8Zi4CsY,4331 +setuptools/_distutils/tests/test_build_ext.py,sha256=QFO9qYVhWWdJu17HXc4x9RMnLZlhk0lAHi9HVppbuX4,22545 +setuptools/_distutils/tests/test_build_py.py,sha256=NsfmRrojOHBXNMqWR_mp5g4PLTgjhD7iZFUffGZFIdw,6882 +setuptools/_distutils/tests/test_build_scripts.py,sha256=cD-FRy-oX55sXRX5Ez5xQCaeHrWajyKc4Xuwv2fe48w,2880 +setuptools/_distutils/tests/test_check.py,sha256=hHSV07qf7YoSxGsTbbsUQ9tssZz5RRNdbrY1s2SwaFI,6226 +setuptools/_distutils/tests/test_clean.py,sha256=hPH6jfIpGFUrvWbF1txkiNVSNaAxt2wq5XjV499zO4E,1240 +setuptools/_distutils/tests/test_cmd.py,sha256=bgRB79mitoOKR1OiyZHnCogvGxt3pWkxeTqIC04lQWQ,3254 +setuptools/_distutils/tests/test_config_cmd.py,sha256=Zs6WX0IfxDvmuC19XzuVNnYCnTr9Y-hl73TAmDSBN4Y,2664 +setuptools/_distutils/tests/test_core.py,sha256=L7XKVAxa-MGoAZeANopnuK9fRKneYhkSQpgw8XQvcF8,3829 +setuptools/_distutils/tests/test_dir_util.py,sha256=E84lC-k4riVUwURyWaQ0Jqx2ui2-io-0RuJa3M7qkJs,4500 +setuptools/_distutils/tests/test_dist.py,sha256=a6wlc5fQJd5qQ6HOndzcupNhjTxvj6-_JLtpuYvaP1M,18793 +setuptools/_distutils/tests/test_extension.py,sha256=-YejLgZCuycFrOBd64pVH0JvwMc9NwhzHvQxvvjXHqk,3670 +setuptools/_distutils/tests/test_file_util.py,sha256=livjnl3FkilQlrB2rFdFQq9nvjEVZHynNya0bfzv_b4,3522 +setuptools/_distutils/tests/test_filelist.py,sha256=rJwkqCUfkGDgWlD22TozsT8ycbupMHB8DXqThzwT1T4,10766 +setuptools/_distutils/tests/test_install.py,sha256=TfCB0ykhIxydIC2Q4SuTAZzSHvteMHgrBL9whoSgK9Q,8618 +setuptools/_distutils/tests/test_install_data.py,sha256=vKq3K97k0hBAnOg38nmwEdf7cEDVr9rTVyCeJolgb4A,2464 +setuptools/_distutils/tests/test_install_headers.py,sha256=PVAYpo_tYl980Qf64DPOmmSvyefIHdU06f7VsJeZykE,936 +setuptools/_distutils/tests/test_install_lib.py,sha256=qri6Rl-maNTQrNDV8DbeXNl0hjsfRIKiI4rfZLrmWBI,3612 +setuptools/_distutils/tests/test_install_scripts.py,sha256=KE3v0cDkFW-90IOID-OmZZGM2mhy-ZkEuuW7UXS2SHw,1600 +setuptools/_distutils/tests/test_log.py,sha256=isFtOufloCyEdZaQOV7cVUr46GwtdVMj43mGBB5XH7k,323 +setuptools/_distutils/tests/test_modified.py,sha256=h1--bOWmtJo1bpVV6uRhdnS9br71CBiNDM1MDwSGpug,4221 +setuptools/_distutils/tests/test_sdist.py,sha256=cfzUhlCA418-1vH9ta3IBs26c_jUBbkJoFOK5GnAyNk,15062 +setuptools/_distutils/tests/test_spawn.py,sha256=eS8w9D7bTxyFLSyRahJWeuh8Kc1F8RWWiY_dSG5B5Bc,4803 +setuptools/_distutils/tests/test_sysconfig.py,sha256=lxM8LsUi1TomjDV4HoYK8u5nUoBkeNL60Uq8PY1DcwU,11986 +setuptools/_distutils/tests/test_text_file.py,sha256=WQWSB5AfdBDZaMA8BFgipJPnsJb_2SKMfL90fSkRVtw,3460 +setuptools/_distutils/tests/test_util.py,sha256=H9zlZ4z4Vh4TfjNYDBsxP7wguQLpxCfJYyOcm1yZU3c,7988 +setuptools/_distutils/tests/test_version.py,sha256=ahfg_mP8wRy1sgwY-_Px5hrjgf6_upTIpnCgpR4yWRk,2750 +setuptools/_distutils/tests/test_versionpredicate.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_distutils/tests/unix_compat.py,sha256=z-op6C2iVdX1aq5BIBR7cqOxijKE97alNwJqHNdLpoI,386 +setuptools/_distutils/text_file.py,sha256=z4dkOJBr9Bo2LG0TNqm8sD63LEEaKSSP0J0bWBrFG3c,12101 +setuptools/_distutils/unixccompiler.py,sha256=1bXJWH4fiu_A2WfriHzf88xjllQTXnnjUkZdRKs9cWU,212 +setuptools/_distutils/util.py,sha256=Njfnqk60zMdkiAjRnGcTWX3t49-obHapOlbNvyIl02I,18094 +setuptools/_distutils/version.py,sha256=vImT5-ECXkQ21oKL0XYFiTqK6NyM09cpzBNoA_34CQU,12619 +setuptools/_distutils/versionpredicate.py,sha256=qBWQ6wTj12ODytoTmIydefIY2jb4uY1sdbgbuLn-IJM,5205 +setuptools/_distutils/zosccompiler.py,sha256=svdiXZ2kdcwKrJKfhUhib03y8gz7aGZKukXH3I7YkBc,58 +setuptools/_entry_points.py,sha256=Y3QUE9JKFW_YyquDnpffNWSs6f3jKEt1e-dnx--9-Kw,2310 +setuptools/_imp.py,sha256=YY1EjZEN-0zYci1cxO10B_adAEOr7i8eK8JoCc9Ierc,2435 +setuptools/_importlib.py,sha256=aKIjcK0HKXNz2D-XTrxaixGn_juTkONwmu3dcheMOF0,223 +setuptools/_itertools.py,sha256=jWRfsIrpC7myooz3hDURj9GtvpswZeKXg2HakmEhNjo,657 +setuptools/_normalization.py,sha256=kAmGfrwjF5djydEfLLyKgjkXCbL_0_ZxUPO-DlLlmIY,5824 +setuptools/_path.py,sha256=cPv41v03HD7uEYqCIo-E_cGRfpPVr4lywBCiK-HSrCg,2685 +setuptools/_reqs.py,sha256=QI3C9uOBSNRccu208qPnixHx51nxCry7_nPTIJaSYxM,1438 +setuptools/_shutil.py,sha256=cAOllcoyMTXs5JLoybQi29yI5gABk82hepJyOBv2bMw,1496 +setuptools/_static.py,sha256=GTR79gESF1_JaK4trLkpDrEuCeEtPlwQW0MRv7VNQX4,4855 +setuptools/_vendor/__pycache__/typing_extensions.cpython-312.pyc,, +setuptools/_vendor/autocommand-2.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/autocommand-2.2.2.dist-info/LICENSE,sha256=reeNBJgtaZctREqOFKlPh6IzTdOFXMgDSOqOJAqg3y0,7634 +setuptools/_vendor/autocommand-2.2.2.dist-info/METADATA,sha256=OADZuR3O6iBlpu1ieTgzYul6w4uOVrk0P0BO5TGGAJk,15006 +setuptools/_vendor/autocommand-2.2.2.dist-info/RECORD,sha256=giu6ZrQVJvpUcYa4AiH4XaUNZSvuVJPb_l0UCFES8MM,1308 +setuptools/_vendor/autocommand-2.2.2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92 +setuptools/_vendor/autocommand-2.2.2.dist-info/top_level.txt,sha256=AzfhgKKS8EdAwWUTSF8mgeVQbXOY9kokHB6kSqwwqu0,12 +setuptools/_vendor/autocommand/__init__.py,sha256=zko5Rnvolvb-UXjCx_2ArPTGBWwUK5QY4LIQIKYR7As,1037 +setuptools/_vendor/autocommand/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/autocommand/__pycache__/autoasync.cpython-312.pyc,, +setuptools/_vendor/autocommand/__pycache__/autocommand.cpython-312.pyc,, +setuptools/_vendor/autocommand/__pycache__/automain.cpython-312.pyc,, +setuptools/_vendor/autocommand/__pycache__/autoparse.cpython-312.pyc,, +setuptools/_vendor/autocommand/__pycache__/errors.cpython-312.pyc,, +setuptools/_vendor/autocommand/autoasync.py,sha256=AMdyrxNS4pqWJfP_xuoOcImOHWD-qT7x06wmKN1Vp-U,5680 +setuptools/_vendor/autocommand/autocommand.py,sha256=hmkEmQ72HtL55gnURVjDOnsfYlGd5lLXbvT4KG496Qw,2505 +setuptools/_vendor/autocommand/automain.py,sha256=A2b8i754Mxc_DjU9WFr6vqYDWlhz0cn8miu8d8EsxV8,2076 +setuptools/_vendor/autocommand/autoparse.py,sha256=WVWmZJPcbzUKXP40raQw_0HD8qPJ2V9VG1eFFmmnFxw,11642 +setuptools/_vendor/autocommand/errors.py,sha256=7aa3roh9Herd6nIKpQHNWEslWE8oq7GiHYVUuRqORnA,886 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/METADATA,sha256=ghXFTq132dxaEIolxr3HK1mZqm9iyUmaRANZQSr6WlE,2020 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/RECORD,sha256=JYofHISeEXUGmlWl1s41ev3QTjTNXeJwk-Ss7HqdLOE,1360 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/backports.tarfile-1.2.0.dist-info/top_level.txt,sha256=cGjaLMOoBR1FK0ApojtzWVmViTtJ7JGIK_HwXiEsvtU,10 +setuptools/_vendor/backports/__init__.py,sha256=iOEMwnlORWezdO8-2vxBIPSR37D7JGjluZ8f55vzxls,81 +setuptools/_vendor/backports/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/backports/tarfile/__init__.py,sha256=Pwf2qUIfB0SolJPCKcx3vz3UEu_aids4g4sAfxy94qg,108491 +setuptools/_vendor/backports/tarfile/__main__.py,sha256=Yw2oGT1afrz2eBskzdPYL8ReB_3liApmhFkN2EbDmc4,59 +setuptools/_vendor/backports/tarfile/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/backports/tarfile/__pycache__/__main__.cpython-312.pyc,, +setuptools/_vendor/backports/tarfile/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/backports/tarfile/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/backports/tarfile/compat/__pycache__/py38.cpython-312.pyc,, +setuptools/_vendor/backports/tarfile/compat/py38.py,sha256=iYkyt_gvWjLzGUTJD9TuTfMMjOk-ersXZmRlvQYN2qE,568 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/METADATA,sha256=anuQ7_7h4J1bSEzfcjIBakPi2cyVQ7y7jklLHsBeH1k,4648 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/RECORD,sha256=DY08buueu-hsrH1ghhVSQzwynanqUSSLYdAr4uXmQDA,2518 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91 +setuptools/_vendor/importlib_metadata-8.0.0.dist-info/top_level.txt,sha256=CO3fD9yylANiXkrMo4qHLV_mqXL2sC5JFKgt1yWAT-A,19 +setuptools/_vendor/importlib_metadata/__init__.py,sha256=tZNB-23h8Bixi9uCrQqj9Yf0aeC--Josdy3IZRIQeB0,33798 +setuptools/_vendor/importlib_metadata/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_adapters.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_collections.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_compat.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_functools.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_itertools.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_meta.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/_text.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/__pycache__/diagnose.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/_adapters.py,sha256=rIhWTwBvYA1bV7i-5FfVX38qEXDTXFeS5cb5xJtP3ks,2317 +setuptools/_vendor/importlib_metadata/_collections.py,sha256=CJ0OTCHIjWA0ZIVS4voORAsn2R4R2cQBEtPsZEJpASY,743 +setuptools/_vendor/importlib_metadata/_compat.py,sha256=73QKrN9KNoaZzhbX5yPCCZa-FaALwXe8TPlDR72JgBU,1314 +setuptools/_vendor/importlib_metadata/_functools.py,sha256=PsY2-4rrKX4RVeRC1oGp1lB1pmC9eKN88_f-bD9uOoA,2895 +setuptools/_vendor/importlib_metadata/_itertools.py,sha256=cvr_2v8BRbxcIl5x5ldfqdHjhI8Yi8s8yk50G_nm6jQ,2068 +setuptools/_vendor/importlib_metadata/_meta.py,sha256=nxZ7C8GVlcBFAKWyVOn_dn7ot_twBcbm1NmvjIetBHI,1801 +setuptools/_vendor/importlib_metadata/_text.py,sha256=HCsFksZpJLeTP3NEk_ngrAeXVRRtTrtyh9eOABoRP4A,2166 +setuptools/_vendor/importlib_metadata/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/importlib_metadata/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/compat/__pycache__/py311.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/compat/__pycache__/py39.cpython-312.pyc,, +setuptools/_vendor/importlib_metadata/compat/py311.py,sha256=uqm-K-uohyj1042TH4a9Er_I5o7667DvulcD-gC_fSA,608 +setuptools/_vendor/importlib_metadata/compat/py39.py,sha256=cPkMv6-0ilK-0Jw_Tkn0xYbOKJZc4WJKQHow0c2T44w,1102 +setuptools/_vendor/importlib_metadata/diagnose.py,sha256=nkSRMiowlmkhLYhKhvCg9glmt_11Cox-EmLzEbqYTa8,379 +setuptools/_vendor/importlib_metadata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/inflect-7.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/inflect-7.3.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/inflect-7.3.1.dist-info/METADATA,sha256=ZgMNY0WAZRs-U8wZiV2SMfjSKqBrMngXyDMs_CAwMwg,21079 +setuptools/_vendor/inflect-7.3.1.dist-info/RECORD,sha256=XXg0rBuiYSxoAQUP3lenuYsPNqz4jDwtTzdv2JEbMJE,943 +setuptools/_vendor/inflect-7.3.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91 +setuptools/_vendor/inflect-7.3.1.dist-info/top_level.txt,sha256=m52ujdp10CqT6jh1XQxZT6kEntcnv-7Tl7UiGNTzWZA,8 +setuptools/_vendor/inflect/__init__.py,sha256=Jxy1HJXZiZ85kHeLAhkmvz6EMTdFqBe-duvt34R6IOc,103796 +setuptools/_vendor/inflect/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/inflect/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/inflect/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/inflect/compat/__pycache__/py38.cpython-312.pyc,, +setuptools/_vendor/inflect/compat/py38.py,sha256=oObVfVnWX9_OpnOuEJn1mFbJxVhwyR5epbiTNXDDaso,160 +setuptools/_vendor/inflect/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/METADATA,sha256=IMUaliNsA5X1Ox9MXUWOagch5R4Wwb_3M7erp29dBtg,3933 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/RECORD,sha256=HptivXDkpfom6VlMu4CGD_7KPev-6Hc9rvp3TNJZygY,873 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91 +setuptools/_vendor/jaraco.collections-5.1.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/METADATA,sha256=xDtguJej0tN9iEXCUvxEJh2a7xceIRVBEakBLSr__tY,4020 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/RECORD,sha256=VRl7iKeEQyl7stgnp1uq50CzOJYlHYcoNdS0x17C9X4,641 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/jaraco.context-5.3.0.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/METADATA,sha256=i4aUaQDX-jjdEQK5wevhegyx8JyLfin2HyvaSk3FHso,2891 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/RECORD,sha256=YyqnwE98S8wBwCevW5vHb-iVj0oYEDW5V6O9MBS6JIs,843 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/jaraco.functools-4.0.1.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/METADATA,sha256=AzWdm6ViMfDOPoQMfLWn2zgBQSGJScyqeN29TcuWXVI,3658 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/RECORD,sha256=gW2UV0HcokYJk4jKPu10_AZnrLqjb3C1WbJJTDl5sfY,1500 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/jaraco.text-3.12.1.dist-info/top_level.txt,sha256=0JnN3LfXH4LIRfXL-QFOGCJzQWZO3ELx4R1d_louoQM,7 +setuptools/_vendor/jaraco/__pycache__/context.cpython-312.pyc,, +setuptools/_vendor/jaraco/collections/__init__.py,sha256=Pc1-SqjWm81ad1P0-GttpkwO_LWlnaY6gUq8gcKh2v0,26640 +setuptools/_vendor/jaraco/collections/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/jaraco/collections/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/jaraco/context.py,sha256=REoLIxDkO5MfEYowt_WoupNCRoxBS5v7YX2PbW8lIcs,9552 +setuptools/_vendor/jaraco/functools/__init__.py,sha256=hEAJaS2uSZRuF_JY4CxCHIYh79ZpxaPp9OiHyr9EJ1w,16642 +setuptools/_vendor/jaraco/functools/__init__.pyi,sha256=gk3dsgHzo5F_U74HzAvpNivFAPCkPJ1b2-yCd62dfnw,3878 +setuptools/_vendor/jaraco/functools/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/jaraco/functools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/jaraco/text/Lorem ipsum.txt,sha256=N_7c_79zxOufBY9HZ3yzMgOkNv-TkOTTio4BydrSjgs,1335 +setuptools/_vendor/jaraco/text/__init__.py,sha256=Y2YUqXR_orUoDaY4SkPRe6ZZhb5HUHB_Ah9RCNsVyho,16250 +setuptools/_vendor/jaraco/text/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/__pycache__/layouts.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/__pycache__/show-newlines.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/__pycache__/strip-prefix.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/__pycache__/to-dvorak.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/__pycache__/to-qwerty.cpython-312.pyc,, +setuptools/_vendor/jaraco/text/layouts.py,sha256=HTC8aSTLZ7uXipyOXapRMC158juecjK6RVwitfmZ9_w,643 +setuptools/_vendor/jaraco/text/show-newlines.py,sha256=WGQa65e8lyhb92LUOLqVn6KaCtoeVgVws6WtSRmLk6w,904 +setuptools/_vendor/jaraco/text/strip-prefix.py,sha256=NfVXV8JVNo6nqcuYASfMV7_y4Eo8zMQqlCOGvAnRIVw,412 +setuptools/_vendor/jaraco/text/to-dvorak.py,sha256=1SNcbSsvISpXXg-LnybIHHY-RUFOQr36zcHkY1pWFqw,119 +setuptools/_vendor/jaraco/text/to-qwerty.py,sha256=s4UMQUnPwFn_dB5uZC27BurHOQcYondBfzIpVL5pEzw,119 +setuptools/_vendor/more_itertools-10.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/more_itertools-10.3.0.dist-info/LICENSE,sha256=CfHIyelBrz5YTVlkHqm4fYPAyw_QB-te85Gn4mQ8GkY,1053 +setuptools/_vendor/more_itertools-10.3.0.dist-info/METADATA,sha256=BFO90O-fLNiVQMpj7oIS5ztzgJUUQZ3TA32P5HH3N-A,36293 +setuptools/_vendor/more_itertools-10.3.0.dist-info/RECORD,sha256=d8jnPgGNwP1-ntbICwWkQEVF9kH7CFIgzkKzaLWao9M,1259 +setuptools/_vendor/more_itertools-10.3.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/more_itertools-10.3.0.dist-info/WHEEL,sha256=rSgq_JpHF9fHR1lx53qwg_1-2LypZE_qmcuXbVUq948,81 +setuptools/_vendor/more_itertools/__init__.py,sha256=dtAbGjTDmn_ghiU5YXfhyDy0phAlXVdt5klZA5fUa-Q,149 +setuptools/_vendor/more_itertools/__init__.pyi,sha256=5B3eTzON1BBuOLob1vCflyEb2lSd6usXQQ-Cv-hXkeA,43 +setuptools/_vendor/more_itertools/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/more_itertools/__pycache__/more.cpython-312.pyc,, +setuptools/_vendor/more_itertools/__pycache__/recipes.cpython-312.pyc,, +setuptools/_vendor/more_itertools/more.py,sha256=1E5kzFncRKTDw0cYv1yRXMgDdunstLQd1QStcnL6U90,148370 +setuptools/_vendor/more_itertools/more.pyi,sha256=iXXeqt48Nxe8VGmIWpkVXuKpR2FYNuu2DU8nQLWCCu0,21484 +setuptools/_vendor/more_itertools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/more_itertools/recipes.py,sha256=WedhhfhGVgr6zii8fIbGJVmRTw0ZKRiLKnYBDGJv4nY,28591 +setuptools/_vendor/more_itertools/recipes.pyi,sha256=T_mdGpcFdfrP3JSWbwzYP9JyNV-Go-7RPfpxfftAWlA,4617 +setuptools/_vendor/packaging-24.2.dist-info/INSTALLER,sha256=5hhM4Q4mYTT9z6QB6PGpUAW81PGNFrYrdXMj4oM_6ak,2 +setuptools/_vendor/packaging-24.2.dist-info/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197 +setuptools/_vendor/packaging-24.2.dist-info/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174 +setuptools/_vendor/packaging-24.2.dist-info/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344 +setuptools/_vendor/packaging-24.2.dist-info/METADATA,sha256=ohH86s6k5mIfQxY2TS0LcSfADeOFa4BiCC-bxZV-pNs,3204 +setuptools/_vendor/packaging-24.2.dist-info/RECORD,sha256=Y4DrXM0KY0ArfzhbAEa1LYFPwW3WEgEeL4iCqXe-A-M,2009 +setuptools/_vendor/packaging-24.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/packaging-24.2.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82 +setuptools/_vendor/packaging/__init__.py,sha256=dk4Ta_vmdVJxYHDcfyhvQNw8V3PgSBomKNXqg-D2JDY,494 +setuptools/_vendor/packaging/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_elffile.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_manylinux.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_musllinux.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_parser.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_structures.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/_tokenizer.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/markers.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/metadata.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/requirements.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/specifiers.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/tags.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/utils.cpython-312.pyc,, +setuptools/_vendor/packaging/__pycache__/version.cpython-312.pyc,, +setuptools/_vendor/packaging/_elffile.py,sha256=cflAQAkE25tzhYmq_aCi72QfbT_tn891tPzfpbeHOwE,3306 +setuptools/_vendor/packaging/_manylinux.py,sha256=vl5OCoz4kx80H5rwXKeXWjl9WNISGmr4ZgTpTP9lU9c,9612 +setuptools/_vendor/packaging/_musllinux.py,sha256=p9ZqNYiOItGee8KcZFeHF_YcdhVwGHdK6r-8lgixvGQ,2694 +setuptools/_vendor/packaging/_parser.py,sha256=s_TvTvDNK0NrM2QB3VKThdWFM4Nc0P6JnkObkl3MjpM,10236 +setuptools/_vendor/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431 +setuptools/_vendor/packaging/_tokenizer.py,sha256=J6v5H7Jzvb-g81xp_2QACKwO7LxHQA6ikryMU7zXwN8,5273 +setuptools/_vendor/packaging/licenses/__init__.py,sha256=1x5M1nEYjcgwEbLt0dXwz2ukjr18DiCzC0sraQqJ-Ww,5715 +setuptools/_vendor/packaging/licenses/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/packaging/licenses/__pycache__/_spdx.cpython-312.pyc,, +setuptools/_vendor/packaging/licenses/_spdx.py,sha256=oAm1ztPFwlsmCKe7lAAsv_OIOfS1cWDu9bNBkeu-2ns,48398 +setuptools/_vendor/packaging/markers.py,sha256=c89TNzB7ZdGYhkovm6PYmqGyHxXlYVaLW591PHUNKD8,10561 +setuptools/_vendor/packaging/metadata.py,sha256=YJibM7GYe4re8-0a3OlXmGS-XDgTEoO4tlBt2q25Bng,34762 +setuptools/_vendor/packaging/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/packaging/requirements.py,sha256=gYyRSAdbrIyKDY66ugIDUQjRMvxkH2ALioTmX3tnL6o,2947 +setuptools/_vendor/packaging/specifiers.py,sha256=GG1wPNMcL0fMJO68vF53wKMdwnfehDcaI-r9NpTfilA,40074 +setuptools/_vendor/packaging/tags.py,sha256=CFqrJzAzc2XNGexerH__T-Y5Iwq7WbsYXsiLERLWxY0,21014 +setuptools/_vendor/packaging/utils.py,sha256=0F3Hh9OFuRgrhTgGZUl5K22Fv1YP2tZl1z_2gO6kJiA,5050 +setuptools/_vendor/packaging/version.py,sha256=olfyuk_DPbflNkJ4wBWetXQ17c74x3DB501degUv7DY,16676 +setuptools/_vendor/platformdirs-4.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/platformdirs-4.2.2.dist-info/METADATA,sha256=zmsie01G1MtXR0wgIv5XpVeTO7idr0WWvfmxKsKWuGk,11429 +setuptools/_vendor/platformdirs-4.2.2.dist-info/RECORD,sha256=TCEddtQu1A78Os_Mhm2JEqcYr7yit-UYSUQjZtbpn-g,1642 +setuptools/_vendor/platformdirs-4.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/platformdirs-4.2.2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87 +setuptools/_vendor/platformdirs-4.2.2.dist-info/licenses/LICENSE,sha256=KeD9YukphQ6G6yjD_czwzv30-pSHkBHP-z0NS-1tTbY,1089 +setuptools/_vendor/platformdirs/__init__.py,sha256=EMGE8qeHRR9CzDFr8kL3tA8hdZZniYjXBVZd0UGTWK0,22225 +setuptools/_vendor/platformdirs/__main__.py,sha256=HnsUQHpiBaiTxwcmwVw-nFaPdVNZtQIdi1eWDtI-MzI,1493 +setuptools/_vendor/platformdirs/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/__main__.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/android.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/api.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/macos.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/unix.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/version.cpython-312.pyc,, +setuptools/_vendor/platformdirs/__pycache__/windows.cpython-312.pyc,, +setuptools/_vendor/platformdirs/android.py,sha256=xZXY9Jd46WOsxT2U6-5HsNtDZ-IQqxcEUrBLl3hYk4o,9016 +setuptools/_vendor/platformdirs/api.py,sha256=QBYdUac2eC521ek_y53uD1Dcq-lJX8IgSRVd4InC6uc,8996 +setuptools/_vendor/platformdirs/macos.py,sha256=wftsbsvq6nZ0WORXSiCrZNkRHz_WKuktl0a6mC7MFkI,5580 +setuptools/_vendor/platformdirs/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/platformdirs/unix.py,sha256=Cci9Wqt35dAMsg6HT9nRGHSBW5obb0pR3AE1JJnsCXg,10643 +setuptools/_vendor/platformdirs/version.py,sha256=r7F76tZRjgQKzrpx_I0_ZMQOMU-PS7eGnHD7zEK3KB0,411 +setuptools/_vendor/platformdirs/windows.py,sha256=IFpiohUBwxPtCzlyKwNtxyW4Jk8haa6W8o59mfrDXVo,10125 +setuptools/_vendor/tomli-2.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/tomli-2.0.1.dist-info/LICENSE,sha256=uAgWsNUwuKzLTCIReDeQmEpuO2GSLCte6S8zcqsnQv4,1072 +setuptools/_vendor/tomli-2.0.1.dist-info/METADATA,sha256=zPDceKmPwJGLWtZykrHixL7WVXWmJGzZ1jyRT5lCoPI,8875 +setuptools/_vendor/tomli-2.0.1.dist-info/RECORD,sha256=DLn5pFGh42WsVLTIhmLh2gy1SnLRalJY-wq_-dPhwCI,999 +setuptools/_vendor/tomli-2.0.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/tomli-2.0.1.dist-info/WHEEL,sha256=jPMR_Dzkc4X4icQtmz81lnNY_kAsfog7ry7qoRvYLXw,81 +setuptools/_vendor/tomli/__init__.py,sha256=JhUwV66DB1g4Hvt1UQCVMdfCu-IgAV8FXmvDU9onxd4,396 +setuptools/_vendor/tomli/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/tomli/__pycache__/_parser.cpython-312.pyc,, +setuptools/_vendor/tomli/__pycache__/_re.cpython-312.pyc,, +setuptools/_vendor/tomli/__pycache__/_types.cpython-312.pyc,, +setuptools/_vendor/tomli/_parser.py,sha256=g9-ENaALS-B8dokYpCuzUFalWlog7T-SIYMjLZSWrtM,22633 +setuptools/_vendor/tomli/_re.py,sha256=dbjg5ChZT23Ka9z9DHOXfdtSpPwUfdgMXnj8NOoly-w,2943 +setuptools/_vendor/tomli/_types.py,sha256=-GTG2VUqkpxwMqzmVO4F7ybKddIbAnuAHXfmWQcTi3Q,254 +setuptools/_vendor/tomli/py.typed,sha256=8PjyZ1aVoQpRVvt71muvuq5qE-jTFZkK-GLHkhdebmc,26 +setuptools/_vendor/typeguard-4.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/typeguard-4.3.0.dist-info/LICENSE,sha256=YWP3mH37ONa8MgzitwsvArhivEESZRbVUu8c1DJH51g,1130 +setuptools/_vendor/typeguard-4.3.0.dist-info/METADATA,sha256=z2dcHAp0TwhYCFU5Deh8x31nazElgujUz9tbuP0pjSE,3717 +setuptools/_vendor/typeguard-4.3.0.dist-info/RECORD,sha256=SKUZWVgkeDUidUKM7s1473fXmsna55bjmi6vJUAoJVI,2402 +setuptools/_vendor/typeguard-4.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/typeguard-4.3.0.dist-info/entry_points.txt,sha256=qp7NQ1aLtiSgMQqo6gWlfGpy0IIXzoMJmeQTLpzqFZQ,48 +setuptools/_vendor/typeguard-4.3.0.dist-info/top_level.txt,sha256=4z28AhuDodwRS_c1J_l8H51t5QuwfTseskYzlxp6grs,10 +setuptools/_vendor/typeguard/__init__.py,sha256=Onh4w38elPCjtlcU3JY9k3h70NjsxXIkAflmQn-Z0FY,2071 +setuptools/_vendor/typeguard/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_checkers.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_config.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_decorators.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_exceptions.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_functions.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_importhook.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_memo.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_pytest_plugin.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_suppression.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_transformer.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_union_transformer.cpython-312.pyc,, +setuptools/_vendor/typeguard/__pycache__/_utils.cpython-312.pyc,, +setuptools/_vendor/typeguard/_checkers.py,sha256=JRrgKicdOEfIBoNEtegYCEIlhpad-a1u1Em7GCj0WCI,31360 +setuptools/_vendor/typeguard/_config.py,sha256=nIz8QwDa-oFO3L9O8_6srzlmd99pSby2wOM4Wb7F_B0,2846 +setuptools/_vendor/typeguard/_decorators.py,sha256=v6dsIeWvPhExGLP_wXF-RmDUyjZf_Ak28g7gBJ_v0-0,9033 +setuptools/_vendor/typeguard/_exceptions.py,sha256=ZIPeiV-FBd5Emw2EaWd2Fvlsrwi4ocwT2fVGBIAtHcQ,1121 +setuptools/_vendor/typeguard/_functions.py,sha256=ibgSAKa5ptIm1eR9ARG0BSozAFJPFNASZqhPVyQeqig,10393 +setuptools/_vendor/typeguard/_importhook.py,sha256=ugjCDvFcdWMU7UugqlJG91IpVNpEIxtRr-99s0h1k7M,6389 +setuptools/_vendor/typeguard/_memo.py,sha256=1juQV_vxnD2JYKbSrebiQuj4oKHz6n67v9pYA-CCISg,1303 +setuptools/_vendor/typeguard/_pytest_plugin.py,sha256=-fcSqkv54rIfIF8pDavY5YQPkj4OX8GMt_lL7CQSD4I,4416 +setuptools/_vendor/typeguard/_suppression.py,sha256=VQfzxcwIbu3if0f7VBkKM7hkYOA7tNFw9a7jMBsmMg4,2266 +setuptools/_vendor/typeguard/_transformer.py,sha256=9Ha7_QhdwoUni_6hvdY-hZbuEergowHrNL2vzHIakFY,44937 +setuptools/_vendor/typeguard/_union_transformer.py,sha256=v_42r7-6HuRX2SoFwnyJ-E5PlxXpVeUJPJR1-HU9qSo,1354 +setuptools/_vendor/typeguard/_utils.py,sha256=5HhO1rPn5f1M6ymkVAEv7Xmlz1cX-j0OnTMlyHqqrR8,5270 +setuptools/_vendor/typeguard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/typing_extensions-4.12.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/typing_extensions-4.12.2.dist-info/LICENSE,sha256=Oy-B_iHRgcSZxZolbI4ZaEVdZonSaaqFNzv7avQdo78,13936 +setuptools/_vendor/typing_extensions-4.12.2.dist-info/METADATA,sha256=BeUQIa8cnYbrjWx-N8TOznM9UGW5Gm2DicVpDtRA8W0,3018 +setuptools/_vendor/typing_extensions-4.12.2.dist-info/RECORD,sha256=dxAALYGXHmMqpqL8M9xddKr118quIgQKZdPjFQOwXuk,571 +setuptools/_vendor/typing_extensions-4.12.2.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81 +setuptools/_vendor/typing_extensions.py,sha256=gwekpyG9DVG3lxWKX4ni8u7nk3We5slG98mA9F3DJQw,134451 +setuptools/_vendor/wheel-0.45.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/wheel-0.45.1.dist-info/LICENSE.txt,sha256=MMI2GGeRCPPo6h0qZYx8pBe9_IkcmO8aifpP8MmChlQ,1107 +setuptools/_vendor/wheel-0.45.1.dist-info/METADATA,sha256=mKz84H7m7jsxJyzeIcTVORiTb0NPMV39KvOIYhGgmjA,2313 +setuptools/_vendor/wheel-0.45.1.dist-info/RECORD,sha256=1jnxrHyZPDcVvULyfGFhiba4Z5L9_RsXr9dxcNbhaYQ,4900 +setuptools/_vendor/wheel-0.45.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/wheel-0.45.1.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82 +setuptools/_vendor/wheel-0.45.1.dist-info/entry_points.txt,sha256=rTY1BbkPHhkGMm4Q3F0pIzJBzW2kMxoG1oriffvGdA0,104 +setuptools/_vendor/wheel/__init__.py,sha256=mrxMnvdXACur_LWegbUfh5g5ysWZrd63UJn890wvGNk,59 +setuptools/_vendor/wheel/__main__.py,sha256=NkMUnuTCGcOkgY0IBLgBCVC_BGGcWORx2K8jYGS12UE,455 +setuptools/_vendor/wheel/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/__main__.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/_bdist_wheel.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/_setuptools_logging.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/bdist_wheel.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/macosx_libfile.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/metadata.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/util.cpython-312.pyc,, +setuptools/_vendor/wheel/__pycache__/wheelfile.cpython-312.pyc,, +setuptools/_vendor/wheel/_bdist_wheel.py,sha256=UghCQjSH_pVfcZh6oRjzSw_TQhcf3anSx1OkiLSL82M,21694 +setuptools/_vendor/wheel/_setuptools_logging.py,sha256=-5KC-lne0ilOUWIDfOkqapUWGMFZhuKYDIavIZiB5kM,781 +setuptools/_vendor/wheel/bdist_wheel.py,sha256=tpf9WufiSO1RuEMg5oPhIfSG8DMziCZ_4muCKF69Cqo,1107 +setuptools/_vendor/wheel/cli/__init__.py,sha256=Npq6_jKi03dhIcRnmbuFhwviVJxwO0tYEnEhWMv9cJo,4402 +setuptools/_vendor/wheel/cli/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/wheel/cli/__pycache__/convert.cpython-312.pyc,, +setuptools/_vendor/wheel/cli/__pycache__/pack.cpython-312.pyc,, +setuptools/_vendor/wheel/cli/__pycache__/tags.cpython-312.pyc,, +setuptools/_vendor/wheel/cli/__pycache__/unpack.cpython-312.pyc,, +setuptools/_vendor/wheel/cli/convert.py,sha256=Bi0ntEXb9nTllCxWeTRQ4j-nPs3szWSEKipG_GgnMkQ,12634 +setuptools/_vendor/wheel/cli/pack.py,sha256=CAFcHdBVulvsHYJlndKVO7KMI9JqBTZz5ii0PKxxCOs,3103 +setuptools/_vendor/wheel/cli/tags.py,sha256=lHw-LaWrkS5Jy_qWcw-6pSjeNM6yAjDnqKI3E5JTTCU,4760 +setuptools/_vendor/wheel/cli/unpack.py,sha256=Y_J7ynxPSoFFTT7H0fMgbBlVErwyDGcObgme5MBuz58,1021 +setuptools/_vendor/wheel/macosx_libfile.py,sha256=k1x7CE3LPtOVGqj6NXQ1nTGYVPaeRrhVzUG_KPq3zDs,16572 +setuptools/_vendor/wheel/metadata.py,sha256=JC4p7jlQZu2bUTAQ2fevkqLjg_X6gnNyRhLn6OUO1tc,6171 +setuptools/_vendor/wheel/util.py,sha256=aL7aibHwYUgfc8WlolL5tXdkV4DatbJxZHb1kwHFJAU,423 +setuptools/_vendor/wheel/vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/wheel/vendored/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/LICENSE,sha256=ytHvW9NA1z4HS6YU0m996spceUDD2MNIUuZcSQlobEg,197 +setuptools/_vendor/wheel/vendored/packaging/LICENSE.APACHE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174 +setuptools/_vendor/wheel/vendored/packaging/LICENSE.BSD,sha256=tw5-m3QvHMb5SLNMFqo5_-zpQZY2S8iP8NIYDwAo-sU,1344 +setuptools/_vendor/wheel/vendored/packaging/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/wheel/vendored/packaging/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_elffile.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_manylinux.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_musllinux.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_parser.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_structures.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/_tokenizer.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/markers.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/requirements.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/specifiers.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/tags.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/utils.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/__pycache__/version.cpython-312.pyc,, +setuptools/_vendor/wheel/vendored/packaging/_elffile.py,sha256=hbmK8OD6Z7fY6hwinHEUcD1by7czkGiNYu7ShnFEk2k,3266 +setuptools/_vendor/wheel/vendored/packaging/_manylinux.py,sha256=P7sdR5_7XBY09LVYYPhHmydMJIIwPXWsh4olk74Uuj4,9588 +setuptools/_vendor/wheel/vendored/packaging/_musllinux.py,sha256=z1s8To2hQ0vpn_d-O2i5qxGwEK8WmGlLt3d_26V7NeY,2674 +setuptools/_vendor/wheel/vendored/packaging/_parser.py,sha256=4tT4emSl2qTaU7VTQE1Xa9o1jMPCsBezsYBxyNMUN-s,10347 +setuptools/_vendor/wheel/vendored/packaging/_structures.py,sha256=q3eVNmbWJGG_S0Dit_S3Ao8qQqz_5PYTXFAKBZe5yr4,1431 +setuptools/_vendor/wheel/vendored/packaging/_tokenizer.py,sha256=alCtbwXhOFAmFGZ6BQ-wCTSFoRAJ2z-ysIf7__MTJ_k,5292 +setuptools/_vendor/wheel/vendored/packaging/markers.py,sha256=_TSPI1BhJYO7Bp9AzTmHQxIqHEVXaTjmDh9G-w8qzPA,8232 +setuptools/_vendor/wheel/vendored/packaging/requirements.py,sha256=dgoBeVprPu2YE6Q8nGfwOPTjATHbRa_ZGLyXhFEln6Q,2933 +setuptools/_vendor/wheel/vendored/packaging/specifiers.py,sha256=IWSt0SrLSP72heWhAC8UL0eGvas7XIQHjqiViVfmPKE,39778 +setuptools/_vendor/wheel/vendored/packaging/tags.py,sha256=fedHXiOHkBxNZTXotXv8uXPmMFU9ae-TKBujgYHigcA,18950 +setuptools/_vendor/wheel/vendored/packaging/utils.py,sha256=XgdmP3yx9-wQEFjO7OvMj9RjEf5JlR5HFFR69v7SQ9E,5268 +setuptools/_vendor/wheel/vendored/packaging/version.py,sha256=PFJaYZDxBgyxkfYhH3SQw4qfE9ICCWrTmitvq14y3bs,16234 +setuptools/_vendor/wheel/vendored/vendor.txt,sha256=Z2ENjB1i5prfez8CdM1Sdr3c6Zxv2rRRolMpLmBncAE,16 +setuptools/_vendor/wheel/wheelfile.py,sha256=USCttNlJwafxt51YYFFKG7jnxz8dfhbyqAZL6jMTA9s,8411 +setuptools/_vendor/zipp-3.19.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +setuptools/_vendor/zipp-3.19.2.dist-info/LICENSE,sha256=htoPAa6uRjSKPD1GUZXcHOzN55956HdppkuNoEsqR0E,1023 +setuptools/_vendor/zipp-3.19.2.dist-info/METADATA,sha256=UIrk_kMIHGSwsKKChYizqMw0MMZpPRZ2ZiVpQAsN_bE,3575 +setuptools/_vendor/zipp-3.19.2.dist-info/RECORD,sha256=8xby4D_ZrefrvAsVRwaEjiu4_VaLkJNRCfDY484rm_4,1039 +setuptools/_vendor/zipp-3.19.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/zipp-3.19.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92 +setuptools/_vendor/zipp-3.19.2.dist-info/top_level.txt,sha256=iAbdoSHfaGqBfVb2XuR9JqSQHCoOsOtG6y9C_LSpqFw,5 +setuptools/_vendor/zipp/__init__.py,sha256=QuI1g00G4fRAcGt-HqbV0oWIkmSgedCGGYsHHYzNa8A,13412 +setuptools/_vendor/zipp/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/zipp/__pycache__/glob.cpython-312.pyc,, +setuptools/_vendor/zipp/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/_vendor/zipp/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/_vendor/zipp/compat/__pycache__/py310.cpython-312.pyc,, +setuptools/_vendor/zipp/compat/py310.py,sha256=eZpkW0zRtunkhEh8jjX3gCGe22emoKCBJw72Zt4RkhA,219 +setuptools/_vendor/zipp/glob.py,sha256=etWpnfEoRyfUvrUsi6sTiGmErvPwe6HzY6pT8jg_lUI,3082 +setuptools/archive_util.py,sha256=Tl_64hSTtc4y8x7xa98rFVUbG24oArpjzLAYGYP2_sI,7356 +setuptools/build_meta.py,sha256=rry-LowqvWFsxG6Qm5QWetHJGeETzRdiQ5-bs4bOkjo,20446 +setuptools/cli-32.exe,sha256=MqzBvFQxFsviz_EMuGd3LfLyVP8mNMhwrvC0bEtpb9s,11776 +setuptools/cli-64.exe,sha256=u7PeVwdinmpgoMI4zUd7KPB_AGaYL9qVP6b87DkHOko,14336 +setuptools/cli-arm64.exe,sha256=uafQjaiA36yLz1SOuksG-1m28JsX0zFIoPZhgyiSbGE,13824 +setuptools/cli.exe,sha256=MqzBvFQxFsviz_EMuGd3LfLyVP8mNMhwrvC0bEtpb9s,11776 +setuptools/command/__init__.py,sha256=wdSrlNR0P6nCz9_oFtCAiAkeFJMsZa1jPcpXT53f0SM,803 +setuptools/command/__pycache__/__init__.cpython-312.pyc,, +setuptools/command/__pycache__/_requirestxt.cpython-312.pyc,, +setuptools/command/__pycache__/alias.cpython-312.pyc,, +setuptools/command/__pycache__/bdist_egg.cpython-312.pyc,, +setuptools/command/__pycache__/bdist_rpm.cpython-312.pyc,, +setuptools/command/__pycache__/bdist_wheel.cpython-312.pyc,, +setuptools/command/__pycache__/build.cpython-312.pyc,, +setuptools/command/__pycache__/build_clib.cpython-312.pyc,, +setuptools/command/__pycache__/build_ext.cpython-312.pyc,, +setuptools/command/__pycache__/build_py.cpython-312.pyc,, +setuptools/command/__pycache__/develop.cpython-312.pyc,, +setuptools/command/__pycache__/dist_info.cpython-312.pyc,, +setuptools/command/__pycache__/easy_install.cpython-312.pyc,, +setuptools/command/__pycache__/editable_wheel.cpython-312.pyc,, +setuptools/command/__pycache__/egg_info.cpython-312.pyc,, +setuptools/command/__pycache__/install.cpython-312.pyc,, +setuptools/command/__pycache__/install_egg_info.cpython-312.pyc,, +setuptools/command/__pycache__/install_lib.cpython-312.pyc,, +setuptools/command/__pycache__/install_scripts.cpython-312.pyc,, +setuptools/command/__pycache__/rotate.cpython-312.pyc,, +setuptools/command/__pycache__/saveopts.cpython-312.pyc,, +setuptools/command/__pycache__/sdist.cpython-312.pyc,, +setuptools/command/__pycache__/setopt.cpython-312.pyc,, +setuptools/command/__pycache__/test.cpython-312.pyc,, +setuptools/command/_requirestxt.py,sha256=ItYMTJGh_i5TlQstX_nFopqEhkC4PJFadBL2Zd3V670,4228 +setuptools/command/alias.py,sha256=rDdrMt32DS6qf3K7tjZZyHD_dMKrm77AXcAtx-nBQ0I,2380 +setuptools/command/bdist_egg.py,sha256=3eDucQ4fdeYMsLO9PhBfY1JkcMLhZXgnAI_9FdFNsEE,16972 +setuptools/command/bdist_rpm.py,sha256=LyqI49w48SKk0FmuHsE9MLzX1SuXjL7YMNbZMFZqFII,1435 +setuptools/command/bdist_wheel.py,sha256=_LfGHB7CV_uyncqlOTSETEi2gjVCoPKuAXcyRFoq7Cs,22246 +setuptools/command/build.py,sha256=eI7STMERGGZEpzk1tvJN8p9IOjAAXMcGLzljv2mwI3M,6052 +setuptools/command/build_clib.py,sha256=AbgpPIF_3qL8fZr3JIebI-WHTMTBiMfrFkVQz8K40G4,4528 +setuptools/command/build_ext.py,sha256=bUH4M0NizaJJrv10wK-ZD3uY0TxCSZlYQDhiwwzHslM,18377 +setuptools/command/build_py.py,sha256=DCbjvB18kkL-xUK5rvlzm0C6twTeOxNhyvJDxxa7fII,15539 +setuptools/command/develop.py,sha256=zX22119sI1G1gfJ1gNCE4hkg2zbLKx0uUwvNmC5bIu8,6886 +setuptools/command/dist_info.py,sha256=HU752iLLmmYMHbsDBgz2ubRjkgJobugOp8H71LzzDys,3450 +setuptools/command/easy_install.py,sha256=0Z4kFlE78Ae2AfHXYTxZFUa2t3qlNqXCtQu4J1Nx8iA,87870 +setuptools/command/editable_wheel.py,sha256=3bBipRZA3E4poQ8LEWhMYEjHjCzqU_pIdO86C3t7oNY,35624 +setuptools/command/egg_info.py,sha256=WWUozR3DZCrWsTQhHXOygMiEUcrjLWphET0-Zsocsm4,25982 +setuptools/command/install.py,sha256=MmTGb8m1R8fJ0cc5FTWCF6uq-s1ZJmvpYm-N_CtqEaI,7046 +setuptools/command/install_egg_info.py,sha256=3I9IPCH7D59Sh-6aVYz-h6wwyxq-wkxrKwKg3nDdJqs,2075 +setuptools/command/install_lib.py,sha256=9n1_U83eHcERL_a_rv_LhHCkhXlLdqyZ4SdBow-9qcE,4319 +setuptools/command/install_scripts.py,sha256=tVOCj3e8OTIrkoL_bGbT5pOksdxZfQblH_bdI4DtVV4,2637 +setuptools/command/launcher manifest.xml,sha256=xlLbjWrB01tKC0-hlVkOKkiSPbzMml2eOPtJ_ucCnbE,628 +setuptools/command/rotate.py,sha256=XNd_BEEOWAJHW1FcLTMUWWl4QB6zAuk7b8VWQg3FHos,2187 +setuptools/command/saveopts.py,sha256=Np0PVb7SD7oTbu9Z9sosS7D-CkkIkU7x4glu5Es1tjA,692 +setuptools/command/sdist.py,sha256=JaQm2-ebXI2kvyrBjJKP8yNLPa5eMbMeis88CXBMYlk,7374 +setuptools/command/setopt.py,sha256=xZF2RCc4ABvE9eHHAzF50-fkQg3au8fcRUVVGd58k3U,5100 +setuptools/command/test.py,sha256=k7xcq7D7bEehgxarbw-dW3AtmGZORqz8HjKR6FGJ3jk,1343 +setuptools/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/compat/__pycache__/py310.cpython-312.pyc,, +setuptools/compat/__pycache__/py311.cpython-312.pyc,, +setuptools/compat/__pycache__/py312.cpython-312.pyc,, +setuptools/compat/__pycache__/py39.cpython-312.pyc,, +setuptools/compat/py310.py,sha256=8sqwWczIcrkzeAbhaim4pKVd4tXZdcqmebgdvzji0rc,141 +setuptools/compat/py311.py,sha256=e6tJAFwZEP82hmMBl10HYeSypelo_Ti2wTjKZVKLwOE,790 +setuptools/compat/py312.py,sha256=vYKVtdrdOTsO_R90dJkEXsFwfMJFuIFJflhIgHrjJ-Y,366 +setuptools/compat/py39.py,sha256=BJMtnkfcqyTfccqjYQxfoRtU2nTnWaEESBVkshTiXqY,493 +setuptools/config/NOTICE,sha256=Ld3wiBgpejuJ1D2V_2WdjahXQRCMkTbfo6TYVsBiO9g,493 +setuptools/config/__init__.py,sha256=aiPnL9BJn1O6MfmuNXyn8W2Lp8u9qizRVqwPiOdPIjY,1499 +setuptools/config/__pycache__/__init__.cpython-312.pyc,, +setuptools/config/__pycache__/_apply_pyprojecttoml.cpython-312.pyc,, +setuptools/config/__pycache__/expand.cpython-312.pyc,, +setuptools/config/__pycache__/pyprojecttoml.cpython-312.pyc,, +setuptools/config/__pycache__/setupcfg.cpython-312.pyc,, +setuptools/config/_apply_pyprojecttoml.py,sha256=SUyTw7A2btZ1lBuWKN5o42-Diyv95eGTiYJ3rZOnGSc,19120 +setuptools/config/_validate_pyproject/NOTICE,sha256=XTANv6ZDE4sBO3WsnK7uWR-VG4sO4kKIw0zNkmxHgMg,18737 +setuptools/config/_validate_pyproject/__init__.py,sha256=dnp6T7ePP1R5z4OuC7Fd2dkFlIrtIfizUfvpGJP6nz0,1042 +setuptools/config/_validate_pyproject/__pycache__/__init__.cpython-312.pyc,, +setuptools/config/_validate_pyproject/__pycache__/error_reporting.cpython-312.pyc,, +setuptools/config/_validate_pyproject/__pycache__/extra_validations.cpython-312.pyc,, +setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_exceptions.cpython-312.pyc,, +setuptools/config/_validate_pyproject/__pycache__/fastjsonschema_validations.cpython-312.pyc,, +setuptools/config/_validate_pyproject/__pycache__/formats.cpython-312.pyc,, +setuptools/config/_validate_pyproject/error_reporting.py,sha256=meldD7nBQdolQhvG-43r1Ue-gU1n7ORAJR86vh3Rrvk,11813 +setuptools/config/_validate_pyproject/extra_validations.py,sha256=-GUG5S--ijY8WfXbdXPoHl6ywGsyEF9dtDpenSoJPHg,2858 +setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py,sha256=w749JgqKi8clBFcObdcbZVqsmF4oJ_QByhZ1SGbUFNw,1612 +setuptools/config/_validate_pyproject/fastjsonschema_validations.py,sha256=FihD5ZcM6p77BPZ04CGqh3BEwVNoPMKJZJAyuJpkAU0,354682 +setuptools/config/_validate_pyproject/formats.py,sha256=TETokJBK9hjl-cVg1olsojkJwLxfP7_chgJQNmzAB98,13564 +setuptools/config/distutils.schema.json,sha256=Tcp32kRnhwORGw_9p6GEi08lj2h15tQRzOYBbzGmcBU,972 +setuptools/config/expand.py,sha256=JNAktRCsyyRB-rQodbPnCucmLWqcYvzCDC8Ebn2Z7xM,16041 +setuptools/config/pyprojecttoml.py,sha256=YMu5PdbJJI5azp6kR_boM1mflf5nqOA-InF4s6LnLgw,18320 +setuptools/config/setupcfg.py,sha256=VZDkwE7DYv45SbadJD8CwKrDtiXvjgllL8PYSvoRCyg,26575 +setuptools/config/setuptools.schema.json,sha256=dZBRuSEnZkatoVlt1kVwG8ocTeRdO7BD0xvOWKH54PY,16071 +setuptools/depends.py,sha256=jKYfjmt_2ZQYVghb8L9bU7LJ6erHJ5ze-K_fKV1BMXk,5965 +setuptools/discovery.py,sha256=-42c3XhwzkfodDKKP50C2YBzr11fncAgmUzBdBRb0-Q,21258 +setuptools/dist.py,sha256=RZz7aj9RxqSYriqgFoZOu-7KIV82cmlaMFx9owZrApQ,44897 +setuptools/errors.py,sha256=gY2x2PIaIgy01yRANRC-zcCwxDCqCScgJoCOZFe0yio,3024 +setuptools/extension.py,sha256=KCnv9p3tgm0ZVqtgE451fyILsm4hCyvOiUtOu787D-4,6683 +setuptools/glob.py,sha256=AC_B33DY8g-CHELxDsJrtwFrpiucSAZsakPFdSOQzhc,6062 +setuptools/gui-32.exe,sha256=hdrh6V13hF8stZvKw9Sv50u-TJGpvMW_SnHNQxBNvnw,11776 +setuptools/gui-64.exe,sha256=NHG2FA6txkEid9u-_j_vjDRaDxpZd2CGuAo2GMOoPjs,14336 +setuptools/gui-arm64.exe,sha256=5pT0dDQFyLWSb_RX22_n8aEt7HwWqcOGR4TT9OB64Jc,13824 +setuptools/gui.exe,sha256=hdrh6V13hF8stZvKw9Sv50u-TJGpvMW_SnHNQxBNvnw,11776 +setuptools/installer.py,sha256=_4Wegx4r3L05sMo3-IlqFp-OuxnWyBqjyMZ7LWQXmh8,5110 +setuptools/launch.py,sha256=IBb5lEv69CyuZ9ewIrmKlXh154kdLmP29LKfTMkximE,820 +setuptools/logging.py,sha256=W16iHJ1HcCXYQ0RxyrEfJ83FT4175tCtoYg-E6uSpVI,1261 +setuptools/modified.py,sha256=ZwbfBfCFP88ltvbv_dJDz-t1LsQjnM-JUpgZnnQZjjM,568 +setuptools/monkey.py,sha256=FwMWl2n1v2bHbeqBy-o9g8yUNaAkYFbszCbXe9d5Za8,3717 +setuptools/msvc.py,sha256=vmM0qL4rIzrtD9pia9ZEwtqZ4LbbrgL0dU0EANVYRm8,41631 +setuptools/namespaces.py,sha256=2GGqYY1BNDEhMtBc1rHTv7klgmNVRdksJeW-L1f--ys,3171 +setuptools/package_index.py,sha256=yHXj4Z_QaUeh8W6rwq08I5LxnyHrSkNf01uXHwdE8K0,39095 +setuptools/sandbox.py,sha256=fMqtcOuipHO6RKPh1YB5o7d985dLKo76Whp3vrIei2E,14906 +setuptools/script (dev).tmpl,sha256=RUzQzCQUaXtwdLtYHWYbIQmOaES5Brqq1FvUA_tu-5I,218 +setuptools/script.tmpl,sha256=WGTt5piezO27c-Dbx6l5Q4T3Ff20A5z7872hv3aAhYY,138 +setuptools/tests/__init__.py,sha256=AnBfls2iJbTDQzmMKeLRt-9lxhaOHUVOZEgXv89Uwvs,335 +setuptools/tests/__pycache__/__init__.cpython-312.pyc,, +setuptools/tests/__pycache__/contexts.cpython-312.pyc,, +setuptools/tests/__pycache__/environment.cpython-312.pyc,, +setuptools/tests/__pycache__/fixtures.cpython-312.pyc,, +setuptools/tests/__pycache__/mod_with_constant.cpython-312.pyc,, +setuptools/tests/__pycache__/namespaces.cpython-312.pyc,, +setuptools/tests/__pycache__/script-with-bom.cpython-312.pyc,, +setuptools/tests/__pycache__/server.cpython-312.pyc,, +setuptools/tests/__pycache__/test_archive_util.cpython-312.pyc,, +setuptools/tests/__pycache__/test_bdist_deprecations.cpython-312.pyc,, +setuptools/tests/__pycache__/test_bdist_egg.cpython-312.pyc,, +setuptools/tests/__pycache__/test_bdist_wheel.cpython-312.pyc,, +setuptools/tests/__pycache__/test_build.cpython-312.pyc,, +setuptools/tests/__pycache__/test_build_clib.cpython-312.pyc,, +setuptools/tests/__pycache__/test_build_ext.cpython-312.pyc,, +setuptools/tests/__pycache__/test_build_meta.cpython-312.pyc,, +setuptools/tests/__pycache__/test_build_py.cpython-312.pyc,, +setuptools/tests/__pycache__/test_config_discovery.cpython-312.pyc,, +setuptools/tests/__pycache__/test_core_metadata.cpython-312.pyc,, +setuptools/tests/__pycache__/test_depends.cpython-312.pyc,, +setuptools/tests/__pycache__/test_develop.cpython-312.pyc,, +setuptools/tests/__pycache__/test_dist.cpython-312.pyc,, +setuptools/tests/__pycache__/test_dist_info.cpython-312.pyc,, +setuptools/tests/__pycache__/test_distutils_adoption.cpython-312.pyc,, +setuptools/tests/__pycache__/test_easy_install.cpython-312.pyc,, +setuptools/tests/__pycache__/test_editable_install.cpython-312.pyc,, +setuptools/tests/__pycache__/test_egg_info.cpython-312.pyc,, +setuptools/tests/__pycache__/test_extern.cpython-312.pyc,, +setuptools/tests/__pycache__/test_find_packages.cpython-312.pyc,, +setuptools/tests/__pycache__/test_find_py_modules.cpython-312.pyc,, +setuptools/tests/__pycache__/test_glob.cpython-312.pyc,, +setuptools/tests/__pycache__/test_install_scripts.cpython-312.pyc,, +setuptools/tests/__pycache__/test_logging.cpython-312.pyc,, +setuptools/tests/__pycache__/test_manifest.cpython-312.pyc,, +setuptools/tests/__pycache__/test_namespaces.cpython-312.pyc,, +setuptools/tests/__pycache__/test_packageindex.cpython-312.pyc,, +setuptools/tests/__pycache__/test_sandbox.cpython-312.pyc,, +setuptools/tests/__pycache__/test_sdist.cpython-312.pyc,, +setuptools/tests/__pycache__/test_setopt.cpython-312.pyc,, +setuptools/tests/__pycache__/test_setuptools.cpython-312.pyc,, +setuptools/tests/__pycache__/test_shutil_wrapper.cpython-312.pyc,, +setuptools/tests/__pycache__/test_unicode_utils.cpython-312.pyc,, +setuptools/tests/__pycache__/test_virtualenv.cpython-312.pyc,, +setuptools/tests/__pycache__/test_warnings.cpython-312.pyc,, +setuptools/tests/__pycache__/test_wheel.cpython-312.pyc,, +setuptools/tests/__pycache__/test_windows_wrappers.cpython-312.pyc,, +setuptools/tests/__pycache__/text.cpython-312.pyc,, +setuptools/tests/__pycache__/textwrap.cpython-312.pyc,, +setuptools/tests/compat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/tests/compat/__pycache__/__init__.cpython-312.pyc,, +setuptools/tests/compat/__pycache__/py39.cpython-312.pyc,, +setuptools/tests/compat/py39.py,sha256=eUy7_F-6KRTOIKl-veshUu6I0EdTSdBZMh0EV0lZ1-g,135 +setuptools/tests/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/tests/config/__pycache__/__init__.cpython-312.pyc,, +setuptools/tests/config/__pycache__/test_apply_pyprojecttoml.cpython-312.pyc,, +setuptools/tests/config/__pycache__/test_expand.cpython-312.pyc,, +setuptools/tests/config/__pycache__/test_pyprojecttoml.cpython-312.pyc,, +setuptools/tests/config/__pycache__/test_pyprojecttoml_dynamic_deps.cpython-312.pyc,, +setuptools/tests/config/__pycache__/test_setupcfg.cpython-312.pyc,, +setuptools/tests/config/downloads/__init__.py,sha256=9ixnDEdyL_arKbUzfuiJftAj9bGxKz8M9alOFZMjx9Y,1827 +setuptools/tests/config/downloads/__pycache__/__init__.cpython-312.pyc,, +setuptools/tests/config/downloads/__pycache__/preload.cpython-312.pyc,, +setuptools/tests/config/downloads/preload.py,sha256=sIGGZpY3cmMpMwiJYYYYHG2ifZJkvJgEotRFtiulV1I,450 +setuptools/tests/config/setupcfg_examples.txt,sha256=cAbVvCbkFZuTUL6xRRzRgqyB0rLvJTfvw3D30glo2OE,1912 +setuptools/tests/config/test_apply_pyprojecttoml.py,sha256=l6nE4d8WLU_eSWRic7VSoqeKv9Bi7CZGHcEuB2ehk2w,28807 +setuptools/tests/config/test_expand.py,sha256=S0oT6JvgA_oujR4YS4RUuf5gmOt1CTQV66RQDzV8xd4,8933 +setuptools/tests/config/test_pyprojecttoml.py,sha256=0LefSljUhA6MqtJ5AVzLhomqZcYiFKdu_1ckDeMT1LY,12406 +setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py,sha256=9W73-yLhZJmvCiO4rTiQoBpZT5wNA90Xbd5n2HCshd4,3271 +setuptools/tests/config/test_setupcfg.py,sha256=ZvN-O-2Dgon1adp6oM6il8JWdgT9y196fRvqESU5ELI,33427 +setuptools/tests/contexts.py,sha256=TAdZKxmmodx1ExMVo01o4QpRjpIpo4X3IWKq_BnjxpU,3480 +setuptools/tests/environment.py,sha256=95_UtTaRiuvwYC9eXKEHbn02kDtZysvZq3UZJmPUj1I,3102 +setuptools/tests/fixtures.py,sha256=-V7iD6BeE2E0Rw6dVvTOCm36JG8ZTTnrXhN0GISlgrg,5197 +setuptools/tests/indexes/test_links_priority/external.html,sha256=eL9euOuE93JKZdqlXxBOlHbKwIuNuIdq7GBRpsaPMcU,92 +setuptools/tests/indexes/test_links_priority/simple/foobar/index.html,sha256=DD-TKr7UU4zAjHHz4VexYDNSAzR27levSh1c-k3ZdLE,174 +setuptools/tests/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +setuptools/tests/integration/__pycache__/__init__.cpython-312.pyc,, +setuptools/tests/integration/__pycache__/helpers.cpython-312.pyc,, +setuptools/tests/integration/__pycache__/test_pip_install_sdist.cpython-312.pyc,, +setuptools/tests/integration/helpers.py,sha256=3PHcS9SCA-fwVJmUP2ad5NQOttJAETI5Nnoc_xroO5k,2522 +setuptools/tests/integration/test_pip_install_sdist.py,sha256=SFbvuYF_hDzt6OtsQ5GjFNnxmoJ_eElfvpYsiyyGJ-g,8256 +setuptools/tests/mod_with_constant.py,sha256=X_Kj80M55w1tmQ4f7uZY91ZTALo4hKVT6EHxgYocUMQ,22 +setuptools/tests/namespaces.py,sha256=HPcI3nR5MCFWXpaADIJ1fwKxymcQgBkuw87Ic5PUSAQ,2774 +setuptools/tests/script-with-bom.py,sha256=hRRgIizEULGiG_ZTNoMY46HhKhxpWfy5FGcD6Qbh5fc,18 +setuptools/tests/server.py,sha256=0FDZf0cSInCP5n1haK7AxHo3jD261RK7D3-RjP-F53k,2397 +setuptools/tests/test_archive_util.py,sha256=buuKdY8XkW26Pe3IKAoBRGHG0MDumnuNoPg2WsAQzIg,845 +setuptools/tests/test_bdist_deprecations.py,sha256=75Xq3gYn79LIIyusEltbHan0bEgAt2e_CaL7KLS8-KQ,775 +setuptools/tests/test_bdist_egg.py,sha256=6PaYN1F3JDbIh1uK0urv7yJFcx98z5dn9SOJ8Mv91l8,1957 +setuptools/tests/test_bdist_wheel.py,sha256=dZ9a7OT_UyRvLnoCi2KGEIbtzhEQjM3YutYMA6ZCezs,23083 +setuptools/tests/test_build.py,sha256=wJgMz2hwHADcLFg-nXrwRVhus7hjmAeEGgrpIQwCGnA,798 +setuptools/tests/test_build_clib.py,sha256=bX51XRAf4uO7IuHFpjePnoK8mE74N2gsoeEqF-ofgws,3123 +setuptools/tests/test_build_ext.py,sha256=e4ZSxsYPB5zq1KSqGEuATZ0t0PJQzMhjjkKJ-hIjcgc,10099 +setuptools/tests/test_build_meta.py,sha256=Iakpp9Micvhxi9_F2RPyY2NnCB1G90a38s4O5A3CuiE,34118 +setuptools/tests/test_build_py.py,sha256=gobME_Cvzf6Ugxq70iWfXekb_xyyT61khwjFq8zkwfw,14186 +setuptools/tests/test_config_discovery.py,sha256=FqV-lOtkqaI-ayzU2zocSdD5TaRAgCZnixNDilKA6FQ,22580 +setuptools/tests/test_core_metadata.py,sha256=vbVJ5_Lsx_hsO_GdB6nQEXJRjA2ydx6_qSbr5LpheAA,20881 +setuptools/tests/test_depends.py,sha256=yQBXoQbNQlJit6mbRVoz6Bb553f3sNrq02lZimNz5XY,424 +setuptools/tests/test_develop.py,sha256=CLzXZ8-b5-VFTuau4P4yXEdLx1UdyTFcOfrV0qyUIdE,5142 +setuptools/tests/test_dist.py,sha256=GFjyL2etAxvVM3q7NhFEGcXS5gyKj8VzbqcbKzpqbOk,8901 +setuptools/tests/test_dist_info.py,sha256=5kBRj9tuBsVreBsY22H2feMO_JQZsSoOZMU_MJfUevY,7077 +setuptools/tests/test_distutils_adoption.py,sha256=_eynrOfyEqXFEmjUJhzpe8GXPyTUPvNSObs4qAAmBy8,5987 +setuptools/tests/test_easy_install.py,sha256=jx4lpFyee0G432cdnwBow3AkL4ibw-0QILwldwv5SCI,53534 +setuptools/tests/test_editable_install.py,sha256=7eTEtpT0k7QeVyZg64eh3kZn-SjckuB9LcokOuV37DI,43383 +setuptools/tests/test_egg_info.py,sha256=QCzoUOkFocmbkwS6XU7F8WNzKE8CGEMRxYBqKLgfUrc,44866 +setuptools/tests/test_extern.py,sha256=rpKU6oCcksumLwf5TeKlDluFQ0TUfbPwTLQbpxcFrCU,296 +setuptools/tests/test_find_packages.py,sha256=CTLAcTzWGWBLCcd2aAsUVkvO3ibrlqexFBdDKOWPoq8,7819 +setuptools/tests/test_find_py_modules.py,sha256=zQjuhIG5TQN2SJPix9ARo4DL_w84Ln8QsHDUjjbrtAQ,2404 +setuptools/tests/test_glob.py,sha256=P3JvpH-kXQ4BZ3zvRF-zKxOgwyWzwIaQIz0WHdxS0kk,887 +setuptools/tests/test_install_scripts.py,sha256=scIrJ6a_ssKqg4vIBNaUjmAKHEYLUUZ9WKnPeKnE6gc,3433 +setuptools/tests/test_logging.py,sha256=zlE5DlldukC7Jc54FNvDV_7ux3ErAkrfrN5CSsnNOUQ,2099 +setuptools/tests/test_manifest.py,sha256=eMg65pIA52DizB6mpktSU-b8CjwaNCS5MSgL_V1LrFI,18562 +setuptools/tests/test_namespaces.py,sha256=Y6utoe5PHHqL_DlgawqB9F8XpsUDPvvw1sQMenK04e0,4515 +setuptools/tests/test_packageindex.py,sha256=qEjLHpSu2gAkegwEstzHQT-Om1uQIYjA8zeNzEX79uo,8775 +setuptools/tests/test_sandbox.py,sha256=shUWE7fLTWe7Jzdfi6NheBWauG3oUukbUV46cArD0u0,4330 +setuptools/tests/test_sdist.py,sha256=RYLvPa_nfyC1ZmoinzqMzJynTDG4RtPYC19_0LU6pvs,32872 +setuptools/tests/test_setopt.py,sha256=3VxxM4ATfP-P4AGnDjoWCnHr5-i9CSEQTFYU1-FTnvI,1365 +setuptools/tests/test_setuptools.py,sha256=_eIhqKf45-OtHqxRf20KndOZJlJdS0PuFLXBO3M-LN8,9008 +setuptools/tests/test_shutil_wrapper.py,sha256=g15E11PtZxG-InB2BWNFyH-svObXx2XcMhgMLJPuFnc,641 +setuptools/tests/test_unicode_utils.py,sha256=xWfEEl8jkQCt9othUTXJfFmdyATAFggJs2tTxjbumbw,316 +setuptools/tests/test_virtualenv.py,sha256=g-njC_9JTAs1YVx_1dGJ_Q6RlInO4qKVu9-XAgNb6TY,3730 +setuptools/tests/test_warnings.py,sha256=zwR2zcnCeCeDqILZlJOPAcuyPHoDvGu1OtOVYiLMk74,3347 +setuptools/tests/test_wheel.py,sha256=J-83W1KdXTgAjFZE3H-ytohhvDE1iqdbE5YF5jLQlGQ,19370 +setuptools/tests/test_windows_wrappers.py,sha256=aF6UTowN3yzCgdBh9nDQVvYIfSYogrTK776TEyXEBqg,7881 +setuptools/tests/text.py,sha256=a12197pMVTvB6FAWQ0ujT8fIQiLIWJlFAl1UCaDUDfg,123 +setuptools/tests/textwrap.py,sha256=FNNNq_MiaEJx88PnsbJQIRxmj1qmgcAOCXXRsODPJN4,98 +setuptools/unicode_utils.py,sha256=ukMGh8pEAw6F_Ezb-K5D3c-078RgA_GcF0oW6lg4lSs,3189 +setuptools/version.py,sha256=WJCeUuyq74Aok2TeK9-OexZOu8XrlQy7-y0BEuWNovQ,161 +setuptools/warnings.py,sha256=oY0Se5eOqje_FEyjTgonUc0XGwgsrI5cgm1kkwulz_w,3796 +setuptools/wheel.py,sha256=xkAtvgm7uPTyYV2zqVmQ0wA8kLwOyRT2Jes1zAy07Ks,8624 +setuptools/windows_support.py,sha256=wW4IYLM1Bv7Z1MaauP2xmPjyy-wkmQnXdyvXscAf9fw,726 diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..1eb3c49d99559863120cfb8433fc8738fba43ba9 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: setuptools (78.1.0) +Root-Is-Purelib: true +Tag: py3-none-any + diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/entry_points.txt b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..0db0a6c8f1b8d9c0ad4a25db6892e29f8988fcf2 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/entry_points.txt @@ -0,0 +1,51 @@ +[distutils.commands] +alias = setuptools.command.alias:alias +bdist_egg = setuptools.command.bdist_egg:bdist_egg +bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm +bdist_wheel = setuptools.command.bdist_wheel:bdist_wheel +build = setuptools.command.build:build +build_clib = setuptools.command.build_clib:build_clib +build_ext = setuptools.command.build_ext:build_ext +build_py = setuptools.command.build_py:build_py +develop = setuptools.command.develop:develop +dist_info = setuptools.command.dist_info:dist_info +easy_install = setuptools.command.easy_install:easy_install +editable_wheel = setuptools.command.editable_wheel:editable_wheel +egg_info = setuptools.command.egg_info:egg_info +install = setuptools.command.install:install +install_egg_info = setuptools.command.install_egg_info:install_egg_info +install_lib = setuptools.command.install_lib:install_lib +install_scripts = setuptools.command.install_scripts:install_scripts +rotate = setuptools.command.rotate:rotate +saveopts = setuptools.command.saveopts:saveopts +sdist = setuptools.command.sdist:sdist +setopt = setuptools.command.setopt:setopt + +[distutils.setup_keywords] +dependency_links = setuptools.dist:assert_string_list +eager_resources = setuptools.dist:assert_string_list +entry_points = setuptools.dist:check_entry_points +exclude_package_data = setuptools.dist:check_package_data +extras_require = setuptools.dist:check_extras +include_package_data = setuptools.dist:assert_bool +install_requires = setuptools.dist:check_requirements +namespace_packages = setuptools.dist:check_nsp +package_data = setuptools.dist:check_package_data +packages = setuptools.dist:check_packages +python_requires = setuptools.dist:check_specifier +setup_requires = setuptools.dist:check_requirements +use_2to3 = setuptools.dist:invalid_unless_false +zip_safe = setuptools.dist:assert_bool + +[egg_info.writers] +PKG-INFO = setuptools.command.egg_info:write_pkg_info +dependency_links.txt = setuptools.command.egg_info:overwrite_arg +eager_resources.txt = setuptools.command.egg_info:overwrite_arg +entry_points.txt = setuptools.command.egg_info:write_entries +namespace_packages.txt = setuptools.command.egg_info:overwrite_arg +requires.txt = setuptools.command.egg_info:write_requirements +top_level.txt = setuptools.command.egg_info:write_toplevel_names + +[setuptools.finalize_distribution_options] +keywords = setuptools.dist:Distribution._finalize_setup_keywords +parent_finalize = setuptools.dist:_Distribution.finalize_options diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/licenses/LICENSE b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/licenses/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1bb5a44356f00884a71ceeefd24ded6caaba2418 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/licenses/LICENSE @@ -0,0 +1,17 @@ +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. diff --git a/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..b5ac1070294b478b7cc2ce677207ee08813bfa37 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools-78.1.0.dist-info/top_level.txt @@ -0,0 +1,3 @@ +_distutils_hack +pkg_resources +setuptools diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..0d925111fa6e611ae919df8bb30bcda0f248c5b6 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_core_metadata.py @@ -0,0 +1,622 @@ +from __future__ import annotations + +import functools +import importlib +import io +from email import message_from_string +from email.generator import Generator +from email.message import EmailMessage, Message +from email.parser import Parser +from email.policy import EmailPolicy +from inspect import cleandoc +from pathlib import Path +from unittest.mock import Mock + +import jaraco.path +import pytest +from packaging.metadata import Metadata +from packaging.requirements import Requirement + +from setuptools import _reqs, sic +from setuptools._core_metadata import rfc822_escape, rfc822_unescape +from setuptools.command.egg_info import egg_info, write_requirements +from setuptools.config import expand, setupcfg +from setuptools.dist import Distribution + +from .config.downloads import retrieve_file, urls_from_file + +EXAMPLE_BASE_INFO = dict( + name="package", + version="0.0.1", + author="Foo Bar", + author_email="foo@bar.net", + long_description="Long\ndescription", + description="Short description", + keywords=["one", "two"], +) + + +@pytest.mark.parametrize( + ("content", "result"), + ( + pytest.param( + "Just a single line", + None, + id="single_line", + ), + pytest.param( + "Multiline\nText\nwithout\nextra indents\n", + None, + id="multiline", + ), + pytest.param( + "Multiline\n With\n\nadditional\n indentation", + None, + id="multiline_with_indentation", + ), + pytest.param( + " Leading whitespace", + "Leading whitespace", + id="remove_leading_whitespace", + ), + pytest.param( + " Leading whitespace\nIn\n Multiline comment", + "Leading whitespace\nIn\n Multiline comment", + id="remove_leading_whitespace_multiline", + ), + ), +) +def test_rfc822_unescape(content, result): + assert (result or content) == rfc822_unescape(rfc822_escape(content)) + + +def __read_test_cases(): + base = EXAMPLE_BASE_INFO + + params = functools.partial(dict, base) + + return [ + ('Metadata version 1.0', params()), + ( + 'Metadata Version 1.0: Short long description', + params( + long_description='Short long description', + ), + ), + ( + 'Metadata version 1.1: Classifiers', + params( + classifiers=[ + 'Programming Language :: Python :: 3', + 'Programming Language :: Python :: 3.7', + 'License :: OSI Approved :: MIT License', + ], + ), + ), + ( + 'Metadata version 1.1: Download URL', + params( + download_url='https://example.com', + ), + ), + ( + 'Metadata Version 1.2: Requires-Python', + params( + python_requires='>=3.7', + ), + ), + pytest.param( + 'Metadata Version 1.2: Project-Url', + params(project_urls=dict(Foo='https://example.bar')), + marks=pytest.mark.xfail( + reason="Issue #1578: project_urls not read", + ), + ), + ( + 'Metadata Version 2.1: Long Description Content Type', + params( + long_description_content_type='text/x-rst; charset=UTF-8', + ), + ), + ( + 'License', + params( + license='MIT', + ), + ), + ( + 'License multiline', + params( + license='This is a long license \nover multiple lines', + ), + ), + pytest.param( + 'Metadata Version 2.1: Provides Extra', + params(provides_extras=['foo', 'bar']), + marks=pytest.mark.xfail(reason="provides_extras not read"), + ), + ( + 'Missing author', + dict( + name='foo', + version='1.0.0', + author_email='snorri@sturluson.name', + ), + ), + ( + 'Missing author e-mail', + dict( + name='foo', + version='1.0.0', + author='Snorri Sturluson', + ), + ), + ( + 'Missing author and e-mail', + dict( + name='foo', + version='1.0.0', + ), + ), + ( + 'Bypass normalized version', + dict( + name='foo', + version=sic('1.0.0a'), + ), + ), + ] + + +@pytest.mark.parametrize(("name", "attrs"), __read_test_cases()) +def test_read_metadata(name, attrs): + dist = Distribution(attrs) + metadata_out = dist.metadata + dist_class = metadata_out.__class__ + + # Write to PKG_INFO and then load into a new metadata object + PKG_INFO = io.StringIO() + + metadata_out.write_pkg_file(PKG_INFO) + PKG_INFO.seek(0) + pkg_info = PKG_INFO.read() + assert _valid_metadata(pkg_info) + + PKG_INFO.seek(0) + metadata_in = dist_class() + metadata_in.read_pkg_file(PKG_INFO) + + tested_attrs = [ + ('name', dist_class.get_name), + ('version', dist_class.get_version), + ('author', dist_class.get_contact), + ('author_email', dist_class.get_contact_email), + ('metadata_version', dist_class.get_metadata_version), + ('provides', dist_class.get_provides), + ('description', dist_class.get_description), + ('long_description', dist_class.get_long_description), + ('download_url', dist_class.get_download_url), + ('keywords', dist_class.get_keywords), + ('platforms', dist_class.get_platforms), + ('obsoletes', dist_class.get_obsoletes), + ('requires', dist_class.get_requires), + ('classifiers', dist_class.get_classifiers), + ('project_urls', lambda s: getattr(s, 'project_urls', {})), + ('provides_extras', lambda s: getattr(s, 'provides_extras', {})), + ] + + for attr, getter in tested_attrs: + assert getter(metadata_in) == getter(metadata_out) + + +def __maintainer_test_cases(): + attrs = {"name": "package", "version": "1.0", "description": "xxx"} + + def merge_dicts(d1, d2): + d1 = d1.copy() + d1.update(d2) + + return d1 + + return [ + ('No author, no maintainer', attrs.copy()), + ( + 'Author (no e-mail), no maintainer', + merge_dicts(attrs, {'author': 'Author Name'}), + ), + ( + 'Author (e-mail), no maintainer', + merge_dicts( + attrs, {'author': 'Author Name', 'author_email': 'author@name.com'} + ), + ), + ( + 'No author, maintainer (no e-mail)', + merge_dicts(attrs, {'maintainer': 'Maintainer Name'}), + ), + ( + 'No author, maintainer (e-mail)', + merge_dicts( + attrs, + { + 'maintainer': 'Maintainer Name', + 'maintainer_email': 'maintainer@name.com', + }, + ), + ), + ( + 'Author (no e-mail), Maintainer (no-email)', + merge_dicts( + attrs, {'author': 'Author Name', 'maintainer': 'Maintainer Name'} + ), + ), + ( + 'Author (e-mail), Maintainer (e-mail)', + merge_dicts( + attrs, + { + 'author': 'Author Name', + 'author_email': 'author@name.com', + 'maintainer': 'Maintainer Name', + 'maintainer_email': 'maintainer@name.com', + }, + ), + ), + ( + 'No author (e-mail), no maintainer (e-mail)', + merge_dicts( + attrs, + { + 'author_email': 'author@name.com', + 'maintainer_email': 'maintainer@name.com', + }, + ), + ), + ('Author unicode', merge_dicts(attrs, {'author': '鉄沢寛'})), + ('Maintainer unicode', merge_dicts(attrs, {'maintainer': 'Jan Łukasiewicz'})), + ] + + +@pytest.mark.parametrize(("name", "attrs"), __maintainer_test_cases()) +def test_maintainer_author(name, attrs, tmpdir): + tested_keys = { + 'author': 'Author', + 'author_email': 'Author-email', + 'maintainer': 'Maintainer', + 'maintainer_email': 'Maintainer-email', + } + + # Generate a PKG-INFO file + dist = Distribution(attrs) + fn = tmpdir.mkdir('pkg_info') + fn_s = str(fn) + + dist.metadata.write_pkg_info(fn_s) + + with open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f: + pkg_info = f.read() + + assert _valid_metadata(pkg_info) + + # Drop blank lines and strip lines from default description + raw_pkg_lines = pkg_info.splitlines() + pkg_lines = list(filter(None, raw_pkg_lines[:-2])) + + pkg_lines_set = set(pkg_lines) + + # Duplicate lines should not be generated + assert len(pkg_lines) == len(pkg_lines_set) + + for fkey, dkey in tested_keys.items(): + val = attrs.get(dkey, None) + if val is None: + for line in pkg_lines: + assert not line.startswith(fkey + ':') + else: + line = f'{fkey}: {val}' + assert line in pkg_lines_set + + +class TestParityWithMetadataFromPyPaWheel: + def base_example(self): + attrs = dict( + **EXAMPLE_BASE_INFO, + # Example with complex requirement definition + python_requires=">=3.8", + install_requires=""" + packaging==23.2 + more-itertools==8.8.0; extra == "other" + jaraco.text==3.7.0 + importlib-resources==5.10.2; python_version<"3.8" + importlib-metadata==6.0.0 ; python_version<"3.8" + colorama>=0.4.4; sys_platform == "win32" + """, + extras_require={ + "testing": """ + pytest >= 6 + pytest-checkdocs >= 2.4 + tomli ; \\ + # Using stdlib when possible + python_version < "3.11" + ini2toml[lite]>=0.9 + """, + "other": [], + }, + ) + # Generate a PKG-INFO file using setuptools + return Distribution(attrs) + + def test_requires_dist(self, tmp_path): + dist = self.base_example() + pkg_info = _get_pkginfo(dist) + assert _valid_metadata(pkg_info) + + # Ensure Requires-Dist is present + expected = [ + 'Metadata-Version:', + 'Requires-Python: >=3.8', + 'Provides-Extra: other', + 'Provides-Extra: testing', + 'Requires-Dist: tomli; python_version < "3.11" and extra == "testing"', + 'Requires-Dist: more-itertools==8.8.0; extra == "other"', + 'Requires-Dist: ini2toml[lite]>=0.9; extra == "testing"', + ] + for line in expected: + assert line in pkg_info + + HERE = Path(__file__).parent + EXAMPLES_FILE = HERE / "config/setupcfg_examples.txt" + + @pytest.fixture(params=[None, *urls_from_file(EXAMPLES_FILE)]) + def dist(self, request, monkeypatch, tmp_path): + """Example of distribution with arbitrary configuration""" + monkeypatch.chdir(tmp_path) + monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.42")) + monkeypatch.setattr(expand, "read_files", Mock(return_value="hello world")) + monkeypatch.setattr( + Distribution, "_finalize_license_files", Mock(return_value=None) + ) + if request.param is None: + yield self.base_example() + else: + # Real-world usage + config = retrieve_file(request.param) + yield setupcfg.apply_configuration(Distribution({}), config) + + @pytest.mark.uses_network + def test_equivalent_output(self, tmp_path, dist): + """Ensure output from setuptools is equivalent to the one from `pypa/wheel`""" + # Generate a METADATA file using pypa/wheel for comparison + wheel_metadata = importlib.import_module("wheel.metadata") + pkginfo_to_metadata = getattr(wheel_metadata, "pkginfo_to_metadata", None) + + if pkginfo_to_metadata is None: # pragma: nocover + pytest.xfail( + "wheel.metadata.pkginfo_to_metadata is undefined, " + "(this is likely to be caused by API changes in pypa/wheel" + ) + + # Generate an simplified "egg-info" dir for pypa/wheel to convert + pkg_info = _get_pkginfo(dist) + egg_info_dir = tmp_path / "pkg.egg-info" + egg_info_dir.mkdir(parents=True) + (egg_info_dir / "PKG-INFO").write_text(pkg_info, encoding="utf-8") + write_requirements(egg_info(dist), egg_info_dir, egg_info_dir / "requires.txt") + + # Get pypa/wheel generated METADATA but normalize requirements formatting + metadata_msg = pkginfo_to_metadata(egg_info_dir, egg_info_dir / "PKG-INFO") + metadata_str = _normalize_metadata(metadata_msg) + pkg_info_msg = message_from_string(pkg_info) + pkg_info_str = _normalize_metadata(pkg_info_msg) + + # Compare setuptools PKG-INFO x pypa/wheel METADATA + assert metadata_str == pkg_info_str + + # Make sure it parses/serializes well in pypa/wheel + _assert_roundtrip_message(pkg_info) + + +class TestPEP643: + STATIC_CONFIG = { + "setup.cfg": cleandoc( + """ + [metadata] + name = package + version = 0.0.1 + author = Foo Bar + author_email = foo@bar.net + long_description = Long + description + description = Short description + keywords = one, two + platforms = abcd + [options] + install_requires = requests + """ + ), + "pyproject.toml": cleandoc( + """ + [project] + name = "package" + version = "0.0.1" + authors = [ + {name = "Foo Bar", email = "foo@bar.net"} + ] + description = "Short description" + readme = {text = "Long\\ndescription", content-type = "text/plain"} + keywords = ["one", "two"] + dependencies = ["requests"] + license = "AGPL-3.0-or-later" + [tool.setuptools] + provides = ["abcd"] + obsoletes = ["abcd"] + """ + ), + } + + @pytest.mark.parametrize("file", STATIC_CONFIG.keys()) + def test_static_config_has_no_dynamic(self, file, tmpdir_cwd): + Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8") + metadata = _get_metadata() + assert metadata.get_all("Dynamic") is None + assert metadata.get_all("dynamic") is None + + @pytest.mark.parametrize("file", STATIC_CONFIG.keys()) + @pytest.mark.parametrize( + "fields", + [ + # Single dynamic field + {"requires-python": ("python_requires", ">=3.12")}, + {"author-email": ("author_email", "snoopy@peanuts.com")}, + {"keywords": ("keywords", ["hello", "world"])}, + {"platform": ("platforms", ["abcd"])}, + # Multiple dynamic fields + { + "summary": ("description", "hello world"), + "description": ("long_description", "bla bla bla bla"), + "requires-dist": ("install_requires", ["hello-world"]), + }, + ], + ) + def test_modified_fields_marked_as_dynamic(self, file, fields, tmpdir_cwd): + # We start with a static config + Path(file).write_text(self.STATIC_CONFIG[file], encoding="utf-8") + dist = _makedist() + + # ... but then we simulate the effects of a plugin modifying the distribution + for attr, value in fields.values(): + # `dist` and `dist.metadata` are complicated... + # Some attributes work when set on `dist`, others on `dist.metadata`... + # Here we set in both just in case (this also avoids calling `_finalize_*`) + setattr(dist, attr, value) + setattr(dist.metadata, attr, value) + + # Then we should be able to list the modified fields as Dynamic + metadata = _get_metadata(dist) + assert set(metadata.get_all("Dynamic")) == set(fields) + + @pytest.mark.parametrize( + "extra_toml", + [ + "# Let setuptools autofill license-files", + "license-files = ['LICENSE*', 'AUTHORS*', 'NOTICE']", + ], + ) + def test_license_files_dynamic(self, extra_toml, tmpdir_cwd): + # For simplicity (and for the time being) setuptools is not making + # any special handling to guarantee `License-File` is considered static. + # Instead we rely in the fact that, although suboptimal, it is OK to have + # it as dynamics, as per: + # https://github.com/pypa/setuptools/issues/4629#issuecomment-2331233677 + files = { + "pyproject.toml": self.STATIC_CONFIG["pyproject.toml"].replace( + 'license = "AGPL-3.0-or-later"', + f"dynamic = ['license']\n{extra_toml}", + ), + "LICENSE.md": "--- mock license ---", + "NOTICE": "--- mock notice ---", + "AUTHORS.txt": "--- me ---", + } + # Sanity checks: + assert extra_toml in files["pyproject.toml"] + assert 'license = "AGPL-3.0-or-later"' not in extra_toml + + jaraco.path.build(files) + dist = _makedist(license_expression="AGPL-3.0-or-later") + metadata = _get_metadata(dist) + assert set(metadata.get_all("Dynamic")) == { + 'license-file', + 'license-expression', + } + assert metadata.get("License-Expression") == "AGPL-3.0-or-later" + assert set(metadata.get_all("License-File")) == { + "NOTICE", + "AUTHORS.txt", + "LICENSE.md", + } + + +def _makedist(**attrs): + dist = Distribution(attrs) + dist.parse_config_files() + return dist + + +def _assert_roundtrip_message(metadata: str) -> None: + """Emulate the way wheel.bdist_wheel parses and regenerates the message, + then ensures the metadata generated by setuptools is compatible. + """ + with io.StringIO(metadata) as buffer: + msg = Parser(EmailMessage).parse(buffer) + + serialization_policy = EmailPolicy( + utf8=True, + mangle_from_=False, + max_line_length=0, + ) + with io.BytesIO() as buffer: + out = io.TextIOWrapper(buffer, encoding="utf-8") + Generator(out, policy=serialization_policy).flatten(msg) + out.flush() + regenerated = buffer.getvalue() + + raw_metadata = bytes(metadata, "utf-8") + # Normalise newlines to avoid test errors on Windows: + raw_metadata = b"\n".join(raw_metadata.splitlines()) + regenerated = b"\n".join(regenerated.splitlines()) + assert regenerated == raw_metadata + + +def _normalize_metadata(msg: Message) -> str: + """Allow equivalent metadata to be compared directly""" + # The main challenge regards the requirements and extras. + # Both setuptools and wheel already apply some level of normalization + # but they differ regarding which character is chosen, according to the + # following spec it should be "-": + # https://packaging.python.org/en/latest/specifications/name-normalization/ + + # Related issues: + # https://github.com/pypa/packaging/issues/845 + # https://github.com/pypa/packaging/issues/644#issuecomment-2429813968 + + extras = {x.replace("_", "-"): x for x in msg.get_all("Provides-Extra", [])} + reqs = [ + _normalize_req(req, extras) + for req in _reqs.parse(msg.get_all("Requires-Dist", [])) + ] + del msg["Requires-Dist"] + del msg["Provides-Extra"] + + # Ensure consistent ord + for req in sorted(reqs): + msg["Requires-Dist"] = req + for extra in sorted(extras): + msg["Provides-Extra"] = extra + + # TODO: Handle lack of PEP 643 implementation in pypa/wheel? + del msg["Metadata-Version"] + + return msg.as_string() + + +def _normalize_req(req: Requirement, extras: dict[str, str]) -> str: + """Allow equivalent requirement objects to be compared directly""" + as_str = str(req).replace(req.name, req.name.replace("_", "-")) + for norm, orig in extras.items(): + as_str = as_str.replace(orig, norm) + return as_str + + +def _get_pkginfo(dist: Distribution): + with io.StringIO() as fp: + dist.metadata.write_pkg_file(fp) + return fp.getvalue() + + +def _get_metadata(dist: Distribution | None = None): + return message_from_string(_get_pkginfo(dist or _makedist())) + + +def _valid_metadata(text: str) -> bool: + metadata = Metadata.from_email(text, validate=True) # can raise exceptions + return metadata is not None diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py new file mode 100644 index 0000000000000000000000000000000000000000..1714c041f7a23e1ecbfc3245bf964f75c13734ca --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_depends.py @@ -0,0 +1,15 @@ +import sys + +from setuptools import depends + + +class TestGetModuleConstant: + def test_basic(self): + """ + Invoke get_module_constant on a module in + the test package. + """ + mod_name = 'setuptools.tests.mod_with_constant' + val = depends.get_module_constant(mod_name, 'value') + assert val == 'three, sir!' + assert 'setuptools.tests.mod_with_constant' not in sys.modules diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py new file mode 100644 index 0000000000000000000000000000000000000000..929fa9c285eb4d11e646dab2864be6d5fa023e2b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_develop.py @@ -0,0 +1,175 @@ +"""develop tests""" + +import os +import pathlib +import platform +import subprocess +import sys + +import pytest + +from setuptools._path import paths_on_pythonpath +from setuptools.command.develop import develop +from setuptools.dist import Distribution + +from . import contexts, namespaces + +SETUP_PY = """\ +from setuptools import setup + +setup(name='foo', + packages=['foo'], +) +""" + +INIT_PY = """print "foo" +""" + + +@pytest.fixture +def temp_user(monkeypatch): + with contexts.tempdir() as user_base: + with contexts.tempdir() as user_site: + monkeypatch.setattr('site.USER_BASE', user_base) + monkeypatch.setattr('site.USER_SITE', user_site) + yield + + +@pytest.fixture +def test_env(tmpdir, temp_user): + target = tmpdir + foo = target.mkdir('foo') + setup = target / 'setup.py' + if setup.isfile(): + raise ValueError(dir(target)) + with setup.open('w') as f: + f.write(SETUP_PY) + init = foo / '__init__.py' + with init.open('w') as f: + f.write(INIT_PY) + with target.as_cwd(): + yield target + + +class TestDevelop: + in_virtualenv = hasattr(sys, 'real_prefix') + in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix + + def test_console_scripts(self, tmpdir): + """ + Test that console scripts are installed and that they reference + only the project by name and not the current version. + """ + pytest.skip( + "TODO: needs a fixture to cause 'develop' " + "to be invoked without mutating environment." + ) + settings = dict( + name='foo', + packages=['foo'], + version='0.0', + entry_points={ + 'console_scripts': [ + 'foocmd = foo:foo', + ], + }, + ) + dist = Distribution(settings) + dist.script_name = 'setup.py' + cmd = develop(dist) + cmd.ensure_finalized() + cmd.install_dir = tmpdir + cmd.run() + # assert '0.0' not in foocmd_text + + @pytest.mark.xfail(reason="legacy behavior retained for compatibility #4167") + def test_egg_link_filename(self): + settings = dict( + name='Foo $$$ Bar_baz-bing', + ) + dist = Distribution(settings) + cmd = develop(dist) + cmd.ensure_finalized() + link = pathlib.Path(cmd.egg_link) + assert link.suffix == '.egg-link' + assert link.stem == 'Foo_Bar_baz_bing' + + +class TestResolver: + """ + TODO: These tests were written with a minimal understanding + of what _resolve_setup_path is intending to do. Come up with + more meaningful cases that look like real-world scenarios. + """ + + def test_resolve_setup_path_cwd(self): + assert develop._resolve_setup_path('.', '.', '.') == '.' + + def test_resolve_setup_path_one_dir(self): + assert develop._resolve_setup_path('pkgs', '.', 'pkgs') == '../' + + def test_resolve_setup_path_one_dir_trailing_slash(self): + assert develop._resolve_setup_path('pkgs/', '.', 'pkgs') == '../' + + +class TestNamespaces: + @staticmethod + def install_develop(src_dir, target): + develop_cmd = [ + sys.executable, + 'setup.py', + 'develop', + '--install-dir', + str(target), + ] + with src_dir.as_cwd(): + with paths_on_pythonpath([str(target)]): + subprocess.check_call(develop_cmd) + + @pytest.mark.skipif( + bool(os.environ.get("APPVEYOR")), + reason="https://github.com/pypa/setuptools/issues/851", + ) + @pytest.mark.skipif( + platform.python_implementation() == 'PyPy', + reason="https://github.com/pypa/setuptools/issues/1202", + ) + def test_namespace_package_importable(self, tmpdir): + """ + Installing two packages sharing the same namespace, one installed + naturally using pip or `--single-version-externally-managed` + and the other installed using `develop` should leave the namespace + in tact and both packages reachable by import. + """ + pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA') + pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB') + target = tmpdir / 'packages' + # use pip to install to the target directory + install_cmd = [ + sys.executable, + '-m', + 'pip', + 'install', + str(pkg_A), + '-t', + str(target), + ] + subprocess.check_call(install_cmd) + self.install_develop(pkg_B, target) + namespaces.make_site_dir(target) + try_import = [ + sys.executable, + '-c', + 'import myns.pkgA; import myns.pkgB', + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(try_import) + + # additionally ensure that pkg_resources import works + pkg_resources_imp = [ + sys.executable, + '-c', + 'import pkg_resources', + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(pkg_resources_imp) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py new file mode 100644 index 0000000000000000000000000000000000000000..e65ab310e7f2ad98b591affb352c855a2f86eda1 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist.py @@ -0,0 +1,278 @@ +import os +import re +import urllib.parse +import urllib.request + +import pytest + +from setuptools import Distribution +from setuptools.dist import check_package_data, check_specifier + +from .test_easy_install import make_trivial_sdist +from .test_find_packages import ensure_files +from .textwrap import DALS + +from distutils.errors import DistutilsSetupError + + +def test_dist_fetch_build_egg(tmpdir): + """ + Check multiple calls to `Distribution.fetch_build_egg` work as expected. + """ + index = tmpdir.mkdir('index') + index_url = urllib.parse.urljoin('file://', urllib.request.pathname2url(str(index))) + + def sdist_with_index(distname, version): + dist_dir = index.mkdir(distname) + dist_sdist = f'{distname}-{version}.tar.gz' + make_trivial_sdist(str(dist_dir.join(dist_sdist)), distname, version) + with dist_dir.join('index.html').open('w') as fp: + fp.write( + DALS( + """ + + {dist_sdist}
+ + """ + ).format(dist_sdist=dist_sdist) + ) + + sdist_with_index('barbazquux', '3.2.0') + sdist_with_index('barbazquux-runner', '2.11.1') + with tmpdir.join('setup.cfg').open('w') as fp: + fp.write( + DALS( + """ + [easy_install] + index_url = {index_url} + """ + ).format(index_url=index_url) + ) + reqs = """ + barbazquux-runner + barbazquux + """.split() + with tmpdir.as_cwd(): + dist = Distribution() + dist.parse_config_files() + resolved_dists = [dist.fetch_build_egg(r) for r in reqs] + assert [dist.key for dist in resolved_dists if dist] == reqs + + +EXAMPLE_BASE_INFO = dict( + name="package", + version="0.0.1", + author="Foo Bar", + author_email="foo@bar.net", + long_description="Long\ndescription", + description="Short description", + keywords=["one", "two"], +) + + +def test_provides_extras_deterministic_order(): + attrs = dict(extras_require=dict(a=['foo'], b=['bar'])) + dist = Distribution(attrs) + assert list(dist.metadata.provides_extras) == ['a', 'b'] + attrs['extras_require'] = dict(reversed(attrs['extras_require'].items())) + dist = Distribution(attrs) + assert list(dist.metadata.provides_extras) == ['b', 'a'] + + +CHECK_PACKAGE_DATA_TESTS = ( + # Valid. + ( + { + '': ['*.txt', '*.rst'], + 'hello': ['*.msg'], + }, + None, + ), + # Not a dictionary. + ( + ( + ('', ['*.txt', '*.rst']), + ('hello', ['*.msg']), + ), + ( + "'package_data' must be a dictionary mapping package" + " names to lists of string wildcard patterns" + ), + ), + # Invalid key type. + ( + { + 400: ['*.txt', '*.rst'], + }, + ("keys of 'package_data' dict must be strings (got 400)"), + ), + # Invalid value type. + ( + { + 'hello': '*.msg', + }, + ( + "\"values of 'package_data' dict\" must be of type " + " (got '*.msg')" + ), + ), + # Invalid value type (generators are single use) + ( + { + 'hello': (x for x in "generator"), + }, + ( + "\"values of 'package_data' dict\" must be of type " + " (got =3.0, !=3.1'} + dist = Distribution(attrs) + check_specifier(dist, attrs, attrs['python_requires']) + + attrs = {'name': 'foo', 'python_requires': ['>=3.0', '!=3.1']} + dist = Distribution(attrs) + check_specifier(dist, attrs, attrs['python_requires']) + + # invalid specifier value + attrs = {'name': 'foo', 'python_requires': '>=invalid-version'} + with pytest.raises(DistutilsSetupError): + dist = Distribution(attrs) + + +def test_metadata_name(): + with pytest.raises(DistutilsSetupError, match='missing.*name'): + Distribution()._validate_metadata() + + +@pytest.mark.parametrize( + ('dist_name', 'py_module'), + [ + ("my.pkg", "my_pkg"), + ("my-pkg", "my_pkg"), + ("my_pkg", "my_pkg"), + ("pkg", "pkg"), + ], +) +def test_dist_default_py_modules(tmp_path, dist_name, py_module): + (tmp_path / f"{py_module}.py").touch() + + (tmp_path / "setup.py").touch() + (tmp_path / "noxfile.py").touch() + # ^-- make sure common tool files are ignored + + attrs = {**EXAMPLE_BASE_INFO, "name": dist_name, "src_root": str(tmp_path)} + # Find `py_modules` corresponding to dist_name if not given + dist = Distribution(attrs) + dist.set_defaults() + assert dist.py_modules == [py_module] + # When `py_modules` is given, don't do anything + dist = Distribution({**attrs, "py_modules": ["explicity_py_module"]}) + dist.set_defaults() + assert dist.py_modules == ["explicity_py_module"] + # When `packages` is given, don't do anything + dist = Distribution({**attrs, "packages": ["explicity_package"]}) + dist.set_defaults() + assert not dist.py_modules + + +@pytest.mark.parametrize( + ('dist_name', 'package_dir', 'package_files', 'packages'), + [ + ("my.pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]), + ("my-pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]), + ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]), + ("my.pkg", None, ["my/pkg/__init__.py"], ["my", "my.pkg"]), + ( + "my_pkg", + None, + ["src/my_pkg/__init__.py", "src/my_pkg2/__init__.py"], + ["my_pkg", "my_pkg2"], + ), + ( + "my_pkg", + {"pkg": "lib", "pkg2": "lib2"}, + ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"], + ["pkg", "pkg.nested", "pkg2"], + ), + ], +) +def test_dist_default_packages( + tmp_path, dist_name, package_dir, package_files, packages +): + ensure_files(tmp_path, package_files) + + (tmp_path / "setup.py").touch() + (tmp_path / "noxfile.py").touch() + # ^-- should not be included by default + + attrs = { + **EXAMPLE_BASE_INFO, + "name": dist_name, + "src_root": str(tmp_path), + "package_dir": package_dir, + } + # Find `packages` either corresponding to dist_name or inside src + dist = Distribution(attrs) + dist.set_defaults() + assert not dist.py_modules + assert not dist.py_modules + assert set(dist.packages) == set(packages) + # When `py_modules` is given, don't do anything + dist = Distribution({**attrs, "py_modules": ["explicit_py_module"]}) + dist.set_defaults() + assert not dist.packages + assert set(dist.py_modules) == {"explicit_py_module"} + # When `packages` is given, don't do anything + dist = Distribution({**attrs, "packages": ["explicit_package"]}) + dist.set_defaults() + assert not dist.py_modules + assert set(dist.packages) == {"explicit_package"} + + +@pytest.mark.parametrize( + ('dist_name', 'package_dir', 'package_files'), + [ + ("my.pkg.nested", None, ["my/pkg/nested/__init__.py"]), + ("my.pkg", None, ["my/pkg/__init__.py", "my/pkg/file.py"]), + ("my_pkg", None, ["my_pkg.py"]), + ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/nested/__init__.py"]), + ("my_pkg", None, ["src/my_pkg/__init__.py", "src/my_pkg/nested/__init__.py"]), + ( + "my_pkg", + {"my_pkg": "lib", "my_pkg.lib2": "lib2"}, + ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"], + ), + # Should not try to guess a name from multiple py_modules/packages + ("UNKNOWN", None, ["src/mod1.py", "src/mod2.py"]), + ("UNKNOWN", None, ["src/pkg1/__ini__.py", "src/pkg2/__init__.py"]), + ], +) +def test_dist_default_name(tmp_path, dist_name, package_dir, package_files): + """Make sure dist.name is discovered from packages/py_modules""" + ensure_files(tmp_path, package_files) + attrs = { + **EXAMPLE_BASE_INFO, + "src_root": "/".join(os.path.split(tmp_path)), # POSIX-style + "package_dir": package_dir, + } + del attrs["name"] + + dist = Distribution(attrs) + dist.set_defaults() + assert dist.py_modules or dist.packages + assert dist.get_name() == dist_name diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py new file mode 100644 index 0000000000000000000000000000000000000000..426694e0198fdbe6ee7466822bc7c15634e2b648 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_dist_info.py @@ -0,0 +1,210 @@ +"""Test .dist-info style distributions.""" + +import pathlib +import re +import shutil +import subprocess +import sys +from functools import partial + +import pytest + +import pkg_resources +from setuptools.archive_util import unpack_archive + +from .textwrap import DALS + +read = partial(pathlib.Path.read_text, encoding="utf-8") + + +class TestDistInfo: + metadata_base = DALS( + """ + Metadata-Version: 1.2 + Requires-Dist: splort (==4) + Provides-Extra: baz + Requires-Dist: quux (>=1.1); extra == 'baz' + """ + ) + + @classmethod + def build_metadata(cls, **kwargs): + lines = ('{key}: {value}\n'.format(**locals()) for key, value in kwargs.items()) + return cls.metadata_base + ''.join(lines) + + @pytest.fixture + def metadata(self, tmpdir): + dist_info_name = 'VersionedDistribution-2.718.dist-info' + versioned = tmpdir / dist_info_name + versioned.mkdir() + filename = versioned / 'METADATA' + content = self.build_metadata( + Name='VersionedDistribution', + ) + filename.write_text(content, encoding='utf-8') + + dist_info_name = 'UnversionedDistribution.dist-info' + unversioned = tmpdir / dist_info_name + unversioned.mkdir() + filename = unversioned / 'METADATA' + content = self.build_metadata( + Name='UnversionedDistribution', + Version='0.3', + ) + filename.write_text(content, encoding='utf-8') + + return str(tmpdir) + + def test_distinfo(self, metadata): + dists = dict( + (d.project_name, d) for d in pkg_resources.find_distributions(metadata) + ) + + assert len(dists) == 2, dists + + unversioned = dists['UnversionedDistribution'] + versioned = dists['VersionedDistribution'] + + assert versioned.version == '2.718' # from filename + assert unversioned.version == '0.3' # from METADATA + + def test_conditional_dependencies(self, metadata): + specs = 'splort==4', 'quux>=1.1' + requires = list(map(pkg_resources.Requirement.parse, specs)) + + for d in pkg_resources.find_distributions(metadata): + assert d.requires() == requires[:1] + assert d.requires(extras=('baz',)) == [ + requires[0], + pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"'), + ] + assert d.extras == ['baz'] + + def test_invalid_version(self, tmp_path): + """ + Supplying an invalid version crashes dist_info. + """ + config = "[metadata]\nname=proj\nversion=42\n[egg_info]\ntag_build=invalid!!!\n" + (tmp_path / "setup.cfg").write_text(config, encoding="utf-8") + msg = re.compile("invalid version", re.M | re.I) + proc = run_command_inner("dist_info", cwd=tmp_path, check=False) + assert proc.returncode + assert msg.search(proc.stdout) + assert not list(tmp_path.glob("*.dist-info")) + + def test_tag_arguments(self, tmp_path): + config = """ + [metadata] + name=proj + version=42 + [egg_info] + tag_date=1 + tag_build=.post + """ + (tmp_path / "setup.cfg").write_text(config, encoding="utf-8") + + print(run_command("dist_info", "--no-date", cwd=tmp_path)) + dist_info = next(tmp_path.glob("*.dist-info")) + assert dist_info.name.startswith("proj-42") + shutil.rmtree(dist_info) + + print(run_command("dist_info", "--tag-build", ".a", cwd=tmp_path)) + dist_info = next(tmp_path.glob("*.dist-info")) + assert dist_info.name.startswith("proj-42a") + + @pytest.mark.parametrize("keep_egg_info", (False, True)) + def test_output_dir(self, tmp_path, keep_egg_info): + config = "[metadata]\nname=proj\nversion=42\n" + (tmp_path / "setup.cfg").write_text(config, encoding="utf-8") + out = tmp_path / "__out" + out.mkdir() + opts = ["--keep-egg-info"] if keep_egg_info else [] + run_command("dist_info", "--output-dir", out, *opts, cwd=tmp_path) + assert len(list(out.glob("*.dist-info"))) == 1 + assert len(list(tmp_path.glob("*.dist-info"))) == 0 + expected_egg_info = int(keep_egg_info) + assert len(list(out.glob("*.egg-info"))) == expected_egg_info + assert len(list(tmp_path.glob("*.egg-info"))) == 0 + assert len(list(out.glob("*.__bkp__"))) == 0 + assert len(list(tmp_path.glob("*.__bkp__"))) == 0 + + +class TestWheelCompatibility: + """Make sure the .dist-info directory produced with the ``dist_info`` command + is the same as the one produced by ``bdist_wheel``. + """ + + SETUPCFG = DALS( + """ + [metadata] + name = {name} + version = {version} + + [options] + install_requires = + foo>=12; sys_platform != "linux" + + [options.extras_require] + test = pytest + + [options.entry_points] + console_scripts = + executable-name = my_package.module:function + discover = + myproj = my_package.other_module:function + """ + ) + + EGG_INFO_OPTS = [ + # Related: #3088 #2872 + ("", ""), + (".post", "[egg_info]\ntag_build = post\n"), + (".post", "[egg_info]\ntag_build = .post\n"), + (".post", "[egg_info]\ntag_build = post\ntag_date = 1\n"), + (".dev", "[egg_info]\ntag_build = .dev\n"), + (".dev", "[egg_info]\ntag_build = .dev\ntag_date = 1\n"), + ("a1", "[egg_info]\ntag_build = .a1\n"), + ("+local", "[egg_info]\ntag_build = +local\n"), + ] + + @pytest.mark.parametrize("name", "my-proj my_proj my.proj My.Proj".split()) + @pytest.mark.parametrize("version", ["0.42.13"]) + @pytest.mark.parametrize(("suffix", "cfg"), EGG_INFO_OPTS) + def test_dist_info_is_the_same_as_in_wheel( + self, name, version, tmp_path, suffix, cfg + ): + config = self.SETUPCFG.format(name=name, version=version) + cfg + + for i in "dir_wheel", "dir_dist": + (tmp_path / i).mkdir() + (tmp_path / i / "setup.cfg").write_text(config, encoding="utf-8") + + run_command("bdist_wheel", cwd=tmp_path / "dir_wheel") + wheel = next(tmp_path.glob("dir_wheel/dist/*.whl")) + unpack_archive(wheel, tmp_path / "unpack") + wheel_dist_info = next(tmp_path.glob("unpack/*.dist-info")) + + run_command("dist_info", cwd=tmp_path / "dir_dist") + dist_info = next(tmp_path.glob("dir_dist/*.dist-info")) + + assert dist_info.name == wheel_dist_info.name + assert dist_info.name.startswith(f"my_proj-{version}{suffix}") + for file in "METADATA", "entry_points.txt": + assert read(dist_info / file) == read(wheel_dist_info / file) + + +def run_command_inner(*cmd, **kwargs): + opts = { + "stderr": subprocess.STDOUT, + "stdout": subprocess.PIPE, + "text": True, + "encoding": "utf-8", + "check": True, + **kwargs, + } + cmd = [sys.executable, "-c", "__import__('setuptools').setup()", *map(str, cmd)] + return subprocess.run(cmd, **opts) + + +def run_command(*args, **kwargs): + return run_command_inner(*args, **kwargs).stdout diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py new file mode 100644 index 0000000000000000000000000000000000000000..f99a58849950029f53322c19cde1c171fe26622c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_distutils_adoption.py @@ -0,0 +1,198 @@ +import os +import platform +import sys +import textwrap + +import pytest + +IS_PYPY = '__pypy__' in sys.builtin_module_names + +_TEXT_KWARGS = {"text": True, "encoding": "utf-8"} # For subprocess.run + + +def win_sr(env): + """ + On Windows, SYSTEMROOT must be present to avoid + + > Fatal Python error: _Py_HashRandomization_Init: failed to + > get random numbers to initialize Python + """ + if env and platform.system() == 'Windows': + env['SYSTEMROOT'] = os.environ['SYSTEMROOT'] + return env + + +def find_distutils(venv, imports='distutils', env=None, **kwargs): + py_cmd = 'import {imports}; print(distutils.__file__)'.format(**locals()) + cmd = ['python', '-c', py_cmd] + return venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS, **kwargs) + + +def count_meta_path(venv, env=None): + py_cmd = textwrap.dedent( + """ + import sys + is_distutils = lambda finder: finder.__class__.__name__ == "DistutilsMetaFinder" + print(len(list(filter(is_distutils, sys.meta_path)))) + """ + ) + cmd = ['python', '-c', py_cmd] + return int(venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS)) + + +skip_without_stdlib_distutils = pytest.mark.skipif( + sys.version_info >= (3, 12), + reason='stdlib distutils is removed from Python 3.12+', +) + + +@skip_without_stdlib_distutils +def test_distutils_stdlib(venv): + """ + Ensure stdlib distutils is used when appropriate. + """ + env = dict(SETUPTOOLS_USE_DISTUTILS='stdlib') + assert venv.name not in find_distutils(venv, env=env).split(os.sep) + assert count_meta_path(venv, env=env) == 0 + + +def test_distutils_local_with_setuptools(venv): + """ + Ensure local distutils is used when appropriate. + """ + env = dict(SETUPTOOLS_USE_DISTUTILS='local') + loc = find_distutils(venv, imports='setuptools, distutils', env=env) + assert venv.name in loc.split(os.sep) + assert count_meta_path(venv, env=env) <= 1 + + +@pytest.mark.xfail('IS_PYPY', reason='pypy imports distutils on startup') +def test_distutils_local(venv): + """ + Even without importing, the setuptools-local copy of distutils is + preferred. + """ + env = dict(SETUPTOOLS_USE_DISTUTILS='local') + assert venv.name in find_distutils(venv, env=env).split(os.sep) + assert count_meta_path(venv, env=env) <= 1 + + +def test_pip_import(venv): + """ + Ensure pip can be imported. + Regression test for #3002. + """ + cmd = ['python', '-c', 'import pip'] + venv.run(cmd, **_TEXT_KWARGS) + + +def test_distutils_has_origin(): + """ + Distutils module spec should have an origin. #2990. + """ + assert __import__('distutils').__spec__.origin + + +ENSURE_IMPORTS_ARE_NOT_DUPLICATED = r""" +# Depending on the importlib machinery and _distutils_hack, some imports are +# duplicated resulting in different module objects being loaded, which prevents +# patches as shown in #3042. +# This script provides a way of verifying if this duplication is happening. + +from distutils import cmd +import distutils.command.sdist as sdist + +# import last to prevent caching +from distutils import {imported_module} + +for mod in (cmd, sdist): + assert mod.{imported_module} == {imported_module}, ( + f"\n{{mod.dir_util}}\n!=\n{{{imported_module}}}" + ) + +print("success") +""" + + +@pytest.mark.usefixtures("tmpdir_cwd") +@pytest.mark.parametrize( + ('distutils_version', 'imported_module'), + [ + pytest.param("stdlib", "dir_util", marks=skip_without_stdlib_distutils), + pytest.param("stdlib", "file_util", marks=skip_without_stdlib_distutils), + pytest.param("stdlib", "archive_util", marks=skip_without_stdlib_distutils), + ("local", "dir_util"), + ("local", "file_util"), + ("local", "archive_util"), + ], +) +def test_modules_are_not_duplicated_on_import(distutils_version, imported_module, venv): + env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version) + script = ENSURE_IMPORTS_ARE_NOT_DUPLICATED.format(imported_module=imported_module) + cmd = ['python', '-c', script] + output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip() + assert output == "success" + + +ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED = r""" +import types +import distutils.dist as dist +from distutils import log +if isinstance(dist.log, types.ModuleType): + assert dist.log == log, f"\n{dist.log}\n!=\n{log}" +print("success") +""" + + +@pytest.mark.usefixtures("tmpdir_cwd") +@pytest.mark.parametrize( + "distutils_version", + [ + "local", + pytest.param("stdlib", marks=skip_without_stdlib_distutils), + ], +) +def test_log_module_is_not_duplicated_on_import(distutils_version, venv): + env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version) + cmd = ['python', '-c', ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED] + output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip() + assert output == "success" + + +ENSURE_CONSISTENT_ERROR_FROM_MODIFIED_PY = r""" +from setuptools.modified import newer +from {imported_module}.errors import DistutilsError + +# Can't use pytest.raises in this context +try: + newer("", "") +except DistutilsError: + print("success") +else: + raise AssertionError("Expected to raise") +""" + + +@pytest.mark.usefixtures("tmpdir_cwd") +@pytest.mark.parametrize( + ('distutils_version', 'imported_module'), + [ + ("local", "distutils"), + # Unfortunately we still get ._distutils.errors.DistutilsError with SETUPTOOLS_USE_DISTUTILS=stdlib + # But that's a deprecated use-case we don't mind not fully supporting in newer code + pytest.param( + "stdlib", "setuptools._distutils", marks=skip_without_stdlib_distutils + ), + ], +) +def test_consistent_error_from_modified_py(distutils_version, imported_module, venv): + env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version) + cmd = [ + 'python', + '-c', + ENSURE_CONSISTENT_ERROR_FROM_MODIFIED_PY.format( + imported_module=imported_module + ), + ] + output = venv.run(cmd, env=win_sr(env), **_TEXT_KWARGS).strip() + assert output == "success" diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py new file mode 100644 index 0000000000000000000000000000000000000000..b58b0b66663e4bfb6e26bd730e62bff8267eeff5 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_easy_install.py @@ -0,0 +1,1476 @@ +"""Easy install Tests""" + +import contextlib +import io +import itertools +import logging +import os +import pathlib +import re +import site +import subprocess +import sys +import tarfile +import tempfile +import time +import warnings +import zipfile +from pathlib import Path +from typing import NamedTuple +from unittest import mock + +import pytest +from jaraco import path + +import pkg_resources +import setuptools.command.easy_install as ei +from pkg_resources import Distribution as PRDistribution, normalize_path, working_set +from setuptools import sandbox +from setuptools._normalization import safer_name +from setuptools.command.easy_install import PthDistributions +from setuptools.dist import Distribution +from setuptools.sandbox import run_setup +from setuptools.tests import fail_on_ascii +from setuptools.tests.server import MockServer, path_to_url + +from . import contexts +from .textwrap import DALS + +import distutils.errors + + +@pytest.fixture(autouse=True) +def pip_disable_index(monkeypatch): + """ + Important: Disable the default index for pip to avoid + querying packages in the index and potentially resolving + and installing packages there. + """ + monkeypatch.setenv('PIP_NO_INDEX', 'true') + + +class FakeDist: + def get_entry_map(self, group): + if group != 'console_scripts': + return {} + return {'name': 'ep'} + + def as_requirement(self): + return 'spec' + + +SETUP_PY = DALS( + """ + from setuptools import setup + + setup() + """ +) + + +class TestEasyInstallTest: + def test_get_script_args(self): + header = ei.CommandSpec.best().from_environment().as_header() + dist = FakeDist() + args = next(ei.ScriptWriter.get_args(dist)) + _name, script = itertools.islice(args, 2) + assert script.startswith(header) + assert "'spec'" in script + assert "'console_scripts'" in script + assert "'name'" in script + assert re.search('^# EASY-INSTALL-ENTRY-SCRIPT', script, flags=re.MULTILINE) + + def test_no_find_links(self): + # new option '--no-find-links', that blocks find-links added at + # the project level + dist = Distribution() + cmd = ei.easy_install(dist) + cmd.check_pth_processing = lambda: True + cmd.no_find_links = True + cmd.find_links = ['link1', 'link2'] + cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') + cmd.args = ['ok'] + cmd.ensure_finalized() + assert cmd.package_index.scanned_urls == {} + + # let's try without it (default behavior) + cmd = ei.easy_install(dist) + cmd.check_pth_processing = lambda: True + cmd.find_links = ['link1', 'link2'] + cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok') + cmd.args = ['ok'] + cmd.ensure_finalized() + keys = sorted(cmd.package_index.scanned_urls.keys()) + assert keys == ['link1', 'link2'] + + def test_write_exception(self): + """ + Test that `cant_write_to_target` is rendered as a DistutilsError. + """ + dist = Distribution() + cmd = ei.easy_install(dist) + cmd.install_dir = os.getcwd() + with pytest.raises(distutils.errors.DistutilsError): + cmd.cant_write_to_target() + + def test_all_site_dirs(self, monkeypatch): + """ + get_site_dirs should always return site dirs reported by + site.getsitepackages. + """ + path = normalize_path('/setuptools/test/site-packages') + + def mock_gsp(): + return [path] + + monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False) + assert path in ei.get_site_dirs() + + def test_all_site_dirs_works_without_getsitepackages(self, monkeypatch): + monkeypatch.delattr(site, 'getsitepackages', raising=False) + assert ei.get_site_dirs() + + @pytest.fixture + def sdist_unicode(self, tmpdir): + files = [ + ( + 'setup.py', + DALS( + """ + import setuptools + setuptools.setup( + name="setuptools-test-unicode", + version="1.0", + packages=["mypkg"], + include_package_data=True, + ) + """ + ), + ), + ( + 'mypkg/__init__.py', + "", + ), + ( + 'mypkg/☃.txt', + "", + ), + ] + sdist_name = 'setuptools-test-unicode-1.0.zip' + sdist = tmpdir / sdist_name + # can't use make_sdist, because the issue only occurs + # with zip sdists. + sdist_zip = zipfile.ZipFile(str(sdist), 'w') + for filename, content in files: + sdist_zip.writestr(filename, content) + sdist_zip.close() + return str(sdist) + + @fail_on_ascii + def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch): + """ + The install command should execute correctly even if + the package has unicode filenames. + """ + dist = Distribution({'script_args': ['easy_install']}) + target = (tmpdir / 'target').ensure_dir() + cmd = ei.easy_install( + dist, + install_dir=str(target), + args=['x'], + ) + monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target)) + cmd.ensure_finalized() + cmd.easy_install(sdist_unicode) + + @pytest.fixture + def sdist_unicode_in_script(self, tmpdir): + files = [ + ( + "setup.py", + DALS( + """ + import setuptools + setuptools.setup( + name="setuptools-test-unicode", + version="1.0", + packages=["mypkg"], + include_package_data=True, + scripts=['mypkg/unicode_in_script'], + ) + """ + ), + ), + ("mypkg/__init__.py", ""), + ( + "mypkg/unicode_in_script", + DALS( + """ + #!/bin/sh + # á + + non_python_fn() { + } + """ + ), + ), + ] + sdist_name = "setuptools-test-unicode-script-1.0.zip" + sdist = tmpdir / sdist_name + # can't use make_sdist, because the issue only occurs + # with zip sdists. + sdist_zip = zipfile.ZipFile(str(sdist), "w") + for filename, content in files: + sdist_zip.writestr(filename, content.encode('utf-8')) + sdist_zip.close() + return str(sdist) + + @fail_on_ascii + def test_unicode_content_in_sdist( + self, sdist_unicode_in_script, tmpdir, monkeypatch + ): + """ + The install command should execute correctly even if + the package has unicode in scripts. + """ + dist = Distribution({"script_args": ["easy_install"]}) + target = (tmpdir / "target").ensure_dir() + cmd = ei.easy_install(dist, install_dir=str(target), args=["x"]) + monkeypatch.setitem(os.environ, "PYTHONPATH", str(target)) + cmd.ensure_finalized() + cmd.easy_install(sdist_unicode_in_script) + + @pytest.fixture + def sdist_script(self, tmpdir): + files = [ + ( + 'setup.py', + DALS( + """ + import setuptools + setuptools.setup( + name="setuptools-test-script", + version="1.0", + scripts=["mypkg_script"], + ) + """ + ), + ), + ( + 'mypkg_script', + DALS( + """ + #/usr/bin/python + print('mypkg_script') + """ + ), + ), + ] + sdist_name = 'setuptools-test-script-1.0.zip' + sdist = str(tmpdir / sdist_name) + make_sdist(sdist, files) + return sdist + + @pytest.mark.skipif( + not sys.platform.startswith('linux'), reason="Test can only be run on Linux" + ) + def test_script_install(self, sdist_script, tmpdir, monkeypatch): + """ + Check scripts are installed. + """ + dist = Distribution({'script_args': ['easy_install']}) + target = (tmpdir / 'target').ensure_dir() + cmd = ei.easy_install( + dist, + install_dir=str(target), + args=['x'], + ) + monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target)) + cmd.ensure_finalized() + cmd.easy_install(sdist_script) + assert (target / 'mypkg_script').exists() + + +@pytest.mark.filterwarnings('ignore:Unbuilt egg') +class TestPTHFileWriter: + def test_add_from_cwd_site_sets_dirty(self): + """a pth file manager should set dirty + if a distribution is in site but also the cwd + """ + pth = PthDistributions('does-not_exist', [os.getcwd()]) + assert not pth.dirty + pth.add(PRDistribution(os.getcwd())) + assert pth.dirty + + def test_add_from_site_is_ignored(self): + location = '/test/location/does-not-have-to-exist' + # PthDistributions expects all locations to be normalized + location = pkg_resources.normalize_path(location) + pth = PthDistributions( + 'does-not_exist', + [ + location, + ], + ) + assert not pth.dirty + pth.add(PRDistribution(location)) + assert not pth.dirty + + def test_many_pth_distributions_merge_together(self, tmpdir): + """ + If the pth file is modified under the hood, then PthDistribution + will refresh its content before saving, merging contents when + necessary. + """ + # putting the pth file in a dedicated sub-folder, + pth_subdir = tmpdir.join("pth_subdir") + pth_subdir.mkdir() + pth_path = str(pth_subdir.join("file1.pth")) + pth1 = PthDistributions(pth_path) + pth2 = PthDistributions(pth_path) + assert pth1.paths == pth2.paths == [], ( + "unless there would be some default added at some point" + ) + # and so putting the src_subdir in folder distinct than the pth one, + # so to keep it absolute by PthDistributions + new_src_path = tmpdir.join("src_subdir") + new_src_path.mkdir() # must exist to be accounted + new_src_path_str = str(new_src_path) + pth1.paths.append(new_src_path_str) + pth1.save() + assert pth1.paths, ( + "the new_src_path added must still be present/valid in pth1 after save" + ) + # now, + assert new_src_path_str not in pth2.paths, ( + "right before we save the entry should still not be present" + ) + pth2.save() + assert new_src_path_str in pth2.paths, ( + "the new_src_path entry should have been added by pth2 with its save() call" + ) + assert pth2.paths[-1] == new_src_path, ( + "and it should match exactly on the last entry actually " + "given we append to it in save()" + ) + # finally, + assert PthDistributions(pth_path).paths == pth2.paths, ( + "and we should have the exact same list at the end " + "with a fresh PthDistributions instance" + ) + + +@pytest.fixture +def setup_context(tmpdir): + with (tmpdir / 'setup.py').open('w', encoding="utf-8") as f: + f.write(SETUP_PY) + with tmpdir.as_cwd(): + yield tmpdir + + +@pytest.mark.usefixtures("user_override") +@pytest.mark.usefixtures("setup_context") +class TestUserInstallTest: + # prevent check that site-packages is writable. easy_install + # shouldn't be writing to system site-packages during finalize + # options, but while it does, bypass the behavior. + prev_sp_write = mock.patch( + 'setuptools.command.easy_install.easy_install.check_site_dir', + mock.Mock(), + ) + + # simulate setuptools installed in user site packages + @mock.patch('setuptools.command.easy_install.__file__', site.USER_SITE) + @mock.patch('site.ENABLE_USER_SITE', True) + @prev_sp_write + def test_user_install_not_implied_user_site_enabled(self): + self.assert_not_user_site() + + @mock.patch('site.ENABLE_USER_SITE', False) + @prev_sp_write + def test_user_install_not_implied_user_site_disabled(self): + self.assert_not_user_site() + + @staticmethod + def assert_not_user_site(): + # create a finalized easy_install command + dist = Distribution() + dist.script_name = 'setup.py' + cmd = ei.easy_install(dist) + cmd.args = ['py'] + cmd.ensure_finalized() + assert not cmd.user, 'user should not be implied' + + def test_multiproc_atexit(self): + pytest.importorskip('multiprocessing') + + log = logging.getLogger('test_easy_install') + logging.basicConfig(level=logging.INFO, stream=sys.stderr) + log.info('this should not break') + + @pytest.fixture + def foo_package(self, tmpdir): + egg_file = tmpdir / 'foo-1.0.egg-info' + with egg_file.open('w') as f: + f.write('Name: foo\n') + return str(tmpdir) + + @pytest.fixture + def install_target(self, tmpdir): + target = str(tmpdir) + with mock.patch('sys.path', sys.path + [target]): + python_path = os.path.pathsep.join(sys.path) + with mock.patch.dict(os.environ, PYTHONPATH=python_path): + yield target + + def test_local_index(self, foo_package, install_target): + """ + The local index must be used when easy_install locates installed + packages. + """ + dist = Distribution() + dist.script_name = 'setup.py' + cmd = ei.easy_install(dist) + cmd.install_dir = install_target + cmd.args = ['foo'] + cmd.ensure_finalized() + cmd.local_index.scan([foo_package]) + res = cmd.easy_install('foo') + actual = os.path.normcase(os.path.realpath(res.location)) + expected = os.path.normcase(os.path.realpath(foo_package)) + assert actual == expected + + @contextlib.contextmanager + def user_install_setup_context(self, *args, **kwargs): + """ + Wrap sandbox.setup_context to patch easy_install in that context to + appear as user-installed. + """ + with self.orig_context(*args, **kwargs): + import setuptools.command.easy_install as ei + + ei.__file__ = site.USER_SITE + yield + + def patched_setup_context(self): + self.orig_context = sandbox.setup_context + + return mock.patch( + 'setuptools.sandbox.setup_context', + self.user_install_setup_context, + ) + + +@pytest.fixture +def distutils_package(): + distutils_setup_py = SETUP_PY.replace( + 'from setuptools import setup', + 'from distutils.core import setup', + ) + with contexts.tempdir(cd=os.chdir): + with open('setup.py', 'w', encoding="utf-8") as f: + f.write(distutils_setup_py) + yield + + +@pytest.mark.usefixtures("distutils_package") +class TestDistutilsPackage: + def test_bdist_egg_available_on_distutils_pkg(self): + run_setup('setup.py', ['bdist_egg']) + + +@pytest.fixture +def mock_index(): + # set up a server which will simulate an alternate package index. + p_index = MockServer() + if p_index.server_port == 0: + # Some platforms (Jython) don't find a port to which to bind, + # so skip test for them. + pytest.skip("could not find a valid port") + p_index.start() + return p_index + + +class TestInstallRequires: + def test_setup_install_includes_dependencies(self, tmp_path, mock_index): + """ + When ``python setup.py install`` is called directly, it will use easy_install + to fetch dependencies. + """ + # TODO: Remove these tests once `setup.py install` is completely removed + project_root = tmp_path / "project" + project_root.mkdir(exist_ok=True) + install_root = tmp_path / "install" + install_root.mkdir(exist_ok=True) + + self.create_project(project_root) + cmd = [ + sys.executable, + '-c', + '__import__("setuptools").setup()', + 'install', + '--install-base', + str(install_root), + '--install-lib', + str(install_root), + '--install-headers', + str(install_root), + '--install-scripts', + str(install_root), + '--install-data', + str(install_root), + '--install-purelib', + str(install_root), + '--install-platlib', + str(install_root), + ] + env = {**os.environ, "__EASYINSTALL_INDEX": mock_index.url} + cp = subprocess.run( + cmd, + cwd=str(project_root), + env=env, + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + encoding="utf-8", + ) + assert cp.returncode != 0 + try: + assert '/does-not-exist/' in {r.path for r in mock_index.requests} + assert next( + line + for line in cp.stdout.splitlines() + if "not find suitable distribution for" in line + and "does-not-exist" in line + ) + except Exception: + if "failed to get random numbers" in cp.stdout: + pytest.xfail(f"{sys.platform} failure - {cp.stdout}") + raise + + def create_project(self, root): + config = """ + [metadata] + name = project + version = 42 + + [options] + install_requires = does-not-exist + py_modules = mod + """ + (root / 'setup.cfg').write_text(DALS(config), encoding="utf-8") + (root / 'mod.py').touch() + + +class TestSetupRequires: + def test_setup_requires_honors_fetch_params(self, mock_index, monkeypatch): + """ + When easy_install installs a source distribution which specifies + setup_requires, it should honor the fetch parameters (such as + index-url, and find-links). + """ + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + monkeypatch.setenv('PIP_NO_INDEX', 'false') + with contexts.quiet(): + # create an sdist that has a build-time dependency. + with TestSetupRequires.create_sdist() as dist_file: + with contexts.tempdir() as temp_install_dir: + with contexts.environment(PYTHONPATH=temp_install_dir): + cmd = [ + sys.executable, + '-c', + '__import__("setuptools").setup()', + 'easy_install', + '--index-url', + mock_index.url, + '--exclude-scripts', + '--install-dir', + temp_install_dir, + dist_file, + ] + subprocess.Popen(cmd).wait() + # there should have been one requests to the server + assert [r.path for r in mock_index.requests] == ['/does-not-exist/'] + + @staticmethod + @contextlib.contextmanager + def create_sdist(): + """ + Return an sdist with a setup_requires dependency (of something that + doesn't exist) + """ + with contexts.tempdir() as dir: + dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz') + make_sdist( + dist_path, + [ + ( + 'setup.py', + DALS( + """ + import setuptools + setuptools.setup( + name="setuptools-test-fetcher", + version="1.0", + setup_requires = ['does-not-exist'], + ) + """ + ), + ), + ('setup.cfg', ''), + ], + ) + yield dist_path + + use_setup_cfg = ( + (), + ('dependency_links',), + ('setup_requires',), + ('dependency_links', 'setup_requires'), + ) + + @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg) + def test_setup_requires_overrides_version_conflict(self, use_setup_cfg): + """ + Regression test for distribution issue 323: + https://bitbucket.org/tarek/distribute/issues/323 + + Ensures that a distribution's setup_requires requirements can still be + installed and used locally even if a conflicting version of that + requirement is already on the path. + """ + + fake_dist = PRDistribution( + 'does-not-matter', project_name='foobar', version='0.0' + ) + working_set.add(fake_dist) + + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + test_pkg = create_setup_requires_package( + temp_dir, use_setup_cfg=use_setup_cfg + ) + test_setup_py = os.path.join(test_pkg, 'setup.py') + with contexts.quiet() as (stdout, _stderr): + # Don't even need to install the package, just + # running the setup.py at all is sufficient + run_setup(test_setup_py, ['--name']) + + lines = stdout.readlines() + assert len(lines) > 0 + assert lines[-1].strip() == 'test_pkg' + + @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg) + def test_setup_requires_override_nspkg(self, use_setup_cfg): + """ + Like ``test_setup_requires_overrides_version_conflict`` but where the + ``setup_requires`` package is part of a namespace package that has + *already* been imported. + """ + + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + foobar_1_archive = os.path.join(temp_dir, 'foo_bar-0.1.tar.gz') + make_nspkg_sdist(foobar_1_archive, 'foo.bar', '0.1') + # Now actually go ahead an extract to the temp dir and add the + # extracted path to sys.path so foo.bar v0.1 is importable + foobar_1_dir = os.path.join(temp_dir, 'foo_bar-0.1') + os.mkdir(foobar_1_dir) + with tarfile.open(foobar_1_archive) as tf: + tf.extraction_filter = lambda member, path: member + tf.extractall(foobar_1_dir) + sys.path.insert(1, foobar_1_dir) + + dist = PRDistribution( + foobar_1_dir, project_name='foo.bar', version='0.1' + ) + working_set.add(dist) + + template = DALS( + """\ + import foo # Even with foo imported first the + # setup_requires package should override + import setuptools + setuptools.setup(**%r) + + if not (hasattr(foo, '__path__') and + len(foo.__path__) == 2): + print('FAIL') + + if 'foo_bar-0.2' not in foo.__path__[0]: + print('FAIL') + """ + ) + + test_pkg = create_setup_requires_package( + temp_dir, + 'foo.bar', + '0.2', + make_nspkg_sdist, + template, + use_setup_cfg=use_setup_cfg, + ) + + test_setup_py = os.path.join(test_pkg, 'setup.py') + + with contexts.quiet() as (stdout, _stderr): + try: + # Don't even need to install the package, just + # running the setup.py at all is sufficient + run_setup(test_setup_py, ['--name']) + except pkg_resources.VersionConflict: # pragma: nocover + pytest.fail( + 'Installing setup.py requirements caused a VersionConflict' + ) + + assert 'FAIL' not in stdout.getvalue() + lines = stdout.readlines() + assert len(lines) > 0 + assert lines[-1].strip() == 'test_pkg' + + @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg) + def test_setup_requires_with_attr_version(self, use_setup_cfg): + def make_dependency_sdist(dist_path, distname, version): + files = [ + ( + 'setup.py', + DALS( + f""" + import setuptools + setuptools.setup( + name={distname!r}, + version={version!r}, + py_modules=[{distname!r}], + ) + """ + ), + ), + ( + distname + '.py', + DALS( + """ + version = 42 + """ + ), + ), + ] + make_sdist(dist_path, files) + + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + test_pkg = create_setup_requires_package( + temp_dir, + setup_attrs=dict(version='attr: foobar.version'), + make_package=make_dependency_sdist, + use_setup_cfg=use_setup_cfg + ('version',), + ) + test_setup_py = os.path.join(test_pkg, 'setup.py') + with contexts.quiet() as (stdout, _stderr): + run_setup(test_setup_py, ['--version']) + lines = stdout.readlines() + assert len(lines) > 0 + assert lines[-1].strip() == '42' + + def test_setup_requires_honors_pip_env(self, mock_index, monkeypatch): + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + monkeypatch.setenv('PIP_NO_INDEX', 'false') + monkeypatch.setenv('PIP_INDEX_URL', mock_index.url) + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + test_pkg = create_setup_requires_package( + temp_dir, + 'python-xlib', + '0.19', + setup_attrs=dict(dependency_links=[]), + ) + test_setup_cfg = os.path.join(test_pkg, 'setup.cfg') + with open(test_setup_cfg, 'w', encoding="utf-8") as fp: + fp.write( + DALS( + """ + [easy_install] + index_url = https://pypi.org/legacy/ + """ + ) + ) + test_setup_py = os.path.join(test_pkg, 'setup.py') + with pytest.raises(distutils.errors.DistutilsError): + run_setup(test_setup_py, ['--version']) + assert len(mock_index.requests) == 1 + assert mock_index.requests[0].path == '/python-xlib/' + + def test_setup_requires_with_pep508_url(self, mock_index, monkeypatch): + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + monkeypatch.setenv('PIP_INDEX_URL', mock_index.url) + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + dep_sdist = os.path.join(temp_dir, 'dep.tar.gz') + make_trivial_sdist(dep_sdist, 'dependency', '42') + dep_url = path_to_url(dep_sdist, authority='localhost') + test_pkg = create_setup_requires_package( + temp_dir, + # Ignored (overridden by setup_attrs) + 'python-xlib', + '0.19', + setup_attrs=dict(setup_requires=f'dependency @ {dep_url}'), + ) + test_setup_py = os.path.join(test_pkg, 'setup.py') + run_setup(test_setup_py, ['--version']) + assert len(mock_index.requests) == 0 + + def test_setup_requires_with_allow_hosts(self, mock_index): + """The `allow-hosts` option in not supported anymore.""" + files = { + 'test_pkg': { + 'setup.py': DALS( + """ + from setuptools import setup + setup(setup_requires='python-xlib') + """ + ), + 'setup.cfg': DALS( + """ + [easy_install] + allow_hosts = * + """ + ), + } + } + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + path.build(files, prefix=temp_dir) + setup_py = str(pathlib.Path(temp_dir, 'test_pkg', 'setup.py')) + with pytest.raises(distutils.errors.DistutilsError): + run_setup(setup_py, ['--version']) + assert len(mock_index.requests) == 0 + + def test_setup_requires_with_python_requires(self, monkeypatch, tmpdir): + """Check `python_requires` is honored.""" + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + monkeypatch.setenv('PIP_NO_INDEX', '1') + monkeypatch.setenv('PIP_VERBOSE', '1') + dep_1_0_sdist = 'dep-1.0.tar.gz' + dep_1_0_url = path_to_url(str(tmpdir / dep_1_0_sdist)) + dep_1_0_python_requires = '>=2.7' + make_python_requires_sdist( + str(tmpdir / dep_1_0_sdist), 'dep', '1.0', dep_1_0_python_requires + ) + dep_2_0_sdist = 'dep-2.0.tar.gz' + dep_2_0_url = path_to_url(str(tmpdir / dep_2_0_sdist)) + dep_2_0_python_requires = ( + f'!={sys.version_info.major}.{sys.version_info.minor}.*' + ) + make_python_requires_sdist( + str(tmpdir / dep_2_0_sdist), 'dep', '2.0', dep_2_0_python_requires + ) + index = tmpdir / 'index.html' + index.write_text( + DALS( + """ + + Links for dep + +

Links for dep

+ {dep_1_0_sdist}
+ {dep_2_0_sdist}
+ + + """ + ).format( + dep_1_0_url=dep_1_0_url, + dep_1_0_sdist=dep_1_0_sdist, + dep_1_0_python_requires=dep_1_0_python_requires, + dep_2_0_url=dep_2_0_url, + dep_2_0_sdist=dep_2_0_sdist, + dep_2_0_python_requires=dep_2_0_python_requires, + ), + 'utf-8', + ) + index_url = path_to_url(str(index)) + with contexts.save_pkg_resources_state(): + test_pkg = create_setup_requires_package( + str(tmpdir), + 'python-xlib', + '0.19', # Ignored (overridden by setup_attrs). + setup_attrs=dict(setup_requires='dep', dependency_links=[index_url]), + ) + test_setup_py = os.path.join(test_pkg, 'setup.py') + run_setup(test_setup_py, ['--version']) + eggs = list( + map(str, pkg_resources.find_distributions(os.path.join(test_pkg, '.eggs'))) + ) + assert eggs == ['dep 1.0'] + + @pytest.mark.parametrize('with_dependency_links_in_setup_py', (False, True)) + def test_setup_requires_with_find_links_in_setup_cfg( + self, monkeypatch, with_dependency_links_in_setup_py + ): + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + make_trivial_sdist( + os.path.join(temp_dir, 'python-xlib-42.tar.gz'), 'python-xlib', '42' + ) + test_pkg = os.path.join(temp_dir, 'test_pkg') + test_setup_py = os.path.join(test_pkg, 'setup.py') + test_setup_cfg = os.path.join(test_pkg, 'setup.cfg') + os.mkdir(test_pkg) + with open(test_setup_py, 'w', encoding="utf-8") as fp: + if with_dependency_links_in_setup_py: + dependency_links = [os.path.join(temp_dir, 'links')] + else: + dependency_links = [] + fp.write( + DALS( + """ + from setuptools import installer, setup + setup(setup_requires='python-xlib==42', + dependency_links={dependency_links!r}) + """ + ).format(dependency_links=dependency_links) + ) + with open(test_setup_cfg, 'w', encoding="utf-8") as fp: + fp.write( + DALS( + """ + [easy_install] + index_url = {index_url} + find_links = {find_links} + """ + ).format( + index_url=os.path.join(temp_dir, 'index'), + find_links=temp_dir, + ) + ) + run_setup(test_setup_py, ['--version']) + + def test_setup_requires_with_transitive_extra_dependency(self, monkeypatch): + """ + Use case: installing a package with a build dependency on + an already installed `dep[extra]`, which in turn depends + on `extra_dep` (whose is not already installed). + """ + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + # Create source distribution for `extra_dep`. + make_trivial_sdist( + os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'), 'extra_dep', '1.0' + ) + # Create source tree for `dep`. + dep_pkg = os.path.join(temp_dir, 'dep') + os.mkdir(dep_pkg) + path.build( + { + 'setup.py': DALS( + """ + import setuptools + setuptools.setup( + name='dep', version='2.0', + extras_require={'extra': ['extra_dep']}, + ) + """ + ), + 'setup.cfg': '', + }, + prefix=dep_pkg, + ) + # "Install" dep. + run_setup(os.path.join(dep_pkg, 'setup.py'), ['dist_info']) + working_set.add_entry(dep_pkg) + # Create source tree for test package. + test_pkg = os.path.join(temp_dir, 'test_pkg') + test_setup_py = os.path.join(test_pkg, 'setup.py') + os.mkdir(test_pkg) + with open(test_setup_py, 'w', encoding="utf-8") as fp: + fp.write( + DALS( + """ + from setuptools import installer, setup + setup(setup_requires='dep[extra]') + """ + ) + ) + # Check... + monkeypatch.setenv('PIP_FIND_LINKS', str(temp_dir)) + monkeypatch.setenv('PIP_NO_INDEX', '1') + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + run_setup(test_setup_py, ['--version']) + + def test_setup_requires_with_distutils_command_dep(self, monkeypatch): + """ + Use case: ensure build requirements' extras + are properly installed and activated. + """ + with contexts.save_pkg_resources_state(): + with contexts.tempdir() as temp_dir: + # Create source distribution for `extra_dep`. + make_sdist( + os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'), + [ + ( + 'setup.py', + DALS( + """ + import setuptools + setuptools.setup( + name='extra_dep', + version='1.0', + py_modules=['extra_dep'], + ) + """ + ), + ), + ('setup.cfg', ''), + ('extra_dep.py', ''), + ], + ) + # Create source tree for `epdep`. + dep_pkg = os.path.join(temp_dir, 'epdep') + os.mkdir(dep_pkg) + path.build( + { + 'setup.py': DALS( + """ + import setuptools + setuptools.setup( + name='dep', version='2.0', + py_modules=['epcmd'], + extras_require={'extra': ['extra_dep']}, + entry_points=''' + [distutils.commands] + epcmd = epcmd:epcmd [extra] + ''', + ) + """ + ), + 'setup.cfg': '', + 'epcmd.py': DALS( + """ + from distutils.command.build_py import build_py + + import extra_dep + + class epcmd(build_py): + pass + """ + ), + }, + prefix=dep_pkg, + ) + # "Install" dep. + run_setup(os.path.join(dep_pkg, 'setup.py'), ['dist_info']) + working_set.add_entry(dep_pkg) + # Create source tree for test package. + test_pkg = os.path.join(temp_dir, 'test_pkg') + test_setup_py = os.path.join(test_pkg, 'setup.py') + os.mkdir(test_pkg) + with open(test_setup_py, 'w', encoding="utf-8") as fp: + fp.write( + DALS( + """ + from setuptools import installer, setup + setup(setup_requires='dep[extra]') + """ + ) + ) + # Check... + monkeypatch.setenv('PIP_FIND_LINKS', str(temp_dir)) + monkeypatch.setenv('PIP_NO_INDEX', '1') + monkeypatch.setenv('PIP_RETRIES', '0') + monkeypatch.setenv('PIP_TIMEOUT', '0') + run_setup(test_setup_py, ['epcmd']) + + +def make_trivial_sdist(dist_path, distname, version): + """ + Create a simple sdist tarball at dist_path, containing just a simple + setup.py. + """ + + make_sdist( + dist_path, + [ + ( + 'setup.py', + DALS( + f"""\ + import setuptools + setuptools.setup( + name={distname!r}, + version={version!r} + ) + """ + ), + ), + ('setup.cfg', ''), + ], + ) + + +def make_nspkg_sdist(dist_path, distname, version): + """ + Make an sdist tarball with distname and version which also contains one + package with the same name as distname. The top-level package is + designated a namespace package). + """ + # Assert that the distname contains at least one period + assert '.' in distname + + parts = distname.split('.') + nspackage = parts[0] + + packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)] + + setup_py = DALS( + f"""\ + import setuptools + setuptools.setup( + name={distname!r}, + version={version!r}, + packages={packages!r}, + namespace_packages=[{nspackage!r}] + ) + """ + ) + + init = "__import__('pkg_resources').declare_namespace(__name__)" + + files = [('setup.py', setup_py), (os.path.join(nspackage, '__init__.py'), init)] + for package in packages[1:]: + filename = os.path.join(*(package.split('.') + ['__init__.py'])) + files.append((filename, '')) + + make_sdist(dist_path, files) + + +def make_python_requires_sdist(dist_path, distname, version, python_requires): + make_sdist( + dist_path, + [ + ( + 'setup.py', + DALS( + """\ + import setuptools + setuptools.setup( + name={name!r}, + version={version!r}, + python_requires={python_requires!r}, + ) + """ + ).format( + name=distname, version=version, python_requires=python_requires + ), + ), + ('setup.cfg', ''), + ], + ) + + +def make_sdist(dist_path, files): + """ + Create a simple sdist tarball at dist_path, containing the files + listed in ``files`` as ``(filename, content)`` tuples. + """ + + # Distributions with only one file don't play well with pip. + assert len(files) > 1 + with tarfile.open(dist_path, 'w:gz') as dist: + for filename, content in files: + file_bytes = io.BytesIO(content.encode('utf-8')) + file_info = tarfile.TarInfo(name=filename) + file_info.size = len(file_bytes.getvalue()) + file_info.mtime = int(time.time()) + dist.addfile(file_info, fileobj=file_bytes) + + +def create_setup_requires_package( + path, + distname='foobar', + version='0.1', + make_package=make_trivial_sdist, + setup_py_template=None, + setup_attrs=None, + use_setup_cfg=(), +): + """Creates a source tree under path for a trivial test package that has a + single requirement in setup_requires--a tarball for that requirement is + also created and added to the dependency_links argument. + + ``distname`` and ``version`` refer to the name/version of the package that + the test package requires via ``setup_requires``. The name of the test + package itself is just 'test_pkg'. + """ + + normalized_distname = safer_name(distname) + test_setup_attrs = { + 'name': 'test_pkg', + 'version': '0.0', + 'setup_requires': [f'{normalized_distname}=={version}'], + 'dependency_links': [os.path.abspath(path)], + } + if setup_attrs: + test_setup_attrs.update(setup_attrs) + + test_pkg = os.path.join(path, 'test_pkg') + os.mkdir(test_pkg) + + # setup.cfg + if use_setup_cfg: + options = [] + metadata = [] + for name in use_setup_cfg: + value = test_setup_attrs.pop(name) + if name in 'name version'.split(): + section = metadata + else: + section = options + if isinstance(value, (tuple, list)): + value = ';'.join(value) + section.append(f'{name}: {value}') + test_setup_cfg_contents = DALS( + """ + [metadata] + {metadata} + [options] + {options} + """ + ).format( + options='\n'.join(options), + metadata='\n'.join(metadata), + ) + else: + test_setup_cfg_contents = '' + with open(os.path.join(test_pkg, 'setup.cfg'), 'w', encoding="utf-8") as f: + f.write(test_setup_cfg_contents) + + # setup.py + if setup_py_template is None: + setup_py_template = DALS( + """\ + import setuptools + setuptools.setup(**%r) + """ + ) + with open(os.path.join(test_pkg, 'setup.py'), 'w', encoding="utf-8") as f: + f.write(setup_py_template % test_setup_attrs) + + foobar_path = os.path.join(path, f'{normalized_distname}-{version}.tar.gz') + make_package(foobar_path, distname, version) + + return test_pkg + + +@pytest.mark.skipif( + sys.platform.startswith('java') and ei.is_sh(sys.executable), + reason="Test cannot run under java when executable is sh", +) +class TestScriptHeader: + non_ascii_exe = '/Users/José/bin/python' + exe_with_spaces = r'C:\Program Files\Python36\python.exe' + + def test_get_script_header(self): + expected = f'#!{ei.nt_quote_arg(os.path.normpath(sys.executable))}\n' + actual = ei.ScriptWriter.get_header('#!/usr/local/bin/python') + assert actual == expected + + def test_get_script_header_args(self): + expected = f'#!{ei.nt_quote_arg(os.path.normpath(sys.executable))} -x\n' + actual = ei.ScriptWriter.get_header('#!/usr/bin/python -x') + assert actual == expected + + def test_get_script_header_non_ascii_exe(self): + actual = ei.ScriptWriter.get_header( + '#!/usr/bin/python', executable=self.non_ascii_exe + ) + expected = f'#!{self.non_ascii_exe} -x\n' + assert actual == expected + + def test_get_script_header_exe_with_spaces(self): + actual = ei.ScriptWriter.get_header( + '#!/usr/bin/python', executable='"' + self.exe_with_spaces + '"' + ) + expected = f'#!"{self.exe_with_spaces}"\n' + assert actual == expected + + +class TestCommandSpec: + def test_custom_launch_command(self): + """ + Show how a custom CommandSpec could be used to specify a #! executable + which takes parameters. + """ + cmd = ei.CommandSpec(['/usr/bin/env', 'python3']) + assert cmd.as_header() == '#!/usr/bin/env python3\n' + + def test_from_param_for_CommandSpec_is_passthrough(self): + """ + from_param should return an instance of a CommandSpec + """ + cmd = ei.CommandSpec(['python']) + cmd_new = ei.CommandSpec.from_param(cmd) + assert cmd is cmd_new + + @mock.patch('sys.executable', TestScriptHeader.exe_with_spaces) + @mock.patch.dict(os.environ) + def test_from_environment_with_spaces_in_executable(self): + os.environ.pop('__PYVENV_LAUNCHER__', None) + cmd = ei.CommandSpec.from_environment() + assert len(cmd) == 1 + assert cmd.as_header().startswith('#!"') + + def test_from_simple_string_uses_shlex(self): + """ + In order to support `executable = /usr/bin/env my-python`, make sure + from_param invokes shlex on that input. + """ + cmd = ei.CommandSpec.from_param('/usr/bin/env my-python') + assert len(cmd) == 2 + assert '"' not in cmd.as_header() + + def test_from_param_raises_expected_error(self) -> None: + """ + from_param should raise its own TypeError when the argument's type is unsupported + """ + with pytest.raises(TypeError) as exc_info: + ei.CommandSpec.from_param(object()) # type: ignore[arg-type] # We want a type error here + assert ( + str(exc_info.value) == "Argument has an unsupported type " + ), exc_info.value + + +class TestWindowsScriptWriter: + def test_header(self): + hdr = ei.WindowsScriptWriter.get_header('') + assert hdr.startswith('#!') + assert hdr.endswith('\n') + hdr = hdr.lstrip('#!') + hdr = hdr.rstrip('\n') + # header should not start with an escaped quote + assert not hdr.startswith('\\"') + + +class VersionStub(NamedTuple): + major: int + minor: int + micro: int + releaselevel: str + serial: int + + +def test_use_correct_python_version_string(tmpdir, tmpdir_cwd, monkeypatch): + # In issue #3001, easy_install wrongly uses the `python3.1` directory + # when the interpreter is `python3.10` and the `--user` option is given. + # See pypa/setuptools#3001. + dist = Distribution() + cmd = dist.get_command_obj('easy_install') + cmd.args = ['ok'] + cmd.optimize = 0 + cmd.user = True + cmd.install_userbase = str(tmpdir) + cmd.install_usersite = None + install_cmd = dist.get_command_obj('install') + install_cmd.install_userbase = str(tmpdir) + install_cmd.install_usersite = None + + with monkeypatch.context() as patch, warnings.catch_warnings(): + warnings.simplefilter("ignore") + version = '3.10.1 (main, Dec 21 2021, 09:17:12) [GCC 10.2.1 20210110]' + info = VersionStub(3, 10, 1, "final", 0) + patch.setattr('site.ENABLE_USER_SITE', True) + patch.setattr('sys.version', version) + patch.setattr('sys.version_info', info) + patch.setattr(cmd, 'create_home_path', mock.Mock()) + cmd.finalize_options() + + name = "pypy" if hasattr(sys, 'pypy_version_info') else "python" + install_dir = cmd.install_dir.lower() + + # In some platforms (e.g. Windows), install_dir is mostly determined + # via `sysconfig`, which define constants eagerly at module creation. + # This means that monkeypatching `sys.version` to emulate 3.10 for testing + # may have no effect. + # The safest test here is to rely on the fact that 3.1 is no longer + # supported/tested, and make sure that if 'python3.1' ever appears in the string + # it is followed by another digit (e.g. 'python3.10'). + if re.search(name + r'3\.?1', install_dir): + assert re.search(name + r'3\.?1\d', install_dir) + + # The following "variables" are used for interpolation in distutils + # installation schemes, so it should be fair to treat them as "semi-public", + # or at least public enough so we can have a test to make sure they are correct + assert cmd.config_vars['py_version'] == '3.10.1' + assert cmd.config_vars['py_version_short'] == '3.10' + assert cmd.config_vars['py_version_nodot'] == '310' + + +@pytest.mark.xfail( + sys.platform == "darwin", + reason="https://github.com/pypa/setuptools/pull/4716#issuecomment-2447624418", +) +def test_editable_user_and_build_isolation(setup_context, monkeypatch, tmp_path): + """`setup.py develop` should honor `--user` even under build isolation""" + + # == Arrange == + # Pretend that build isolation was enabled + # e.g pip sets the environment variable PYTHONNOUSERSITE=1 + monkeypatch.setattr('site.ENABLE_USER_SITE', False) + + # Patching $HOME for 2 reasons: + # 1. setuptools/command/easy_install.py:create_home_path + # tries creating directories in $HOME. + # Given:: + # self.config_vars['DESTDIRS'] = ( + # "/home/user/.pyenv/versions/3.9.10 " + # "/home/user/.pyenv/versions/3.9.10/lib " + # "/home/user/.pyenv/versions/3.9.10/lib/python3.9 " + # "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload") + # `create_home_path` will:: + # makedirs( + # "/home/user/.pyenv/versions/3.9.10 " + # "/home/user/.pyenv/versions/3.9.10/lib " + # "/home/user/.pyenv/versions/3.9.10/lib/python3.9 " + # "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload") + # + # 2. We are going to force `site` to update site.USER_BASE and site.USER_SITE + # To point inside our new home + monkeypatch.setenv('HOME', str(tmp_path / '.home')) + monkeypatch.setenv('USERPROFILE', str(tmp_path / '.home')) + monkeypatch.setenv('APPDATA', str(tmp_path / '.home')) + monkeypatch.setattr('site.USER_BASE', None) + monkeypatch.setattr('site.USER_SITE', None) + user_site = Path(site.getusersitepackages()) + user_site.mkdir(parents=True, exist_ok=True) + + sys_prefix = tmp_path / '.sys_prefix' + sys_prefix.mkdir(parents=True, exist_ok=True) + monkeypatch.setattr('sys.prefix', str(sys_prefix)) + + setup_script = ( + "__import__('setuptools').setup(name='aproj', version=42, packages=[])\n" + ) + (tmp_path / "setup.py").write_text(setup_script, encoding="utf-8") + + # == Sanity check == + assert list(sys_prefix.glob("*")) == [] + assert list(user_site.glob("*")) == [] + + # == Act == + run_setup('setup.py', ['develop', '--user']) + + # == Assert == + # Should not install to sys.prefix + assert list(sys_prefix.glob("*")) == [] + # Should install to user site + installed = {f.name for f in user_site.glob("*")} + # sometimes easy-install.pth is created and sometimes not + installed = installed - {"easy-install.pth"} + assert installed == {'aproj.egg-link'} diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py new file mode 100644 index 0000000000000000000000000000000000000000..038dcadf934af20dbe11dcb13ba324ceb30bf90d --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_editable_install.py @@ -0,0 +1,1289 @@ +from __future__ import annotations + +import os +import platform +import stat +import subprocess +import sys +from copy import deepcopy +from importlib import import_module +from importlib.machinery import EXTENSION_SUFFIXES +from pathlib import Path +from textwrap import dedent +from typing import Any +from unittest.mock import Mock +from uuid import uuid4 + +import jaraco.envs +import jaraco.path +import pytest +from path import Path as _Path + +from setuptools._importlib import resources as importlib_resources +from setuptools.command.editable_wheel import ( + _DebuggingTips, + _encode_pth, + _find_namespaces, + _find_package_roots, + _find_virtual_namespaces, + _finder_template, + _LinkTree, + _TopLevelFinder, + editable_wheel, +) +from setuptools.dist import Distribution +from setuptools.extension import Extension +from setuptools.warnings import SetuptoolsDeprecationWarning + +from . import contexts, namespaces + +from distutils.core import run_setup + + +@pytest.fixture(params=["strict", "lenient"]) +def editable_opts(request): + if request.param == "strict": + return ["--config-settings", "editable-mode=strict"] + return [] + + +EXAMPLE = { + 'pyproject.toml': dedent( + """\ + [build-system] + requires = ["setuptools"] + build-backend = "setuptools.build_meta" + + [project] + name = "mypkg" + version = "3.14159" + license = {text = "MIT"} + description = "This is a Python package" + dynamic = ["readme"] + classifiers = [ + "Development Status :: 5 - Production/Stable", + "Intended Audience :: Developers" + ] + urls = {Homepage = "https://github.com"} + + [tool.setuptools] + package-dir = {"" = "src"} + packages = {find = {where = ["src"]}} + license-files = ["LICENSE*"] + + [tool.setuptools.dynamic] + readme = {file = "README.rst"} + + [tool.distutils.egg_info] + tag-build = ".post0" + """ + ), + "MANIFEST.in": dedent( + """\ + global-include *.py *.txt + global-exclude *.py[cod] + prune dist + prune build + """ + ).strip(), + "README.rst": "This is a ``README``", + "LICENSE.txt": "---- placeholder MIT license ----", + "src": { + "mypkg": { + "__init__.py": dedent( + """\ + import sys + from importlib.metadata import PackageNotFoundError, version + + try: + __version__ = version(__name__) + except PackageNotFoundError: + __version__ = "unknown" + """ + ), + "__main__.py": dedent( + """\ + from importlib.resources import read_text + from . import __version__, __name__ as parent + from .mod import x + + data = read_text(parent, "data.txt") + print(__version__, data, x) + """ + ), + "mod.py": "x = ''", + "data.txt": "Hello World", + } + }, +} + + +SETUP_SCRIPT_STUB = "__import__('setuptools').setup()" + + +@pytest.mark.xfail(sys.platform == "darwin", reason="pypa/setuptools#4328") +@pytest.mark.parametrize( + "files", + [ + {**EXAMPLE, "setup.py": SETUP_SCRIPT_STUB}, + EXAMPLE, # No setup.py script + ], +) +def test_editable_with_pyproject(tmp_path, venv, files, editable_opts): + project = tmp_path / "mypkg" + project.mkdir() + jaraco.path.build(files, prefix=project) + + cmd = [ + "python", + "-m", + "pip", + "install", + "--no-build-isolation", # required to force current version of setuptools + "-e", + str(project), + *editable_opts, + ] + print(venv.run(cmd)) + + cmd = ["python", "-m", "mypkg"] + assert venv.run(cmd).strip() == "3.14159.post0 Hello World" + + (project / "src/mypkg/data.txt").write_text("foobar", encoding="utf-8") + (project / "src/mypkg/mod.py").write_text("x = 42", encoding="utf-8") + assert venv.run(cmd).strip() == "3.14159.post0 foobar 42" + + +def test_editable_with_flat_layout(tmp_path, venv, editable_opts): + files = { + "mypkg": { + "pyproject.toml": dedent( + """\ + [build-system] + requires = ["setuptools", "wheel"] + build-backend = "setuptools.build_meta" + + [project] + name = "mypkg" + version = "3.14159" + + [tool.setuptools] + packages = ["pkg"] + py-modules = ["mod"] + """ + ), + "pkg": {"__init__.py": "a = 4"}, + "mod.py": "b = 2", + }, + } + jaraco.path.build(files, prefix=tmp_path) + project = tmp_path / "mypkg" + + cmd = [ + "python", + "-m", + "pip", + "install", + "--no-build-isolation", # required to force current version of setuptools + "-e", + str(project), + *editable_opts, + ] + print(venv.run(cmd)) + cmd = ["python", "-c", "import pkg, mod; print(pkg.a, mod.b)"] + assert venv.run(cmd).strip() == "4 2" + + +def test_editable_with_single_module(tmp_path, venv, editable_opts): + files = { + "mypkg": { + "pyproject.toml": dedent( + """\ + [build-system] + requires = ["setuptools", "wheel"] + build-backend = "setuptools.build_meta" + + [project] + name = "mod" + version = "3.14159" + + [tool.setuptools] + py-modules = ["mod"] + """ + ), + "mod.py": "b = 2", + }, + } + jaraco.path.build(files, prefix=tmp_path) + project = tmp_path / "mypkg" + + cmd = [ + "python", + "-m", + "pip", + "install", + "--no-build-isolation", # required to force current version of setuptools + "-e", + str(project), + *editable_opts, + ] + print(venv.run(cmd)) + cmd = ["python", "-c", "import mod; print(mod.b)"] + assert venv.run(cmd).strip() == "2" + + +class TestLegacyNamespaces: + # legacy => pkg_resources.declare_namespace(...) + setup(namespace_packages=...) + + def test_nspkg_file_is_unique(self, tmp_path, monkeypatch): + deprecation = pytest.warns( + SetuptoolsDeprecationWarning, match=".*namespace_packages parameter.*" + ) + installation_dir = tmp_path / ".installation_dir" + installation_dir.mkdir() + examples = ( + "myns.pkgA", + "myns.pkgB", + "myns.n.pkgA", + "myns.n.pkgB", + ) + + for name in examples: + pkg = namespaces.build_namespace_package(tmp_path, name, version="42") + with deprecation, monkeypatch.context() as ctx: + ctx.chdir(pkg) + dist = run_setup("setup.py", stop_after="config") + cmd = editable_wheel(dist) + cmd.finalize_options() + editable_name = cmd.get_finalized_command("dist_info").name + cmd._install_namespaces(installation_dir, editable_name) + + files = list(installation_dir.glob("*-nspkg.pth")) + assert len(files) == len(examples) + + @pytest.mark.parametrize( + "impl", + ( + "pkg_resources", + # "pkgutil", => does not work + ), + ) + @pytest.mark.parametrize("ns", ("myns.n",)) + def test_namespace_package_importable( + self, venv, tmp_path, ns, impl, editable_opts + ): + """ + Installing two packages sharing the same namespace, one installed + naturally using pip or `--single-version-externally-managed` + and the other installed in editable mode should leave the namespace + intact and both packages reachable by import. + (Ported from test_develop). + """ + build_system = """\ + [build-system] + requires = ["setuptools"] + build-backend = "setuptools.build_meta" + """ + pkg_A = namespaces.build_namespace_package(tmp_path, f"{ns}.pkgA", impl=impl) + pkg_B = namespaces.build_namespace_package(tmp_path, f"{ns}.pkgB", impl=impl) + (pkg_A / "pyproject.toml").write_text(build_system, encoding="utf-8") + (pkg_B / "pyproject.toml").write_text(build_system, encoding="utf-8") + # use pip to install to the target directory + opts = editable_opts[:] + opts.append("--no-build-isolation") # force current version of setuptools + venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts]) + venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts]) + venv.run(["python", "-c", f"import {ns}.pkgA; import {ns}.pkgB"]) + # additionally ensure that pkg_resources import works + venv.run(["python", "-c", "import pkg_resources"]) + + +class TestPep420Namespaces: + def test_namespace_package_importable(self, venv, tmp_path, editable_opts): + """ + Installing two packages sharing the same namespace, one installed + normally using pip and the other installed in editable mode + should allow importing both packages. + """ + pkg_A = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgA') + pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB') + # use pip to install to the target directory + opts = editable_opts[:] + opts.append("--no-build-isolation") # force current version of setuptools + venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts]) + venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts]) + venv.run(["python", "-c", "import myns.n.pkgA; import myns.n.pkgB"]) + + def test_namespace_created_via_package_dir(self, venv, tmp_path, editable_opts): + """Currently users can create a namespace by tweaking `package_dir`""" + files = { + "pkgA": { + "pyproject.toml": dedent( + """\ + [build-system] + requires = ["setuptools", "wheel"] + build-backend = "setuptools.build_meta" + + [project] + name = "pkgA" + version = "3.14159" + + [tool.setuptools] + package-dir = {"myns.n.pkgA" = "src"} + """ + ), + "src": {"__init__.py": "a = 1"}, + }, + } + jaraco.path.build(files, prefix=tmp_path) + pkg_A = tmp_path / "pkgA" + pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB') + pkg_C = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgC') + + # use pip to install to the target directory + opts = editable_opts[:] + opts.append("--no-build-isolation") # force current version of setuptools + venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts]) + venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts]) + venv.run(["python", "-m", "pip", "install", "-e", str(pkg_C), *opts]) + venv.run(["python", "-c", "from myns.n import pkgA, pkgB, pkgC"]) + + def test_namespace_accidental_config_in_lenient_mode(self, venv, tmp_path): + """Sometimes users might specify an ``include`` pattern that ignores parent + packages. In a normal installation this would ignore all modules inside the + parent packages, and make them namespaces (reported in issue #3504), + so the editable mode should preserve this behaviour. + """ + files = { + "pkgA": { + "pyproject.toml": dedent( + """\ + [build-system] + requires = ["setuptools", "wheel"] + build-backend = "setuptools.build_meta" + + [project] + name = "pkgA" + version = "3.14159" + + [tool.setuptools] + packages.find.include = ["mypkg.*"] + """ + ), + "mypkg": { + "__init__.py": "", + "other.py": "b = 1", + "n": { + "__init__.py": "", + "pkgA.py": "a = 1", + }, + }, + "MANIFEST.in": EXAMPLE["MANIFEST.in"], + }, + } + jaraco.path.build(files, prefix=tmp_path) + pkg_A = tmp_path / "pkgA" + + # use pip to install to the target directory + opts = ["--no-build-isolation"] # force current version of setuptools + venv.run(["python", "-m", "pip", "-v", "install", "-e", str(pkg_A), *opts]) + out = venv.run(["python", "-c", "from mypkg.n import pkgA; print(pkgA.a)"]) + assert out.strip() == "1" + cmd = """\ + try: + import mypkg.other + except ImportError: + print("mypkg.other not defined") + """ + out = venv.run(["python", "-c", dedent(cmd)]) + assert "mypkg.other not defined" in out + + +def test_editable_with_prefix(tmp_path, sample_project, editable_opts): + """ + Editable install to a prefix should be discoverable. + """ + prefix = tmp_path / 'prefix' + + # figure out where pip will likely install the package + site_packages_all = [ + prefix / Path(path).relative_to(sys.prefix) + for path in sys.path + if 'site-packages' in path and path.startswith(sys.prefix) + ] + + for sp in site_packages_all: + sp.mkdir(parents=True) + + # install workaround + _addsitedirs(site_packages_all) + + env = dict(os.environ, PYTHONPATH=os.pathsep.join(map(str, site_packages_all))) + cmd = [ + sys.executable, + '-m', + 'pip', + 'install', + '--editable', + str(sample_project), + '--prefix', + str(prefix), + '--no-build-isolation', + *editable_opts, + ] + subprocess.check_call(cmd, env=env) + + # now run 'sample' with the prefix on the PYTHONPATH + bin = 'Scripts' if platform.system() == 'Windows' else 'bin' + exe = prefix / bin / 'sample' + subprocess.check_call([exe], env=env) + + +class TestFinderTemplate: + """This test focus in getting a particular implementation detail right. + If at some point in time the implementation is changed for something different, + this test can be modified or even excluded. + """ + + def install_finder(self, finder): + loc = {} + exec(finder, loc, loc) + loc["install"]() + + def test_packages(self, tmp_path): + files = { + "src1": { + "pkg1": { + "__init__.py": "", + "subpkg": {"mod1.py": "a = 42"}, + }, + }, + "src2": {"mod2.py": "a = 43"}, + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = { + "pkg1": str(tmp_path / "src1/pkg1"), + "mod2": str(tmp_path / "src2/mod2"), + } + template = _finder_template(str(uuid4()), mapping, {}) + + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ("pkg1", "pkg1.subpkg", "pkg1.subpkg.mod1", "mod2"): + sys.modules.pop(mod, None) + + self.install_finder(template) + mod1 = import_module("pkg1.subpkg.mod1") + mod2 = import_module("mod2") + subpkg = import_module("pkg1.subpkg") + + assert mod1.a == 42 + assert mod2.a == 43 + expected = str((tmp_path / "src1/pkg1/subpkg").resolve()) + assert_path(subpkg, expected) + + def test_namespace(self, tmp_path): + files = {"pkg": {"__init__.py": "a = 13", "text.txt": "abc"}} + jaraco.path.build(files, prefix=tmp_path) + + mapping = {"ns.othername": str(tmp_path / "pkg")} + namespaces = {"ns": []} + + template = _finder_template(str(uuid4()), mapping, namespaces) + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ("ns", "ns.othername"): + sys.modules.pop(mod, None) + + self.install_finder(template) + pkg = import_module("ns.othername") + text = importlib_resources.files(pkg) / "text.txt" + + expected = str((tmp_path / "pkg").resolve()) + assert_path(pkg, expected) + assert pkg.a == 13 + + # Make sure resources can also be found + assert text.read_text(encoding="utf-8") == "abc" + + def test_combine_namespaces(self, tmp_path): + files = { + "src1": {"ns": {"pkg1": {"__init__.py": "a = 13"}}}, + "src2": {"ns": {"mod2.py": "b = 37"}}, + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = { + "ns.pkgA": str(tmp_path / "src1/ns/pkg1"), + "ns": str(tmp_path / "src2/ns"), + } + namespaces_ = {"ns": [str(tmp_path / "src1"), str(tmp_path / "src2")]} + template = _finder_template(str(uuid4()), mapping, namespaces_) + + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ("ns", "ns.pkgA", "ns.mod2"): + sys.modules.pop(mod, None) + + self.install_finder(template) + pkgA = import_module("ns.pkgA") + mod2 = import_module("ns.mod2") + + expected = str((tmp_path / "src1/ns/pkg1").resolve()) + assert_path(pkgA, expected) + assert pkgA.a == 13 + assert mod2.b == 37 + + def test_combine_namespaces_nested(self, tmp_path): + """ + Users may attempt to combine namespace packages in a nested way via + ``package_dir`` as shown in pypa/setuptools#4248. + """ + + files = { + "src": {"my_package": {"my_module.py": "a = 13"}}, + "src2": {"my_package2": {"my_module2.py": "b = 37"}}, + } + + stack = jaraco.path.DirectoryStack() + with stack.context(tmp_path): + jaraco.path.build(files) + attrs = { + "script_name": "%PEP 517%", + "package_dir": { + "different_name": "src/my_package", + "different_name.subpkg": "src2/my_package2", + }, + "packages": ["different_name", "different_name.subpkg"], + } + dist = Distribution(attrs) + finder = _TopLevelFinder(dist, str(uuid4())) + code = next(v for k, v in finder.get_implementation() if k.endswith(".py")) + + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in attrs["packages"]: + sys.modules.pop(mod, None) + + self.install_finder(code) + mod1 = import_module("different_name.my_module") + mod2 = import_module("different_name.subpkg.my_module2") + + expected = str((tmp_path / "src/my_package/my_module.py").resolve()) + assert str(Path(mod1.__file__).resolve()) == expected + + expected = str((tmp_path / "src2/my_package2/my_module2.py").resolve()) + assert str(Path(mod2.__file__).resolve()) == expected + + assert mod1.a == 13 + assert mod2.b == 37 + + def test_dynamic_path_computation(self, tmp_path): + # Follows the example in PEP 420 + files = { + "project1": {"parent": {"child": {"one.py": "x = 1"}}}, + "project2": {"parent": {"child": {"two.py": "x = 2"}}}, + "project3": {"parent": {"child": {"three.py": "x = 3"}}}, + } + jaraco.path.build(files, prefix=tmp_path) + mapping = {} + namespaces_ = {"parent": [str(tmp_path / "project1/parent")]} + template = _finder_template(str(uuid4()), mapping, namespaces_) + + mods = (f"parent.child.{name}" for name in ("one", "two", "three")) + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ("parent", "parent.child", "parent.child", *mods): + sys.modules.pop(mod, None) + + self.install_finder(template) + + one = import_module("parent.child.one") + assert one.x == 1 + + with pytest.raises(ImportError): + import_module("parent.child.two") + + sys.path.append(str(tmp_path / "project2")) + two = import_module("parent.child.two") + assert two.x == 2 + + with pytest.raises(ImportError): + import_module("parent.child.three") + + sys.path.append(str(tmp_path / "project3")) + three = import_module("parent.child.three") + assert three.x == 3 + + def test_no_recursion(self, tmp_path): + # See issue #3550 + files = { + "pkg": { + "__init__.py": "from . import pkg", + }, + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = { + "pkg": str(tmp_path / "pkg"), + } + template = _finder_template(str(uuid4()), mapping, {}) + + with contexts.save_paths(), contexts.save_sys_modules(): + sys.modules.pop("pkg", None) + + self.install_finder(template) + with pytest.raises(ImportError, match="pkg"): + import_module("pkg") + + def test_similar_name(self, tmp_path): + files = { + "foo": { + "__init__.py": "", + "bar": { + "__init__.py": "", + }, + }, + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = { + "foo": str(tmp_path / "foo"), + } + template = _finder_template(str(uuid4()), mapping, {}) + + with contexts.save_paths(), contexts.save_sys_modules(): + sys.modules.pop("foo", None) + sys.modules.pop("foo.bar", None) + + self.install_finder(template) + with pytest.raises(ImportError, match="foobar"): + import_module("foobar") + + def test_case_sensitivity(self, tmp_path): + files = { + "foo": { + "__init__.py": "", + "lowercase.py": "x = 1", + "bar": { + "__init__.py": "", + "lowercase.py": "x = 2", + }, + }, + } + jaraco.path.build(files, prefix=tmp_path) + mapping = { + "foo": str(tmp_path / "foo"), + } + template = _finder_template(str(uuid4()), mapping, {}) + with contexts.save_paths(), contexts.save_sys_modules(): + sys.modules.pop("foo", None) + + self.install_finder(template) + with pytest.raises(ImportError, match="'FOO'"): + import_module("FOO") + + with pytest.raises(ImportError, match="'foo\\.LOWERCASE'"): + import_module("foo.LOWERCASE") + + with pytest.raises(ImportError, match="'foo\\.bar\\.Lowercase'"): + import_module("foo.bar.Lowercase") + + with pytest.raises(ImportError, match="'foo\\.BAR'"): + import_module("foo.BAR.lowercase") + + with pytest.raises(ImportError, match="'FOO'"): + import_module("FOO.bar.lowercase") + + mod = import_module("foo.lowercase") + assert mod.x == 1 + + mod = import_module("foo.bar.lowercase") + assert mod.x == 2 + + def test_namespace_case_sensitivity(self, tmp_path): + files = { + "pkg": { + "__init__.py": "a = 13", + "foo": { + "__init__.py": "b = 37", + "bar.py": "c = 42", + }, + }, + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = {"ns.othername": str(tmp_path / "pkg")} + namespaces = {"ns": []} + + template = _finder_template(str(uuid4()), mapping, namespaces) + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ("ns", "ns.othername"): + sys.modules.pop(mod, None) + + self.install_finder(template) + pkg = import_module("ns.othername") + expected = str((tmp_path / "pkg").resolve()) + assert_path(pkg, expected) + assert pkg.a == 13 + + foo = import_module("ns.othername.foo") + assert foo.b == 37 + + bar = import_module("ns.othername.foo.bar") + assert bar.c == 42 + + with pytest.raises(ImportError, match="'NS'"): + import_module("NS.othername.foo") + + with pytest.raises(ImportError, match="'ns\\.othername\\.FOO\\'"): + import_module("ns.othername.FOO") + + with pytest.raises(ImportError, match="'ns\\.othername\\.foo\\.BAR\\'"): + import_module("ns.othername.foo.BAR") + + def test_intermediate_packages(self, tmp_path): + """ + The finder should not import ``fullname`` if the intermediate segments + don't exist (see pypa/setuptools#4019). + """ + files = { + "src": { + "mypkg": { + "__init__.py": "", + "config.py": "a = 13", + "helloworld.py": "b = 13", + "components": { + "config.py": "a = 37", + }, + }, + } + } + jaraco.path.build(files, prefix=tmp_path) + + mapping = {"mypkg": str(tmp_path / "src/mypkg")} + template = _finder_template(str(uuid4()), mapping, {}) + + with contexts.save_paths(), contexts.save_sys_modules(): + for mod in ( + "mypkg", + "mypkg.config", + "mypkg.helloworld", + "mypkg.components", + "mypkg.components.config", + "mypkg.components.helloworld", + ): + sys.modules.pop(mod, None) + + self.install_finder(template) + + config = import_module("mypkg.components.config") + assert config.a == 37 + + helloworld = import_module("mypkg.helloworld") + assert helloworld.b == 13 + + with pytest.raises(ImportError): + import_module("mypkg.components.helloworld") + + +def test_pkg_roots(tmp_path): + """This test focus in getting a particular implementation detail right. + If at some point in time the implementation is changed for something different, + this test can be modified or even excluded. + """ + files = { + "a": {"b": {"__init__.py": "ab = 1"}, "__init__.py": "a = 1"}, + "d": {"__init__.py": "d = 1", "e": {"__init__.py": "de = 1"}}, + "f": {"g": {"h": {"__init__.py": "fgh = 1"}}}, + "other": {"__init__.py": "abc = 1"}, + "another": {"__init__.py": "abcxyz = 1"}, + "yet_another": {"__init__.py": "mnopq = 1"}, + } + jaraco.path.build(files, prefix=tmp_path) + package_dir = { + "a.b.c": "other", + "a.b.c.x.y.z": "another", + "m.n.o.p.q": "yet_another", + } + packages = [ + "a", + "a.b", + "a.b.c", + "a.b.c.x.y", + "a.b.c.x.y.z", + "d", + "d.e", + "f", + "f.g", + "f.g.h", + "m.n.o.p.q", + ] + roots = _find_package_roots(packages, package_dir, tmp_path) + assert roots == { + "a": str(tmp_path / "a"), + "a.b.c": str(tmp_path / "other"), + "a.b.c.x.y.z": str(tmp_path / "another"), + "d": str(tmp_path / "d"), + "f": str(tmp_path / "f"), + "m.n.o.p.q": str(tmp_path / "yet_another"), + } + + ns = set(dict(_find_namespaces(packages, roots))) + assert ns == {"f", "f.g"} + + ns = set(_find_virtual_namespaces(roots)) + assert ns == {"a.b", "a.b.c.x", "a.b.c.x.y", "m", "m.n", "m.n.o", "m.n.o.p"} + + +class TestOverallBehaviour: + PYPROJECT = """\ + [build-system] + requires = ["setuptools"] + build-backend = "setuptools.build_meta" + + [project] + name = "mypkg" + version = "3.14159" + """ + + # Any: Would need a TypedDict. Keep it simple for tests + FLAT_LAYOUT: dict[str, Any] = { + "pyproject.toml": dedent(PYPROJECT), + "MANIFEST.in": EXAMPLE["MANIFEST.in"], + "otherfile.py": "", + "mypkg": { + "__init__.py": "", + "mod1.py": "var = 42", + "subpackage": { + "__init__.py": "", + "mod2.py": "var = 13", + "resource_file.txt": "resource 39", + }, + }, + } + + EXAMPLES = { + "flat-layout": FLAT_LAYOUT, + "src-layout": { + "pyproject.toml": dedent(PYPROJECT), + "MANIFEST.in": EXAMPLE["MANIFEST.in"], + "otherfile.py": "", + "src": {"mypkg": FLAT_LAYOUT["mypkg"]}, + }, + "custom-layout": { + "pyproject.toml": dedent(PYPROJECT) + + dedent( + """\ + [tool.setuptools] + packages = ["mypkg", "mypkg.subpackage"] + + [tool.setuptools.package-dir] + "mypkg.subpackage" = "other" + """ + ), + "MANIFEST.in": EXAMPLE["MANIFEST.in"], + "otherfile.py": "", + "mypkg": { + "__init__.py": "", + "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"], + }, + "other": FLAT_LAYOUT["mypkg"]["subpackage"], + }, + "namespace": { + "pyproject.toml": dedent(PYPROJECT), + "MANIFEST.in": EXAMPLE["MANIFEST.in"], + "otherfile.py": "", + "src": { + "mypkg": { + "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"], + "subpackage": FLAT_LAYOUT["mypkg"]["subpackage"], + }, + }, + }, + } + + @pytest.mark.xfail(sys.platform == "darwin", reason="pypa/setuptools#4328") + @pytest.mark.parametrize("layout", EXAMPLES.keys()) + def test_editable_install(self, tmp_path, venv, layout, editable_opts): + project, _ = install_project( + "mypkg", venv, tmp_path, self.EXAMPLES[layout], *editable_opts + ) + + # Ensure stray files are not importable + cmd_import_error = """\ + try: + import otherfile + except ImportError as ex: + print(ex) + """ + out = venv.run(["python", "-c", dedent(cmd_import_error)]) + assert "No module named 'otherfile'" in out + + # Ensure the modules are importable + cmd_get_vars = """\ + import mypkg, mypkg.mod1, mypkg.subpackage.mod2 + print(mypkg.mod1.var, mypkg.subpackage.mod2.var) + """ + out = venv.run(["python", "-c", dedent(cmd_get_vars)]) + assert "42 13" in out + + # Ensure resources are reachable + cmd_get_resource = """\ + import mypkg.subpackage + from setuptools._importlib import resources as importlib_resources + text = importlib_resources.files(mypkg.subpackage) / "resource_file.txt" + print(text.read_text(encoding="utf-8")) + """ + out = venv.run(["python", "-c", dedent(cmd_get_resource)]) + assert "resource 39" in out + + # Ensure files are editable + mod1 = next(project.glob("**/mod1.py")) + mod2 = next(project.glob("**/mod2.py")) + resource_file = next(project.glob("**/resource_file.txt")) + + mod1.write_text("var = 17", encoding="utf-8") + mod2.write_text("var = 781", encoding="utf-8") + resource_file.write_text("resource 374", encoding="utf-8") + + out = venv.run(["python", "-c", dedent(cmd_get_vars)]) + assert "42 13" not in out + assert "17 781" in out + + out = venv.run(["python", "-c", dedent(cmd_get_resource)]) + assert "resource 39" not in out + assert "resource 374" in out + + +class TestLinkTree: + FILES = deepcopy(TestOverallBehaviour.EXAMPLES["src-layout"]) + FILES["pyproject.toml"] += dedent( + """\ + [tool.setuptools] + # Temporary workaround: both `include-package-data` and `package-data` configs + # can be removed after #3260 is fixed. + include-package-data = false + package-data = {"*" = ["*.txt"]} + + [tool.setuptools.packages.find] + where = ["src"] + exclude = ["*.subpackage*"] + """ + ) + FILES["src"]["mypkg"]["resource.not_in_manifest"] = "abc" + + def test_generated_tree(self, tmp_path): + jaraco.path.build(self.FILES, prefix=tmp_path) + + with _Path(tmp_path): + name = "mypkg-3.14159" + dist = Distribution({"script_name": "%PEP 517%"}) + dist.parse_config_files() + + wheel = Mock() + aux = tmp_path / ".aux" + build = tmp_path / ".build" + aux.mkdir() + build.mkdir() + + build_py = dist.get_command_obj("build_py") + build_py.editable_mode = True + build_py.build_lib = str(build) + build_py.ensure_finalized() + outputs = build_py.get_outputs() + output_mapping = build_py.get_output_mapping() + + make_tree = _LinkTree(dist, name, aux, build) + make_tree(wheel, outputs, output_mapping) + + mod1 = next(aux.glob("**/mod1.py")) + expected = tmp_path / "src/mypkg/mod1.py" + assert_link_to(mod1, expected) + + assert next(aux.glob("**/subpackage"), None) is None + assert next(aux.glob("**/mod2.py"), None) is None + assert next(aux.glob("**/resource_file.txt"), None) is None + + assert next(aux.glob("**/resource.not_in_manifest"), None) is None + + def test_strict_install(self, tmp_path, venv): + opts = ["--config-settings", "editable-mode=strict"] + install_project("mypkg", venv, tmp_path, self.FILES, *opts) + + out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"]) + assert "42" in out + + # Ensure packages excluded from distribution are not importable + cmd_import_error = """\ + try: + from mypkg import subpackage + except ImportError as ex: + print(ex) + """ + out = venv.run(["python", "-c", dedent(cmd_import_error)]) + assert "cannot import name 'subpackage'" in out + + # Ensure resource files excluded from distribution are not reachable + cmd_get_resource = """\ + import mypkg + from setuptools._importlib import resources as importlib_resources + try: + text = importlib_resources.files(mypkg) / "resource.not_in_manifest" + print(text.read_text(encoding="utf-8")) + except FileNotFoundError as ex: + print(ex) + """ + out = venv.run(["python", "-c", dedent(cmd_get_resource)]) + assert "No such file or directory" in out + assert "resource.not_in_manifest" in out + + +@pytest.mark.filterwarnings("ignore:.*compat.*:setuptools.SetuptoolsDeprecationWarning") +def test_compat_install(tmp_path, venv): + # TODO: Remove `compat` after Dec/2022. + opts = ["--config-settings", "editable-mode=compat"] + files = TestOverallBehaviour.EXAMPLES["custom-layout"] + install_project("mypkg", venv, tmp_path, files, *opts) + + out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"]) + assert "42" in out + + expected_path = comparable_path(str(tmp_path)) + + # Compatible behaviour will make spurious modules and excluded + # files importable directly from the original path + for cmd in ( + "import otherfile; print(otherfile)", + "import other; print(other)", + "import mypkg; print(mypkg)", + ): + out = comparable_path(venv.run(["python", "-c", cmd])) + assert expected_path in out + + # Compatible behaviour will not consider custom mappings + cmd = """\ + try: + from mypkg import subpackage; + except ImportError as ex: + print(ex) + """ + out = venv.run(["python", "-c", dedent(cmd)]) + assert "cannot import name 'subpackage'" in out + + +def test_pbr_integration(tmp_path, venv, editable_opts): + """Ensure editable installs work with pbr, issue #3500""" + files = { + "pyproject.toml": dedent( + """\ + [build-system] + requires = ["setuptools"] + build-backend = "setuptools.build_meta" + """ + ), + "setup.py": dedent( + """\ + __import__('setuptools').setup( + pbr=True, + setup_requires=["pbr"], + ) + """ + ), + "setup.cfg": dedent( + """\ + [metadata] + name = mypkg + + [files] + packages = + mypkg + """ + ), + "mypkg": { + "__init__.py": "", + "hello.py": "print('Hello world!')", + }, + "other": {"test.txt": "Another file in here."}, + } + venv.run(["python", "-m", "pip", "install", "pbr"]) + + with contexts.environment(PBR_VERSION="0.42"): + install_project("mypkg", venv, tmp_path, files, *editable_opts) + + out = venv.run(["python", "-c", "import mypkg.hello"]) + assert "Hello world!" in out + + +class TestCustomBuildPy: + """ + Issue #3501 indicates that some plugins/customizations might rely on: + + 1. ``build_py`` not running + 2. ``build_py`` always copying files to ``build_lib`` + + During the transition period setuptools should prevent potential errors from + happening due to those assumptions. + """ + + # TODO: Remove tests after _run_build_steps is removed. + + FILES = { + **TestOverallBehaviour.EXAMPLES["flat-layout"], + "setup.py": dedent( + """\ + import pathlib + from setuptools import setup + from setuptools.command.build_py import build_py as orig + + class my_build_py(orig): + def run(self): + super().run() + raise ValueError("TEST_RAISE") + + setup(cmdclass={"build_py": my_build_py}) + """ + ), + } + + def test_safeguarded_from_errors(self, tmp_path, venv): + """Ensure that errors in custom build_py are reported as warnings""" + # Warnings should show up + _, out = install_project("mypkg", venv, tmp_path, self.FILES) + assert "SetuptoolsDeprecationWarning" in out + assert "ValueError: TEST_RAISE" in out + # but installation should be successful + out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"]) + assert "42" in out + + +class TestCustomBuildWheel: + def install_custom_build_wheel(self, dist): + bdist_wheel_cls = dist.get_command_class("bdist_wheel") + + class MyBdistWheel(bdist_wheel_cls): + def get_tag(self): + # In issue #3513, we can see that some extensions may try to access + # the `plat_name` property in bdist_wheel + if self.plat_name.startswith("macosx-"): + _ = "macOS platform" + return super().get_tag() + + dist.cmdclass["bdist_wheel"] = MyBdistWheel + + def test_access_plat_name(self, tmpdir_cwd): + # Even when a custom bdist_wheel tries to access plat_name the build should + # be successful + jaraco.path.build({"module.py": "x = 42"}) + dist = Distribution() + dist.script_name = "setup.py" + dist.set_defaults() + self.install_custom_build_wheel(dist) + cmd = editable_wheel(dist) + cmd.ensure_finalized() + cmd.run() + wheel_file = str(next(Path().glob('dist/*.whl'))) + assert "editable" in wheel_file + + +class TestCustomBuildExt: + def install_custom_build_ext_distutils(self, dist): + from distutils.command.build_ext import build_ext as build_ext_cls + + class MyBuildExt(build_ext_cls): + pass + + dist.cmdclass["build_ext"] = MyBuildExt + + @pytest.mark.skipif( + sys.platform != "linux", reason="compilers may fail without correct setup" + ) + def test_distutils_leave_inplace_files(self, tmpdir_cwd): + jaraco.path.build({"module.c": ""}) + attrs = { + "ext_modules": [Extension("module", ["module.c"])], + } + dist = Distribution(attrs) + dist.script_name = "setup.py" + dist.set_defaults() + self.install_custom_build_ext_distutils(dist) + cmd = editable_wheel(dist) + cmd.ensure_finalized() + cmd.run() + wheel_file = str(next(Path().glob('dist/*.whl'))) + assert "editable" in wheel_file + files = [p for p in Path().glob("module.*") if p.suffix != ".c"] + assert len(files) == 1 + name = files[0].name + assert any(name.endswith(ext) for ext in EXTENSION_SUFFIXES) + + +def test_debugging_tips(tmpdir_cwd, monkeypatch): + """Make sure to display useful debugging tips to the user.""" + jaraco.path.build({"module.py": "x = 42"}) + dist = Distribution() + dist.script_name = "setup.py" + dist.set_defaults() + cmd = editable_wheel(dist) + cmd.ensure_finalized() + + SimulatedErr = type("SimulatedErr", (Exception,), {}) + simulated_failure = Mock(side_effect=SimulatedErr()) + monkeypatch.setattr(cmd, "get_finalized_command", simulated_failure) + + expected_msg = "following steps are recommended to help debug" + with pytest.raises(SimulatedErr), pytest.warns(_DebuggingTips, match=expected_msg): + cmd.run() + + +@pytest.mark.filterwarnings("error") +def test_encode_pth(): + """Ensure _encode_pth function does not produce encoding warnings""" + content = _encode_pth("tkmilan_ç_utf8") # no warnings (would be turned into errors) + assert isinstance(content, bytes) + + +def install_project(name, venv, tmp_path, files, *opts): + project = tmp_path / name + project.mkdir() + jaraco.path.build(files, prefix=project) + opts = [*opts, "--no-build-isolation"] # force current version of setuptools + out = venv.run( + ["python", "-m", "pip", "-v", "install", "-e", str(project), *opts], + stderr=subprocess.STDOUT, + ) + return project, out + + +def _addsitedirs(new_dirs): + """To use this function, it is necessary to insert new_dir in front of sys.path. + The Python process will try to import a ``sitecustomize`` module on startup. + If we manipulate sys.path/PYTHONPATH, we can force it to run our code, + which invokes ``addsitedir`` and ensure ``.pth`` files are loaded. + """ + content = '\n'.join( + ("import site",) + + tuple(f"site.addsitedir({os.fspath(new_dir)!r})" for new_dir in new_dirs) + ) + (new_dirs[0] / "sitecustomize.py").write_text(content, encoding="utf-8") + + +# ---- Assertion Helpers ---- + + +def assert_path(pkg, expected): + # __path__ is not guaranteed to exist, so we have to account for that + if pkg.__path__: + path = next(iter(pkg.__path__), None) + if path: + assert str(Path(path).resolve()) == expected + + +def assert_link_to(file: Path, other: Path) -> None: + if file.is_symlink(): + assert str(file.resolve()) == str(other.resolve()) + else: + file_stat = file.stat() + other_stat = other.stat() + assert file_stat[stat.ST_INO] == other_stat[stat.ST_INO] + assert file_stat[stat.ST_DEV] == other_stat[stat.ST_DEV] + + +def comparable_path(str_with_path: str) -> str: + return str_with_path.lower().replace(os.sep, "/").replace("//", "/") diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py new file mode 100644 index 0000000000000000000000000000000000000000..528e2c13d8513727794cf65272aa20ce33e87d9d --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_egg_info.py @@ -0,0 +1,1305 @@ +from __future__ import annotations + +import ast +import glob +import os +import re +import stat +import sys +import time +from pathlib import Path +from unittest import mock + +import pytest +from jaraco import path + +from setuptools import errors +from setuptools.command.egg_info import egg_info, manifest_maker, write_entries +from setuptools.dist import Distribution + +from . import contexts, environment +from .textwrap import DALS + + +class Environment(str): + pass + + +@pytest.fixture +def env(): + with contexts.tempdir(prefix='setuptools-test.') as env_dir: + env = Environment(env_dir) + os.chmod(env_dir, stat.S_IRWXU) + subs = 'home', 'lib', 'scripts', 'data', 'egg-base' + env.paths = dict((dirname, os.path.join(env_dir, dirname)) for dirname in subs) + list(map(os.mkdir, env.paths.values())) + path.build({ + env.paths['home']: { + '.pydistutils.cfg': DALS( + """ + [egg_info] + egg-base = {egg-base} + """.format(**env.paths) + ) + } + }) + yield env + + +class TestEggInfo: + setup_script = DALS( + """ + from setuptools import setup + + setup( + name='foo', + py_modules=['hello'], + entry_points={'console_scripts': ['hi = hello.run']}, + zip_safe=False, + ) + """ + ) + + def _create_project(self): + path.build({ + 'setup.py': self.setup_script, + 'hello.py': DALS( + """ + def run(): + print('hello') + """ + ), + }) + + @staticmethod + def _extract_mv_version(pkg_info_lines: list[str]) -> tuple[int, int]: + version_str = pkg_info_lines[0].split(' ')[1] + major, minor = map(int, version_str.split('.')[:2]) + return major, minor + + def test_egg_info_save_version_info_setup_empty(self, tmpdir_cwd, env): + """ + When the egg_info section is empty or not present, running + save_version_info should add the settings to the setup.cfg + in a deterministic order. + """ + setup_cfg = os.path.join(env.paths['home'], 'setup.cfg') + dist = Distribution() + ei = egg_info(dist) + ei.initialize_options() + ei.save_version_info(setup_cfg) + + with open(setup_cfg, 'r', encoding="utf-8") as f: + content = f.read() + + assert '[egg_info]' in content + assert 'tag_build =' in content + assert 'tag_date = 0' in content + + expected_order = ( + 'tag_build', + 'tag_date', + ) + + self._validate_content_order(content, expected_order) + + @staticmethod + def _validate_content_order(content, expected): + """ + Assert that the strings in expected appear in content + in order. + """ + pattern = '.*'.join(expected) + flags = re.MULTILINE | re.DOTALL + assert re.search(pattern, content, flags) + + def test_egg_info_save_version_info_setup_defaults(self, tmpdir_cwd, env): + """ + When running save_version_info on an existing setup.cfg + with the 'default' values present from a previous run, + the file should remain unchanged. + """ + setup_cfg = os.path.join(env.paths['home'], 'setup.cfg') + path.build({ + setup_cfg: DALS( + """ + [egg_info] + tag_build = + tag_date = 0 + """ + ), + }) + dist = Distribution() + ei = egg_info(dist) + ei.initialize_options() + ei.save_version_info(setup_cfg) + + with open(setup_cfg, 'r', encoding="utf-8") as f: + content = f.read() + + assert '[egg_info]' in content + assert 'tag_build =' in content + assert 'tag_date = 0' in content + + expected_order = ( + 'tag_build', + 'tag_date', + ) + + self._validate_content_order(content, expected_order) + + def test_expected_files_produced(self, tmpdir_cwd, env): + self._create_project() + + self._run_egg_info_command(tmpdir_cwd, env) + actual = os.listdir('foo.egg-info') + + expected = [ + 'PKG-INFO', + 'SOURCES.txt', + 'dependency_links.txt', + 'entry_points.txt', + 'not-zip-safe', + 'top_level.txt', + ] + assert sorted(actual) == expected + + def test_handling_utime_error(self, tmpdir_cwd, env): + dist = Distribution() + ei = egg_info(dist) + utime_patch = mock.patch('os.utime', side_effect=OSError("TEST")) + mkpath_patch = mock.patch( + 'setuptools.command.egg_info.egg_info.mkpath', return_val=None + ) + + with utime_patch, mkpath_patch: + import distutils.errors + + msg = r"Cannot update time stamp of directory 'None'" + with pytest.raises(distutils.errors.DistutilsFileError, match=msg): + ei.run() + + def test_license_is_a_string(self, tmpdir_cwd, env): + setup_config = DALS( + """ + [metadata] + name=foo + version=0.0.1 + license=file:MIT + """ + ) + + setup_script = DALS( + """ + from setuptools import setup + + setup() + """ + ) + + path.build({ + 'setup.py': setup_script, + 'setup.cfg': setup_config, + }) + + # This command should fail with a ValueError, but because it's + # currently configured to use a subprocess, the actual traceback + # object is lost and we need to parse it from stderr + with pytest.raises(AssertionError) as exc: + self._run_egg_info_command(tmpdir_cwd, env) + + # The only argument to the assertion error should be a traceback + # containing a ValueError + assert 'ValueError' in exc.value.args[0] + + def test_rebuilt(self, tmpdir_cwd, env): + """Ensure timestamps are updated when the command is re-run.""" + self._create_project() + + self._run_egg_info_command(tmpdir_cwd, env) + timestamp_a = os.path.getmtime('foo.egg-info') + + # arbitrary sleep just to handle *really* fast systems + time.sleep(0.001) + + self._run_egg_info_command(tmpdir_cwd, env) + timestamp_b = os.path.getmtime('foo.egg-info') + + assert timestamp_a != timestamp_b + + def test_manifest_template_is_read(self, tmpdir_cwd, env): + self._create_project() + path.build({ + 'MANIFEST.in': DALS( + """ + recursive-include docs *.rst + """ + ), + 'docs': { + 'usage.rst': "Run 'hi'", + }, + }) + self._run_egg_info_command(tmpdir_cwd, env) + egg_info_dir = os.path.join('.', 'foo.egg-info') + sources_txt = os.path.join(egg_info_dir, 'SOURCES.txt') + with open(sources_txt, encoding="utf-8") as f: + assert 'docs/usage.rst' in f.read().split('\n') + + def _setup_script_with_requires(self, requires, use_setup_cfg=False): + setup_script = DALS( + """ + from setuptools import setup + + setup(name='foo', zip_safe=False, %s) + """ + ) % ('' if use_setup_cfg else requires) + setup_config = requires if use_setup_cfg else '' + path.build({ + 'setup.py': setup_script, + 'setup.cfg': setup_config, + }) + + mismatch_marker = f"python_version<'{sys.version_info[0]}'" + # Alternate equivalent syntax. + mismatch_marker_alternate = f'python_version < "{sys.version_info[0]}"' + invalid_marker = "<=>++" + + class RequiresTestHelper: + @staticmethod + def parametrize(*test_list, **format_dict): + idlist = [] + argvalues = [] + for test in test_list: + test_params = test.lstrip().split('\n\n', 3) + name_kwargs = test_params.pop(0).split('\n') + if len(name_kwargs) > 1: + val = name_kwargs[1].strip() + install_cmd_kwargs = ast.literal_eval(val) + else: + install_cmd_kwargs = {} + name = name_kwargs[0].strip() + setup_py_requires, setup_cfg_requires, expected_requires = [ + DALS(a).format(**format_dict) for a in test_params + ] + for id_, requires, use_cfg in ( + (name, setup_py_requires, False), + (name + '_in_setup_cfg', setup_cfg_requires, True), + ): + idlist.append(id_) + marks = () + if requires.startswith('@xfail\n'): + requires = requires[7:] + marks = pytest.mark.xfail + argvalues.append( + pytest.param( + requires, + use_cfg, + expected_requires, + install_cmd_kwargs, + marks=marks, + ) + ) + return pytest.mark.parametrize( + ( + "requires", + "use_setup_cfg", + "expected_requires", + "install_cmd_kwargs", + ), + argvalues, + ids=idlist, + ) + + @RequiresTestHelper.parametrize( + # Format of a test: + # + # id + # install_cmd_kwargs [optional] + # + # requires block (when used in setup.py) + # + # requires block (when used in setup.cfg) + # + # expected contents of requires.txt + """ + install_requires_deterministic + + install_requires=["wheel>=0.5", "pytest"] + + [options] + install_requires = + wheel>=0.5 + pytest + + wheel>=0.5 + pytest + """, + """ + install_requires_ordered + + install_requires=["pytest>=3.0.2,!=10.9999"] + + [options] + install_requires = + pytest>=3.0.2,!=10.9999 + + pytest!=10.9999,>=3.0.2 + """, + """ + install_requires_with_marker + + install_requires=["barbazquux;{mismatch_marker}"], + + [options] + install_requires = + barbazquux; {mismatch_marker} + + [:{mismatch_marker_alternate}] + barbazquux + """, + """ + install_requires_with_extra + {'cmd': ['egg_info']} + + install_requires=["barbazquux [test]"], + + [options] + install_requires = + barbazquux [test] + + barbazquux[test] + """, + """ + install_requires_with_extra_and_marker + + install_requires=["barbazquux [test]; {mismatch_marker}"], + + [options] + install_requires = + barbazquux [test]; {mismatch_marker} + + [:{mismatch_marker_alternate}] + barbazquux[test] + """, + """ + setup_requires_with_markers + + setup_requires=["barbazquux;{mismatch_marker}"], + + [options] + setup_requires = + barbazquux; {mismatch_marker} + + """, + """ + extras_require_with_extra + {'cmd': ['egg_info']} + + extras_require={{"extra": ["barbazquux [test]"]}}, + + [options.extras_require] + extra = barbazquux [test] + + [extra] + barbazquux[test] + """, + """ + extras_require_with_extra_and_marker_in_req + + extras_require={{"extra": ["barbazquux [test]; {mismatch_marker}"]}}, + + [options.extras_require] + extra = + barbazquux [test]; {mismatch_marker} + + [extra] + + [extra:{mismatch_marker_alternate}] + barbazquux[test] + """, + # FIXME: ConfigParser does not allow : in key names! + """ + extras_require_with_marker + + extras_require={{":{mismatch_marker}": ["barbazquux"]}}, + + @xfail + [options.extras_require] + :{mismatch_marker} = barbazquux + + [:{mismatch_marker}] + barbazquux + """, + """ + extras_require_with_marker_in_req + + extras_require={{"extra": ["barbazquux; {mismatch_marker}"]}}, + + [options.extras_require] + extra = + barbazquux; {mismatch_marker} + + [extra] + + [extra:{mismatch_marker_alternate}] + barbazquux + """, + """ + extras_require_with_empty_section + + extras_require={{"empty": []}}, + + [options.extras_require] + empty = + + [empty] + """, + # Format arguments. + invalid_marker=invalid_marker, + mismatch_marker=mismatch_marker, + mismatch_marker_alternate=mismatch_marker_alternate, + ) + def test_requires( + self, + tmpdir_cwd, + env, + requires, + use_setup_cfg, + expected_requires, + install_cmd_kwargs, + ): + self._setup_script_with_requires(requires, use_setup_cfg) + self._run_egg_info_command(tmpdir_cwd, env, **install_cmd_kwargs) + egg_info_dir = os.path.join('.', 'foo.egg-info') + requires_txt = os.path.join(egg_info_dir, 'requires.txt') + if os.path.exists(requires_txt): + with open(requires_txt, encoding="utf-8") as fp: + install_requires = fp.read() + else: + install_requires = '' + assert install_requires.lstrip() == expected_requires + assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == [] + + def test_install_requires_unordered_disallowed(self, tmpdir_cwd, env): + """ + Packages that pass unordered install_requires sequences + should be rejected as they produce non-deterministic + builds. See #458. + """ + req = 'install_requires={"fake-factory==0.5.2", "pytz"}' + self._setup_script_with_requires(req) + with pytest.raises(AssertionError): + self._run_egg_info_command(tmpdir_cwd, env) + + def test_extras_require_with_invalid_marker(self, tmpdir_cwd, env): + tmpl = 'extras_require={{":{marker}": ["barbazquux"]}},' + req = tmpl.format(marker=self.invalid_marker) + self._setup_script_with_requires(req) + with pytest.raises(AssertionError): + self._run_egg_info_command(tmpdir_cwd, env) + assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == [] + + def test_extras_require_with_invalid_marker_in_req(self, tmpdir_cwd, env): + tmpl = 'extras_require={{"extra": ["barbazquux; {marker}"]}},' + req = tmpl.format(marker=self.invalid_marker) + self._setup_script_with_requires(req) + with pytest.raises(AssertionError): + self._run_egg_info_command(tmpdir_cwd, env) + assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == [] + + def test_provides_extra(self, tmpdir_cwd, env): + self._setup_script_with_requires('extras_require={"foobar": ["barbazquux"]},') + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + assert 'Provides-Extra: foobar' in pkg_info_lines + assert 'Metadata-Version: 2.4' in pkg_info_lines + + def test_doesnt_provides_extra(self, tmpdir_cwd, env): + self._setup_script_with_requires( + """install_requires=["spam ; python_version<'3.6'"]""" + ) + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_text = fp.read() + assert 'Provides-Extra:' not in pkg_info_text + + @pytest.mark.parametrize( + ('files', 'license_in_sources'), + [ + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE + """ + ), + 'LICENSE': "Test license", + }, + True, + ), # with license + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = INVALID_LICENSE + """ + ), + 'LICENSE': "Test license", + }, + False, + ), # with an invalid license + ( + { + 'setup.cfg': DALS( + """ + """ + ), + 'LICENSE': "Test license", + }, + True, + ), # no license_file attribute, LICENSE auto-included + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE + """ + ), + 'MANIFEST.in': "exclude LICENSE", + 'LICENSE': "Test license", + }, + True, + ), # manifest is overwritten by license_file + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICEN[CS]E* + """ + ), + 'LICENSE': "Test license", + }, + True, + id="glob_pattern", + ), + ], + ) + def test_setup_cfg_license_file(self, tmpdir_cwd, env, files, license_in_sources): + self._create_project() + path.build(files) + + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + + sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8") + + if license_in_sources: + assert 'LICENSE' in sources_text + else: + assert 'LICENSE' not in sources_text + # for invalid license test + assert 'INVALID_LICENSE' not in sources_text + + @pytest.mark.parametrize( + ('files', 'incl_licenses', 'excl_licenses'), + [ + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE-ABC + LICENSE-XYZ + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + ['LICENSE-ABC', 'LICENSE-XYZ'], + [], + ), # with licenses + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = LICENSE-ABC, LICENSE-XYZ + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + ['LICENSE-ABC', 'LICENSE-XYZ'], + [], + ), # with commas + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE-ABC + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + ['LICENSE-ABC'], + ['LICENSE-XYZ'], + ), # with one license + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + [], + ['LICENSE-ABC', 'LICENSE-XYZ'], + ), # empty + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = LICENSE-XYZ + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + ['LICENSE-XYZ'], + ['LICENSE-ABC'], + ), # on same line + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE-ABC + INVALID_LICENSE + """ + ), + 'LICENSE-ABC': "Test license", + }, + ['LICENSE-ABC'], + ['INVALID_LICENSE'], + ), # with an invalid license + ( + { + 'setup.cfg': DALS( + """ + """ + ), + 'LICENSE': "Test license", + }, + ['LICENSE'], + [], + ), # no license_files attribute, LICENSE auto-included + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = LICENSE + """ + ), + 'MANIFEST.in': "exclude LICENSE", + 'LICENSE': "Test license", + }, + ['LICENSE'], + [], + ), # manifest is overwritten by license_files + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE-ABC + LICENSE-XYZ + """ + ), + 'MANIFEST.in': "exclude LICENSE-XYZ", + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + # manifest is overwritten by license_files + }, + ['LICENSE-ABC', 'LICENSE-XYZ'], + [], + ), + pytest.param( + { + 'setup.cfg': "", + 'LICENSE-ABC': "ABC license", + 'COPYING-ABC': "ABC copying", + 'NOTICE-ABC': "ABC notice", + 'AUTHORS-ABC': "ABC authors", + 'LICENCE-XYZ': "XYZ license", + 'LICENSE': "License", + 'INVALID-LICENSE': "Invalid license", + }, + [ + 'LICENSE-ABC', + 'COPYING-ABC', + 'NOTICE-ABC', + 'AUTHORS-ABC', + 'LICENCE-XYZ', + 'LICENSE', + ], + ['INVALID-LICENSE'], + # ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*') + id="default_glob_patterns", + ), + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE* + """ + ), + 'LICENSE-ABC': "ABC license", + 'NOTICE-XYZ': "XYZ notice", + }, + ['LICENSE-ABC'], + ['NOTICE-XYZ'], + id="no_default_glob_patterns", + ), + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = + LICENSE-ABC + LICENSE* + """ + ), + 'LICENSE-ABC': "ABC license", + }, + ['LICENSE-ABC'], + [], + id="files_only_added_once", + ), + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_files = **/LICENSE + """ + ), + 'LICENSE': "ABC license", + 'LICENSE-OTHER': "Don't include", + 'vendor': {'LICENSE': "Vendor license"}, + }, + ['LICENSE', 'vendor/LICENSE'], + ['LICENSE-OTHER'], + id="recursive_glob", + ), + ], + ) + def test_setup_cfg_license_files( + self, tmpdir_cwd, env, files, incl_licenses, excl_licenses + ): + self._create_project() + path.build(files) + + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + + sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8") + sources_lines = [line.strip() for line in sources_text.splitlines()] + + for lf in incl_licenses: + assert sources_lines.count(lf) == 1 + + for lf in excl_licenses: + assert sources_lines.count(lf) == 0 + + @pytest.mark.parametrize( + ('files', 'incl_licenses', 'excl_licenses'), + [ + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = + license_files = + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + }, + [], + ['LICENSE-ABC', 'LICENSE-XYZ'], + ), # both empty + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = + LICENSE-ABC + LICENSE-XYZ + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-XYZ': "XYZ license", + # license_file is still singular + }, + [], + ['LICENSE-ABC', 'LICENSE-XYZ'], + ), + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE-ABC + license_files = + LICENSE-XYZ + LICENSE-PQR + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-PQR': "PQR license", + 'LICENSE-XYZ': "XYZ license", + }, + ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], + [], + ), # combined + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE-ABC + license_files = + LICENSE-ABC + LICENSE-XYZ + LICENSE-PQR + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-PQR': "PQR license", + 'LICENSE-XYZ': "XYZ license", + # duplicate license + }, + ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], + [], + ), + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE-ABC + license_files = + LICENSE-XYZ + """ + ), + 'LICENSE-ABC': "ABC license", + 'LICENSE-PQR': "PQR license", + 'LICENSE-XYZ': "XYZ license", + # combined subset + }, + ['LICENSE-ABC', 'LICENSE-XYZ'], + ['LICENSE-PQR'], + ), + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE-ABC + license_files = + LICENSE-XYZ + LICENSE-PQR + """ + ), + 'LICENSE-PQR': "Test license", + # with invalid licenses + }, + ['LICENSE-PQR'], + ['LICENSE-ABC', 'LICENSE-XYZ'], + ), + ( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE-ABC + license_files = + LICENSE-PQR + LICENSE-XYZ + """ + ), + 'MANIFEST.in': "exclude LICENSE-ABC\nexclude LICENSE-PQR", + 'LICENSE-ABC': "ABC license", + 'LICENSE-PQR': "PQR license", + 'LICENSE-XYZ': "XYZ license", + # manifest is overwritten + }, + ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'], + [], + ), + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE* + """ + ), + 'LICENSE-ABC': "ABC license", + 'NOTICE-XYZ': "XYZ notice", + }, + ['LICENSE-ABC'], + ['NOTICE-XYZ'], + id="no_default_glob_patterns", + ), + pytest.param( + { + 'setup.cfg': DALS( + """ + [metadata] + license_file = LICENSE* + license_files = + NOTICE* + """ + ), + 'LICENSE-ABC': "ABC license", + 'NOTICE-ABC': "ABC notice", + 'AUTHORS-ABC': "ABC authors", + }, + ['LICENSE-ABC', 'NOTICE-ABC'], + ['AUTHORS-ABC'], + id="combined_glob_patterrns", + ), + ], + ) + def test_setup_cfg_license_file_license_files( + self, tmpdir_cwd, env, files, incl_licenses, excl_licenses + ): + self._create_project() + path.build(files) + + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + + sources_text = Path(egg_info_dir, "SOURCES.txt").read_text(encoding="utf-8") + sources_lines = [line.strip() for line in sources_text.splitlines()] + + for lf in incl_licenses: + assert sources_lines.count(lf) == 1 + + for lf in excl_licenses: + assert sources_lines.count(lf) == 0 + + def test_license_file_attr_pkg_info(self, tmpdir_cwd, env): + """All matched license files should have a corresponding License-File.""" + self._create_project() + path.build({ + "setup.cfg": DALS( + """ + [metadata] + license_files = + NOTICE* + LICENSE* + **/LICENSE + """ + ), + "LICENSE-ABC": "ABC license", + "LICENSE-XYZ": "XYZ license", + "NOTICE": "included", + "IGNORE": "not include", + "vendor": {'LICENSE': "Vendor license"}, + }) + + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + license_file_lines = [ + line for line in pkg_info_lines if line.startswith('License-File:') + ] + + # Only 'NOTICE', LICENSE-ABC', and 'LICENSE-XYZ' should have been matched + # Also assert that order from license_files is keeped + assert len(license_file_lines) == 4 + assert "License-File: NOTICE" == license_file_lines[0] + assert "License-File: LICENSE-ABC" in license_file_lines[1:] + assert "License-File: LICENSE-XYZ" in license_file_lines[1:] + assert "License-File: vendor/LICENSE" in license_file_lines[3] + + def test_metadata_version(self, tmpdir_cwd, env): + """Make sure latest metadata version is used by default.""" + self._setup_script_with_requires("") + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + # Update metadata version if changed + assert self._extract_mv_version(pkg_info_lines) == (2, 4) + + def test_long_description_content_type(self, tmpdir_cwd, env): + # Test that specifying a `long_description_content_type` keyword arg to + # the `setup` function results in writing a `Description-Content-Type` + # line to the `PKG-INFO` file in the `.egg-info` + # directory. + # `Description-Content-Type` is described at + # https://github.com/pypa/python-packaging-user-guide/pull/258 + + self._setup_script_with_requires( + """long_description_content_type='text/markdown',""" + ) + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + expected_line = 'Description-Content-Type: text/markdown' + assert expected_line in pkg_info_lines + assert 'Metadata-Version: 2.4' in pkg_info_lines + + def test_long_description(self, tmpdir_cwd, env): + # Test that specifying `long_description` and `long_description_content_type` + # keyword args to the `setup` function results in writing + # the description in the message payload of the `PKG-INFO` file + # in the `.egg-info` directory. + self._setup_script_with_requires( + "long_description='This is a long description\\nover multiple lines'," + "long_description_content_type='text/markdown'," + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + assert 'Metadata-Version: 2.4' in pkg_info_lines + assert '' == pkg_info_lines[-1] # last line should be empty + long_desc_lines = pkg_info_lines[pkg_info_lines.index('') :] + assert 'This is a long description' in long_desc_lines + assert 'over multiple lines' in long_desc_lines + + def test_project_urls(self, tmpdir_cwd, env): + # Test that specifying a `project_urls` dict to the `setup` + # function results in writing multiple `Project-URL` lines to + # the `PKG-INFO` file in the `.egg-info` + # directory. + # `Project-URL` is described at https://packaging.python.org + # /specifications/core-metadata/#project-url-multiple-use + + self._setup_script_with_requires( + """project_urls={ + 'Link One': 'https://example.com/one/', + 'Link Two': 'https://example.com/two/', + },""" + ) + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + expected_line = 'Project-URL: Link One, https://example.com/one/' + assert expected_line in pkg_info_lines + expected_line = 'Project-URL: Link Two, https://example.com/two/' + assert expected_line in pkg_info_lines + assert self._extract_mv_version(pkg_info_lines) >= (1, 2) + + def test_license(self, tmpdir_cwd, env): + """Test single line license.""" + self._setup_script_with_requires("license='MIT',") + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + assert 'License: MIT' in pkg_info_lines + + def test_license_escape(self, tmpdir_cwd, env): + """Test license is escaped correctly if longer than one line.""" + self._setup_script_with_requires( + "license='This is a long license text \\nover multiple lines'," + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + + assert 'License: This is a long license text ' in pkg_info_lines + assert ' over multiple lines' in pkg_info_lines + assert 'text \n over multiple' in '\n'.join(pkg_info_lines) + + def test_python_requires_egg_info(self, tmpdir_cwd, env): + self._setup_script_with_requires("""python_requires='>=2.7.12',""") + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + environment.run_setup_py( + cmd=['egg_info'], + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + assert 'Requires-Python: >=2.7.12' in pkg_info_lines + assert self._extract_mv_version(pkg_info_lines) >= (1, 2) + + def test_manifest_maker_warning_suppression(self): + fixtures = [ + "standard file not found: should have one of foo.py, bar.py", + "standard file 'setup.py' not found", + ] + + for msg in fixtures: + assert manifest_maker._should_suppress_warning(msg) + + def test_egg_info_includes_setup_py(self, tmpdir_cwd): + self._create_project() + dist = Distribution({"name": "foo", "version": "0.0.1"}) + dist.script_name = "non_setup.py" + egg_info_instance = egg_info(dist) + egg_info_instance.finalize_options() + egg_info_instance.run() + + assert 'setup.py' in egg_info_instance.filelist.files + + with open(egg_info_instance.egg_info + "/SOURCES.txt", encoding="utf-8") as f: + sources = f.read().split('\n') + assert 'setup.py' in sources + + def _run_egg_info_command(self, tmpdir_cwd, env, cmd=None, output=None): + environ = os.environ.copy().update( + HOME=env.paths['home'], + ) + if cmd is None: + cmd = [ + 'egg_info', + ] + code, data = environment.run_setup_py( + cmd=cmd, + pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]), + data_stream=1, + env=environ, + ) + assert not code, data + + if output: + assert output in data + + def test_egg_info_tag_only_once(self, tmpdir_cwd, env): + self._create_project() + path.build({ + 'setup.cfg': DALS( + """ + [egg_info] + tag_build = dev + tag_date = 0 + tag_svn_revision = 0 + """ + ), + }) + self._run_egg_info_command(tmpdir_cwd, env) + egg_info_dir = os.path.join('.', 'foo.egg-info') + with open(os.path.join(egg_info_dir, 'PKG-INFO'), encoding="utf-8") as fp: + pkg_info_lines = fp.read().split('\n') + assert 'Version: 0.0.0.dev0' in pkg_info_lines + + +class TestWriteEntries: + def test_invalid_entry_point(self, tmpdir_cwd, env): + dist = Distribution({"name": "foo", "version": "0.0.1"}) + dist.entry_points = {"foo": "foo = invalid-identifier:foo"} + cmd = dist.get_command_obj("egg_info") + expected_msg = r"Problems to parse .*invalid-identifier.*" + with pytest.raises(errors.OptionError, match=expected_msg) as ex: + write_entries(cmd, "entry_points", "entry_points.txt") + assert "ensure entry-point follows the spec" in ex.value.args[0] + + def test_valid_entry_point(self, tmpdir_cwd, env): + dist = Distribution({"name": "foo", "version": "0.0.1"}) + dist.entry_points = { + "abc": "foo = bar:baz", + "def": ["faa = bor:boz"], + } + cmd = dist.get_command_obj("egg_info") + write_entries(cmd, "entry_points", "entry_points.txt") + content = Path("entry_points.txt").read_text(encoding="utf-8") + assert "[abc]\nfoo = bar:baz\n" in content + assert "[def]\nfaa = bor:boz\n" in content diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py new file mode 100644 index 0000000000000000000000000000000000000000..d7eb3c62c190dacdd4a054d2934962be2f4ee860 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_extern.py @@ -0,0 +1,15 @@ +import importlib +import pickle + +import packaging + +from setuptools import Distribution + + +def test_reimport_extern(): + packaging2 = importlib.import_module(packaging.__name__) + assert packaging is packaging2 + + +def test_distribution_picklable(): + pickle.loads(pickle.dumps(Distribution())) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py new file mode 100644 index 0000000000000000000000000000000000000000..9fd9f8f6637d13cb898fcd446a6b090323d02014 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_packages.py @@ -0,0 +1,218 @@ +"""Tests for automatic package discovery""" + +import os +import shutil +import tempfile + +import pytest + +from setuptools import find_namespace_packages, find_packages +from setuptools.discovery import FlatLayoutPackageFinder + +from .compat.py39 import os_helper + + +class TestFindPackages: + def setup_method(self, method): + self.dist_dir = tempfile.mkdtemp() + self._make_pkg_structure() + + def teardown_method(self, method): + shutil.rmtree(self.dist_dir) + + def _make_pkg_structure(self): + """Make basic package structure. + + dist/ + docs/ + conf.py + pkg/ + __pycache__/ + nspkg/ + mod.py + subpkg/ + assets/ + asset + __init__.py + setup.py + + """ + self.docs_dir = self._mkdir('docs', self.dist_dir) + self._touch('conf.py', self.docs_dir) + self.pkg_dir = self._mkdir('pkg', self.dist_dir) + self._mkdir('__pycache__', self.pkg_dir) + self.ns_pkg_dir = self._mkdir('nspkg', self.pkg_dir) + self._touch('mod.py', self.ns_pkg_dir) + self.sub_pkg_dir = self._mkdir('subpkg', self.pkg_dir) + self.asset_dir = self._mkdir('assets', self.sub_pkg_dir) + self._touch('asset', self.asset_dir) + self._touch('__init__.py', self.sub_pkg_dir) + self._touch('setup.py', self.dist_dir) + + def _mkdir(self, path, parent_dir=None): + if parent_dir: + path = os.path.join(parent_dir, path) + os.mkdir(path) + return path + + def _touch(self, path, dir_=None): + if dir_: + path = os.path.join(dir_, path) + open(path, 'wb').close() + return path + + def test_regular_package(self): + self._touch('__init__.py', self.pkg_dir) + packages = find_packages(self.dist_dir) + assert packages == ['pkg', 'pkg.subpkg'] + + def test_exclude(self): + self._touch('__init__.py', self.pkg_dir) + packages = find_packages(self.dist_dir, exclude=('pkg.*',)) + assert packages == ['pkg'] + + def test_exclude_recursive(self): + """ + Excluding a parent package should not exclude child packages as well. + """ + self._touch('__init__.py', self.pkg_dir) + self._touch('__init__.py', self.sub_pkg_dir) + packages = find_packages(self.dist_dir, exclude=('pkg',)) + assert packages == ['pkg.subpkg'] + + def test_include_excludes_other(self): + """ + If include is specified, other packages should be excluded. + """ + self._touch('__init__.py', self.pkg_dir) + alt_dir = self._mkdir('other_pkg', self.dist_dir) + self._touch('__init__.py', alt_dir) + packages = find_packages(self.dist_dir, include=['other_pkg']) + assert packages == ['other_pkg'] + + def test_dir_with_dot_is_skipped(self): + shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets')) + data_dir = self._mkdir('some.data', self.pkg_dir) + self._touch('__init__.py', data_dir) + self._touch('file.dat', data_dir) + packages = find_packages(self.dist_dir) + assert 'pkg.some.data' not in packages + + def test_dir_with_packages_in_subdir_is_excluded(self): + """ + Ensure that a package in a non-package such as build/pkg/__init__.py + is excluded. + """ + build_dir = self._mkdir('build', self.dist_dir) + build_pkg_dir = self._mkdir('pkg', build_dir) + self._touch('__init__.py', build_pkg_dir) + packages = find_packages(self.dist_dir) + assert 'build.pkg' not in packages + + @pytest.mark.skipif(not os_helper.can_symlink(), reason='Symlink support required') + def test_symlinked_packages_are_included(self): + """ + A symbolically-linked directory should be treated like any other + directory when matched as a package. + + Create a link from lpkg -> pkg. + """ + self._touch('__init__.py', self.pkg_dir) + linked_pkg = os.path.join(self.dist_dir, 'lpkg') + os.symlink('pkg', linked_pkg) + assert os.path.isdir(linked_pkg) + packages = find_packages(self.dist_dir) + assert 'lpkg' in packages + + def _assert_packages(self, actual, expected): + assert set(actual) == set(expected) + + def test_pep420_ns_package(self): + packages = find_namespace_packages( + self.dist_dir, include=['pkg*'], exclude=['pkg.subpkg.assets'] + ) + self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg']) + + def test_pep420_ns_package_no_includes(self): + packages = find_namespace_packages(self.dist_dir, exclude=['pkg.subpkg.assets']) + self._assert_packages(packages, ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg']) + + def test_pep420_ns_package_no_includes_or_excludes(self): + packages = find_namespace_packages(self.dist_dir) + expected = ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg', 'pkg.subpkg.assets'] + self._assert_packages(packages, expected) + + def test_regular_package_with_nested_pep420_ns_packages(self): + self._touch('__init__.py', self.pkg_dir) + packages = find_namespace_packages( + self.dist_dir, exclude=['docs', 'pkg.subpkg.assets'] + ) + self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg']) + + def test_pep420_ns_package_no_non_package_dirs(self): + shutil.rmtree(self.docs_dir) + shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets')) + packages = find_namespace_packages(self.dist_dir) + self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg']) + + +class TestFlatLayoutPackageFinder: + EXAMPLES = { + "hidden-folders": ( + [".pkg/__init__.py", "pkg/__init__.py", "pkg/nested/file.txt"], + ["pkg", "pkg.nested"], + ), + "private-packages": ( + ["_pkg/__init__.py", "pkg/_private/__init__.py"], + ["pkg", "pkg._private"], + ), + "invalid-name": ( + ["invalid-pkg/__init__.py", "other.pkg/__init__.py", "yet,another/file.py"], + [], + ), + "docs": (["pkg/__init__.py", "docs/conf.py", "docs/readme.rst"], ["pkg"]), + "tests": ( + ["pkg/__init__.py", "tests/test_pkg.py", "tests/__init__.py"], + ["pkg"], + ), + "examples": ( + [ + "pkg/__init__.py", + "examples/__init__.py", + "examples/file.py", + "example/other_file.py", + # Sub-packages should always be fine + "pkg/example/__init__.py", + "pkg/examples/__init__.py", + ], + ["pkg", "pkg.examples", "pkg.example"], + ), + "tool-specific": ( + [ + "htmlcov/index.html", + "pkg/__init__.py", + "tasks/__init__.py", + "tasks/subpackage/__init__.py", + "fabfile/__init__.py", + "fabfile/subpackage/__init__.py", + # Sub-packages should always be fine + "pkg/tasks/__init__.py", + "pkg/fabfile/__init__.py", + ], + ["pkg", "pkg.tasks", "pkg.fabfile"], + ), + } + + @pytest.mark.parametrize("example", EXAMPLES.keys()) + def test_unwanted_directories_not_included(self, tmp_path, example): + files, expected_packages = self.EXAMPLES[example] + ensure_files(tmp_path, files) + found_packages = FlatLayoutPackageFinder.find(str(tmp_path)) + assert set(found_packages) == set(expected_packages) + + +def ensure_files(root_path, files): + for file in files: + path = root_path / file + path.parent.mkdir(parents=True, exist_ok=True) + path.touch() diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py new file mode 100644 index 0000000000000000000000000000000000000000..8034b544294e5d30274bac82f24f93613120a0d4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_find_py_modules.py @@ -0,0 +1,73 @@ +"""Tests for automatic discovery of modules""" + +import os + +import pytest + +from setuptools.discovery import FlatLayoutModuleFinder, ModuleFinder + +from .compat.py39 import os_helper +from .test_find_packages import ensure_files + + +class TestModuleFinder: + def find(self, path, *args, **kwargs): + return set(ModuleFinder.find(str(path), *args, **kwargs)) + + EXAMPLES = { + # circumstance: (files, kwargs, expected_modules) + "simple_folder": ( + ["file.py", "other.py"], + {}, # kwargs + ["file", "other"], + ), + "exclude": ( + ["file.py", "other.py"], + {"exclude": ["f*"]}, + ["other"], + ), + "include": ( + ["file.py", "fole.py", "other.py"], + {"include": ["f*"], "exclude": ["fo*"]}, + ["file"], + ), + "invalid-name": (["my-file.py", "other.file.py"], {}, []), + } + + @pytest.mark.parametrize("example", EXAMPLES.keys()) + def test_finder(self, tmp_path, example): + files, kwargs, expected_modules = self.EXAMPLES[example] + ensure_files(tmp_path, files) + assert self.find(tmp_path, **kwargs) == set(expected_modules) + + @pytest.mark.skipif(not os_helper.can_symlink(), reason='Symlink support required') + def test_symlinked_packages_are_included(self, tmp_path): + src = "_myfiles/file.py" + ensure_files(tmp_path, [src]) + os.symlink(tmp_path / src, tmp_path / "link.py") + assert self.find(tmp_path) == {"link"} + + +class TestFlatLayoutModuleFinder: + def find(self, path, *args, **kwargs): + return set(FlatLayoutModuleFinder.find(str(path))) + + EXAMPLES = { + # circumstance: (files, expected_modules) + "hidden-files": ([".module.py"], []), + "private-modules": (["_module.py"], []), + "common-names": ( + ["setup.py", "conftest.py", "test.py", "tests.py", "example.py", "mod.py"], + ["mod"], + ), + "tool-specific": ( + ["tasks.py", "fabfile.py", "noxfile.py", "dodo.py", "manage.py", "mod.py"], + ["mod"], + ), + } + + @pytest.mark.parametrize("example", EXAMPLES.keys()) + def test_unwanted_files_not_included(self, tmp_path, example): + files, expected_modules = self.EXAMPLES[example] + ensure_files(tmp_path, files) + assert self.find(tmp_path) == set(expected_modules) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py new file mode 100644 index 0000000000000000000000000000000000000000..8d225a44610163c7d56d65b07c06f0f598ccfe84 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_glob.py @@ -0,0 +1,45 @@ +import pytest +from jaraco import path + +from setuptools.glob import glob + + +@pytest.mark.parametrize( + ('tree', 'pattern', 'matches'), + ( + ('', b'', []), + ('', '', []), + ( + """ + appveyor.yml + CHANGES.rst + LICENSE + MANIFEST.in + pyproject.toml + README.rst + setup.cfg + setup.py + """, + '*.rst', + ('CHANGES.rst', 'README.rst'), + ), + ( + """ + appveyor.yml + CHANGES.rst + LICENSE + MANIFEST.in + pyproject.toml + README.rst + setup.cfg + setup.py + """, + b'*.rst', + (b'CHANGES.rst', b'README.rst'), + ), + ), +) +def test_glob(monkeypatch, tmpdir, tree, pattern, matches): + monkeypatch.chdir(tmpdir) + path.build({name: '' for name in tree.split()}) + assert list(sorted(glob(pattern))) == list(sorted(matches)) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..e62a6b7f318df2da0cf29e53c41f74e5525e78ac --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_install_scripts.py @@ -0,0 +1,89 @@ +"""install_scripts tests""" + +import sys + +import pytest + +from setuptools.command.install_scripts import install_scripts +from setuptools.dist import Distribution + +from . import contexts + + +class TestInstallScripts: + settings = dict( + name='foo', + entry_points={'console_scripts': ['foo=foo:foo']}, + version='0.0', + ) + unix_exe = '/usr/dummy-test-path/local/bin/python' + unix_spaces_exe = '/usr/bin/env dummy-test-python' + win32_exe = 'C:\\Dummy Test Path\\Program Files\\Python 3.6\\python.exe' + + def _run_install_scripts(self, install_dir, executable=None): + dist = Distribution(self.settings) + dist.script_name = 'setup.py' + cmd = install_scripts(dist) + cmd.install_dir = install_dir + if executable is not None: + bs = cmd.get_finalized_command('build_scripts') + bs.executable = executable + cmd.ensure_finalized() + with contexts.quiet(): + cmd.run() + + @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only') + def test_sys_executable_escaping_unix(self, tmpdir, monkeypatch): + """ + Ensure that shebang is not quoted on Unix when getting the Python exe + from sys.executable. + """ + expected = f'#!{self.unix_exe}\n' + monkeypatch.setattr('sys.executable', self.unix_exe) + with tmpdir.as_cwd(): + self._run_install_scripts(str(tmpdir)) + with open(str(tmpdir.join('foo')), 'r', encoding="utf-8") as f: + actual = f.readline() + assert actual == expected + + @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only') + def test_sys_executable_escaping_win32(self, tmpdir, monkeypatch): + """ + Ensure that shebang is quoted on Windows when getting the Python exe + from sys.executable and it contains a space. + """ + expected = f'#!"{self.win32_exe}"\n' + monkeypatch.setattr('sys.executable', self.win32_exe) + with tmpdir.as_cwd(): + self._run_install_scripts(str(tmpdir)) + with open(str(tmpdir.join('foo-script.py')), 'r', encoding="utf-8") as f: + actual = f.readline() + assert actual == expected + + @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only') + def test_executable_with_spaces_escaping_unix(self, tmpdir): + """ + Ensure that shebang on Unix is not quoted, even when + a value with spaces + is specified using --executable. + """ + expected = f'#!{self.unix_spaces_exe}\n' + with tmpdir.as_cwd(): + self._run_install_scripts(str(tmpdir), self.unix_spaces_exe) + with open(str(tmpdir.join('foo')), 'r', encoding="utf-8") as f: + actual = f.readline() + assert actual == expected + + @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only') + def test_executable_arg_escaping_win32(self, tmpdir): + """ + Ensure that shebang on Windows is quoted when + getting a path with spaces + from --executable, that is itself properly quoted. + """ + expected = f'#!"{self.win32_exe}"\n' + with tmpdir.as_cwd(): + self._run_install_scripts(str(tmpdir), '"' + self.win32_exe + '"') + with open(str(tmpdir.join('foo-script.py')), 'r', encoding="utf-8") as f: + actual = f.readline() + assert actual == expected diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py new file mode 100644 index 0000000000000000000000000000000000000000..ea58001e93d8e4bcbd50bfd49303324d71858d16 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_logging.py @@ -0,0 +1,76 @@ +import functools +import inspect +import logging +import sys + +import pytest + +IS_PYPY = '__pypy__' in sys.builtin_module_names + + +setup_py = """\ +from setuptools import setup + +setup( + name="test_logging", + version="0.0" +) +""" + + +@pytest.mark.parametrize( + ('flag', 'expected_level'), [("--dry-run", "INFO"), ("--verbose", "DEBUG")] +) +def test_verbosity_level(tmp_path, monkeypatch, flag, expected_level): + """Make sure the correct verbosity level is set (issue #3038)""" + import setuptools # noqa: F401 # import setuptools to monkeypatch distutils + + import distutils # <- load distutils after all the patches take place + + logger = logging.Logger(__name__) + monkeypatch.setattr(logging, "root", logger) + unset_log_level = logger.getEffectiveLevel() + assert logging.getLevelName(unset_log_level) == "NOTSET" + + setup_script = tmp_path / "setup.py" + setup_script.write_text(setup_py, encoding="utf-8") + dist = distutils.core.run_setup(setup_script, stop_after="init") + dist.script_args = [flag, "sdist"] + dist.parse_command_line() # <- where the log level is set + log_level = logger.getEffectiveLevel() + log_level_name = logging.getLevelName(log_level) + assert log_level_name == expected_level + + +def flaky_on_pypy(func): + @functools.wraps(func) + def _func(): + try: + func() + except AssertionError: # pragma: no cover + if IS_PYPY: + msg = "Flaky monkeypatch on PyPy (#4124)" + pytest.xfail(f"{msg}. Original discussion in #3707, #3709.") + raise + + return _func + + +@flaky_on_pypy +def test_patching_does_not_cause_problems(): + # Ensure `dist.log` is only patched if necessary + + import _distutils_hack + + import setuptools.logging + + from distutils import dist + + setuptools.logging.configure() + + if _distutils_hack.enabled(): + # Modern logging infra, no problematic patching. + assert dist.__file__ is None or "setuptools" in dist.__file__ + assert isinstance(dist.log, logging.Logger) + else: + assert inspect.ismodule(dist.log) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..903a528db0cc2bba27bbcef24aa1c59dc4156528 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_manifest.py @@ -0,0 +1,622 @@ +"""sdist tests""" + +from __future__ import annotations + +import contextlib +import io +import itertools +import logging +import os +import shutil +import sys +import tempfile + +import pytest + +from setuptools.command.egg_info import FileList, egg_info, translate_pattern +from setuptools.dist import Distribution +from setuptools.tests.textwrap import DALS + +from distutils import log +from distutils.errors import DistutilsTemplateError + +IS_PYPY = '__pypy__' in sys.builtin_module_names + + +def make_local_path(s): + """Converts '/' in a string to os.sep""" + return s.replace('/', os.sep) + + +SETUP_ATTRS = { + 'name': 'app', + 'version': '0.0', + 'packages': ['app'], +} + +SETUP_PY = f"""\ +from setuptools import setup + +setup(**{SETUP_ATTRS!r}) +""" + + +@contextlib.contextmanager +def quiet(): + old_stdout, old_stderr = sys.stdout, sys.stderr + sys.stdout, sys.stderr = io.StringIO(), io.StringIO() + try: + yield + finally: + sys.stdout, sys.stderr = old_stdout, old_stderr + + +def touch(filename): + open(filename, 'wb').close() + + +# The set of files always in the manifest, including all files in the +# .egg-info directory +default_files = frozenset( + map( + make_local_path, + [ + 'README.rst', + 'MANIFEST.in', + 'setup.py', + 'app.egg-info/PKG-INFO', + 'app.egg-info/SOURCES.txt', + 'app.egg-info/dependency_links.txt', + 'app.egg-info/top_level.txt', + 'app/__init__.py', + ], + ) +) + + +translate_specs: list[tuple[str, list[str], list[str]]] = [ + ('foo', ['foo'], ['bar', 'foobar']), + ('foo/bar', ['foo/bar'], ['foo/bar/baz', './foo/bar', 'foo']), + # Glob matching + ('*.txt', ['foo.txt', 'bar.txt'], ['foo/foo.txt']), + ('dir/*.txt', ['dir/foo.txt', 'dir/bar.txt', 'dir/.txt'], ['notdir/foo.txt']), + ('*/*.py', ['bin/start.py'], []), + ('docs/page-?.txt', ['docs/page-9.txt'], ['docs/page-10.txt']), + # Globstars change what they mean depending upon where they are + ( + 'foo/**/bar', + ['foo/bing/bar', 'foo/bing/bang/bar', 'foo/bar'], + ['foo/abar'], + ), + ( + 'foo/**', + ['foo/bar/bing.py', 'foo/x'], + ['/foo/x'], + ), + ( + '**', + ['x', 'abc/xyz', '@nything'], + [], + ), + # Character classes + ( + 'pre[one]post', + ['preopost', 'prenpost', 'preepost'], + ['prepost', 'preonepost'], + ), + ( + 'hello[!one]world', + ['helloxworld', 'helloyworld'], + ['hellooworld', 'helloworld', 'hellooneworld'], + ), + ( + '[]one].txt', + ['o.txt', '].txt', 'e.txt'], + ['one].txt'], + ), + ( + 'foo[!]one]bar', + ['fooybar'], + ['foo]bar', 'fooobar', 'fooebar'], + ), +] +""" +A spec of inputs for 'translate_pattern' and matches and mismatches +for that input. +""" + +match_params = itertools.chain.from_iterable( + zip(itertools.repeat(pattern), matches) + for pattern, matches, mismatches in translate_specs +) + + +@pytest.fixture(params=match_params) +def pattern_match(request): + return map(make_local_path, request.param) + + +mismatch_params = itertools.chain.from_iterable( + zip(itertools.repeat(pattern), mismatches) + for pattern, matches, mismatches in translate_specs +) + + +@pytest.fixture(params=mismatch_params) +def pattern_mismatch(request): + return map(make_local_path, request.param) + + +def test_translated_pattern_match(pattern_match): + pattern, target = pattern_match + assert translate_pattern(pattern).match(target) + + +def test_translated_pattern_mismatch(pattern_mismatch): + pattern, target = pattern_mismatch + assert not translate_pattern(pattern).match(target) + + +class TempDirTestCase: + def setup_method(self, method): + self.temp_dir = tempfile.mkdtemp() + self.old_cwd = os.getcwd() + os.chdir(self.temp_dir) + + def teardown_method(self, method): + os.chdir(self.old_cwd) + shutil.rmtree(self.temp_dir) + + +class TestManifestTest(TempDirTestCase): + def setup_method(self, method): + super().setup_method(method) + + f = open(os.path.join(self.temp_dir, 'setup.py'), 'w', encoding="utf-8") + f.write(SETUP_PY) + f.close() + """ + Create a file tree like: + - LICENSE + - README.rst + - testing.rst + - .hidden.rst + - app/ + - __init__.py + - a.txt + - b.txt + - c.rst + - static/ + - app.js + - app.js.map + - app.css + - app.css.map + """ + + for fname in ['README.rst', '.hidden.rst', 'testing.rst', 'LICENSE']: + touch(os.path.join(self.temp_dir, fname)) + + # Set up the rest of the test package + test_pkg = os.path.join(self.temp_dir, 'app') + os.mkdir(test_pkg) + for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']: + touch(os.path.join(test_pkg, fname)) + + # Some compiled front-end assets to include + static = os.path.join(test_pkg, 'static') + os.mkdir(static) + for fname in ['app.js', 'app.js.map', 'app.css', 'app.css.map']: + touch(os.path.join(static, fname)) + + def make_manifest(self, contents): + """Write a MANIFEST.in.""" + manifest = os.path.join(self.temp_dir, 'MANIFEST.in') + with open(manifest, 'w', encoding="utf-8") as f: + f.write(DALS(contents)) + + def get_files(self): + """Run egg_info and get all the files to include, as a set""" + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = egg_info(dist) + cmd.ensure_finalized() + + cmd.run() + + return set(cmd.filelist.files) + + def test_no_manifest(self): + """Check a missing MANIFEST.in includes only the standard files.""" + assert (default_files - set(['MANIFEST.in'])) == self.get_files() + + def test_empty_files(self): + """Check an empty MANIFEST.in includes only the standard files.""" + self.make_manifest("") + assert default_files == self.get_files() + + def test_include(self): + """Include extra rst files in the project root.""" + self.make_manifest("include *.rst") + files = default_files | set(['testing.rst', '.hidden.rst']) + assert files == self.get_files() + + def test_exclude(self): + """Include everything in app/ except the text files""" + ml = make_local_path + self.make_manifest( + """ + include app/* + exclude app/*.txt + """ + ) + files = default_files | set([ml('app/c.rst')]) + assert files == self.get_files() + + def test_include_multiple(self): + """Include with multiple patterns.""" + ml = make_local_path + self.make_manifest("include app/*.txt app/static/*") + files = default_files | set([ + ml('app/a.txt'), + ml('app/b.txt'), + ml('app/static/app.js'), + ml('app/static/app.js.map'), + ml('app/static/app.css'), + ml('app/static/app.css.map'), + ]) + assert files == self.get_files() + + def test_graft(self): + """Include the whole app/static/ directory.""" + ml = make_local_path + self.make_manifest("graft app/static") + files = default_files | set([ + ml('app/static/app.js'), + ml('app/static/app.js.map'), + ml('app/static/app.css'), + ml('app/static/app.css.map'), + ]) + assert files == self.get_files() + + def test_graft_glob_syntax(self): + """Include the whole app/static/ directory.""" + ml = make_local_path + self.make_manifest("graft */static") + files = default_files | set([ + ml('app/static/app.js'), + ml('app/static/app.js.map'), + ml('app/static/app.css'), + ml('app/static/app.css.map'), + ]) + assert files == self.get_files() + + def test_graft_global_exclude(self): + """Exclude all *.map files in the project.""" + ml = make_local_path + self.make_manifest( + """ + graft app/static + global-exclude *.map + """ + ) + files = default_files | set([ml('app/static/app.js'), ml('app/static/app.css')]) + assert files == self.get_files() + + def test_global_include(self): + """Include all *.rst, *.js, and *.css files in the whole tree.""" + ml = make_local_path + self.make_manifest( + """ + global-include *.rst *.js *.css + """ + ) + files = default_files | set([ + '.hidden.rst', + 'testing.rst', + ml('app/c.rst'), + ml('app/static/app.js'), + ml('app/static/app.css'), + ]) + assert files == self.get_files() + + def test_graft_prune(self): + """Include all files in app/, except for the whole app/static/ dir.""" + ml = make_local_path + self.make_manifest( + """ + graft app + prune app/static + """ + ) + files = default_files | set([ml('app/a.txt'), ml('app/b.txt'), ml('app/c.rst')]) + assert files == self.get_files() + + +class TestFileListTest(TempDirTestCase): + """ + A copy of the relevant bits of distutils/tests/test_filelist.py, + to ensure setuptools' version of FileList keeps parity with distutils. + """ + + @pytest.fixture(autouse=os.getenv("SETUPTOOLS_USE_DISTUTILS") == "stdlib") + def _compat_record_logs(self, monkeypatch, caplog): + """Account for stdlib compatibility""" + + def _log(_logger, level, msg, args): + exc = sys.exc_info() + rec = logging.LogRecord("distutils", level, "", 0, msg, args, exc) + caplog.records.append(rec) + + monkeypatch.setattr(log.Log, "_log", _log) + + def get_records(self, caplog, *levels): + return [r for r in caplog.records if r.levelno in levels] + + def assertNoWarnings(self, caplog): + assert self.get_records(caplog, log.WARN) == [] + caplog.clear() + + def assertWarnings(self, caplog): + if IS_PYPY and not caplog.records: + pytest.xfail("caplog checks may not work well in PyPy") + else: + assert len(self.get_records(caplog, log.WARN)) > 0 + caplog.clear() + + def make_files(self, files): + for file in files: + file = os.path.join(self.temp_dir, file) + dirname, _basename = os.path.split(file) + os.makedirs(dirname, exist_ok=True) + touch(file) + + def test_process_template_line(self): + # testing all MANIFEST.in template patterns + file_list = FileList() + ml = make_local_path + + # simulated file list + self.make_files([ + 'foo.tmp', + 'ok', + 'xo', + 'four.txt', + 'buildout.cfg', + # filelist does not filter out VCS directories, + # it's sdist that does + ml('.hg/last-message.txt'), + ml('global/one.txt'), + ml('global/two.txt'), + ml('global/files.x'), + ml('global/here.tmp'), + ml('f/o/f.oo'), + ml('dir/graft-one'), + ml('dir/dir2/graft2'), + ml('dir3/ok'), + ml('dir3/sub/ok.txt'), + ]) + + MANIFEST_IN = DALS( + """\ + include ok + include xo + exclude xo + include foo.tmp + include buildout.cfg + global-include *.x + global-include *.txt + global-exclude *.tmp + recursive-include f *.oo + recursive-exclude global *.x + graft dir + prune dir3 + """ + ) + + for line in MANIFEST_IN.split('\n'): + if not line: + continue + file_list.process_template_line(line) + + wanted = [ + 'buildout.cfg', + 'four.txt', + 'ok', + ml('.hg/last-message.txt'), + ml('dir/graft-one'), + ml('dir/dir2/graft2'), + ml('f/o/f.oo'), + ml('global/one.txt'), + ml('global/two.txt'), + ] + + file_list.sort() + assert file_list.files == wanted + + def test_exclude_pattern(self): + # return False if no match + file_list = FileList() + assert not file_list.exclude_pattern('*.py') + + # return True if files match + file_list = FileList() + file_list.files = ['a.py', 'b.py'] + assert file_list.exclude_pattern('*.py') + + # test excludes + file_list = FileList() + file_list.files = ['a.py', 'a.txt'] + file_list.exclude_pattern('*.py') + file_list.sort() + assert file_list.files == ['a.txt'] + + def test_include_pattern(self): + # return False if no match + file_list = FileList() + self.make_files([]) + assert not file_list.include_pattern('*.py') + + # return True if files match + file_list = FileList() + self.make_files(['a.py', 'b.txt']) + assert file_list.include_pattern('*.py') + + # test * matches all files + file_list = FileList() + self.make_files(['a.py', 'b.txt']) + file_list.include_pattern('*') + file_list.sort() + assert file_list.files == ['a.py', 'b.txt'] + + def test_process_template_line_invalid(self): + # invalid lines + file_list = FileList() + for action in ( + 'include', + 'exclude', + 'global-include', + 'global-exclude', + 'recursive-include', + 'recursive-exclude', + 'graft', + 'prune', + 'blarg', + ): + with pytest.raises(DistutilsTemplateError): + file_list.process_template_line(action) + + def test_include(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # include + file_list = FileList() + self.make_files(['a.py', 'b.txt', ml('d/c.py')]) + + file_list.process_template_line('include *.py') + file_list.sort() + assert file_list.files == ['a.py'] + self.assertNoWarnings(caplog) + + file_list.process_template_line('include *.rb') + file_list.sort() + assert file_list.files == ['a.py'] + self.assertWarnings(caplog) + + def test_exclude(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # exclude + file_list = FileList() + file_list.files = ['a.py', 'b.txt', ml('d/c.py')] + + file_list.process_template_line('exclude *.py') + file_list.sort() + assert file_list.files == ['b.txt', ml('d/c.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('exclude *.rb') + file_list.sort() + assert file_list.files == ['b.txt', ml('d/c.py')] + self.assertWarnings(caplog) + + def test_global_include(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # global-include + file_list = FileList() + self.make_files(['a.py', 'b.txt', ml('d/c.py')]) + + file_list.process_template_line('global-include *.py') + file_list.sort() + assert file_list.files == ['a.py', ml('d/c.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('global-include *.rb') + file_list.sort() + assert file_list.files == ['a.py', ml('d/c.py')] + self.assertWarnings(caplog) + + def test_global_exclude(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # global-exclude + file_list = FileList() + file_list.files = ['a.py', 'b.txt', ml('d/c.py')] + + file_list.process_template_line('global-exclude *.py') + file_list.sort() + assert file_list.files == ['b.txt'] + self.assertNoWarnings(caplog) + + file_list.process_template_line('global-exclude *.rb') + file_list.sort() + assert file_list.files == ['b.txt'] + self.assertWarnings(caplog) + + def test_recursive_include(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # recursive-include + file_list = FileList() + self.make_files(['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')]) + + file_list.process_template_line('recursive-include d *.py') + file_list.sort() + assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('recursive-include e *.py') + file_list.sort() + assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')] + self.assertWarnings(caplog) + + def test_recursive_exclude(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # recursive-exclude + file_list = FileList() + file_list.files = ['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')] + + file_list.process_template_line('recursive-exclude d *.py') + file_list.sort() + assert file_list.files == ['a.py', ml('d/c.txt')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('recursive-exclude e *.py') + file_list.sort() + assert file_list.files == ['a.py', ml('d/c.txt')] + self.assertWarnings(caplog) + + def test_graft(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # graft + file_list = FileList() + self.make_files(['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')]) + + file_list.process_template_line('graft d') + file_list.sort() + assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('graft e') + file_list.sort() + assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')] + self.assertWarnings(caplog) + + def test_prune(self, caplog): + caplog.set_level(logging.DEBUG) + ml = make_local_path + # prune + file_list = FileList() + file_list.files = ['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')] + + file_list.process_template_line('prune d') + file_list.sort() + assert file_list.files == ['a.py', ml('f/f.py')] + self.assertNoWarnings(caplog) + + file_list.process_template_line('prune e') + file_list.sort() + assert file_list.files == ['a.py', ml('f/f.py')] + self.assertWarnings(caplog) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py new file mode 100644 index 0000000000000000000000000000000000000000..a0f4120bf7900b2118cc066034e036ab7af1798b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_namespaces.py @@ -0,0 +1,138 @@ +import subprocess +import sys + +from setuptools._path import paths_on_pythonpath + +from . import namespaces + + +class TestNamespaces: + def test_mixed_site_and_non_site(self, tmpdir): + """ + Installing two packages sharing the same namespace, one installed + to a site dir and the other installed just to a path on PYTHONPATH + should leave the namespace in tact and both packages reachable by + import. + """ + pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA') + pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB') + site_packages = tmpdir / 'site-packages' + path_packages = tmpdir / 'path-packages' + targets = site_packages, path_packages + # use pip to install to the target directory + install_cmd = [ + sys.executable, + '-m', + 'pip.__main__', + 'install', + str(pkg_A), + '-t', + str(site_packages), + ] + subprocess.check_call(install_cmd) + namespaces.make_site_dir(site_packages) + install_cmd = [ + sys.executable, + '-m', + 'pip.__main__', + 'install', + str(pkg_B), + '-t', + str(path_packages), + ] + subprocess.check_call(install_cmd) + try_import = [ + sys.executable, + '-c', + 'import myns.pkgA; import myns.pkgB', + ] + with paths_on_pythonpath(map(str, targets)): + subprocess.check_call(try_import) + + def test_pkg_resources_import(self, tmpdir): + """ + Ensure that a namespace package doesn't break on import + of pkg_resources. + """ + pkg = namespaces.build_namespace_package(tmpdir, 'myns.pkgA') + target = tmpdir / 'packages' + target.mkdir() + install_cmd = [ + sys.executable, + '-m', + 'pip', + 'install', + '-t', + str(target), + str(pkg), + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(install_cmd) + namespaces.make_site_dir(target) + try_import = [ + sys.executable, + '-c', + 'import pkg_resources', + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(try_import) + + def test_namespace_package_installed_and_cwd(self, tmpdir): + """ + Installing a namespace packages but also having it in the current + working directory, only one version should take precedence. + """ + pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA') + target = tmpdir / 'packages' + # use pip to install to the target directory + install_cmd = [ + sys.executable, + '-m', + 'pip.__main__', + 'install', + str(pkg_A), + '-t', + str(target), + ] + subprocess.check_call(install_cmd) + namespaces.make_site_dir(target) + + # ensure that package imports and pkg_resources imports + pkg_resources_imp = [ + sys.executable, + '-c', + 'import pkg_resources; import myns.pkgA', + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(pkg_resources_imp, cwd=str(pkg_A)) + + def test_packages_in_the_same_namespace_installed_and_cwd(self, tmpdir): + """ + Installing one namespace package and also have another in the same + namespace in the current working directory, both of them must be + importable. + """ + pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA') + pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB') + target = tmpdir / 'packages' + # use pip to install to the target directory + install_cmd = [ + sys.executable, + '-m', + 'pip.__main__', + 'install', + str(pkg_A), + '-t', + str(target), + ] + subprocess.check_call(install_cmd) + namespaces.make_site_dir(target) + + # ensure that all packages import and pkg_resources imports + pkg_resources_imp = [ + sys.executable, + '-c', + 'import pkg_resources; import myns.pkgA; import myns.pkgB', + ] + with paths_on_pythonpath([str(target)]): + subprocess.check_call(pkg_resources_imp, cwd=str(pkg_B)) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py new file mode 100644 index 0000000000000000000000000000000000000000..2a6e5917a8733c71a5d9b29d4bde6fc12cc1e183 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_packageindex.py @@ -0,0 +1,267 @@ +import http.client +import re +import urllib.error +import urllib.request +from inspect import cleandoc + +import pytest + +import setuptools.package_index + +import distutils.errors + + +class TestPackageIndex: + def test_regex(self): + hash_url = 'http://other_url?:action=show_md5&' + hash_url += 'digest=0123456789abcdef0123456789abcdef' + doc = """ + Name + (md5) + """.lstrip().format(**locals()) + assert setuptools.package_index.PYPI_MD5.match(doc) + + def test_bad_url_bad_port(self): + index = setuptools.package_index.PackageIndex() + url = 'http://127.0.0.1:0/nonesuch/test_package_index' + with pytest.raises(Exception, match=re.escape(url)): + v = index.open_url(url) + assert isinstance(v, urllib.error.HTTPError) + + def test_bad_url_typo(self): + # issue 16 + # easy_install inquant.contentmirror.plone breaks because of a typo + # in its home URL + index = setuptools.package_index.PackageIndex(hosts=('www.example.com',)) + + url = 'url:%20https://svn.plone.org/svn/collective/inquant.contentmirror.plone/trunk' + + with pytest.raises(Exception, match=re.escape(url)): + v = index.open_url(url) + assert isinstance(v, urllib.error.HTTPError) + + def test_bad_url_bad_status_line(self): + index = setuptools.package_index.PackageIndex(hosts=('www.example.com',)) + + def _urlopen(*args): + raise http.client.BadStatusLine('line') + + index.opener = _urlopen + url = 'http://example.com' + with pytest.raises(Exception, match=r'line'): + index.open_url(url) + + def test_bad_url_double_scheme(self): + """ + A bad URL with a double scheme should raise a DistutilsError. + """ + index = setuptools.package_index.PackageIndex(hosts=('www.example.com',)) + + # issue 20 + url = 'http://http://svn.pythonpaste.org/Paste/wphp/trunk' + try: + index.open_url(url) + except distutils.errors.DistutilsError as error: + msg = str(error) + assert ( + 'nonnumeric port' in msg + or 'getaddrinfo failed' in msg + or 'Name or service not known' in msg + ) + return + raise RuntimeError("Did not raise") + + def test_url_ok(self): + index = setuptools.package_index.PackageIndex(hosts=('www.example.com',)) + url = 'file:///tmp/test_package_index' + assert index.url_ok(url, True) + + def test_parse_bdist_wininst(self): + parse = setuptools.package_index.parse_bdist_wininst + + actual = parse('reportlab-2.5.win32-py2.4.exe') + expected = 'reportlab-2.5', '2.4', 'win32' + assert actual == expected + + actual = parse('reportlab-2.5.win32.exe') + expected = 'reportlab-2.5', None, 'win32' + assert actual == expected + + actual = parse('reportlab-2.5.win-amd64-py2.7.exe') + expected = 'reportlab-2.5', '2.7', 'win-amd64' + assert actual == expected + + actual = parse('reportlab-2.5.win-amd64.exe') + expected = 'reportlab-2.5', None, 'win-amd64' + assert actual == expected + + def test__vcs_split_rev_from_url(self): + """ + Test the basic usage of _vcs_split_rev_from_url + """ + vsrfu = setuptools.package_index.PackageIndex._vcs_split_rev_from_url + url, rev = vsrfu('https://example.com/bar@2995') + assert url == 'https://example.com/bar' + assert rev == '2995' + + def test_local_index(self, tmpdir): + """ + local_open should be able to read an index from the file system. + """ + index_file = tmpdir / 'index.html' + with index_file.open('w') as f: + f.write('
content
') + url = 'file:' + urllib.request.pathname2url(str(tmpdir)) + '/' + res = setuptools.package_index.local_open(url) + assert 'content' in res.read() + + def test_egg_fragment(self): + """ + EGG fragments must comply to PEP 440 + """ + epoch = [ + '', + '1!', + ] + releases = [ + '0', + '0.0', + '0.0.0', + ] + pre = [ + 'a0', + 'b0', + 'rc0', + ] + post = ['.post0'] + dev = [ + '.dev0', + ] + local = [ + ('', ''), + ('+ubuntu.0', '+ubuntu.0'), + ('+ubuntu-0', '+ubuntu.0'), + ('+ubuntu_0', '+ubuntu.0'), + ] + versions = [ + [''.join([e, r, p, loc]) for loc in locs] + for e in epoch + for r in releases + for p in sum([pre, post, dev], ['']) + for locs in local + ] + for v, vc in versions: + dists = list( + setuptools.package_index.distros_for_url( + 'http://example.com/example-foo.zip#egg=example-foo-' + v + ) + ) + assert dists[0].version == '' + assert dists[1].version == vc + + def test_download_git_with_rev(self, tmp_path, fp): + url = 'git+https://github.example/group/project@master#egg=foo' + index = setuptools.package_index.PackageIndex() + + expected_dir = tmp_path / 'project@master' + fp.register([ + 'git', + 'clone', + '--quiet', + 'https://github.example/group/project', + expected_dir, + ]) + fp.register(['git', '-C', expected_dir, 'checkout', '--quiet', 'master']) + + result = index.download(url, tmp_path) + + assert result == str(expected_dir) + assert len(fp.calls) == 2 + + def test_download_git_no_rev(self, tmp_path, fp): + url = 'git+https://github.example/group/project#egg=foo' + index = setuptools.package_index.PackageIndex() + + expected_dir = tmp_path / 'project' + fp.register([ + 'git', + 'clone', + '--quiet', + 'https://github.example/group/project', + expected_dir, + ]) + index.download(url, tmp_path) + + def test_download_svn(self, tmp_path): + url = 'svn+https://svn.example/project#egg=foo' + index = setuptools.package_index.PackageIndex() + + msg = r".*SVN download is not supported.*" + with pytest.raises(distutils.errors.DistutilsError, match=msg): + index.download(url, tmp_path) + + +class TestContentCheckers: + def test_md5(self): + checker = setuptools.package_index.HashChecker.from_url( + 'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478' + ) + checker.feed('You should probably not be using MD5'.encode('ascii')) + assert checker.hash.hexdigest() == 'f12895fdffbd45007040d2e44df98478' + assert checker.is_valid() + + def test_other_fragment(self): + "Content checks should succeed silently if no hash is present" + checker = setuptools.package_index.HashChecker.from_url( + 'http://foo/bar#something%20completely%20different' + ) + checker.feed('anything'.encode('ascii')) + assert checker.is_valid() + + def test_blank_md5(self): + "Content checks should succeed if a hash is empty" + checker = setuptools.package_index.HashChecker.from_url('http://foo/bar#md5=') + checker.feed('anything'.encode('ascii')) + assert checker.is_valid() + + def test_get_hash_name_md5(self): + checker = setuptools.package_index.HashChecker.from_url( + 'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478' + ) + assert checker.hash_name == 'md5' + + def test_report(self): + checker = setuptools.package_index.HashChecker.from_url( + 'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478' + ) + rep = checker.report(lambda x: x, 'My message about %s') + assert rep == 'My message about md5' + + +class TestPyPIConfig: + def test_percent_in_password(self, tmp_home_dir): + pypirc = tmp_home_dir / '.pypirc' + pypirc.write_text( + cleandoc( + """ + [pypi] + repository=https://pypi.org + username=jaraco + password=pity% + """ + ), + encoding="utf-8", + ) + cfg = setuptools.package_index.PyPIConfig() + cred = cfg.creds_by_repository['https://pypi.org'] + assert cred.username == 'jaraco' + assert cred.password == 'pity%' + + +@pytest.mark.timeout(1) +def test_REL_DoS(): + """ + REL should not hang on a contrived attack string. + """ + setuptools.package_index.REL.search('< rel=' + ' ' * 2**12) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py new file mode 100644 index 0000000000000000000000000000000000000000..a476b7c93d7441834f415223cb386859581724f8 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_sandbox.py @@ -0,0 +1,134 @@ +"""develop tests""" + +import os +import types + +import pytest + +import pkg_resources +import setuptools.sandbox + + +class TestSandbox: + def test_devnull(self, tmpdir): + with setuptools.sandbox.DirectorySandbox(str(tmpdir)): + self._file_writer(os.devnull) + + @staticmethod + def _file_writer(path): + def do_write(): + with open(path, 'w', encoding="utf-8") as f: + f.write('xxx') + + return do_write + + def test_setup_py_with_BOM(self): + """ + It should be possible to execute a setup.py with a Byte Order Mark + """ + target = pkg_resources.resource_filename(__name__, 'script-with-bom.py') + namespace = types.ModuleType('namespace') + setuptools.sandbox._execfile(target, vars(namespace)) + assert namespace.result == 'passed' + + def test_setup_py_with_CRLF(self, tmpdir): + setup_py = tmpdir / 'setup.py' + with setup_py.open('wb') as stream: + stream.write(b'"degenerate script"\r\n') + setuptools.sandbox._execfile(str(setup_py), globals()) + + +class TestExceptionSaver: + def test_exception_trapped(self): + with setuptools.sandbox.ExceptionSaver(): + raise ValueError("details") + + def test_exception_resumed(self): + with setuptools.sandbox.ExceptionSaver() as saved_exc: + raise ValueError("details") + + with pytest.raises(ValueError) as caught: + saved_exc.resume() + + assert isinstance(caught.value, ValueError) + assert str(caught.value) == 'details' + + def test_exception_reconstructed(self): + orig_exc = ValueError("details") + + with setuptools.sandbox.ExceptionSaver() as saved_exc: + raise orig_exc + + with pytest.raises(ValueError) as caught: + saved_exc.resume() + + assert isinstance(caught.value, ValueError) + assert caught.value is not orig_exc + + def test_no_exception_passes_quietly(self): + with setuptools.sandbox.ExceptionSaver() as saved_exc: + pass + + saved_exc.resume() + + def test_unpickleable_exception(self): + class CantPickleThis(Exception): + "This Exception is unpickleable because it's not in globals" + + def __repr__(self) -> str: + return f'CantPickleThis{self.args!r}' + + with setuptools.sandbox.ExceptionSaver() as saved_exc: + raise CantPickleThis('detail') + + with pytest.raises(setuptools.sandbox.UnpickleableException) as caught: + saved_exc.resume() + + assert str(caught.value) == "CantPickleThis('detail',)" + + def test_unpickleable_exception_when_hiding_setuptools(self): + """ + As revealed in #440, an infinite recursion can occur if an unpickleable + exception while setuptools is hidden. Ensure this doesn't happen. + """ + + class ExceptionUnderTest(Exception): + """ + An unpickleable exception (not in globals). + """ + + with pytest.raises(setuptools.sandbox.UnpickleableException) as caught: + with setuptools.sandbox.save_modules(): + setuptools.sandbox.hide_setuptools() + raise ExceptionUnderTest + + (msg,) = caught.value.args + assert msg == 'ExceptionUnderTest()' + + def test_sandbox_violation_raised_hiding_setuptools(self, tmpdir): + """ + When in a sandbox with setuptools hidden, a SandboxViolation + should reflect a proper exception and not be wrapped in + an UnpickleableException. + """ + + def write_file(): + "Trigger a SandboxViolation by writing outside the sandbox" + with open('/etc/foo', 'w', encoding="utf-8"): + pass + + with pytest.raises(setuptools.sandbox.SandboxViolation) as caught: + with setuptools.sandbox.save_modules(): + setuptools.sandbox.hide_setuptools() + with setuptools.sandbox.DirectorySandbox(str(tmpdir)): + write_file() + + cmd, args, kwargs = caught.value.args + assert cmd == 'open' + assert args == ('/etc/foo', 'w') + assert kwargs == {"encoding": "utf-8"} + + msg = str(caught.value) + assert 'open' in msg + assert "('/etc/foo', 'w')" in msg + assert "{'encoding': 'utf-8'}" in msg diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py new file mode 100644 index 0000000000000000000000000000000000000000..19d8ddf6dafb0cacc044a6021f283d3e9faaf800 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_sdist.py @@ -0,0 +1,984 @@ +"""sdist tests""" + +import contextlib +import io +import logging +import os +import pathlib +import sys +import tarfile +import tempfile +import unicodedata +from inspect import cleandoc +from pathlib import Path +from unittest import mock + +import jaraco.path +import pytest + +from setuptools import Command, SetuptoolsDeprecationWarning +from setuptools._importlib import metadata +from setuptools.command.egg_info import manifest_maker +from setuptools.command.sdist import sdist +from setuptools.dist import Distribution +from setuptools.extension import Extension +from setuptools.tests import fail_on_ascii + +from .text import Filenames + +import distutils +from distutils.core import run_setup + +SETUP_ATTRS = { + 'name': 'sdist_test', + 'version': '0.0', + 'packages': ['sdist_test'], + 'package_data': {'sdist_test': ['*.txt']}, + 'data_files': [("data", [os.path.join("d", "e.dat")])], +} + +SETUP_PY = f"""\ +from setuptools import setup + +setup(**{SETUP_ATTRS!r}) +""" + +EXTENSION = Extension( + name="sdist_test.f", + sources=[os.path.join("sdist_test", "f.c")], + depends=[os.path.join("sdist_test", "f.h")], +) +EXTENSION_SOURCES = EXTENSION.sources + EXTENSION.depends + + +@contextlib.contextmanager +def quiet(): + old_stdout, old_stderr = sys.stdout, sys.stderr + sys.stdout, sys.stderr = io.StringIO(), io.StringIO() + try: + yield + finally: + sys.stdout, sys.stderr = old_stdout, old_stderr + + +# Convert to POSIX path +def posix(path): + if not isinstance(path, str): + return path.replace(os.sep.encode('ascii'), b'/') + else: + return path.replace(os.sep, '/') + + +# HFS Plus uses decomposed UTF-8 +def decompose(path): + if isinstance(path, str): + return unicodedata.normalize('NFD', path) + try: + path = path.decode('utf-8') + path = unicodedata.normalize('NFD', path) + path = path.encode('utf-8') + except UnicodeError: + pass # Not UTF-8 + return path + + +def read_all_bytes(filename): + with open(filename, 'rb') as fp: + return fp.read() + + +def latin1_fail(): + try: + desc, filename = tempfile.mkstemp(suffix=Filenames.latin_1) + os.close(desc) + os.remove(filename) + except Exception: + return True + + +fail_on_latin1_encoded_filenames = pytest.mark.xfail( + latin1_fail(), + reason="System does not support latin-1 filenames", +) + + +skip_under_xdist = pytest.mark.skipif( + "os.environ.get('PYTEST_XDIST_WORKER')", + reason="pytest-dev/pytest-xdist#843", +) +skip_under_stdlib_distutils = pytest.mark.skipif( + not distutils.__package__.startswith('setuptools'), + reason="the test is not supported with stdlib distutils", +) + + +def touch(path): + open(path, 'wb').close() + return path + + +def symlink_or_skip_test(src, dst): + try: + os.symlink(src, dst) + except (OSError, NotImplementedError): + pytest.skip("symlink not supported in OS") + return None + return dst + + +class TestSdistTest: + @pytest.fixture(autouse=True) + def source_dir(self, tmpdir): + tmpdir = tmpdir / "project_root" + tmpdir.mkdir() + + (tmpdir / 'setup.py').write_text(SETUP_PY, encoding='utf-8') + + # Set up the rest of the test package + test_pkg = tmpdir / 'sdist_test' + test_pkg.mkdir() + data_folder = tmpdir / 'd' + data_folder.mkdir() + # *.rst was not included in package_data, so c.rst should not be + # automatically added to the manifest when not under version control + for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']: + touch(test_pkg / fname) + touch(data_folder / 'e.dat') + # C sources are not included by default, but they will be, + # if an extension module uses them as sources or depends + for fname in EXTENSION_SOURCES: + touch(tmpdir / fname) + + with tmpdir.as_cwd(): + yield tmpdir + + def assert_package_data_in_manifest(self, cmd): + manifest = cmd.filelist.files + assert os.path.join('sdist_test', 'a.txt') in manifest + assert os.path.join('sdist_test', 'b.txt') in manifest + assert os.path.join('sdist_test', 'c.rst') not in manifest + assert os.path.join('d', 'e.dat') in manifest + + def setup_with_extension(self): + setup_attrs = {**SETUP_ATTRS, 'ext_modules': [EXTENSION]} + + dist = Distribution(setup_attrs) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + return cmd + + def test_package_data_in_sdist(self): + """Regression test for pull request #4: ensures that files listed in + package_data are included in the manifest even if they're not added to + version control. + """ + + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + self.assert_package_data_in_manifest(cmd) + + def test_package_data_and_include_package_data_in_sdist(self): + """ + Ensure package_data and include_package_data work + together. + """ + setup_attrs = {**SETUP_ATTRS, 'include_package_data': True} + assert setup_attrs['package_data'] + + dist = Distribution(setup_attrs) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + self.assert_package_data_in_manifest(cmd) + + def test_extension_sources_in_sdist(self): + """ + Ensure that the files listed in Extension.sources and Extension.depends + are automatically included in the manifest. + """ + cmd = self.setup_with_extension() + self.assert_package_data_in_manifest(cmd) + manifest = cmd.filelist.files + for path in EXTENSION_SOURCES: + assert path in manifest + + def test_missing_extension_sources(self): + """ + Similar to test_extension_sources_in_sdist but the referenced files don't exist. + Missing files should not be included in distribution (with no error raised). + """ + for path in EXTENSION_SOURCES: + os.remove(path) + + cmd = self.setup_with_extension() + self.assert_package_data_in_manifest(cmd) + manifest = cmd.filelist.files + for path in EXTENSION_SOURCES: + assert path not in manifest + + def test_symlinked_extension_sources(self): + """ + Similar to test_extension_sources_in_sdist but the referenced files are + instead symbolic links to project-local files. Referenced file paths + should be included. Symlink targets themselves should NOT be included. + """ + symlinked = [] + for path in EXTENSION_SOURCES: + base, ext = os.path.splitext(path) + target = base + "_target." + ext + + os.rename(path, target) + symlink_or_skip_test(os.path.basename(target), path) + symlinked.append(target) + + cmd = self.setup_with_extension() + self.assert_package_data_in_manifest(cmd) + manifest = cmd.filelist.files + for path in EXTENSION_SOURCES: + assert path in manifest + for path in symlinked: + assert path not in manifest + + _INVALID_PATHS = { + "must be relative": lambda: ( + os.path.abspath(os.path.join("sdist_test", "f.h")) + ), + "can't have `..` segments": lambda: ( + os.path.join("sdist_test", "..", "sdist_test", "f.h") + ), + "doesn't exist": lambda: ( + os.path.join("sdist_test", "this_file_does_not_exist.h") + ), + "must be inside the project root": lambda: ( + symlink_or_skip_test( + touch(os.path.join("..", "outside_of_project_root.h")), + "symlink.h", + ) + ), + } + + @skip_under_stdlib_distutils + @pytest.mark.parametrize("reason", _INVALID_PATHS.keys()) + def test_invalid_extension_depends(self, reason, caplog): + """ + Due to backwards compatibility reasons, `Extension.depends` should accept + invalid/weird paths, but then ignore them when building a sdist. + + This test verifies that the source distribution is still built + successfully with such paths, but that instead of adding these paths to + the manifest, we emit an informational message, notifying the user that + the invalid path won't be automatically included. + """ + invalid_path = self._INVALID_PATHS[reason]() + extension = Extension( + name="sdist_test.f", + sources=[], + depends=[invalid_path], + ) + setup_attrs = {**SETUP_ATTRS, 'ext_modules': [extension]} + + dist = Distribution(setup_attrs) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(), caplog.at_level(logging.INFO): + cmd.run() + + self.assert_package_data_in_manifest(cmd) + manifest = cmd.filelist.files + assert invalid_path not in manifest + + expected_message = [ + message + for (logger, level, message) in caplog.record_tuples + if ( + logger == "root" # + and level == logging.INFO # + and invalid_path in message # + ) + ] + assert len(expected_message) == 1 + (expected_message,) = expected_message + assert reason in expected_message + + def test_custom_build_py(self): + """ + Ensure projects defining custom build_py don't break + when creating sdists (issue #2849) + """ + from distutils.command.build_py import build_py as OrigBuildPy + + using_custom_command_guard = mock.Mock() + + class CustomBuildPy(OrigBuildPy): + """ + Some projects have custom commands inheriting from `distutils` + """ + + def get_data_files(self): + using_custom_command_guard() + return super().get_data_files() + + setup_attrs = {**SETUP_ATTRS, 'include_package_data': True} + assert setup_attrs['package_data'] + + dist = Distribution(setup_attrs) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + # Make sure we use the custom command + cmd.cmdclass = {'build_py': CustomBuildPy} + cmd.distribution.cmdclass = {'build_py': CustomBuildPy} + assert cmd.distribution.get_command_class('build_py') == CustomBuildPy + + msg = "setuptools instead of distutils" + with quiet(), pytest.warns(SetuptoolsDeprecationWarning, match=msg): + cmd.run() + + using_custom_command_guard.assert_called() + self.assert_package_data_in_manifest(cmd) + + def test_setup_py_exists(self): + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'foo.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + manifest = cmd.filelist.files + assert 'setup.py' in manifest + + def test_setup_py_missing(self): + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'foo.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + if os.path.exists("setup.py"): + os.remove("setup.py") + with quiet(): + cmd.run() + + manifest = cmd.filelist.files + assert 'setup.py' not in manifest + + def test_setup_py_excluded(self): + with open("MANIFEST.in", "w", encoding="utf-8") as manifest_file: + manifest_file.write("exclude setup.py") + + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'foo.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + manifest = cmd.filelist.files + assert 'setup.py' not in manifest + + def test_defaults_case_sensitivity(self, source_dir): + """ + Make sure default files (README.*, etc.) are added in a case-sensitive + way to avoid problems with packages built on Windows. + """ + + touch(source_dir / 'readme.rst') + touch(source_dir / 'SETUP.cfg') + + dist = Distribution(SETUP_ATTRS) + # the extension deliberately capitalized for this test + # to make sure the actual filename (not capitalized) gets added + # to the manifest + dist.script_name = 'setup.PY' + cmd = sdist(dist) + cmd.ensure_finalized() + + with quiet(): + cmd.run() + + # lowercase all names so we can test in a + # case-insensitive way to make sure the files + # are not included. + manifest = map(lambda x: x.lower(), cmd.filelist.files) + assert 'readme.rst' not in manifest, manifest + assert 'setup.py' not in manifest, manifest + assert 'setup.cfg' not in manifest, manifest + + def test_exclude_dev_only_cache_folders(self, source_dir): + included = { + # Emulate problem in https://github.com/pypa/setuptools/issues/4601 + "MANIFEST.in": ( + "global-include LICEN[CS]E* COPYING* NOTICE* AUTHORS*\n" + "global-include *.txt\n" + ), + # For the sake of being conservative and limiting unforeseen side-effects + # we just exclude dev-only cache folders at the root of the repository: + "test/.venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "", + "src/.nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "", + "doc/.tox/default/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "", + # Let's test against false positives with similarly named files: + ".venv-requirements.txt": "", + ".tox-coveragerc.txt": "", + ".noxy/coveragerc.txt": "", + } + + excluded = { + # .tox/.nox/.venv are well-know folders present at the root of Python repos + # and therefore should be excluded + ".tox/release/lib/python3.11/site-packages/foo-4.dist-info/LICENSE": "", + ".nox/py/lib/python3.12/site-packages/bar-2.dist-info/COPYING.txt": "", + ".venv/lib/python3.9/site-packages/bar-2.dist-info/AUTHORS.rst": "", + } + + for file, content in {**excluded, **included}.items(): + Path(source_dir, file).parent.mkdir(parents=True, exist_ok=True) + Path(source_dir, file).write_text(content, encoding="utf-8") + + cmd = self.setup_with_extension() + self.assert_package_data_in_manifest(cmd) + manifest = {f.replace(os.sep, '/') for f in cmd.filelist.files} + for path in excluded: + assert os.path.exists(path) + assert path not in manifest, (path, manifest) + for path in included: + assert os.path.exists(path) + assert path in manifest, (path, manifest) + + @fail_on_ascii + def test_manifest_is_written_with_utf8_encoding(self): + # Test for #303. + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + mm = manifest_maker(dist) + mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt') + os.mkdir('sdist_test.egg-info') + + # UTF-8 filename + filename = os.path.join('sdist_test', 'smörbröd.py') + + # Must create the file or it will get stripped. + touch(filename) + + # Add UTF-8 filename and write manifest + with quiet(): + mm.run() + mm.filelist.append(filename) + mm.write_manifest() + + contents = read_all_bytes(mm.manifest) + + # The manifest should be UTF-8 encoded + u_contents = contents.decode('UTF-8') + + # The manifest should contain the UTF-8 filename + assert posix(filename) in u_contents + + @fail_on_ascii + def test_write_manifest_allows_utf8_filenames(self): + # Test for #303. + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + mm = manifest_maker(dist) + mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt') + os.mkdir('sdist_test.egg-info') + + filename = os.path.join(b'sdist_test', Filenames.utf_8) + + # Must touch the file or risk removal + touch(filename) + + # Add filename and write manifest + with quiet(): + mm.run() + u_filename = filename.decode('utf-8') + mm.filelist.files.append(u_filename) + # Re-write manifest + mm.write_manifest() + + contents = read_all_bytes(mm.manifest) + + # The manifest should be UTF-8 encoded + contents.decode('UTF-8') + + # The manifest should contain the UTF-8 filename + assert posix(filename) in contents + + # The filelist should have been updated as well + assert u_filename in mm.filelist.files + + @skip_under_xdist + def test_write_manifest_skips_non_utf8_filenames(self): + """ + Files that cannot be encoded to UTF-8 (specifically, those that + weren't originally successfully decoded and have surrogate + escapes) should be omitted from the manifest. + See https://bitbucket.org/tarek/distribute/issue/303 for history. + """ + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + mm = manifest_maker(dist) + mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt') + os.mkdir('sdist_test.egg-info') + + # Latin-1 filename + filename = os.path.join(b'sdist_test', Filenames.latin_1) + + # Add filename with surrogates and write manifest + with quiet(): + mm.run() + u_filename = filename.decode('utf-8', 'surrogateescape') + mm.filelist.append(u_filename) + # Re-write manifest + mm.write_manifest() + + contents = read_all_bytes(mm.manifest) + + # The manifest should be UTF-8 encoded + contents.decode('UTF-8') + + # The Latin-1 filename should have been skipped + assert posix(filename) not in contents + + # The filelist should have been updated as well + assert u_filename not in mm.filelist.files + + @fail_on_ascii + def test_manifest_is_read_with_utf8_encoding(self): + # Test for #303. + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + # Create manifest + with quiet(): + cmd.run() + + # Add UTF-8 filename to manifest + filename = os.path.join(b'sdist_test', Filenames.utf_8) + cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt') + manifest = open(cmd.manifest, 'ab') + manifest.write(b'\n' + filename) + manifest.close() + + # The file must exist to be included in the filelist + touch(filename) + + # Re-read manifest + cmd.filelist.files = [] + with quiet(): + cmd.read_manifest() + + # The filelist should contain the UTF-8 filename + filename = filename.decode('utf-8') + assert filename in cmd.filelist.files + + @fail_on_latin1_encoded_filenames + def test_read_manifest_skips_non_utf8_filenames(self): + # Test for #303. + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + # Create manifest + with quiet(): + cmd.run() + + # Add Latin-1 filename to manifest + filename = os.path.join(b'sdist_test', Filenames.latin_1) + cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt') + manifest = open(cmd.manifest, 'ab') + manifest.write(b'\n' + filename) + manifest.close() + + # The file must exist to be included in the filelist + touch(filename) + + # Re-read manifest + cmd.filelist.files = [] + with quiet(): + cmd.read_manifest() + + # The Latin-1 filename should have been skipped + filename = filename.decode('latin-1') + assert filename not in cmd.filelist.files + + @fail_on_ascii + @fail_on_latin1_encoded_filenames + def test_sdist_with_utf8_encoded_filename(self): + # Test for #303. + dist = Distribution(self.make_strings(SETUP_ATTRS)) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + filename = os.path.join(b'sdist_test', Filenames.utf_8) + touch(filename) + + with quiet(): + cmd.run() + + if sys.platform == 'darwin': + filename = decompose(filename) + + fs_enc = sys.getfilesystemencoding() + + if sys.platform == 'win32': + if fs_enc == 'cp1252': + # Python mangles the UTF-8 filename + filename = filename.decode('cp1252') + assert filename in cmd.filelist.files + else: + filename = filename.decode('mbcs') + assert filename in cmd.filelist.files + else: + filename = filename.decode('utf-8') + assert filename in cmd.filelist.files + + @classmethod + def make_strings(cls, item): + if isinstance(item, dict): + return {key: cls.make_strings(value) for key, value in item.items()} + if isinstance(item, list): + return list(map(cls.make_strings, item)) + return str(item) + + @fail_on_latin1_encoded_filenames + @skip_under_xdist + def test_sdist_with_latin1_encoded_filename(self): + # Test for #303. + dist = Distribution(self.make_strings(SETUP_ATTRS)) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + + # Latin-1 filename + filename = os.path.join(b'sdist_test', Filenames.latin_1) + touch(filename) + assert os.path.isfile(filename) + + with quiet(): + cmd.run() + + # not all windows systems have a default FS encoding of cp1252 + if sys.platform == 'win32': + # Latin-1 is similar to Windows-1252 however + # on mbcs filesys it is not in latin-1 encoding + fs_enc = sys.getfilesystemencoding() + if fs_enc != 'mbcs': + fs_enc = 'latin-1' + filename = filename.decode(fs_enc) + + assert filename in cmd.filelist.files + else: + # The Latin-1 filename should have been skipped + filename = filename.decode('latin-1') + assert filename not in cmd.filelist.files + + _EXAMPLE_DIRECTIVES = { + "setup.cfg - long_description and version": """ + [metadata] + name = testing + version = file: src/VERSION.txt + license_files = DOWHATYOUWANT + long_description = file: README.rst, USAGE.rst + """, + "pyproject.toml - static readme/license files and dynamic version": """ + [project] + name = "testing" + readme = "USAGE.rst" + license-files = ["DOWHATYOUWANT"] + dynamic = ["version"] + [tool.setuptools.dynamic] + version = {file = ["src/VERSION.txt"]} + """, + "pyproject.toml - directive with str instead of list": """ + [project] + name = "testing" + readme = "USAGE.rst" + license-files = ["DOWHATYOUWANT"] + dynamic = ["version"] + [tool.setuptools.dynamic] + version = {file = "src/VERSION.txt"} + """, + "pyproject.toml - deprecated license table with file entry": """ + [project] + name = "testing" + readme = "USAGE.rst" + license = {file = "DOWHATYOUWANT"} + dynamic = ["version"] + [tool.setuptools.dynamic] + version = {file = "src/VERSION.txt"} + """, + } + + @pytest.mark.parametrize("config", _EXAMPLE_DIRECTIVES.keys()) + @pytest.mark.filterwarnings( + "ignore:.project.license. as a TOML table is deprecated" + ) + def test_add_files_referenced_by_config_directives(self, source_dir, config): + config_file, _, _ = config.partition(" - ") + config_text = self._EXAMPLE_DIRECTIVES[config] + (source_dir / 'src').mkdir() + (source_dir / 'src/VERSION.txt').write_text("0.42", encoding="utf-8") + (source_dir / 'README.rst').write_text("hello world!", encoding="utf-8") + (source_dir / 'USAGE.rst').write_text("hello world!", encoding="utf-8") + (source_dir / 'DOWHATYOUWANT').write_text("hello world!", encoding="utf-8") + (source_dir / config_file).write_text(config_text, encoding="utf-8") + + dist = Distribution({"packages": []}) + dist.script_name = 'setup.py' + dist.parse_config_files() + + cmd = sdist(dist) + cmd.ensure_finalized() + with quiet(): + cmd.run() + + assert ( + 'src/VERSION.txt' in cmd.filelist.files + or 'src\\VERSION.txt' in cmd.filelist.files + ) + assert 'USAGE.rst' in cmd.filelist.files + assert 'DOWHATYOUWANT' in cmd.filelist.files + assert '/' not in cmd.filelist.files + assert '\\' not in cmd.filelist.files + + def test_pyproject_toml_in_sdist(self, source_dir): + """ + Check if pyproject.toml is included in source distribution if present + """ + touch(source_dir / 'pyproject.toml') + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + with quiet(): + cmd.run() + manifest = cmd.filelist.files + assert 'pyproject.toml' in manifest + + def test_pyproject_toml_excluded(self, source_dir): + """ + Check that pyproject.toml can excluded even if present + """ + touch(source_dir / 'pyproject.toml') + with open('MANIFEST.in', 'w', encoding="utf-8") as mts: + print('exclude pyproject.toml', file=mts) + dist = Distribution(SETUP_ATTRS) + dist.script_name = 'setup.py' + cmd = sdist(dist) + cmd.ensure_finalized() + with quiet(): + cmd.run() + manifest = cmd.filelist.files + assert 'pyproject.toml' not in manifest + + def test_build_subcommand_source_files(self, source_dir): + touch(source_dir / '.myfile~') + + # Sanity check: without custom commands file list should not be affected + dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"}) + cmd = sdist(dist) + cmd.ensure_finalized() + with quiet(): + cmd.run() + manifest = cmd.filelist.files + assert '.myfile~' not in manifest + + # Test: custom command should be able to augment file list + dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"}) + build = dist.get_command_obj("build") + build.sub_commands = [*build.sub_commands, ("build_custom", None)] + + class build_custom(Command): + def initialize_options(self): ... + + def finalize_options(self): ... + + def run(self): ... + + def get_source_files(self): + return ['.myfile~'] + + dist.cmdclass.update(build_custom=build_custom) + + cmd = sdist(dist) + cmd.use_defaults = True + cmd.ensure_finalized() + with quiet(): + cmd.run() + manifest = cmd.filelist.files + assert '.myfile~' in manifest + + @pytest.mark.skipif("os.environ.get('SETUPTOOLS_USE_DISTUTILS') == 'stdlib'") + def test_build_base_pathlib(self, source_dir): + """ + Ensure if build_base is a pathlib.Path, the build still succeeds. + """ + dist = Distribution({ + **SETUP_ATTRS, + "script_name": "setup.py", + "options": {"build": {"build_base": pathlib.Path('build')}}, + }) + cmd = sdist(dist) + cmd.ensure_finalized() + with quiet(): + cmd.run() + + +def test_default_revctrl(): + """ + When _default_revctrl was removed from the `setuptools.command.sdist` + module in 10.0, it broke some systems which keep an old install of + setuptools (Distribute) around. Those old versions require that the + setuptools package continue to implement that interface, so this + function provides that interface, stubbed. See #320 for details. + + This interface must be maintained until Ubuntu 12.04 is no longer + supported (by Setuptools). + """ + (ep,) = metadata.EntryPoints._from_text( + """ + [setuptools.file_finders] + svn_cvs = setuptools.command.sdist:_default_revctrl + """ + ) + res = ep.load() + assert hasattr(res, '__iter__') + + +class TestRegressions: + """ + Can be removed/changed if the project decides to change how it handles symlinks + or external files. + """ + + @staticmethod + def files_for_symlink_in_extension_depends(tmp_path, dep_path): + return { + "external": { + "dir": {"file.h": ""}, + }, + "project": { + "setup.py": cleandoc( + f""" + from setuptools import Extension, setup + setup( + name="myproj", + version="42", + ext_modules=[ + Extension( + "hello", sources=["hello.pyx"], + depends=[{dep_path!r}] + ) + ], + ) + """ + ), + "hello.pyx": "", + "MANIFEST.in": "global-include *.h", + }, + } + + @pytest.mark.parametrize( + "dep_path", ("myheaders/dir/file.h", "myheaders/dir/../dir/file.h") + ) + def test_symlink_in_extension_depends(self, monkeypatch, tmp_path, dep_path): + # Given a project with a symlinked dir and a "depends" targeting that dir + files = self.files_for_symlink_in_extension_depends(tmp_path, dep_path) + jaraco.path.build(files, prefix=str(tmp_path)) + symlink_or_skip_test(tmp_path / "external", tmp_path / "project/myheaders") + + # When `sdist` runs, there should be no error + members = run_sdist(monkeypatch, tmp_path / "project") + # and the sdist should contain the symlinked files + for expected in ( + "myproj-42/hello.pyx", + "myproj-42/myheaders/dir/file.h", + ): + assert expected in members + + @staticmethod + def files_for_external_path_in_extension_depends(tmp_path, dep_path): + head, _, tail = dep_path.partition("$tmp_path$/") + dep_path = tmp_path / tail if tail else head + + return { + "external": { + "dir": {"file.h": ""}, + }, + "project": { + "setup.py": cleandoc( + f""" + from setuptools import Extension, setup + setup( + name="myproj", + version="42", + ext_modules=[ + Extension( + "hello", sources=["hello.pyx"], + depends=[{str(dep_path)!r}] + ) + ], + ) + """ + ), + "hello.pyx": "", + "MANIFEST.in": "global-include *.h", + }, + } + + @pytest.mark.parametrize( + "dep_path", ("$tmp_path$/external/dir/file.h", "../external/dir/file.h") + ) + def test_external_path_in_extension_depends(self, monkeypatch, tmp_path, dep_path): + # Given a project with a "depends" targeting an external dir + files = self.files_for_external_path_in_extension_depends(tmp_path, dep_path) + jaraco.path.build(files, prefix=str(tmp_path)) + # When `sdist` runs, there should be no error + members = run_sdist(monkeypatch, tmp_path / "project") + # and the sdist should not contain the external file + for name in members: + assert "file.h" not in name + + +def run_sdist(monkeypatch, project): + """Given a project directory, run the sdist and return its contents""" + monkeypatch.chdir(project) + with quiet(): + run_setup("setup.py", ["sdist"]) + + archive = next((project / "dist").glob("*.tar.gz")) + with tarfile.open(str(archive)) as tar: + return set(tar.getnames()) + + +def test_sanity_check_setuptools_own_sdist(setuptools_sdist): + with tarfile.open(setuptools_sdist) as tar: + files = tar.getnames() + + # setuptools sdist should not include the .tox folder + tox_files = [name for name in files if ".tox" in name] + assert len(tox_files) == 0, f"not empty {tox_files}" diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py new file mode 100644 index 0000000000000000000000000000000000000000..ccf25618a5d6e255ad0be0fbed51fc29c179dcfe --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_setopt.py @@ -0,0 +1,40 @@ +import configparser + +from setuptools.command import setopt + + +class TestEdit: + @staticmethod + def parse_config(filename): + parser = configparser.ConfigParser() + with open(filename, encoding='utf-8') as reader: + parser.read_file(reader) + return parser + + @staticmethod + def write_text(file, content): + with open(file, 'wb') as strm: + strm.write(content.encode('utf-8')) + + def test_utf8_encoding_retained(self, tmpdir): + """ + When editing a file, non-ASCII characters encoded in + UTF-8 should be retained. + """ + config = tmpdir.join('setup.cfg') + self.write_text(str(config), '[names]\njaraco=джарако') + setopt.edit_config(str(config), dict(names=dict(other='yes'))) + parser = self.parse_config(str(config)) + assert parser.get('names', 'jaraco') == 'джарако' + assert parser.get('names', 'other') == 'yes' + + def test_case_retained(self, tmpdir): + """ + When editing a file, case of keys should be retained. + """ + config = tmpdir.join('setup.cfg') + self.write_text(str(config), '[names]\nFoO=bAr') + setopt.edit_config(str(config), dict(names=dict(oTher='yes'))) + actual = config.read_text(encoding='ascii') + assert 'FoO' in actual + assert 'oTher' in actual diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py new file mode 100644 index 0000000000000000000000000000000000000000..1d56e1a8a4ebc5c7aaeb9902ef9972f7de97ecbf --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_setuptools.py @@ -0,0 +1,290 @@ +"""Tests for the 'setuptools' package""" + +import os +import re +import sys +from zipfile import ZipFile + +import pytest +from packaging.version import Version + +import setuptools +import setuptools.depends as dep +import setuptools.dist +from setuptools.depends import Require + +import distutils.cmd +import distutils.core +from distutils.core import Extension +from distutils.errors import DistutilsSetupError + + +@pytest.fixture(autouse=True) +def isolated_dir(tmpdir_cwd): + return + + +def makeSetup(**args): + """Return distribution from 'setup(**args)', without executing commands""" + + distutils.core._setup_stop_after = "commandline" + + # Don't let system command line leak into tests! + args.setdefault('script_args', ['install']) + + try: + return setuptools.setup(**args) + finally: + distutils.core._setup_stop_after = None + + +needs_bytecode = pytest.mark.skipif( + not hasattr(dep, 'get_module_constant'), + reason="bytecode support not available", +) + + +class TestDepends: + def testExtractConst(self): + if not hasattr(dep, 'extract_constant'): + # skip on non-bytecode platforms + return + + def f1(): + global x, y, z + x = "test" + y = z # pyright: ignore[reportUnboundVariable] # Explicitly testing for this runtime issue + + fc = f1.__code__ + + # unrecognized name + assert dep.extract_constant(fc, 'q', -1) is None + + # constant assigned + assert dep.extract_constant(fc, 'x', -1) == "test" + + # expression assigned + assert dep.extract_constant(fc, 'y', -1) == -1 + + # recognized name, not assigned + assert dep.extract_constant(fc, 'z', -1) is None + + def testFindModule(self): + with pytest.raises(ImportError): + dep.find_module('no-such.-thing') + with pytest.raises(ImportError): + dep.find_module('setuptools.non-existent') + f, _p, _i = dep.find_module('setuptools.tests') + f.close() + + @needs_bytecode + def testModuleExtract(self): + from json import __version__ + + assert dep.get_module_constant('json', '__version__') == __version__ + assert dep.get_module_constant('sys', 'version') == sys.version + assert ( + dep.get_module_constant('setuptools.tests.test_setuptools', '__doc__') + == __doc__ + ) + + @needs_bytecode + def testRequire(self): + req = Require('Json', '1.0.3', 'json') + + assert req.name == 'Json' + assert req.module == 'json' + assert req.requested_version == Version('1.0.3') + assert req.attribute == '__version__' + assert req.full_name() == 'Json-1.0.3' + + from json import __version__ + + assert str(req.get_version()) == __version__ + assert req.version_ok('1.0.9') + assert not req.version_ok('0.9.1') + assert not req.version_ok('unknown') + + assert req.is_present() + assert req.is_current() + + req = Require('Do-what-I-mean', '1.0', 'd-w-i-m') + assert not req.is_present() + assert not req.is_current() + + @needs_bytecode + def test_require_present(self): + # In #1896, this test was failing for months with the only + # complaint coming from test runners (not end users). + # TODO: Evaluate if this code is needed at all. + req = Require('Tests', None, 'tests', homepage="http://example.com") + assert req.format is None + assert req.attribute is None + assert req.requested_version is None + assert req.full_name() == 'Tests' + assert req.homepage == 'http://example.com' + + from setuptools.tests import __path__ + + paths = [os.path.dirname(p) for p in __path__] + assert req.is_present(paths) + assert req.is_current(paths) + + +class TestDistro: + def setup_method(self, method): + self.e1 = Extension('bar.ext', ['bar.c']) + self.e2 = Extension('c.y', ['y.c']) + + self.dist = makeSetup( + packages=['a', 'a.b', 'a.b.c', 'b', 'c'], + py_modules=['b.d', 'x'], + ext_modules=(self.e1, self.e2), + package_dir={}, + ) + + def testDistroType(self): + assert isinstance(self.dist, setuptools.dist.Distribution) + + def testExcludePackage(self): + self.dist.exclude_package('a') + assert self.dist.packages == ['b', 'c'] + + self.dist.exclude_package('b') + assert self.dist.packages == ['c'] + assert self.dist.py_modules == ['x'] + assert self.dist.ext_modules == [self.e1, self.e2] + + self.dist.exclude_package('c') + assert self.dist.packages == [] + assert self.dist.py_modules == ['x'] + assert self.dist.ext_modules == [self.e1] + + # test removals from unspecified options + makeSetup().exclude_package('x') + + def testIncludeExclude(self): + # remove an extension + self.dist.exclude(ext_modules=[self.e1]) + assert self.dist.ext_modules == [self.e2] + + # add it back in + self.dist.include(ext_modules=[self.e1]) + assert self.dist.ext_modules == [self.e2, self.e1] + + # should not add duplicate + self.dist.include(ext_modules=[self.e1]) + assert self.dist.ext_modules == [self.e2, self.e1] + + def testExcludePackages(self): + self.dist.exclude(packages=['c', 'b', 'a']) + assert self.dist.packages == [] + assert self.dist.py_modules == ['x'] + assert self.dist.ext_modules == [self.e1] + + def testEmpty(self): + dist = makeSetup() + dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2]) + dist = makeSetup() + dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2]) + + def testContents(self): + assert self.dist.has_contents_for('a') + self.dist.exclude_package('a') + assert not self.dist.has_contents_for('a') + + assert self.dist.has_contents_for('b') + self.dist.exclude_package('b') + assert not self.dist.has_contents_for('b') + + assert self.dist.has_contents_for('c') + self.dist.exclude_package('c') + assert not self.dist.has_contents_for('c') + + def testInvalidIncludeExclude(self): + with pytest.raises(DistutilsSetupError): + self.dist.include(nonexistent_option='x') + with pytest.raises(DistutilsSetupError): + self.dist.exclude(nonexistent_option='x') + with pytest.raises(DistutilsSetupError): + self.dist.include(packages={'x': 'y'}) + with pytest.raises(DistutilsSetupError): + self.dist.exclude(packages={'x': 'y'}) + with pytest.raises(DistutilsSetupError): + self.dist.include(ext_modules={'x': 'y'}) + with pytest.raises(DistutilsSetupError): + self.dist.exclude(ext_modules={'x': 'y'}) + + with pytest.raises(DistutilsSetupError): + self.dist.include(package_dir=['q']) + with pytest.raises(DistutilsSetupError): + self.dist.exclude(package_dir=['q']) + + +@pytest.fixture +def example_source(tmpdir): + tmpdir.mkdir('foo') + (tmpdir / 'foo/bar.py').write('') + (tmpdir / 'readme.txt').write('') + return tmpdir + + +def test_findall(example_source): + found = list(setuptools.findall(str(example_source))) + expected = ['readme.txt', 'foo/bar.py'] + expected = [example_source.join(fn) for fn in expected] + assert found == expected + + +def test_findall_curdir(example_source): + with example_source.as_cwd(): + found = list(setuptools.findall()) + expected = ['readme.txt', os.path.join('foo', 'bar.py')] + assert found == expected + + +@pytest.fixture +def can_symlink(tmpdir): + """ + Skip if cannot create a symbolic link + """ + link_fn = 'link' + target_fn = 'target' + try: + os.symlink(target_fn, link_fn) + except (OSError, NotImplementedError, AttributeError): + pytest.skip("Cannot create symbolic links") + os.remove(link_fn) + + +@pytest.mark.usefixtures("can_symlink") +def test_findall_missing_symlink(tmpdir): + with tmpdir.as_cwd(): + os.symlink('foo', 'bar') + found = list(setuptools.findall()) + assert found == [] + + +@pytest.mark.xfail(reason="unable to exclude tests; #4475 #3260") +def test_its_own_wheel_does_not_contain_tests(setuptools_wheel): + with ZipFile(setuptools_wheel) as zipfile: + contents = [f.replace(os.sep, '/') for f in zipfile.namelist()] + + for member in contents: + assert '/tests/' not in member + + +def test_wheel_includes_cli_scripts(setuptools_wheel): + with ZipFile(setuptools_wheel) as zipfile: + contents = [f.replace(os.sep, '/') for f in zipfile.namelist()] + + assert any('cli-64.exe' in member for member in contents) + + +def test_wheel_includes_vendored_metadata(setuptools_wheel): + with ZipFile(setuptools_wheel) as zipfile: + contents = [f.replace(os.sep, '/') for f in zipfile.namelist()] + + assert any( + re.search(r'_vendor/.*\.dist-info/METADATA', member) for member in contents + ) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..74ff7e9a896328a3d57ca3639658e3b9d538585f --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_shutil_wrapper.py @@ -0,0 +1,23 @@ +import stat +import sys +from unittest.mock import Mock + +from setuptools import _shutil + + +def test_rmtree_readonly(monkeypatch, tmp_path): + """Verify onerr works as expected""" + + tmp_dir = tmp_path / "with_readonly" + tmp_dir.mkdir() + some_file = tmp_dir.joinpath("file.txt") + some_file.touch() + some_file.chmod(stat.S_IREAD) + + expected_count = 1 if sys.platform.startswith("win") else 0 + chmod_fn = Mock(wraps=_shutil.attempt_chmod_verbose) + monkeypatch.setattr(_shutil, "attempt_chmod_verbose", chmod_fn) + + _shutil.rmtree(tmp_dir) + assert chmod_fn.call_count == expected_count + assert not tmp_dir.is_dir() diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..a24a9bd5305d1de7c1c925466bb7d222c85864a7 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_unicode_utils.py @@ -0,0 +1,10 @@ +from setuptools import unicode_utils + + +def test_filesys_decode_fs_encoding_is_None(monkeypatch): + """ + Test filesys_decode does not raise TypeError when + getfilesystemencoding returns None. + """ + monkeypatch.setattr('sys.getfilesystemencoding', lambda: None) + unicode_utils.filesys_decode(b'test') diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py new file mode 100644 index 0000000000000000000000000000000000000000..b02949baf9cef8eb4df9c697add28f79a93b64d4 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_virtualenv.py @@ -0,0 +1,113 @@ +import os +import subprocess +import sys +from urllib.error import URLError +from urllib.request import urlopen + +import pytest + + +@pytest.fixture(autouse=True) +def pytest_virtualenv_works(venv): + """ + pytest_virtualenv may not work. if it doesn't, skip these + tests. See #1284. + """ + venv_prefix = venv.run(["python", "-c", "import sys; print(sys.prefix)"]).strip() + if venv_prefix == sys.prefix: + pytest.skip("virtualenv is broken (see pypa/setuptools#1284)") + + +def test_clean_env_install(venv_without_setuptools, setuptools_wheel): + """ + Check setuptools can be installed in a clean environment. + """ + cmd = ["python", "-m", "pip", "install", str(setuptools_wheel)] + venv_without_setuptools.run(cmd) + + +def access_pypi(): + # Detect if tests are being run without connectivity + if not os.environ.get('NETWORK_REQUIRED', False): # pragma: nocover + try: + urlopen('https://pypi.org', timeout=1) + except URLError: + # No network, disable most of these tests + return False + + return True + + +@pytest.mark.skipif( + 'platform.python_implementation() == "PyPy"', + reason="https://github.com/pypa/setuptools/pull/2865#issuecomment-965834995", +) +@pytest.mark.skipif(not access_pypi(), reason="no network") +# ^-- Even when it is not necessary to install a different version of `pip` +# the build process will still try to download `wheel`, see #3147 and #2986. +@pytest.mark.parametrize( + 'pip_version', + [ + None, + pytest.param( + 'pip<20.1', + marks=pytest.mark.xfail( + 'sys.version_info >= (3, 12)', + reason="pip 23.1.2 required for Python 3.12 and later", + ), + ), + pytest.param( + 'pip<21', + marks=pytest.mark.xfail( + 'sys.version_info >= (3, 12)', + reason="pip 23.1.2 required for Python 3.12 and later", + ), + ), + pytest.param( + 'pip<22', + marks=pytest.mark.xfail( + 'sys.version_info >= (3, 12)', + reason="pip 23.1.2 required for Python 3.12 and later", + ), + ), + pytest.param( + 'pip<23', + marks=pytest.mark.xfail( + 'sys.version_info >= (3, 12)', + reason="pip 23.1.2 required for Python 3.12 and later", + ), + ), + pytest.param( + 'https://github.com/pypa/pip/archive/main.zip', + marks=pytest.mark.xfail(reason='#2975'), + ), + ], +) +def test_pip_upgrade_from_source( + pip_version, venv_without_setuptools, setuptools_wheel, setuptools_sdist +): + """ + Check pip can upgrade setuptools from source. + """ + # Install pip/wheel, in a venv without setuptools (as it + # should not be needed for bootstrapping from source) + venv = venv_without_setuptools + venv.run(["pip", "install", "-U", "wheel"]) + if pip_version is not None: + venv.run(["python", "-m", "pip", "install", "-U", pip_version, "--retries=1"]) + with pytest.raises(subprocess.CalledProcessError): + # Meta-test to make sure setuptools is not installed + venv.run(["python", "-c", "import setuptools"]) + + # Then install from wheel. + venv.run(["pip", "install", str(setuptools_wheel)]) + # And finally try to upgrade from source. + venv.run(["pip", "install", "--no-cache-dir", "--upgrade", str(setuptools_sdist)]) + + +def test_no_missing_dependencies(bare_venv, request): + """ + Quick and dirty test to ensure all external dependencies are vendored. + """ + setuptools_dir = request.config.rootdir + bare_venv.run(['python', 'setup.py', '--help'], cwd=setuptools_dir) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py new file mode 100644 index 0000000000000000000000000000000000000000..41193d4f717344546f8c70ad18b268a04740129b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_warnings.py @@ -0,0 +1,106 @@ +from inspect import cleandoc + +import pytest + +from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning + +_EXAMPLES = { + "default": dict( + args=("Hello {x}", "\n\t{target} {v:.1f}"), + kwargs={"x": 5, "v": 3, "target": "World"}, + expected=""" + Hello 5 + !! + + ******************************************************************************** + World 3.0 + ******************************************************************************** + + !! + """, + ), + "futue_due_date": dict( + args=("Summary", "Lorem ipsum"), + kwargs={"due_date": (9999, 11, 22)}, + expected=""" + Summary + !! + + ******************************************************************************** + Lorem ipsum + + By 9999-Nov-22, you need to update your project and remove deprecated calls + or your builds will no longer be supported. + ******************************************************************************** + + !! + """, + ), + "past_due_date_with_docs": dict( + args=("Summary", "Lorem ipsum"), + kwargs={"due_date": (2000, 11, 22), "see_docs": "some_page.html"}, + expected=""" + Summary + !! + + ******************************************************************************** + Lorem ipsum + + This deprecation is overdue, please update your project and remove deprecated + calls to avoid build errors in the future. + + See https://setuptools.pypa.io/en/latest/some_page.html for details. + ******************************************************************************** + + !! + """, + ), +} + + +@pytest.mark.parametrize("example_name", _EXAMPLES.keys()) +def test_formatting(monkeypatch, example_name): + """ + It should automatically handle indentation, interpolation and things like due date. + """ + args = _EXAMPLES[example_name]["args"] + kwargs = _EXAMPLES[example_name]["kwargs"] + expected = _EXAMPLES[example_name]["expected"] + + monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false") + with pytest.warns(SetuptoolsWarning) as warn_info: + SetuptoolsWarning.emit(*args, **kwargs) + assert _get_message(warn_info) == cleandoc(expected) + + +def test_due_date_enforcement(monkeypatch): + class _MyDeprecation(SetuptoolsDeprecationWarning): + _SUMMARY = "Summary" + _DETAILS = "Lorem ipsum" + _DUE_DATE = (2000, 11, 22) + _SEE_DOCS = "some_page.html" + + monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "true") + with pytest.raises(SetuptoolsDeprecationWarning) as exc_info: + _MyDeprecation.emit() + + expected = """ + Summary + !! + + ******************************************************************************** + Lorem ipsum + + This deprecation is overdue, please update your project and remove deprecated + calls to avoid build errors in the future. + + See https://setuptools.pypa.io/en/latest/some_page.html for details. + ******************************************************************************** + + !! + """ + assert str(exc_info.value) == cleandoc(expected) + + +def _get_message(warn_info): + return next(warn.message.args[0] for warn in warn_info) diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..70165c608b60bc70a908a8b56e1f1105feeb4712 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_wheel.py @@ -0,0 +1,714 @@ +"""wheel tests""" + +from __future__ import annotations + +import contextlib +import glob +import inspect +import os +import pathlib +import shutil +import stat +import subprocess +import sys +import zipfile +from typing import Any + +import pytest +from jaraco import path +from packaging.tags import parse_tag +from packaging.utils import canonicalize_name + +from pkg_resources import PY_MAJOR, Distribution, PathMetadata +from setuptools.wheel import Wheel + +from .contexts import tempdir +from .textwrap import DALS + +from distutils.sysconfig import get_config_var +from distutils.util import get_platform + +WHEEL_INFO_TESTS = ( + ('invalid.whl', ValueError), + ( + 'simplewheel-2.0-1-py2.py3-none-any.whl', + { + 'project_name': 'simplewheel', + 'version': '2.0', + 'build': '1', + 'py_version': 'py2.py3', + 'abi': 'none', + 'platform': 'any', + }, + ), + ( + 'simple.dist-0.1-py2.py3-none-any.whl', + { + 'project_name': 'simple.dist', + 'version': '0.1', + 'build': None, + 'py_version': 'py2.py3', + 'abi': 'none', + 'platform': 'any', + }, + ), + ( + 'example_pkg_a-1-py3-none-any.whl', + { + 'project_name': 'example_pkg_a', + 'version': '1', + 'build': None, + 'py_version': 'py3', + 'abi': 'none', + 'platform': 'any', + }, + ), + ( + 'PyQt5-5.9-5.9.1-cp35.cp36.cp37-abi3-manylinux1_x86_64.whl', + { + 'project_name': 'PyQt5', + 'version': '5.9', + 'build': '5.9.1', + 'py_version': 'cp35.cp36.cp37', + 'abi': 'abi3', + 'platform': 'manylinux1_x86_64', + }, + ), +) + + +@pytest.mark.parametrize( + ('filename', 'info'), WHEEL_INFO_TESTS, ids=[t[0] for t in WHEEL_INFO_TESTS] +) +def test_wheel_info(filename, info): + if inspect.isclass(info): + with pytest.raises(info): + Wheel(filename) + return + w = Wheel(filename) + assert {k: getattr(w, k) for k in info.keys()} == info + + +@contextlib.contextmanager +def build_wheel(extra_file_defs=None, **kwargs): + file_defs = { + 'setup.py': ( + DALS( + """ + # -*- coding: utf-8 -*- + from setuptools import setup + import setuptools + setup(**%r) + """ + ) + % kwargs + ).encode('utf-8'), + } + if extra_file_defs: + file_defs.update(extra_file_defs) + with tempdir() as source_dir: + path.build(file_defs, source_dir) + subprocess.check_call( + (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir + ) + yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0] + + +def tree_set(root): + contents = set() + for dirpath, dirnames, filenames in os.walk(root): + for filename in filenames: + contents.add(os.path.join(os.path.relpath(dirpath, root), filename)) + return contents + + +def flatten_tree(tree): + """Flatten nested dicts and lists into a full list of paths""" + output = set() + for node, contents in tree.items(): + if isinstance(contents, dict): + contents = flatten_tree(contents) + + for elem in contents: + if isinstance(elem, dict): + output |= {os.path.join(node, val) for val in flatten_tree(elem)} + else: + output.add(os.path.join(node, elem)) + return output + + +def format_install_tree(tree): + return { + x.format( + py_version=PY_MAJOR, + platform=get_platform(), + shlib_ext=get_config_var('EXT_SUFFIX') or get_config_var('SO'), + ) + for x in tree + } + + +def _check_wheel_install( + filename, install_dir, install_tree_includes, project_name, version, requires_txt +): + w = Wheel(filename) + egg_path = os.path.join(install_dir, w.egg_name()) + w.install_as_egg(egg_path) + if install_tree_includes is not None: + install_tree = format_install_tree(install_tree_includes) + exp = tree_set(install_dir) + assert install_tree.issubset(exp), install_tree - exp + + metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO')) + dist = Distribution.from_filename(egg_path, metadata=metadata) + assert dist.project_name == project_name + assert dist.version == version + if requires_txt is None: + assert not dist.has_metadata('requires.txt') + else: + # Order must match to ensure reproducibility. + assert requires_txt == dist.get_metadata('requires.txt').lstrip() + + +class Record: + def __init__(self, id, **kwargs): + self._id = id + self._fields = kwargs + + def __repr__(self) -> str: + return f'{self._id}(**{self._fields!r})' + + +# Using Any to avoid possible type union issues later in test +# making a TypedDict is not worth in a test and anonymous/inline TypedDict are experimental +# https://github.com/python/mypy/issues/9884 +WHEEL_INSTALL_TESTS: tuple[dict[str, Any], ...] = ( + dict( + id='basic', + file_defs={'foo': {'__init__.py': ''}}, + setup_kwargs=dict( + packages=['foo'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'], + 'foo': ['__init__.py'], + } + }), + ), + dict( + id='utf-8', + setup_kwargs=dict( + description='Description accentuée', + ), + ), + dict( + id='data', + file_defs={ + 'data.txt': DALS( + """ + Some data... + """ + ), + }, + setup_kwargs=dict( + data_files=[('data_dir', ['data.txt'])], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'], + 'data_dir': ['data.txt'], + } + }), + ), + dict( + id='extension', + file_defs={ + 'extension.c': DALS( + """ + #include "Python.h" + + #if PY_MAJOR_VERSION >= 3 + + static struct PyModuleDef moduledef = { + PyModuleDef_HEAD_INIT, + "extension", + NULL, + 0, + NULL, + NULL, + NULL, + NULL, + NULL + }; + + #define INITERROR return NULL + + PyMODINIT_FUNC PyInit_extension(void) + + #else + + #define INITERROR return + + void initextension(void) + + #endif + { + #if PY_MAJOR_VERSION >= 3 + PyObject *module = PyModule_Create(&moduledef); + #else + PyObject *module = Py_InitModule("extension", NULL); + #endif + if (module == NULL) + INITERROR; + #if PY_MAJOR_VERSION >= 3 + return module; + #endif + } + """ + ), + }, + setup_kwargs=dict( + ext_modules=[ + Record( + 'setuptools.Extension', name='extension', sources=['extension.c'] + ) + ], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}-{platform}.egg': [ + 'extension{shlib_ext}', + { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'top_level.txt', + ] + }, + ] + }), + ), + dict( + id='header', + file_defs={ + 'header.h': DALS( + """ + """ + ), + }, + setup_kwargs=dict( + headers=['header.h'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': [ + 'header.h', + { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'top_level.txt', + ] + }, + ] + }), + ), + dict( + id='script', + file_defs={ + 'script.py': DALS( + """ + #/usr/bin/python + print('hello world!') + """ + ), + 'script.sh': DALS( + """ + #/bin/sh + echo 'hello world!' + """ + ), + }, + setup_kwargs=dict( + scripts=['script.py', 'script.sh'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'top_level.txt', + {'scripts': ['script.py', 'script.sh']}, + ] + } + }), + ), + dict( + id='requires1', + install_requires='foobar==2.0', + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'requires.txt', + 'top_level.txt', + ] + } + }), + requires_txt=DALS( + """ + foobar==2.0 + """ + ), + ), + dict( + id='requires2', + install_requires=f""" + bar + foo<=2.0; {sys.platform!r} in sys_platform + """, + requires_txt=DALS( + """ + bar + foo<=2.0 + """ + ), + ), + dict( + id='requires3', + install_requires=f""" + bar; {sys.platform!r} != sys_platform + """, + ), + dict( + id='requires4', + install_requires=""" + foo + """, + extras_require={ + 'extra': 'foobar>3', + }, + requires_txt=DALS( + """ + foo + + [extra] + foobar>3 + """ + ), + ), + dict( + id='requires5', + extras_require={ + 'extra': f'foobar; {sys.platform!r} != sys_platform', + }, + requires_txt=DALS( + """ + [extra] + """ + ), + ), + dict( + id='requires_ensure_order', + install_requires=""" + foo + bar + baz + qux + """, + extras_require={ + 'extra': """ + foobar>3 + barbaz>4 + bazqux>5 + quxzap>6 + """, + }, + requires_txt=DALS( + """ + foo + bar + baz + qux + + [extra] + foobar>3 + barbaz>4 + bazqux>5 + quxzap>6 + """ + ), + ), + dict( + id='namespace_package', + file_defs={ + 'foo': { + 'bar': {'__init__.py': ''}, + }, + }, + setup_kwargs=dict( + namespace_packages=['foo'], + packages=['foo.bar'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': [ + 'foo-1.0-py{py_version}-nspkg.pth', + { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'namespace_packages.txt', + 'top_level.txt', + ] + }, + { + 'foo': [ + '__init__.py', + {'bar': ['__init__.py']}, + ] + }, + ] + }), + ), + dict( + id='empty_namespace_package', + file_defs={ + 'foobar': { + '__init__.py': ( + "__import__('pkg_resources').declare_namespace(__name__)" + ) + }, + }, + setup_kwargs=dict( + namespace_packages=['foobar'], + packages=['foobar'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': [ + 'foo-1.0-py{py_version}-nspkg.pth', + { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'namespace_packages.txt', + 'top_level.txt', + ] + }, + { + 'foobar': [ + '__init__.py', + ] + }, + ] + }), + ), + dict( + id='data_in_package', + file_defs={ + 'foo': { + '__init__.py': '', + 'data_dir': { + 'data.txt': DALS( + """ + Some data... + """ + ), + }, + } + }, + setup_kwargs=dict( + packages=['foo'], + data_files=[('foo/data_dir', ['foo/data_dir/data.txt'])], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'top_level.txt', + ], + 'foo': [ + '__init__.py', + { + 'data_dir': [ + 'data.txt', + ] + }, + ], + } + }), + ), +) + + +@pytest.mark.parametrize( + 'params', + WHEEL_INSTALL_TESTS, + ids=[params['id'] for params in WHEEL_INSTALL_TESTS], +) +def test_wheel_install(params): + project_name = params.get('name', 'foo') + version = params.get('version', '1.0') + install_requires = params.get('install_requires', []) + extras_require = params.get('extras_require', {}) + requires_txt = params.get('requires_txt', None) + install_tree = params.get('install_tree') + file_defs = params.get('file_defs', {}) + setup_kwargs = params.get('setup_kwargs', {}) + with ( + build_wheel( + name=project_name, + version=version, + install_requires=install_requires, + extras_require=extras_require, + extra_file_defs=file_defs, + **setup_kwargs, + ) as filename, + tempdir() as install_dir, + ): + _check_wheel_install( + filename, install_dir, install_tree, project_name, version, requires_txt + ) + + +def test_wheel_install_pep_503(): + project_name = 'Foo_Bar' # PEP 503 canonicalized name is "foo-bar" + version = '1.0' + with ( + build_wheel( + name=project_name, + version=version, + ) as filename, + tempdir() as install_dir, + ): + new_filename = filename.replace(project_name, canonicalize_name(project_name)) + shutil.move(filename, new_filename) + _check_wheel_install( + new_filename, + install_dir, + None, + canonicalize_name(project_name), + version, + None, + ) + + +def test_wheel_no_dist_dir(): + project_name = 'nodistinfo' + version = '1.0' + wheel_name = f'{project_name}-{version}-py2.py3-none-any.whl' + with tempdir() as source_dir: + wheel_path = os.path.join(source_dir, wheel_name) + # create an empty zip file + zipfile.ZipFile(wheel_path, 'w').close() + with tempdir() as install_dir: + with pytest.raises(ValueError): + _check_wheel_install( + wheel_path, install_dir, None, project_name, version, None + ) + + +def test_wheel_is_compatible(monkeypatch): + def sys_tags(): + return { + (t.interpreter, t.abi, t.platform) + for t in parse_tag('cp36-cp36m-manylinux1_x86_64') + } + + monkeypatch.setattr('setuptools.wheel._get_supported_tags', sys_tags) + assert Wheel('onnxruntime-0.1.2-cp36-cp36m-manylinux1_x86_64.whl').is_compatible() + + +def test_wheel_mode(): + @contextlib.contextmanager + def build_wheel(extra_file_defs=None, **kwargs): + file_defs = { + 'setup.py': ( + DALS( + """ + # -*- coding: utf-8 -*- + from setuptools import setup + import setuptools + setup(**%r) + """ + ) + % kwargs + ).encode('utf-8'), + } + if extra_file_defs: + file_defs.update(extra_file_defs) + with tempdir() as source_dir: + path.build(file_defs, source_dir) + runsh = pathlib.Path(source_dir) / "script.sh" + os.chmod(runsh, 0o777) + subprocess.check_call( + (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir + ) + yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0] + + params = dict( + id='script', + file_defs={ + 'script.py': DALS( + """ + #/usr/bin/python + print('hello world!') + """ + ), + 'script.sh': DALS( + """ + #/bin/sh + echo 'hello world!' + """ + ), + }, + setup_kwargs=dict( + scripts=['script.py', 'script.sh'], + ), + install_tree=flatten_tree({ + 'foo-1.0-py{py_version}.egg': { + 'EGG-INFO': [ + 'PKG-INFO', + 'RECORD', + 'WHEEL', + 'top_level.txt', + {'scripts': ['script.py', 'script.sh']}, + ] + } + }), + ) + + project_name = params.get('name', 'foo') + version = params.get('version', '1.0') + install_tree = params.get('install_tree') + file_defs = params.get('file_defs', {}) + setup_kwargs = params.get('setup_kwargs', {}) + + with ( + build_wheel( + name=project_name, + version=version, + install_requires=[], + extras_require={}, + extra_file_defs=file_defs, + **setup_kwargs, + ) as filename, + tempdir() as install_dir, + ): + _check_wheel_install( + filename, install_dir, install_tree, project_name, version, None + ) + w = Wheel(filename) + base = pathlib.Path(install_dir) / w.egg_name() + script_sh = base / "EGG-INFO" / "scripts" / "script.sh" + assert script_sh.exists() + if sys.platform != 'win32': + # Editable file mode has no effect on Windows + assert oct(stat.S_IMODE(script_sh.stat().st_mode)) == "0o777" diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py b/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py new file mode 100644 index 0000000000000000000000000000000000000000..f895485387f2f9f673f96f7114629297a381e66c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/test_windows_wrappers.py @@ -0,0 +1,259 @@ +""" +Python Script Wrapper for Windows +================================= + +setuptools includes wrappers for Python scripts that allows them to be +executed like regular windows programs. There are 2 wrappers, one +for command-line programs, cli.exe, and one for graphical programs, +gui.exe. These programs are almost identical, function pretty much +the same way, and are generated from the same source file. The +wrapper programs are used by copying them to the directory containing +the script they are to wrap and with the same name as the script they +are to wrap. +""" + +import pathlib +import platform +import subprocess +import sys +import textwrap + +import pytest + +import pkg_resources +from setuptools.command.easy_install import nt_quote_arg + +pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only") + + +class WrapperTester: + @classmethod + def prep_script(cls, template): + python_exe = nt_quote_arg(sys.executable) + return template % locals() + + @classmethod + def create_script(cls, tmpdir): + """ + Create a simple script, foo-script.py + + Note that the script starts with a Unix-style '#!' line saying which + Python executable to run. The wrapper will use this line to find the + correct Python executable. + """ + + script = cls.prep_script(cls.script_tmpl) + + with (tmpdir / cls.script_name).open('w') as f: + f.write(script) + + # also copy cli.exe to the sample directory + with (tmpdir / cls.wrapper_name).open('wb') as f: + w = pkg_resources.resource_string('setuptools', cls.wrapper_source) + f.write(w) + + +def win_launcher_exe(prefix): + """A simple routine to select launcher script based on platform.""" + assert prefix in ('cli', 'gui') + if platform.machine() == "ARM64": + return f"{prefix}-arm64.exe" + else: + return f"{prefix}-32.exe" + + +class TestCLI(WrapperTester): + script_name = 'foo-script.py' + wrapper_name = 'foo.exe' + wrapper_source = win_launcher_exe('cli') + + script_tmpl = textwrap.dedent( + """ + #!%(python_exe)s + import sys + input = repr(sys.stdin.read()) + print(sys.argv[0][-14:]) + print(sys.argv[1:]) + print(input) + if __debug__: + print('non-optimized') + """ + ).lstrip() + + def test_basic(self, tmpdir): + """ + When the copy of cli.exe, foo.exe in this example, runs, it examines + the path name it was run with and computes a Python script path name + by removing the '.exe' suffix and adding the '-script.py' suffix. (For + GUI programs, the suffix '-script.pyw' is added.) This is why we + named out script the way we did. Now we can run out script by running + the wrapper: + + This example was a little pathological in that it exercised windows + (MS C runtime) quoting rules: + + - Strings containing spaces are surrounded by double quotes. + + - Double quotes in strings need to be escaped by preceding them with + back slashes. + + - One or more backslashes preceding double quotes need to be escaped + by preceding each of them with back slashes. + """ + self.create_script(tmpdir) + cmd = [ + str(tmpdir / 'foo.exe'), + 'arg1', + 'arg 2', + 'arg "2\\"', + 'arg 4\\', + 'arg5 a\\\\b', + ] + proc = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + text=True, + encoding="utf-8", + ) + stdout, _stderr = proc.communicate('hello\nworld\n') + actual = stdout.replace('\r\n', '\n') + expected = textwrap.dedent( + r""" + \foo-script.py + ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b'] + 'hello\nworld\n' + non-optimized + """ + ).lstrip() + assert actual == expected + + def test_symlink(self, tmpdir): + """ + Ensure that symlink for the foo.exe is working correctly. + """ + script_dir = tmpdir / "script_dir" + script_dir.mkdir() + self.create_script(script_dir) + symlink = pathlib.Path(tmpdir / "foo.exe") + symlink.symlink_to(script_dir / "foo.exe") + + cmd = [ + str(tmpdir / 'foo.exe'), + 'arg1', + 'arg 2', + 'arg "2\\"', + 'arg 4\\', + 'arg5 a\\\\b', + ] + proc = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + text=True, + encoding="utf-8", + ) + stdout, _stderr = proc.communicate('hello\nworld\n') + actual = stdout.replace('\r\n', '\n') + expected = textwrap.dedent( + r""" + \foo-script.py + ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b'] + 'hello\nworld\n' + non-optimized + """ + ).lstrip() + assert actual == expected + + def test_with_options(self, tmpdir): + """ + Specifying Python Command-line Options + -------------------------------------- + + You can specify a single argument on the '#!' line. This can be used + to specify Python options like -O, to run in optimized mode or -i + to start the interactive interpreter. You can combine multiple + options as usual. For example, to run in optimized mode and + enter the interpreter after running the script, you could use -Oi: + """ + self.create_script(tmpdir) + tmpl = textwrap.dedent( + """ + #!%(python_exe)s -Oi + import sys + input = repr(sys.stdin.read()) + print(sys.argv[0][-14:]) + print(sys.argv[1:]) + print(input) + if __debug__: + print('non-optimized') + sys.ps1 = '---' + """ + ).lstrip() + with (tmpdir / 'foo-script.py').open('w') as f: + f.write(self.prep_script(tmpl)) + cmd = [str(tmpdir / 'foo.exe')] + proc = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + encoding="utf-8", + ) + stdout, _stderr = proc.communicate() + actual = stdout.replace('\r\n', '\n') + expected = textwrap.dedent( + r""" + \foo-script.py + [] + '' + --- + """ + ).lstrip() + assert actual == expected + + +class TestGUI(WrapperTester): + """ + Testing the GUI Version + ----------------------- + """ + + script_name = 'bar-script.pyw' + wrapper_source = win_launcher_exe('gui') + wrapper_name = 'bar.exe' + + script_tmpl = textwrap.dedent( + """ + #!%(python_exe)s + import sys + f = open(sys.argv[1], 'wb') + bytes_written = f.write(repr(sys.argv[2]).encode('utf-8')) + f.close() + """ + ).strip() + + def test_basic(self, tmpdir): + """Test the GUI version with the simple script, bar-script.py""" + self.create_script(tmpdir) + + cmd = [ + str(tmpdir / 'bar.exe'), + str(tmpdir / 'test_output.txt'), + 'Test Argument', + ] + proc = subprocess.Popen( + cmd, + stdout=subprocess.PIPE, + stdin=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + encoding="utf-8", + ) + stdout, stderr = proc.communicate() + assert not stdout + assert not stderr + with (tmpdir / 'test_output.txt').open('rb') as f_out: + actual = f_out.read().decode('ascii') + assert actual == repr('Test Argument') diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/text.py b/.venv/lib/python3.12/site-packages/setuptools/tests/text.py new file mode 100644 index 0000000000000000000000000000000000000000..e05cc633ede9e5ce4f74b66a7bf76327c2000caa --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/text.py @@ -0,0 +1,4 @@ +class Filenames: + unicode = 'smörbröd.py' + latin_1 = unicode.encode('latin-1') + utf_8 = unicode.encode('utf-8') diff --git a/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py b/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py new file mode 100644 index 0000000000000000000000000000000000000000..5e39618dca4ad6c3f0d4c8cb20af59ab85fb0eba --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/tests/textwrap.py @@ -0,0 +1,6 @@ +import textwrap + + +def DALS(s): + "dedent and left-strip" + return textwrap.dedent(s).lstrip() diff --git a/.venv/lib/python3.12/site-packages/setuptools/unicode_utils.py b/.venv/lib/python3.12/site-packages/setuptools/unicode_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..f502f5b089619eafd28e2c7a61967e34e16920e5 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/unicode_utils.py @@ -0,0 +1,102 @@ +import sys +import unicodedata +from configparser import RawConfigParser + +from .compat import py39 +from .warnings import SetuptoolsDeprecationWarning + + +# HFS Plus uses decomposed UTF-8 +def decompose(path): + if isinstance(path, str): + return unicodedata.normalize('NFD', path) + try: + path = path.decode('utf-8') + path = unicodedata.normalize('NFD', path) + path = path.encode('utf-8') + except UnicodeError: + pass # Not UTF-8 + return path + + +def filesys_decode(path): + """ + Ensure that the given path is decoded, + ``None`` when no expected encoding works + """ + + if isinstance(path, str): + return path + + fs_enc = sys.getfilesystemencoding() or 'utf-8' + candidates = fs_enc, 'utf-8' + + for enc in candidates: + try: + return path.decode(enc) + except UnicodeDecodeError: + continue + + return None + + +def try_encode(string, enc): + "turn unicode encoding into a functional routine" + try: + return string.encode(enc) + except UnicodeEncodeError: + return None + + +def _read_utf8_with_fallback(file: str, fallback_encoding=py39.LOCALE_ENCODING) -> str: + """ + First try to read the file with UTF-8, if there is an error fallback to a + different encoding ("locale" by default). Returns the content of the file. + Also useful when reading files that might have been produced by an older version of + setuptools. + """ + try: + with open(file, "r", encoding="utf-8") as f: + return f.read() + except UnicodeDecodeError: # pragma: no cover + _Utf8EncodingNeeded.emit(file=file, fallback_encoding=fallback_encoding) + with open(file, "r", encoding=fallback_encoding) as f: + return f.read() + + +def _cfg_read_utf8_with_fallback( + cfg: RawConfigParser, file: str, fallback_encoding=py39.LOCALE_ENCODING +) -> None: + """Same idea as :func:`_read_utf8_with_fallback`, but for the + :meth:`RawConfigParser.read` method. + + This method may call ``cfg.clear()``. + """ + try: + cfg.read(file, encoding="utf-8") + except UnicodeDecodeError: # pragma: no cover + _Utf8EncodingNeeded.emit(file=file, fallback_encoding=fallback_encoding) + cfg.clear() + cfg.read(file, encoding=fallback_encoding) + + +class _Utf8EncodingNeeded(SetuptoolsDeprecationWarning): + _SUMMARY = """ + `encoding="utf-8"` fails with {file!r}, trying `encoding={fallback_encoding!r}`. + """ + + _DETAILS = """ + Fallback behavior for UTF-8 is considered **deprecated** and future versions of + `setuptools` may not implement it. + + Please encode {file!r} with "utf-8" to ensure future builds will succeed. + + If this file was produced by `setuptools` itself, cleaning up the cached files + and re-building/re-installing the package with a newer version of `setuptools` + (e.g. by updating `build-system.requires` in its `pyproject.toml`) + might solve the problem. + """ + # TODO: Add a deadline? + # Will we be able to remove this? + # The question comes to mind mainly because of sdists that have been produced + # by old versions of setuptools and published to PyPI... diff --git a/.venv/lib/python3.12/site-packages/setuptools/version.py b/.venv/lib/python3.12/site-packages/setuptools/version.py new file mode 100644 index 0000000000000000000000000000000000000000..ec253c414474677d3a5977511cfe901bfb786740 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/version.py @@ -0,0 +1,6 @@ +from ._importlib import metadata + +try: + __version__ = metadata.version('setuptools') or '0.dev0+unknown' +except Exception: + __version__ = '0.dev0+unknown' diff --git a/.venv/lib/python3.12/site-packages/setuptools/warnings.py b/.venv/lib/python3.12/site-packages/setuptools/warnings.py new file mode 100644 index 0000000000000000000000000000000000000000..96467787c237846bfbacf2d44eb833be0a88b633 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/warnings.py @@ -0,0 +1,110 @@ +"""Provide basic warnings used by setuptools modules. + +Using custom classes (other than ``UserWarning``) allow users to set +``PYTHONWARNINGS`` filters to run tests and prepare for upcoming changes in +setuptools. +""" + +from __future__ import annotations + +import os +import warnings +from datetime import date +from inspect import cleandoc +from textwrap import indent +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from typing_extensions import TypeAlias + +_DueDate: TypeAlias = tuple[int, int, int] # time tuple +_INDENT = 8 * " " +_TEMPLATE = f"""{80 * '*'}\n{{details}}\n{80 * '*'}""" + + +class SetuptoolsWarning(UserWarning): + """Base class in ``setuptools`` warning hierarchy.""" + + @classmethod + def emit( + cls, + summary: str | None = None, + details: str | None = None, + due_date: _DueDate | None = None, + see_docs: str | None = None, + see_url: str | None = None, + stacklevel: int = 2, + **kwargs, + ) -> None: + """Private: reserved for ``setuptools`` internal use only""" + # Default values: + summary_ = summary or getattr(cls, "_SUMMARY", None) or "" + details_ = details or getattr(cls, "_DETAILS", None) or "" + due_date = due_date or getattr(cls, "_DUE_DATE", None) + docs_ref = see_docs or getattr(cls, "_SEE_DOCS", None) + docs_url = docs_ref and f"https://setuptools.pypa.io/en/latest/{docs_ref}" + see_url = see_url or getattr(cls, "_SEE_URL", None) + due = date(*due_date) if due_date else None + + text = cls._format(summary_, details_, due, see_url or docs_url, kwargs) + if due and due < date.today() and _should_enforce(): + raise cls(text) + warnings.warn(text, cls, stacklevel=stacklevel + 1) + + @classmethod + def _format( + cls, + summary: str, + details: str, + due_date: date | None = None, + see_url: str | None = None, + format_args: dict | None = None, + ) -> str: + """Private: reserved for ``setuptools`` internal use only""" + today = date.today() + summary = cleandoc(summary).format_map(format_args or {}) + possible_parts = [ + cleandoc(details).format_map(format_args or {}), + ( + f"\nBy {due_date:%Y-%b-%d}, you need to update your project and remove " + "deprecated calls\nor your builds will no longer be supported." + if due_date and due_date > today + else None + ), + ( + "\nThis deprecation is overdue, please update your project and remove " + "deprecated\ncalls to avoid build errors in the future." + if due_date and due_date < today + else None + ), + (f"\nSee {see_url} for details." if see_url else None), + ] + parts = [x for x in possible_parts if x] + if parts: + body = indent(_TEMPLATE.format(details="\n".join(parts)), _INDENT) + return "\n".join([summary, "!!\n", body, "\n!!"]) + return summary + + +class InformationOnly(SetuptoolsWarning): + """Currently there is no clear way of displaying messages to the users + that use the setuptools backend directly via ``pip``. + The only thing that might work is a warning, although it is not the + most appropriate tool for the job... + + See pypa/packaging-problems#558. + """ + + +class SetuptoolsDeprecationWarning(SetuptoolsWarning): + """ + Base class for warning deprecations in ``setuptools`` + + This class is not derived from ``DeprecationWarning``, and as such is + visible by default. + """ + + +def _should_enforce(): + enforce = os.getenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false").lower() + return enforce in ("true", "on", "ok", "1") diff --git a/.venv/lib/python3.12/site-packages/setuptools/wheel.py b/.venv/lib/python3.12/site-packages/setuptools/wheel.py new file mode 100644 index 0000000000000000000000000000000000000000..c7ca43b5cfb2aff8d6983bbba4b7e6fdc9d01f83 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/wheel.py @@ -0,0 +1,236 @@ +"""Wheels support.""" + +import contextlib +import email +import functools +import itertools +import os +import posixpath +import re +import zipfile + +from packaging.tags import sys_tags +from packaging.utils import canonicalize_name +from packaging.version import Version as parse_version + +import setuptools +from setuptools.archive_util import _unpack_zipfile_obj +from setuptools.command.egg_info import _egg_basename, write_requirements + +from .unicode_utils import _read_utf8_with_fallback + +from distutils.util import get_platform + +WHEEL_NAME = re.compile( + r"""^(?P.+?)-(?P\d.*?) + ((-(?P\d.*?))?-(?P.+?)-(?P.+?)-(?P.+?) + )\.whl$""", + re.VERBOSE, +).match + +NAMESPACE_PACKAGE_INIT = "__import__('pkg_resources').declare_namespace(__name__)\n" + + +@functools.cache +def _get_supported_tags(): + # We calculate the supported tags only once, otherwise calling + # this method on thousands of wheels takes seconds instead of + # milliseconds. + return {(t.interpreter, t.abi, t.platform) for t in sys_tags()} + + +def unpack(src_dir, dst_dir) -> None: + """Move everything under `src_dir` to `dst_dir`, and delete the former.""" + for dirpath, dirnames, filenames in os.walk(src_dir): + subdir = os.path.relpath(dirpath, src_dir) + for f in filenames: + src = os.path.join(dirpath, f) + dst = os.path.join(dst_dir, subdir, f) + os.renames(src, dst) + for n, d in reversed(list(enumerate(dirnames))): + src = os.path.join(dirpath, d) + dst = os.path.join(dst_dir, subdir, d) + if not os.path.exists(dst): + # Directory does not exist in destination, + # rename it and prune it from os.walk list. + os.renames(src, dst) + del dirnames[n] + # Cleanup. + for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True): + assert not filenames + os.rmdir(dirpath) + + +@contextlib.contextmanager +def disable_info_traces(): + """ + Temporarily disable info traces. + """ + from distutils import log + + saved = log.set_threshold(log.WARN) + try: + yield + finally: + log.set_threshold(saved) + + +class Wheel: + def __init__(self, filename) -> None: + match = WHEEL_NAME(os.path.basename(filename)) + if match is None: + raise ValueError(f'invalid wheel name: {filename!r}') + self.filename = filename + for k, v in match.groupdict().items(): + setattr(self, k, v) + + def tags(self): + """List tags (py_version, abi, platform) supported by this wheel.""" + return itertools.product( + self.py_version.split('.'), + self.abi.split('.'), + self.platform.split('.'), + ) + + def is_compatible(self): + """Is the wheel compatible with the current platform?""" + return next((True for t in self.tags() if t in _get_supported_tags()), False) + + def egg_name(self): + return ( + _egg_basename( + self.project_name, + self.version, + platform=(None if self.platform == 'any' else get_platform()), + ) + + ".egg" + ) + + def get_dist_info(self, zf): + # find the correct name of the .dist-info dir in the wheel file + for member in zf.namelist(): + dirname = posixpath.dirname(member) + if dirname.endswith('.dist-info') and canonicalize_name(dirname).startswith( + canonicalize_name(self.project_name) + ): + return dirname + raise ValueError("unsupported wheel format. .dist-info not found") + + def install_as_egg(self, destination_eggdir) -> None: + """Install wheel as an egg directory.""" + with zipfile.ZipFile(self.filename) as zf: + self._install_as_egg(destination_eggdir, zf) + + def _install_as_egg(self, destination_eggdir, zf): + dist_basename = f'{self.project_name}-{self.version}' + dist_info = self.get_dist_info(zf) + dist_data = f'{dist_basename}.data' + egg_info = os.path.join(destination_eggdir, 'EGG-INFO') + + self._convert_metadata(zf, destination_eggdir, dist_info, egg_info) + self._move_data_entries(destination_eggdir, dist_data) + self._fix_namespace_packages(egg_info, destination_eggdir) + + @staticmethod + def _convert_metadata(zf, destination_eggdir, dist_info, egg_info): + import pkg_resources + + def get_metadata(name): + with zf.open(posixpath.join(dist_info, name)) as fp: + value = fp.read().decode('utf-8') + return email.parser.Parser().parsestr(value) + + wheel_metadata = get_metadata('WHEEL') + # Check wheel format version is supported. + wheel_version = parse_version(wheel_metadata.get('Wheel-Version')) + wheel_v1 = parse_version('1.0') <= wheel_version < parse_version('2.0dev0') + if not wheel_v1: + raise ValueError(f'unsupported wheel format version: {wheel_version}') + # Extract to target directory. + _unpack_zipfile_obj(zf, destination_eggdir) + # Convert metadata. + dist_info = os.path.join(destination_eggdir, dist_info) + dist = pkg_resources.Distribution.from_location( + destination_eggdir, + dist_info, + metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info), + ) + + # Note: Evaluate and strip markers now, + # as it's difficult to convert back from the syntax: + # foobar; "linux" in sys_platform and extra == 'test' + def raw_req(req): + req.marker = None + return str(req) + + install_requires = list(map(raw_req, dist.requires())) + extras_require = { + extra: [ + req + for req in map(raw_req, dist.requires((extra,))) + if req not in install_requires + ] + for extra in dist.extras + } + os.rename(dist_info, egg_info) + os.rename( + os.path.join(egg_info, 'METADATA'), + os.path.join(egg_info, 'PKG-INFO'), + ) + setup_dist = setuptools.Distribution( + attrs=dict( + install_requires=install_requires, + extras_require=extras_require, + ), + ) + with disable_info_traces(): + write_requirements( + setup_dist.get_command_obj('egg_info'), + None, + os.path.join(egg_info, 'requires.txt'), + ) + + @staticmethod + def _move_data_entries(destination_eggdir, dist_data): + """Move data entries to their correct location.""" + dist_data = os.path.join(destination_eggdir, dist_data) + dist_data_scripts = os.path.join(dist_data, 'scripts') + if os.path.exists(dist_data_scripts): + egg_info_scripts = os.path.join(destination_eggdir, 'EGG-INFO', 'scripts') + os.mkdir(egg_info_scripts) + for entry in os.listdir(dist_data_scripts): + # Remove bytecode, as it's not properly handled + # during easy_install scripts install phase. + if entry.endswith('.pyc'): + os.unlink(os.path.join(dist_data_scripts, entry)) + else: + os.rename( + os.path.join(dist_data_scripts, entry), + os.path.join(egg_info_scripts, entry), + ) + os.rmdir(dist_data_scripts) + for subdir in filter( + os.path.exists, + ( + os.path.join(dist_data, d) + for d in ('data', 'headers', 'purelib', 'platlib') + ), + ): + unpack(subdir, destination_eggdir) + if os.path.exists(dist_data): + os.rmdir(dist_data) + + @staticmethod + def _fix_namespace_packages(egg_info, destination_eggdir): + namespace_packages = os.path.join(egg_info, 'namespace_packages.txt') + if os.path.exists(namespace_packages): + namespace_packages = _read_utf8_with_fallback(namespace_packages).split() + + for mod in namespace_packages: + mod_dir = os.path.join(destination_eggdir, *mod.split('.')) + mod_init = os.path.join(mod_dir, '__init__.py') + if not os.path.exists(mod_dir): + os.mkdir(mod_dir) + if not os.path.exists(mod_init): + with open(mod_init, 'w', encoding="utf-8") as fp: + fp.write(NAMESPACE_PACKAGE_INIT) diff --git a/.venv/lib/python3.12/site-packages/setuptools/windows_support.py b/.venv/lib/python3.12/site-packages/setuptools/windows_support.py new file mode 100644 index 0000000000000000000000000000000000000000..7a2b53a291409c66851961a559eb4d69be0f4acc --- /dev/null +++ b/.venv/lib/python3.12/site-packages/setuptools/windows_support.py @@ -0,0 +1,30 @@ +import platform + + +def windows_only(func): + if platform.system() != 'Windows': + return lambda *args, **kwargs: None + return func + + +@windows_only +def hide_file(path: str) -> None: + """ + Set the hidden attribute on a file or directory. + + From https://stackoverflow.com/questions/19622133/ + + `path` must be text. + """ + import ctypes + import ctypes.wintypes + + SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW + SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD + SetFileAttributes.restype = ctypes.wintypes.BOOL + + FILE_ATTRIBUTE_HIDDEN = 0x02 + + ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN) + if not ret: + raise ctypes.WinError() diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/LICENSE b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1cc22a5aa7679ebaa10934212f356823931bdc3e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/LICENSE @@ -0,0 +1,18 @@ +Copyright (c) 2010-2024 Benjamin Peterson + +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. diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/METADATA b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..cfde03c2631c5c1d5cdc0949d0ee3379e7110f0e --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/METADATA @@ -0,0 +1,43 @@ +Metadata-Version: 2.1 +Name: six +Version: 1.17.0 +Summary: Python 2 and 3 compatibility utilities +Home-page: https://github.com/benjaminp/six +Author: Benjamin Peterson +Author-email: benjamin@python.org +License: MIT +Classifier: Development Status :: 5 - Production/Stable +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 3 +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Topic :: Software Development :: Libraries +Classifier: Topic :: Utilities +Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.* +License-File: LICENSE + +.. image:: https://img.shields.io/pypi/v/six.svg + :target: https://pypi.org/project/six/ + :alt: six on PyPI + +.. image:: https://readthedocs.org/projects/six/badge/?version=latest + :target: https://six.readthedocs.io/ + :alt: six's documentation on Read the Docs + +.. image:: https://img.shields.io/badge/license-MIT-green.svg + :target: https://github.com/benjaminp/six/blob/master/LICENSE + :alt: MIT License badge + +Six is a Python 2 and 3 compatibility library. It provides utility functions +for smoothing over the differences between the Python versions with the goal of +writing Python code that is compatible on both Python versions. See the +documentation for more information on what is provided. + +Six supports Python 2.7 and 3.3+. It is contained in only one Python +file, so it can be easily copied into your project. (The copyright and license +notice must be retained.) + +Online documentation is at https://six.readthedocs.io/. + +Bugs can be reported to https://github.com/benjaminp/six. The code can also +be found there. diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/RECORD b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..bb90c1a52e0f905a3facec665e8600ef20931282 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/RECORD @@ -0,0 +1,8 @@ +__pycache__/six.cpython-312.pyc,, +six-1.17.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +six-1.17.0.dist-info/LICENSE,sha256=Q3W6IOK5xsTnytKUCmKP2Q6VzD1Q7pKq51VxXYuh-9A,1066 +six-1.17.0.dist-info/METADATA,sha256=ViBCB4wnUlSfbYp8htvF3XCAiKe-bYBnLsewcQC3JGg,1658 +six-1.17.0.dist-info/RECORD,, +six-1.17.0.dist-info/WHEEL,sha256=pxeNX5JdtCe58PUSYP9upmc7jdRPgvT0Gm9kb1SHlVw,109 +six-1.17.0.dist-info/top_level.txt,sha256=_iVH_iYEtEXnD8nYGQYpYFUvkUW9sEO1GYbkeKSAais,4 +six.py,sha256=xRyR9wPT1LNpbJI8tf7CE-BeddkhU5O--sfy-mo5BN8,34703 diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..104f3874635f24f0d2918dfeaf6a59652274460c --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: setuptools (75.6.0) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..ffe2fce498955b628014618b28c6bcf152466a4a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six-1.17.0.dist-info/top_level.txt @@ -0,0 +1 @@ +six diff --git a/.venv/lib/python3.12/site-packages/six.py b/.venv/lib/python3.12/site-packages/six.py new file mode 100644 index 0000000000000000000000000000000000000000..3de5969b1ad3b973342e5e88ee1770fa7c798152 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/six.py @@ -0,0 +1,1003 @@ +# Copyright (c) 2010-2024 Benjamin Peterson +# +# 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. + +"""Utilities for writing code that runs on Python 2 and 3""" + +from __future__ import absolute_import + +import functools +import itertools +import operator +import sys +import types + +__author__ = "Benjamin Peterson " +__version__ = "1.17.0" + + +# Useful for very coarse version differentiation. +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +if PY3: + string_types = str, + integer_types = int, + class_types = type, + text_type = str + binary_type = bytes + + MAXSIZE = sys.maxsize +else: + string_types = basestring, + integer_types = (int, long) + class_types = (type, types.ClassType) + text_type = unicode + binary_type = str + + if sys.platform.startswith("java"): + # Jython always uses 32 bits. + MAXSIZE = int((1 << 31) - 1) + else: + # It's possible to have sizeof(long) != sizeof(Py_ssize_t). + class X(object): + + def __len__(self): + return 1 << 31 + try: + len(X()) + except OverflowError: + # 32-bit + MAXSIZE = int((1 << 31) - 1) + else: + # 64-bit + MAXSIZE = int((1 << 63) - 1) + del X + +if PY34: + from importlib.util import spec_from_loader +else: + spec_from_loader = None + + +def _add_doc(func, doc): + """Add documentation to a function.""" + func.__doc__ = doc + + +def _import_module(name): + """Import module, returning the module after the last dot.""" + __import__(name) + return sys.modules[name] + + +class _LazyDescr(object): + + def __init__(self, name): + self.name = name + + def __get__(self, obj, tp): + result = self._resolve() + setattr(obj, self.name, result) # Invokes __set__. + try: + # This is a bit ugly, but it avoids running this again by + # removing this descriptor. + delattr(obj.__class__, self.name) + except AttributeError: + pass + return result + + +class MovedModule(_LazyDescr): + + def __init__(self, name, old, new=None): + super(MovedModule, self).__init__(name) + if PY3: + if new is None: + new = name + self.mod = new + else: + self.mod = old + + def _resolve(self): + return _import_module(self.mod) + + def __getattr__(self, attr): + _module = self._resolve() + value = getattr(_module, attr) + setattr(self, attr, value) + return value + + +class _LazyModule(types.ModuleType): + + def __init__(self, name): + super(_LazyModule, self).__init__(name) + self.__doc__ = self.__class__.__doc__ + + def __dir__(self): + attrs = ["__doc__", "__name__"] + attrs += [attr.name for attr in self._moved_attributes] + return attrs + + # Subclasses should override this + _moved_attributes = [] + + +class MovedAttribute(_LazyDescr): + + def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): + super(MovedAttribute, self).__init__(name) + if PY3: + if new_mod is None: + new_mod = name + self.mod = new_mod + if new_attr is None: + if old_attr is None: + new_attr = name + else: + new_attr = old_attr + self.attr = new_attr + else: + self.mod = old_mod + if old_attr is None: + old_attr = name + self.attr = old_attr + + def _resolve(self): + module = _import_module(self.mod) + return getattr(module, self.attr) + + +class _SixMetaPathImporter(object): + + """ + A meta path importer to import six.moves and its submodules. + + This class implements a PEP302 finder and loader. It should be compatible + with Python 2.5 and all existing versions of Python3 + """ + + def __init__(self, six_module_name): + self.name = six_module_name + self.known_modules = {} + + def _add_module(self, mod, *fullnames): + for fullname in fullnames: + self.known_modules[self.name + "." + fullname] = mod + + def _get_module(self, fullname): + return self.known_modules[self.name + "." + fullname] + + def find_module(self, fullname, path=None): + if fullname in self.known_modules: + return self + return None + + def find_spec(self, fullname, path, target=None): + if fullname in self.known_modules: + return spec_from_loader(fullname, self) + return None + + def __get_module(self, fullname): + try: + return self.known_modules[fullname] + except KeyError: + raise ImportError("This loader does not know module " + fullname) + + def load_module(self, fullname): + try: + # in case of a reload + return sys.modules[fullname] + except KeyError: + pass + mod = self.__get_module(fullname) + if isinstance(mod, MovedModule): + mod = mod._resolve() + else: + mod.__loader__ = self + sys.modules[fullname] = mod + return mod + + def is_package(self, fullname): + """ + Return true, if the named module is a package. + + We need this method to get correct spec objects with + Python 3.4 (see PEP451) + """ + return hasattr(self.__get_module(fullname), "__path__") + + def get_code(self, fullname): + """Return None + + Required, if is_package is implemented""" + self.__get_module(fullname) # eventually raises ImportError + return None + get_source = get_code # same as get_code + + def create_module(self, spec): + return self.load_module(spec.name) + + def exec_module(self, module): + pass + +_importer = _SixMetaPathImporter(__name__) + + +class _MovedItems(_LazyModule): + + """Lazy loading of moved objects""" + __path__ = [] # mark as package + + +_moved_attributes = [ + MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), + MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), + MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"), + MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), + MovedAttribute("intern", "__builtin__", "sys"), + MovedAttribute("map", "itertools", "builtins", "imap", "map"), + MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), + MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), + MovedAttribute("getoutput", "commands", "subprocess"), + MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"), + MovedAttribute("reduce", "__builtin__", "functools"), + MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), + MovedAttribute("StringIO", "StringIO", "io"), + MovedAttribute("UserDict", "UserDict", "collections", "IterableUserDict", "UserDict"), + MovedAttribute("UserList", "UserList", "collections"), + MovedAttribute("UserString", "UserString", "collections"), + MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), + MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"), + MovedModule("builtins", "__builtin__"), + MovedModule("configparser", "ConfigParser"), + MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"), + MovedModule("copyreg", "copy_reg"), + MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), + MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"), + MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"), + MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), + MovedModule("http_cookies", "Cookie", "http.cookies"), + MovedModule("html_entities", "htmlentitydefs", "html.entities"), + MovedModule("html_parser", "HTMLParser", "html.parser"), + MovedModule("http_client", "httplib", "http.client"), + MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), + MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"), + MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), + MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"), + MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), + MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), + MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), + MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), + MovedModule("cPickle", "cPickle", "pickle"), + MovedModule("queue", "Queue"), + MovedModule("reprlib", "repr"), + MovedModule("socketserver", "SocketServer"), + MovedModule("_thread", "thread", "_thread"), + MovedModule("tkinter", "Tkinter"), + MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), + MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), + MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), + MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule("tkinter_tix", "Tix", "tkinter.tix"), + MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), + MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), + MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), + MovedModule("tkinter_colorchooser", "tkColorChooser", + "tkinter.colorchooser"), + MovedModule("tkinter_commondialog", "tkCommonDialog", + "tkinter.commondialog"), + MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), + MovedModule("tkinter_font", "tkFont", "tkinter.font"), + MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), + MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", + "tkinter.simpledialog"), + MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), + MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), + MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), + MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), + MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), +] +# Add windows specific modules. +if sys.platform == "win32": + _moved_attributes += [ + MovedModule("winreg", "_winreg"), + ] + +for attr in _moved_attributes: + setattr(_MovedItems, attr.name, attr) + if isinstance(attr, MovedModule): + _importer._add_module(attr, "moves." + attr.name) +del attr + +_MovedItems._moved_attributes = _moved_attributes + +moves = _MovedItems(__name__ + ".moves") +_importer._add_module(moves, "moves") + + +class Module_six_moves_urllib_parse(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_parse""" + + +_urllib_parse_moved_attributes = [ + MovedAttribute("ParseResult", "urlparse", "urllib.parse"), + MovedAttribute("SplitResult", "urlparse", "urllib.parse"), + MovedAttribute("parse_qs", "urlparse", "urllib.parse"), + MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), + MovedAttribute("urldefrag", "urlparse", "urllib.parse"), + MovedAttribute("urljoin", "urlparse", "urllib.parse"), + MovedAttribute("urlparse", "urlparse", "urllib.parse"), + MovedAttribute("urlsplit", "urlparse", "urllib.parse"), + MovedAttribute("urlunparse", "urlparse", "urllib.parse"), + MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), + MovedAttribute("quote", "urllib", "urllib.parse"), + MovedAttribute("quote_plus", "urllib", "urllib.parse"), + MovedAttribute("unquote", "urllib", "urllib.parse"), + MovedAttribute("unquote_plus", "urllib", "urllib.parse"), + MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"), + MovedAttribute("urlencode", "urllib", "urllib.parse"), + MovedAttribute("splitquery", "urllib", "urllib.parse"), + MovedAttribute("splittag", "urllib", "urllib.parse"), + MovedAttribute("splituser", "urllib", "urllib.parse"), + MovedAttribute("splitvalue", "urllib", "urllib.parse"), + MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), + MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), + MovedAttribute("uses_params", "urlparse", "urllib.parse"), + MovedAttribute("uses_query", "urlparse", "urllib.parse"), + MovedAttribute("uses_relative", "urlparse", "urllib.parse"), +] +for attr in _urllib_parse_moved_attributes: + setattr(Module_six_moves_urllib_parse, attr.name, attr) +del attr + +Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes + +_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), + "moves.urllib_parse", "moves.urllib.parse") + + +class Module_six_moves_urllib_error(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_error""" + + +_urllib_error_moved_attributes = [ + MovedAttribute("URLError", "urllib2", "urllib.error"), + MovedAttribute("HTTPError", "urllib2", "urllib.error"), + MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), +] +for attr in _urllib_error_moved_attributes: + setattr(Module_six_moves_urllib_error, attr.name, attr) +del attr + +Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes + +_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), + "moves.urllib_error", "moves.urllib.error") + + +class Module_six_moves_urllib_request(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_request""" + + +_urllib_request_moved_attributes = [ + MovedAttribute("urlopen", "urllib2", "urllib.request"), + MovedAttribute("install_opener", "urllib2", "urllib.request"), + MovedAttribute("build_opener", "urllib2", "urllib.request"), + MovedAttribute("pathname2url", "urllib", "urllib.request"), + MovedAttribute("url2pathname", "urllib", "urllib.request"), + MovedAttribute("getproxies", "urllib", "urllib.request"), + MovedAttribute("Request", "urllib2", "urllib.request"), + MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), + MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), + MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), + MovedAttribute("BaseHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), + MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), + MovedAttribute("FileHandler", "urllib2", "urllib.request"), + MovedAttribute("FTPHandler", "urllib2", "urllib.request"), + MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), + MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), + MovedAttribute("urlretrieve", "urllib", "urllib.request"), + MovedAttribute("urlcleanup", "urllib", "urllib.request"), + MovedAttribute("proxy_bypass", "urllib", "urllib.request"), + MovedAttribute("parse_http_list", "urllib2", "urllib.request"), + MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"), +] +if sys.version_info[:2] < (3, 14): + _urllib_request_moved_attributes.extend( + [ + MovedAttribute("URLopener", "urllib", "urllib.request"), + MovedAttribute("FancyURLopener", "urllib", "urllib.request"), + ] + ) +for attr in _urllib_request_moved_attributes: + setattr(Module_six_moves_urllib_request, attr.name, attr) +del attr + +Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes + +_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), + "moves.urllib_request", "moves.urllib.request") + + +class Module_six_moves_urllib_response(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_response""" + + +_urllib_response_moved_attributes = [ + MovedAttribute("addbase", "urllib", "urllib.response"), + MovedAttribute("addclosehook", "urllib", "urllib.response"), + MovedAttribute("addinfo", "urllib", "urllib.response"), + MovedAttribute("addinfourl", "urllib", "urllib.response"), +] +for attr in _urllib_response_moved_attributes: + setattr(Module_six_moves_urllib_response, attr.name, attr) +del attr + +Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes + +_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), + "moves.urllib_response", "moves.urllib.response") + + +class Module_six_moves_urllib_robotparser(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_robotparser""" + + +_urllib_robotparser_moved_attributes = [ + MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), +] +for attr in _urllib_robotparser_moved_attributes: + setattr(Module_six_moves_urllib_robotparser, attr.name, attr) +del attr + +Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes + +_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), + "moves.urllib_robotparser", "moves.urllib.robotparser") + + +class Module_six_moves_urllib(types.ModuleType): + + """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" + __path__ = [] # mark as package + parse = _importer._get_module("moves.urllib_parse") + error = _importer._get_module("moves.urllib_error") + request = _importer._get_module("moves.urllib_request") + response = _importer._get_module("moves.urllib_response") + robotparser = _importer._get_module("moves.urllib_robotparser") + + def __dir__(self): + return ['parse', 'error', 'request', 'response', 'robotparser'] + +_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"), + "moves.urllib") + + +def add_move(move): + """Add an item to six.moves.""" + setattr(_MovedItems, move.name, move) + + +def remove_move(name): + """Remove item from six.moves.""" + try: + delattr(_MovedItems, name) + except AttributeError: + try: + del moves.__dict__[name] + except KeyError: + raise AttributeError("no such move, %r" % (name,)) + + +if PY3: + _meth_func = "__func__" + _meth_self = "__self__" + + _func_closure = "__closure__" + _func_code = "__code__" + _func_defaults = "__defaults__" + _func_globals = "__globals__" +else: + _meth_func = "im_func" + _meth_self = "im_self" + + _func_closure = "func_closure" + _func_code = "func_code" + _func_defaults = "func_defaults" + _func_globals = "func_globals" + + +try: + advance_iterator = next +except NameError: + def advance_iterator(it): + return it.next() +next = advance_iterator + + +try: + callable = callable +except NameError: + def callable(obj): + return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) + + +if PY3: + def get_unbound_function(unbound): + return unbound + + create_bound_method = types.MethodType + + def create_unbound_method(func, cls): + return func + + Iterator = object +else: + def get_unbound_function(unbound): + return unbound.im_func + + def create_bound_method(func, obj): + return types.MethodType(func, obj, obj.__class__) + + def create_unbound_method(func, cls): + return types.MethodType(func, None, cls) + + class Iterator(object): + + def next(self): + return type(self).__next__(self) + + callable = callable +_add_doc(get_unbound_function, + """Get the function out of a possibly unbound function""") + + +get_method_function = operator.attrgetter(_meth_func) +get_method_self = operator.attrgetter(_meth_self) +get_function_closure = operator.attrgetter(_func_closure) +get_function_code = operator.attrgetter(_func_code) +get_function_defaults = operator.attrgetter(_func_defaults) +get_function_globals = operator.attrgetter(_func_globals) + + +if PY3: + def iterkeys(d, **kw): + return iter(d.keys(**kw)) + + def itervalues(d, **kw): + return iter(d.values(**kw)) + + def iteritems(d, **kw): + return iter(d.items(**kw)) + + def iterlists(d, **kw): + return iter(d.lists(**kw)) + + viewkeys = operator.methodcaller("keys") + + viewvalues = operator.methodcaller("values") + + viewitems = operator.methodcaller("items") +else: + def iterkeys(d, **kw): + return d.iterkeys(**kw) + + def itervalues(d, **kw): + return d.itervalues(**kw) + + def iteritems(d, **kw): + return d.iteritems(**kw) + + def iterlists(d, **kw): + return d.iterlists(**kw) + + viewkeys = operator.methodcaller("viewkeys") + + viewvalues = operator.methodcaller("viewvalues") + + viewitems = operator.methodcaller("viewitems") + +_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") +_add_doc(itervalues, "Return an iterator over the values of a dictionary.") +_add_doc(iteritems, + "Return an iterator over the (key, value) pairs of a dictionary.") +_add_doc(iterlists, + "Return an iterator over the (key, [values]) pairs of a dictionary.") + + +if PY3: + def b(s): + return s.encode("latin-1") + + def u(s): + return s + unichr = chr + import struct + int2byte = struct.Struct(">B").pack + del struct + byte2int = operator.itemgetter(0) + indexbytes = operator.getitem + iterbytes = iter + import io + StringIO = io.StringIO + BytesIO = io.BytesIO + del io + _assertCountEqual = "assertCountEqual" + if sys.version_info[1] <= 1: + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" + else: + _assertRaisesRegex = "assertRaisesRegex" + _assertRegex = "assertRegex" + _assertNotRegex = "assertNotRegex" +else: + def b(s): + return s + # Workaround for standalone backslash + + def u(s): + return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape") + unichr = unichr + int2byte = chr + + def byte2int(bs): + return ord(bs[0]) + + def indexbytes(buf, i): + return ord(buf[i]) + iterbytes = functools.partial(itertools.imap, ord) + import StringIO + StringIO = BytesIO = StringIO.StringIO + _assertCountEqual = "assertItemsEqual" + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" +_add_doc(b, """Byte literal""") +_add_doc(u, """Text literal""") + + +def assertCountEqual(self, *args, **kwargs): + return getattr(self, _assertCountEqual)(*args, **kwargs) + + +def assertRaisesRegex(self, *args, **kwargs): + return getattr(self, _assertRaisesRegex)(*args, **kwargs) + + +def assertRegex(self, *args, **kwargs): + return getattr(self, _assertRegex)(*args, **kwargs) + + +def assertNotRegex(self, *args, **kwargs): + return getattr(self, _assertNotRegex)(*args, **kwargs) + + +if PY3: + exec_ = getattr(moves.builtins, "exec") + + def reraise(tp, value, tb=None): + try: + if value is None: + value = tp() + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + finally: + value = None + tb = None + +else: + def exec_(_code_, _globs_=None, _locs_=None): + """Execute code in a namespace.""" + if _globs_ is None: + frame = sys._getframe(1) + _globs_ = frame.f_globals + if _locs_ is None: + _locs_ = frame.f_locals + del frame + elif _locs_ is None: + _locs_ = _globs_ + exec("""exec _code_ in _globs_, _locs_""") + + exec_("""def reraise(tp, value, tb=None): + try: + raise tp, value, tb + finally: + tb = None +""") + + +if sys.version_info[:2] > (3,): + exec_("""def raise_from(value, from_value): + try: + raise value from from_value + finally: + value = None +""") +else: + def raise_from(value, from_value): + raise value + + +print_ = getattr(moves.builtins, "print", None) +if print_ is None: + def print_(*args, **kwargs): + """The new-style print function for Python 2.4 and 2.5.""" + fp = kwargs.pop("file", sys.stdout) + if fp is None: + return + + def write(data): + if not isinstance(data, basestring): + data = str(data) + # If the file has an encoding, encode unicode with it. + if (isinstance(fp, file) and + isinstance(data, unicode) and + fp.encoding is not None): + errors = getattr(fp, "errors", None) + if errors is None: + errors = "strict" + data = data.encode(fp.encoding, errors) + fp.write(data) + want_unicode = False + sep = kwargs.pop("sep", None) + if sep is not None: + if isinstance(sep, unicode): + want_unicode = True + elif not isinstance(sep, str): + raise TypeError("sep must be None or a string") + end = kwargs.pop("end", None) + if end is not None: + if isinstance(end, unicode): + want_unicode = True + elif not isinstance(end, str): + raise TypeError("end must be None or a string") + if kwargs: + raise TypeError("invalid keyword arguments to print()") + if not want_unicode: + for arg in args: + if isinstance(arg, unicode): + want_unicode = True + break + if want_unicode: + newline = unicode("\n") + space = unicode(" ") + else: + newline = "\n" + space = " " + if sep is None: + sep = space + if end is None: + end = newline + for i, arg in enumerate(args): + if i: + write(sep) + write(arg) + write(end) +if sys.version_info[:2] < (3, 3): + _print = print_ + + def print_(*args, **kwargs): + fp = kwargs.get("file", sys.stdout) + flush = kwargs.pop("flush", False) + _print(*args, **kwargs) + if flush and fp is not None: + fp.flush() + +_add_doc(reraise, """Reraise an exception.""") + +if sys.version_info[0:2] < (3, 4): + # This does exactly the same what the :func:`py3:functools.update_wrapper` + # function does on Python versions after 3.2. It sets the ``__wrapped__`` + # attribute on ``wrapper`` object and it doesn't raise an error if any of + # the attributes mentioned in ``assigned`` and ``updated`` are missing on + # ``wrapped`` object. + def _update_wrapper(wrapper, wrapped, + assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES): + for attr in assigned: + try: + value = getattr(wrapped, attr) + except AttributeError: + continue + else: + setattr(wrapper, attr, value) + for attr in updated: + getattr(wrapper, attr).update(getattr(wrapped, attr, {})) + wrapper.__wrapped__ = wrapped + return wrapper + _update_wrapper.__doc__ = functools.update_wrapper.__doc__ + + def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES): + return functools.partial(_update_wrapper, wrapped=wrapped, + assigned=assigned, updated=updated) + wraps.__doc__ = functools.wraps.__doc__ + +else: + wraps = functools.wraps + + +def with_metaclass(meta, *bases): + """Create a base class with a metaclass.""" + # This requires a bit of explanation: the basic idea is to make a dummy + # metaclass for one level of class instantiation that replaces itself with + # the actual metaclass. + class metaclass(type): + + def __new__(cls, name, this_bases, d): + if sys.version_info[:2] >= (3, 7): + # This version introduced PEP 560 that requires a bit + # of extra care (we mimic what is done by __build_class__). + resolved_bases = types.resolve_bases(bases) + if resolved_bases is not bases: + d['__orig_bases__'] = bases + else: + resolved_bases = bases + return meta(name, resolved_bases, d) + + @classmethod + def __prepare__(cls, name, this_bases): + return meta.__prepare__(name, bases) + return type.__new__(metaclass, 'temporary_class', (), {}) + + +def add_metaclass(metaclass): + """Class decorator for creating a class with a metaclass.""" + def wrapper(cls): + orig_vars = cls.__dict__.copy() + slots = orig_vars.get('__slots__') + if slots is not None: + if isinstance(slots, str): + slots = [slots] + for slots_var in slots: + orig_vars.pop(slots_var) + orig_vars.pop('__dict__', None) + orig_vars.pop('__weakref__', None) + if hasattr(cls, '__qualname__'): + orig_vars['__qualname__'] = cls.__qualname__ + return metaclass(cls.__name__, cls.__bases__, orig_vars) + return wrapper + + +def ensure_binary(s, encoding='utf-8', errors='strict'): + """Coerce **s** to six.binary_type. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> encoded to `bytes` + - `bytes` -> `bytes` + """ + if isinstance(s, binary_type): + return s + if isinstance(s, text_type): + return s.encode(encoding, errors) + raise TypeError("not expecting type '%s'" % type(s)) + + +def ensure_str(s, encoding='utf-8', errors='strict'): + """Coerce *s* to `str`. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + # Optimization: Fast return for the common case. + if type(s) is str: + return s + if PY2 and isinstance(s, text_type): + return s.encode(encoding, errors) + elif PY3 and isinstance(s, binary_type): + return s.decode(encoding, errors) + elif not isinstance(s, (text_type, binary_type)): + raise TypeError("not expecting type '%s'" % type(s)) + return s + + +def ensure_text(s, encoding='utf-8', errors='strict'): + """Coerce *s* to six.text_type. + + For Python 2: + - `unicode` -> `unicode` + - `str` -> `unicode` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + if isinstance(s, binary_type): + return s.decode(encoding, errors) + elif isinstance(s, text_type): + return s + else: + raise TypeError("not expecting type '%s'" % type(s)) + + +def python_2_unicode_compatible(klass): + """ + A class decorator that defines __unicode__ and __str__ methods under Python 2. + Under Python 3 it does nothing. + + To support Python 2 and 3 with a single code base, define a __str__ method + returning text and apply this decorator to the class. + """ + if PY2: + if '__str__' not in klass.__dict__: + raise ValueError("@python_2_unicode_compatible cannot be applied " + "to %s because it doesn't define __str__()." % + klass.__name__) + klass.__unicode__ = klass.__str__ + klass.__str__ = lambda self: self.__unicode__().encode('utf-8') + return klass + + +# Complete the moves implementation. +# This code is at the end of this module to speed up module loading. +# Turn this module into a package. +__path__ = [] # required for PEP 302 and PEP 451 +__package__ = __name__ # see PEP 366 @ReservedAssignment +if globals().get("__spec__") is not None: + __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable +# Remove other six meta path importers, since they cause problems. This can +# happen if six is removed from sys.modules and then reloaded. (Setuptools does +# this for some reason.) +if sys.meta_path: + for i, importer in enumerate(sys.meta_path): + # Here's some real nastiness: Another "instance" of the six module might + # be floating around. Therefore, we can't use isinstance() to check for + # the six meta path importer, since the other six instance will have + # inserted an importer with different class. + if (type(importer).__name__ == "_SixMetaPathImporter" and + importer.name == __name__): + del sys.meta_path[i] + break + del i, importer +# Finally, add the importer to the meta path import hook. +sys.meta_path.append(_importer) diff --git a/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/METADATA b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..eb7d6d8219ac25ee4fc0af3b83b44ab1d34c55df --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/METADATA @@ -0,0 +1,114 @@ +Metadata-Version: 2.4 +Name: soupsieve +Version: 2.9.2 +Summary: A modern CSS selector implementation for Beautiful Soup. +Project-URL: Homepage, https://github.com/facelessuser/soupsieve +Author-email: Isaac Muse +License-Expression: MIT +License-File: LICENSE.md +Keywords: CSS,HTML,XML,filter,query,selector,soup +Classifier: Development Status :: 5 - Production/Stable +Classifier: Environment :: Console +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: MIT License +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: Python :: 3 +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.14 +Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Typing :: Typed +Requires-Python: >=3.10 +Description-Content-Type: text/markdown + +[![Donate via PayPal][donate-image]][donate-link] +[![Build][github-ci-image]][github-ci-link] +[![Coverage Status][codecov-image]][codecov-link] +[![PyPI Version][pypi-image]][pypi-link] +[![PyPI Downloads][pypi-down]][pypi-link] +[![PyPI - Python Version][python-image]][pypi-link] +[![License][license-image-mit]][license-link] + +# Soup Sieve + +## Overview + +Soup Sieve is a CSS selector library designed to be used with [Beautiful Soup 4][bs4]. It aims to provide selecting, +matching, and filtering using modern CSS selectors. Soup Sieve currently provides selectors from the CSS level 1 +specifications up through the latest CSS level 4 drafts and beyond (though some are not yet implemented). + +Soup Sieve was written with the intent to replace Beautiful Soup's builtin select feature, and as of Beautiful Soup +version 4.7.0, it now is :confetti_ball:. Soup Sieve can also be imported in order to use its API directly for +more controlled, specialized parsing. + +Soup Sieve has implemented most of the CSS selectors up through the latest CSS draft specifications, though there are a +number that don't make sense in a non-browser environment. Selectors that cannot provide meaningful functionality simply +do not match anything. Some of the supported selectors are: + +- `.classes` +- `#ids` +- `[attributes=value]` +- `parent child` +- `parent > child` +- `sibling ~ sibling` +- `sibling + sibling` +- `:not(element.class, element2.class)` +- `:is(element.class, element2.class)` +- `parent:has(> child)` +- and [many more](https://facelessuser.github.io/soupsieve/selectors/) + + +## Installation + +You must have Beautiful Soup already installed: + +``` +pip install beautifulsoup4 +``` + +In most cases, assuming you've installed version 4.7.0, that should be all you need to do, but if you've installed via +some alternative method, and Soup Sieve is not automatically installed, you can install it directly: + +``` +pip install soupsieve +``` + +If you want to manually install it from source, first ensure that [`build`](https://pypi.org/project/build/) is +installed: + +``` +pip install build +``` + +Then navigate to the root of the project and build the wheel and install (replacing `` with the current version): + +``` +python -m build -w +pip install dist/soupsieve--py3-none-any.whl +``` + +## Documentation + +Documentation is found here: https://facelessuser.github.io/soupsieve/. + +## License + +MIT + +[bs4]: https://beautiful-soup-4.readthedocs.io/en/latest/# + +[github-ci-image]: https://github.com/facelessuser/soupsieve/workflows/build/badge.svg +[github-ci-link]: https://github.com/facelessuser/soupsieve/actions?query=workflow%3Abuild+branch%3Amain +[codecov-image]: https://img.shields.io/codecov/c/github/facelessuser/soupsieve/master.svg?logo=codecov&logoColor=aaaaaa&labelColor=333333 +[codecov-link]: https://codecov.io/github/facelessuser/soupsieve +[pypi-image]: https://img.shields.io/pypi/v/soupsieve.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333 +[pypi-down]: https://img.shields.io/pypi/dm/soupsieve.svg?logo=pypi&logoColor=aaaaaa&labelColor=333333 +[pypi-link]: https://pypi.python.org/pypi/soupsieve +[python-image]: https://img.shields.io/pypi/pyversions/soupsieve?logo=python&logoColor=aaaaaa&labelColor=333333 +[license-image-mit]: https://img.shields.io/badge/license-MIT-blue.svg?labelColor=333333 +[license-link]: https://github.com/facelessuser/soupsieve/blob/main/LICENSE.md +[donate-image]: https://img.shields.io/badge/Donate-PayPal-3fabd1?logo=paypal +[donate-link]: https://www.paypal.me/facelessuser diff --git a/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/RECORD b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..bff4c18a6fbfc31ca101bd92d10846a6af9cac35 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/RECORD @@ -0,0 +1,20 @@ +soupsieve-2.9.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +soupsieve-2.9.2.dist-info/METADATA,sha256=Ja3mWAgXOBZXpCt8GKqpAyI-tpZAG-PuqYUNPUoa8YI,4586 +soupsieve-2.9.2.dist-info/RECORD,, +soupsieve-2.9.2.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87 +soupsieve-2.9.2.dist-info/licenses/LICENSE.md,sha256=dqCs25jDpjaB4gtvCWaZ74ytX7NdVu74OH4Ppx15epo,1096 +soupsieve/__init__.py,sha256=FV4Ol2FRldy7rG94nQHNHoJTZIdQbUJdZkGhXkI3tiE,4581 +soupsieve/__meta__.py,sha256=GWNjSuOoU3r23v6D1P38tEs-pavnOjiVpqEyOfDsMBk,6766 +soupsieve/__pycache__/__init__.cpython-312.pyc,, +soupsieve/__pycache__/__meta__.cpython-312.pyc,, +soupsieve/__pycache__/css_match.cpython-312.pyc,, +soupsieve/__pycache__/css_parser.cpython-312.pyc,, +soupsieve/__pycache__/css_types.cpython-312.pyc,, +soupsieve/__pycache__/pretty.cpython-312.pyc,, +soupsieve/__pycache__/util.cpython-312.pyc,, +soupsieve/css_match.py,sha256=UmCH_ltakWVIDyyfKBs619ttpyw9nANbNVdkl3Z65TM,60276 +soupsieve/css_parser.py,sha256=kqwBKDzFgxxHn_prd93D8oTaw00SkRtxdUf7jItTRas,48182 +soupsieve/css_types.py,sha256=OxTs1p2bZK4nvPjJu-TVgPYVrMXnQwQ7RGq0cfzZwC0,10014 +soupsieve/pretty.py,sha256=iSM-NKCzruJQCwEriQT72LrF4slxsib7TB552H2bsqA,4362 +soupsieve/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +soupsieve/util.py,sha256=Q0MVH77cUBXMtKV0D2f8Syf90remPe0EfLqe6-msAeI,3352 diff --git a/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..7401812e19af977cc5088f3b8fb1ef6bc0441c0a --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: hatchling 1.31.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/licenses/LICENSE.md b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/licenses/LICENSE.md new file mode 100644 index 0000000000000000000000000000000000000000..128c5342c81d4986cba6d118a41e402d7b676996 --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve-2.9.2.dist-info/licenses/LICENSE.md @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 - 2026 Isaac Muse + +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. diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__init__.py b/.venv/lib/python3.12/site-packages/soupsieve/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e170c71c5453fd3d19bf25499d8f177c101cb8af --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve/__init__.py @@ -0,0 +1,168 @@ +""" +Soup Sieve. + +A CSS selector filter for BeautifulSoup4. + +MIT License + +Copyright (c) 2018 Isaac Muse + +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. +""" +from __future__ import annotations +from .__meta__ import __version__, __version_info__ # noqa: F401 +from . import css_parser as cp +from . import css_match as cm +from . import css_types as ct +from .util import DEBUG, SelectorSyntaxError # noqa: F401 +import bs4 +from typing import Any, Iterator, Iterable + +__all__ = ( + 'DEBUG', 'SelectorSyntaxError', 'SoupSieve', + 'closest', 'compile', 'filter', 'iselect', + 'match', 'select', 'select_one' +) + +SoupSieve = cm.SoupSieve + + +def compile( # noqa: A001 + pattern: str, + namespaces: dict[str, str] | None = None, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> cm.SoupSieve: + """Compile CSS pattern.""" + + if isinstance(pattern, SoupSieve): + if flags: + raise ValueError("Cannot process 'flags' argument on a compiled selector list") + elif namespaces is not None: + raise ValueError("Cannot process 'namespaces' argument on a compiled selector list") + elif custom is not None: + raise ValueError("Cannot process 'custom' argument on a compiled selector list") + return pattern + + return cp._cached_css_compile( + pattern, + ct.Namespaces(namespaces) if namespaces is not None else namespaces, + ct.CustomSelectors(custom) if custom is not None else custom, + flags + ) + + +def purge() -> None: + """Purge cached patterns.""" + + cp._purge_cache() + + +def closest( + select: str, + tag: bs4.Tag, + namespaces: dict[str, str] | None = None, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> bs4.Tag | None: + """Match closest ancestor.""" + + return compile(select, namespaces, flags, **kwargs).closest(tag) + + +def match( + select: str, + tag: bs4.Tag, + namespaces: dict[str, str] | None = None, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> bool: + """Match node.""" + + return compile(select, namespaces, flags, **kwargs).match(tag) + + +def filter( # noqa: A001 + select: str, + iterable: Iterable[bs4.Tag], + namespaces: dict[str, str] | None = None, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> list[bs4.Tag]: + """Filter list of nodes.""" + + return compile(select, namespaces, flags, **kwargs).filter(iterable) + + +def select_one( + select: str, + tag: bs4.Tag, + namespaces: dict[str, str] | None = None, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> bs4.Tag | None: + """Select a single tag.""" + + return compile(select, namespaces, flags, **kwargs).select_one(tag) + + +def select( + select: str, + tag: bs4.Tag, + namespaces: dict[str, str] | None = None, + limit: int = 0, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> list[bs4.Tag]: + """Select the specified tags.""" + + return compile(select, namespaces, flags, **kwargs).select(tag, limit) + + +def iselect( + select: str, + tag: bs4.Tag, + namespaces: dict[str, str] | None = None, + limit: int = 0, + flags: int = 0, + *, + custom: dict[str, str] | None = None, + **kwargs: Any +) -> Iterator[bs4.Tag]: + """Iterate the specified tags.""" + + yield from compile(select, namespaces, flags, **kwargs).iselect(tag, limit) + + +def escape(ident: str) -> str: + """Escape identifier.""" + + return cp.escape(ident) diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__meta__.py b/.venv/lib/python3.12/site-packages/soupsieve/__meta__.py new file mode 100644 index 0000000000000000000000000000000000000000..e90cf9bf418aac05985889766c5f922f278922eb --- /dev/null +++ b/.venv/lib/python3.12/site-packages/soupsieve/__meta__.py @@ -0,0 +1,197 @@ +"""Meta related things.""" +from __future__ import annotations +from collections import namedtuple +import re + +RE_VER = re.compile( + r'''(?x) + (?P\d+)(?:\.(?P\d+))?(?:\.(?P\d+))? + (?:(?Pa|b|rc)(?P
\d+))?
+    (?:\.post(?P\d+))?
+    (?:\.dev(?P\d+))?
+    '''
+)
+
+REL_MAP = {
+    ".dev": "",
+    ".dev-alpha": "a",
+    ".dev-beta": "b",
+    ".dev-candidate": "rc",
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": ""
+}
+
+DEV_STATUS = {
+    ".dev": "2 - Pre-Alpha",
+    ".dev-alpha": "2 - Pre-Alpha",
+    ".dev-beta": "2 - Pre-Alpha",
+    ".dev-candidate": "2 - Pre-Alpha",
+    "alpha": "3 - Alpha",
+    "beta": "4 - Beta",
+    "candidate": "4 - Beta",
+    "final": "5 - Production/Stable"
+}
+
+PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'}
+
+
+class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])):
+    """
+    Get the version (PEP 440).
+
+    A biased approach to the PEP 440 semantic version.
+
+    Provides a tuple structure which is sorted for comparisons `v1 > v2` etc.
+      (major, minor, micro, release type, pre-release build, post-release build, development release build)
+    Release types are named in is such a way they are comparable with ease.
+    Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get
+    development status for setup files.
+
+    How it works (currently):
+
+    - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`.
+    - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`.
+      The dot is used to ensure all development specifiers are sorted before `alpha`.
+      You can specify a `dev` number for development builds, but do not have to as implicit development releases
+      are allowed.
+    - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not
+      allow implicit prereleases.
+    - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases
+      are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be
+      noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically
+      does not allow implicit post releases.
+    - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`.
+
+    Acceptable version releases:
+
+    ```
+    Version(1, 0, 0, "final")                    1.0
+    Version(1, 2, 0, "final")                    1.2
+    Version(1, 2, 3, "final")                    1.2.3
+    Version(1, 2, 0, ".dev-alpha", pre=4)        1.2a4
+    Version(1, 2, 0, ".dev-beta", pre=4)         1.2b4
+    Version(1, 2, 0, ".dev-candidate", pre=4)    1.2rc4
+    Version(1, 2, 0, "final", post=1)            1.2.post1
+    Version(1, 2, 3, ".dev")                     1.2.3.dev0
+    Version(1, 2, 3, ".dev", dev=1)              1.2.3.dev1
+    ```
+
+    """
+
+    def __new__(
+        cls,
+        major: int, minor: int, micro: int, release: str = "final",
+        pre: int = 0, post: int = 0, dev: int = 0
+    ) -> Version:
+        """Validate version info."""
+
+        # Ensure all parts are positive integers.
+        for value in (major, minor, micro, pre, post):
+            if not (isinstance(value, int) and value >= 0):
+                raise ValueError("All version parts except 'release' should be integers.")
+
+        if release not in REL_MAP:
+            raise ValueError(f"'{release}' is not a valid release type.")
+
+        # Ensure valid pre-release (we do not allow implicit pre-releases).
+        if ".dev-candidate" < release < "final":
+            if pre == 0:
+                raise ValueError("Implicit pre-releases not allowed.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure valid development or development/pre release
+        elif release < "alpha":
+            if release > ".dev" and pre == 0:
+                raise ValueError("Implicit pre-release not allowed.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure a valid normal release
+        else:
+            if pre:
+                raise ValueError("Version is not a pre-release.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+
+        return super().__new__(cls, major, minor, micro, release, pre, post, dev)
+
+    def _is_pre(self) -> bool:
+        """Is prerelease."""
+
+        return bool(self.pre > 0)
+
+    def _is_dev(self) -> bool:
+        """Is development."""
+
+        return bool(self.release < "alpha")
+
+    def _is_post(self) -> bool:
+        """Is post."""
+
+        return bool(self.post > 0)
+
+    def _get_dev_status(self) -> str:  # pragma: no cover
+        """Get development status string."""
+
+        return DEV_STATUS[self.release]
+
+    def _get_canonical(self) -> str:
+        """Get the canonical output string."""
+
+        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..
+        if self.micro == 0:
+            ver = f"{self.major}.{self.minor}"
+        else:
+            ver = f"{self.major}.{self.minor}.{self.micro}"
+        if self._is_pre():
+            ver += f'{REL_MAP[self.release]}{self.pre}'
+        if self._is_post():
+            ver += f".post{self.post}"
+        if self._is_dev():
+            ver += f".dev{self.dev}"
+
+        return ver
+
+
+def parse_version(ver: str) -> Version:
+    """Parse version into a comparable Version tuple."""
+
+    m = RE_VER.match(ver)
+
+    if m is None:
+        raise ValueError(f"'{ver}' is not a valid version")
+
+    # Handle major, minor, micro
+    major = int(m.group('major'))
+    minor = int(m.group('minor')) if m.group('minor') else 0
+    micro = int(m.group('micro')) if m.group('micro') else 0
+
+    # Handle pre releases
+    if m.group('type'):
+        release = PRE_REL_MAP[m.group('type')]
+        pre = int(m.group('pre'))
+    else:
+        release = "final"
+        pre = 0
+
+    # Handle development releases
+    dev = m.group('dev') if m.group('dev') else 0
+    if m.group('dev'):
+        dev = int(m.group('dev'))
+        release = '.dev-' + release if pre else '.dev'
+    else:
+        dev = 0
+
+    # Handle post
+    post = int(m.group('post')) if m.group('post') else 0
+
+    return Version(major, minor, micro, release, pre, post, dev)
+
+
+__version_info__ = Version(2, 9, 2, "final")
+__version__ = __version_info__._get_canonical()
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..640f75484aad55ab097f63c8d6b45d9570f039d7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__meta__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__meta__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60ae94cdf95da7431633075313cbb8bc8ee21987
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/__meta__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_match.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_match.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5e91734fb7dac3bde7ff7e41f0669f1b70f4ee8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_match.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_parser.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_parser.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c232f680dae37ff57b713cc745d184efd2a049d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_parser.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_types.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_types.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9b059fe647beb1b1321156d128e3ee8a882f42f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/css_types.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/pretty.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/pretty.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e7238eee192c2f867cb0d4e616bd228414b9125
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/pretty.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9bb69de721bd86938733466ab48b7ce994d50a79
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/soupsieve/__pycache__/util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/css_match.py b/.venv/lib/python3.12/site-packages/soupsieve/css_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f4dc1e1189ce3b0f4400802dc99c496553c4eb4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/soupsieve/css_match.py
@@ -0,0 +1,1628 @@
+"""CSS matcher."""
+from __future__ import annotations
+from datetime import datetime
+from . import util
+import re
+from . import css_types as ct
+import unicodedata
+import bs4
+from typing import Iterator, Iterable, Any, Callable, Sequence, Any, cast  # noqa: F401, F811
+
+# Empty tag pattern (whitespace okay)
+RE_NOT_EMPTY = re.compile('[^ \t\r\n\f]')
+
+RE_NOT_WS = re.compile('[^ \t\r\n\f]+')
+
+# Relationships
+REL_PARENT = ' '
+REL_CLOSE_PARENT = '>'
+REL_SIBLING = '~'
+REL_CLOSE_SIBLING = '+'
+
+# Relationships for :has() (forward looking)
+REL_HAS_PARENT = ': '
+REL_HAS_CLOSE_PARENT = ':>'
+REL_HAS_SIBLING = ':~'
+REL_HAS_CLOSE_SIBLING = ':+'
+
+NS_XHTML = 'http://www.w3.org/1999/xhtml'
+NS_XML = 'http://www.w3.org/XML/1998/namespace'
+
+DIR_FLAGS = ct.SEL_DIR_LTR | ct.SEL_DIR_RTL
+RANGES = ct.SEL_IN_RANGE | ct.SEL_OUT_OF_RANGE
+
+DIR_MAP = {
+    'ltr': ct.SEL_DIR_LTR,
+    'rtl': ct.SEL_DIR_RTL,
+    'auto': 0
+}
+
+RE_NUM = re.compile(r"^(?P-?(?:[0-9]{1,}(\.[0-9]+)?|\.[0-9]+))$")
+RE_TIME = re.compile(r'^(?P[0-9]{2}):(?P[0-9]{2})$')
+RE_MONTH = re.compile(r'^(?P[0-9]{4,})-(?P[0-9]{2})$')
+RE_WEEK = re.compile(r'^(?P[0-9]{4,})-W(?P[0-9]{2})$')
+RE_DATE = re.compile(r'^(?P[0-9]{4,})-(?P[0-9]{2})-(?P[0-9]{2})$')
+RE_DATETIME = re.compile(
+    r'^(?P[0-9]{4,})-(?P[0-9]{2})-(?P[0-9]{2})T(?P[0-9]{2}):(?P[0-9]{2})$'
+)
+RE_WILD_STRIP = re.compile(r'(?:(?:-\*-)(?:\*(?:-|$))*|-\*$)')
+
+MONTHS_30 = (4, 6, 9, 11)  # April, June, September, and November
+FEB = 2
+SHORT_MONTH = 30
+LONG_MONTH = 31
+FEB_MONTH = 28
+FEB_LEAP_MONTH = 29
+DAYS_IN_WEEK = 7
+
+
+class _FakeParent:
+    """
+    Fake parent class.
+
+    When we have a fragment with no `BeautifulSoup` document object,
+    we can't evaluate `nth` selectors properly.  Create a temporary
+    fake parent so we can traverse the root element as a child.
+    """
+
+    def __init__(self, element: bs4.Tag) -> None:
+        """Initialize."""
+
+        self.contents = [element]
+
+    def __len__(self) -> int:
+        """Length."""
+
+        return len(self.contents)
+
+
+class _DocumentNav:
+    """Navigate a Beautiful Soup document."""
+
+    @classmethod
+    def assert_valid_input(cls, tag: Any) -> None:
+        """Check if valid input tag or document."""
+
+        # Fail on unexpected types.
+        if not cls.is_tag(tag):
+            raise TypeError(f"Expected a BeautifulSoup 'Tag', but instead received type {type(tag)}")
+
+    @staticmethod
+    def is_doc(obj: bs4.element.PageElement | None) -> bool:
+        """Is `BeautifulSoup` object."""
+        return isinstance(obj, bs4.BeautifulSoup)
+
+    @staticmethod
+    def is_tag(obj: bs4.element.PageElement | None) -> bool:
+        """Is tag."""
+        return isinstance(obj, bs4.Tag)
+
+    @staticmethod
+    def is_declaration(obj: bs4.element.PageElement | None) -> bool:  # pragma: no cover
+        """Is declaration."""
+        return isinstance(obj, bs4.Declaration)
+
+    @staticmethod
+    def is_cdata(obj: bs4.element.PageElement | None) -> bool:
+        """Is CDATA."""
+        return isinstance(obj, bs4.CData)
+
+    @staticmethod
+    def is_processing_instruction(obj: bs4.element.PageElement | None) -> bool:  # pragma: no cover
+        """Is processing instruction."""
+        return isinstance(obj, bs4.ProcessingInstruction)
+
+    @staticmethod
+    def is_navigable_string(obj: bs4.element.PageElement | None) -> bool:
+        """Is navigable string."""
+        return isinstance(obj, bs4.element.NavigableString)
+
+    @staticmethod
+    def is_special_string(obj: bs4.element.PageElement | None) -> bool:
+        """Is special string."""
+        return isinstance(obj, (bs4.Comment, bs4.Declaration, bs4.CData, bs4.ProcessingInstruction, bs4.Doctype))
+
+    @classmethod
+    def is_content_string(cls, obj: bs4.element.PageElement | None) -> bool:
+        """Check if node is content string."""
+
+        return cls.is_navigable_string(obj) and not cls.is_special_string(obj)
+
+    @staticmethod
+    def create_fake_parent(el: bs4.Tag) -> _FakeParent:
+        """Create fake parent for a given element."""
+
+        return _FakeParent(el)
+
+    @staticmethod
+    def is_xml_tree(el: bs4.Tag | None) -> bool:
+        """Check if element (or document) is from a XML tree."""
+
+        return el is not None and bool(el._is_xml)
+
+    def is_iframe(self, el: bs4.Tag | None) -> bool:
+        """Check if element is an `iframe`."""
+
+        if el is None:  # pragma: no cover
+            return False
+
+        return bool(
+            ((el.name if self.is_xml_tree(el) else util.lower(el.name)) == 'iframe') and
+            self.is_html_tag(el)  # type: ignore[attr-defined]
+        )
+
+    def is_root(self, el: bs4.Tag) -> bool:
+        """
+        Return whether element is a root element.
+
+        We check that the element is the root of the tree (which we have already pre-calculated),
+        and we check if it is the root element under an `iframe`.
+        """
+
+        root = self.root and self.root is el  # type: ignore[attr-defined]
+        if not root:
+            parent = self.get_parent(el)
+            root = parent is not None and self.is_html and self.is_iframe(parent)  # type: ignore[attr-defined]
+        return root
+
+    def get_contents(self, el: bs4.Tag | None, no_iframe: bool = False) -> Iterator[bs4.element.PageElement]:
+        """Get contents or contents in reverse."""
+
+        if el is not None:
+            if not no_iframe or not self.is_iframe(el):
+                yield from el.contents
+
+    def get_tag_children(
+        self,
+        el: bs4.Tag | None,
+        start: int | None = None,
+        reverse: bool = False,
+        no_iframe: bool = False
+    ) -> Iterator[bs4.Tag]:
+        """Get tag children."""
+
+        return self.get_children(el, start, reverse, True, no_iframe)  # type: ignore[return-value]
+
+    def get_children(
+        self,
+        el: bs4.Tag | None,
+        start: int | None = None,
+        reverse: bool = False,
+        tags: bool = False,
+        no_iframe: bool = False
+    ) -> Iterator[bs4.element.PageElement]:
+        """Get children."""
+
+        if el is not None and (not no_iframe or not self.is_iframe(el)):
+            last = len(el.contents) - 1
+            if start is None:
+                index = last if reverse else 0
+            else:
+                index = start
+            end = -1 if reverse else last + 1
+            incr = -1 if reverse else 1
+
+            if 0 <= index <= last:
+                while index != end:
+                    node = el.contents[index]
+                    index += incr
+                    if not tags or self.is_tag(node):
+                        yield node
+
+    def get_tag_descendants(
+        self,
+        el: bs4.Tag | None,
+        no_iframe: bool = False
+    ) -> Iterator[bs4.Tag]:
+        """Specifically get tag descendants."""
+
+        yield from self.get_descendants(el, tags=True, no_iframe=no_iframe)  # type: ignore[misc]
+
+    def get_descendants(
+        self,
+        el: bs4.Tag | None,
+        tags: bool = False,
+        no_iframe: bool = False
+    ) -> Iterator[bs4.element.PageElement]:
+        """Get descendants."""
+
+        if el is not None and (not no_iframe or not self.is_iframe(el)):
+            next_good = None
+            for child in el.descendants:
+
+                if next_good is not None:
+                    if child is not next_good:
+                        continue
+                    next_good = None
+
+                if isinstance(child, bs4.Tag):
+                    if no_iframe and self.is_iframe(child):
+                        if child.next_sibling is not None:
+                            next_good = child.next_sibling
+                        else:
+                            last_child = child  # type: bs4.element.PageElement
+                            while isinstance(last_child, bs4.Tag) and last_child.contents:
+                                last_child = last_child.contents[-1]
+                            next_good = last_child.next_element
+                        yield child
+                        if next_good is None:
+                            break
+                        # Coverage isn't seeing this even though it's executed
+                        continue  # pragma: no cover
+                    yield child
+
+                elif not tags:
+                    yield child
+
+    def get_parent(self, el: bs4.Tag | None, no_iframe: bool = False) -> bs4.Tag | None:
+        """Get parent."""
+
+        parent = el.parent if el is not None else None
+        if no_iframe and parent is not None and self.is_iframe(parent):  # pragma: no cover
+            parent = None
+        return parent
+
+    @staticmethod
+    def get_tag_name(el: bs4.Tag | None) -> str | None:
+        """Get tag."""
+
+        return el.name if el is not None else None
+
+    @staticmethod
+    def get_prefix_name(el: bs4.Tag) -> str | None:
+        """Get prefix."""
+
+        return el.prefix
+
+    @staticmethod
+    def get_uri(el: bs4.Tag | None) -> str | None:
+        """Get namespace `URI`."""
+
+        return el.namespace if el is not None else None
+
+    @classmethod
+    def get_next_tag(cls, el: bs4.Tag) -> bs4.Tag | None:
+        """Get next sibling tag."""
+
+        return cls.get_next(el, tags=True)  # type: ignore[return-value]
+
+    @classmethod
+    def get_next(cls, el: bs4.Tag, tags: bool = False) -> bs4.element.PageElement | None:
+        """Get next sibling tag."""
+
+        sibling = el.next_sibling
+        while tags and not isinstance(sibling, bs4.Tag) and sibling is not None:
+            sibling = sibling.next_sibling
+
+        if tags and not isinstance(sibling, bs4.Tag):
+            sibling = None
+
+        return sibling
+
+    @classmethod
+    def get_previous_tag(cls, el: bs4.Tag, tags: bool = True) -> bs4.Tag | None:
+        """Get previous sibling tag."""
+
+        return cls.get_previous(el, True)  # type: ignore[return-value]
+
+    @classmethod
+    def get_previous(cls, el: bs4.Tag, tags: bool = False) -> bs4.element.PageElement | None:
+        """Get previous sibling tag."""
+
+        sibling = el.previous_sibling
+        while tags and not isinstance(sibling, bs4.Tag) and sibling is not None:
+            sibling = sibling.previous_sibling
+
+        if tags and not isinstance(sibling, bs4.Tag):
+            sibling = None
+
+        return sibling
+
+    @staticmethod
+    def has_html_ns(el: bs4.Tag | None) -> bool:
+        """
+        Check if element has an HTML namespace.
+
+        This is a bit different than whether a element is treated as having an HTML namespace,
+        like we do in the case of `is_html_tag`.
+        """
+
+        ns = getattr(el, 'namespace') if el is not None else None  # noqa: B009
+        return bool(ns and ns == NS_XHTML)
+
+    @staticmethod
+    def split_namespace(el: bs4.Tag | None, attr_name: str) -> tuple[str | None, str | None]:
+        """Return namespace and attribute name without the prefix."""
+
+        if el is None:  # pragma: no cover
+            return None, None
+
+        return getattr(attr_name, 'namespace', None), getattr(attr_name, 'name', None)
+
+    @classmethod
+    def normalize_value(cls, value: Any) -> str | Sequence[str]:
+        """Normalize the value to be a string or list of strings."""
+
+        # Treat `None` as empty string.
+        if value is None:
+            return ''
+
+        # Pass through strings
+        if (isinstance(value, str)):
+            return value
+
+        # If it's a byte string, convert it to Unicode, treating it as UTF-8.
+        if isinstance(value, bytes):
+            return value.decode("utf8")
+
+        # BeautifulSoup supports sequences of attribute values, so make sure the children are strings.
+        if isinstance(value, Sequence):
+            new_value = []
+            for v in value:
+                if not isinstance(v, (str, bytes)) and isinstance(v, Sequence):
+                    # This is most certainly a user error and will crash and burn later.
+                    # To keep things working, we'll do what we do with all objects,
+                    # And convert them to strings.
+                    new_value.append(str(v))
+                else:
+                    # Convert the child to a string
+                    new_value.append(cast(str, cls.normalize_value(v)))
+            return new_value
+
+        # Try and make anything else a string
+        return str(value)
+
+    @classmethod
+    def get_attribute_by_name(
+        cls,
+        el: bs4.Tag,
+        name: str,
+        default: str | Sequence[str] | None = None
+    ) -> str | Sequence[str] | None:
+        """Get attribute by name."""
+
+        value = default
+        if el._is_xml:
+            try:
+                value = cls.normalize_value(el.attrs[name])
+            except KeyError:
+                pass
+        else:
+            for k, v in el.attrs.items():
+                if util.lower(k) == name:
+                    value = cls.normalize_value(v)
+                    break
+        return value
+
+    @classmethod
+    def iter_attributes(cls, el: bs4.Tag | None) -> Iterator[tuple[str, str | Sequence[str] | None]]:
+        """Iterate attributes."""
+
+        if el is not None:
+            for k, v in el.attrs.items():
+                yield k, cls.normalize_value(v)
+
+    @classmethod
+    def get_classes(cls, el: bs4.Tag) -> Sequence[str]:
+        """Get classes."""
+
+        classes = cls.get_attribute_by_name(el, 'class', [])
+        if isinstance(classes, str):
+            classes = RE_NOT_WS.findall(classes)
+        return cast(Sequence[str], classes)
+
+    def get_text(self, el: bs4.Tag, no_iframe: bool = False) -> str:
+        """Get text."""
+
+        return ''.join(
+            [
+                node for node in self.get_descendants(el, no_iframe=no_iframe)  # type: ignore[misc]
+                if self.is_content_string(node)
+            ]
+        )
+
+    def get_own_text(self, el: bs4.Tag, no_iframe: bool = False) -> list[str]:
+        """Get Own Text."""
+
+        return [
+            node for node in self.get_contents(el, no_iframe=no_iframe) if self.is_content_string(node)  # type: ignore[misc]
+        ]
+
+
+class Inputs:
+    """Class for parsing and validating input items."""
+
+    @staticmethod
+    def validate_day(year: int, month: int, day: int) -> bool:
+        """Validate day."""
+
+        max_days = LONG_MONTH
+        if month == FEB:
+            max_days = FEB_LEAP_MONTH if ((year % 4 == 0) and (year % 100 != 0)) or (year % 400 == 0) else FEB_MONTH
+        elif month in MONTHS_30:
+            max_days = SHORT_MONTH
+        return 1 <= day <= max_days
+
+    @staticmethod
+    def validate_week(year: int, week: int) -> bool:
+        """Validate week."""
+
+        # Validate an ISO week number for `year`.
+        #
+        # Per ISO 8601 rules, the last ISO week of a year is the week
+        # containing Dec 28. Using Dec 28 guarantees we obtain the
+        # correct ISO week-number for the final week of `year`, even in
+        # years where Dec 31 falls in ISO week 01 of the following year.
+        #
+        # Example: if Dec 31 is a Thursday the year's last ISO week will
+        # be week 53; if Dec 31 is a Monday and that week is counted as
+        # week 1 of the next year, Dec 28 still belongs to the final
+        # week of the current ISO year and yields the correct max week.
+        max_week = datetime(year, 12, 28).isocalendar()[1]
+        return 1 <= week <= max_week
+
+    @staticmethod
+    def validate_month(month: int) -> bool:
+        """Validate month."""
+
+        return 1 <= month <= 12
+
+    @staticmethod
+    def validate_year(year: int) -> bool:
+        """Validate year."""
+
+        return 1 <= year
+
+    @staticmethod
+    def validate_hour(hour: int) -> bool:
+        """Validate hour."""
+
+        return 0 <= hour <= 23
+
+    @staticmethod
+    def validate_minutes(minutes: int) -> bool:
+        """Validate minutes."""
+
+        return 0 <= minutes <= 59
+
+    @classmethod
+    def parse_value(cls, itype: str, value: str | None) -> tuple[float, ...] | None:
+        """Parse the input value."""
+
+        parsed = None  # type: tuple[float, ...] | None
+        if value is None:
+            return value
+        if itype == "date":
+            m = RE_DATE.match(value)
+            if m:
+                year = int(m.group('year'), 10)
+                month = int(m.group('month'), 10)
+                day = int(m.group('day'), 10)
+                if cls.validate_year(year) and cls.validate_month(month) and cls.validate_day(year, month, day):
+                    parsed = (year, month, day)
+        elif itype == "month":
+            m = RE_MONTH.match(value)
+            if m:
+                year = int(m.group('year'), 10)
+                month = int(m.group('month'), 10)
+                if cls.validate_year(year) and cls.validate_month(month):
+                    parsed = (year, month)
+        elif itype == "week":
+            m = RE_WEEK.match(value)
+            if m:
+                year = int(m.group('year'), 10)
+                week = int(m.group('week'), 10)
+                if cls.validate_year(year) and cls.validate_week(year, week):
+                    parsed = (year, week)
+        elif itype == "time":
+            m = RE_TIME.match(value)
+            if m:
+                hour = int(m.group('hour'), 10)
+                minutes = int(m.group('minutes'), 10)
+                if cls.validate_hour(hour) and cls.validate_minutes(minutes):
+                    parsed = (hour, minutes)
+        elif itype == "datetime-local":
+            m = RE_DATETIME.match(value)
+            if m:
+                year = int(m.group('year'), 10)
+                month = int(m.group('month'), 10)
+                day = int(m.group('day'), 10)
+                hour = int(m.group('hour'), 10)
+                minutes = int(m.group('minutes'), 10)
+                if (
+                    cls.validate_year(year) and cls.validate_month(month) and cls.validate_day(year, month, day) and
+                    cls.validate_hour(hour) and cls.validate_minutes(minutes)
+                ):
+                    parsed = (year, month, day, hour, minutes)
+        elif itype in ("number", "range"):
+            m = RE_NUM.match(value)
+            if m:
+                parsed = (float(m.group('value')),)
+        return parsed
+
+
+class CSSMatch(_DocumentNav):
+    """Perform CSS matching."""
+
+    def __init__(
+        self,
+        selectors: ct.SelectorList,
+        scope: bs4.Tag | None,
+        namespaces: ct.Namespaces | None,
+        flags: int
+    ) -> None:
+        """Initialize."""
+
+        self.assert_valid_input(scope)
+        self.tag = scope
+        self.cached_meta_lang = []  # type: list[tuple[str, str]]
+        self.cached_default_forms = []  # type: list[tuple[bs4.Tag, bs4.Tag]]
+        self.cached_indeterminate_forms = []  # type: list[tuple[bs4.Tag, str, bool]]
+        self.selectors = selectors
+        self.namespaces = {} if namespaces is None else namespaces  # type: ct.Namespaces | dict[str, str]
+        self.flags = flags
+        self.iframe_restrict = False
+
+        # Find the root element for the whole tree
+        doc = scope
+        parent = self.get_parent(doc)
+        while parent:
+            doc = parent
+            parent = self.get_parent(doc)
+        root = None  # type: bs4.Tag | None
+        if not self.is_doc(doc):
+            root = doc
+        else:
+            for child in self.get_tag_children(doc):
+                root = child
+                break
+
+        self.root = root
+        self.scope = scope if scope is not doc else root
+        self.has_html_namespace = self.has_html_ns(root)
+
+        # A document can be both XML and HTML (XHTML)
+        self.is_xml = self.is_xml_tree(doc)
+        self.is_html = not self.is_xml or self.has_html_namespace
+
+    def supports_namespaces(self) -> bool:
+        """Check if namespaces are supported in the HTML type."""
+
+        return self.is_xml or self.has_html_namespace
+
+    def get_tag_ns(self, el: bs4.Tag | None) -> str:
+        """Get tag namespace."""
+
+        namespace = ''
+        if el is None:  # pragma: no cover
+            return namespace
+
+        if self.supports_namespaces():
+            ns = self.get_uri(el)
+            if ns:
+                namespace = ns
+        else:
+            namespace = NS_XHTML
+        return namespace
+
+    def is_html_tag(self, el: bs4.Tag | None) -> bool:
+        """Check if tag is in HTML namespace."""
+
+        return self.get_tag_ns(el) == NS_XHTML
+
+    def get_tag(self, el: bs4.Tag | None) -> str | None:
+        """Get tag."""
+
+        name = self.get_tag_name(el)
+        return util.lower(name) if name is not None and not self.is_xml else name
+
+    def get_prefix(self, el: bs4.Tag) -> str | None:
+        """Get prefix."""
+
+        prefix = self.get_prefix_name(el)
+        return util.lower(prefix) if prefix is not None and not self.is_xml else prefix
+
+    def find_bidi(self, el: bs4.Tag) -> int | None:
+        """Get directionality from element text."""
+
+        for node in self.get_children(el):
+
+            # Analyze child text nodes
+            if self.is_tag(node):
+
+                # Avoid analyzing certain elements specified in the specification.
+                direction = DIR_MAP.get(util.lower(self.get_attribute_by_name(node, 'dir', '')), None)  # type: ignore[arg-type]
+                name = self.get_tag(node)  # type: ignore[arg-type]
+                if (
+                    (name and name in ('bdi', 'script', 'style', 'textarea', 'iframe')) or
+                    not self.is_html_tag(node) or  # type: ignore[arg-type]
+                    direction is not None
+                ):
+                    continue  # pragma: no cover
+
+                # Check directionality of this node's text
+                value = self.find_bidi(node)  # type: ignore[arg-type]
+                if value is not None:
+                    return value
+
+                # Direction could not be determined
+                continue  # pragma: no cover
+
+            # Skip `doctype` comments, etc.
+            if self.is_special_string(node):
+                continue
+
+            # Analyze text nodes for directionality.
+            for c in node:  # type: ignore[attr-defined]
+                bidi = unicodedata.bidirectional(c)
+                if bidi in ('AL', 'R', 'L'):
+                    return ct.SEL_DIR_LTR if bidi == 'L' else ct.SEL_DIR_RTL
+        return None
+
+    def extended_language_filter(self, lang_range: str, lang_tag: str) -> bool:
+        """Filter the language tags."""
+
+        match = True
+        lang_range = RE_WILD_STRIP.sub('-', lang_range).lower()
+        ranges = lang_range.split('-')
+        subtags = lang_tag.lower().split('-')
+        length = len(ranges)
+        slength = len(subtags)
+        rindex = 0
+        sindex = 0
+        r = ranges[rindex]
+        s = subtags[sindex]
+
+        # Empty specified language should match unspecified language attributes
+        if length == 1 and slength == 1 and not r and r == s:
+            return True
+
+        # Primary tag needs to match
+        if (r != '*' and r != s) or (r == '*' and slength == 1 and not s):
+            match = False
+
+        rindex += 1
+        sindex += 1
+
+        # Match until we run out of ranges
+        while match and rindex < length:
+            r = ranges[rindex]
+            try:
+                s = subtags[sindex]
+            except IndexError:
+                # Ran out of subtags,
+                # but we still have ranges
+                match = False
+                continue
+
+            # Empty range
+            if not r:
+                match = False
+                continue
+
+            # Matched range
+            elif s == r:
+                rindex += 1
+
+            # Implicit wildcard cannot match
+            # singletons
+            elif len(s) == 1:
+                match = False
+                continue
+
+            # Implicitly matched, so grab next subtag
+            sindex += 1
+
+        return match
+
+    def match_attribute_name(
+        self,
+        el: bs4.Tag,
+        attr: str,
+        prefix: str | None
+    ) -> str | Sequence[str] | None:
+        """Match attribute name and return value if it exists."""
+
+        value = None
+        if self.supports_namespaces():
+            value = None
+            # If we have not defined namespaces, we can't very well find them, so don't bother trying.
+            if prefix:
+                ns = self.namespaces.get(prefix)
+                if ns is None and prefix != '*':
+                    return None
+            else:
+                ns = None
+
+            for k, v in self.iter_attributes(el):
+
+                # Get attribute parts
+                namespace, name = self.split_namespace(el, k)
+
+                # Can't match a prefix attribute as we haven't specified one to match
+                # Try to match it normally as a whole `p:a` as selector may be trying `p\:a`.
+                if ns is None:
+                    if (self.is_xml and attr == k) or (not self.is_xml and util.lower(attr) == util.lower(k)):
+                        value = v
+                        break
+                    # Coverage is not finding this even though it is executed.
+                    # Adding a print statement before this (and erasing coverage) causes coverage to find the line.
+                    # Ignore the false positive message.
+                    continue  # pragma: no cover
+
+                # We can't match our desired prefix attribute as the attribute doesn't have a prefix
+                if namespace is None or (ns != namespace and prefix != '*'):
+                    continue
+
+                # The attribute doesn't match.
+                if (util.lower(attr) != util.lower(name)) if not self.is_xml else (attr != name):
+                    continue
+
+                value = v
+                break
+        else:
+            for k, v in self.iter_attributes(el):
+                if util.lower(attr) != util.lower(k):
+                    continue
+                value = v
+                break
+        return value
+
+    def match_namespace(self, el: bs4.Tag, tag: ct.SelectorTag) -> bool:
+        """Match the namespace of the element."""
+
+        match = True
+        namespace = self.get_tag_ns(el)
+        default_namespace = self.namespaces.get('')
+        tag_ns = '' if tag.prefix is None else self.namespaces.get(tag.prefix)
+        # We must match the default namespace if one is not provided
+        if tag.prefix is None and (default_namespace is not None and namespace != default_namespace):
+            match = False
+        # If we specified `|tag`, we must not have a namespace.
+        elif (tag.prefix is not None and tag.prefix == '' and namespace):
+            match = False
+        # Verify prefix matches
+        elif (
+            tag.prefix and
+            tag.prefix != '*' and (tag_ns is None or namespace != tag_ns)
+        ):
+            match = False
+        return match
+
+    def match_attributes(self, el: bs4.Tag, attributes: tuple[ct.SelectorAttribute, ...]) -> bool:
+        """Match attributes."""
+
+        match = True
+        if attributes:
+            for a in attributes:
+                temp = self.match_attribute_name(el, a.attribute, a.prefix)
+                pattern = a.xml_type_pattern if self.is_xml and a.xml_type_pattern else a.pattern
+                if temp is None:
+                    match = False
+                    break
+                value = temp if isinstance(temp, str) else ' '.join(temp)
+                if pattern is None:
+                    continue
+                elif pattern.match(value) is None:
+                    match = False
+                    break
+        return match
+
+    def match_tagname(self, el: bs4.Tag, tag: ct.SelectorTag) -> bool:
+        """Match tag name."""
+
+        name = (util.lower(tag.name) if not self.is_xml and tag.name is not None else tag.name)
+        return not (
+            name is not None and
+            name not in (self.get_tag(el), '*')
+        )
+
+    def match_tag(self, el: bs4.Tag, tag: ct.SelectorTag | None) -> bool:
+        """Match the tag."""
+
+        match = True
+        if tag is not None:
+            # Verify namespace
+            if not self.match_namespace(el, tag):
+                match = False
+            if not self.match_tagname(el, tag):
+                match = False
+        return match
+
+    def match_past_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
+        """Match past relationship."""
+
+        found = False
+        # I don't think this can ever happen, but it makes `mypy` happy
+        if isinstance(relation[0], ct.SelectorNull):  # pragma: no cover
+            return found
+
+        if relation[0].rel_type == REL_PARENT:
+            parent = self.get_parent(el, no_iframe=self.iframe_restrict)
+            while not found and parent:
+                found = self.match_selectors(parent, relation)
+                parent = self.get_parent(parent, no_iframe=self.iframe_restrict)
+        elif relation[0].rel_type == REL_CLOSE_PARENT:
+            parent = self.get_parent(el, no_iframe=self.iframe_restrict)
+            if parent:
+                found = self.match_selectors(parent, relation)
+        elif relation[0].rel_type == REL_SIBLING:
+            sibling = self.get_previous_tag(el)
+            while not found and sibling:
+                found = self.match_selectors(sibling, relation)
+                sibling = self.get_previous_tag(sibling)
+        elif relation[0].rel_type == REL_CLOSE_SIBLING:
+            sibling = self.get_previous_tag(el)
+            if sibling and self.is_tag(sibling):
+                found = self.match_selectors(sibling, relation)
+        return found
+
+    def match_future_child(self, parent: bs4.Tag, relation: ct.SelectorList, recursive: bool = False) -> bool:
+        """Match future child."""
+
+        match = False
+        if recursive:
+            children = self.get_tag_descendants  # type: Callable[..., Iterator[bs4.Tag]]
+        else:
+            children = self.get_tag_children
+        for child in children(parent, no_iframe=self.iframe_restrict):
+            match = self.match_selectors(child, relation)
+            if match:
+                break
+        return match
+
+    def match_future_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
+        """Match future relationship."""
+
+        found = False
+        # I don't think this can ever happen, but it makes `mypy` happy
+        if isinstance(relation[0], ct.SelectorNull):  # pragma: no cover
+            return found
+
+        if relation[0].rel_type == REL_HAS_PARENT:
+            found = self.match_future_child(el, relation, True)
+        elif relation[0].rel_type == REL_HAS_CLOSE_PARENT:
+            found = self.match_future_child(el, relation)
+        elif relation[0].rel_type == REL_HAS_SIBLING:
+            sibling = self.get_next_tag(el)
+            while not found and sibling:
+                found = self.match_selectors(sibling, relation)
+                sibling = self.get_next_tag(sibling)
+        elif relation[0].rel_type == REL_HAS_CLOSE_SIBLING:
+            sibling = self.get_next_tag(el)
+            if sibling and self.is_tag(sibling):
+                found = self.match_selectors(sibling, relation)
+        return found
+
+    def match_relations(self, el: bs4.Tag, relation: ct.SelectorList) -> bool:
+        """Match relationship to other elements."""
+
+        found = False
+
+        if isinstance(relation[0], ct.SelectorNull) or relation[0].rel_type is None:
+            return found
+
+        if relation[0].rel_type.startswith(':'):
+            found = self.match_future_relations(el, relation)
+        else:
+            found = self.match_past_relations(el, relation)
+
+        return found
+
+    def match_id(self, el: bs4.Tag, ids: tuple[str, ...]) -> bool:
+        """Match element's ID."""
+
+        found = True
+        for i in ids:
+            if i != self.get_attribute_by_name(el, 'id', ''):
+                found = False
+                break
+        return found
+
+    def match_classes(self, el: bs4.Tag, classes: tuple[str, ...]) -> bool:
+        """Match element's classes."""
+
+        current_classes = self.get_classes(el)
+        found = True
+        for c in classes:
+            if c not in current_classes:
+                found = False
+                break
+        return found
+
+    def match_root(self, el: bs4.Tag) -> bool:
+        """Match element as root."""
+
+        is_root = self.is_root(el)
+        if is_root:
+            sibling = self.get_previous(el)  # type: Any
+            while is_root and sibling is not None:
+                if (
+                    self.is_tag(sibling) or (self.is_content_string(sibling) and sibling.strip()) or
+                    self.is_cdata(sibling)
+                ):
+                    is_root = False
+                else:
+                    sibling = self.get_previous(sibling)
+        if is_root:
+            sibling = self.get_next(el)
+            while is_root and sibling is not None:
+                if (
+                    self.is_tag(sibling) or (self.is_content_string(sibling) and sibling.strip()) or
+                    self.is_cdata(sibling)
+                ):
+                    is_root = False
+                else:
+                    sibling = self.get_next(sibling)
+        return is_root
+
+    def match_scope(self, el: bs4.Tag) -> bool:
+        """Match element as scope."""
+
+        return self.scope is el
+
+    def match_nth_tag_type(self, el: bs4.Tag, child: bs4.Tag) -> bool:
+        """Match tag type for `nth` matches."""
+
+        return (
+            (self.get_tag(child) == self.get_tag(el)) and
+            (self.get_tag_ns(child) == self.get_tag_ns(el))
+        )
+
+    def match_nth(self, el: bs4.Tag, nth: tuple[ct.SelectorNth, ...]) -> bool:
+        """Match `nth` elements."""
+
+        matched = True
+
+        for n in nth:
+            matched = False
+            if n.selectors and not self.match_selectors(el, n.selectors):
+                break
+            parent = self.get_parent(el)  # type: bs4.Tag | None
+            if parent is None:
+                parent = cast('bs4.Tag', self.create_fake_parent(el))
+            last = n.last
+            last_index = len(parent) - 1
+            index = last_index if last else 0
+            relative_index = 0
+            a = n.a
+            b = n.b
+            var = n.n
+            count = 0
+            count_incr = 1
+            factor = -1 if last else 1
+            idx = last_idx = a * count + b if var else a
+
+            # We can only adjust bounds within a variable index
+            if var:
+                # Find the count `n` that yields the smallest in-bounds index
+                # (>= 1), then set the increment direction so that the index
+                # ascends from there as the evaluation loop below walks children.
+                if a > 0:
+                    # Ascending sequence: smallest n with a * n + b >= 1.
+                    count = 0 if b >= 1 else -(-(1 - b) // a)
+                elif a < 0:
+                    # Descending sequence: largest n with a * n + b >= 1, then
+                    # walk n back down so the index increases.
+                    count = (b - 1) // -a if b >= 1 else 0
+                    count_incr = -1
+                idx = last_idx = a * count + b
+
+            # Evaluate elements while our calculated nth index is still in range
+            while 1 <= idx <= last_index + 1:
+                child = None  # type: bs4.element.PageElement | None
+                # Evaluate while our child index is still in range.
+                for child in self.get_children(parent, start=index, reverse=factor < 0):
+                    index += factor
+                    if not isinstance(child, bs4.Tag):
+                        continue
+                    # Handle `of S` in `nth-child`
+                    if n.selectors and not self.match_selectors(child, n.selectors):
+                        continue
+                    # Handle `of-type`
+                    if n.of_type and not self.match_nth_tag_type(el, child):
+                        continue
+                    relative_index += 1
+                    if relative_index == idx:
+                        if child is el:
+                            matched = True
+                        else:
+                            break
+                    if child is el:
+                        break
+                if child is el:
+                    break
+                last_idx = idx
+                count += count_incr
+                if count < 0:
+                    # Count is counting down and has now ventured into invalid territory.
+                    break
+                idx = a * count + b if var else a
+                if last_idx == idx:
+                    break
+            if not matched:
+                break
+        return matched
+
+    def match_empty(self, el: bs4.Tag) -> bool:
+        """Check if element is empty (if requested)."""
+
+        is_empty = True
+        for child in self.get_children(el):
+            if self.is_tag(child):
+                is_empty = False
+                break
+            elif self.is_content_string(child) and RE_NOT_EMPTY.search(child):  # type: ignore[call-overload]
+                is_empty = False
+                break
+        return is_empty
+
+    def match_subselectors(self, el: bs4.Tag, selectors: tuple[ct.SelectorList, ...]) -> bool:
+        """Match selectors."""
+
+        match = True
+        for sel in selectors:
+            if not self.match_selectors(el, sel):
+                match = False
+        return match
+
+    def match_contains(self, el: bs4.Tag, contains: tuple[ct.SelectorContains, ...]) -> bool:
+        """Match element if it contains text."""
+
+        match = True
+        content = None  # type: str | Sequence[str] | None
+        for contain_list in contains:
+            if content is None:
+                if contain_list.own:
+                    content = self.get_own_text(el, no_iframe=self.is_html)
+                else:
+                    content = self.get_text(el, no_iframe=self.is_html)
+            found = False
+            for text in contain_list.text:
+                if contain_list.own:
+                    for c in content:
+                        if text in c:
+                            found = True
+                            break
+                    if found:
+                        break
+                else:
+                    if text in content:
+                        found = True
+                        break
+            if not found:
+                match = False
+        return match
+
+    def match_default(self, el: bs4.Tag) -> bool:
+        """Match default."""
+
+        match = False
+
+        # Find this input's form
+        form = None  # type: bs4.Tag | None
+        parent = self.get_parent(el, no_iframe=True)
+        while parent and form is None:
+            if self.get_tag(parent) == 'form' and self.is_html_tag(parent):
+                form = parent
+            else:
+                parent = self.get_parent(parent, no_iframe=True)
+
+        if form is not None:
+            # Look in form cache to see if we've already located its default button
+            found_form = False
+            for f, t in self.cached_default_forms:
+                if f is form:
+                    found_form = True
+                    if t is el:
+                        match = True
+                    break
+
+            # We didn't have the form cached, so look for its default button
+            if not found_form:
+                for child in self.get_tag_descendants(form, no_iframe=True):
+                    name = self.get_tag(child)
+                    # Can't do nested forms (haven't figured out why we never hit this)
+                    if name == 'form':  # pragma: no cover
+                        break
+                    if name in ('input', 'button'):
+                        v = self.get_attribute_by_name(child, 'type', '')
+                        if v and util.lower(v) == 'submit':
+                            self.cached_default_forms.append((form, child))
+                            if el is child:
+                                match = True
+                            break
+        return match
+
+    def match_indeterminate(self, el: bs4.Tag) -> bool:
+        """Match default."""
+
+        match = False
+        name = cast(str, self.get_attribute_by_name(el, 'name'))
+
+        def get_parent_form(el: bs4.Tag) -> bs4.Tag | None:
+            """Find this input's form."""
+            form = None
+            parent = self.get_parent(el, no_iframe=True)
+            while form is None:
+                if self.get_tag(parent) == 'form' and self.is_html_tag(parent):
+                    form = parent
+                    break
+                last_parent = parent
+                parent = self.get_parent(parent, no_iframe=True)
+                if parent is None:
+                    form = last_parent
+                    break
+            return form
+
+        form = get_parent_form(el)
+
+        # Look in form cache to see if we've already evaluated that its fellow radio buttons are indeterminate
+        if form is not None:
+            found_form = False
+            for f, n, i in self.cached_indeterminate_forms:
+                if f is form and n == name:
+                    found_form = True
+                    if i is True:
+                        match = True
+                    break
+
+            # We didn't have the form cached, so validate that the radio button is indeterminate
+            if not found_form:
+                checked = False
+                for child in self.get_tag_descendants(form, no_iframe=True):
+                    if child is el:
+                        continue
+                    tag_name = self.get_tag(child)
+                    if tag_name == 'input':
+                        is_radio = False
+                        check = False
+                        has_name = False
+                        for k, v in self.iter_attributes(child):
+                            if util.lower(k) == 'type' and util.lower(v) == 'radio':
+                                is_radio = True
+                            elif util.lower(k) == 'name' and v == name:
+                                has_name = True
+                            elif util.lower(k) == 'checked':
+                                check = True
+                            if is_radio and check and has_name and get_parent_form(child) is form:
+                                checked = True
+                                break
+                    if checked:
+                        break
+                if not checked:
+                    match = True
+                self.cached_indeterminate_forms.append((form, name, match))
+
+        return match
+
+    def match_lang(self, el: bs4.Tag, langs: tuple[ct.SelectorLang, ...]) -> bool:
+        """Match languages."""
+
+        match = False
+        has_ns = self.supports_namespaces()
+        root = self.root
+        has_html_namespace = self.has_html_namespace
+
+        # Walk parents looking for `lang` (HTML) or `xml:lang` XML property.
+        parent = el  # type: bs4.Tag | None
+        found_lang = None
+        last = None
+        while not found_lang:
+            has_html_ns = self.has_html_ns(parent)
+            for k, v in self.iter_attributes(parent):
+                attr_ns, attr = self.split_namespace(parent, k)
+                if (
+                    ((not has_ns or has_html_ns) and (util.lower(k) if not self.is_xml else k) == 'lang') or
+                    (
+                        has_ns and not has_html_ns and attr_ns == NS_XML and
+                        (util.lower(attr) if not self.is_xml and attr is not None else attr) == 'lang'
+                    )
+                ):
+                    found_lang = v
+                    break
+            last = parent
+            parent = self.get_parent(parent, no_iframe=self.is_html)
+
+            if parent is None:
+                root = last
+                has_html_namespace = self.has_html_ns(root)
+                parent = last
+                break
+
+        # Use cached meta language.
+        if found_lang is None and self.cached_meta_lang:
+            for cache in self.cached_meta_lang:
+                if root is not None and cast(str, root) is cache[0]:
+                    found_lang = cache[1]
+
+        # If we couldn't find a language, and the document is HTML, look to meta to determine language.
+        if found_lang is None and (not self.is_xml or (has_html_namespace and root and root.name == 'html')):
+            # Find head
+            found = False
+            for tag in ('html', 'head'):
+                found = False
+                for child in self.get_tag_children(parent, no_iframe=self.is_html):
+                    if self.get_tag(child) == tag and self.is_html_tag(child):
+                        found = True
+                        parent = child
+                        break
+                if not found:  # pragma: no cover
+                    break
+
+            # Search meta tags
+            if found and parent is not None:
+                for child2 in parent:
+                    if isinstance(child2, bs4.Tag) and self.get_tag(child2) == 'meta' and self.is_html_tag(parent):
+                        c_lang = False
+                        content = None
+                        for k, v in self.iter_attributes(child2):
+                            if util.lower(k) == 'http-equiv' and util.lower(v) == 'content-language':
+                                c_lang = True
+                            if util.lower(k) == 'content':
+                                content = v
+                            if c_lang and content:
+                                found_lang = content
+                                self.cached_meta_lang.append((cast(str, root), cast(str, found_lang)))
+                                break
+                    if found_lang is not None:
+                        break
+                if found_lang is None:
+                    self.cached_meta_lang.append((cast(str, root), ''))
+
+        # If we determined a language, compare.
+        if found_lang is not None:
+            for patterns in langs:
+                match = False
+                for pattern in patterns:
+                    if self.extended_language_filter(pattern, cast(str, found_lang)):
+                        match = True
+                if not match:
+                    break
+
+        return match
+
+    def match_dir(self, el: bs4.Tag | None, directionality: int) -> bool:
+        """Check directionality."""
+
+        # If we have to match both left and right, we can't match either.
+        if directionality & ct.SEL_DIR_LTR and directionality & ct.SEL_DIR_RTL:
+            return False
+
+        if el is None or not self.is_html_tag(el):
+            return False
+
+        # Element has defined direction of left to right or right to left
+        direction = DIR_MAP.get(util.lower(self.get_attribute_by_name(el, 'dir', '')), None)
+        if direction not in (None, 0):
+            return direction == directionality
+
+        # Element is the document element (the root) and no direction assigned, assume left to right.
+        is_root = self.is_root(el)
+        if is_root and direction is None:
+            return ct.SEL_DIR_LTR == directionality
+
+        # If `input[type=telephone]` and no direction is assigned, assume left to right.
+        name = self.get_tag(el)
+        is_input = name == 'input'
+        is_textarea = name == 'textarea'
+        is_bdi = name == 'bdi'
+        itype = util.lower(self.get_attribute_by_name(el, 'type', '')) if is_input else ''
+        if is_input and itype == 'tel' and direction is None:
+            return ct.SEL_DIR_LTR == directionality
+
+        # Auto handling for text inputs
+        if ((is_input and itype in ('text', 'search', 'tel', 'url', 'email')) or is_textarea) and direction == 0:
+            if is_textarea:
+                value = ''.join(node for node in self.get_contents(el, no_iframe=True) if self.is_content_string(node))  # type: ignore[misc]
+            else:
+                value = cast(str, self.get_attribute_by_name(el, 'value', ''))
+            if value:
+                for c in value:
+                    bidi = unicodedata.bidirectional(c)
+                    if bidi in ('AL', 'R', 'L'):
+                        direction = ct.SEL_DIR_LTR if bidi == 'L' else ct.SEL_DIR_RTL
+                        return direction == directionality
+                # Assume left to right
+                return ct.SEL_DIR_LTR == directionality
+            elif is_root:
+                return ct.SEL_DIR_LTR == directionality
+            return self.match_dir(self.get_parent(el, no_iframe=True), directionality)
+
+        # Auto handling for `bdi` and other non text inputs.
+        if (is_bdi and direction is None) or direction == 0:
+            direction = self.find_bidi(el)
+            if direction is not None:
+                return direction == directionality
+            elif is_root:
+                return ct.SEL_DIR_LTR == directionality
+            return self.match_dir(self.get_parent(el, no_iframe=True), directionality)
+
+        # Match parents direction
+        return self.match_dir(self.get_parent(el, no_iframe=True), directionality)
+
+    def match_range(self, el: bs4.Tag, condition: int) -> bool:
+        """
+        Match range.
+
+        Behavior is modeled after what we see in browsers. Browsers seem to evaluate
+        if the value is out of range, and if not, it is in range. So a missing value
+        will not evaluate out of range; therefore, value is in range. Personally, I
+        feel like this should evaluate as neither in or out of range.
+        """
+
+        out_of_range = False
+
+        itype = util.lower(self.get_attribute_by_name(el, 'type'))
+        mn = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'min', None)))
+        mx = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'max', None)))
+
+        # There is no valid min or max, so we cannot evaluate a range
+        if mn is None and mx is None:
+            return False
+
+        value = Inputs.parse_value(itype, cast(str, self.get_attribute_by_name(el, 'value', None)))
+        if value is not None:
+            if itype in ("date", "datetime-local", "month", "week", "number", "range"):
+                if mn is not None and value < mn:
+                    out_of_range = True
+                if not out_of_range and mx is not None and value > mx:
+                    out_of_range = True
+            elif itype == "time":
+                if mn is not None and mx is not None and mn > mx:
+                    # Time is periodic, so this is a reversed/discontinuous range
+                    if value < mn and value > mx:
+                        out_of_range = True
+                else:
+                    if mn is not None and value < mn:
+                        out_of_range = True
+                    if not out_of_range and mx is not None and value > mx:
+                        out_of_range = True
+
+        return not out_of_range if condition & ct.SEL_IN_RANGE else out_of_range
+
+    def match_defined(self, el: bs4.Tag) -> bool:
+        """
+        Match defined.
+
+        `:defined` is related to custom elements in a browser.
+
+        - If the document is XML (not XHTML), all tags will match.
+        - Tags that are not custom (don't have a hyphen) are marked defined.
+        - If the tag has a prefix (without or without a namespace), it will not match.
+
+        This is of course requires the parser to provide us with the proper prefix and namespace info,
+        if it doesn't, there is nothing we can do.
+        """
+
+        name = self.get_tag(el)
+        return (
+            name is not None and (
+                name.find('-') == -1 or
+                name.find(':') != -1 or
+                self.get_prefix(el) is not None
+            )
+        )
+
+    def match_placeholder_shown(self, el: bs4.Tag) -> bool:
+        """
+        Match placeholder shown according to HTML spec.
+
+        - text area should be checked if they have content. A single newline does not count as content.
+
+        """
+
+        match = False
+        content = self.get_text(el)
+        if content in ('', '\n'):
+            match = True
+
+        return match
+
+    def match_selectors(self, el: bs4.Tag, selectors: ct.SelectorList) -> bool:
+        """Check if element matches one of the selectors."""
+
+        match = False
+        is_not = selectors.is_not
+        is_html = selectors.is_html
+
+        # Internal selector lists that use the HTML flag, will automatically get the `html` namespace.
+        if is_html:
+            namespaces = self.namespaces
+            iframe_restrict = self.iframe_restrict
+            self.namespaces = {'html': NS_XHTML}
+            self.iframe_restrict = True
+
+        if not is_html or self.is_html:
+            for selector in selectors:
+                match = is_not
+                # We have a un-matchable situation (like `:focus` as you can focus an element in this environment)
+                if isinstance(selector, ct.SelectorNull):
+                    continue
+                # Verify tag matches
+                if not self.match_tag(el, selector.tag):
+                    continue
+                # Verify tag is defined
+                if selector.flags & ct.SEL_DEFINED and not self.match_defined(el):
+                    continue
+                # Verify element is root
+                if selector.flags & ct.SEL_ROOT and not self.match_root(el):
+                    continue
+                # Verify element is scope
+                if selector.flags & ct.SEL_SCOPE and not self.match_scope(el):
+                    continue
+                # Verify element has placeholder shown
+                if selector.flags & ct.SEL_PLACEHOLDER_SHOWN and not self.match_placeholder_shown(el):
+                    continue
+                # Verify `nth` matches
+                if not self.match_nth(el, selector.nth):
+                    continue
+                if selector.flags & ct.SEL_EMPTY and not self.match_empty(el):
+                    continue
+                # Verify id matches
+                if selector.ids and not self.match_id(el, selector.ids):
+                    continue
+                # Verify classes match
+                if selector.classes and not self.match_classes(el, selector.classes):
+                    continue
+                # Verify attribute(s) match
+                if not self.match_attributes(el, selector.attributes):
+                    continue
+                # Verify ranges
+                if selector.flags & RANGES and not self.match_range(el, selector.flags & RANGES):
+                    continue
+                # Verify language patterns
+                if selector.lang and not self.match_lang(el, selector.lang):
+                    continue
+                # Verify pseudo selector patterns
+                if selector.selectors and not self.match_subselectors(el, selector.selectors):
+                    continue
+                # Verify relationship selectors
+                if selector.relation and not self.match_relations(el, selector.relation):
+                    continue
+                # Validate that the current default selector match corresponds to the first submit button in the form
+                if selector.flags & ct.SEL_DEFAULT and not self.match_default(el):
+                    continue
+                # Validate that the unset radio button is among radio buttons with the same name in a form that are
+                # also not set.
+                if selector.flags & ct.SEL_INDETERMINATE and not self.match_indeterminate(el):
+                    continue
+                # Validate element directionality
+                if selector.flags & DIR_FLAGS and not self.match_dir(el, selector.flags & DIR_FLAGS):
+                    continue
+                # Validate that the tag contains the specified text.
+                if selector.contains and not self.match_contains(el, selector.contains):
+                    continue
+                match = not is_not
+                break
+
+        # Restore actual namespaces being used for external selector lists
+        if is_html:
+            self.namespaces = namespaces
+            self.iframe_restrict = iframe_restrict
+
+        return match
+
+    def select(self, limit: int = 0) -> Iterator[bs4.Tag]:
+        """Match all tags under the targeted tag."""
+
+        lim = None if limit < 1 else limit
+
+        for child in self.get_tag_descendants(self.tag):
+            if self.match(child):
+                yield child
+                if lim is not None:
+                    lim -= 1
+                    if lim < 1:
+                        break
+
+    def closest(self) -> bs4.Tag | None:
+        """Match closest ancestor."""
+
+        current = self.tag  # type: bs4.Tag | None
+        closest = None
+        while closest is None and current is not None:
+            if self.match(current):
+                closest = current
+            else:
+                current = self.get_parent(current)
+        return closest
+
+    def filter(self) -> list[bs4.Tag]:  # noqa A001
+        """Filter tag's children."""
+
+        return [
+            tag for tag in self.get_contents(self.tag)
+            if isinstance(tag, bs4.Tag) and self.match(tag)
+        ]
+
+    def match(self, el: bs4.Tag) -> bool:
+        """Match."""
+
+        return not self.is_doc(el) and self.is_tag(el) and self.match_selectors(el, self.selectors)
+
+
+class SoupSieve(ct.Immutable):
+    """Compiled Soup Sieve selector matching object."""
+
+    pattern: str
+    selectors: ct.SelectorList
+    namespaces: ct.Namespaces | None
+    custom: dict[str, str]
+    flags: int
+
+    __slots__ = ("pattern", "selectors", "namespaces", "custom", "flags", "_hash")
+
+    def __init__(
+        self,
+        pattern: str,
+        selectors: ct.SelectorList,
+        namespaces: ct.Namespaces | None,
+        custom: ct.CustomSelectors | None,
+        flags: int
+    ):
+        """Initialize."""
+
+        super().__init__(
+            pattern=pattern,
+            selectors=selectors,
+            namespaces=namespaces,
+            custom=custom,
+            flags=flags
+        )
+
+    def match(self, tag: bs4.Tag) -> bool:
+        """Match."""
+
+        return CSSMatch(self.selectors, tag, self.namespaces, self.flags).match(tag)
+
+    def closest(self, tag: bs4.Tag) -> bs4.Tag | None:
+        """Match closest ancestor."""
+
+        return CSSMatch(self.selectors, tag, self.namespaces, self.flags).closest()
+
+    def filter(self, iterable: Iterable[bs4.Tag]) -> list[bs4.Tag]:  # noqa A001
+        """
+        Filter.
+
+        `CSSMatch` can cache certain searches for tags of the same document,
+        so if we are given a tag, all tags are from the same document,
+        and we can take advantage of the optimization.
+
+        Any other kind of iterable could have tags from different documents or detached tags,
+        so for those, we use a new `CSSMatch` for each item in the iterable.
+        """
+
+        if isinstance(iterable, bs4.Tag):
+            return CSSMatch(self.selectors, iterable, self.namespaces, self.flags).filter()
+        else:
+            return [node for node in iterable if not CSSMatch.is_navigable_string(node) and self.match(node)]
+
+    def select_one(self, tag: bs4.Tag) -> bs4.Tag | None:
+        """Select a single tag."""
+
+        tags = self.select(tag, limit=1)
+        return tags[0] if tags else None
+
+    def select(self, tag: bs4.Tag, limit: int = 0) -> list[bs4.Tag]:
+        """Select the specified tags."""
+
+        return list(self.iselect(tag, limit))
+
+    def iselect(self, tag: bs4.Tag, limit: int = 0) -> Iterator[bs4.Tag]:
+        """Iterate the specified tags."""
+
+        yield from CSSMatch(self.selectors, tag, self.namespaces, self.flags).select(limit)
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        return (
+            f"SoupSieve(pattern={self.pattern!r}, namespaces={self.namespaces!r}, "
+            f"custom={self.custom!r}, flags={self.flags!r})"
+        )
+
+    __str__ = __repr__
+
+
+ct.pickle_register(SoupSieve)
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/css_parser.py b/.venv/lib/python3.12/site-packages/soupsieve/css_parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..8602a41a0ff68b73381164bb2d008920bf18a22a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/soupsieve/css_parser.py
@@ -0,0 +1,1359 @@
+"""CSS selector parser."""
+from __future__ import annotations
+import re
+from functools import lru_cache
+from . import util
+from . import css_match as cm
+from . import css_types as ct
+from .util import SelectorSyntaxError
+import warnings
+from typing import Match, Any, Iterator, cast
+from dataclasses import dataclass
+from collections import UserDict
+import threading
+
+RE_LOCK = threading.Lock()
+SEL_LOCK = threading.RLock()
+
+UNICODE_REPLACEMENT_CHAR = 0xFFFD
+
+SELECTOR_LIMIT = 8192
+
+# Simple pseudo classes that take no parameters
+PSEUDO_SIMPLE = {
+    ":any-link",
+    ":empty",
+    ":first-child",
+    ":first-of-type",
+    ":in-range",
+    ":open",
+    ":out-of-range",
+    ":last-child",
+    ":last-of-type",
+    ":link",
+    ":only-child",
+    ":only-of-type",
+    ":root",
+    ':checked',
+    ':default',
+    ':disabled',
+    ':enabled',
+    ':indeterminate',
+    ':optional',
+    ':placeholder-shown',
+    ':read-only',
+    ':read-write',
+    ':required',
+    ':scope',
+    ':defined',
+    ':muted'
+}
+
+# Supported, simple pseudo classes that match nothing in the Soup Sieve environment
+PSEUDO_SIMPLE_NO_MATCH = {
+    ':active',
+    ':autofill',
+    ':buffering',
+    ':current',
+    ':focus',
+    ':focus-visible',
+    ':focus-within',
+    ':fullscreen',
+    ':future',
+    ':host',
+    ':hover',
+    ':local-link',
+    ':past',
+    ':paused',
+    ':picture-in-picture',
+    ':playing',
+    ':popover-open',
+    ':seeking',
+    ':stalled',
+    ':target',
+    ':target-within',
+    ':user-invalid',
+    ':volume-locked',
+    ':visited'
+}
+
+# Complex pseudo classes that take selector lists
+PSEUDO_COMPLEX = {
+    ':contains',
+    ':-soup-contains',
+    ':-soup-contains-own',
+    ':has',
+    ':is',
+    ':matches',
+    ':not',
+    ':where'
+}
+
+PSEUDO_COMPLEX_NO_MATCH = {
+    ':current',
+    ':host',
+    ':host-context'
+}
+
+# Complex pseudo classes that take very specific parameters and are handled special
+PSEUDO_SPECIAL = {
+    ':dir',
+    ':lang',
+    ':nth-child',
+    ':nth-last-child',
+    ':nth-last-of-type',
+    ':nth-of-type'
+}
+
+PSEUDO_SUPPORTED = PSEUDO_SIMPLE | PSEUDO_SIMPLE_NO_MATCH | PSEUDO_COMPLEX | PSEUDO_COMPLEX_NO_MATCH | PSEUDO_SPECIAL
+
+# Sub-patterns parts
+# Whitespace
+NEWLINE = r'(?:\r\n|(?!\r\n)[\n\f\r])'
+WS = fr'(?:[ \t]|{NEWLINE})'
+# Comments
+COMMENTS = r'(?:/\*(?:[^*]|\*(?!/))*\*/)'
+# Whitespace with comments included
+WSC = fr'(?:{WS}|{COMMENTS})'
+# CSS escapes
+CSS_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$))'
+CSS_STRING_ESCAPES = fr'(?:\\(?:[a-f0-9]{{1,6}}{WS}?|[^\r\n\f]|$|{NEWLINE}))'
+# CSS Identifier
+IDENTIFIER = fr'''
+(?:(?:--|-?(?:[^\x00-\x2f\x30-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES}))
+(?:[^\x00-\x2c\x2e\x2f\x3A-\x40\x5B-\x5E\x60\x7B-\x9f]|{CSS_ESCAPES})*)
+'''
+# `nth` content
+NTH = fr'(?:[-+])?(?:[0-9]+n?|n)(?:(?<=n){WSC}*(?:[-+]){WSC}*(?:[0-9]+))?'
+# Value: quoted string or identifier
+VALUE = fr'''(?:"(?:\\(?:.|{NEWLINE})|[^\\"\r\n\f])*?"|'(?:\\(?:.|{NEWLINE})|[^\\'\r\n\f])*?'|{IDENTIFIER})'''
+# Attribute value comparison. `!=` is handled special as it is non-standard.
+ATTR = fr'(?:{WSC}*(?P[!~^|*$]?=){WSC}*(?P{VALUE})(?:{WSC}*(?P[is]))?)?{WSC}*'
+
+# Selector patterns
+# IDs (`#id`)
+PAT_ID = fr'\#{IDENTIFIER}'
+# Classes (`.class`)
+PAT_CLASS = fr'\.{IDENTIFIER}'
+# Prefix:Tag (`prefix|tag`)
+PAT_TAG = fr'(?P(?:{IDENTIFIER}|\*)?\|)?(?P{IDENTIFIER}|\*)'
+# Attributes (`[attr]`, `[attr=value]`, etc.)
+PAT_ATTR = fr'\[{WSC}*(?P(?:{IDENTIFIER}|\*)?\|)?(?P{IDENTIFIER}){ATTR}\]'
+# Pseudo class (`:pseudo-class`, `:pseudo-class(`)
+PAT_PSEUDO_CLASS = fr'(?P:{IDENTIFIER})(?P\({WSC}*)?'
+# Pseudo class special patterns. Matches `:pseudo-class(` for special case pseudo classes.
+PAT_PSEUDO_CLASS_SPECIAL = fr'(?P:{IDENTIFIER})(?P\({WSC}*)'
+# Custom pseudo class (`:--custom-pseudo`)
+PAT_PSEUDO_CLASS_CUSTOM = fr'(?P:(?=--){IDENTIFIER})'
+# Nesting ampersand selector. Matches `&`
+PAT_AMP = r'&'
+# Closing pseudo group (`)`)
+PAT_PSEUDO_CLOSE = fr'{WSC}*\)'
+# Pseudo element (`::pseudo-element`)
+PAT_PSEUDO_ELEMENT = fr':{PAT_PSEUDO_CLASS}'
+# At rule (`@page`, etc.) (not supported)
+PAT_AT_RULE = fr'@P{IDENTIFIER}'
+# Pseudo class `nth-child` (`:nth-child(an+b [of S]?)`, `:first-child`, etc.)
+PAT_PSEUDO_NTH_CHILD = fr'''
+(?P{PAT_PSEUDO_CLASS_SPECIAL}
+(?P{NTH}|even|odd))(?:{WSC}*\)|(?P{COMMENTS}*{WS}{WSC}*of{COMMENTS}*{WS}{WSC}*))
+'''
+# Pseudo class `nth-of-type` (`:nth-of-type(an+b)`, `:first-of-type`, etc.)
+PAT_PSEUDO_NTH_TYPE = fr'''
+(?P{PAT_PSEUDO_CLASS_SPECIAL}
+(?P{NTH}|even|odd)){WSC}*\)
+'''
+# Pseudo class language (`:lang("*-de", en)`)
+PAT_PSEUDO_LANG = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)'
+# Pseudo class direction (`:dir(ltr)`)
+PAT_PSEUDO_DIR = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?Pltr|rtl){WSC}*\)'
+# Combining characters (`>`, `~`, ` `, `+`, `,`)
+PAT_COMBINE = fr'{WSC}*?(?P[,+>~]|{WS}(?![,+>~])){WSC}*'
+# Extra: Contains (`:contains(text)`)
+PAT_PSEUDO_CONTAINS = fr'{PAT_PSEUDO_CLASS_SPECIAL}(?P{VALUE}(?:{WSC}*,{WSC}*{VALUE})*){WSC}*\)'
+
+# Regular expressions
+# CSS escape pattern
+RE_CSS_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WSC}?)|(\\[^\r\n\f])|(\\$))', re.I)
+RE_CSS_STR_ESC = re.compile(fr'(?:(\\[a-f0-9]{{1,6}}{WS}?)|(\\[^\r\n\f])|(\\$)|(\\{NEWLINE}))', re.I)
+# Pattern to break up `nth` specifiers
+RE_NTH = re.compile(fr'(?P[-+])?(?P[0-9]+n?|n)(?:(?<=n){WSC}*(?P[-+]){WSC}*(?P[0-9]+))?', re.I)
+# Pattern to iterate multiple values.
+RE_VALUES = re.compile(fr'(?:(?P{VALUE})|(?P{WSC}*,{WSC}*))', re.X)
+# Whitespace checks
+RE_WS = re.compile(WS)
+RE_WS_BEGIN = re.compile(fr'^{WSC}*')
+RE_WS_END = re.compile(fr'^(?:[ \t]|(?:\n\r|(?!\n\r)[\n\f\r])|{COMMENTS})*')
+RE_CUSTOM = re.compile(fr'^{PAT_PSEUDO_CLASS_CUSTOM}$', re.X)
+RE_PSEUDO_CLASS_SPECIAL = re.compile(PAT_PSEUDO_CLASS_SPECIAL, re.I | re.X | re.U)
+
+QUOTED = ("'", '"')
+
+# Constants
+# List split token
+COMMA_COMBINATOR = ','
+# Relation token for descendant
+WS_COMBINATOR = " "
+
+# Parse flags
+FLG_PSEUDO = 0x01
+FLG_NOT = 0x02
+FLG_RELATIVE = 0x04
+FLG_DEFAULT = 0x08
+FLG_HTML = 0x10
+FLG_INDETERMINATE = 0x20
+FLG_OPEN = 0x40
+FLG_IN_RANGE = 0x80
+FLG_OUT_OF_RANGE = 0x100
+FLG_PLACEHOLDER_SHOWN = 0x200
+FLG_FORGIVE = 0x400
+
+# Maximum cached patterns to store
+_MAXCACHE = 500
+
+
+@lru_cache(maxsize=_MAXCACHE)
+def _cached_css_compile(
+    pattern: str,
+    namespaces: ct.Namespaces | None,
+    custom: ct.CustomSelectors | None,
+    flags: int
+) -> cm.SoupSieve:
+    """Cached CSS compile."""
+
+    custom_selectors = process_custom(custom)
+    return cm.SoupSieve(
+        pattern,
+        CSSParser(
+            pattern,
+            custom=custom_selectors,
+            flags=flags
+        ).process_selectors(),
+        namespaces,
+        custom,
+        flags
+    )
+
+
+def _purge_cache() -> None:
+    """Purge the cache."""
+
+    _cached_css_compile.cache_clear()
+
+
+def process_custom(custom: ct.CustomSelectors | None) -> dict[str, str | ct.SelectorList]:
+    """Process custom."""
+
+    custom_selectors = {}
+    if custom is not None:
+        for key, value in custom.items():
+            name = util.lower(key)
+            if RE_CUSTOM.match(name) is None:
+                raise SelectorSyntaxError(f"The name '{name}' is not a valid custom pseudo-class name")
+            if name in custom_selectors:
+                raise KeyError(f"The custom selector '{name}' has already been registered")
+            custom_selectors[css_unescape(name)] = value
+    return custom_selectors
+
+
+def css_unescape(content: str) -> str:
+    """
+    Unescape CSS value.
+
+    Strings allow for spanning the value on multiple strings by escaping a new line.
+    """
+
+    def replace(m: Match[str]) -> str:
+        """Replace with the appropriate substitute."""
+
+        if m.group(1):
+            codepoint = int(m.group(1)[1:], 16)
+            if codepoint == 0:
+                codepoint = UNICODE_REPLACEMENT_CHAR
+            value = chr(codepoint)
+        elif m.group(2):
+            value = m.group(2)[1:]
+        elif m.group(3):
+            value = '\ufffd'
+        else:
+            value = ''
+
+        return value
+
+    quoted = content.startswith(QUOTED)
+    return (RE_CSS_STR_ESC if quoted else RE_CSS_ESC).sub(
+        replace,
+        content[1:-1] if quoted else content
+    )
+
+
+def escape(ident: str) -> str:
+    """Escape identifier."""
+
+    string = []
+    length = len(ident)
+    start_dash = length > 0 and ident[0] == '-'
+    if length == 1 and start_dash:
+        # Need to escape identifier that is a single `-` with no other characters
+        string.append(f'\\{ident}')
+    else:
+        for index, c in enumerate(ident):
+            codepoint = ord(c)
+            if codepoint == 0x00:
+                string.append('\ufffd')
+            elif (0x01 <= codepoint <= 0x1F) or codepoint == 0x7F:
+                string.append(f'\\{codepoint:x} ')
+            elif (index == 0 or (start_dash and index == 1)) and (0x30 <= codepoint <= 0x39):
+                string.append(f'\\{codepoint:x} ')
+            elif (
+                codepoint in (0x2D, 0x5F) or codepoint >= 0x80 or (0x30 <= codepoint <= 0x39) or
+                (0x30 <= codepoint <= 0x39) or (0x41 <= codepoint <= 0x5A) or (0x61 <= codepoint <= 0x7A)
+            ):
+                string.append(c)
+            else:
+                string.append(f'\\{c}')
+    return ''.join(string)
+
+
+class SelectorPattern:
+    """Selector pattern."""
+
+    def __init__(self, name: str, pattern: str) -> None:
+        """Initialize."""
+
+        self.name = name
+        self.pattern = pattern
+        self._re_pattern: re.Pattern[str] | None = None
+
+    @property
+    def re_pattern(self) -> re.Pattern[str]:
+        """Retrieve the compiled regular expression pattern."""
+
+        with RE_LOCK:
+            if self._re_pattern is None:
+                self._re_pattern = re.compile(self.pattern, re.I | re.X | re.U)
+        return self._re_pattern
+
+    def get_name(self) -> str:
+        """Get name."""
+
+        return self.name
+
+    def match(self, selector: str, index: int, flags: int) -> Match[str] | None:
+        """Match the selector."""
+
+        return self.re_pattern.match(selector, index)
+
+
+class SpecialPseudoPattern(SelectorPattern):
+    """Selector pattern."""
+
+    def __init__(self, patterns: tuple[tuple[str, tuple[str, ...], str, type[SelectorPattern]], ...]) -> None:
+        """Initialize."""
+
+        self.patterns = {}
+        for p in patterns:
+            name = p[0]
+            pattern = p[3](name, p[2])
+            for pseudo in p[1]:
+                self.patterns[pseudo] = pattern
+
+        self.matched_name = None  # type: SelectorPattern | None
+
+    def get_name(self) -> str:
+        """Get name."""
+
+        return '' if self.matched_name is None else self.matched_name.get_name()
+
+    def match(self, selector: str, index: int, flags: int) -> Match[str] | None:
+        """Match the selector."""
+
+        pseudo = None
+        m = RE_PSEUDO_CLASS_SPECIAL.match(selector, index)
+        if m:
+            name = util.lower(css_unescape(m.group('name')))
+            pattern = self.patterns.get(name)
+            if pattern:
+                pseudo = pattern.match(selector, index, flags)
+                if pseudo:
+                    self.matched_name = pattern
+
+        return pseudo
+
+
+class _Selector:
+    """
+    Intermediate selector class.
+
+    This stores selector data for a compound selector as we are acquiring them.
+    Once we are done collecting the data for a compound selector, we freeze
+    the data in an object that can be pickled and hashed.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize."""
+
+        self.tag = kwargs.get('tag', None)  # type: ct.SelectorTag | None
+        self.ids = kwargs.get('ids', [])  # type: list[str]
+        self.classes = kwargs.get('classes', [])  # type: list[str]
+        self.attributes = kwargs.get('attributes', [])  # type: list[ct.SelectorAttribute]
+        self.nth = kwargs.get('nth', [])  # type: list[ct.SelectorNth]
+        self.selectors = kwargs.get('selectors', [])  # type: list[ct.SelectorList]
+        self.relations = kwargs.get('relations', [])  # type: list[_Selector]
+        self.rel_type = kwargs.get('rel_type', None)  # type: str | None
+        self.contains = kwargs.get('contains', [])  # type: list[ct.SelectorContains]
+        self.lang = kwargs.get('lang', [])  # type: list[ct.SelectorLang]
+        self.flags = kwargs.get('flags', 0)  # type: int
+        self.no_match = kwargs.get('no_match', False)  # type: bool
+
+    def _freeze_relations(self, relations: list[_Selector]) -> ct.SelectorList:
+        """Freeze relation."""
+
+        if relations:
+            sel = relations[0]
+            sel.relations.extend(relations[1:])
+            return ct.SelectorList([sel.freeze()])
+        else:
+            return ct.SelectorList()
+
+    def freeze(self) -> ct.Selector | ct.SelectorNull:
+        """Freeze self."""
+
+        if self.no_match:
+            return ct.SelectorNull()
+        else:
+            return ct.Selector(
+                self.tag,
+                tuple(self.ids),
+                tuple(self.classes),
+                tuple(self.attributes),
+                tuple(self.nth),
+                tuple(self.selectors),
+                self._freeze_relations(self.relations),
+                self.rel_type,
+                tuple(self.contains),
+                tuple(self.lang),
+                self.flags
+            )
+
+    def __str__(self) -> str:  # pragma: no cover
+        """String representation."""
+
+        return (
+            f'_Selector(tag={self.tag!r}, ids={self.ids!r}, classes={self.classes!r}, attributes={self.attributes!r}, '
+            f'nth={self.nth!r}, selectors={self.selectors!r}, relations={self.relations!r}, '
+            f'rel_type={self.rel_type!r}, contains={self.contains!r}, lang={self.lang!r}, flags={self.flags!r}, '
+            f'no_match={self.no_match!r})'
+        )
+
+    __repr__ = __str__
+
+
+@dataclass
+class CSSPattern:
+    """A CSS pattern that hasn't been processed by `CSSParser` yet."""
+
+    selector: str
+    flags: int
+
+
+class PseudoSelectorMap(UserDict[str, CSSPattern | ct.SelectorList]):
+    """Pseudo selector map."""
+
+    def __setitem__(self, key: str, value: CSSPattern | ct.SelectorList) -> None:
+        """Set item."""
+
+        self.data[key] = value
+
+    def __getitem__(self, key: str) -> ct.SelectorList:
+        """Get item."""
+
+        with SEL_LOCK:
+            value = self.data[key]
+            if isinstance(value, CSSPattern):
+                value = CSSParser(value.selector).process_selectors(flags=value.flags)
+                self.data[key] = value
+
+        return value
+
+
+# CSS pattern for `:link` and `:any-link`
+CSS_LINK = CSSPattern('html|*:is(a, area)[href]', FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:checked`
+CSS_CHECKED = CSSPattern(
+    '''
+    html|*:is(input[type=checkbox], input[type=radio])[checked], html|option[selected]
+    ''',
+    FLG_PSEUDO | FLG_HTML
+)
+# CSS pattern for `:default` (must compile CSS_CHECKED first)
+CSS_DEFAULT = CSSPattern(
+    '''
+    :checked,
+
+    /*
+    This pattern must be at the end.
+    Special logic is applied to the last selector.
+    */
+    html|form html|*:is(button, input)[type="submit"]
+    ''',
+    FLG_PSEUDO | FLG_HTML | FLG_DEFAULT
+)
+# CSS pattern for `:indeterminate`
+CSS_INDETERMINATE = CSSPattern(
+    '''
+    html|input[type="checkbox"][indeterminate],
+    html|input[type="radio"]:is(:not([name]), [name=""]):not([checked]),
+    html|progress:not([value]),
+
+    /*
+    This pattern must be at the end.
+    Special logic is applied to the last selector.
+    */
+    html|input[type="radio"][name]:not([name='']):not([checked])
+    ''',
+    FLG_PSEUDO | FLG_HTML | FLG_INDETERMINATE
+)
+# CSS pattern for `:disabled`
+CSS_DISABLED = CSSPattern(
+    '''
+    html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset)[disabled],
+    html|optgroup[disabled] > html|option,
+    html|fieldset[disabled] > html|*:is(input:not([type=hidden]), button, select, textarea, fieldset),
+    html|fieldset[disabled] >
+        html|*:not(legend:nth-of-type(1)) html|*:is(input:not([type=hidden]), button, select, textarea, fieldset)
+    ''',
+    FLG_PSEUDO | FLG_HTML
+)
+# CSS pattern for `:enabled`
+CSS_ENABLED = CSSPattern(
+    '''
+    html|*:is(input:not([type=hidden]), button, select, textarea, fieldset, optgroup, option, fieldset):not(:disabled)
+    ''',
+    FLG_PSEUDO | FLG_HTML
+)
+# CSS pattern for `:required`
+CSS_REQUIRED = CSSPattern('html|*:is(input, textarea, select)[required]', FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:optional`
+CSS_OPTIONAL = CSSPattern('html|*:is(input, textarea, select):not([required])', FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:placeholder-shown`
+CSS_PLACEHOLDER_SHOWN = CSSPattern(
+    '''
+    html|input:is(
+        :not([type]),
+        [type=""],
+        [type=text],
+        [type=search],
+        [type=url],
+        [type=tel],
+        [type=email],
+        [type=password],
+        [type=number]
+    )[placeholder]:not([placeholder='']):is(:not([value]), [value=""]),
+    html|textarea[placeholder]:not([placeholder=''])
+    ''',
+    FLG_PSEUDO | FLG_HTML | FLG_PLACEHOLDER_SHOWN
+)
+# CSS pattern for `:read-write` (CSS_DISABLED must be compiled first)
+CSS_READ_WRITE = CSSPattern(
+    '''
+    html|*:is(
+        textarea,
+        input:is(
+            :not([type]),
+            [type=""],
+            [type=text],
+            [type=search],
+            [type=url],
+            [type=tel],
+            [type=email],
+            [type=number],
+            [type=password],
+            [type=date],
+            [type=datetime-local],
+            [type=month],
+            [type=time],
+            [type=week]
+        )
+    ):not([readonly], :disabled),
+    html|*:is([contenteditable=""], [contenteditable="true" i])
+    ''',
+    FLG_PSEUDO | FLG_HTML
+)
+# CSS pattern for `:read-only`
+CSS_READ_ONLY = CSSPattern('html|*:not(:read-write)', FLG_PSEUDO | FLG_HTML)
+# CSS pattern for `:in-range`
+CSS_IN_RANGE = CSSPattern(
+    '''
+    html|input:is(
+        [type="date"],
+        [type="month"],
+        [type="week"],
+        [type="time"],
+        [type="datetime-local"],
+        [type="number"],
+        [type="range"]
+    ):is(
+        [min],
+        [max]
+    )
+    ''',
+    FLG_PSEUDO | FLG_HTML | FLG_IN_RANGE
+)
+# CSS pattern for `:out-of-range`
+CSS_OUT_OF_RANGE = CSSPattern(
+    '''
+    html|input:is(
+        [type="date"],
+        [type="month"],
+        [type="week"],
+        [type="time"],
+        [type="datetime-local"],
+        [type="number"],
+        [type="range"]
+    ):is(
+        [min],
+        [max]
+    )
+    ''',
+    FLG_PSEUDO | FLG_HTML | FLG_OUT_OF_RANGE
+)
+# CSS pattern for :open
+CSS_OPEN = CSSPattern('html|*:is(details, dialog)[open]', FLG_PSEUDO | FLG_HTML)
+# CSS pattern for :muted
+CSS_MUTED = CSSPattern('html|*:is(video, audio)[muted]', FLG_PSEUDO | FLG_HTML)
+# CSS pattern default for `:nth-child` "of S" feature
+CSS_NTH_OF_S_DEFAULT = CSSPattern("*|*", FLG_PSEUDO)
+
+
+class CSSParser:
+    """Parse CSS selectors."""
+
+    CSS_TOKENS = (
+        SelectorPattern("pseudo_close", PAT_PSEUDO_CLOSE),
+        SpecialPseudoPattern(
+            (
+                (
+                    "pseudo_contains",
+                    (':contains', ':-soup-contains', ':-soup-contains-own'),
+                    PAT_PSEUDO_CONTAINS,
+                    SelectorPattern
+                ),
+                ("pseudo_nth_child", (':nth-child', ':nth-last-child'), PAT_PSEUDO_NTH_CHILD, SelectorPattern),
+                ("pseudo_nth_type", (':nth-of-type', ':nth-last-of-type'), PAT_PSEUDO_NTH_TYPE, SelectorPattern),
+                ("pseudo_lang", (':lang',), PAT_PSEUDO_LANG, SelectorPattern),
+                ("pseudo_dir", (':dir',), PAT_PSEUDO_DIR, SelectorPattern)
+            )
+        ),
+        SelectorPattern("pseudo_class_custom", PAT_PSEUDO_CLASS_CUSTOM),
+        SelectorPattern("pseudo_class", PAT_PSEUDO_CLASS),
+        SelectorPattern("pseudo_element", PAT_PSEUDO_ELEMENT),
+        SelectorPattern("amp", PAT_AMP),
+        SelectorPattern("at_rule", PAT_AT_RULE),
+        SelectorPattern("id", PAT_ID),
+        SelectorPattern("class", PAT_CLASS),
+        SelectorPattern("tag", PAT_TAG),
+        SelectorPattern("attribute", PAT_ATTR),
+        SelectorPattern("combine", PAT_COMBINE)
+    )
+
+    # Pseudos that expand to selectors
+    PSEUDO_SELECTORS = PseudoSelectorMap(
+        {
+            ':link': CSS_LINK,
+            ':any-link': CSS_LINK,
+            ':checked': CSS_CHECKED,
+            ':default': CSS_DEFAULT,
+            ':indeterminate': CSS_INDETERMINATE,
+            ':disabled': CSS_DISABLED,
+            ':enabled': CSS_ENABLED,
+            ':required': CSS_REQUIRED,
+            ':muted': CSS_MUTED,
+            ':open': CSS_OPEN,
+            ':optional': CSS_OPTIONAL,
+            ':read-only': CSS_READ_ONLY,
+            ':read-write': CSS_READ_WRITE,
+            ':in-range': CSS_IN_RANGE,
+            ':out-of-range': CSS_OUT_OF_RANGE,
+            ':placeholder-shown': CSS_PLACEHOLDER_SHOWN,
+            '': CSS_NTH_OF_S_DEFAULT
+        }
+    )
+
+    def __init__(
+        self,
+        selector: str,
+        custom: dict[str, str | ct.SelectorList] | None = None,
+        flags: int = 0
+    ) -> None:
+        """Initialize."""
+
+        self.pattern = selector.replace('\x00', '\ufffd')
+        self.flags = flags
+        self.debug = self.flags & util.DEBUG
+        self.custom = {} if custom is None else custom
+        self.count = 0
+
+    def increment_count(self, increment: int = 1) -> None:
+        """Check the current selector count."""
+
+        self.count += increment
+        if self.count > SELECTOR_LIMIT:
+            raise ValueError(f'Selector exceeds pseudo-class nesting limit of {SELECTOR_LIMIT}')
+
+    def parse_attribute_selector(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Create attribute selector from the returned regex match."""
+
+        inverse = False
+        op = m.group('cmp')
+        case = util.lower(m.group('case')) if m.group('case') else None
+        ns = css_unescape(m.group('attr_ns')[:-1]) if m.group('attr_ns') else ''
+        attr = css_unescape(m.group('attr_name'))
+        is_type = False
+        pattern2 = None
+        value = ''
+
+        if case:
+            flags = (re.I if case == 'i' else 0) | re.DOTALL
+        elif util.lower(attr) == 'type':
+            flags = re.I | re.DOTALL
+            is_type = True
+        else:
+            flags = re.DOTALL
+
+        if op:
+            value = css_unescape(m.group('value'))
+
+        if not op:
+            # Attribute name
+            pattern = None
+        elif op.startswith('^'):
+            # Value start with
+            # `^=` should match nothing if the value is empty, so use `(?!)` which cannot be matched.
+            value = r'(?!)' if not value else re.escape(value)
+            pattern = re.compile(r'^%s.*' % value, flags)
+        elif op.startswith('$'):
+            # Value ends with
+            # `$=` should match nothing if the value is empty, so use `(?!)` which cannot be matched.
+            value = r'(?!)' if not value else re.escape(value)
+            pattern = re.compile(r'.*?%s$' % value, flags)
+        elif op.startswith('*'):
+            # Value contains
+            # `*=` should match nothing if the value is empty, so use `(?!)` which cannot be matched.
+            value = r'(?!)' if not value else re.escape(value)
+            pattern = re.compile(r'.*?%s.*' % value, flags)
+        elif op.startswith('~'):
+            # Value contains word within space separated list
+            # `*~` should match nothing if the value is empty, so use `(?!)` which cannot be matched.
+            value = r'(?!)' if not value or RE_WS.search(value) else re.escape(value)
+            pattern = re.compile(r'.*?(?:(?<=^)|(?<=[ \t\r\n\f]))%s(?=(?:[ \t\r\n\f]|$)).*' % value, flags)
+        elif op.startswith('|'):
+            # Value starts with word in dash separated list
+            pattern = re.compile(r'^%s(?:-.*)?$' % re.escape(value), flags)
+        else:
+            # Value matches
+            pattern = re.compile(r'^%s$' % re.escape(value), flags)
+            if op.startswith('!'):
+                # Equivalent to `:not([attr=value])`
+                inverse = True
+        if is_type and pattern:
+            pattern2 = re.compile(pattern.pattern)
+
+        # Append the attribute selector
+        sel_attr = ct.SelectorAttribute(attr, ns, pattern, pattern2)
+        if inverse:
+            # If we are using `!=`, we need to nest the pattern under a `:not()`.
+            sub_sel = _Selector()
+            sub_sel.attributes.append(sel_attr)
+            not_list = ct.SelectorList([sub_sel.freeze()], True, False)
+            sel.selectors.append(not_list)
+        else:
+            sel.attributes.append(sel_attr)
+
+        has_selector = True
+        return has_selector
+
+    def parse_tag_pattern(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse tag pattern from regex match."""
+
+        prefix = css_unescape(m.group('tag_ns')[:-1]) if m.group('tag_ns') else None
+        tag = css_unescape(m.group('tag_name'))
+        sel.tag = ct.SelectorTag(tag, prefix)
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_class_custom(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """
+        Parse custom pseudo class alias.
+
+        Compile custom selectors as we need them. When compiling a custom selector,
+        set it to `None` in the dictionary so we can avoid an infinite loop.
+        """
+
+        pseudo = util.lower(css_unescape(m.group('name')))
+        selector = self.custom.get(pseudo)
+        if selector is None:
+            raise SelectorSyntaxError(
+                f"Undefined custom selector '{pseudo}' found at position {m.end(0)}",
+                self.pattern,
+                m.end(0)
+            )
+
+        if not isinstance(selector, ct.SelectorList):
+            del self.custom[pseudo]
+            selector = CSSParser(
+                selector, custom=self.custom, flags=self.flags
+            ).process_selectors(flags=FLG_PSEUDO)
+            self.custom[pseudo] = selector
+
+        self.increment_count(selector.count)
+        sel.selectors.append(selector)
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_class(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]],
+        is_html: bool
+    ) -> tuple[bool, bool]:
+        """Parse pseudo class."""
+
+        complex_pseudo = False
+        pseudo = util.lower(css_unescape(m.group('name')))
+        if m.group('open'):
+            complex_pseudo = True
+        if complex_pseudo and pseudo in PSEUDO_COMPLEX:
+            has_selector = self.parse_pseudo_open(sel, pseudo, has_selector, iselector, m.end(0))
+        elif not complex_pseudo and pseudo in PSEUDO_SIMPLE:
+            if pseudo == ':root':
+                sel.flags |= ct.SEL_ROOT
+            elif pseudo == ':defined':
+                sel.flags |= ct.SEL_DEFINED
+                is_html = True
+            elif pseudo == ':scope':
+                sel.flags |= ct.SEL_SCOPE
+            elif pseudo == ':empty':
+                sel.flags |= ct.SEL_EMPTY
+            elif pseudo in self.PSEUDO_SELECTORS:
+                pseudo_selector = self.PSEUDO_SELECTORS[pseudo]
+                self.increment_count(pseudo_selector.count)
+                sel.selectors.append(pseudo_selector)
+            elif pseudo == ':first-child':
+                sel.nth.append(ct.SelectorNth(1, False, 0, False, False, ct.SelectorList()))
+            elif pseudo == ':last-child':
+                sel.nth.append(ct.SelectorNth(1, False, 0, False, True, ct.SelectorList()))
+            elif pseudo == ':first-of-type':
+                sel.nth.append(ct.SelectorNth(1, False, 0, True, False, ct.SelectorList()))
+            elif pseudo == ':last-of-type':
+                sel.nth.append(ct.SelectorNth(1, False, 0, True, True, ct.SelectorList()))
+            elif pseudo == ':only-child':
+                sel.nth.extend(
+                    [
+                        ct.SelectorNth(1, False, 0, False, False, ct.SelectorList()),
+                        ct.SelectorNth(1, False, 0, False, True, ct.SelectorList())
+                    ]
+                )
+            elif pseudo == ':only-of-type':
+                sel.nth.extend(
+                    [
+                        ct.SelectorNth(1, False, 0, True, False, ct.SelectorList()),
+                        ct.SelectorNth(1, False, 0, True, True, ct.SelectorList())
+                    ]
+                )
+            has_selector = True
+        elif complex_pseudo and pseudo in PSEUDO_COMPLEX_NO_MATCH:
+            self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN)
+            sel.no_match = True
+            has_selector = True
+        elif not complex_pseudo and pseudo in PSEUDO_SIMPLE_NO_MATCH:
+            sel.no_match = True
+            has_selector = True
+        elif pseudo in PSEUDO_SUPPORTED:
+            raise SelectorSyntaxError(
+                f"Invalid syntax for pseudo class '{pseudo}'",
+                self.pattern,
+                m.start(0)
+            )
+        else:
+            raise SelectorSyntaxError(
+                f"'{pseudo}' was detected as a pseudo-class and is either unsupported or invalid. "
+                "If the syntax was not intended to be recognized as a pseudo-class, please escape the colon.",
+                self.pattern,
+                m.start(0)
+            )
+
+        return has_selector, is_html
+
+    def parse_pseudo_nth(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]]
+    ) -> bool:
+        """Parse `nth` pseudo."""
+
+        mdict = m.groupdict()
+        if mdict.get('pseudo_nth_child'):
+            postfix = '_child'
+        else:
+            postfix = '_type'
+        mdict['name'] = util.lower(css_unescape(mdict['name']))
+        content = util.lower(mdict.get('nth' + postfix))
+        if content == 'even':
+            # 2n
+            s1 = 2
+            s2 = 0
+            var = True
+        elif content == 'odd':
+            # 2n+1
+            s1 = 2
+            s2 = 1
+            var = True
+        else:
+            nth_parts = cast(Match[str], RE_NTH.match(content))
+            _s1 = '-' if nth_parts.group('s1') and nth_parts.group('s1') == '-' else ''
+            a = nth_parts.group('a')
+            var = a.endswith('n')
+            if a.startswith('n'):
+                _s1 += '1'
+            elif var:
+                _s1 += a[:-1]
+            else:
+                _s1 += a
+            _s2 = '-' if nth_parts.group('s2') and nth_parts.group('s2') == '-' else ''
+            if nth_parts.group('b'):
+                _s2 += nth_parts.group('b')
+            else:
+                _s2 = '0'
+            s1 = int(_s1, 10)
+            s2 = int(_s2, 10)
+
+        pseudo_sel = mdict['name']
+        if postfix == '_child':
+            if m.group('of'):
+                # Parse the rest of `of S`.
+                nth_sel = self.parse_selectors(iselector, m.end(0), FLG_PSEUDO | FLG_OPEN)
+            else:
+                # Use default `*|*` for `of S`.
+                nth_sel = self.PSEUDO_SELECTORS['']
+                self.increment_count(nth_sel.count)
+            if pseudo_sel == ':nth-child':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, False, False, nth_sel))
+            elif pseudo_sel == ':nth-last-child':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, False, True, nth_sel))
+        else:
+            if pseudo_sel == ':nth-of-type':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, True, False, ct.SelectorList()))
+            elif pseudo_sel == ':nth-last-of-type':
+                sel.nth.append(ct.SelectorNth(s1, var, s2, True, True, ct.SelectorList()))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_open(
+        self,
+        sel: _Selector,
+        name: str,
+        has_selector: bool,
+        iselector: Iterator[tuple[str, Match[str]]],
+        index: int
+    ) -> bool:
+        """Parse pseudo with opening bracket."""
+
+        flags = FLG_PSEUDO | FLG_OPEN
+        if name == ':not':
+            flags |= FLG_NOT
+        elif name == ':has':
+            flags |= FLG_RELATIVE
+        elif name in (':where', ':is'):
+            flags |= FLG_FORGIVE
+
+        sel.selectors.append(self.parse_selectors(iselector, index, flags))
+        has_selector = True
+
+        return has_selector
+
+    def parse_has_combinator(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        selectors: list[_Selector],
+        rel_type: str,
+        index: int
+    ) -> tuple[bool, _Selector, str]:
+        """Parse combinator tokens."""
+
+        combinator = m.group('relation').strip()
+        if not combinator:
+            combinator = WS_COMBINATOR
+        if combinator == COMMA_COMBINATOR:
+            if not has_selector:
+                raise SelectorSyntaxError(
+                    f"The combinator '{combinator}' at position {index}, must have a selector before it",
+                    self.pattern,
+                    index
+                )
+            sel.rel_type = rel_type
+            selectors[-1].relations.append(sel)
+            rel_type = ":" + WS_COMBINATOR
+            selectors.append(_Selector())
+        else:
+            if has_selector:
+                # End the current selector and associate the leading combinator with this selector.
+                sel.rel_type = rel_type
+                selectors[-1].relations.append(sel)
+            elif rel_type[1:] != WS_COMBINATOR:
+                # It's impossible to have two whitespace combinators after each other as the patterns
+                # will gobble up trailing whitespace. It is also impossible to have a whitespace
+                # combinator after any other kind for the same reason. But we could have
+                # multiple non-whitespace combinators. So if the current combinator is not a whitespace,
+                # then we've hit the multiple combinator case, so we should fail.
+                raise SelectorSyntaxError(
+                    f'The multiple combinators at position {index}',
+                    self.pattern,
+                    index
+                )
+
+            # Set the leading combinator for the next selector.
+            rel_type = ':' + combinator
+
+        sel = _Selector()
+        has_selector = False
+        return has_selector, sel, rel_type
+
+    def parse_combinator(
+        self,
+        sel: _Selector,
+        m: Match[str],
+        has_selector: bool,
+        selectors: list[_Selector],
+        relations: list[_Selector],
+        is_pseudo: bool,
+        is_forgive: bool,
+        index: int
+    ) -> tuple[bool, _Selector]:
+        """Parse combinator tokens."""
+
+        combinator = m.group('relation').strip()
+        if not combinator:
+            combinator = WS_COMBINATOR
+        if not has_selector:
+            if not is_forgive or combinator != COMMA_COMBINATOR:
+                raise SelectorSyntaxError(
+                    f"The combinator '{combinator}' at position {index}, must have a selector before it",
+                    self.pattern,
+                    index
+                )
+
+            # If we are in a forgiving pseudo class, just make the selector a "no match"
+            if combinator == COMMA_COMBINATOR:
+                self.increment_count()
+                del relations[:]
+        else:
+            if combinator == COMMA_COMBINATOR:
+                if not sel.tag and not is_pseudo:
+                    # Implied `*`
+                    sel.tag = ct.SelectorTag('*', None)
+                sel.relations.extend(relations)
+                selectors.append(sel)
+                del relations[:]
+            else:
+                sel.relations.extend(relations)
+                sel.rel_type = combinator
+                del relations[:]
+                relations.append(sel)
+
+        sel = _Selector()
+        has_selector = False
+
+        return has_selector, sel
+
+    def parse_class_id(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse HTML classes and ids."""
+
+        selector = m.group(0)
+        if selector.startswith('.'):
+            sel.classes.append(css_unescape(selector[1:]))
+        else:
+            sel.ids.append(css_unescape(selector[1:]))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_contains(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse contains."""
+
+        pseudo = util.lower(css_unescape(m.group('name')))
+        if pseudo == ":contains":
+            warnings.warn(  # noqa: B028
+                "The pseudo class ':contains' is deprecated, ':-soup-contains' should be used moving forward.",
+                FutureWarning
+            )
+        contains_own = pseudo == ":-soup-contains-own"
+        patterns = [
+            css_unescape(token.group('value'))
+            for token in RE_VALUES.finditer(m.group('values'))
+            if not token.group('split')
+        ]
+        sel.contains.append(ct.SelectorContains(patterns, contains_own))
+        has_selector = True
+        return has_selector
+
+    def parse_pseudo_lang(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse pseudo language."""
+
+        patterns = [
+            css_unescape(token.group('value'))
+            for token in RE_VALUES.finditer(m.group('values'))
+            if not token.group('split')
+        ]
+        sel.lang.append(ct.SelectorLang(patterns))
+        has_selector = True
+
+        return has_selector
+
+    def parse_pseudo_dir(self, sel: _Selector, m: Match[str], has_selector: bool) -> bool:
+        """Parse pseudo direction."""
+
+        value = ct.SEL_DIR_LTR if util.lower(m.group('dir')) == 'ltr' else ct.SEL_DIR_RTL
+        sel.flags |= value
+        has_selector = True
+        return has_selector
+
+    def parse_selectors(
+        self,
+        iselector: Iterator[tuple[str, Match[str]]],
+        index: int = 0,
+        flags: int = 0
+    ) -> ct.SelectorList:
+        """Parse selectors."""
+
+        # Initialize important variables
+        sel = _Selector()
+        selectors = []
+        has_selector = False
+        closed = False
+        relations = []  # type: list[_Selector]
+        rel_type = ":" + WS_COMBINATOR
+        count = self.count
+
+        # Setup various flags
+        is_open = bool(flags & FLG_OPEN)
+        is_pseudo = bool(flags & FLG_PSEUDO)
+        is_relative = bool(flags & FLG_RELATIVE)
+        is_not = bool(flags & FLG_NOT)
+        is_html = bool(flags & FLG_HTML)
+        is_default = bool(flags & FLG_DEFAULT)
+        is_indeterminate = bool(flags & FLG_INDETERMINATE)
+        is_in_range = bool(flags & FLG_IN_RANGE)
+        is_out_of_range = bool(flags & FLG_OUT_OF_RANGE)
+        is_placeholder_shown = bool(flags & FLG_PLACEHOLDER_SHOWN)
+        is_forgive = bool(flags & FLG_FORGIVE)
+
+        # Print out useful debug stuff
+        if self.debug:  # pragma: no cover
+            if is_pseudo:
+                print('    is_pseudo: True')
+            if is_open:
+                print('    is_open: True')
+            if is_relative:
+                print('    is_relative: True')
+            if is_not:
+                print('    is_not: True')
+            if is_html:
+                print('    is_html: True')
+            if is_default:
+                print('    is_default: True')
+            if is_indeterminate:
+                print('    is_indeterminate: True')
+            if is_in_range:
+                print('    is_in_range: True')
+            if is_out_of_range:
+                print('    is_out_of_range: True')
+            if is_placeholder_shown:
+                print('    is_placeholder_shown: True')
+            if is_forgive:
+                print('    is_forgive: True')
+
+        # The algorithm for relative selectors require an initial selector in the selector list
+        if is_relative:
+            selectors.append(_Selector())
+
+        try:
+            while True:
+                key, m = next(iselector)
+
+                if key not in ('combine', 'pseudo_close'):
+                    self.increment_count()
+
+                # Handle parts
+                if key == "at_rule":
+                    raise NotImplementedError(f"At-rules found at position {m.start(0)}")
+                elif key == "amp":
+                    sel.flags |= ct.SEL_SCOPE
+                    has_selector = True
+                elif key == 'pseudo_class_custom':
+                    has_selector = self.parse_pseudo_class_custom(sel, m, has_selector)
+                elif key == 'pseudo_class':
+                    has_selector, is_html = self.parse_pseudo_class(sel, m, has_selector, iselector, is_html)
+                elif key == 'pseudo_element':
+                    raise NotImplementedError(f"Pseudo-element found at position {m.start(0)}")
+                elif key == 'pseudo_contains':
+                    has_selector = self.parse_pseudo_contains(sel, m, has_selector)
+                elif key in ('pseudo_nth_type', 'pseudo_nth_child'):
+                    has_selector = self.parse_pseudo_nth(sel, m, has_selector, iselector)
+                elif key == 'pseudo_lang':
+                    has_selector = self.parse_pseudo_lang(sel, m, has_selector)
+                elif key == 'pseudo_dir':
+                    has_selector = self.parse_pseudo_dir(sel, m, has_selector)
+                    # Currently only supports HTML
+                    is_html = True
+                elif key == 'pseudo_close':
+                    if not has_selector:
+                        if not is_forgive:
+                            raise SelectorSyntaxError(
+                                f"Expected a selector at position {m.start(0)}",
+                                self.pattern,
+                                m.start(0)
+                            )
+                        sel.no_match = True
+                    if is_open:
+                        closed = True
+                        break
+                    else:
+                        raise SelectorSyntaxError(
+                            f"Unmatched pseudo-class close at position {m.start(0)}",
+                            self.pattern,
+                            m.start(0)
+                        )
+                elif key == 'combine':
+                    if is_relative:
+                        has_selector, sel, rel_type = self.parse_has_combinator(
+                            sel, m, has_selector, selectors, rel_type, index
+                        )
+                    else:
+                        has_selector, sel = self.parse_combinator(
+                            sel, m, has_selector, selectors, relations, is_pseudo, is_forgive, index
+                        )
+                elif key == 'attribute':
+                    has_selector = self.parse_attribute_selector(sel, m, has_selector)
+                elif key == 'tag':
+                    if has_selector:
+                        raise SelectorSyntaxError(
+                            f"Tag name found at position {m.start(0)} instead of at the start",
+                            self.pattern,
+                            m.start(0)
+                        )
+                    has_selector = self.parse_tag_pattern(sel, m, has_selector)
+                elif key in ('class', 'id'):
+                    has_selector = self.parse_class_id(sel, m, has_selector)
+
+                index = m.end(0)
+        except StopIteration:
+            pass
+
+        # Handle selectors that are not closed
+        if is_open and not closed:
+            raise SelectorSyntaxError(
+                f"Unclosed pseudo-class at position {index}",
+                self.pattern,
+                index
+            )
+
+        # Cleanup completed selector piece
+        if has_selector:
+            if not sel.tag and not is_pseudo:
+                # Implied `*`
+                sel.tag = ct.SelectorTag('*', None)
+            if is_relative:
+                sel.rel_type = rel_type
+                selectors[-1].relations.append(sel)
+            else:
+                sel.relations.extend(relations)
+                del relations[:]
+                selectors.append(sel)
+
+        # Forgive empty slots in pseudo-classes that have lists (and are forgiving)
+        elif is_forgive and (not selectors or not relations):
+            # Handle normal pseudo-classes with empty slots like `:is()` etc.
+            self.increment_count()
+            sel.no_match = True
+            del relations[:]
+            selectors.append(sel)
+            has_selector = True
+
+        if not has_selector:
+            # We will always need to finish a selector when `:has()` is used as it leads with combining.
+            # May apply to others as well.
+            raise SelectorSyntaxError(
+                f'Expected a selector at position {index}',
+                self.pattern,
+                index
+            )
+
+        # Some patterns require additional logic, such as default. We try to make these the
+        # last pattern, and append the appropriate flag to that selector which communicates
+        # to the matcher what additional logic is required.
+        if is_default:
+            selectors[-1].flags = ct.SEL_DEFAULT
+        if is_indeterminate:
+            selectors[-1].flags = ct.SEL_INDETERMINATE
+        if is_in_range:
+            selectors[-1].flags = ct.SEL_IN_RANGE
+        if is_out_of_range:
+            selectors[-1].flags = ct.SEL_OUT_OF_RANGE
+        if is_placeholder_shown:
+            selectors[-1].flags = ct.SEL_PLACEHOLDER_SHOWN
+
+        # Return selector list
+        return ct.SelectorList([s.freeze() for s in selectors], is_not, is_html, self.count - count)
+
+    def selector_iter(self, pattern: str) -> Iterator[tuple[str, Match[str]]]:
+        """Iterate selector tokens."""
+
+        # Ignore whitespace and comments at start and end of pattern
+        m = RE_WS_BEGIN.search(pattern)
+        index = m.end(0) if m else 0
+        m = RE_WS_END.search(pattern[::-1])
+        offset = m.end(0) if m else 0
+        end = len(pattern) - (1 + offset)
+
+        if self.debug:  # pragma: no cover
+            print(f'## PARSING: {pattern!r}')
+        while index <= end:
+            m = None
+            for v in self.CSS_TOKENS:
+                m = v.match(pattern, index, self.flags)
+                if m:
+                    name = v.get_name()
+                    if self.debug:  # pragma: no cover
+                        print(f"TOKEN: '{name}' --> {m.group(0)!r} at position {m.start(0)}")
+                    index = m.end(0)
+                    yield name, m
+                    break
+            if m is None:
+                c = pattern[index]
+                # If the character represents the start of one of the known selector types,
+                # throw an exception mentioning that the known selector type is in error;
+                # otherwise, report the invalid character.
+                if c == '[':
+                    msg = f"Malformed attribute selector at position {index}"
+                elif c == '.':
+                    msg = f"Malformed class selector at position {index}"
+                elif c == '#':
+                    msg = f"Malformed id selector at position {index}"
+                elif c == ':':
+                    msg = f"Malformed pseudo-class selector at position {index}"
+                else:
+                    msg = f"Invalid character {c!r} position {index}"
+                raise SelectorSyntaxError(msg, self.pattern, index)
+        if self.debug:  # pragma: no cover
+            print('## END PARSING')
+
+    def process_selectors(self, index: int = 0, flags: int = 0) -> ct.SelectorList:
+        """Process selectors."""
+
+        return self.parse_selectors(self.selector_iter(self.pattern), index, flags)
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/css_types.py b/.venv/lib/python3.12/site-packages/soupsieve/css_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1af46efed50fa26487e16df8e69895c9e6533aa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/soupsieve/css_types.py
@@ -0,0 +1,410 @@
+"""CSS selector structure items."""
+from __future__ import annotations
+import copyreg
+from .pretty import pretty
+from typing import Any, Iterator, Hashable, Pattern, Iterable, Mapping
+
+__all__ = (
+    'Selector',
+    'SelectorNull',
+    'SelectorTag',
+    'SelectorAttribute',
+    'SelectorContains',
+    'SelectorNth',
+    'SelectorLang',
+    'SelectorList',
+    'Namespaces',
+    'CustomSelectors'
+)
+
+
+SEL_EMPTY = 0x1
+SEL_ROOT = 0x2
+SEL_DEFAULT = 0x4
+SEL_INDETERMINATE = 0x8
+SEL_SCOPE = 0x10
+SEL_DIR_LTR = 0x20
+SEL_DIR_RTL = 0x40
+SEL_IN_RANGE = 0x80
+SEL_OUT_OF_RANGE = 0x100
+SEL_DEFINED = 0x200
+SEL_PLACEHOLDER_SHOWN = 0x400
+
+
+class Immutable:
+    """Immutable."""
+
+    __slots__: tuple[str, ...] = ('_hash',)
+
+    _hash: int
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize."""
+
+        temp = []
+        for k, v in kwargs.items():
+            temp.append(type(v))
+            temp.append(v)
+            super().__setattr__(k, v)
+        super().__setattr__('_hash', hash(tuple(temp)))
+
+    @classmethod
+    def __base__(cls) -> type[Immutable]:
+        """Get base class."""
+
+        return cls
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            isinstance(other, self.__base__()) and
+            all(getattr(other, key) == getattr(self, key) for key in self.__slots__ if key != '_hash')
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            not isinstance(other, self.__base__()) or
+            any(getattr(other, key) != getattr(self, key) for key in self.__slots__ if key != '_hash')
+        )
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Prevent mutability."""
+
+        raise AttributeError(f"'{self.__class__.__name__}' is immutable")
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        r = ', '.join([f"{k}={getattr(self, k)!r}" for k in self.__slots__[:-1]])
+        return f"{self.__class__.__name__}({r})"
+
+    __str__ = __repr__
+
+    def pretty(self) -> None:  # pragma: no cover
+        """Pretty print."""
+
+        print(pretty(self))
+
+
+class ImmutableDict(Mapping[Any, Any]):
+    """Hashable, immutable dictionary."""
+
+    def __init__(
+        self,
+        arg: dict[Any, Any] | Iterable[tuple[Any, Any]]
+    ) -> None:
+        """Initialize."""
+
+        self._validate(arg)
+        self._d = dict(arg)
+        self._hash = hash(tuple([(type(x), x, type(y), y) for x, y in sorted(self._d.items())]))
+
+    def _validate(self, arg: dict[Any, Any] | Iterable[tuple[Any, Any]]) -> None:
+        """Validate arguments."""
+
+        if isinstance(arg, dict):
+            if not all(isinstance(v, Hashable) for v in arg.values()):
+                raise TypeError(f'{self.__class__.__name__} values must be hashable')
+        elif not all(isinstance(k, Hashable) and isinstance(v, Hashable) for k, v in arg):
+            raise TypeError(f'{self.__class__.__name__} values must be hashable')
+
+    def __iter__(self) -> Iterator[Any]:
+        """Iterator."""
+
+        return iter(self._d)
+
+    def __len__(self) -> int:
+        """Length."""
+
+        return len(self._d)
+
+    def __getitem__(self, key: Any) -> Any:
+        """Get item: `namespace['key']`."""
+
+        return self._d[key]
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        return f"{self._d!r}"
+
+    __str__ = __repr__
+
+
+class Namespaces(ImmutableDict):
+    """Namespaces."""
+
+    def __init__(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Initialize."""
+
+        super().__init__(arg)
+
+    def _validate(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Validate arguments."""
+
+        if not all(
+            isinstance(k, str) and isinstance(v, str)
+            for k, v in (arg.items() if isinstance(arg, dict) else arg)
+        ):
+            raise TypeError(f'{self.__class__.__name__} values must be hashable')
+
+
+class CustomSelectors(ImmutableDict):
+    """Custom selectors."""
+
+    def __init__(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Initialize."""
+
+        super().__init__(arg)
+
+    def _validate(self, arg: dict[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Validate arguments."""
+
+        if not all(
+            isinstance(k, str) and isinstance(v, str)
+            for k, v in (arg.items() if isinstance(arg, dict) else arg)
+        ):
+            raise TypeError(f'{self.__class__.__name__} values must be hashable')
+
+
+class Selector(Immutable):
+    """Selector."""
+
+    __slots__ = (
+        'tag', 'ids', 'classes', 'attributes', 'nth', 'selectors',
+        'relation', 'rel_type', 'contains', 'lang', 'flags', '_hash'
+    )
+
+    tag: SelectorTag | None
+    ids: tuple[str, ...]
+    classes: tuple[str, ...]
+    attributes: tuple[SelectorAttribute, ...]
+    nth: tuple[SelectorNth, ...]
+    selectors: tuple[SelectorList, ...]
+    relation: SelectorList
+    rel_type: str | None
+    contains: tuple[SelectorContains, ...]
+    lang: tuple[SelectorLang, ...]
+    flags: int
+
+    def __init__(
+        self,
+        tag: SelectorTag | None,
+        ids: tuple[str, ...],
+        classes: tuple[str, ...],
+        attributes: tuple[SelectorAttribute, ...],
+        nth: tuple[SelectorNth, ...],
+        selectors: tuple[SelectorList, ...],
+        relation: SelectorList,
+        rel_type: str | None,
+        contains: tuple[SelectorContains, ...],
+        lang: tuple[SelectorLang, ...],
+        flags: int
+    ):
+        """Initialize."""
+
+        super().__init__(
+            tag=tag,
+            ids=ids,
+            classes=classes,
+            attributes=attributes,
+            nth=nth,
+            selectors=selectors,
+            relation=relation,
+            rel_type=rel_type,
+            contains=contains,
+            lang=lang,
+            flags=flags
+        )
+
+
+class SelectorNull(Immutable):
+    """Null Selector."""
+
+    def __init__(self) -> None:
+        """Initialize."""
+
+        super().__init__()
+
+
+class SelectorTag(Immutable):
+    """Selector tag."""
+
+    __slots__ = ("name", "prefix", "_hash")
+
+    name: str
+    prefix: str | None
+
+    def __init__(self, name: str, prefix: str | None) -> None:
+        """Initialize."""
+
+        super().__init__(name=name, prefix=prefix)
+
+
+class SelectorAttribute(Immutable):
+    """Selector attribute rule."""
+
+    __slots__ = ("attribute", "prefix", "pattern", "xml_type_pattern", "_hash")
+
+    attribute: str
+    prefix: str
+    pattern: Pattern[str] | None
+    xml_type_pattern: Pattern[str] | None
+
+    def __init__(
+        self,
+        attribute: str,
+        prefix: str,
+        pattern: Pattern[str] | None,
+        xml_type_pattern: Pattern[str] | None
+    ) -> None:
+        """Initialize."""
+
+        super().__init__(
+            attribute=attribute,
+            prefix=prefix,
+            pattern=pattern,
+            xml_type_pattern=xml_type_pattern
+        )
+
+
+class SelectorContains(Immutable):
+    """Selector contains rule."""
+
+    __slots__ = ("text", "own", "_hash")
+
+    text: tuple[str, ...]
+    own: bool
+
+    def __init__(self, text: Iterable[str], own: bool) -> None:
+        """Initialize."""
+
+        super().__init__(text=tuple(text), own=own)
+
+
+class SelectorNth(Immutable):
+    """Selector nth type."""
+
+    __slots__ = ("a", "n", "b", "of_type", "last", "selectors", "_hash")
+
+    a: int
+    n: bool
+    b: int
+    of_type: bool
+    last: bool
+    selectors: SelectorList
+
+    def __init__(self, a: int, n: bool, b: int, of_type: bool, last: bool, selectors: SelectorList) -> None:
+        """Initialize."""
+
+        super().__init__(
+            a=a,
+            n=n,
+            b=b,
+            of_type=of_type,
+            last=last,
+            selectors=selectors
+        )
+
+
+class SelectorLang(Immutable):
+    """Selector language rules."""
+
+    __slots__ = ("languages", "_hash",)
+
+    languages: tuple[str, ...]
+
+    def __init__(self, languages: Iterable[str]):
+        """Initialize."""
+
+        super().__init__(languages=tuple(languages))
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterator."""
+
+        return iter(self.languages)
+
+    def __len__(self) -> int:  # pragma: no cover
+        """Length."""
+
+        return len(self.languages)
+
+    def __getitem__(self, index: int) -> str:  # pragma: no cover
+        """Get item."""
+
+        return self.languages[index]
+
+
+class SelectorList(Immutable):
+    """Selector list."""
+
+    __slots__ = ("selectors", "is_not", "is_html", "count", "_hash")
+
+    selectors: tuple[Selector | SelectorNull, ...]
+    is_not: bool
+    is_html: bool
+    count: int
+
+    def __init__(
+        self,
+        selectors: Iterable[Selector | SelectorNull] | None = None,
+        is_not: bool = False,
+        is_html: bool = False,
+        count: int = 0,
+    ) -> None:
+        """Initialize."""
+
+        super().__init__(
+            selectors=tuple(selectors) if selectors is not None else (),
+            is_not=is_not,
+            is_html=is_html,
+            count=count
+        )
+
+    def __iter__(self) -> Iterator[Selector | SelectorNull]:
+        """Iterator."""
+
+        return iter(self.selectors)
+
+    def __len__(self) -> int:
+        """Length."""
+
+        return len(self.selectors)
+
+    def __getitem__(self, index: int) -> Selector | SelectorNull:
+        """Get item."""
+
+        return self.selectors[index]
+
+
+def _pickle(p: Any) -> Any:
+    return p.__base__(), tuple([getattr(p, s) for s in p.__slots__[:-1]])
+
+
+def pickle_register(obj: Any) -> None:
+    """Allow object to be pickled."""
+
+    copyreg.pickle(obj, _pickle)
+
+
+pickle_register(Selector)
+pickle_register(SelectorNull)
+pickle_register(SelectorTag)
+pickle_register(SelectorAttribute)
+pickle_register(SelectorContains)
+pickle_register(SelectorNth)
+pickle_register(SelectorLang)
+pickle_register(SelectorList)
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/pretty.py b/.venv/lib/python3.12/site-packages/soupsieve/pretty.py
new file mode 100644
index 0000000000000000000000000000000000000000..37d51d8c2bfa0059654a68ab9bb359225932b1cb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/soupsieve/pretty.py
@@ -0,0 +1,148 @@
+"""
+Format a pretty string of a `SoupSieve` object for easy debugging.
+
+This won't necessarily support all types and such, and definitely
+not support custom outputs.
+
+It is mainly geared towards our types as the `SelectorList`
+object is a beast to look at without some indentation and newlines.
+The format and various output types is fairly known (though it
+hasn't been tested extensively to make sure we aren't missing corners).
+
+Example:
+-------
+```
+>>> import soupsieve as sv
+>>> sv.compile('this > that.class[name=value]').selectors.pretty()
+SelectorList(
+    selectors=(
+        Selector(
+            tag=SelectorTag(
+                name='that',
+                prefix=None),
+            ids=(),
+            classes=(
+                'class',
+                ),
+            attributes=(
+                SelectorAttribute(
+                    attribute='name',
+                    prefix='',
+                    pattern=re.compile(
+                        '^value$'),
+                    xml_type_pattern=None),
+                ),
+            nth=(),
+            selectors=(),
+            relation=SelectorList(
+                selectors=(
+                    Selector(
+                        tag=SelectorTag(
+                            name='this',
+                            prefix=None),
+                        ids=(),
+                        classes=(),
+                        attributes=(),
+                        nth=(),
+                        selectors=(),
+                        relation=SelectorList(
+                            selectors=(),
+                            is_not=False,
+                            is_html=False),
+                        rel_type='>',
+                        contains=(),
+                        lang=(),
+                        flags=0),
+                    ),
+                is_not=False,
+                is_html=False),
+            rel_type=None,
+            contains=(),
+            lang=(),
+            flags=0),
+        ),
+    is_not=False,
+    is_html=False)
+```
+
+"""
+from __future__ import annotations
+import re
+from typing import Any
+
+RE_CLASS = re.compile(r'(?i)[a-z_][_a-z\d.]+\(')
+RE_PARAM = re.compile(r'(?i)[_a-z][_a-z\d]+=')
+RE_EMPTY = re.compile(r'\(\)|\[\]|\{\}')
+RE_LSTRT = re.compile(r'\[')
+RE_DSTRT = re.compile(r'\{')
+RE_TSTRT = re.compile(r'\(')
+RE_LEND = re.compile(r'\]')
+RE_DEND = re.compile(r'\}')
+RE_TEND = re.compile(r'\)')
+RE_INT = re.compile(r'\d+')
+RE_KWORD = re.compile(r'(?i)[_a-z][_a-z\d.]+')
+RE_DQSTR = re.compile(r'"(?:\\.|[^"\\])*"')
+RE_SQSTR = re.compile(r"'(?:\\.|[^'\\])*'")
+RE_SEP = re.compile(r'\s*(,)\s*')
+RE_DSEP = re.compile(r'\s*(:)\s*')
+RE_PSEP = re.compile(r'\s*(\|)\s*')
+
+TOKENS = {
+    'class': RE_CLASS,
+    'param': RE_PARAM,
+    'empty': RE_EMPTY,
+    'lstrt': RE_LSTRT,
+    'dstrt': RE_DSTRT,
+    'tstrt': RE_TSTRT,
+    'lend': RE_LEND,
+    'dend': RE_DEND,
+    'tend': RE_TEND,
+    'sqstr': RE_SQSTR,
+    'sep': RE_SEP,
+    'dsep': RE_DSEP,
+    'psep': RE_PSEP,
+    'int': RE_INT,
+    'kword': RE_KWORD,
+    'dqstr': RE_DQSTR
+}
+
+
+def pretty(obj: Any) -> str:  # pragma: no cover
+    """Make the object output string pretty."""
+
+    sel = str(obj)
+    index = 0
+    end = len(sel) - 1
+    indent = 0
+    output = []
+
+    while index <= end:
+        m = None
+        for k, v in TOKENS.items():
+            m = v.match(sel, index)
+
+            if m:
+                name = k
+                index = m.end(0)
+                if name in ('class', 'lstrt', 'dstrt', 'tstrt'):
+                    indent += 4
+                    output.append(f'{m.group(0)}\n{" " * indent}')
+                elif name in ('param', 'int', 'kword', 'sqstr', 'dqstr', 'empty'):
+                    output.append(m.group(0))
+                elif name in ('lend', 'dend', 'tend'):
+                    indent -= 4
+                    output.append(m.group(0))
+                elif name in ('sep',):
+                    output.append(f'{m.group(1)}\n{" " * indent}')
+                elif name in ('dsep',):
+                    output.append(f'{m.group(1)} ')
+                elif name in ('psep'):
+                    output.append(f' {m.group(1)} ')
+                break
+
+        # We shouldn't hit this, but if we do, store unrecognized character
+        if m is None:  # pragma: no cover
+            output.append(sel[index])
+            index += 1
+
+    return ''.join(output)
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/py.typed b/.venv/lib/python3.12/site-packages/soupsieve/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/soupsieve/util.py b/.venv/lib/python3.12/site-packages/soupsieve/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2e64df22bd3c9259af5273b412d356d6d889c1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/soupsieve/util.py
@@ -0,0 +1,117 @@
+"""Utility."""
+from __future__ import annotations
+from functools import wraps, lru_cache
+import warnings
+import re
+from typing import Callable, Any
+
+DEBUG = 0x00001
+
+RE_PATTERN_LINE_SPLIT = re.compile(r'(?:\r\n|(?!\r\n)[\n\r])|$')
+
+UC_A = ord('A')
+UC_Z = ord('Z')
+
+
+@lru_cache(maxsize=512)
+def lower(string: str) -> str:
+    """Lower."""
+
+    new_string = []
+    for c in string:
+        o = ord(c)
+        new_string.append(chr(o + 32) if UC_A <= o <= UC_Z else c)
+    return ''.join(new_string)
+
+
+class SelectorSyntaxError(Exception):
+    """Syntax error in a CSS selector."""
+
+    def __init__(self, msg: str, pattern: str | None = None, index: int | None = None) -> None:
+        """Initialize."""
+
+        self.line = None
+        self.col = None
+        self.context = None
+
+        if pattern is not None and index is not None:
+            # Format pattern to show line and column position
+            self.context, self.line, self.col = get_pattern_context(pattern, index)
+            msg = f'{msg}\n  line {self.line}:\n{self.context}'
+
+        super().__init__(msg)
+
+
+def deprecated(message: str, stacklevel: int = 2) -> Callable[..., Any]:  # pragma: no cover
+    """
+    Raise a `DeprecationWarning` when wrapped function/method is called.
+
+    Usage:
+
+        @deprecated("This method will be removed in version X; use Y instead.")
+        def some_method()"
+            pass
+    """
+
+    def _wrapper(func: Callable[..., Any]) -> Callable[..., Any]:
+        @wraps(func)
+        def _deprecated_func(*args: Any, **kwargs: Any) -> Any:
+            warnings.warn(
+                f"'{func.__name__}' is deprecated. {message}",
+                category=DeprecationWarning,
+                stacklevel=stacklevel
+            )
+            return func(*args, **kwargs)
+        return _deprecated_func
+    return _wrapper
+
+
+def warn_deprecated(message: str, stacklevel: int = 2) -> None:  # pragma: no cover
+    """Warn deprecated."""
+
+    warnings.warn(
+        message,
+        category=DeprecationWarning,
+        stacklevel=stacklevel
+    )
+
+
+def get_pattern_context(pattern: str, index: int) -> tuple[str, int, int]:
+    """Get the pattern context."""
+
+    last = 0
+    current_line = 1
+    col = 1
+    text = []  # type: list[str]
+    line = 1
+    offset = None  # type: int | None
+
+    # Split pattern by newline and handle the text before the newline
+    for m in RE_PATTERN_LINE_SPLIT.finditer(pattern):
+        linetext = pattern[last:m.start(0)]
+        if not len(m.group(0)) and not len(text):
+            indent = ''
+            offset = -1
+            col = index - last + 1
+        elif last <= index < m.end(0):
+            indent = '--> '
+            offset = (-1 if index > m.start(0) else 0) + 3
+            col = index - last + 1
+        else:
+            indent = '    '
+            offset = None
+        if len(text):
+            # Regardless of whether we are presented with `\r\n`, `\r`, or `\n`,
+            # we will render the output with just `\n`. We will still log the column
+            # correctly though.
+            text.append('\n')
+        text.append(f'{indent}{linetext}')
+        if offset is not None:
+            text.append('\n')
+            text.append(' ' * (col + offset) + '^')
+            line = current_line
+
+        current_line += 1
+        last = m.end(0)
+
+    return ''.join(text), line, col
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/INSTALLER b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/METADATA b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..dc0b7735eb231724e2ee8ff66c2074bcb63f61b2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/METADATA
@@ -0,0 +1,371 @@
+Metadata-Version: 2.4
+Name: supervision
+Version: 0.30.5
+Summary: A set of easy-to-use utils that will come in handy in any Computer Vision project
+Author-email: "Roboflow et al." 
+Maintainer-email: Piotr Skalski 
+License-Expression: MIT
+Project-URL: Documentation, https://supervision.roboflow.com/latest/
+Project-URL: Homepage, https://github.com/roboflow/supervision
+Project-URL: Repository, https://github.com/roboflow/supervision
+Keywords: AI,deep-learning,DL,machine-learning,ML,Roboflow,vision
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+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.14
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: av>=14.2
+Requires-Dist: defusedxml>=0.7.1
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: numpy>=1.21.2
+Requires-Dist: pillow>=9.4
+Requires-Dist: pydeprecate<0.12,>=0.9
+Requires-Dist: pyyaml>=5.3
+Requires-Dist: requests>=2.26
+Requires-Dist: scipy>=1.10
+Requires-Dist: tqdm>=4.62.3
+Provides-Extra: geotiff
+Requires-Dist: rasterio>=1.3; extra == "geotiff"
+Provides-Extra: metrics
+Requires-Dist: pandas>=2; extra == "metrics"
+Dynamic: license-file
+
+
+
+

+📑 Table of Contents
+
+- [👋 Hello](#-hello)
+- [💻 Install](#-install)
+- [🔥 Quickstart](#-quickstart)
+  - [Models](#models)
+  - [Annotators](#annotators)
+  - [Datasets](#datasets)
+- [🎬 Tutorials](#-tutorials)
+- [💜 Built with Supervision](#-built-with-supervision)
+- [📚 Documentation](#-documentation)
+- [🏆 Contribution](#-contribution)
+
+

+
+## 👋 Hello
+
+**We are your essential toolkit for computer vision.** From data loading to real-time zone counting, we provide the building blocks so you can focus on building applications around your models. 🤝
+
+## 💻 Install
+
+Pip install the supervision package in a [**Python>=3.10**](https://www.python.org/) environment.
+
+```bash
+pip install supervision
+```
+
+Read more about conda, mamba, and installing from source in our [guide](https://supervision.roboflow.com/).
+
+## 🔥 Quickstart
+
+### Models
+
+Supervision was designed to be model agnostic. Just plug in any classification, detection, or segmentation model. For your convenience, we have created [connectors](https://supervision.roboflow.com/latest/detection/core/#detections) for the most popular libraries like Ultralytics, Transformers, MMDetection, or Inference. Other integrations, like `rfdetr`, already return `sv.Detections` directly.
+
+Install the optional dependencies for this example with `pip install pillow rfdetr`.
+
+```python
+import supervision as sv
+from PIL import Image
+from rfdetr import RFDETRSmall
+
+image = Image.open("path/to/image.jpg")
+model = RFDETRSmall()
+detections = model.predict(image, threshold=0.5)
+
+len(detections)
+# 5
+```
+
+

+👉 more model connectors
+
+- inference
+
+  Running with [Inference](https://github.com/roboflow/inference) requires a [Roboflow API KEY](https://docs.roboflow.com/api-reference/authentication#retrieve-an-api-key).
+
+  ```python
+  import supervision as sv
+  from PIL import Image
+  from inference import get_model
+
+  image = Image.open("path/to/image.jpg")
+  model = get_model(model_id="rfdetr-small", api_key="ROBOFLOW_API_KEY")
+  result = model.infer(image)[0]
+  detections = sv.Detections.from_inference(result)
+
+  len(detections)
+  # 5
+  ```
+
+

+
+### Annotators
+
+Supervision offers a wide range of highly customizable [annotators](https://supervision.roboflow.com/latest/detection/annotators/), allowing you to compose the perfect visualization for your use case.
+
+```python
+import cv2
+import supervision as sv
+
+image = cv2.imread("path/to/image.jpg")
+# Assuming detections are obtained from a model
+detections = sv.Detections(...)
+
+box_annotator = sv.BoxAnnotator()
+annotated_frame = box_annotator.annotate(scene=image.copy(), detections=detections)
+```
+
+https://github.com/roboflow/supervision/assets/26109316/691e219c-0565-4403-9218-ab5644f39bce
+
+### Datasets
+
+Supervision provides a set of [utils](https://supervision.roboflow.com/latest/datasets/core/) that allow you to load, split, merge, and save datasets in one of the supported formats.
+
+```python
+import supervision as sv
+from roboflow import Roboflow
+
+project = Roboflow().workspace("WORKSPACE_ID").project("PROJECT_ID")
+dataset = project.version("PROJECT_VERSION").download("coco")
+
+ds = sv.DetectionDataset.from_coco(
+    images_directory_path=f"{dataset.location}/train",
+    annotations_path=f"{dataset.location}/train/_annotations.coco.json",
+)
+
+path, image, annotation = ds[0]
+# loads image on demand
+
+for path, image, annotation in ds:
+    # loads image on demand
+    pass
+```
+
+

+👉 more dataset utils
+
+- load
+
+  ```python
+  dataset = sv.DetectionDataset.from_yolo(
+      images_directory_path=...,
+      annotations_directory_path=...,
+      data_yaml_path=...,
+  )
+
+  dataset = sv.DetectionDataset.from_pascal_voc(
+      images_directory_path=...,
+      annotations_directory_path=...,
+  )
+
+  dataset = sv.DetectionDataset.from_coco(
+      images_directory_path=...,
+      annotations_path=...,
+  )
+  ```
+
+- split
+
+  ```python
+  train_dataset, test_dataset = dataset.split(split_ratio=0.7)
+  test_dataset, valid_dataset = test_dataset.split(split_ratio=0.5)
+
+  len(train_dataset), len(test_dataset), len(valid_dataset)
+  # (700, 150, 150)
+  ```
+
+- merge
+
+  ```python
+  ds_1 = sv.DetectionDataset(...)
+  len(ds_1)
+  # 100
+  ds_1.classes
+  # ['dog', 'person']
+
+  ds_2 = sv.DetectionDataset(...)
+  len(ds_2)
+  # 200
+  ds_2.classes
+  # ['cat']
+
+  ds_merged = sv.DetectionDataset.merge([ds_1, ds_2])
+  len(ds_merged)
+  # 300
+  ds_merged.classes
+  # ['cat', 'dog', 'person']
+  ```
+
+- save
+
+  ```python
+  dataset.as_yolo(
+      images_directory_path=...,
+      annotations_directory_path=...,
+      data_yaml_path=...,
+  )
+
+  dataset.as_pascal_voc(
+      images_directory_path=...,
+      annotations_directory_path=...,
+  )
+
+  dataset.as_coco(
+      images_directory_path=...,
+      annotations_path=...,
+  )
+  ```
+
+- convert
+
+  ```python
+  sv.DetectionDataset.from_yolo(
+      images_directory_path=...,
+      annotations_directory_path=...,
+      data_yaml_path=...,
+  ).as_pascal_voc(
+      images_directory_path=...,
+      annotations_directory_path=...,
+  )
+  ```
+
+

+
+## 🎬 Tutorials
+
+Want to learn how to use Supervision? Explore our [how-to guides](https://supervision.roboflow.com/develop/how_to/detect_and_annotate/), [end-to-end examples](https://github.com/roboflow/supervision/tree/0.30.5/examples), [cheatsheet](https://roboflow.github.io/cheatsheet-supervision/), and [cookbooks](https://supervision.roboflow.com/develop/cookbooks/)!
+
+

+
+

+Dwell Time Analysis with Computer Vision | Real-Time Stream Processing
+Dwell Time Analysis with Computer Vision | Real-Time Stream Processing
+
Created: 5 Apr 2024

+
Learn how to use computer vision to analyze wait times and optimize processes. This tutorial covers object detection, tracking, and calculating time spent in designated zones. Use these techniques to improve customer experience in retail, traffic management, or other scenarios.

+
+

+
+

+Speed Estimation & Vehicle Tracking | Computer Vision | Open Source
+Speed Estimation & Vehicle Tracking | Computer Vision | Open Source
+
Created: 11 Jan 2024

+
Learn how to track and estimate the speed of vehicles using YOLO, ByteTrack, and Roboflow Inference. This comprehensive tutorial covers object detection, multi-object tracking, filtering detections, perspective transformation, speed estimation, visualization improvements, and more.

+
+## 💜 Built with Supervision
+
+Did you build something cool using supervision? [Let us know!](https://github.com/roboflow/supervision/discussions/categories/built-with-supervision)
+
+https://user-images.githubusercontent.com/26109316/207858600-ee862b22-0353-440b-ad85-caa0c4777904.mp4
+
+https://github.com/roboflow/supervision/assets/26109316/c9436828-9fbf-4c25-ae8c-60e9c81b3900
+
+https://github.com/roboflow/supervision/assets/26109316/3ac6982f-4943-4108-9b7f-51787ef1a69f
+
+## 📚 Documentation
+
+Visit our [documentation](https://supervision.roboflow.com/) page to learn how supervision can help you build computer vision applications faster and more reliably.
+
+## 🏆 Contribution
+
+We love your input! Please see our [contributing guide](https://github.com/roboflow/supervision/blob/0.30.5/.github/CONTRIBUTING.md) to get started. Thank you 🙏 to all our contributors!
+
+

+    
+      
+    
+

+
+

+
+
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/RECORD b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..d620148114bde271797b5bc853a43b19683023c0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/RECORD
@@ -0,0 +1,204 @@
+supervision-0.30.5.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+supervision-0.30.5.dist-info/METADATA,sha256=MBdGOgq10ROpRSZEauoYeZ8YVGDZt1OiIasYY8gN_Hw,14482
+supervision-0.30.5.dist-info/RECORD,,
+supervision-0.30.5.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision-0.30.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+supervision-0.30.5.dist-info/licenses/LICENSE.md,sha256=crsAn5Yzr5eNpsSfOpJ6g9BN347ZkkkvbypiEi3pUic,1065
+supervision-0.30.5.dist-info/top_level.txt,sha256=nNqFJ85TSqQKq94IDlLXkOAaKzj8ztNvXJQKeU00KcE,12
+supervision/__init__.py,sha256=4RcLn7JSSWlSvFn8UnSIzOIJ_zxaA4BfBVzLSgWoBjE,8244
+supervision/__pycache__/__init__.cpython-312.pyc,,
+supervision/__pycache__/config.cpython-312.pyc,,
+supervision/_cv2/__init__.py,sha256=tTC_T5d7WuQXNqvUW8JAiGPP7Fvp9O8NoVygij9_UCM,8608
+supervision/_cv2/__pycache__/__init__.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_color.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_common.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_components.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_contours.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_drawing.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_geometry.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_image.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_text.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_transform.cpython-312.pyc,,
+supervision/_cv2/__pycache__/_video.cpython-312.pyc,,
+supervision/_cv2/__pycache__/constants.cpython-312.pyc,,
+supervision/_cv2/_color.py,sha256=bEs4rvolS5IIboCAjDfAKU8pCnOmiL8GQE4C8idq0Bg,3526
+supervision/_cv2/_common.py,sha256=2_cmZZpRtIeJA9t2iFC0bkHDmrBqlQpputpYAiRBijs,687
+supervision/_cv2/_components.py,sha256=l-oUkTgP5wD3NW2aVPG7ob3DnKRurgFmxZGQ88W5Dhk,4335
+supervision/_cv2/_contours.py,sha256=Y3IoFy9aG4vmHi6AAA4YbQShCTBIqcmbM6p3mmUoXH0,5617
+supervision/_cv2/_drawing.py,sha256=U_4bfYf8ZRQiRokUN8A0mCkcqYe7yRtdIjzsyArTsS8,9309
+supervision/_cv2/_geometry.py,sha256=T2Fy6zgsG9yYSh_e-feCzBdxrf5RoTGt2vCWGeU2Neo,8556
+supervision/_cv2/_image.py,sha256=tktgOR0GziPM2X4VTm_kHioAzj9KzfHc9Cu2f6toe_0,13710
+supervision/_cv2/_text.py,sha256=fzYo7A0XXfqp03L8w58WWsh7B5TQKiJkb3fLRw-kBcg,4660
+supervision/_cv2/_transform.py,sha256=OaFb6egrO4AIMUqKSL6u1LLIB7KMKTkT3yw4khgp2kI,862
+supervision/_cv2/_video.py,sha256=rUab6Wiy9MrmGIMybyfjlMHV5m3NECVqJmhpnbJeTlw,17052
+supervision/_cv2/constants.py,sha256=zhRt1lXzwA6ooCyF8Y7lFlsxLmqTxs0_tkxBzW0N7c4,733
+supervision/annotators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/annotators/__pycache__/__init__.cpython-312.pyc,,
+supervision/annotators/__pycache__/base.cpython-312.pyc,,
+supervision/annotators/__pycache__/core.cpython-312.pyc,,
+supervision/annotators/__pycache__/utils.cpython-312.pyc,,
+supervision/annotators/base.py,sha256=5NwXexOrZnrVWzTXx32DY2PTjguBEk14i4IyweD4MOg,571
+supervision/annotators/core.py,sha256=dcnYJ5-ecPXXABP4-2XZTbILUXra0ObEuPOgZT1OoYY,137426
+supervision/annotators/utils.py,sha256=02aFx6T4kmxhxpbPvCjLAlPCL8FRj9-BVvzWEDeuOAU,19748
+supervision/assets/__init__.py,sha256=oaFsA_n7Ah8kaH7PevI2u-Ra4-eAQo0MV_8EGNR-Lww,180
+supervision/assets/__pycache__/__init__.cpython-312.pyc,,
+supervision/assets/__pycache__/downloader.cpython-312.pyc,,
+supervision/assets/__pycache__/list.cpython-312.pyc,,
+supervision/assets/downloader.py,sha256=wuiOWY5C2uEywJKRdBCHZByhU-WBr9HM9awIA_AQu3U,4562
+supervision/assets/list.py,sha256=WtlHibdQVuqvOUUvsWDyVIiabGTVhgY-MgGOYyGio8w,4553
+supervision/classification/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/classification/__pycache__/__init__.cpython-312.pyc,,
+supervision/classification/__pycache__/core.cpython-312.pyc,,
+supervision/classification/core.py,sha256=YCmcoEVkEFcEmFUv6NJAMDZr0pX4ykKJXGZYdhfvqWU,6842
+supervision/config.py,sha256=WZEb9OvLkCMEJOejhxP7aLXQQ_Z2ZGy3x3gVL-x6HrU,1483
+supervision/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/dataset/__pycache__/__init__.cpython-312.pyc,,
+supervision/dataset/__pycache__/core.cpython-312.pyc,,
+supervision/dataset/__pycache__/utils.cpython-312.pyc,,
+supervision/dataset/core.py,sha256=BTgj-GWmvrecWkE5uIPfY0i8gEE14L8TJ_qfEjUfUn8,51288
+supervision/dataset/formats/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/dataset/formats/__pycache__/__init__.cpython-312.pyc,,
+supervision/dataset/formats/__pycache__/coco.cpython-312.pyc,,
+supervision/dataset/formats/__pycache__/createml.cpython-312.pyc,,
+supervision/dataset/formats/__pycache__/labelme.cpython-312.pyc,,
+supervision/dataset/formats/__pycache__/pascal_voc.cpython-312.pyc,,
+supervision/dataset/formats/__pycache__/yolo.cpython-312.pyc,,
+supervision/dataset/formats/coco.py,sha256=frDsucEymHGDonvLk6yJaZBX6a7YTT8KQYEhw81V9P0,30097
+supervision/dataset/formats/createml.py,sha256=-ZpWPzluyv5LArXqV11DoWRii5O593_tkOgFiz_VHxY,12729
+supervision/dataset/formats/labelme.py,sha256=dm7lVb70kAb-iz-bbzd-jxyQFjXFRH7gGTaJ6nSOHQQ,15132
+supervision/dataset/formats/pascal_voc.py,sha256=P-l-6jKPUYd-rK-t83nO8NeAkgc4M01jsD8WQ2gQqAw,18373
+supervision/dataset/formats/yolo.py,sha256=ECga7buR-O-kklzYi6utjw3JJAdFjCqF5ydpbKR1Bp8,20138
+supervision/dataset/utils.py,sha256=c31tXzI_xLqaNvc75UNRas5vwE9MRYbdN1ewrFZTRhI,10055
+supervision/detection/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/detection/__pycache__/__init__.cpython-312.pyc,,
+supervision/detection/__pycache__/_geometry_dispatch.cpython-312.pyc,,
+supervision/detection/__pycache__/compact_mask.cpython-312.pyc,,
+supervision/detection/__pycache__/core.cpython-312.pyc,,
+supervision/detection/__pycache__/line_zone.cpython-312.pyc,,
+supervision/detection/__pycache__/vlm.cpython-312.pyc,,
+supervision/detection/_geometry_dispatch.py,sha256=MShDimrCQUFIUpK9UJDdC50d6CLzTBimoyh7NxOgJkI,4169
+supervision/detection/compact_mask.py,sha256=CJvBhHHT_nbG9I739H6Z5vncVWfONm-GFYEkrx_crhM,65289
+supervision/detection/core.py,sha256=0VOv_ZdhH3R39aviS11ll93_P7xF8pGaLwPympCX5xE,137442
+supervision/detection/line_zone.py,sha256=7biteAT8VyCtCcDbPwiK8hRN3PB-VTArNfP-bviorbE,35786
+supervision/detection/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/detection/tools/__pycache__/__init__.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/csv_sink.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/inference_slicer.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/json_sink.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/polygon_zone.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/smoother.cpython-312.pyc,,
+supervision/detection/tools/__pycache__/transformers.cpython-312.pyc,,
+supervision/detection/tools/csv_sink.py,sha256=zPLZz4wq2eWqR9ZvfwVe2FPU-cgEPz-MT5msk8Y5ums,10226
+supervision/detection/tools/inference_slicer.py,sha256=xq5t8rb2DeJyiARtOApuVel4p1ZKKZuCRmi71z47Bvc,39600
+supervision/detection/tools/json_sink.py,sha256=yyvY6ozqfEf63LniE7wHdmu6P77DpzXONMshjZScXvI,7623
+supervision/detection/tools/polygon_zone.py,sha256=oodHebXdUFifRTxe4lRz7D1F8tCjcCb3RPxj55ZY22c,10836
+supervision/detection/tools/smoother.py,sha256=Nn0O_Mxi6MspTat-1WqDYdpNxp6_MAeGaZu_hcZnOPU,9819
+supervision/detection/tools/transformers.py,sha256=CpfvTXiW8aRIwV_-AlWj45Fwo1RiWyF7CO8reweaL3U,10897
+supervision/detection/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/detection/utils/__pycache__/__init__.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/_typing.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/boxes.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/converters.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/internal.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/iou_and_nms.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/masks.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/polygons.cpython-312.pyc,,
+supervision/detection/utils/__pycache__/vlms.cpython-312.pyc,,
+supervision/detection/utils/_typing.py,sha256=EAeOnedx6Rx2MVLT8mdIOOKDj_rv-7R4gRdi8JKXqOo,264
+supervision/detection/utils/boxes.py,sha256=AC5dIvGYHPwL41wZ6huEEi98KF9JaSXUVm_P1yr9Z6I,22742
+supervision/detection/utils/converters.py,sha256=Y6yecvcUfBnWc73l6UTy2OIRNbI-ZgUeLSBcUt4Bex0,27878
+supervision/detection/utils/internal.py,sha256=a0T6AP4KpGcbVexq0Uzge80A92b76M5AA0Gd0aiDOSY,30748
+supervision/detection/utils/iou_and_nms.py,sha256=ywCWE8DGaIJfw60nEFvyki86gzp2s2bcsdfJVDQTOdw,73424
+supervision/detection/utils/masks.py,sha256=77KQrRfq7q9iux4UgU55AWq1MeCMtC759vla-jrq3Eo,23510
+supervision/detection/utils/polygons.py,sha256=mFmVgzJujuht95CzOlen4VwJf7EWSqojSkutFzwS_DQ,6227
+supervision/detection/utils/vlms.py,sha256=NlmiM2zDR_GUdw1hFT53NCiNwI4WRKf5qBVG8UCG9Lg,3018
+supervision/detection/vlm.py,sha256=KPIjBma_nQbIo_tmEOUcuSLUs_brP-87yUCs71ZVKr4,35251
+supervision/draw/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/draw/__pycache__/__init__.cpython-312.pyc,,
+supervision/draw/__pycache__/base.cpython-312.pyc,,
+supervision/draw/__pycache__/color.cpython-312.pyc,,
+supervision/draw/__pycache__/utils.cpython-312.pyc,,
+supervision/draw/base.py,sha256=N4lHOr-t-5u0tJ8wTefXAQDPh9_3glU-L2qXLLj25UY,420
+supervision/draw/color.py,sha256=POJUJhm2RRRHZ7kxyD8V6CndeBmQhsZzz8ACGOD7dVg,17209
+supervision/draw/utils.py,sha256=fRgH9ylcJm6_Lr5CBaCQB4NwPVlYj3xcHfZulgDyCeQ,17211
+supervision/geometry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/geometry/__pycache__/__init__.cpython-312.pyc,,
+supervision/geometry/__pycache__/core.cpython-312.pyc,,
+supervision/geometry/__pycache__/utils.cpython-312.pyc,,
+supervision/geometry/core.py,sha256=DMe_thCf9Hu49os9Z-CjOZEIxLPOW-8HZNdvjCtlA7g,5653
+supervision/geometry/utils.py,sha256=dlAEMp7Am1spj4uzbPuE4WeuPgvbpYBOe4fcGH1ogyI,1786
+supervision/key_points/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/key_points/__pycache__/__init__.cpython-312.pyc,,
+supervision/key_points/__pycache__/annotators.cpython-312.pyc,,
+supervision/key_points/__pycache__/core.cpython-312.pyc,,
+supervision/key_points/__pycache__/skeletons.cpython-312.pyc,,
+supervision/key_points/annotators.py,sha256=61VlOP2z4hS82zo5eYIoTXytdJuKRyneckd7amGBtxw,38984
+supervision/key_points/core.py,sha256=lZeButuAQoiKBVCHuoA0eab0VNtoeH1yVLHZ1WeRfQg,58170
+supervision/key_points/skeletons.py,sha256=tR-jTLI2KJwjpK3XKqbH9clYl9S_7IOIn7wMXgmrO3Y,51609
+supervision/keypoint/__init__.py,sha256=_gXhuYGKySHYGrnbsFFuHE-NzgGakHGaMfyOb1tBYrk,393
+supervision/keypoint/__pycache__/__init__.cpython-312.pyc,,
+supervision/keypoint/__pycache__/annotators.cpython-312.pyc,,
+supervision/keypoint/__pycache__/core.cpython-312.pyc,,
+supervision/keypoint/annotators.py,sha256=o5Ioj69uAt-7TeOOZI3ryy7m6uYElHppVG1FRBTe0dc,390
+supervision/keypoint/core.py,sha256=cQ-EhJ9ez_O2xQ3M9b3HO2q6sgtmGf9jRAJJSRqp2kk,297
+supervision/metrics/__init__.py,sha256=chkwodiDqgcUHlCIPq3hd857Iz0cZv4UxNL4vwVVvjw,1044
+supervision/metrics/__pycache__/__init__.cpython-312.pyc,,
+supervision/metrics/__pycache__/core.cpython-312.pyc,,
+supervision/metrics/__pycache__/detection.cpython-312.pyc,,
+supervision/metrics/__pycache__/f1_score.cpython-312.pyc,,
+supervision/metrics/__pycache__/mean_average_precision.cpython-312.pyc,,
+supervision/metrics/__pycache__/mean_average_recall.cpython-312.pyc,,
+supervision/metrics/__pycache__/precision.cpython-312.pyc,,
+supervision/metrics/__pycache__/recall.cpython-312.pyc,,
+supervision/metrics/core.py,sha256=ajlMmN7Y4jICzxw6WdfdqxLhNE4hquVAWKEx8lRlrqg,2271
+supervision/metrics/detection.py,sha256=H6sR5mn0BzTuXCRA5eruczPC3zqUxmdO1isbo_0jgA4,61778
+supervision/metrics/f1_score.py,sha256=4n5wpuo8gD8TKdqYnLuB06K1dfGRurjK801JjsBn4qQ,33397
+supervision/metrics/mean_average_precision.py,sha256=rCUSxqu7wnbL3YJGm8GcvSP9OGMwsrftXo6DCL4rvdE,67626
+supervision/metrics/mean_average_recall.py,sha256=GgEuy0XUGENPISVWLpGSKbYcBi-aZEEkZkl1wx7xQCo,31516
+supervision/metrics/precision.py,sha256=EBz2xhpf5Vo6aJYGd8yx1xYB3WCRFekf1pmPzbBMfmU,33300
+supervision/metrics/recall.py,sha256=8dFjzDFa812dQNwphrsMrYGG3GdCxHn6N-kLSqCB8dg,34764
+supervision/metrics/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/metrics/utils/__pycache__/__init__.cpython-312.pyc,,
+supervision/metrics/utils/__pycache__/matching.cpython-312.pyc,,
+supervision/metrics/utils/__pycache__/object_size.cpython-312.pyc,,
+supervision/metrics/utils/__pycache__/utils.cpython-312.pyc,,
+supervision/metrics/utils/matching.py,sha256=c_2IuLrR1G6wksQik1ndi3wn6dORg3QEcJbukLBllRU,3699
+supervision/metrics/utils/object_size.py,sha256=k-Ui4_KFHe7Ut5XKxR9iihsz7feJ3WDwvP7G6PTDg9s,10787
+supervision/metrics/utils/utils.py,sha256=vbDk_5fdjnh90-9ApfrGWI-kbbp43zQDM-b-Q7kXAF0,317
+supervision/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/tracker/__init__.py,sha256=ZHw2RvnyqhXOXfFuZLIAuPMOc7FpO6brQfpJtjWAY6Q,134
+supervision/tracker/__pycache__/__init__.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/tracker/byte_tracker/__pycache__/__init__.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__pycache__/core.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__pycache__/kalman_filter.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__pycache__/matching.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__pycache__/single_object_track.cpython-312.pyc,,
+supervision/tracker/byte_tracker/__pycache__/utils.cpython-312.pyc,,
+supervision/tracker/byte_tracker/core.py,sha256=AYkR3z3WAMegq70FkTixFhhaRY8rSHe0wf0y9cNByQ0,16117
+supervision/tracker/byte_tracker/kalman_filter.py,sha256=CPIyH-kkhMgQUIj6llMqdpUq4WoL6gVo8OJbAfOc-5Q,6644
+supervision/tracker/byte_tracker/matching.py,sha256=PLQoLXePvwDXjl6hzGwvHO9utbCtVGKM36ejbPzGSgg,2961
+supervision/tracker/byte_tracker/single_object_track.py,sha256=G7o8NHHfGxzwooz3LPoZXhNc81q8u__N-D-YY0dLM3E,6556
+supervision/tracker/byte_tracker/utils.py,sha256=RrAI277cdkZ5bu7LdciUxlvMIDaAvcNwMfIE-vCIxww,876
+supervision/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+supervision/utils/__pycache__/__init__.cpython-312.pyc,,
+supervision/utils/__pycache__/conversion.cpython-312.pyc,,
+supervision/utils/__pycache__/file.cpython-312.pyc,,
+supervision/utils/__pycache__/image.cpython-312.pyc,,
+supervision/utils/__pycache__/image_window.cpython-312.pyc,,
+supervision/utils/__pycache__/internal.cpython-312.pyc,,
+supervision/utils/__pycache__/iterables.cpython-312.pyc,,
+supervision/utils/__pycache__/logger.cpython-312.pyc,,
+supervision/utils/__pycache__/notebook.cpython-312.pyc,,
+supervision/utils/__pycache__/video.cpython-312.pyc,,
+supervision/utils/conversion.py,sha256=0Nzd3Yu9f8ksy3Vybssh9lKo0c40aj4g_E3jx4cZDqw,7313
+supervision/utils/file.py,sha256=Xz4Z8iVmNz6AxNJRw4-L3-8F5V-pcsr3wOfa3ahxobQ,10050
+supervision/utils/image.py,sha256=_p5o0gubouDZH0hA-DvasX_g840ZgZZEnYGpDauXyG4,40242
+supervision/utils/image_window.py,sha256=LCyQlkwCx85I4NdxQ0X4URsXwYv7G8KiyXhpdMHoz2E,12510
+supervision/utils/internal.py,sha256=ZYLO0Yv6gC3ZxhtFO5VWEEV9gcg2B8rk_Fix6h4Qc2o,6600
+supervision/utils/iterables.py,sha256=33Btb3nzYrL-ikwecRoi-IfXhnDfpbmrAbwB7M2Jy84,2882
+supervision/utils/logger.py,sha256=I9NKKsd_DvsrltS89vaz_knMJRmO8abfxffJCCc692o,2005
+supervision/utils/notebook.py,sha256=NBjfRf6eZSk319BuHeo4-nEP3l2FbqvSgFELtBVZcyw,3916
+supervision/utils/video.py,sha256=qCbOQ4MT_jmX3vXS8Hp431dDbyiDA39ac4SWxu6Lk_8,22901
+supervision/validators/__init__.py,sha256=Q-9YdbaF4sDmGktSA7n3K6mH0EjqxJmoe3-oHCAj0yg,11443
+supervision/validators/__pycache__/__init__.cpython-312.pyc,,
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/REQUESTED b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/WHEEL b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..13013d7b49be5a84c3ee5931b06285b9553cf5d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/licenses/LICENSE.md b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/licenses/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..ab7110e8f2f73a80097d40f3b6ba6da6ce3d942f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/licenses/LICENSE.md
@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Roboflow
+
+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.
diff --git a/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/top_level.txt b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..43b821deee22603d6da796ef2da66d28a7f65d8c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision-0.30.5.dist-info/top_level.txt
@@ -0,0 +1 @@
+supervision
diff --git a/.venv/lib/python3.12/site-packages/supervision/__init__.py b/.venv/lib/python3.12/site-packages/supervision/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..77f4e9952473719e582cb425e22bcac5c7f37219
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/__init__.py
@@ -0,0 +1,317 @@
+import importlib.metadata as importlib_metadata
+from typing import TYPE_CHECKING, Any
+
+try:
+    # This will read version from pyproject.toml
+    __version__ = importlib_metadata.version(__package__ or __name__)
+except importlib_metadata.PackageNotFoundError:
+    __version__ = "development"
+
+from supervision.annotators.core import (
+    BackgroundOverlayAnnotator,
+    BlurAnnotator,
+    BoxAnnotator,
+    BoxCornerAnnotator,
+    CircleAnnotator,
+    ColorAnnotator,
+    ComparisonAnnotator,
+    CropAnnotator,
+    DotAnnotator,
+    EllipseAnnotator,
+    HaloAnnotator,
+    HeatMapAnnotator,
+    IconAnnotator,
+    LabelAnnotator,
+    MaskAnnotator,
+    OrientedBoxAnnotator,
+    PercentageBarAnnotator,
+    PixelateAnnotator,
+    PolygonAnnotator,
+    RichLabelAnnotator,
+    RoundBoxAnnotator,
+    TraceAnnotator,
+    TriangleAnnotator,
+)
+from supervision.annotators.utils import (
+    ColorLookup,
+    hex_to_rgba,
+    is_valid_hex,
+    rgba_to_hex,
+)
+from supervision.classification.core import Classifications
+from supervision.dataset.core import (
+    BaseDataset,
+    ClassificationDataset,
+    DetectionDataset,
+)
+from supervision.dataset.formats.coco import get_coco_class_index_mapping
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.line_zone import (
+    LineZone,
+    LineZoneAnnotator,
+    LineZoneAnnotatorMulticlass,
+)
+from supervision.detection.tools.csv_sink import CSVSink
+from supervision.detection.tools.inference_slicer import (
+    InferenceSlicer,
+    WindowedRasterDataset,
+)
+from supervision.detection.tools.json_sink import JSONSink
+from supervision.detection.tools.polygon_zone import PolygonZone, PolygonZoneAnnotator
+from supervision.detection.tools.smoother import DetectionsSmoother
+from supervision.detection.utils.boxes import (
+    clip_boxes,
+    denormalize_boxes,
+    move_boxes,
+    pad_boxes,
+    scale_boxes,
+    xyxyxyxy_to_xyxy,
+)
+from supervision.detection.utils.converters import (
+    is_compressed_rle,
+    mask_to_polygons,
+    mask_to_rle,
+    mask_to_xyxy,
+    polygon_to_mask,
+    polygon_to_xyxy,
+    rle_to_mask,
+    xcycwh_to_xyxy,
+    xywh_to_xyxy,
+    xyxy_to_mask,
+    xyxy_to_polygons,
+    xyxy_to_xcycarh,
+    xyxy_to_xywh,
+)
+from supervision.detection.utils.iou_and_nms import (
+    OverlapFilter,
+    OverlapMetric,
+    box_iou,
+    box_iou_batch,
+    box_iou_batch_with_jaccard,
+    box_non_max_merge,
+    box_non_max_suppression,
+    box_soft_non_max_suppression,
+    mask_iou_batch,
+    mask_non_max_merge,
+    mask_non_max_suppression,
+    mask_soft_non_max_suppression,
+    oriented_box_iou_batch,
+    oriented_box_non_max_merge,
+    oriented_box_non_max_suppression,
+)
+from supervision.detection.utils.masks import (
+    calculate_masks_centroids,
+    contains_holes,
+    contains_multiple_segments,
+    filter_segments_by_distance,
+    mask_to_roi,
+    move_masks,
+)
+from supervision.detection.utils.polygons import (
+    approximate_polygon,
+    filter_polygons_by_area,
+)
+from supervision.detection.utils.vlms import edit_distance, fuzzy_match_index
+from supervision.detection.vlm import LMM, VLM
+from supervision.draw.color import Color, ColorPalette
+from supervision.draw.utils import (
+    calculate_optimal_line_thickness,
+    calculate_optimal_text_scale,
+    draw_filled_polygon,
+    draw_filled_rectangle,
+    draw_image,
+    draw_line,
+    draw_polygon,
+    draw_rectangle,
+    draw_text,
+)
+from supervision.geometry.core import Point, Position, Rect
+from supervision.geometry.utils import get_polygon_center
+from supervision.key_points.annotators import (
+    EdgeAnnotator,
+    VertexAnnotator,
+    VertexEllipseAnnotator,
+    VertexEllipseAreaAnnotator,
+    VertexEllipseHaloAnnotator,
+    VertexEllipseOutlineAnnotator,
+    VertexLabelAnnotator,
+)
+from supervision.key_points.core import KeyPoints
+from supervision.metrics.detection import ConfusionMatrix, MeanAveragePrecision
+from supervision.utils.conversion import cv2_to_pillow, pillow_to_cv2
+from supervision.utils.file import list_files_with_extensions
+from supervision.utils.image import (
+    ImageSink,
+    crop_image,
+    get_image_resolution_wh,
+    grayscale_image,
+    letterbox_image,
+    load_image_from_url,
+    overlay_image,
+    resize_image,
+    scale_image,
+    tint_image,
+)
+from supervision.utils.image_window import ImageWindow
+from supervision.utils.notebook import plot_image, plot_images_grid
+from supervision.utils.video import (
+    FPSMonitor,
+    VideoInfo,
+    VideoSink,
+    get_video_frames_generator,
+    process_video,
+)
+
+if TYPE_CHECKING:
+    from supervision.tracker.byte_tracker.core import ByteTrack
+
+__all__ = [
+    "LMM",
+    "VLM",
+    "BackgroundOverlayAnnotator",
+    "BaseDataset",
+    "BlurAnnotator",
+    "BoxAnnotator",
+    "BoxCornerAnnotator",
+    "ByteTrack",
+    "CSVSink",
+    "CircleAnnotator",
+    "ClassificationDataset",
+    "Classifications",
+    "Color",
+    "ColorAnnotator",
+    "ColorLookup",
+    "ColorPalette",
+    "CompactMask",
+    "ComparisonAnnotator",
+    "ConfusionMatrix",
+    "CropAnnotator",
+    "DetectionDataset",
+    "Detections",
+    "DetectionsSmoother",
+    "DotAnnotator",
+    "EdgeAnnotator",
+    "EllipseAnnotator",
+    "FPSMonitor",
+    "HaloAnnotator",
+    "HeatMapAnnotator",
+    "IconAnnotator",
+    "ImageSink",
+    "ImageWindow",
+    "InferenceSlicer",
+    "JSONSink",
+    "KeyPoints",
+    "LabelAnnotator",
+    "LineZone",
+    "LineZoneAnnotator",
+    "LineZoneAnnotatorMulticlass",
+    "MaskAnnotator",
+    "MeanAveragePrecision",
+    "OrientedBoxAnnotator",
+    "OverlapFilter",
+    "OverlapMetric",
+    "PercentageBarAnnotator",
+    "PixelateAnnotator",
+    "Point",
+    "PolygonAnnotator",
+    "PolygonZone",
+    "PolygonZoneAnnotator",
+    "Position",
+    "Rect",
+    "RichLabelAnnotator",
+    "RoundBoxAnnotator",
+    "TraceAnnotator",
+    "TriangleAnnotator",
+    "VertexAnnotator",
+    "VertexEllipseAnnotator",
+    "VertexEllipseAreaAnnotator",
+    "VertexEllipseHaloAnnotator",
+    "VertexEllipseOutlineAnnotator",
+    "VertexLabelAnnotator",
+    "VideoInfo",
+    "VideoSink",
+    "WindowedRasterDataset",
+    "approximate_polygon",
+    "box_iou",
+    "box_iou_batch",
+    "box_iou_batch_with_jaccard",
+    "box_non_max_merge",
+    "box_non_max_suppression",
+    "box_soft_non_max_suppression",
+    "calculate_masks_centroids",
+    "calculate_optimal_line_thickness",
+    "calculate_optimal_text_scale",
+    "clip_boxes",
+    "contains_holes",
+    "contains_multiple_segments",
+    "crop_image",
+    "cv2_to_pillow",
+    "denormalize_boxes",
+    "draw_filled_polygon",
+    "draw_filled_rectangle",
+    "draw_image",
+    "draw_line",
+    "draw_polygon",
+    "draw_rectangle",
+    "draw_text",
+    "edit_distance",
+    "filter_polygons_by_area",
+    "filter_segments_by_distance",
+    "fuzzy_match_index",
+    "get_coco_class_index_mapping",
+    "get_image_resolution_wh",
+    "get_polygon_center",
+    "get_video_frames_generator",
+    "grayscale_image",
+    "hex_to_rgba",
+    "is_compressed_rle",
+    "is_valid_hex",
+    "letterbox_image",
+    "list_files_with_extensions",
+    "load_image_from_url",
+    "mask_iou_batch",
+    "mask_non_max_merge",
+    "mask_non_max_suppression",
+    "mask_soft_non_max_suppression",
+    "mask_to_polygons",
+    "mask_to_rle",
+    "mask_to_roi",
+    "mask_to_xyxy",
+    "move_boxes",
+    "move_masks",
+    "oriented_box_iou_batch",
+    "oriented_box_non_max_merge",
+    "oriented_box_non_max_suppression",
+    "overlay_image",
+    "pad_boxes",
+    "pillow_to_cv2",
+    "plot_image",
+    "plot_images_grid",
+    "polygon_to_mask",
+    "polygon_to_xyxy",
+    "process_video",
+    "resize_image",
+    "rgba_to_hex",
+    "rle_to_mask",
+    "scale_boxes",
+    "scale_image",
+    "tint_image",
+    "xcycwh_to_xyxy",
+    "xywh_to_xyxy",
+    "xyxy_to_mask",
+    "xyxy_to_polygons",
+    "xyxy_to_xcycarh",
+    "xyxy_to_xywh",
+    "xyxyxyxy_to_xyxy",
+]
+
+
+def __getattr__(name: str) -> Any:
+    """Lazily resolve deprecated compatibility exports."""
+    if name == "ByteTrack":
+        from supervision.tracker.byte_tracker.core import ByteTrack as byte_track
+
+        globals()[name] = byte_track
+        return byte_track
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/.venv/lib/python3.12/site-packages/supervision/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..189605247dbb1d84a823525d4d4fa6ab9707dd10
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/__pycache__/config.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/__pycache__/config.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b524f1e1b5b7e90602e9df4630d6a7a35287f7a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/__pycache__/config.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__init__.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7948ed3387a48fab401e7cc365e836539d80e947
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/__init__.py
@@ -0,0 +1,302 @@
+"""Private OpenCV compatibility surface used by Supervision."""
+
+from __future__ import annotations
+
+import warnings
+from typing import Any
+
+import numpy.typing as npt
+
+from supervision._cv2._color import _cvt_color, _merge, _split
+from supervision._cv2._common import BackendUnavailableError
+from supervision._cv2._components import (
+    _connected_components,
+    _connected_components_with_stats,
+)
+from supervision._cv2._contours import _find_contours
+from supervision._cv2._drawing import (
+    _circle,
+    _draw_contours,
+    _ellipse,
+    _fill_poly,
+    _line,
+    _polylines,
+    _rectangle,
+)
+from supervision._cv2._geometry import (
+    _approx_poly_dp,
+    _contour_area,
+    _intersect_convex_convex,
+)
+from supervision._cv2._image import (
+    _add_weighted,
+    _convert_scale_abs,
+    _copy_make_border,
+    _flip,
+    _imdecode,
+    _imencode,
+    _imread,
+    _imwrite,
+    _mean,
+    _resize,
+)
+from supervision._cv2._text import _get_text_size, _put_text
+from supervision._cv2._transform import _blur
+from supervision._cv2._video import (
+    _video_writer_fourcc,
+    _VideoCapture,
+    _VideoWriter,
+)
+from supervision._cv2.constants import (
+    _BORDER_CONSTANT,
+    _CAP_PROP_FPS,
+    _CAP_PROP_FRAME_COUNT,
+    _CAP_PROP_FRAME_HEIGHT,
+    _CAP_PROP_FRAME_WIDTH,
+    _CAP_PROP_POS_FRAMES,
+    _CC_STAT_AREA,
+    _CHAIN_APPROX_SIMPLE,
+    _COLOR_BGR2GRAY,
+    _COLOR_BGR2RGB,
+    _COLOR_GRAY2BGR,
+    _COLOR_HSV2BGR,
+    _COLOR_RGB2BGR,
+    _FONT_HERSHEY_COMPLEX,
+    _FONT_HERSHEY_COMPLEX_SMALL,
+    _FONT_HERSHEY_DUPLEX,
+    _FONT_HERSHEY_PLAIN,
+    _FONT_HERSHEY_SCRIPT_COMPLEX,
+    _FONT_HERSHEY_SCRIPT_SIMPLEX,
+    _FONT_HERSHEY_SIMPLEX,
+    _FONT_HERSHEY_TRIPLEX,
+    _FONT_ITALIC,
+    _IMREAD_COLOR,
+    _IMREAD_UNCHANGED,
+    _INTER_LINEAR,
+    _INTER_NEAREST,
+    _LINE_4,
+    _LINE_8,
+    _LINE_AA,
+    _RETR_TREE,
+)
+
+try:
+    import cv2
+except (ImportError, OSError):
+    _IS_CV2_AVAILABLE = False
+else:
+    _IS_CV2_AVAILABLE = True
+
+if _IS_CV2_AVAILABLE:
+    from cv2 import (  # type: ignore[attr-defined]
+        BORDER_CONSTANT,
+        CAP_PROP_FPS,
+        CAP_PROP_FRAME_COUNT,
+        CAP_PROP_FRAME_HEIGHT,
+        CAP_PROP_FRAME_WIDTH,
+        CAP_PROP_POS_FRAMES,
+        CC_STAT_AREA,
+        COLOR_BGR2GRAY,
+        COLOR_BGR2RGB,
+        COLOR_GRAY2BGR,
+        COLOR_HSV2BGR,
+        COLOR_RGB2BGR,
+        FONT_HERSHEY_COMPLEX,
+        FONT_HERSHEY_COMPLEX_SMALL,
+        FONT_HERSHEY_DUPLEX,
+        FONT_HERSHEY_PLAIN,
+        FONT_HERSHEY_SCRIPT_COMPLEX,
+        FONT_HERSHEY_SCRIPT_SIMPLEX,
+        FONT_HERSHEY_SIMPLEX,
+        FONT_HERSHEY_TRIPLEX,
+        FONT_ITALIC,
+        IMREAD_COLOR,
+        IMREAD_UNCHANGED,
+        INTER_LINEAR,
+        INTER_NEAREST,
+        LINE_4,
+        LINE_8,
+        LINE_AA,
+        VideoCapture,
+        VideoWriter,
+        VideoWriter_fourcc,  # type: ignore[attr-defined]
+        addWeighted,
+        approxPolyDP,
+        blur,
+        circle,
+        connectedComponents,
+        connectedComponentsWithStats,
+        contourArea,
+        convertScaleAbs,
+        copyMakeBorder,
+        cvtColor,
+        drawContours,
+        ellipse,
+        fillPoly,
+        flip,
+        getTextSize,
+        imdecode,
+        imencode,
+        imread,
+        imwrite,
+        intersectConvexConvex,
+        line,
+        mean,
+        merge,
+        polylines,
+        putText,
+        rectangle,
+        resize,
+        split,
+    )
+    from cv2 import (
+        findContours as _find_contours_impl,
+    )
+
+    BACKEND_NAME = "opencv"
+else:
+    BACKEND_NAME = "fallback"
+
+    warnings.warn(
+        "OpenCV (`opencv-python`) is not installed; supervision is using its "
+        "pure NumPy fallback backend instead. Some operations may be slower "
+        "or behave slightly differently. Install `opencv-python` for full "
+        "performance and compatibility.",
+        stacklevel=2,
+    )
+
+    BORDER_CONSTANT = _BORDER_CONSTANT
+    CAP_PROP_FPS = _CAP_PROP_FPS
+    CAP_PROP_FRAME_COUNT = _CAP_PROP_FRAME_COUNT
+    CAP_PROP_FRAME_HEIGHT = _CAP_PROP_FRAME_HEIGHT
+    CAP_PROP_FRAME_WIDTH = _CAP_PROP_FRAME_WIDTH
+    CAP_PROP_POS_FRAMES = _CAP_PROP_POS_FRAMES
+    CC_STAT_AREA = _CC_STAT_AREA
+    COLOR_BGR2GRAY = _COLOR_BGR2GRAY
+    COLOR_BGR2RGB = _COLOR_BGR2RGB
+    COLOR_GRAY2BGR = _COLOR_GRAY2BGR
+    COLOR_HSV2BGR = _COLOR_HSV2BGR
+    COLOR_RGB2BGR = _COLOR_RGB2BGR
+    FONT_HERSHEY_COMPLEX = _FONT_HERSHEY_COMPLEX
+    FONT_HERSHEY_COMPLEX_SMALL = _FONT_HERSHEY_COMPLEX_SMALL
+    FONT_HERSHEY_DUPLEX = _FONT_HERSHEY_DUPLEX
+    FONT_HERSHEY_PLAIN = _FONT_HERSHEY_PLAIN
+    FONT_HERSHEY_SCRIPT_COMPLEX = _FONT_HERSHEY_SCRIPT_COMPLEX
+    FONT_HERSHEY_SCRIPT_SIMPLEX = _FONT_HERSHEY_SCRIPT_SIMPLEX
+    FONT_HERSHEY_SIMPLEX = _FONT_HERSHEY_SIMPLEX
+    FONT_HERSHEY_TRIPLEX = _FONT_HERSHEY_TRIPLEX
+    FONT_ITALIC = _FONT_ITALIC
+    IMREAD_COLOR = _IMREAD_COLOR
+    IMREAD_UNCHANGED = _IMREAD_UNCHANGED
+    INTER_LINEAR = _INTER_LINEAR
+    INTER_NEAREST = _INTER_NEAREST
+    LINE_4 = _LINE_4
+    LINE_8 = _LINE_8
+    LINE_AA = _LINE_AA
+
+    # Fallback implementations when cv2 is not available. Suppress type errors because
+    # fallback types differ from cv2 types, but are functionally equivalent.
+    VideoCapture = _VideoCapture  # type: ignore[assignment,misc]
+    VideoWriter = _VideoWriter  # type: ignore[assignment,misc]
+    VideoWriter_fourcc = _video_writer_fourcc  # type: ignore[assignment]
+    addWeighted = _add_weighted  # type: ignore[assignment]
+    approxPolyDP = _approx_poly_dp  # type: ignore[assignment]
+    blur = _blur  # type: ignore[assignment]
+    circle = _circle  # type: ignore[assignment]
+    connectedComponents = _connected_components  # type: ignore[assignment]
+    connectedComponentsWithStats = _connected_components_with_stats  # type: ignore[assignment]
+    contourArea = _contour_area  # type: ignore[assignment]
+    convertScaleAbs = _convert_scale_abs  # type: ignore[assignment]
+    copyMakeBorder = _copy_make_border  # type: ignore[assignment]
+    cvtColor = _cvt_color  # type: ignore[assignment]
+    drawContours = _draw_contours  # type: ignore[assignment]
+    ellipse = _ellipse  # type: ignore[assignment]
+    fillPoly = _fill_poly  # type: ignore[assignment]
+    _find_contours_impl = _find_contours
+    flip = _flip  # type: ignore[assignment]
+    getTextSize = _get_text_size  # type: ignore[assignment]
+    imdecode = _imdecode  # type: ignore[assignment]
+    imencode = _imencode  # type: ignore[assignment]
+    imread = _imread  # type: ignore[assignment]
+    imwrite = _imwrite  # type: ignore[assignment]
+    intersectConvexConvex = _intersect_convex_convex  # type: ignore[assignment]
+    line = _line  # type: ignore[assignment]
+    mean = _mean  # type: ignore[assignment]
+    merge = _merge  # type: ignore[assignment]
+    polylines = _polylines  # type: ignore[assignment]
+    putText = _put_text  # type: ignore[assignment]
+    rectangle = _rectangle  # type: ignore[assignment]
+    resize = _resize  # type: ignore[assignment]
+    split = _split  # type: ignore[assignment]
+
+
+def find_contours(image: npt.NDArray[Any]) -> list[npt.NDArray[Any]]:
+    """Return the contour geometry required by mask-to-polygon conversion."""
+    contours, _ = _find_contours_impl(image, _RETR_TREE, _CHAIN_APPROX_SIMPLE)
+    return list(contours)
+
+
+__all__ = [
+    "BACKEND_NAME",
+    "BORDER_CONSTANT",
+    "CAP_PROP_FPS",
+    "CAP_PROP_FRAME_COUNT",
+    "CAP_PROP_FRAME_HEIGHT",
+    "CAP_PROP_FRAME_WIDTH",
+    "CAP_PROP_POS_FRAMES",
+    "CC_STAT_AREA",
+    "COLOR_BGR2GRAY",
+    "COLOR_BGR2RGB",
+    "COLOR_GRAY2BGR",
+    "COLOR_HSV2BGR",
+    "COLOR_RGB2BGR",
+    "FONT_HERSHEY_COMPLEX",
+    "FONT_HERSHEY_COMPLEX_SMALL",
+    "FONT_HERSHEY_DUPLEX",
+    "FONT_HERSHEY_PLAIN",
+    "FONT_HERSHEY_SCRIPT_COMPLEX",
+    "FONT_HERSHEY_SCRIPT_SIMPLEX",
+    "FONT_HERSHEY_SIMPLEX",
+    "FONT_HERSHEY_TRIPLEX",
+    "FONT_ITALIC",
+    "IMREAD_COLOR",
+    "IMREAD_UNCHANGED",
+    "INTER_LINEAR",
+    "INTER_NEAREST",
+    "LINE_4",
+    "LINE_8",
+    "LINE_AA",
+    "BackendUnavailableError",
+    "VideoCapture",
+    "VideoWriter",
+    "VideoWriter_fourcc",
+    "addWeighted",
+    "approxPolyDP",
+    "blur",
+    "circle",
+    "connectedComponents",
+    "connectedComponentsWithStats",
+    "contourArea",
+    "convertScaleAbs",
+    "copyMakeBorder",
+    "cvtColor",
+    "drawContours",
+    "ellipse",
+    "fillPoly",
+    "find_contours",
+    "flip",
+    "getTextSize",
+    "imdecode",
+    "imencode",
+    "imread",
+    "imwrite",
+    "intersectConvexConvex",
+    "line",
+    "mean",
+    "merge",
+    "polylines",
+    "putText",
+    "rectangle",
+    "resize",
+    "split",
+]
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72782f261c1942be6ab73ea4b5d34d63fbe34498
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_color.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_color.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..caa8f7be81293ef1186b8b32601bf13b1a715aed
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_color.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_common.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..675edbf218f4ef697b2da623bb0aca4a0cf75fa0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_common.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_components.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_components.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd4e2d7037a961142e87603a46999e66c3f780df
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_components.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_contours.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_contours.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13f0613ad144d8dc68a77480ddf4f7f6396ed6fb
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_contours.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_drawing.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_drawing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..443cce31e4edb1ae0ede536a4caf8634f1bc0bcf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_drawing.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_geometry.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_geometry.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f593206c39934192ff8c1d67a5d1f13715cd8c6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_geometry.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_image.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_image.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be2deef87f564c028952661091947fc9a2d1f86d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_image.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_text.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_text.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e6d1c3e95e7f05962983da41afb588b73d42124
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_text.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_transform.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_transform.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6377c01b9b6e34d4baccc3a2f400863a56a7fc74
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_transform.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_video.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_video.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..929c5e9087344e032994220a7bcc74e1adbbdab6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/_video.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/constants.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/constants.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0271592de24429d3be8878ca5cf3f7a43923ae9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/_cv2/__pycache__/constants.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_color.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_color.py
new file mode 100644
index 0000000000000000000000000000000000000000..c395b6e3c924d170a40e1fbfbf318b3a79db5fae
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_color.py
@@ -0,0 +1,96 @@
+"""Private color and channel-operation fallbacks."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision._cv2._common import _cast_array_like_opencv
+from supervision._cv2.constants import (
+    _COLOR_BGR2GRAY,
+    _COLOR_BGR2RGB,
+    _COLOR_GRAY2BGR,
+    _COLOR_HSV2BGR,
+    _COLOR_RGB2BGR,
+)
+
+
+def _cvt_color(image: npt.NDArray[Any], code: int) -> npt.NDArray[Any]:
+    """Convert the BGR, RGB, grayscale, and 8-bit HSV formats used by Supervision."""
+    if code in (_COLOR_BGR2RGB, _COLOR_RGB2BGR):
+        if image.ndim != 3 or image.shape[2] not in (3, 4):
+            raise ValueError(
+                "BGR/RGB conversion requires a three- or four-channel image"
+            )
+        return np.ascontiguousarray(image[..., 2::-1])
+
+    if code == _COLOR_GRAY2BGR:
+        if image.ndim != 2:
+            raise ValueError("GRAY2BGR conversion requires a two-dimensional image")
+        return np.repeat(image[..., np.newaxis], 3, axis=2)
+
+    if code == _COLOR_BGR2GRAY:
+        if image.ndim != 3 or image.shape[2] != 3:
+            raise ValueError("BGR2GRAY conversion requires a three-channel image")
+        if image.dtype == np.uint8:
+            values = image.astype(np.uint32)
+            weighted = (
+                values[..., 0] * 3735
+                + values[..., 1] * 19235
+                + values[..., 2] * 9798
+                + (1 << 14)
+            ) >> 15
+            return weighted.astype(np.uint8)
+        float_values = (
+            image[..., 0].astype(np.float64) * 0.114
+            + image[..., 1].astype(np.float64) * 0.587
+            + image[..., 2].astype(np.float64) * 0.299
+        )
+        return _cast_array_like_opencv(float_values, image.dtype)
+
+    if code == _COLOR_HSV2BGR:
+        if image.ndim != 3 or image.shape[2] != 3:
+            raise ValueError("HSV2BGR conversion requires a three-channel image")
+        return _hsv_to_bgr(image)
+
+    raise ValueError(f"Unsupported color conversion code: {code}")
+
+
+def _hsv_to_bgr(image: npt.NDArray[Any]) -> npt.NDArray[Any]:
+    """Convert OpenCV's 8-bit HSV representation to BGR."""
+    values = image.astype(np.float64)
+    hue = values[..., 0] / 30.0
+    saturation = values[..., 1] / 255.0
+    value = values[..., 2] / 255.0
+
+    chroma = value * saturation
+    sector_index = np.floor(hue).astype(np.int64) % 6
+    sector = hue - np.floor(hue)
+    x = chroma * (1 - np.abs(((sector_index + sector) % 2) - 1))
+    match = value - chroma
+    zeros = np.zeros_like(chroma)
+
+    red = np.choose(sector_index, (chroma, x, zeros, zeros, x, chroma))
+    green = np.choose(sector_index, (x, chroma, chroma, x, zeros, zeros))
+    blue = np.choose(sector_index, (zeros, zeros, x, chroma, chroma, x))
+    bgr = np.stack((blue + match, green + match, red + match), axis=-1) * 255
+    return _cast_array_like_opencv(bgr, image.dtype)
+
+
+def _split(image: npt.NDArray[Any]) -> tuple[npt.NDArray[Any], ...]:
+    """Split an image into contiguous single-channel arrays."""
+    if image.ndim == 2:
+        return (np.ascontiguousarray(image),)
+    return tuple(
+        np.ascontiguousarray(image[..., index]) for index in range(image.shape[2])
+    )
+
+
+def _merge(channels: Sequence[npt.NDArray[Any]]) -> npt.NDArray[Any]:
+    """Merge single-channel arrays along their final axis."""
+    if not channels:
+        raise ValueError("At least one channel is required")
+    return np.ascontiguousarray(np.stack(channels, axis=-1))
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_common.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_common.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6c30167e6e532ac7893afd07fcecc3153048b46
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_common.py
@@ -0,0 +1,23 @@
+"""Private helpers shared by OpenCV fallback implementations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+
+class BackendUnavailableError(RuntimeError):
+    """Raised when an OpenCV operation is used without an available backend."""
+
+
+def _cast_array_like_opencv(
+    values: npt.NDArray[Any], dtype: np.dtype[Any]
+) -> npt.NDArray[Any]:
+    """Round integer results using OpenCV's saturating conversion convention."""
+    if np.issubdtype(dtype, np.integer):
+        info = np.iinfo(dtype)
+        values = np.rint(values)
+        values = np.clip(values, info.min, info.max)
+    return values.astype(dtype, copy=False)
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_components.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_components.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb6b33209ebec67bf6d7954652d0b9b93bf11f31
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_components.py
@@ -0,0 +1,128 @@
+"""Private connected-component and mask-topology fallbacks."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _validate_binary_image(image: npt.NDArray[Any]) -> npt.NDArray[np.bool_]:
+    """Validate and normalize a two-dimensional component image."""
+    values = np.asarray(image)
+    if values.ndim != 2:
+        raise ValueError("Connected-component input must be a two-dimensional image")
+    return cast(npt.NDArray[np.bool_], values != 0)
+
+
+def _label(
+    image: npt.NDArray[Any], connectivity: int
+) -> tuple[int, npt.NDArray[np.int32]]:
+    """Label foreground pixels with the requested four- or eight-way topology."""
+    if connectivity not in (4, 8):
+        raise ValueError("Only 4- and 8-connectivity are supported")
+
+    from scipy import ndimage
+
+    structure = ndimage.generate_binary_structure(2, 1 if connectivity == 4 else 2)
+    labels, count = ndimage.label(_validate_binary_image(image), structure=structure)
+    return int(count), np.ascontiguousarray(labels, dtype=np.int32)
+
+
+def _connected_components(
+    image: npt.NDArray[Any],
+    labels: npt.NDArray[Any] | None = None,
+    connectivity: int = 8,
+    ltype: int = 4,
+) -> tuple[int, npt.NDArray[np.int32]]:
+    """Return OpenCV-shaped connected-component labels and their count."""
+    del ltype
+    count, result = _label(image, connectivity)
+    if labels is not None and labels.shape == result.shape and labels.dtype == np.int32:
+        labels[...] = result
+        result = labels
+    return count + 1, result
+
+
+def _connected_components_with_stats(
+    image: npt.NDArray[Any], connectivity: int = 8, ltype: int = 4
+) -> tuple[
+    int,
+    npt.NDArray[np.int32],
+    npt.NDArray[np.int32],
+    npt.NDArray[np.float64],
+]:
+    """Return labels, bounding-box statistics, and centroids for components."""
+    del ltype
+    from scipy import ndimage
+
+    count, labels = _label(image, connectivity)
+    component_count = count + 1
+    flat_labels = labels.ravel()
+    rows, columns = np.indices(labels.shape)
+    areas = np.bincount(flat_labels, minlength=component_count)
+    x_sums = np.bincount(
+        flat_labels, weights=columns.ravel(), minlength=component_count
+    )
+    y_sums = np.bincount(flat_labels, weights=rows.ravel(), minlength=component_count)
+
+    centroids = np.zeros((component_count, 2), dtype=np.float64)
+    populated = areas != 0
+    centroids[populated, 0] = x_sums[populated] / areas[populated]
+    centroids[populated, 1] = y_sums[populated] / areas[populated]
+
+    stats = np.zeros((component_count, 5), dtype=np.int32)
+    stats[:, 4] = areas.astype(np.int32)
+    objects = ndimage.find_objects(labels, max_label=count)
+    for component, bounds in enumerate(objects, start=1):
+        if bounds is None:
+            continue
+        row_slice, column_slice = bounds
+        stats[component, :4] = (
+            column_slice.start,
+            row_slice.start,
+            column_slice.stop - column_slice.start,
+            row_slice.stop - row_slice.start,
+        )
+
+    background_mask = labels == 0
+    if np.any(background_mask):
+        row_hits = np.any(background_mask, axis=1)
+        col_hits = np.any(background_mask, axis=0)
+        y_indices = np.flatnonzero(row_hits)
+        x_indices = np.flatnonzero(col_hits)
+        stats[0, :4] = (
+            int(x_indices[0]),
+            int(y_indices[0]),
+            int(x_indices[-1] - x_indices[0] + 1),
+            int(y_indices[-1] - y_indices[0] + 1),
+        )
+    return count + 1, labels, stats, centroids
+
+
+def _contains_holes(mask: npt.NDArray[Any]) -> bool:
+    """Return whether a mask has a background component detached from its border."""
+    values = _validate_binary_image(mask)
+    if values.size == 0 or np.all(values):
+        return False
+
+    background_count, background_labels = _label(~values, connectivity=4)
+    if background_count == 0:
+        return False
+
+    border_labels = np.unique(
+        np.concatenate(
+            (
+                background_labels[0],
+                background_labels[-1],
+                background_labels[:, 0],
+                background_labels[:, -1],
+            )
+        )
+    )
+    return bool(
+        np.any(
+            ~np.isin(np.arange(1, background_count + 1, dtype=np.int32), border_labels)
+        )
+    )
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_contours.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_contours.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab56226bb757d54cc0ebce5e4c858f3218041db2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_contours.py
@@ -0,0 +1,154 @@
+"""Private Suzuki-Abe contour fallback."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision._cv2.constants import _CHAIN_APPROX_SIMPLE, _RETR_TREE
+
+_NEIGHBORS = (
+    (0, 1),
+    (-1, 1),
+    (-1, 0),
+    (-1, -1),
+    (0, -1),
+    (1, -1),
+    (1, 0),
+    (1, 1),
+)
+
+
+def _follow_border(
+    image: npt.NDArray[np.bool_],
+    labels: npt.NDArray[np.int32],
+    start: tuple[int, int],
+    previous: tuple[int, int],
+    border_number: int,
+) -> list[tuple[int, int]]:
+    """Trace one border using the Suzuki-Abe neighborhood walk."""
+    rows, columns = image.shape
+
+    def is_foreground(row: int, column: int) -> bool:
+        """Check a pixel while treating the image boundary as background."""
+        return 0 <= row < rows and 0 <= column < columns and bool(image[row, column])
+
+    direction = _NEIGHBORS.index((previous[0] - start[0], previous[1] - start[1]))
+    first_direction = -1
+    for offset in range(1, 9):
+        candidate_direction = (direction + offset) % 8
+        delta_row, delta_column = _NEIGHBORS[candidate_direction]
+        if is_foreground(start[0] + delta_row, start[1] + delta_column):
+            first_direction = candidate_direction
+            break
+    if first_direction < 0:
+        labels[start] = -border_number
+        return [start]
+
+    first_neighbor = (
+        start[0] + _NEIGHBORS[first_direction][0],
+        start[1] + _NEIGHBORS[first_direction][1],
+    )
+    contour: list[tuple[int, int]] = []
+    previous_point, current = first_neighbor, start
+    while True:
+        direction = _NEIGHBORS.index(
+            (previous_point[0] - current[0], previous_point[1] - current[1])
+        )
+        east_zero = False
+        next_point: tuple[int, int] | None = None
+        for offset in range(1, 9):
+            candidate_direction = (direction - offset) % 8
+            delta_row, delta_column = _NEIGHBORS[candidate_direction]
+            row = current[0] + delta_row
+            column = current[1] + delta_column
+            if is_foreground(row, column):
+                next_point = (row, column)
+                break
+            if candidate_direction == 0:
+                east_zero = True
+
+        if east_zero:
+            labels[current] = -border_number
+        elif labels[current] == 0:
+            labels[current] = border_number
+        contour.append(current)
+
+        if next_point == start and current == first_neighbor and len(contour) > 1:
+            return contour
+        if next_point is None:
+            return contour
+        previous_point, current = current, next_point
+        if len(contour) > 4 * image.size:
+            raise RuntimeError("Contour border tracing did not converge")
+
+
+def _trace_borders(mask: npt.NDArray[np.bool_]) -> list[np.ndarray]:
+    """Trace all foreground and hole borders in raster candidate order."""
+    image = np.ascontiguousarray(mask, dtype=bool)
+    labels = np.zeros(image.shape, dtype=np.int32)
+    left_zero = image & ~np.pad(image[:, :-1], ((0, 0), (1, 0)))
+    right_zero = image & ~np.pad(image[:, 1:], ((0, 0), (0, 1)))
+    candidates = np.argwhere(left_zero | right_zero)
+    borders: list[np.ndarray] = []
+    border_number = 1
+    for row, column in candidates:
+        row, column = int(row), int(column)
+        if left_zero[row, column] and labels[row, column] == 0:
+            border_number += 1
+            border = _follow_border(
+                image, labels, (row, column), (row, column - 1), border_number
+            )
+            borders.append(np.array([(column, row) for row, column in border]))
+        elif right_zero[row, column] and labels[row, column] >= 0:
+            border_number += 1
+            border = _follow_border(
+                image, labels, (row, column), (row, column + 1), border_number
+            )
+            borders.append(np.array([(column, row) for row, column in border]))
+    return borders
+
+
+def _reverse_preserving_start(contour: np.ndarray) -> np.ndarray:
+    """Reverse a traced contour while retaining its Suzuki-Abe start pixel."""
+    if len(contour) < 2:
+        return contour
+    return np.concatenate((contour[:1], contour[:0:-1]))
+
+
+def _compress_contour(contour: np.ndarray) -> np.ndarray:
+    """Apply OpenCV's collinear-run compression for SIMPLE contours."""
+    contour = _reverse_preserving_start(contour)
+    if len(contour) < 3:
+        return contour
+    keep: list[np.ndarray] = []
+    for index, point in enumerate(contour):
+        previous = point - contour[index - 1]
+        following = contour[(index + 1) % len(contour)] - point
+        if (
+            np.any(previous)
+            and np.any(following)
+            and np.array_equal(np.sign(previous), np.sign(following))
+        ):
+            continue
+        keep.append(point)
+    return np.asarray(keep, dtype=np.int32)
+
+
+def _find_contours(
+    image: npt.NDArray[Any], mode: int, method: int
+) -> tuple[list[npt.NDArray[np.int32]], npt.NDArray[np.int32] | None]:
+    """Find contours for the supported tree and SIMPLE modes."""
+    if mode != _RETR_TREE:
+        raise ValueError("Only RETR_TREE is supported by the fallback")
+    if method != _CHAIN_APPROX_SIMPLE:
+        raise ValueError("Only CHAIN_APPROX_SIMPLE is supported by the fallback")
+    values = np.asarray(image)
+    if values.ndim != 2:
+        raise ValueError("Contour input must be a two-dimensional image")
+    traced = [_compress_contour(contour) for contour in _trace_borders(values != 0)]
+    if not traced:
+        return [], None
+    return [contour.reshape(-1, 1, 2) for contour in traced], None
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_drawing.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_drawing.py
new file mode 100644
index 0000000000000000000000000000000000000000..db749ac270de470dcc07865b830da03015802487
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_drawing.py
@@ -0,0 +1,284 @@
+"""Private Pillow-based drawing fallbacks for the OpenCV facade."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image, ImageDraw
+
+_ImageArray = npt.NDArray[Any]
+_Point = tuple[int, int]
+
+
+def _drawing_mask(
+    image: _ImageArray, draw_operation: Callable[[Any], None]
+) -> npt.NDArray[np.bool_]:
+    """Render a shape into a clipped one-bit mask with Pillow."""
+    height, width = image.shape[:2]
+    mask = Image.new("1", (width, height))
+    draw_operation(ImageDraw.Draw(mask))
+    return np.asarray(mask, dtype=bool)
+
+
+def _color_for_image(image: _ImageArray, color: Any) -> Any:
+    """Normalize an OpenCV scalar color to the image channel count."""
+    values = np.asarray(color).reshape(-1)
+    if image.ndim == 2:
+        return values[0] if values.size else 0
+    channels = image.shape[2]
+    if values.size == 0:
+        return np.zeros(channels, dtype=image.dtype)
+    if values.size < channels:
+        return np.pad(values, (0, channels - values.size))
+    return values[:channels]
+
+
+def _paint(image: _ImageArray, mask: npt.NDArray[np.bool_], color: Any) -> _ImageArray:
+    """Apply a scalar or multi-channel color to a drawing mask."""
+    image[mask] = _color_for_image(image, color)
+    return image
+
+
+def _point(point: Sequence[int | float]) -> _Point:
+    """Convert an OpenCV point to integer Pillow coordinates."""
+    return round(point[0]), round(point[1])
+
+
+def _points(points: npt.NDArray[Any], offset: tuple[int, int] = (0, 0)) -> list[_Point]:
+    """Normalize OpenCV polygon shapes to integer Pillow coordinates."""
+    values = np.asarray(points)
+    if values.size == 0:
+        return []
+    if values.ndim not in (2, 3) or values.shape[-1] != 2:
+        raise ValueError("Drawing points must have shape (N, 2) or (N, 1, 2)")
+    normalized = np.rint(values.reshape(-1, 2)).astype(np.int64)
+    normalized += np.asarray(offset, dtype=np.int64)
+    return [(int(x), int(y)) for x, y in normalized]
+
+
+def _validate_shift(shift: int) -> None:
+    """Reject fixed-point coordinates not supported by the fallback."""
+    if shift != 0:
+        raise ValueError("Only unshifted drawing coordinates are supported")
+
+
+def _line(
+    img: _ImageArray,
+    pt1: Sequence[int | float],
+    pt2: Sequence[int | float],
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    shift: int = 0,
+) -> _ImageArray:
+    """Draw a line in place using Pillow's integer rasterization."""
+    del lineType
+    _validate_shift(shift)
+    width = max(1, thickness)
+    mask = _drawing_mask(
+        img,
+        lambda draw: draw.line([_point(pt1), _point(pt2)], fill=1, width=width),
+    )
+    return _paint(img, mask, color)
+
+
+def _rectangle(
+    img: _ImageArray,
+    pt1: Sequence[int | float],
+    pt2: Sequence[int | float],
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    shift: int = 0,
+) -> _ImageArray:
+    """Draw or fill an inclusive-axis-aligned rectangle in place."""
+    del lineType
+    _validate_shift(shift)
+    first_point, second_point = _point(pt1), _point(pt2)
+    first = tuple(min(left, right) for left, right in zip(first_point, second_point))
+    second = tuple(max(left, right) for left, right in zip(first_point, second_point))
+    if thickness < 0:
+        mask = _drawing_mask(img, lambda draw: draw.rectangle([first, second], fill=1))
+    else:
+        width = max(1, thickness)
+        mask = _drawing_mask(
+            img,
+            lambda draw: draw.rectangle([first, second], outline=1, width=width),
+        )
+    return _paint(img, mask, color)
+
+
+def _circle(
+    img: _ImageArray,
+    center: Sequence[int | float],
+    radius: int,
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    shift: int = 0,
+) -> _ImageArray:
+    """Draw or fill a circle in place."""
+    del lineType
+    _validate_shift(shift)
+    x, y = _point(center)
+    bounds = [x - radius, y - radius, x + radius, y + radius]
+    if thickness < 0:
+        mask = _drawing_mask(img, lambda draw: draw.ellipse(bounds, fill=1))
+    else:
+        width = max(1, thickness)
+        mask = _drawing_mask(
+            img,
+            lambda draw: draw.ellipse(bounds, outline=1, width=width),
+        )
+    return _paint(img, mask, color)
+
+
+def _ellipse_points(
+    center: Sequence[int | float],
+    axes: Sequence[int | float],
+    angle: float,
+    start_angle: float,
+    end_angle: float,
+) -> list[_Point]:
+    """Sample an OpenCV ellipse arc as integer image coordinates."""
+    center_x, center_y = center
+    axis_x, axis_y = axes
+    span = max(0.0, end_angle - start_angle)
+    sample_count = max(2, int(np.ceil(span * max(axis_x, axis_y) * np.pi / 90)))
+    angles = np.linspace(start_angle, end_angle, sample_count + 1)
+    radians = np.deg2rad(angles)
+    rotation = np.deg2rad(angle)
+    cosine, sine = np.cos(rotation), np.sin(rotation)
+    x = center_x + axis_x * np.cos(radians) * cosine - axis_y * np.sin(radians) * sine
+    y = center_y + axis_x * np.cos(radians) * sine + axis_y * np.sin(radians) * cosine
+    return [(round(x_value), round(y_value)) for x_value, y_value in zip(x, y)]
+
+
+def _ellipse(
+    img: _ImageArray,
+    center: Sequence[int | float],
+    axes: Sequence[int | float],
+    angle: float,
+    startAngle: float,
+    endAngle: float,
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    shift: int = 0,
+) -> _ImageArray:
+    """Draw or fill an optionally rotated ellipse arc in place."""
+    del lineType
+    _validate_shift(shift)
+    ellipse_points = _ellipse_points(center, axes, angle, startAngle, endAngle)
+    is_full = endAngle - startAngle >= 360
+
+    def draw_ellipse(draw: Any) -> None:
+        if thickness < 0:
+            if is_full:
+                draw.polygon(ellipse_points, fill=1)
+            else:
+                draw.polygon([_point(center), *ellipse_points], fill=1)
+            return
+        width = max(1, thickness)
+        draw.line(ellipse_points, fill=1, width=width, joint="curve")
+        if is_full and len(ellipse_points) > 1:
+            draw.line([ellipse_points[-1], ellipse_points[0]], fill=1, width=width)
+
+    return _paint(img, _drawing_mask(img, draw_ellipse), color)
+
+
+def _polylines(
+    img: _ImageArray,
+    pts: Sequence[npt.NDArray[Any]],
+    isClosed: bool,
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    shift: int = 0,
+) -> _ImageArray:
+    """Draw one or more open or closed polylines in place."""
+    del lineType
+    _validate_shift(shift)
+    width = max(1, thickness)
+
+    def draw_polylines(draw: Any) -> None:
+        for polygon in pts:
+            points = _points(polygon)
+            if not points:
+                continue
+            points = [
+                point
+                for index, point in enumerate(points)
+                if index == 0 or point != points[index - 1]
+            ]
+            if len(points) == 1:
+                draw.point(points[0], fill=1)
+                continue
+            if isClosed:
+                points.append(points[0])
+            draw.line(points, fill=1, width=width, joint="curve")
+
+    return _paint(img, _drawing_mask(img, draw_polylines), color)
+
+
+def _fill_poly(
+    img: _ImageArray,
+    pts: Sequence[npt.NDArray[Any]],
+    color: Any,
+    lineType: int = 8,
+    shift: int = 0,
+    offset: tuple[int, int] = (0, 0),
+) -> _ImageArray:
+    """Fill one or more polygons in place."""
+    del lineType
+    _validate_shift(shift)
+
+    def draw_polygons(draw: Any) -> None:
+        for polygon in pts:
+            points = _points(polygon, offset=offset)
+            if len(points) == 1:
+                draw.point(points[0], fill=1)
+            elif len(points) == 2:
+                draw.line(points, fill=1)
+            elif len(points) >= 3:
+                draw.polygon(points, fill=1)
+
+    return _paint(img, _drawing_mask(img, draw_polygons), color)
+
+
+def _draw_contours(
+    image: _ImageArray,
+    contours: Sequence[npt.NDArray[Any]],
+    contourIdx: int,
+    color: Any,
+    thickness: int = 1,
+    lineType: int = 8,
+    hierarchy: npt.NDArray[Any] | None = None,
+    maxLevel: int = 2**31 - 1,
+    offset: tuple[int, int] = (0, 0),
+) -> _ImageArray:
+    """Draw selected contours with OpenCV-compatible in-place mutation."""
+    del lineType, maxLevel
+    # OpenCV walks the hierarchy tree to also draw a contour's nested descendants;
+    # the fallback only does flat contourIdx selection, so reject a hierarchy
+    # instead of silently diverging. maxLevel is a no-op without a hierarchy, which
+    # matches OpenCV ignoring it whenever hierarchy is None.
+    if hierarchy is not None:
+        raise ValueError("Only None hierarchy is supported by the fallback")
+    selected = contours if contourIdx < 0 else contours[contourIdx : contourIdx + 1]
+
+    def draw_selected(draw: Any) -> None:
+        for contour in selected:
+            points = _points(contour, offset=offset)
+            if len(points) < 2:
+                continue
+            if thickness < 0:
+                draw.polygon(points, fill=1)
+            else:
+                width = max(1, thickness)
+                draw.line([*points, points[0]], fill=1, width=width, joint="curve")
+
+    return _paint(image, _drawing_mask(image, draw_selected), color)
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_geometry.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_geometry.py
new file mode 100644
index 0000000000000000000000000000000000000000..e57bb8db2eec96f11e78167852fafc2ed1c0c94f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_geometry.py
@@ -0,0 +1,234 @@
+"""Private polygon geometry fallbacks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _as_points(contour: npt.NDArray[Any]) -> npt.NDArray[np.float64]:
+    """Normalize an OpenCV contour to an ``(N, 2)`` float64 array."""
+    points = np.asarray(contour)
+    if points.size == 0:
+        return np.empty((0, 2), dtype=np.float64)
+    if points.ndim not in (2, 3) or points.shape[-1] != 2:
+        raise ValueError("Contours must have shape (N, 2) or (N, 1, 2)")
+    return points.reshape(-1, 2).astype(np.float64, copy=False)
+
+
+def _contour_area(contour: npt.NDArray[Any], oriented: bool = False) -> float:
+    """Compute a contour's signed or absolute shoelace area."""
+    points = _as_points(contour)
+    if len(points) < 3:
+        return 0.0
+    x = points[:, 0]
+    y = points[:, 1]
+    area = 0.5 * float(np.dot(x, np.roll(y, -1)) - np.dot(y, np.roll(x, -1)))
+    return area if oriented else abs(area)
+
+
+def _simplify_slices(
+    points: npt.NDArray[np.float64], epsilon_squared: float, closed: bool
+) -> npt.NDArray[np.float64]:
+    """Run OpenCV's stack-based Douglas-Peucker slice traversal."""
+    count = len(points)
+    stack: list[tuple[int, int]] = []
+    output: list[npt.NDArray[np.float64]] = []
+
+    if closed or np.array_equal(points[0], points[-1]):
+        closed = True
+        position = 0
+        right_start = 0
+        start_point = points[0]
+        within_epsilon = False
+        for _ in range(3):
+            position = (position + right_start) % count
+            start_point = points[position]
+            maximum_distance = 0.0
+            right_start = 0
+            for offset in range(1, count):
+                point = points[(position + offset) % count]
+                difference = point - start_point
+                distance = float(np.dot(difference, difference))
+                if distance > maximum_distance:
+                    maximum_distance = distance
+                    right_start = offset
+            within_epsilon = maximum_distance <= epsilon_squared
+
+        if within_epsilon:
+            output.append(start_point)
+        else:
+            split = (position + right_start) % count
+            stack.extend(((split, position), (position, split)))
+    else:
+        stack.append((0, count - 1))
+
+    while stack:
+        start, end = stack.pop()
+        start_point = points[start]
+        end_point = points[end]
+        position = (start + 1) % count
+        maximum_distance = 0.0
+        split = start
+
+        if position != end:
+            segment = end_point - start_point
+            while position != end:
+                point = points[position]
+                distance = abs(
+                    float(
+                        (point[1] - start_point[1]) * segment[0]
+                        - (point[0] - start_point[0]) * segment[1]
+                    )
+                )
+                if distance > maximum_distance:
+                    maximum_distance = distance
+                    split = position
+                position = (position + 1) % count
+            segment_length_squared = float(np.dot(segment, segment))
+            within_epsilon = (
+                maximum_distance * maximum_distance
+                <= epsilon_squared * segment_length_squared
+            )
+        else:
+            within_epsilon = True
+
+        if within_epsilon:
+            output.append(start_point)
+        else:
+            stack.extend(((split, end), (start, split)))
+
+    if not closed:
+        output.append(points[-1])
+    return np.asarray(output, dtype=np.float64)
+
+
+def _cleanup_approximation(
+    points: npt.NDArray[np.float64], epsilon_squared: float, closed: bool
+) -> npt.NDArray[np.float64]:
+    """Remove OpenCV's final near-collinear points from an approximation."""
+    count = len(points)
+    if count <= 2:
+        return points
+
+    destination = points.copy()
+    new_count = count
+    position = count - 1 if closed else 0
+    start_point = destination[position]
+    position = (position + 1) % count
+    write_position = position
+    point = destination[position]
+    position = (position + 1) % count
+    index = 0 if closed else 1
+    stop = count if closed else count - 1
+
+    while index < stop and new_count > 2:
+        end_point = destination[position]
+        position = (position + 1) % count
+        segment = end_point - start_point
+        offset = point - start_point
+        distance = abs(float(offset[0] * segment[1] - offset[1] * segment[0]))
+        inner_product = float(np.dot(offset, end_point - point))
+        removable = (
+            distance * distance
+            <= 0.5 * epsilon_squared * float(np.dot(segment, segment))
+            and segment[0] != 0
+            and segment[1] != 0
+            and inner_product >= 0
+        )
+        if removable:
+            new_count -= 1
+            destination[write_position] = end_point
+            start_point = end_point
+            write_position = (write_position + 1) % count
+            point = destination[position]
+            position = (position + 1) % count
+            index += 2
+            continue
+
+        destination[write_position] = point
+        start_point = point
+        write_position = (write_position + 1) % count
+        point = end_point
+        index += 1
+
+    if not closed:
+        destination[write_position] = point
+    return np.asarray(destination[:new_count], dtype=np.float64)
+
+
+def _approx_poly_dp(
+    contour: npt.NDArray[Any], epsilon: float, closed: bool
+) -> npt.NDArray[Any]:
+    """Approximate a contour with the supported OpenCV polygon contract."""
+    if epsilon < 0:
+        raise ValueError("epsilon must be non-negative")
+    points = _as_points(contour)
+    if len(points) == 0:
+        dtype = np.asarray(contour).dtype
+        return np.empty((0, 1, 2), dtype=dtype)
+
+    epsilon_squared = float(epsilon) ** 2
+    simplified = _simplify_slices(points, epsilon_squared, closed)
+    simplified = _cleanup_approximation(simplified, epsilon_squared, closed)
+
+    dtype = np.asarray(contour).dtype
+    return simplified.astype(dtype, copy=False).reshape(-1, 1, 2)
+
+
+def _cross(edge: npt.NDArray[np.float64], point: npt.NDArray[np.float64]) -> float:
+    """Return the two-dimensional cross product of two vectors."""
+    return float(edge[0] * point[1] - edge[1] * point[0])
+
+
+def _intersect_convex_convex(
+    first: npt.NDArray[Any],
+    second: npt.NDArray[Any],
+    handle_nested: bool = True,
+) -> tuple[float, npt.NDArray[Any]]:
+    """Clip two convex polygons and return their intersection area and vertices."""
+    del handle_nested
+    subject = _as_points(first)
+    clip = _as_points(second)
+    output = subject
+    if len(subject) < 3 or len(clip) < 3:
+        return 0.0, np.empty((0, 1, 2), dtype=np.float32)
+
+    orientation = 1.0 if _contour_area(clip, oriented=True) >= 0 else -1.0
+    for index, clip_start in enumerate(clip):
+        clip_end = clip[(index + 1) % len(clip)]
+        edge = clip_end - clip_start
+        input_points = output
+        if len(input_points) == 0:
+            break
+        output_points: list[npt.NDArray[np.float64]] = []
+        previous = input_points[-1]
+        previous_inside = orientation * _cross(edge, previous - clip_start) >= 0
+        for current in input_points:
+            current_inside = orientation * _cross(edge, current - clip_start) >= 0
+            if current_inside != previous_inside:
+                direction = current - previous
+                denominator = _cross(edge, direction)
+                if denominator != 0:
+                    factor = _cross(edge, clip_start - previous) / denominator
+                    output_points.append(previous + factor * direction)
+            if current_inside:
+                output_points.append(current)
+            previous = current
+            previous_inside = current_inside
+        output = np.asarray(output_points, dtype=np.float64)
+
+    if len(output) == 0:
+        dtype = np.asarray(first).dtype
+        result_dtype = dtype if np.issubdtype(dtype, np.floating) else np.float32
+        return 0.0, np.empty((0, 1, 2), dtype=result_dtype)
+
+    output = output[np.r_[True, np.any(np.diff(output, axis=0) != 0, axis=1)]]
+    if len(output) > 1 and np.array_equal(output[0], output[-1]):
+        output = output[:-1]
+    area = _contour_area(output)
+    dtype = np.asarray(first).dtype
+    result_dtype = dtype if np.issubdtype(dtype, np.floating) else np.float32
+    return area, output.astype(result_dtype, copy=False).reshape(-1, 1, 2)
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_image.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..29e787d475fc61b1bbac1d63c36748c8883a0e51
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_image.py
@@ -0,0 +1,372 @@
+"""Private image-operation and image-I/O fallbacks."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Sequence
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision._cv2._common import _cast_array_like_opencv
+from supervision._cv2.constants import (
+    _BORDER_CONSTANT,
+    _IMREAD_COLOR,
+    _IMREAD_UNCHANGED,
+    _INTER_LINEAR,
+    _INTER_NEAREST,
+)
+
+
+def _flip(image: npt.NDArray[Any], flip_code: int) -> npt.NDArray[Any]:
+    """Flip an image vertically, horizontally, or along both axes."""
+    if flip_code == 0:
+        axes: tuple[int, ...] = (0,)
+    elif flip_code == 1:
+        axes = (1,)
+    elif flip_code == -1:
+        axes = (0, 1)
+    else:
+        raise ValueError(f"Unsupported flip code: {flip_code}")
+    return np.ascontiguousarray(np.flip(image, axis=axes))
+
+
+def _copy_make_border(
+    image: npt.NDArray[Any],
+    top: int,
+    bottom: int,
+    left: int,
+    right: int,
+    border_type: int,
+    value: int | float | Sequence[int | float] = 0,
+) -> npt.NDArray[Any]:
+    """Add a constant border around an image."""
+    if border_type != _BORDER_CONSTANT:
+        raise ValueError("Only BORDER_CONSTANT is supported by the fallback")
+    if min(top, bottom, left, right) < 0:
+        raise ValueError("Border sizes must be non-negative")
+
+    height, width = image.shape[:2]
+    shape = (height + top + bottom, width + left + right, *image.shape[2:])
+
+    # OpenCV's Scalar(v) fills only channel 0 and zero-pads the rest for
+    # multichannel images — a bare scalar is treated the same as a
+    # length-1 sequence, not broadcast to every channel.
+    sequence_value = value if isinstance(value, Sequence) else (value,)
+    values = np.asarray(sequence_value, dtype=image.dtype).reshape(-1)
+    if image.ndim == 2:
+        fill_value: Any = values[0] if values.size else 0
+    else:
+        fill = np.zeros(image.shape[2], dtype=image.dtype)
+        fill[: min(values.size, image.shape[2])] = values[: image.shape[2]]
+        fill_value = fill.reshape((1, 1, -1))
+
+    result = np.full(shape, fill_value, dtype=image.dtype)
+    result[top : top + height, left : left + width] = image
+    return result
+
+
+def _add_weighted(
+    src1: npt.NDArray[Any],
+    alpha: float,
+    src2: npt.NDArray[Any],
+    beta: float,
+    gamma: float,
+    dst: npt.NDArray[Any] | None = None,
+    dtype: int | None = None,
+) -> npt.NDArray[Any]:
+    """Blend two arrays with OpenCV-compatible saturation and optional mutation."""
+    if dtype is not None and dtype != -1:
+        raise ValueError(
+            "addWeighted fallback only supports the default output depth; "
+            f"unsupported dtype: {dtype}"
+        )
+    if src1.shape != src2.shape:
+        raise ValueError("addWeighted inputs must have equal shapes")
+    result = _cast_array_like_opencv(
+        src1.astype(np.float64) * alpha + src2.astype(np.float64) * beta + gamma,
+        src1.dtype,
+    )
+    if dst is not None:
+        dst[...] = result
+        return dst
+    return result
+
+
+def _convert_scale_abs(
+    image: npt.NDArray[Any], alpha: float = 1, beta: float = 0
+) -> npt.NDArray[np.uint8]:
+    """Scale, offset, take the absolute value, and saturate to uint8."""
+    values = np.abs(image.astype(np.float64) * alpha + beta)
+    return _cast_array_like_opencv(values, np.dtype(np.uint8))
+
+
+def _mean(
+    image: npt.NDArray[Any], mask: npt.NDArray[Any] | None = None
+) -> tuple[float, float, float, float]:
+    """Return per-channel means using OpenCV's four-value result contract."""
+    if mask is None:
+        selected = (
+            image.reshape(-1, 1)
+            if image.ndim == 2
+            else image.reshape(-1, image.shape[2])
+        )
+    else:
+        if mask.shape != image.shape[:2]:
+            raise ValueError("Mean mask must match the image height and width")
+        selected = image[mask != 0]
+        if image.ndim == 2:
+            selected = selected.reshape(-1, 1)
+    if selected.size == 0:
+        means = np.zeros(4, dtype=np.float64)
+    else:
+        means = np.zeros(4, dtype=np.float64)
+        means[: selected.shape[1]] = np.mean(selected, axis=0)
+    return cast(
+        tuple[float, float, float, float],
+        tuple(float(value) for value in means),
+    )
+
+
+def _resize(
+    src: npt.NDArray[Any],
+    dsize: tuple[int, int] | None,
+    fx: float = 0,
+    fy: float = 0,
+    interpolation: int = _INTER_LINEAR,
+) -> npt.NDArray[Any]:
+    """Resize with exact nearest or OpenCV-compatible linear sampling."""
+    source_height, source_width = src.shape[:2]
+    width, height = dsize if dsize is not None else (0, 0)
+    if width == 0 or height == 0:
+        width = round(source_width * fx)
+        height = round(source_height * fy)
+    if min(width, height, source_width, source_height) <= 0:
+        raise ValueError("Resize dimensions must be positive")
+
+    if interpolation == _INTER_NEAREST:
+        y_indices = np.minimum(
+            (np.arange(height) * source_height // height), source_height - 1
+        )
+        x_indices = np.minimum(
+            (np.arange(width) * source_width // width), source_width - 1
+        )
+        return np.ascontiguousarray(src[y_indices[:, np.newaxis], x_indices])
+
+    if interpolation != _INTER_LINEAR:
+        raise ValueError(f"Unsupported interpolation mode: {interpolation}")
+
+    if src.dtype == np.uint8 and (
+        src.ndim == 2 or (src.ndim == 3 and src.shape[2] == 3)
+    ):
+        from PIL import Image
+
+        size = (width, height)
+        image = Image.fromarray(src)
+        if width >= source_width and height >= source_height:
+            resized = image.resize(size, resample=Image.Resampling.BILINEAR)
+        else:
+            # Affine sampling keeps Pillow from widening its bilinear kernel
+            # during reduction and maps pixel centers like INTER_LINEAR.
+            resized = image.transform(
+                size,
+                Image.Transform.AFFINE,
+                (source_width / width, 0, 0, 0, source_height / height, 0),
+                resample=Image.Resampling.BILINEAR,
+            )
+        return np.ascontiguousarray(np.asarray(resized))
+
+    y = (np.arange(height) + 0.5) * source_height / height - 0.5
+    x = (np.arange(width) + 0.5) * source_width / width - 0.5
+    y_floor = np.floor(y).astype(np.int64)
+    x_floor = np.floor(x).astype(np.int64)
+    y0 = np.clip(y_floor, 0, source_height - 1)
+    y1 = np.clip(y_floor + 1, 0, source_height - 1)
+    x0 = np.clip(x_floor, 0, source_width - 1)
+    x1 = np.clip(x_floor + 1, 0, source_width - 1)
+    wy = y - y_floor
+    wx = x - x_floor
+
+    source = src.astype(np.float64)
+    top_left = source[y0[:, np.newaxis], x0]
+    top_right = source[y0[:, np.newaxis], x1]
+    bottom_left = source[y1[:, np.newaxis], x0]
+    bottom_right = source[y1[:, np.newaxis], x1]
+    if src.ndim == 3:
+        wy = wy[:, np.newaxis, np.newaxis]
+        wx = wx[np.newaxis, :, np.newaxis]
+    else:
+        wy = wy[:, np.newaxis]
+        wx = wx[np.newaxis, :]
+    resized = (
+        top_left * (1 - wx) * (1 - wy)
+        + top_right * wx * (1 - wy)
+        + bottom_left * (1 - wx) * wy
+        + bottom_right * wx * wy
+    )
+    return np.ascontiguousarray(_cast_array_like_opencv(resized, src.dtype))
+
+
+_EXIF_ORIENTATION_TAG = 0x0112
+
+
+def _exif_oriented(image: Any) -> Any:
+    """Rotate and flip a Pillow image by its EXIF orientation tag, as OpenCV does.
+
+    `cv2.imread` and `cv2.imdecode` apply the tag on every read except
+    `IMREAD_UNCHANGED`. An image without the tag, or with the identity orientation
+    `1`, is returned as it is rather than copied.
+    """
+    from PIL import ImageOps
+
+    if image.getexif().get(_EXIF_ORIENTATION_TAG, 1) == 1:
+        return image
+    return ImageOps.exif_transpose(image)
+
+
+def _opencv_unchanged_mode(image: Any) -> str | None:
+    """Return the Pillow mode whose pixels match `cv2.imread(IMREAD_UNCHANGED)`.
+
+    OpenCV keeps an image's bit depth and alpha, but never returns a two-channel or
+    boolean array the way Pillow's own modes do: it expands palettes to BGR, adds an
+    alpha channel for grayscale with alpha and for a palette or RGB image with a
+    transparent color, and reads 1-bit images as 8-bit `0` and `255`. It also never
+    returns CMYK ink values, whose black channel would pass for alpha: a CMYK JPEG
+    is converted to BGR, and a CMYK TIFF to BGRA with an opaque alpha channel. `None`
+    means the image's own mode already matches.
+    """
+    has_transparency = "transparency" in image.info
+    if image.mode == "P":
+        return "RGBA" if has_transparency else "RGB"
+    if image.mode == "LA" or (image.mode == "RGB" and has_transparency):
+        return "RGBA"
+    if image.mode == "1":
+        return "L"
+    if image.mode == "CMYK":
+        return "RGBA" if image.format == "TIFF" else "RGB"
+    return None
+
+
+def _read_pil_source(source: Any, flags: int) -> npt.NDArray[Any] | None:
+    """Decode any source Pillow can open into BGR or BGRA arrays."""
+    from PIL import Image
+
+    try:
+        with Image.open(source) as image:
+            if flags == _IMREAD_UNCHANGED:
+                unchanged_mode = _opencv_unchanged_mode(image)
+                if unchanged_mode is not None:
+                    converted = image.convert(unchanged_mode)
+                    values = np.asarray(converted)
+                    converted.close()
+                else:
+                    values = np.asarray(image)
+            elif image.mode in {"I", "I;16", "I;16B", "I;16L"}:
+                values = np.asarray(_exif_oriented(image)).astype(np.float64)
+                values = np.clip(np.rint(values / 256), 0, 255).astype(np.uint8)
+                if values.ndim == 2:
+                    values = np.repeat(values[..., np.newaxis], 3, axis=2)
+            else:
+                values = np.asarray(_exif_oriented(image).convert("RGB"))
+    except (FileNotFoundError, OSError, ValueError):
+        return None
+
+    if values.ndim == 3 and values.shape[2] == 3:
+        values = values[..., ::-1]
+    elif values.ndim == 3 and values.shape[2] == 4:
+        values = values[..., [2, 1, 0, 3]]
+    return np.ascontiguousarray(values)
+
+
+def _imread(filename: str, flags: int = _IMREAD_COLOR) -> npt.NDArray[Any] | None:
+    """Read an image with Pillow while returning BGR or BGRA arrays."""
+    return _read_pil_source(filename, flags)
+
+
+def _imdecode(
+    buf: npt.NDArray[Any], flags: int = _IMREAD_COLOR
+) -> npt.NDArray[Any] | None:
+    """Decode in-memory encoded image bytes, returning BGR or BGRA arrays."""
+    import io
+
+    data = np.asarray(buf, dtype=np.uint8).tobytes()
+    return _read_pil_source(io.BytesIO(data), flags)
+
+
+def _bgr_to_pil_values(image: npt.NDArray[Any]) -> npt.NDArray[Any]:
+    """Reorder BGR or BGRA channels into the RGB order Pillow expects."""
+    values = np.asarray(image)
+    if values.ndim == 3 and values.shape[2] == 3:
+        values = values[..., ::-1]
+    elif values.ndim == 3 and values.shape[2] == 4:
+        values = values[..., [2, 1, 0, 3]]
+    return np.ascontiguousarray(values)
+
+
+def _opencv_default_save_options(image_format: str | None) -> dict[str, Any]:
+    """Return the Pillow save options that encode like OpenCV's default writers.
+
+    Given no parameters, `cv2.imwrite` and `cv2.imencode` write JPEG at quality 95 and
+    WebP losslessly, while Pillow's defaults are JPEG at quality 75 and lossy WebP at
+    quality 80. Formats such as PNG, BMP and TIFF are lossless in both libraries.
+    """
+    if image_format == "JPEG":
+        return {"quality": 95}
+    if image_format == "WEBP":
+        return {"lossless": True}
+    return {}
+
+
+def _imwrite(
+    filename: str, image: npt.NDArray[Any], params: Sequence[int] | None = None
+) -> bool:
+    """Write a BGR or BGRA array with Pillow and return OpenCV's boolean status.
+
+    `params` is accepted for compatibility with `cv2.imwrite`'s signature and is
+    ignored: the file is encoded with the OpenCV defaults that
+    `_opencv_default_save_options` returns, not with the quality or compression the
+    caller asked for.
+    """
+    from PIL import Image
+
+    del params
+    extension = os.path.splitext(filename)[1].lower()
+    image_format = Image.registered_extensions().get(extension)
+    save_options = _opencv_default_save_options(image_format)
+    try:
+        Image.fromarray(_bgr_to_pil_values(image)).save(filename, **save_options)
+    except (OSError, ValueError):
+        return False
+    return True
+
+
+def _imencode(
+    ext: str, image: npt.NDArray[Any], params: Sequence[int] | None = None
+) -> tuple[bool, npt.NDArray[np.uint8] | None]:
+    """Encode a BGR or BGRA array in memory, mirroring `cv2.imencode`'s return.
+
+    `params` is accepted for compatibility with `cv2.imencode`'s signature and is
+    ignored: the image is encoded with the OpenCV defaults that
+    `_opencv_default_save_options` returns, not with the quality or compression the
+    caller asked for.
+    """
+    import io
+
+    from PIL import Image
+
+    del params
+    # A suffix is not its codec's name, so resolve it through the same registry
+    # `_imwrite` and `Image.save` consult for a file path. An unregistered suffix
+    # resolves to None, which `Image.save` rejects for a buffer with no file name.
+    extension = f".{ext.lstrip('.').lower()}"
+    image_format = Image.registered_extensions().get(extension)
+    save_options = _opencv_default_save_options(image_format)
+    buffer = io.BytesIO()
+    try:
+        Image.fromarray(_bgr_to_pil_values(image)).save(
+            buffer, format=image_format, **save_options
+        )
+    except (KeyError, OSError, ValueError):
+        return False, None
+    return True, np.frombuffer(buffer.getvalue(), dtype=np.uint8)
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_text.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_text.py
new file mode 100644
index 0000000000000000000000000000000000000000..4caa9d99859583ca70738d3b27d68ce8499aa8a1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_text.py
@@ -0,0 +1,133 @@
+"""Private Pillow-based text fallback for the OpenCV compatibility facade.
+
+OpenCV renders text with built-in Hershey stroke fonts. The fallback instead
+draws a proportional TrueType face (DejaVu Sans, shipped with Matplotlib, an
+existing required dependency), so glyph shapes and text metrics differ from
+OpenCV within the documented visual-divergence tier. ``getTextSize`` derives
+its box from the same font ``putText`` renders with, so the reported rectangle
+always encloses the drawn text.
+"""
+
+from __future__ import annotations
+
+from functools import cache
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image, ImageDraw
+
+from supervision._cv2._drawing import _paint
+from supervision._cv2.constants import _FONT_ITALIC, _LINE_8
+
+_ImageArray = npt.NDArray[Any]
+
+# OpenCV's font_scale is unit-relative rather than a pixel size. This factor
+# maps it to a Pillow point size whose cap height lands near OpenCV's Hershey
+# Simplex at the same scale; it is a readability choice, not an exact metric
+# match (which no proportional TrueType face can provide).
+_PIXELS_PER_SCALE = 32
+
+
+@cache
+def _font_path(italic: bool) -> str:
+    """Locate a bundled DejaVu Sans face through Matplotlib's font manager."""
+    from matplotlib import font_manager
+
+    style = "italic" if italic else "normal"
+    properties = font_manager.FontProperties(family="DejaVu Sans", style=style)
+    return str(font_manager.findfont(properties))
+
+
+@cache
+def _load_font(font_face: int, font_scale: float) -> Any:
+    """Return a cached Pillow font sized for an OpenCV font scale."""
+    from PIL import ImageFont
+
+    size = max(1, round(font_scale * _PIXELS_PER_SCALE))
+    return ImageFont.truetype(_font_path(bool(font_face & _FONT_ITALIC)), size)
+
+
+def _stroke_width(thickness: int) -> int:
+    """Map an OpenCV stroke thickness to the Pillow stroke_width it renders with."""
+    return max(0, thickness - 1)
+
+
+def _get_text_size(
+    text: str, fontFace: int, fontScale: float, thickness: int
+) -> tuple[tuple[int, int], int]:
+    """Return an OpenCV-shaped ``((width, height), baseline)`` for the face.
+
+    Height is the font ascent and baseline the descent, both string-independent
+    like OpenCV's contract, so consumers get stable row heights. Padding uses
+    the same stroke_width _put_text renders with: Pillow's stroke dilates the
+    glyph outline by stroke_width pixels on every side, so width grows by
+    twice that (left and right) while height and baseline each grow by one
+    stroke_width (top and bottom).
+    """
+    font = _load_font(fontFace, fontScale)
+    ascent, descent = font.getmetrics()
+    stroke_width = _stroke_width(thickness)
+    width = round(font.getlength(text)) + 2 * stroke_width
+    height = ascent + stroke_width
+    baseline = descent + stroke_width
+    return (width, height), baseline
+
+
+def _put_text(
+    img: _ImageArray,
+    text: str,
+    org: tuple[int, int],
+    fontFace: int,
+    fontScale: float,
+    color: Any,
+    thickness: int = 1,
+    lineType: int = _LINE_8,
+    bottomLeftOrigin: bool = False,
+) -> _ImageArray:
+    """Render text with a Pillow face, anchored at OpenCV's baseline origin.
+
+    Thickness maps to a Pillow stroke width to emulate OpenCV's bolder strokes.
+    ``bottomLeftOrigin`` (an inverted-axis mode no Supervision caller uses) is
+    rejected rather than silently ignored.
+    """
+    del lineType
+    if bottomLeftOrigin:
+        raise ValueError("bottomLeftOrigin is not supported by the fallback")
+    if not text:
+        return img
+
+    font = _load_font(fontFace, fontScale)
+    stroke_width = _stroke_width(thickness)
+    x, y = round(org[0]), round(org[1])
+    left, top, right, bottom = font.getbbox(
+        text, anchor="ls", stroke_width=stroke_width
+    )
+    width, height = right - left, bottom - top
+    if width <= 0 or height <= 0:
+        return img
+
+    mask_image = Image.new("1", (width, height))
+    ImageDraw.Draw(mask_image).text(
+        (-left, -top),
+        text,
+        fill=1,
+        font=font,
+        anchor="ls",
+        stroke_width=stroke_width,
+    )
+    mask = np.asarray(mask_image, dtype=bool)
+
+    image_height, image_width = img.shape[:2]
+    x_start, y_start = max(0, x + left), max(0, y + top)
+    x_stop, y_stop = min(image_width, x + right), min(image_height, y + bottom)
+    if x_start >= x_stop or y_start >= y_stop:
+        return img
+    mask_x = x_start - (x + left)
+    mask_y = y_start - (y + top)
+    clipped_mask = mask[
+        mask_y : mask_y + (y_stop - y_start),
+        mask_x : mask_x + (x_stop - x_start),
+    ]
+    _paint(img[y_start:y_stop, x_start:x_stop], clipped_mask, color)
+    return img
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_transform.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_transform.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e5b0a3da1f66706637d7979639373a5c4efb4f0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_transform.py
@@ -0,0 +1,26 @@
+"""Private transform and filter fallbacks."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision._cv2._common import _cast_array_like_opencv
+
+
+def _blur(
+    image: npt.NDArray[Any], ksize: tuple[int, int], border_type: int = 4
+) -> npt.NDArray[Any]:
+    """Apply a box filter with OpenCV's default reflect-101 boundary behavior."""
+    if min(ksize) <= 0:
+        raise ValueError("Blur kernel dimensions must be positive")
+    if border_type != 4:
+        raise ValueError("Only OpenCV's default blur border is supported")
+
+    from scipy import ndimage
+
+    size = (*ksize[::-1], 1) if image.ndim == 3 else ksize[::-1]
+    values = ndimage.uniform_filter(image.astype(np.float64), size=size, mode="mirror")
+    return np.ascontiguousarray(_cast_array_like_opencv(values, image.dtype))
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/_video.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/_video.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7f90bb4b617ba90cdc84b402d75cc0e5d771d64
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/_video.py
@@ -0,0 +1,431 @@
+"""Private PyAV-backed video and audio fallbacks."""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from collections.abc import Callable, Iterator
+from fractions import Fraction
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision._cv2._common import BackendUnavailableError
+from supervision._cv2.constants import (
+    _CAP_PROP_FPS,
+    _CAP_PROP_FRAME_COUNT,
+    _CAP_PROP_FRAME_HEIGHT,
+    _CAP_PROP_FRAME_WIDTH,
+    _CAP_PROP_POS_FRAMES,
+)
+
+logger = logging.getLogger(__name__)
+
+# PyAV is imported locally in each function below, not at module scope: it
+# bundles its own `libavdevice`, which macOS's Objective-C runtime treats as
+# a duplicate of the one OpenCV's wheel already bundles when both are loaded
+# into the same process (GH-2505). Deferring the import until a PyAV-backed
+# capture/writer/remux call actually happens keeps an OpenCV-only import
+# from ever touching PyAV's native libraries.
+
+_CODECS = {
+    "mp4v": ("mpeg4", "yuv420p"),
+    "xvid": ("mpeg4", "yuv420p"),
+    "avc1": ("libx264", "yuv420p"),
+    "h264": ("libx264", "yuv420p"),
+    "mjpg": ("mjpeg", "yuvj420p"),
+    "vp09": ("libvpx-vp9", "yuv420p"),
+}
+
+
+def _video_writer_fourcc(*chars: str) -> int:
+    """Encode four single-character strings using OpenCV's integer layout."""
+    if len(chars) != 4 or any(len(char) != 1 for char in chars):
+        raise TypeError("VideoWriter_fourcc requires exactly four characters")
+    return sum(ord(char) << (8 * index) for index, char in enumerate(chars))
+
+
+def _decode_fourcc(fourcc: int) -> str:
+    """Decode a fourcc integer into its four-character representation."""
+    return "".join(chr((fourcc >> (8 * index)) & 0xFF) for index in range(4))
+
+
+def _codec_details(fourcc: int) -> tuple[str, str]:
+    """Return the PyAV codec and pixel format for a supported fourcc."""
+    code = _decode_fourcc(fourcc).lower()
+    try:
+        return _CODECS[code]
+    except KeyError as exc:
+        raise ValueError(f"Unsupported video codec: {code!r}") from exc
+
+
+def _quarter_turns(rotation: int) -> int:
+    """Return the counterclockwise quarter turns OpenCV applies for a display rotation.
+
+    Phones store a portrait video as landscape frames plus a display matrix, and
+    OpenCV's FFmpeg backend turns every frame upright by that matrix, but only for
+    multiples of 90 degrees; any other angle is left alone.
+    """
+    quarter_turns, remainder = divmod(rotation, 90)
+    return 0 if remainder else quarter_turns % 4
+
+
+class _VideoCapture:
+    """Expose OpenCV-shaped file capture backed by PyAV decoding."""
+
+    def __init__(self, source: str | os.PathLike[str] | int) -> None:
+        """Open a file source and retain a lazy PyAV frame iterator."""
+        self._container: Any = None
+        self._stream: Any = None
+        self._frames: Iterator[Any] | None = None
+        self._source = source
+        self._position = 0
+        self._frame_count_cache: int | None = None
+        self._rotation_cache: int | None = None
+        self._opened = False
+        self._error: Exception | None = None
+
+        try:
+            if isinstance(source, int):
+                raise BackendUnavailableError(
+                    "PyAV fallback supports file paths, not webcam device indexes."
+                )
+            import av
+
+            self._container = av.open(str(source), mode="r")
+            if not self._container.streams.video:
+                raise ValueError(f"Video source has no video stream: {source}")
+            self._stream = self._container.streams.video[0]
+            self._frames = iter(self._container.decode(video=self._stream.index))
+            self._opened = True
+        except Exception as exc:
+            self._error = exc
+            logger.warning("Failed to open video source %r: %s", source, exc)
+            self.release()
+
+    def isOpened(self) -> bool:
+        """Return whether the underlying video file is open for reading."""
+        return self._opened
+
+    def _frame_count(self) -> int:
+        """Return the stream count, decoding a second handle if metadata lacks it."""
+        if self._frame_count_cache is not None:
+            return self._frame_count_cache
+
+        count = int(getattr(self._stream, "frames", 0) or 0)
+        if count <= 0 and not isinstance(self._source, int):
+            import av
+
+            container = av.open(str(self._source), mode="r")
+            try:
+                count = sum(1 for _ in container.decode(video=self._stream.index))
+            finally:
+                container.close()
+        self._frame_count_cache = count
+        return count
+
+    def _rotation(self) -> int:
+        """Return the stream's display rotation, decoding one frame on a second handle.
+
+        PyAV only exposes the display matrix on decoded frames, so the first frame is
+        decoded from a separate container to leave this capture's position untouched.
+        """
+        if self._rotation_cache is not None:
+            return self._rotation_cache
+
+        import av
+
+        container = av.open(str(self._source), mode="r")
+        try:
+            frames = container.decode(video=self._stream.index)
+            rotation = next((int(frame.rotation) for frame in frames), 0)
+        finally:
+            container.close()
+        self._rotation_cache = rotation
+        return rotation
+
+    def get(self, property_id: int) -> float:
+        """Return the supported OpenCV capture property as a float.
+
+        Width and height are those of the upright frames `read` returns, so they swap
+        for a video whose display matrix turns it by a quarter, as in OpenCV.
+        """
+        if not self._opened:
+            return 0.0
+        if property_id in (_CAP_PROP_FRAME_WIDTH, _CAP_PROP_FRAME_HEIGHT):
+            width, height = self._stream.width, self._stream.height
+            if _quarter_turns(self._rotation()) % 2:
+                width, height = height, width
+            return float(width if property_id == _CAP_PROP_FRAME_WIDTH else height)
+        if property_id == _CAP_PROP_FPS:
+            rate = getattr(self._stream, "average_rate", None) or getattr(
+                self._stream, "base_rate", None
+            )
+            return float(rate) if rate is not None else 0.0
+        if property_id == _CAP_PROP_FRAME_COUNT:
+            return float(self._frame_count())
+        if property_id == _CAP_PROP_POS_FRAMES:
+            return float(self._position)
+        return 0.0
+
+    def _reset(self) -> None:
+        """Seek the decoder to the first frame and reset the logical position."""
+        self._container.seek(0, stream=self._stream, backward=True)
+        self._frames = iter(self._container.decode(video=self._stream.index))
+        self._position = 0
+
+    def set(self, property_id: int, value: float) -> bool:
+        """Set the supported frame-position property using exact frame decoding."""
+        if not self._opened or property_id != _CAP_PROP_POS_FRAMES:
+            return False
+        target = max(0, round(value))
+        if target > self._frame_count():
+            return False
+        if target < self._position:
+            self._reset()
+        while self._position < target:
+            success, _ = self.read()
+            if not success:
+                return False
+        return True
+
+    def read(self) -> tuple[bool, npt.NDArray[np.uint8] | None]:
+        """Decode and return the next frame upright in OpenCV's BGR array format."""
+        if not self._opened or self._frames is None:
+            return False, None
+        try:
+            frame = next(self._frames)
+        except StopIteration:
+            return False, None
+        except Exception as exc:
+            self._error = exc
+            return False, None
+
+        self._position += 1
+        image = frame.to_ndarray(format="bgr24")
+        quarter_turns = _quarter_turns(int(frame.rotation))
+        if quarter_turns:
+            image = np.ascontiguousarray(np.rot90(image, quarter_turns))
+        return True, image
+
+    def grab(self) -> bool:
+        """Decode and discard one frame."""
+        success, _ = self.read()
+        return success
+
+    def release(self) -> None:
+        """Close the PyAV container and make subsequent reads return false."""
+        container = self._container
+        self._container = None
+        self._stream = None
+        self._frames = None
+        self._opened = False
+        if container is not None:
+            container.close()
+
+
+class _VideoWriter:
+    """Expose OpenCV-shaped video writing backed by PyAV encoding."""
+
+    def __init__(
+        self,
+        filename: str | os.PathLike[str],
+        fourcc: int,
+        fps: float,
+        frame_size: tuple[int, int],
+        is_color: bool = True,
+    ) -> None:
+        """Open a PyAV writer for the requested codec and frame dimensions.
+
+        The PyAV fallback always encodes 3-channel BGR frames, so grayscale
+        output is unsupported. ``is_color=False`` is rejected up front rather
+        than silently ignored, keeping the OpenCV-shaped contract honest for
+        callers that would otherwise expect single-channel writes.
+
+        Raises:
+            NotImplementedError: If ``is_color`` is ``False``; grayscale
+                writing is not supported by the PyAV fallback.
+        """
+        if not is_color:
+            raise NotImplementedError(
+                "PyAV video fallback only supports color (3-channel BGR) frames; "
+                "is_color=False is not implemented."
+            )
+        self._container: Any = None
+        self._stream: Any = None
+        self._width, self._height = frame_size
+        self._opened = False
+        self._error: Exception | None = None
+
+        try:
+            import av
+
+            codec, pixel_format = _codec_details(fourcc)
+            self._container = av.open(str(filename), mode="w")
+            rate = Fraction(str(fps)).limit_denominator(100_000)
+            self._stream = self._container.add_stream(codec, rate=rate)
+            self._stream.width = self._width
+            self._stream.height = self._height
+            self._stream.pix_fmt = pixel_format
+            self._opened = True
+        except Exception as exc:
+            self._error = exc
+            self.release()
+
+    def isOpened(self) -> bool:
+        """Return whether the writer initialized successfully."""
+        return self._opened
+
+    def write(self, frame: npt.NDArray[np.uint8]) -> None:
+        """Encode one BGR frame and mux all packets produced by the encoder."""
+        if not self._opened or self._container is None or self._stream is None:
+            raise RuntimeError("Video writer is not open") from self._error
+        if frame.shape != (self._height, self._width, 3):
+            raise ValueError(
+                "Video frame must have shape "
+                f"({self._height}, {self._width}, 3), got {frame.shape}"
+            )
+        if frame.dtype != np.uint8:
+            raise ValueError("Video frames must use uint8 dtype")
+
+        import av
+
+        video_frame = av.VideoFrame.from_ndarray(
+            np.ascontiguousarray(frame), format="bgr24"
+        )
+        for packet in self._stream.encode(video_frame):
+            self._container.mux(packet)
+
+    def release(self) -> None:
+        """Flush delayed encoder packets and close the output container."""
+        container = self._container
+        stream = self._stream
+        self._container = None
+        self._stream = None
+        self._opened = False
+        if container is None:
+            return
+        try:
+            if stream is not None:
+                for packet in stream.encode():
+                    container.mux(packet)
+        finally:
+            container.close()
+
+
+def _timestamp_seconds(timestamp: int | None, time_base: Any) -> float | None:
+    """Convert a stream timestamp to seconds while preserving missing values."""
+    return None if timestamp is None else float(timestamp * time_base)
+
+
+def _best_effort_cleanup(action: Callable[[], None], description: str) -> None:
+    """Run a cleanup action, logging and suppressing any failure.
+
+    Cleanup steps in a ``finally`` block must never raise, otherwise a failing
+    ``container.close()`` (or file removal) would mask or replace the primary
+    result or the original exception that sent control into ``finally``.
+    """
+    try:
+        action()
+    except Exception as exc:
+        logger.debug("Cleanup step failed (%s): %s", description, exc)
+
+
+def _mux_audio(source_path: str, video_path: str) -> None:
+    """Remux the source's first audio stream into the processed video with PyAV."""
+    source_container: Any = None
+    video_container: Any = None
+    output_container: Any = None
+    temporary_path: str | None = None
+    try:
+        import av
+
+        source_container = av.open(source_path, mode="r")
+        video_container = av.open(video_path, mode="r")
+        if not source_container.streams.audio or not video_container.streams.video:
+            logger.info("No audio or video stream available; leaving output unchanged")
+            return
+
+        source_audio = source_container.streams.audio[0]
+        target_video = video_container.streams.video[0]
+        suffix = Path(video_path).suffix
+        with tempfile.NamedTemporaryFile(
+            suffix=suffix, dir=str(Path(video_path).absolute().parent), delete=False
+        ) as temporary_file:
+            temporary_path = temporary_file.name
+
+        output_container = av.open(temporary_path, mode="w")
+        output_video = output_container.add_stream_from_template(target_video)
+        output_audio = output_container.add_stream_from_template(source_audio)
+
+        # Copy encoded packets to avoid a lossy decode/re-encode cycle for both streams.
+        video_base: int | None = None
+        video_duration: float | None = None
+        for packet in video_container.demux(target_video):
+            if packet.pts is None and packet.dts is None:
+                continue
+            if video_base is None:
+                video_base = packet.pts if packet.pts is not None else packet.dts
+            if video_base is None:
+                continue
+            packet.pts = None if packet.pts is None else packet.pts - video_base
+            packet.dts = None if packet.dts is None else packet.dts - video_base
+            packet.stream = output_video
+            output_container.mux(packet)
+            packet_end = packet.pts
+            if packet_end is not None:
+                packet_end += packet.duration or 0
+                packet_seconds = _timestamp_seconds(packet_end, target_video.time_base)
+                if packet_seconds is not None:
+                    video_duration = max(video_duration or 0.0, packet_seconds)
+
+        # Rebase audio independently and stop at the processed video duration, matching
+        # ffmpeg's `-shortest` behavior without requiring a system executable.
+        audio_base: int | None = None
+        for packet in source_container.demux(source_audio):
+            if packet.pts is None and packet.dts is None:
+                continue
+            if audio_base is None:
+                audio_base = packet.pts if packet.pts is not None else packet.dts
+            if audio_base is None:
+                continue
+            relative_pts = None if packet.pts is None else packet.pts - audio_base
+            relative_seconds = _timestamp_seconds(relative_pts, source_audio.time_base)
+            if (
+                video_duration is not None
+                and relative_seconds is not None
+                and relative_seconds > video_duration
+            ):
+                break
+            packet.pts = relative_pts
+            packet.dts = None if packet.dts is None else packet.dts - audio_base
+            packet.stream = output_audio
+            output_container.mux(packet)
+
+        output_container.close()
+        output_container = None
+        video_container.close()
+        video_container = None
+        source_container.close()
+        source_container = None
+        os.replace(temporary_path, video_path)
+        temporary_path = None
+    except Exception as exc:
+        logger.warning("Audio remuxing failed: %s. Output video has no audio.", exc)
+    finally:
+        # Cleanup runs best-effort: a failing close/remove here must not mask the
+        # primary result or replace the original exception handled above.
+        if output_container is not None:
+            _best_effort_cleanup(output_container.close, "closing output container")
+        if video_container is not None:
+            _best_effort_cleanup(video_container.close, "closing video container")
+        if source_container is not None:
+            _best_effort_cleanup(source_container.close, "closing source container")
+        if temporary_path is not None and os.path.exists(temporary_path):
+            leftover_path = temporary_path
+            _best_effort_cleanup(
+                lambda: os.remove(leftover_path), "removing temporary file"
+            )
diff --git a/.venv/lib/python3.12/site-packages/supervision/_cv2/constants.py b/.venv/lib/python3.12/site-packages/supervision/_cv2/constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ab4fc783404d9049d7924230bd3d2df5e421902
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/_cv2/constants.py
@@ -0,0 +1,32 @@
+"""Private numeric constants used by the OpenCV compatibility modules."""
+
+_BORDER_CONSTANT = 0
+_CAP_PROP_FPS = 5
+_CAP_PROP_FRAME_COUNT = 7
+_CAP_PROP_FRAME_HEIGHT = 4
+_CAP_PROP_FRAME_WIDTH = 3
+_CAP_PROP_POS_FRAMES = 1
+_CC_STAT_AREA = 4
+_CHAIN_APPROX_SIMPLE = 2
+_COLOR_BGR2GRAY = 6
+_COLOR_BGR2RGB = 4
+_COLOR_GRAY2BGR = 8
+_COLOR_HSV2BGR = 54
+_COLOR_RGB2BGR = 4
+_FONT_HERSHEY_SIMPLEX = 0
+_FONT_HERSHEY_PLAIN = 1
+_FONT_HERSHEY_DUPLEX = 2
+_FONT_HERSHEY_COMPLEX = 3
+_FONT_HERSHEY_TRIPLEX = 4
+_FONT_HERSHEY_COMPLEX_SMALL = 5
+_FONT_HERSHEY_SCRIPT_SIMPLEX = 6
+_FONT_HERSHEY_SCRIPT_COMPLEX = 7
+_FONT_ITALIC = 16
+_IMREAD_COLOR = 1
+_IMREAD_UNCHANGED = -1
+_INTER_LINEAR = 1
+_INTER_NEAREST = 0
+_LINE_4 = 4
+_LINE_8 = 8
+_LINE_AA = 16
+_RETR_TREE = 3
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/__init__.py b/.venv/lib/python3.12/site-packages/supervision/annotators/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad1a3e4caa807a287ff088f8f4e5ea0e707afac5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/base.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/base.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5d7c0420674e948babc2ed24f173f1833510689b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/base.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5ed89620ea6d93891d9bcb2670291df15f3039e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/core.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3052e3da8305f5d139ce024b04f51b551334c6fcc969e432da03ff39ce4e365e
+size 147406
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a6daf6cc72d1e96c1b336db8eb4fda4d8853361
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/annotators/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/base.py b/.venv/lib/python3.12/site-packages/supervision/annotators/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8f6f2c67364bc2a890e00c5e966dc6ad0c1d3d1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/annotators/base.py
@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+from typing import Any
+
+from supervision.detection.core import Detections
+
+
+class BaseAnnotator(ABC):
+    """Base class for annotators that consume :class:`Detections`.
+
+    Attributes:
+        requires_mask: Whether integrations must provide ``Detections.mask`` for
+            this annotator. Check this before materializing expensive mask payloads.
+    """
+
+    requires_mask: bool = False
+
+    @abstractmethod
+    def annotate(
+        self, scene: Any, detections: Detections, *args: Any, **kwargs: Any
+    ) -> Any:
+        pass
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/core.py b/.venv/lib/python3.12/site-packages/supervision/annotators/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..e43928193e95f2cc595134859dd5d0b6ef70c5cd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/annotators/core.py
@@ -0,0 +1,3658 @@
+from collections.abc import Iterator
+from functools import lru_cache
+from math import sqrt
+from typing import Any, ClassVar, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void  # type: ignore[import-untyped,unused-ignore]
+from PIL import Image, ImageDraw, ImageFont
+from scipy.interpolate import splev, splprep
+
+from supervision import _cv2 as cv2
+from supervision.annotators.base import BaseAnnotator
+from supervision.annotators.utils import (
+    PENDING_TRACK_ID,
+    ColorLookup,
+    Trace,
+    _validate_labels,
+    calculate_dynamic_kernel_size,
+    calculate_dynamic_pixel_size,
+    get_labels_text,
+    hex_to_rgba,
+    resolve_color,
+    resolve_text_background_xyxy,
+    snap_boxes,
+    wrap_text,
+)
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.utils.boxes import clip_boxes, spread_out_boxes
+from supervision.detection.utils.converters import (
+    mask_to_polygons,
+    polygon_to_mask,
+    xyxy_to_polygons,
+)
+from supervision.detection.utils.masks import _masks_to_roi
+from supervision.draw.base import ImageType
+from supervision.draw.color import Color, ColorPalette
+from supervision.draw.utils import draw_polygon, draw_rounded_rectangle, draw_text
+from supervision.geometry.core import Point, Position, Rect
+from supervision.utils.conversion import (
+    ensure_cv2_image_for_class_method,
+    ensure_pil_image_for_class_method,
+)
+from supervision.utils.image import (
+    _overlay_image,
+    crop_image,
+    letterbox_image,
+    scale_image,
+)
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+
+@lru_cache
+def _load_icon_from_path(
+    icon_path: str, icon_resolution_wh: tuple[int, int]
+) -> npt.NDArray[np.uint8]:
+    """Load and resize an icon image through a cache shared by annotators.
+
+    Icons are read unchanged to keep their alpha channel, which also keeps a grayscale
+    PNG as a 2-D array and a 16-bit PNG at 16 bits. A 16-bit icon is scaled down to 8
+    bits and a grayscale icon is expanded to BGR, the depth and layout the icon overlay
+    draws; an icon of any other pixel type is rejected.
+    """
+    icon = cv2.imread(icon_path, cv2.IMREAD_UNCHANGED)
+    if icon is None:
+        raise FileNotFoundError(f"Error: Couldn't load the icon image from {icon_path}")
+    icon_array: npt.NDArray[np.uint8]
+    if icon.dtype == np.uint8:
+        icon_array = cast(npt.NDArray[np.uint8], icon)
+    elif icon.dtype == np.uint16:
+        # The overlay writes the icon into an 8-bit scene, where a 16-bit value wraps
+        # modulo 256 and redraws a bright icon as a dark one; keep the high byte.
+        icon_array = np.clip(np.rint(icon / 256), 0, 255).astype(np.uint8)
+    else:
+        raise ValueError(
+            f"Icon image ('{icon_path}') has an unsupported pixel type "
+            f"('{icon.dtype}'); an icon must be 8-bit or 16-bit."
+        )
+    if icon_array.ndim == 2:
+        icon_array = cast(
+            npt.NDArray[np.uint8], cv2.cvtColor(icon_array, cv2.COLOR_GRAY2BGR)
+        )
+    result: npt.NDArray[np.uint8] = letterbox_image(
+        image=icon_array, resolution_wh=icon_resolution_wh
+    )
+    return result
+
+
+def _normalize_color_input(color: Color | ColorPalette | str) -> Color | ColorPalette:
+    """Normalize accepted color inputs to internal color objects.
+
+    Accepts `Color`, `ColorPalette`, or hex string input. Hex strings are parsed via
+    `hex_to_rgba` and converted to `Color` (alpha channel is ignored because annotator
+    drawing uses RGB/BGR colors).
+    """
+    if isinstance(color, str):
+        r, g, b, _ = hex_to_rgba(color)
+        return Color.from_rgb_tuple((r, g, b))
+    return color
+
+
+CV2_FONT = cv2.FONT_HERSHEY_SIMPLEX
+
+
+class _BaseLabelAnnotator(BaseAnnotator):
+    """
+    Base class for annotators that add labels to detections.
+
+    Attributes:
+        color: The color to use for the label background.
+        color_lookup: The method used to determine the color of the label.
+        text_color: The color to use for the label text.
+        text_padding: The padding around the label text, in pixels.
+        text_anchor: The position of the text relative to the detection
+            bounding box.
+        text_offset: A tuple of 2D coordinates `(x, y)` to
+            offset the text position from the anchor point, in pixels.
+        border_radius: The radius of the label background corners, in pixels.
+        smart_position: Whether to intelligently adjust the label position to
+            avoid overlapping with other elements.
+        max_line_length: Maximum number of characters per line before
+            wrapping the text. None means no wrapping.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        text_color: Color | ColorPalette | str = Color.WHITE,
+        text_padding: int = 10,
+        text_position: Position = Position.TOP_LEFT,
+        text_offset: tuple[int, int] = (0, 0),
+        border_radius: int = 0,
+        smart_position: bool = False,
+        max_line_length: int | None = None,
+    ):
+        """
+        Initializes the _BaseLabelAnnotator.
+
+        Args:
+            color: The color to use for the label
+                background.
+            color_lookup: The method used to determine the color
+                of the label
+            text_color: The color to use for the
+                label text.
+            text_padding: The padding around the label text, in pixels.
+            text_position: The position of the text relative to the
+                detection bounding box.
+            text_offset: A tuple of 2D coordinates
+                `(x, y)` to offset the text position from the anchor point, in pixels.
+            border_radius: The radius of the label background corners,
+                in pixels.
+            smart_position: Whether to intelligently adjust the label
+                position to avoid overlapping with other elements.
+            max_line_length: Maximum number of characters per
+                line before wrapping the text. None means no wrapping.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.color_lookup: ColorLookup = color_lookup
+        self.text_color: Color | ColorPalette = _normalize_color_input(text_color)
+        self.text_padding: int = text_padding
+        self.text_anchor: Position = text_position
+        self.text_offset: tuple[int, int] = text_offset
+        self.border_radius: int = border_radius
+        self.smart_position = smart_position
+        self.max_line_length: int | None = max_line_length
+
+    def _adjust_labels_in_frame(
+        self,
+        resolution_wh: tuple[int, int],
+        labels: list[str],
+        label_properties: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.float32]:
+        """
+        Adjusts the position of labels to ensure they stay within the frame boundaries.
+
+        Args:
+            resolution_wh: The width and height of the frame.
+            labels: The list of text labels.
+            label_properties: An array of label properties, where each row
+                            contains [x1, y1, x2, y2, text_height, ...].
+
+        Returns:
+            The adjusted label properties.
+        """
+        adjusted_properties = label_properties.copy()
+
+        # First, make sure the boxes don't go outside the frame
+        adjusted_properties[:, :4] = snap_boxes(
+            adjusted_properties[:, :4],
+            resolution_wh,
+        )
+
+        # Apply the spread out algorithm to avoid box overlaps
+        if len(labels) > 1:
+            # Extract the box coordinates
+            boxes = adjusted_properties[:, :4]
+            # Use the spread_out_boxes function to adjust overlapping boxes
+            spread_boxes = spread_out_boxes(boxes)
+            # Update the properties with the spread out boxes
+            adjusted_properties[:, :4] = spread_boxes
+
+            # Additional check to ensure boxes are still within frame after spreading
+            adjusted_properties[:, :4] = snap_boxes(
+                adjusted_properties[:, :4], resolution_wh
+            )
+
+        return cast(
+            npt.NDArray[np.float32],
+            np.asarray(adjusted_properties, dtype=np.float32),
+        )
+
+
+class BoxAnnotator(BaseAnnotator):
+    """
+    A class for drawing bounding boxes on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the bounding box lines.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with bounding boxes based on the provided detections.
+
+        Args:
+            scene: The image where bounding boxes will be drawn. `ImageType`
+                is a flexible type, accepting either `numpy.ndarray` or
+                `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> box_annotator = sv.BoxAnnotator()
+            >>> annotated_frame = box_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![bounding-box-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/bounding-box-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        for detection_idx in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            cv2.rectangle(
+                img=scene,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
+                color=color.as_bgr(),
+                thickness=self.thickness,
+            )
+        return scene
+
+
+class OrientedBoxAnnotator(BaseAnnotator):
+    """
+    A class for drawing oriented bounding boxes on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the bounding box lines.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with oriented bounding boxes based on the
+        provided detections.
+
+        Args:
+            scene: The image where bounding boxes will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from ultralytics import YOLO
+
+            image = cv2.imread("")
+            model = YOLO("yolov8n-obb.pt")
+
+            result = model(image)[0]
+            detections = sv.Detections.from_ultralytics(result)
+
+            oriented_box_annotator = sv.OrientedBoxAnnotator()
+            annotated_frame = oriented_box_annotator.annotate(
+                scene=image.copy(),
+                detections=detections
+            )
+            ```
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from supervision.config import ORIENTED_BOX_COORDINATES
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> obb = np.array([[[20, 20], [80, 20], [80, 80], [20, 80]]])
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0]),
+            ...     data={ORIENTED_BOX_COORDINATES: obb},
+            ... )
+            >>> oriented_box_annotator = sv.OrientedBoxAnnotator()
+            >>> annotated_frame = oriented_box_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if detections.data is None or ORIENTED_BOX_COORDINATES not in detections.data:
+            return scene
+        obb_boxes = np.array(detections.data[ORIENTED_BOX_COORDINATES]).astype(int)
+
+        for detection_idx in range(len(detections)):
+            obb = obb_boxes[detection_idx]
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+
+            cv2.drawContours(scene, [obb], 0, color.as_bgr(), self.thickness)
+
+        return scene
+
+
+# --- Shared mask-painting utilities ---
+def _iter_mask_crops(
+    detections: Detections,
+) -> Iterator[tuple[int, npt.NDArray[np.bool_], npt.NDArray[np.int32] | None]]:
+    """Yield ``(detection_idx, mask_or_crop, offset_or_None)`` for each mask.
+
+    Encapsulates the ``CompactMask`` vs dense dispatch so individual annotators
+    do not need inline ``isinstance`` checks. For ``CompactMask`` inputs yields
+    the bbox crop and its ``(x1, y1)`` image-space origin; for dense masks
+    yields the full-frame boolean slice with ``offset=None``.
+
+    Args:
+        detections: Object detections whose masks to iterate.
+
+    Yields:
+        Tuple of ``(detection_idx, mask_or_crop, offset_or_None)``.
+        ``mask_or_crop`` is boolean (crop-sized for ``CompactMask``, full-frame
+        for dense). ``offset_or_None`` is an int32 ``(x1, y1)`` array for
+        crop→image translation, or ``None`` for dense masks.
+    """
+    masks = detections.mask
+    if masks is None:
+        return
+    # TODO: replace isinstance dispatch with a MaskLike Protocol (separate PR)
+    compact_mask = masks if isinstance(masks, CompactMask) else None
+    for detection_idx in range(len(detections)):
+        if compact_mask is None:
+            yield (
+                detection_idx,
+                cast(npt.NDArray[np.bool_], masks[detection_idx]),
+                None,
+            )
+        else:
+            yield (
+                detection_idx,
+                compact_mask.crop(detection_idx),
+                compact_mask.offsets[detection_idx],
+            )
+
+
+def _paint_masks_by_area(
+    canvas: npt.NDArray[np.uint8],
+    detections: Detections,
+    color: Color | ColorPalette,
+    color_lookup: ColorLookup | npt.NDArray[np.int_],
+    collect_union: bool = False,
+    canvas_origin: tuple[int, int] = (0, 0),
+) -> npt.NDArray[np.bool_] | None:
+    """Paint each detection's mask into `canvas` in descending-area order.
+
+    Smaller masks are drawn on top of larger ones. `CompactMask` detections
+    are painted into their bounding-box crop only, avoiding a full `(H, W)`
+    allocation per mask; dense masks fall back to full-frame boolean indexing.
+
+    Args:
+        canvas: BGR image array painted in place. Shape ``(H, W, 3)``.
+        detections: Detections whose masks to paint. Returns immediately
+            without modifying `canvas` when ``detections.mask`` is ``None``.
+        color: Single color or palette used to resolve each detection's color.
+        color_lookup: Strategy for mapping colors to detection indices.
+        collect_union: When ``True``, allocate and return a ``(H, W)``
+            boolean array that accumulates the union of all painted masks
+            (useful for callers like `HaloAnnotator` that need the combined
+            mask footprint). When ``False`` (default), returns ``None``.
+        canvas_origin: Absolute ``(x, y)`` origin of `canvas` within the source
+            image. Use the default for full-frame painting.
+
+    Returns:
+        A boolean array matching the canvas dimensions when
+        ``collect_union=True``, otherwise ``None``. When called with an
+        ROI sub-canvas, dimensions are the ROI size, not the full image.
+    """
+    masks = detections.mask
+    if masks is None:
+        return None
+    union: npt.NDArray[np.bool_] | None = (
+        np.zeros(canvas.shape[:2], dtype=bool) if collect_union else None
+    )
+    compact_mask = masks if isinstance(masks, CompactMask) else None
+    origin_x, origin_y = canvas_origin
+    canvas_h, canvas_w = canvas.shape[:2]
+    for detection_idx in np.flip(np.argsort(detections.area)):
+        color_bgr = resolve_color(
+            color=color,
+            detections=detections,
+            detection_idx=detection_idx,
+            color_lookup=color_lookup,
+        ).as_bgr()
+        if compact_mask is not None:
+            x1 = int(compact_mask.offsets[detection_idx, 0])
+            y1 = int(compact_mask.offsets[detection_idx, 1])
+            crop_m = compact_mask.crop(detection_idx)
+            crop_h, crop_w = crop_m.shape
+            crop_x1 = max(0, origin_x - x1)
+            crop_y1 = max(0, origin_y - y1)
+            canvas_x1 = max(0, x1 - origin_x)
+            canvas_y1 = max(0, y1 - origin_y)
+            paint_w = min(crop_w - crop_x1, canvas_w - canvas_x1)
+            paint_h = min(crop_h - crop_y1, canvas_h - canvas_y1)
+            if paint_w <= 0 or paint_h <= 0:
+                continue
+            crop_slice = crop_m[
+                crop_y1 : crop_y1 + paint_h, crop_x1 : crop_x1 + paint_w
+            ]
+            canvas_slice = canvas[
+                canvas_y1 : canvas_y1 + paint_h,
+                canvas_x1 : canvas_x1 + paint_w,
+            ]
+            canvas_slice[crop_slice] = color_bgr
+            if union is not None:
+                union[
+                    canvas_y1 : canvas_y1 + paint_h,
+                    canvas_x1 : canvas_x1 + paint_w,
+                ] |= crop_slice
+        else:
+            mask = np.asarray(masks[detection_idx], dtype=bool)
+            mask = mask[origin_y : origin_y + canvas_h, origin_x : origin_x + canvas_w]
+            canvas[mask] = color_bgr
+            if union is not None:
+                union |= mask
+    return union
+
+
+class MaskAnnotator(BaseAnnotator):
+    """
+    A class for drawing masks on an image using provided detections.
+
+    !!! warning
+
+        This annotator uses `sv.Detections.mask`.
+    """
+
+    requires_mask = True
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        opacity: float = 0.5,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.opacity = opacity
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with masks based on the provided detections.
+
+        Args:
+            scene: The image where masks will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     mask=np.zeros((1, 100, 100), dtype=bool),
+            ...     class_id=np.array([0])
+            ... )
+            >>> mask_annotator = sv.MaskAnnotator()
+            >>> annotated_frame = mask_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![mask-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/mask-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if detections.mask is None:
+            return scene
+
+        image_shape = (int(scene.shape[0]), int(scene.shape[1]))
+        effective_lookup = (
+            self.color_lookup if custom_color_lookup is None else custom_color_lookup
+        )
+        if len(detections) > 0:
+            resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=0,
+                color_lookup=effective_lookup,
+            )
+        roi = _masks_to_roi(detections.mask, image_shape, detections.xyxy)
+        if roi is None:
+            return scene
+
+        x1, y1, x2, y2 = roi
+        scene_roi = scene[y1:y2, x1:x2]
+        colored_mask = np.array(scene_roi, copy=True, dtype=np.uint8)
+        _paint_masks_by_area(
+            colored_mask,
+            detections,
+            self.color,
+            effective_lookup,
+            canvas_origin=(x1, y1),
+        )
+        tmp = cv2.addWeighted(
+            colored_mask, self.opacity, scene_roi.copy(), 1 - self.opacity, 0
+        )
+        scene_roi[:] = tmp
+        return scene
+
+
+class PolygonAnnotator(BaseAnnotator):
+    """
+    A class for drawing polygons on an image using provided detections.
+
+    !!! warning
+
+        This annotator uses `sv.Detections.mask`.
+    """
+
+    requires_mask = True
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the polygon lines.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with polygons based on the provided detections.
+
+        Args:
+            scene: The image where polygons will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> polygon_annotator = sv.PolygonAnnotator()
+            >>> annotated_frame = polygon_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        Note:
+            When `detections.mask` is a `CompactMask`, each detection's polygon
+            is decoded from a bbox-sized crop (O(crop_area)) rather than a
+            full-frame ``(H, W)`` allocation (O(H·W)). Polygon coordinates are
+            shifted from crop-local space to image space via the stored
+            ``(x1, y1)`` bbox origin. Pixels outside the declared ``xyxy`` box
+            are not represented in compact storage and will not be drawn.
+
+        ![polygon-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/polygon-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if detections.mask is None:
+            return scene
+
+        for detection_idx, mask, offset in _iter_mask_crops(detections):
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            for polygon in mask_to_polygons(mask=mask):
+                if offset is not None:
+                    # translate crop-local polygon to image space via (x1, y1) origin
+                    polygon = polygon + offset
+                scene = draw_polygon(
+                    scene=scene,
+                    polygon=cast(npt.NDArray[np.int_], polygon),
+                    color=color,
+                    thickness=self.thickness,
+                )
+
+        return scene
+
+
+class ColorAnnotator(BaseAnnotator):
+    """
+    A class for drawing box masks on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        opacity: float = 0.5,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.color_lookup: ColorLookup = color_lookup
+        self.opacity = opacity
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with box masks based on the provided detections.
+
+        Args:
+            scene: The image where bounding boxes will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> color_annotator = sv.ColorAnnotator()
+            >>> annotated_frame = color_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![box-mask-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/box-mask-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        scene_with_boxes = scene.copy()
+        for detection_idx in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            cv2.rectangle(
+                img=scene_with_boxes,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
+                color=color.as_bgr(),
+                thickness=-1,
+            )
+
+        cv2.addWeighted(
+            scene_with_boxes, self.opacity, scene, 1 - self.opacity, gamma=0, dst=scene
+        )
+        return scene
+
+
+class HaloAnnotator(BaseAnnotator):
+    """
+    A class for drawing Halos on an image using provided detections.
+
+    !!! warning
+
+        This annotator uses `sv.Detections.mask`.
+    """
+
+    requires_mask = True
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        opacity: float = 0.8,
+        kernel_size: int = 40,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            kernel_size: The size of the average pooling kernel used for creating
+                the halo.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.opacity = opacity
+        self.color_lookup: ColorLookup = color_lookup
+        self.kernel_size: int = kernel_size
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with halos based on the provided detections.
+
+        Args:
+            scene: The image where the halo effect will be applied.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     mask=np.zeros((1, 100, 100), dtype=bool),
+            ...     class_id=np.array([0])
+            ... )
+            >>> halo_annotator = sv.HaloAnnotator()
+            >>> annotated_frame = halo_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![halo-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/halo-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if detections.mask is None:
+            return scene
+        colored_mask = np.zeros_like(scene, dtype=np.uint8)
+        fmask = _paint_masks_by_area(
+            colored_mask,
+            detections,
+            self.color,
+            self.color_lookup if custom_color_lookup is None else custom_color_lookup,
+            collect_union=True,
+        )
+        assert fmask is not None  # collect_union=True always returns an array
+
+        colored_mask = cast(
+            npt.NDArray[np.uint8],
+            cv2.blur(colored_mask, (self.kernel_size, self.kernel_size)),
+        )
+        colored_mask[fmask] = [0, 0, 0]
+        gray = cv2.cvtColor(colored_mask, cv2.COLOR_BGR2GRAY)
+        gray_max = gray.max()
+        if gray_max == 0:
+            # no halo to draw (e.g. empty masks); leave the scene untouched
+            return scene
+        alpha = self.opacity * gray / gray_max
+        alpha_mask = alpha[:, :, np.newaxis]
+        # Blend in float space so halo opacity cannot wrap around uint8 boundaries.
+        blended_scene = np.clip(
+            scene.astype(np.float32) * (1 - alpha_mask)
+            + colored_mask.astype(np.float32) * alpha_mask,
+            0,
+            255,
+        ).astype(np.uint8)
+        np.copyto(scene, blended_scene)
+        return scene
+
+
+class EllipseAnnotator(BaseAnnotator):
+    """
+    A class for drawing ellipses on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        start_angle: int = -45,
+        end_angle: int = 235,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the ellipse lines.
+            start_angle: Starting angle of the ellipse.
+            end_angle: Ending angle of the ellipse.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.start_angle: int = start_angle
+        self.end_angle: int = end_angle
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with ellipses based on the provided detections.
+
+        Args:
+            scene: The image where ellipses will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> ellipse_annotator = sv.EllipseAnnotator()
+            >>> annotated_frame = ellipse_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![ellipse-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/ellipse-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        for detection_idx in range(len(detections)):
+            x1, _y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            center = (int((x1 + x2) / 2), y2)
+            width = x2 - x1
+            cv2.ellipse(
+                scene,
+                center=center,
+                axes=(int(width), int(0.35 * width)),
+                angle=0.0,
+                startAngle=self.start_angle,
+                endAngle=self.end_angle,
+                color=color.as_bgr(),
+                thickness=self.thickness,
+                lineType=cv2.LINE_4,
+            )
+        return scene
+
+
+class BoxCornerAnnotator(BaseAnnotator):
+    """
+    A class for drawing box corners on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 4,
+        corner_length: int = 15,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the corner lines.
+            corner_length: Length of each corner line.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.corner_length: int = corner_length
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with box corners based on the provided detections.
+
+        Args:
+            scene: The image where box corners will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> corner_annotator = sv.BoxCornerAnnotator()
+            >>> annotated_frame = corner_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![box-corner-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/box-corner-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        for detection_idx in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            corners = [(x1, y1), (x2, y1), (x1, y2), (x2, y2)]
+
+            for x, y in corners:
+                x_end = x + self.corner_length if x == x1 else x - self.corner_length
+                cv2.line(
+                    scene, (x, y), (x_end, y), color.as_bgr(), thickness=self.thickness
+                )
+
+                y_end = y + self.corner_length if y == y1 else y - self.corner_length
+                cv2.line(
+                    scene, (x, y), (x, y_end), color.as_bgr(), thickness=self.thickness
+                )
+        return scene
+
+
+class CircleAnnotator(BaseAnnotator):
+    """
+    A class for drawing circle on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the circle line.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.color_lookup: ColorLookup = color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with circles based on the provided detections.
+
+        Args:
+            scene: The image where box corners will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> circle_annotator = sv.CircleAnnotator()
+            >>> annotated_frame = circle_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+
+        ![circle-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/circle-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        for detection_idx in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            center = ((x1 + x2) // 2, (y1 + y2) // 2)
+            distance = sqrt((x1 - center[0]) ** 2 + (y1 - center[1]) ** 2)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            cv2.circle(
+                img=scene,
+                center=center,
+                radius=int(distance),
+                color=color.as_bgr(),
+                thickness=self.thickness,
+            )
+
+        return scene
+
+
+class DotAnnotator(BaseAnnotator):
+    """
+    A class for drawing dots on an image at specific coordinates based on provided
+    detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        radius: int = 4,
+        position: Position = Position.CENTER,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        outline_thickness: int = 0,
+        outline_color: Color | ColorPalette | str = Color.BLACK,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            radius: Radius of the drawn dots.
+            position: The anchor position for placing the dot.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            outline_thickness: Thickness of the outline of the dot.
+            outline_color: The color or color palette to
+                use for outline. It is activated by setting outline_thickness to a value
+                greater than 0.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.radius: int = radius
+        self.position: Position = position
+        self.color_lookup: ColorLookup = color_lookup
+        self.outline_thickness = outline_thickness
+        self.outline_color: Color | ColorPalette = _normalize_color_input(outline_color)
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with dots based on the provided detections.
+
+        Args:
+            scene: The image where dots will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> dot_annotator = sv.DotAnnotator()
+            >>> annotated_frame = dot_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![dot-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/dot-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        xy = detections.get_anchors_coordinates(anchor=self.position)
+        for detection_idx in range(len(detections)):
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            center = (int(xy[detection_idx, 0]), int(xy[detection_idx, 1]))
+
+            cv2.circle(scene, center, self.radius, color.as_bgr(), -1)
+            if self.outline_thickness:
+                outline_color = resolve_color(
+                    color=self.outline_color,
+                    detections=detections,
+                    detection_idx=detection_idx,
+                    color_lookup=self.color_lookup
+                    if custom_color_lookup is None
+                    else custom_color_lookup,
+                )
+                cv2.circle(
+                    scene,
+                    center,
+                    self.radius,
+                    outline_color.as_bgr(),
+                    self.outline_thickness,
+                )
+        return scene
+
+
+class LabelAnnotator(_BaseLabelAnnotator):
+    """
+    A class for annotating labels on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        text_color: Color | ColorPalette | str = Color.WHITE,
+        text_scale: float = 0.5,
+        text_thickness: int = 1,
+        text_padding: int = 10,
+        text_position: Position = Position.TOP_LEFT,
+        text_offset: tuple[int, int] = (0, 0),
+        border_radius: int = 0,
+        smart_position: bool = False,
+        max_line_length: int | None = None,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating the text background.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            text_color: The color or color palette to use
+                for the text.
+            text_scale: Font scale for the text.
+            text_thickness: Thickness of the text characters.
+            text_padding: Padding around the text within its background box.
+            text_position: Position of the text relative to the detection.
+                Possible values are defined in the `Position` enum.
+            text_offset: A tuple of 2D coordinates `(x, y)` to
+                offset the text position from the anchor point, in pixels.
+            border_radius: The radius to apply round edges. If the selected
+                value is higher than the lower dimension, width or height, is clipped.
+            smart_position: Spread out the labels to avoid overlapping.
+            max_line_length: Maximum number of characters per line
+                before wrapping the text. None means no wrapping.
+        """
+        self.text_scale: float = text_scale
+        self.text_thickness: int = text_thickness
+        super().__init__(
+            color=color,
+            color_lookup=color_lookup,
+            text_color=text_color,
+            text_padding=text_padding,
+            text_position=text_position,
+            text_offset=text_offset,
+            border_radius=border_radius,
+            smart_position=smart_position,
+            max_line_length=max_line_length,
+        )
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        labels: list[str] | None = None,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with labels based on the provided detections.
+
+        Args:
+            scene: The image where labels will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            labels: Custom labels for each detection.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     confidence=np.array([0.9]),
+            ...     class_id=np.array([0]),
+            ...     data={'class_name': np.array(['person'])}
+            ... )
+            >>> labels = [
+            ...     f"{class_name} {confidence:.2f}"
+            ...     for class_name, confidence
+            ...     in zip(detections['class_name'], detections.confidence)
+            ... ]
+            >>> label_annotator = sv.LabelAnnotator(text_position=sv.Position.CENTER)
+            >>> annotated_frame = label_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections,
+            ...     labels=labels
+            ... )
+
+            ```
+
+        ![label-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/label-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        _validate_labels(labels, detections)
+
+        labels = get_labels_text(detections, labels)
+        label_properties: npt.NDArray[np.float32] = self._get_label_properties(
+            detections, labels
+        )
+
+        if self.smart_position:
+            label_properties = self._adjust_labels_in_frame(
+                (scene.shape[1], scene.shape[0]),
+                labels,
+                label_properties,
+            )
+
+        self._draw_labels(
+            scene=scene,
+            labels=labels,
+            label_properties=label_properties,
+            detections=detections,
+            custom_color_lookup=custom_color_lookup,
+        )
+
+        return scene
+
+    def _get_label_properties(
+        self,
+        detections: Detections,
+        labels: list[str],
+    ) -> Any:
+        label_properties = []
+        anchors_coordinates: npt.NDArray[np.int32] = detections.get_anchors_coordinates(
+            anchor=self.text_anchor
+        ).astype(int)
+
+        for label, center_coordinates in zip(labels, anchors_coordinates):
+            center_coordinates = (
+                center_coordinates[0] + self.text_offset[0],
+                center_coordinates[1] + self.text_offset[1],
+            )
+
+            wrapped_lines = wrap_text(label, self.max_line_length)
+            line_heights = []
+            line_widths = []
+
+            for line in wrapped_lines:
+                (text_w, text_h) = cv2.getTextSize(
+                    text=line,
+                    fontFace=CV2_FONT,
+                    fontScale=self.text_scale,
+                    thickness=self.text_thickness,
+                )[0]
+                line_heights.append(text_h)
+                line_widths.append(text_w)
+
+            # Get the maximum width and total height
+            max_width = max(line_widths) if line_widths else 0
+            total_height = (
+                sum(line_heights) + (len(line_heights) - 1) * self.text_padding
+            )
+
+            # Add padding around all sides
+            width_padded = max_width + 2 * self.text_padding
+            height_padded = total_height + 2 * self.text_padding
+
+            text_background_xyxy = resolve_text_background_xyxy(
+                center_coordinates=center_coordinates,
+                text_wh=(width_padded, height_padded),
+                position=self.text_anchor,
+            )
+
+            label_properties.append(
+                [
+                    *text_background_xyxy,
+                    total_height,
+                ]
+            )
+        return np.array(label_properties, dtype=np.float32).reshape(-1, 5)
+
+    def _draw_labels(
+        self,
+        scene: npt.NDArray[np.uint8],
+        labels: list[str],
+        label_properties: npt.NDArray[np.float32],
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None,
+    ) -> None:
+        assert len(labels) == len(label_properties) == len(detections), (
+            f"Number of label properties ({len(label_properties)}), "
+            f"labels ({len(labels)}) and detections ({len(detections)}) "
+            "do not match."
+        )
+
+        color_lookup = (
+            custom_color_lookup
+            if custom_color_lookup is not None
+            else self.color_lookup
+        )
+
+        for idx, label_property in enumerate(label_properties):
+            background_color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=idx,
+                color_lookup=color_lookup,
+            )
+            text_color = resolve_color(
+                color=self.text_color,
+                detections=detections,
+                detection_idx=idx,
+                color_lookup=color_lookup,
+            )
+
+            box_xyxy = label_property[:4].astype(int)
+
+            self.draw_rounded_rectangle(
+                scene=scene,
+                xyxy=box_xyxy,
+                color=background_color.as_bgr(),
+                border_radius=self.border_radius,
+            )
+
+            # Handle multiline text
+            wrapped_lines = wrap_text(labels[idx], self.max_line_length)
+            current_y = box_xyxy[1] + self.text_padding  # Start y position
+
+            for line in wrapped_lines:
+                if not line:
+                    # Use a character with ascenders and descenders as height reference
+                    (_, text_h) = cv2.getTextSize(
+                        text="Tg",
+                        fontFace=CV2_FONT,
+                        fontScale=self.text_scale,
+                        thickness=self.text_thickness,
+                    )[0]
+                    current_y += text_h + self.text_padding
+                    continue
+
+                (_, text_h) = cv2.getTextSize(
+                    text=line,
+                    fontFace=CV2_FONT,
+                    fontScale=self.text_scale,
+                    thickness=self.text_thickness,
+                )[0]
+
+                text_x = box_xyxy[0] + self.text_padding
+                text_y = current_y + text_h  # Add height to get to text baseline
+
+                cv2.putText(
+                    img=scene,
+                    text=line,
+                    org=(text_x, text_y),
+                    fontFace=CV2_FONT,
+                    fontScale=self.text_scale,
+                    color=text_color.as_bgr(),
+                    thickness=self.text_thickness,
+                    lineType=cv2.LINE_AA,
+                )
+
+                current_y += text_h + self.text_padding  # Move to next line position
+
+    @staticmethod
+    def draw_rounded_rectangle(
+        scene: npt.NDArray[np.uint8],
+        xyxy: tuple[int, int, int, int],
+        color: tuple[int, int, int],
+        border_radius: int,
+    ) -> npt.NDArray[np.uint8]:
+        """Draw a filled rectangle with optional rounded corners on an image.
+
+        Args:
+            scene: BGR image array to draw on; modified in-place and returned.
+            xyxy: Bounding box as (x1, y1, x2, y2) pixel coordinates.
+            color: Fill color as a BGR tuple (e.g. ``(0, 0, 255)`` for red).
+            border_radius: Corner rounding radius in pixels. Values <= 0
+                (including values clamped to 0 by a degenerate box) draw a
+                plain filled rectangle with square corners.
+
+        Returns:
+            The annotated ``scene`` array.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> scene = np.zeros((200, 200, 3), dtype=np.uint8)
+            >>> scene = sv.LabelAnnotator.draw_rounded_rectangle(
+            ...     scene=scene,
+            ...     xyxy=(10, 10, 100, 50),
+            ...     color=(0, 255, 0),
+            ...     border_radius=0,
+            ... )
+            >>> bool(scene[30, 50].tolist() == [0, 255, 0])
+            True
+
+            ```
+        """
+        x1, y1, x2, y2 = xyxy
+        width = x2 - x1
+        height = y2 - y1
+
+        border_radius = min(border_radius, min(width, height) // 2)
+
+        if border_radius <= 0:
+            # square corners: a single fill rectangle (the common default), rather
+            # than two rectangles plus four zero-radius corner circles
+            cv2.rectangle(
+                img=scene,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
+                color=color,
+                thickness=-1,
+            )
+            return scene
+
+        rectangle_coordinates = [
+            ((x1 + border_radius, y1), (x2 - border_radius, y2)),
+            ((x1, y1 + border_radius), (x2, y2 - border_radius)),
+        ]
+        circle_centers = [
+            (x1 + border_radius, y1 + border_radius),
+            (x2 - border_radius, y1 + border_radius),
+            (x1 + border_radius, y2 - border_radius),
+            (x2 - border_radius, y2 - border_radius),
+        ]
+
+        for coordinates in rectangle_coordinates:
+            cv2.rectangle(
+                img=scene,
+                pt1=coordinates[0],
+                pt2=coordinates[1],
+                color=color,
+                thickness=-1,
+            )
+        for center in circle_centers:
+            cv2.circle(
+                img=scene,
+                center=center,
+                radius=border_radius,
+                color=color,
+                thickness=-1,
+            )
+        return scene
+
+
+class RichLabelAnnotator(_BaseLabelAnnotator):
+    """
+    A class for annotating labels on an image using provided detections,
+    with support for Unicode characters by using a custom font.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        text_color: Color | ColorPalette | str = Color.WHITE,
+        font_path: str | None = None,
+        font_size: int = 10,
+        text_padding: int = 10,
+        text_position: Position = Position.TOP_LEFT,
+        text_offset: tuple[int, int] = (0, 0),
+        border_radius: int = 0,
+        smart_position: bool = False,
+        max_line_length: int | None = None,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating the text background.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            text_color: The color to use for the text.
+            font_path: Path to the font file (e.g., ".ttf" or ".otf")
+                to use for rendering text. If `None`, the default PIL font will be used.
+            font_size: Font size for the text.
+            text_padding: Padding around the text within its background box.
+            text_position: Position of the text relative to the detection.
+                Possible values are defined in the `Position` enum.
+            text_offset: A tuple of 2D coordinates `(x, y)` to
+                offset the text position from the anchor point, in pixels.
+            border_radius: The radius to apply round edges. If the selected
+                value is higher than the lower dimension, width or height, is clipped.
+            smart_position: Spread out the labels to avoid overlapping.
+            max_line_length: Maximum number of characters per line
+                before wrapping the text. None means no wrapping.
+        """
+        self.font_path = font_path
+        self.font_size = font_size
+        self.font = self._load_font(font_size, font_path)
+        super().__init__(
+            color=color,
+            color_lookup=color_lookup,
+            text_color=text_color,
+            text_padding=text_padding,
+            text_position=text_position,
+            text_offset=text_offset,
+            border_radius=border_radius,
+            smart_position=smart_position,
+            max_line_length=max_line_length,
+        )
+
+    @ensure_pil_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        labels: list[str] | None = None,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with labels based on the provided
+        detections, with support for Unicode characters.
+
+        Args:
+            scene: The image where labels will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            labels: Custom labels for each detection.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from PIL import Image
+            >>> image = Image.fromarray(np.zeros((100, 100, 3), dtype=np.uint8))
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     confidence=np.array([0.9]),
+            ...     class_id=np.array([0]),
+            ...     data={'class_name': np.array(['person'])}
+            ... )
+            >>> labels = [
+            ...     f"{class_name} {confidence:.2f}"
+            ...     for class_name, confidence
+            ...     in zip(detections['class_name'], detections.confidence)
+            ... ]
+            >>> rich_label_annotator = sv.RichLabelAnnotator()
+            >>> annotated_frame = rich_label_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections,
+            ...     labels=labels
+            ... )
+
+            ```
+        """
+        _validate_labels(labels, detections)
+
+        draw = ImageDraw.Draw(scene)
+        labels = get_labels_text(detections, labels)
+        label_properties: npt.NDArray[np.float32] = self._get_label_properties(
+            draw, detections, labels
+        )
+
+        if self.smart_position:
+            scene_pil = cast(Image.Image, scene)
+            label_properties = self._adjust_labels_in_frame(
+                (scene_pil.width, scene_pil.height),
+                labels,
+                label_properties,
+            )
+
+        self._draw_labels(
+            draw=draw,
+            labels=labels,
+            label_properties=label_properties,
+            detections=detections,
+            custom_color_lookup=custom_color_lookup,
+        )
+
+        return scene
+
+    def _get_label_properties(
+        self, draw: ImageDraw.ImageDraw, detections: Detections, labels: list[str]
+    ) -> Any:
+        label_properties = []
+
+        anchor_coordinates: npt.NDArray[np.int32] = detections.get_anchors_coordinates(
+            anchor=self.text_anchor
+        ).astype(int)
+
+        for label, center_coordinates in zip(labels, anchor_coordinates):
+            center_coordinates = (
+                center_coordinates[0] + self.text_offset[0],
+                center_coordinates[1] + self.text_offset[1],
+            )
+
+            wrapped_lines = wrap_text(label, self.max_line_length)
+
+            # Calculate the total text height and maximum width
+            max_width = 0.0
+            total_height = 0.0
+
+            for line in wrapped_lines:
+                left, top, right, bottom = draw.textbbox((0, 0), line, font=self.font)
+                line_width = right - left
+                line_height = bottom - top
+
+                max_width = max(max_width, line_width)
+                total_height += line_height
+
+            # Add inter-line spacing
+            if len(wrapped_lines) > 1:
+                total_height += (len(wrapped_lines) - 1) * self.text_padding
+
+            width_padded = int(max_width + 2 * self.text_padding)
+            height_padded = int(total_height + 2 * self.text_padding)
+
+            text_background_xyxy = resolve_text_background_xyxy(
+                center_coordinates=center_coordinates,
+                text_wh=(width_padded, height_padded),
+                position=self.text_anchor,
+            )
+
+            # Get the text origin offsets
+            text_left, text_top, _, _ = draw.textbbox((0, 0), "Tg", font=self.font)
+
+            label_properties.append([*text_background_xyxy, text_left, text_top])
+
+        result: npt.NDArray[np.float32] = np.array(
+            label_properties, dtype=np.float32
+        ).reshape(-1, 6)
+        return result
+
+    def _draw_labels(
+        self,
+        draw: ImageDraw.ImageDraw,
+        labels: list[str],
+        label_properties: npt.NDArray[np.float32],
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None,
+    ) -> None:
+        assert len(labels) == len(label_properties) == len(detections), (
+            f"Number of label properties ({len(label_properties)}), "
+            f"labels ({len(labels)}) and detections ({len(detections)}) "
+            "do not match."
+        )
+        color_lookup = (
+            custom_color_lookup
+            if custom_color_lookup is not None
+            else self.color_lookup
+        )
+
+        for idx, label_property in enumerate(label_properties):
+            background_color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=idx,
+                color_lookup=color_lookup,
+            )
+            text_color = resolve_color(
+                color=self.text_color,
+                detections=detections,
+                detection_idx=idx,
+                color_lookup=color_lookup,
+            )
+
+            box_xyxy = label_property[:4].astype(int)
+            text_left = label_property[4]
+            text_top = label_property[5]
+
+            # Draw the rounded rectangle background
+            draw.rounded_rectangle(
+                tuple(box_xyxy),
+                radius=self.border_radius,
+                fill=background_color.as_rgb(),
+                outline=None,
+            )
+
+            # Draw each line of text
+            wrapped_lines = wrap_text(labels[idx], self.max_line_length)
+            x_position = box_xyxy[0] + self.text_padding - text_left
+            y_position = box_xyxy[1] + self.text_padding - text_top
+
+            for line in wrapped_lines:
+                draw.text(
+                    xy=(x_position, y_position),
+                    text=line,
+                    font=self.font,
+                    fill=text_color.as_rgb(),
+                )
+
+                # Move to the next line position
+                _left, top, _right, bottom = draw.textbbox((0, 0), line, font=self.font)
+                line_height = bottom - top
+                y_position += line_height + self.text_padding
+
+    @staticmethod
+    def _load_font(
+        font_size: int, font_path: str | None
+    ) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+        def load_default_font(
+            size: int,
+        ) -> ImageFont.FreeTypeFont | ImageFont.ImageFont:
+            try:
+                return ImageFont.load_default(size)
+            except TypeError:
+                return ImageFont.load_default()
+
+        if font_path is None:
+            return load_default_font(font_size)
+
+        try:
+            return ImageFont.truetype(font_path, font_size)
+        except OSError:
+            logger.warning(
+                "Font path '%s' not found. Using PIL's default font.", font_path
+            )
+            return load_default_font(font_size)
+
+
+class IconAnnotator(BaseAnnotator):
+    """
+    A class for drawing an icon on an image, using provided detections.
+    """
+
+    def __init__(
+        self,
+        icon_resolution_wh: tuple[int, int] = (64, 64),
+        icon_position: Position = Position.TOP_CENTER,
+        offset_xy: tuple[int, int] = (0, 0),
+    ):
+        """
+        Args:
+            icon_resolution_wh: The size of drawn icons.
+                All icons will be resized to this resolution, keeping the aspect ratio.
+            icon_position: The position of the icon.
+            offset_xy: The offset to apply to the icon position,
+                in pixels. Can be both positive and negative.
+        """
+        self.icon_resolution_wh = icon_resolution_wh
+        self.position = icon_position
+        self.offset_xy = offset_xy
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        icon_path: str | list[str] = "",
+    ) -> ImageType:
+        """
+        Annotates the given scene with given icons.
+
+        Args:
+            scene: The image where labels will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            icon_path: The path to the PNG image to use as an
+                icon. Must be a single path or a list of paths, one for each detection.
+                Pass an empty string `""` to draw nothing.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Example:
+            ```python
+            import supervision as sv
+
+            image = ...
+            detections = sv.Detections(...)
+
+            available_icons = ["roboflow.png", "lenny.png"]
+            icon_paths = [np.random.choice(available_icons) for _ in detections]
+
+            icon_annotator = sv.IconAnnotator()
+            annotated_frame = icon_annotator.annotate(
+                scene=image.copy(),
+                detections=detections,
+                icon_path=icon_paths
+            )
+            ```
+
+        ![icon-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/icon-annotator-example.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if isinstance(icon_path, list) and len(icon_path) != len(detections):
+            raise ValueError(
+                f"The number of icon paths provided ({len(icon_path)}) does not match "
+                f"the number of detections ({len(detections)}). Either provide a single"
+                f" icon path or one for each detection."
+            )
+
+        xy: npt.NDArray[np.int32] = detections.get_anchors_coordinates(
+            anchor=self.position
+        ).astype(int)
+
+        for detection_idx in range(len(detections)):
+            current_path = (
+                icon_path if isinstance(icon_path, str) else icon_path[detection_idx]
+            )
+            if current_path == "":
+                continue
+            icon = self._load_icon(current_path)
+            icon_h, icon_w = icon.shape[:2]
+
+            x = int(xy[detection_idx, 0] - icon_w / 2 + self.offset_xy[0])
+            y = int(xy[detection_idx, 1] - icon_h / 2 + self.offset_xy[1])
+
+            scene[:] = _overlay_image(scene, icon, (x, y))
+        return scene
+
+    def _load_icon(self, icon_path: str) -> npt.NDArray[np.uint8]:
+        """Load an icon through the module-level cache shared by annotators."""
+        return _load_icon_from_path(
+            icon_path=icon_path, icon_resolution_wh=self.icon_resolution_wh
+        )
+
+
+class BlurAnnotator(BaseAnnotator):
+    """
+    A class for blurring regions in an image using provided detections.
+    """
+
+    def __init__(self, kernel_size: int | None = None):
+        """
+        Args:
+            kernel_size: The size of the average pooling kernel used for blurring.
+                If not set, a dynamic size is computed as one-third of the shorter
+                bounding-box dimension. Must be >= 1 when provided.
+        """
+        if kernel_size is not None and kernel_size < 1:
+            raise ValueError(f"kernel_size must be >= 1, got {kernel_size}.")
+        self.kernel_size: int | None = kernel_size
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+    ) -> ImageType:
+        """
+        Annotates the given scene by blurring regions based on the provided detections.
+
+        Args:
+            scene: The image where blurring will be applied.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> blur_annotator = sv.BlurAnnotator()
+            >>> annotated_frame = blur_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![blur-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/blur-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        image_height, image_width = scene.shape[:2]
+        clipped_xyxy: npt.NDArray[np.int32] = clip_boxes(
+            xyxy=detections.xyxy,
+            resolution_wh=(image_width, image_height),
+        ).astype(int)
+
+        for x1, y1, x2, y2 in clipped_xyxy:
+            if x2 <= x1 or y2 <= y1:
+                continue
+            roi = scene[y1:y2, x1:x2]
+            kernel_size = (
+                self.kernel_size
+                if self.kernel_size is not None
+                else calculate_dynamic_kernel_size(x1, y1, x2, y2)
+            )
+            roi = cast(npt.NDArray[np.uint8], cv2.blur(roi, (kernel_size, kernel_size)))
+            scene[y1:y2, x1:x2] = roi
+
+        return scene
+
+
+class TraceAnnotator(BaseAnnotator):
+    """
+    A class for drawing trace paths on an image based on detection coordinates.
+
+    !!! warning
+
+        This annotator uses the `sv.Detections.tracker_id`. Read
+        [here](/latest/trackers/) to learn how to plug
+        tracking into your inference pipeline.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        position: Position = Position.CENTER,
+        trace_length: int = 30,
+        thickness: int = 2,
+        smooth: bool = False,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            color: The color to draw the trace, can be
+                a single color or a color palette.
+            position: The position of the trace.
+                Defaults to `CENTER`.
+            trace_length: The maximum length of the trace in terms of historical
+                points. Defaults to `30`.
+            thickness: The thickness of the trace lines. Defaults to `2`.
+            smooth: If `True`, applies spline smoothing to trace lines using
+                consecutive unique anchor points. Falls back to a raw polyline
+                when fewer than 4 unique points are available (e.g. when a
+                tracker is stationary).
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.trace = Trace(max_size=trace_length, anchor=position)
+        self.thickness = thickness
+        self.smooth = smooth
+        self.color_lookup: ColorLookup = color_lookup
+
+    def reset(self) -> None:
+        """
+        Clears the accumulated trace history so the annotator can be reused
+        across independent streams without carrying over points from a
+        previous stream.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((20, 20, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[1, 1, 10, 10]]),
+            ...     class_id=np.array([0]),
+            ...     tracker_id=np.array([1])
+            ... )
+            >>> trace_annotator = sv.TraceAnnotator()
+            >>> _ = trace_annotator.annotate(scene=image.copy(), detections=detections)
+            >>> trace_annotator.trace.xy.shape
+            (1, 2)
+            >>> trace_annotator.reset()
+            >>> trace_annotator.trace.current_frame_id
+            0
+            >>> trace_annotator.trace.xy.shape
+            (0, 2)
+
+            ```
+        """
+        self.trace.reset()
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Draws trace paths on the frame based on the detection coordinates provided.
+
+        Args:
+            scene: The image on which the traces will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: The detections which include coordinates for
+                which the traces will be drawn. An empty `Detections` batch
+                is a no-op: `scene` is returned unmodified.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Raises:
+            ValueError: If `detections` is non-empty and its `tracker_id` field is
+                missing.
+
+        Examples:
+            ```python
+            import supervision as sv
+            from rfdetr import RFDETRMedium
+
+            model = RFDETRMedium()
+            trace_annotator = sv.TraceAnnotator()
+
+            video_info = sv.VideoInfo.from_video_path(video_path='...')
+            frames_generator = sv.get_video_frames_generator(source_path='...')
+            tracker = sv.ByteTrack()
+
+            with sv.VideoSink(target_path='...', video_info=video_info) as sink:
+               for frame in frames_generator:
+                   detections = model.predict(frame[:, :, ::-1])
+                   detections = tracker.update_with_detections(detections)
+                   annotated_frame = trace_annotator.annotate(
+                       scene=frame.copy(),
+                       detections=detections)
+                   sink.write_frame(frame=annotated_frame)
+            ```
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> trace_annotator = sv.TraceAnnotator()
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[10, 10, 30, 30]]),
+            ...     class_id=np.array([0]),
+            ...     tracker_id=np.array([1]),
+            ... )
+            >>> _ = trace_annotator.annotate(scene=image.copy(), detections=detections)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[70, 70, 90, 90]]),
+            ...     class_id=np.array([0]),
+            ...     tracker_id=np.array([1]),
+            ... )
+            >>> annotated_frame = trace_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+            >>> bool(annotated_frame.any())
+            True
+            >>> annotated_frame = trace_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=sv.Detections.empty()
+            ... )
+            >>> np.array_equal(annotated_frame, image)
+            True
+
+            ```
+
+        ![trace-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/trace-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+
+        # A frame in which nothing was detected carries no `tracker_id` and is
+        # not a missing-tracker mistake, so it must not raise. It still reaches
+        # the trace: advancing the frame counter there keeps `trace_length` a
+        # window over elapsed frames, so a track whose stored history had
+        # already filled that window is not joined to its pre-gap trail when it
+        # reappears after a longer gap.
+        if len(detections) == 0:
+            self.trace.put(detections)
+            return scene
+
+        if detections.tracker_id is None:
+            raise ValueError(
+                "The `tracker_id` field is missing in the provided detections."
+                " See more: https://supervision.roboflow.com/latest/how_to/track_objects"
+            )
+        is_confirmed = detections.tracker_id != PENDING_TRACK_ID
+        filtered_detections: Detections = detections[is_confirmed]  # type: ignore
+        # Validate before filtering so an invalid lookup cannot happen to match only
+        # the confirmed tracks. The matching lookup then drops pending-track entries.
+        if custom_color_lookup is not None:
+            if len(custom_color_lookup) != len(detections):
+                raise ValueError(
+                    f"Length of color lookup {len(custom_color_lookup)} "
+                    f"does not match length of detections {len(detections)}"
+                )
+            custom_color_lookup = custom_color_lookup[is_confirmed]
+
+        self.trace.put(filtered_detections)
+        for detection_idx in range(len(filtered_detections)):
+            tracker_id_val = filtered_detections.tracker_id[detection_idx]  # type: ignore
+            if tracker_id_val is None:
+                continue
+            tracker_id = int(tracker_id_val)
+            color = resolve_color(
+                color=self.color,
+                detections=filtered_detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            xy = self.trace.get(tracker_id=tracker_id)
+            spline_points: npt.NDArray[np.int32] = xy.astype(np.int32)
+
+            if self.smooth:
+                unique_xy = xy[
+                    np.concatenate(([True], np.any(np.diff(xy, axis=0) != 0, axis=1)))
+                ]
+                if len(unique_xy) > 3:
+                    try:
+                        x, y = unique_xy[:, 0], unique_xy[:, 1]
+                        tck, _u = splprep([x, y], s=20)
+                        x_new, y_new = splev(
+                            np.linspace(0, 1, 100),
+                            cast(
+                                tuple[
+                                    npt.NDArray[np.float64],
+                                    npt.NDArray[np.float64],
+                                    int,
+                                ],
+                                tck,
+                            ),
+                        )
+                        spline_points = np.stack((x_new, y_new), axis=1).astype(
+                            np.int32
+                        )
+                    except ValueError:
+                        spline_points = unique_xy.astype(np.int32)
+                else:
+                    spline_points = unique_xy.astype(np.int32)
+
+            if len(xy) > 1:
+                cv2.polylines(
+                    scene,
+                    [spline_points],
+                    False,
+                    color=color.as_bgr(),
+                    thickness=self.thickness,
+                )
+        return scene
+
+
+class HeatMapAnnotator(BaseAnnotator):
+    """
+    A class for drawing heatmaps on an image based on provided detections.
+    Heat accumulates over time and is drawn as a semi-transparent overlay
+    of blurred circles.
+    """
+
+    def __init__(
+        self,
+        position: Position = Position.BOTTOM_CENTER,
+        opacity: float = 0.2,
+        radius: int = 40,
+        kernel_size: int | None = 25,
+        top_hue: int = 0,
+        low_hue: int = 125,
+    ):
+        """
+        Args:
+            position: The position of the heatmap. Defaults to
+                `BOTTOM_CENTER`.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            radius: Radius of the heat circle.
+            kernel_size: Kernel size for blurring the heatmap. Pass `None`
+                to disable blurring entirely.
+            top_hue: Hue at the top of the heatmap. Defaults to 0 (red).
+            low_hue: Hue at the bottom of the heatmap. Defaults to 125 (blue).
+        """
+        self.position = position
+        self.opacity = opacity
+        self.radius = radius
+        self.kernel_size = kernel_size
+        self.top_hue = top_hue
+        self.low_hue = low_hue
+        self.heat_mask: npt.NDArray[np.float32] | None = None
+
+    def reset(self) -> None:
+        """
+        Clears the accumulated heat so the annotator can be reused across
+        independent streams. `annotate` already reinitializes the heat mask
+        when the scene resolution changes; call this to discard heat from a
+        previous stream that shares the same resolution.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((40, 40, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(xyxy=np.array([[10, 10, 20, 20]]))
+            >>> heat_map_annotator = sv.HeatMapAnnotator()
+            >>> _ = heat_map_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+            >>> bool(heat_map_annotator.heat_mask.sum() > 0)
+            True
+            >>> heat_map_annotator.reset()
+            >>> heat_map_annotator.heat_mask is None
+            True
+
+            ```
+        """
+        self.heat_mask = None
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, detections: Detections) -> ImageType:
+        """
+        Annotates the scene with a heatmap based on the provided detections.
+
+        Args:
+            scene: The image where the heatmap will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Note:
+            When `detections` is empty or no heat has accumulated yet, the
+            scene is returned unchanged without raising a ``RuntimeWarning``.
+
+        Examples:
+            ```python
+            import supervision as sv
+            from rfdetr import RFDETRMedium
+
+            model = RFDETRMedium()
+
+            heat_map_annotator = sv.HeatMapAnnotator()
+
+            video_info = sv.VideoInfo.from_video_path(video_path='...')
+            frames_generator = sv.get_video_frames_generator(source_path='...')
+
+            with sv.VideoSink(target_path='...', video_info=video_info) as sink:
+               for frame in frames_generator:
+                   detections = model.predict(frame[:, :, ::-1])
+                   annotated_frame = heat_map_annotator.annotate(
+                       scene=frame.copy(),
+                       detections=detections)
+                   sink.write_frame(frame=annotated_frame)
+            ```
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0]),
+            ... )
+            >>> heat_map_annotator = sv.HeatMapAnnotator()
+            >>> annotated_frame = heat_map_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+            >>> bool(heat_map_annotator.heat_mask.sum() > 0)
+            True
+
+            ```
+
+        ![heatmap-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/heat-map-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if self.heat_mask is None or self.heat_mask.shape != scene.shape[:2]:
+            self.heat_mask = np.zeros(scene.shape[:2], dtype=np.float32)
+
+        mask: npt.NDArray[np.float32] = np.zeros(scene.shape[:2], dtype=np.float32)
+        for xy in detections.get_anchors_coordinates(self.position):
+            x, y = int(xy[0]), int(xy[1])
+            cv2.circle(
+                img=mask,
+                center=(x, y),
+                radius=self.radius,
+                color=(1,),
+                thickness=-1,  # fill
+            )
+        self.heat_mask = mask + self.heat_mask
+        heat_mask = self.heat_mask
+        heat_values = heat_mask.copy()
+        max_val = heat_values.max()
+        if max_val > 0:
+            heat_values = self.low_hue - heat_values / max_val * (
+                self.low_hue - self.top_hue
+            )
+        heat_hue = heat_values.astype(np.uint8)
+        if self.kernel_size is not None:
+            heat_hue = cast(
+                npt.NDArray[np.uint8],
+                cv2.blur(heat_hue, (self.kernel_size, self.kernel_size)),
+            )
+        hsv = np.full(scene.shape, 255, dtype=np.uint8)
+        hsv[..., 0] = heat_hue
+        heat_bgr = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
+        mask2d = heat_mask > 0
+        blended = cv2.addWeighted(heat_bgr, self.opacity, scene, 1 - self.opacity, 0)
+        scene[mask2d] = blended[mask2d]
+        return scene
+
+
+class PixelateAnnotator(BaseAnnotator):
+    """
+    A class for pixelating regions in an image using provided detections.
+    """
+
+    def __init__(self, pixel_size: int | None = None):
+        """
+        Args:
+            pixel_size: The size of the pixelation. If not set, a dynamic size is
+                computed as one-half of the shorter bounding-box dimension. When set
+                and the detection area is smaller than `pixel_size`, the region is
+                filled with its average colour instead to avoid an OpenCV crash.
+                Must be >= 1 when provided.
+        """
+        if pixel_size is not None and pixel_size < 1:
+            raise ValueError(f"pixel_size must be >= 1, got {pixel_size}.")
+        self.pixel_size: int | None = pixel_size
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+    ) -> ImageType:
+        """
+        Annotates the given scene by pixelating regions based on the provided
+            detections.
+
+        Args:
+            scene: The image where pixelating will be applied.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0]),
+            ... )
+            >>> pixelate_annotator = sv.PixelateAnnotator()
+            >>> annotated_frame = pixelate_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![pixelate-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/pixelate-annotator-example-10.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        image_height, image_width = scene.shape[:2]
+        clipped_xyxy: npt.NDArray[np.int32] = clip_boxes(
+            xyxy=detections.xyxy,
+            resolution_wh=(image_width, image_height),
+        ).astype(int)
+
+        for x1, y1, x2, y2 in clipped_xyxy:
+            if x2 <= x1 or y2 <= y1:
+                continue
+            roi = scene[y1:y2, x1:x2]
+
+            pixel_size = (
+                self.pixel_size
+                if self.pixel_size is not None
+                else calculate_dynamic_pixel_size(x1, y1, x2, y2)
+            )
+            if min(y2 - y1, x2 - x1) < pixel_size:
+                if roi.ndim == 2 or (roi.ndim == 3 and roi.shape[2] == 1):
+                    scene[y1:y2, x1:x2] = cv2.mean(roi)[0]
+                else:
+                    num_channels = scene.shape[2]
+                    scene[y1:y2, x1:x2] = cv2.mean(roi)[:num_channels]
+                continue
+
+            scaled_up_roi = cv2.resize(
+                src=roi, dsize=None, fx=1 / pixel_size, fy=1 / pixel_size
+            )
+            scaled_down_roi = cv2.resize(
+                src=scaled_up_roi,
+                dsize=(roi.shape[1], roi.shape[0]),
+                interpolation=cv2.INTER_NEAREST,
+            )
+
+            scene[y1:y2, x1:x2] = scaled_down_roi
+
+        return scene
+
+
+class TriangleAnnotator(BaseAnnotator):
+    """
+    A class for drawing triangle markers on an image at specific coordinates based on
+    provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        base: int = 10,
+        height: int = 10,
+        position: Position = Position.TOP_CENTER,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        outline_thickness: int = 0,
+        outline_color: Color | ColorPalette | str = Color.BLACK,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            base: The base width of the triangle.
+            height: The height of the triangle.
+            position: The anchor position for placing the triangle.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            outline_thickness: Thickness of the outline of the triangle.
+            outline_color: The color or color palette to
+                use for outline. It is activated by setting outline_thickness to a value
+                greater than 0.
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.base: int = base
+        self.height: int = height
+        self.position: Position = position
+        self.color_lookup: ColorLookup = color_lookup
+        self.outline_thickness: int = outline_thickness
+        self.outline_color: Color | ColorPalette = _normalize_color_input(outline_color)
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with triangles based on the provided detections.
+
+        Args:
+            scene: The image where triangles will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> triangle_annotator = sv.TriangleAnnotator()
+            >>> annotated_frame = triangle_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![triangle-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/triangle-annotator-example.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        xy = detections.get_anchors_coordinates(anchor=self.position)
+        for detection_idx in range(len(detections)):
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            tip_x, tip_y = int(xy[detection_idx, 0]), int(xy[detection_idx, 1])
+            vertices = np.array(
+                [
+                    [tip_x - self.base // 2, tip_y - self.height],
+                    [tip_x + self.base // 2, tip_y - self.height],
+                    [tip_x, tip_y],
+                ],
+                np.int32,
+            )
+
+            cv2.fillPoly(scene, [vertices], color.as_bgr())
+            if self.outline_thickness:
+                outline_color = resolve_color(
+                    color=self.outline_color,
+                    detections=detections,
+                    detection_idx=detection_idx,
+                    color_lookup=self.color_lookup
+                    if custom_color_lookup is None
+                    else custom_color_lookup,
+                )
+                cv2.polylines(
+                    scene,
+                    [vertices],
+                    True,
+                    outline_color.as_bgr(),
+                    thickness=self.outline_thickness,
+                )
+        return scene
+
+
+class RoundBoxAnnotator(BaseAnnotator):
+    """
+    A class for drawing bounding boxes with round edges on an image
+    using provided detections.
+    """
+
+    def __init__(
+        self,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        thickness: int = 2,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        roundness: float = 0.6,
+    ):
+        """
+        Args:
+            color: The color or color palette to use for
+                annotating detections.
+            thickness: Thickness of the bounding box lines.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            roundness: Percent of roundness for edges of bounding box.
+                Value must be float 0 < roundness <= 1.0
+                By default roundness percent is calculated based on smaller side
+                length (width or height).
+        """
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.thickness: int = thickness
+        self.color_lookup: ColorLookup = color_lookup
+        if not 0 < roundness <= 1.0:
+            raise ValueError("roundness attribute must be float between (0, 1.0]")
+        self.roundness: float = roundness
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with bounding boxes with rounded edges
+        based on the provided detections.
+
+        Args:
+            scene: The image where rounded bounding boxes will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> round_box_annotator = sv.RoundBoxAnnotator()
+            >>> annotated_frame = round_box_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![round-box-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/round-box-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        for detection_idx in range(len(detections)):
+            x1, y1, x2, y2 = detections.xyxy[detection_idx].astype(int)
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+
+            radius = (
+                int((x2 - x1) // 2 * self.roundness)
+                if abs(x1 - x2) < abs(y1 - y2)
+                else int((y2 - y1) // 2 * self.roundness)
+            )
+
+            circle_coordinates = [
+                ((x1 + radius), (y1 + radius)),
+                ((x2 - radius), (y1 + radius)),
+                ((x2 - radius), (y2 - radius)),
+                ((x1 + radius), (y2 - radius)),
+            ]
+
+            line_coordinates = [
+                ((x1 + radius, y1), (x2 - radius, y1)),
+                ((x2, y1 + radius), (x2, y2 - radius)),
+                ((x1 + radius, y2), (x2 - radius, y2)),
+                ((x1, y1 + radius), (x1, y2 - radius)),
+            ]
+
+            start_angles = (180, 270, 0, 90)
+            end_angles = (270, 360, 90, 180)
+
+            for center_coordinates, line, start_angle, end_angle in zip(
+                circle_coordinates, line_coordinates, start_angles, end_angles
+            ):
+                cv2.ellipse(
+                    img=scene,
+                    center=center_coordinates,
+                    axes=(radius, radius),
+                    angle=0,
+                    startAngle=start_angle,
+                    endAngle=end_angle,
+                    color=color.as_bgr(),
+                    thickness=self.thickness,
+                )
+
+                cv2.line(
+                    img=scene,
+                    pt1=line[0],
+                    pt2=line[1],
+                    color=color.as_bgr(),
+                    thickness=self.thickness,
+                )
+
+        return scene
+
+
+class PercentageBarAnnotator(BaseAnnotator):
+    """
+    A class for drawing percentage bars on an image using provided detections.
+    """
+
+    def __init__(
+        self,
+        height: int = 16,
+        width: int = 80,
+        color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        border_color: Color | str = Color.BLACK,
+        position: Position = Position.TOP_CENTER,
+        color_lookup: ColorLookup = ColorLookup.CLASS,
+        border_thickness: int | None = None,
+    ):
+        """
+        Args:
+            height: The height in pixels of the percentage bar.
+            width: The width in pixels of the percentage bar.
+            color: The color or color palette to use for
+                annotating detections.
+            border_color: The color of the border lines.
+            position: The anchor position of drawing the percentage bar.
+            color_lookup: Strategy for mapping colors to annotations.
+                Options are `INDEX`, `CLASS`, `TRACK`.
+            border_thickness: The thickness of the border lines.
+        """
+        self.height: int = height
+        self.width: int = width
+        self.color: Color | ColorPalette = _normalize_color_input(color)
+        self.border_color = cast(Color, _normalize_color_input(border_color))
+        self.position: Position = position
+        self.color_lookup: ColorLookup = color_lookup
+
+        self.border_thickness = (
+            border_thickness
+            if border_thickness is not None
+            else int(0.15 * self.height)
+        )
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+        custom_values: npt.NDArray[np.float64] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the given scene with percentage bars based on the provided
+        detections. The percentage bars visually represent the confidence or custom
+        values associated with each detection.
+
+        Args:
+            scene: The image where percentage bars will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+            custom_values: Custom values array to use instead
+                of the default detection confidences. This array should have the
+                same length as the number of detections and contain a value between
+                0 and 1 (inclusive) for each detection, representing the percentage
+                to be displayed.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     confidence=np.array([0.9]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> percentage_bar_annotator = sv.PercentageBarAnnotator()
+            >>> annotated_frame = percentage_bar_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![percentage-bar-example](https://media.roboflow.com/
+        supervision-annotator-examples/percentage-bar-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        self._validate_custom_values(custom_values=custom_values, detections=detections)
+
+        anchors = detections.get_anchors_coordinates(anchor=self.position)
+        for detection_idx in range(len(detections)):
+            anchor = anchors[detection_idx]
+            border_coordinates = self.calculate_border_coordinates(
+                anchor_xy=(int(anchor[0]), int(anchor[1])),
+                border_wh=(self.width, self.height),
+                position=self.position,
+            )
+            border_width = border_coordinates[1][0] - border_coordinates[0][0]
+
+            if custom_values is not None:
+                value = custom_values[detection_idx]
+            else:
+                assert detections.confidence is not None  # MyPy type hint
+                value = detections.confidence[detection_idx]
+
+            color = resolve_color(
+                color=self.color,
+                detections=detections,
+                detection_idx=detection_idx,
+                color_lookup=self.color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            cv2.rectangle(
+                img=scene,
+                pt1=border_coordinates[0],
+                pt2=(
+                    border_coordinates[0][0] + int(border_width * value),
+                    border_coordinates[1][1],
+                ),
+                color=color.as_bgr(),
+                thickness=-1,
+            )
+            cv2.rectangle(
+                img=scene,
+                pt1=border_coordinates[0],
+                pt2=border_coordinates[1],
+                color=self.border_color.as_bgr(),
+                thickness=self.border_thickness,
+            )
+        return scene
+
+    @staticmethod
+    def calculate_border_coordinates(
+        anchor_xy: tuple[int, int], border_wh: tuple[int, int], position: Position
+    ) -> tuple[tuple[int, int], tuple[int, int]]:
+        """Compute the border corner coordinates for a given anchor position."""
+        cx, cy = anchor_xy
+        width, height = border_wh
+
+        if position == Position.TOP_LEFT:
+            return (cx - width, cy - height), (cx, cy)
+        elif position == Position.TOP_CENTER:
+            return (cx - width // 2, cy), (cx + width // 2, cy - height)
+        elif position == Position.TOP_RIGHT:
+            return (cx, cy), (cx + width, cy - height)
+        elif position == Position.CENTER_LEFT:
+            return (cx - width, cy - height // 2), (cx, cy + height // 2)
+        elif position == Position.CENTER or position == Position.CENTER_OF_MASS:
+            return (
+                (cx - width // 2, cy - height // 2),
+                (cx + width // 2, cy + height // 2),
+            )
+        elif position == Position.CENTER_RIGHT:
+            return (cx, cy - height // 2), (cx + width, cy + height // 2)
+        elif position == Position.BOTTOM_LEFT:
+            return (cx - width, cy), (cx, cy + height)
+        elif position == Position.BOTTOM_CENTER:
+            return (cx - width // 2, cy), (cx + width // 2, cy + height)
+        elif position == Position.BOTTOM_RIGHT:
+            return (cx, cy), (cx + width, cy + height)
+        raise ValueError(f"Unsupported position: {position}")
+
+    @staticmethod
+    def _validate_custom_values(
+        custom_values: npt.NDArray[np.float64] | list[float] | None,
+        detections: Detections,
+    ) -> None:
+        if custom_values is None:
+            if detections.confidence is None:
+                raise ValueError(
+                    "The provided detections do not contain confidence values. "
+                    "Please provide `custom_values` or ensure that the detections "
+                    "contain confidence values (e.g. by using a different model)."
+                )
+
+        else:
+            if not isinstance(custom_values, (np.ndarray, list)):
+                raise TypeError(
+                    "custom_values must be either a numpy array or a list of floats."
+                )
+
+            if len(custom_values) != len(detections):
+                raise ValueError(
+                    "The length of custom_values must match the number of detections."
+                )
+
+            if not all(0 <= value <= 1 for value in custom_values):
+                raise ValueError("All values in custom_values must be between 0 and 1.")
+
+    @staticmethod
+    @deprecated(  # type: ignore[untyped-decorator]
+        target=_validate_custom_values.__func__,  # type: ignore[attr-defined]
+        deprecated_in="0.29.0",
+        remove_in="0.32.0",
+    )
+    def validate_custom_values(
+        custom_values: npt.NDArray[np.float64] | list[float] | None,
+        detections: Detections,
+    ) -> None:
+        void(custom_values, detections)
+
+
+class CropAnnotator(BaseAnnotator):
+    """
+    A class for drawing scaled up crops of detections on the scene.
+    """
+
+    def __init__(
+        self,
+        position: Position = Position.TOP_CENTER,
+        scale_factor: float = 2.0,
+        border_color: Color | ColorPalette | str = ColorPalette.DEFAULT,
+        border_thickness: int = 2,
+        border_color_lookup: ColorLookup = ColorLookup.CLASS,
+    ):
+        """
+        Args:
+            position: The anchor position for placing the cropped and scaled
+                part of the detection in the scene.
+            scale_factor: The factor by which to scale the cropped image part. A
+                factor of 2, for example, would double the size of the cropped area,
+                allowing for a closer view of the detection.
+            border_color: The color or color palette to
+                use for annotating border around the cropped area.
+            border_thickness: The thickness of the border around the cropped area.
+            border_color_lookup: Strategy for mapping colors to
+                annotations. Options are `INDEX`, `CLASS`, `TRACK`.
+        """
+        self.position: Position = position
+        self.scale_factor: float = scale_factor
+        self.border_color: Color | ColorPalette = _normalize_color_input(border_color)
+        self.border_thickness: int = border_thickness
+        self.border_color_lookup: ColorLookup = border_color_lookup
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        detections: Detections,
+        custom_color_lookup: npt.NDArray[np.int_] | None = None,
+    ) -> ImageType:
+        """
+        Annotates the provided scene with scaled and cropped parts of the image based
+        on the provided detections. Each detection is cropped from the original scene
+        and scaled according to the annotator's scale factor before being placed back
+        onto the scene at the specified position.
+
+
+        Args:
+            scene: The image where cropped detection will be placed.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+            custom_color_lookup: Custom color lookup array.
+                Allows to override the default color mapping strategy.
+
+        Returns:
+            The annotated image.
+
+        Note:
+            Detections whose bounding boxes extend partially outside `scene` are
+            clipped to scene bounds before cropping. Detections fully outside the
+            scene collapse to zero area after clipping and are skipped without
+            raising an error.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> crop_annotator = sv.CropAnnotator()
+            >>> annotated_frame = crop_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![crop-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/crop-annotator-example.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        image_height, image_width = scene.shape[:2]
+        clipped_xyxy: npt.NDArray[np.int32] = clip_boxes(
+            xyxy=detections.xyxy,
+            resolution_wh=(image_width, image_height),
+        ).astype(np.int32)
+        anchors: npt.NDArray[np.int32] = detections.get_anchors_coordinates(
+            anchor=self.position
+        ).astype(np.int32)
+        # Snapshot before the loop so later crops are taken from the original image,
+        # not a scene already annotated by earlier iterations (overlapping-box case).
+        source_scene = scene.copy()
+
+        for idx, (xyxy, anchor) in enumerate(zip(clipped_xyxy, anchors)):
+            crop_x1, crop_y1, crop_x2, crop_y2 = xyxy
+            if crop_x2 <= crop_x1 or crop_y2 <= crop_y1:
+                continue
+            crop = crop_image(image=source_scene, xyxy=xyxy)
+            resized_crop = scale_image(image=crop, scale_factor=self.scale_factor)
+            crop_wh = resized_crop.shape[1], resized_crop.shape[0]
+            (x1, y1), (x2, y2) = self.calculate_crop_coordinates(
+                anchor=anchor, crop_wh=crop_wh, position=self.position
+            )
+            scene = _overlay_image(image=scene, overlay=resized_crop, anchor=(x1, y1))
+            color = resolve_color(
+                color=self.border_color,
+                detections=detections,
+                detection_idx=idx,
+                color_lookup=self.border_color_lookup
+                if custom_color_lookup is None
+                else custom_color_lookup,
+            )
+            cv2.rectangle(
+                img=scene,
+                pt1=(x1, y1),
+                pt2=(x2, y2),
+                color=color.as_bgr(),
+                thickness=self.border_thickness,
+            )
+
+        return scene
+
+    @staticmethod
+    def calculate_crop_coordinates(
+        anchor: tuple[int, int], crop_wh: tuple[int, int], position: Position
+    ) -> tuple[tuple[int, int], tuple[int, int]]:
+        """Compute the crop coordinates for a given anchor position."""
+        anchor_x, anchor_y = anchor
+        width, height = crop_wh
+
+        if position == Position.TOP_LEFT:
+            return (anchor_x - width, anchor_y - height), (anchor_x, anchor_y)
+        elif position == Position.TOP_CENTER:
+            return (
+                (anchor_x - width // 2, anchor_y - height),
+                (anchor_x + width // 2, anchor_y),
+            )
+        elif position == Position.TOP_RIGHT:
+            return (anchor_x, anchor_y - height), (anchor_x + width, anchor_y)
+        elif position == Position.CENTER_LEFT:
+            return (
+                (anchor_x - width, anchor_y - height // 2),
+                (anchor_x, anchor_y + height // 2),
+            )
+        elif position == Position.CENTER or position == Position.CENTER_OF_MASS:
+            return (
+                (anchor_x - width // 2, anchor_y - height // 2),
+                (anchor_x + width // 2, anchor_y + height // 2),
+            )
+        elif position == Position.CENTER_RIGHT:
+            return (
+                (anchor_x, anchor_y - height // 2),
+                (anchor_x + width, anchor_y + height // 2),
+            )
+        elif position == Position.BOTTOM_LEFT:
+            return (anchor_x - width, anchor_y), (anchor_x, anchor_y + height)
+        elif position == Position.BOTTOM_CENTER:
+            return (
+                (anchor_x - width // 2, anchor_y),
+                (anchor_x + width // 2, anchor_y + height),
+            )
+        elif position == Position.BOTTOM_RIGHT:
+            return (anchor_x, anchor_y), (anchor_x + width, anchor_y + height)
+        raise ValueError(f"Unsupported position: {position}")
+
+
+class BackgroundOverlayAnnotator(BaseAnnotator):
+    """
+    A class for drawing a colored overlay on the background of an image outside
+    the region of detections.
+
+    If masks are provided, the background is colored outside the masks.
+    If masks are not provided, the background is colored outside the bounding boxes.
+
+    You can use the `force_box` parameter to force the annotator to use bounding boxes.
+
+    !!! warning
+
+        This annotator uses `sv.Detections.mask`.
+    """
+
+    def __init__(
+        self,
+        color: Color = Color.BLACK,
+        opacity: float = 0.5,
+        force_box: bool = False,
+    ):
+        """
+        Args:
+            color: The color to use for annotating detections.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            force_box: If `True`, forces the annotator to use bounding boxes when
+                masks are provided in the supplied sv.Detections.
+        """
+        self.color: Color = color
+        self.opacity = opacity
+        self.force_box = force_box
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, detections: Detections) -> ImageType:
+        """
+        Applies a colored overlay to the scene outside of the detected regions.
+
+        Args:
+            scene: The image where masks will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections: Object detections to annotate.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[20, 20, 80, 80]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> background_overlay_annotator = sv.BackgroundOverlayAnnotator()
+            >>> annotated_frame = background_overlay_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections=detections
+            ... )
+
+            ```
+
+        ![background-overlay-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/background-color-annotator-example-purple.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        colored_mask = np.full_like(scene, self.color.as_bgr(), dtype=np.uint8)
+
+        cv2.addWeighted(
+            scene, 1 - self.opacity, colored_mask, self.opacity, 0, dst=colored_mask
+        )
+
+        if detections.mask is None or self.force_box:
+            image_height, image_width = scene.shape[:2]
+            clipped_xyxy: npt.NDArray[np.int32] = clip_boxes(
+                xyxy=detections.xyxy,
+                resolution_wh=(image_width, image_height),
+            ).astype(np.int32)
+            for x1, y1, x2, y2 in clipped_xyxy:
+                colored_mask[y1:y2, x1:x2] = scene[y1:y2, x1:x2]
+        else:
+            for mask in detections.mask:
+                mask_bool = np.asarray(mask, dtype=bool)
+                colored_mask[mask_bool] = scene[mask_bool]
+
+        np.copyto(scene, colored_mask)
+        return scene
+
+
+class ComparisonAnnotator:
+    """
+    Highlights the differences between two sets of detections.
+    Useful for comparing results from two different models, or the difference
+    between a ground truth and a prediction.
+
+    If present, uses the oriented bounding box data.
+    Otherwise, if present, uses a mask.
+    Otherwise, uses the bounding box data.
+    """
+
+    # Not a BaseAnnotator subclass — duck-typing callers can still check requires_mask
+    requires_mask: ClassVar[bool] = False
+
+    def __init__(
+        self,
+        color_1: Color = Color.RED,
+        color_2: Color = Color.GREEN,
+        color_overlap: Color = Color.BLUE,
+        *,
+        opacity: float = 0.75,
+        label_1: str = "",
+        label_2: str = "",
+        label_overlap: str = "",
+        label_scale: float = 1.0,
+    ):
+        """
+        Args:
+            color_1: Color of areas only present in the first set of
+                detections.
+            color_2: Color of areas only present in the second set of
+                detections.
+            color_overlap: Color of areas present in both sets of detections.
+            opacity: Opacity of the overlay mask. Must be between `0` and `1`.
+            label_1: Label for the first set of detections.
+            label_2: Label for the second set of detections.
+            label_overlap: Label for areas present in both sets of detections.
+            label_scale: Controls how large the labels are.
+        """
+
+        self.color_1 = color_1
+        self.color_2 = color_2
+        self.color_overlap = color_overlap
+
+        self.opacity = opacity
+        self.label_1 = label_1
+        self.label_2 = label_2
+        self.label_overlap = label_overlap
+        self.label_scale = label_scale
+        self.text_thickness = int(self.label_scale + 1.2)
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self, scene: ImageType, detections_1: Detections, detections_2: Detections
+    ) -> ImageType:
+        """
+        Highlights the differences between two sets of detections.
+
+        Args:
+            scene: The image where detections will be drawn.
+                `ImageType` is a flexible type, accepting either `numpy.ndarray`
+                or `PIL.Image.Image`.
+            detections_1: The first set of detections or predictions.
+            detections_2: The second set of detections to compare or
+                ground truth.
+
+        Returns:
+            The annotated image.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+            >>> detections_1 = sv.Detections(
+            ...     xyxy=np.array([[10, 10, 50, 50]]),
+            ...     class_id=np.array([0]),
+            ... )
+            >>> detections_2 = sv.Detections(
+            ...     xyxy=np.array([[40, 40, 90, 90]]),
+            ...     class_id=np.array([0]),
+            ... )
+            >>> comparison_annotator = sv.ComparisonAnnotator()
+            >>> annotated_frame = comparison_annotator.annotate(
+            ...     scene=image.copy(),
+            ...     detections_1=detections_1,
+            ...     detections_2=detections_2
+            ... )
+
+            ```
+
+        ![comparison-annotator-example](https://media.roboflow.com/
+        supervision-annotator-examples/comparison-annotator-example.png)
+        """
+        if not isinstance(scene, np.ndarray):
+            return scene
+        if detections_1.is_empty() and detections_2.is_empty():
+            return scene
+
+        use_obb = self._use_obb(detections_1, detections_2)
+        use_mask = self._use_mask(detections_1, detections_2)
+
+        if use_obb:
+            mask_1 = self._mask_from_obb(scene, detections_1)
+            mask_2 = self._mask_from_obb(scene, detections_2)
+
+        elif use_mask:
+            mask_1 = self._mask_from_mask(scene, detections_1)
+            mask_2 = self._mask_from_mask(scene, detections_2)
+
+        else:
+            mask_1 = self._mask_from_xyxy(scene, detections_1)
+            mask_2 = self._mask_from_xyxy(scene, detections_2)
+
+        mask_overlap = mask_1 & mask_2
+        mask_1 = mask_1 & ~mask_overlap
+        mask_2 = mask_2 & ~mask_overlap
+
+        color_layer = np.zeros_like(scene, dtype=np.uint8)
+        color_layer[mask_overlap] = self.color_overlap.as_bgr()
+        color_layer[mask_1] = self.color_1.as_bgr()
+        color_layer[mask_2] = self.color_2.as_bgr()
+
+        scene[mask_overlap] = (1 - self.opacity) * scene[
+            mask_overlap
+        ] + self.opacity * color_layer[mask_overlap]
+        scene[mask_1] = (1 - self.opacity) * scene[mask_1] + self.opacity * color_layer[
+            mask_1
+        ]
+        scene[mask_2] = (1 - self.opacity) * scene[mask_2] + self.opacity * color_layer[
+            mask_2
+        ]
+
+        self._draw_labels(scene)
+
+        return scene
+
+    @staticmethod
+    def _use_obb(detections_1: Detections, detections_2: Detections) -> bool:
+        assert not detections_1.is_empty() or not detections_2.is_empty()
+        is_obb_1 = ORIENTED_BOX_COORDINATES in detections_1.data
+        is_obb_2 = ORIENTED_BOX_COORDINATES in detections_2.data
+        return (
+            (is_obb_1 and is_obb_2)
+            or (is_obb_1 and detections_2.is_empty())
+            or (detections_1.is_empty() and is_obb_2)
+        )
+
+    @staticmethod
+    def _use_mask(detections_1: Detections, detections_2: Detections) -> bool:
+        assert not detections_1.is_empty() or not detections_2.is_empty()
+        is_mask_1 = detections_1.mask is not None
+        is_mask_2 = detections_2.mask is not None
+        return (
+            (is_mask_1 and is_mask_2)
+            or (is_mask_1 and detections_2.is_empty())
+            or (detections_1.is_empty() and is_mask_2)
+        )
+
+    @staticmethod
+    def _mask_from_xyxy(
+        scene: npt.NDArray[np.uint8], detections: Detections
+    ) -> npt.NDArray[np.bool_]:
+        mask = np.zeros(scene.shape[:2], dtype=np.bool_)
+        if detections.is_empty():
+            return mask
+
+        resolution_wh = scene.shape[1], scene.shape[0]
+        polygons = xyxy_to_polygons(detections.xyxy)
+
+        for polygon in polygons:
+            polygon_mask = polygon_to_mask(polygon, resolution_wh=resolution_wh)
+            mask |= polygon_mask.astype(np.bool_)
+        return mask
+
+    @staticmethod
+    def _mask_from_obb(
+        scene: npt.NDArray[np.uint8], detections: Detections
+    ) -> npt.NDArray[np.bool_]:
+        mask = np.zeros(scene.shape[:2], dtype=np.bool_)
+        if detections.is_empty():
+            return mask
+
+        resolution_wh = scene.shape[1], scene.shape[0]
+
+        for polygon in detections.data[ORIENTED_BOX_COORDINATES]:
+            polygon_mask = polygon_to_mask(polygon, resolution_wh=resolution_wh)
+            mask |= polygon_mask.astype(np.bool_)
+        return mask
+
+    @staticmethod
+    def _mask_from_mask(
+        scene: npt.NDArray[np.uint8], detections: Detections
+    ) -> npt.NDArray[np.bool_]:
+        mask = np.zeros(scene.shape[:2], dtype=np.bool_)
+        if detections.is_empty():
+            return mask
+        assert detections.mask is not None
+
+        for detections_mask in detections.mask:
+            mask |= detections_mask.astype(np.bool_)
+        return mask
+
+    def _draw_labels(self, scene: npt.NDArray[np.uint8]) -> None:
+        """
+        Draw the labels, explaining what each color represents, with automatically
+        computed positions.
+
+        Args:
+            scene: The image where the labels will be drawn.
+        """
+        margin = int(50 * self.label_scale)
+        gap = int(40 * self.label_scale)
+        y0 = int(50 * self.label_scale)
+        height = int(50 * self.label_scale)
+
+        marker_size = int(20 * self.label_scale)
+        padding = int(10 * self.label_scale)
+        text_box_corner_radius = int(10 * self.label_scale)
+        marker_corner_radius = int(4 * self.label_scale)
+        text_scale = self.label_scale
+
+        label_color_pairs = [
+            (self.label_1, self.color_1),
+            (self.label_2, self.color_2),
+            (self.label_overlap, self.color_overlap),
+        ]
+
+        x0 = margin
+        for text, color in label_color_pairs:
+            if not text:
+                continue
+
+            (text_w, _) = cv2.getTextSize(
+                text=text,
+                fontFace=CV2_FONT,
+                fontScale=self.label_scale,
+                thickness=self.text_thickness,
+            )[0]
+
+            width = text_w + marker_size + padding * 4
+            center_x = x0 + width // 2
+            center_y = y0 + height // 2
+
+            draw_rounded_rectangle(
+                scene=scene,
+                rect=Rect(x=x0, y=y0, width=width, height=height),
+                color=Color.WHITE,
+                border_radius=text_box_corner_radius,
+            )
+
+            draw_rounded_rectangle(
+                scene=scene,
+                rect=Rect(
+                    x=x0 + padding,
+                    y=center_y - marker_size / 2,
+                    width=marker_size,
+                    height=marker_size,
+                ),
+                color=color,
+                border_radius=marker_corner_radius,
+            )
+
+            draw_text(
+                scene,
+                text,
+                text_anchor=Point(x=center_x + marker_size, y=center_y),
+                text_scale=text_scale,
+                text_thickness=self.text_thickness,
+            )
+
+            x0 += width + gap
diff --git a/.venv/lib/python3.12/site-packages/supervision/annotators/utils.py b/.venv/lib/python3.12/site-packages/supervision/annotators/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..54058f39f4050e8d9b476ef6f46a4b3f66704c99
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/annotators/utils.py
@@ -0,0 +1,576 @@
+import re
+import textwrap
+from enum import Enum
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void
+
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.detection.core import Detections
+from supervision.draw.color import Color, ColorPalette
+from supervision.geometry.core import Position
+
+PENDING_TRACK_COLOR = Color.GREY
+PENDING_TRACK_ID = -1
+
+
+class ColorLookup(Enum):
+    """
+    Enumeration class to define strategies for mapping colors to annotations.
+
+    This enum supports three different lookup strategies:
+        - `INDEX`: Colors are determined by the index of the detection within the scene.
+        - `CLASS`: Colors are determined by the class label of the detected object.
+        - `TRACK`: Colors are determined by the tracking identifier of the object.
+    """
+
+    INDEX = "index"
+    CLASS = "class"
+    TRACK = "track"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return list(map(lambda c: c.value, cls))
+
+
+def resolve_color_idx(
+    detections: Detections,
+    detection_idx: int,
+    color_lookup: ColorLookup | npt.NDArray[np.int_] = ColorLookup.CLASS,
+) -> int:
+    if detection_idx >= len(detections):
+        raise ValueError(
+            f"Detection index {detection_idx} "
+            f"is out of bounds for detections of length {len(detections)}"
+        )
+
+    if isinstance(color_lookup, np.ndarray):
+        if len(color_lookup) != len(detections):
+            raise ValueError(
+                f"Length of color lookup {len(color_lookup)} "
+                f"does not match length of detections {len(detections)}"
+            )
+        return int(color_lookup[detection_idx])
+    elif color_lookup == ColorLookup.INDEX:
+        return detection_idx
+    elif color_lookup == ColorLookup.CLASS:
+        if detections.class_id is None:
+            raise ValueError(
+                "Could not resolve color by class because "
+                "Detections do not have class_id. If using an annotator, "
+                "try setting color_lookup to sv.ColorLookup.INDEX or "
+                "sv.ColorLookup.TRACK."
+            )
+        return int(detections.class_id[detection_idx])
+    elif color_lookup == ColorLookup.TRACK:
+        if detections.tracker_id is None:
+            raise ValueError(
+                "Could not resolve color by track because "
+                "Detections do not have tracker_id. Did you call "
+                "tracker.update_with_detections(...) before annotating?"
+            )
+        return int(detections.tracker_id[detection_idx])
+    raise ValueError(f"Unsupported color lookup strategy: {color_lookup}")
+
+
+def resolve_text_background_xyxy(
+    center_coordinates: tuple[int, int],
+    text_wh: tuple[int, int],
+    position: Position,
+) -> tuple[int, int, int, int]:
+    """Compute the background box for text anchored at `position`."""
+    center_x, center_y = center_coordinates
+    text_w, text_h = text_wh
+
+    if position == Position.TOP_LEFT:
+        return center_x, center_y - text_h, center_x + text_w, center_y
+    elif position == Position.TOP_RIGHT:
+        return center_x - text_w, center_y - text_h, center_x, center_y
+    elif position == Position.TOP_CENTER:
+        return (
+            center_x - text_w // 2,
+            center_y - text_h,
+            center_x + text_w // 2,
+            center_y,
+        )
+    elif position == Position.CENTER or position == Position.CENTER_OF_MASS:
+        return (
+            center_x - text_w // 2,
+            center_y - text_h // 2,
+            center_x + text_w // 2,
+            center_y + text_h // 2,
+        )
+    elif position == Position.BOTTOM_LEFT:
+        return center_x, center_y, center_x + text_w, center_y + text_h
+    elif position == Position.BOTTOM_RIGHT:
+        return center_x - text_w, center_y, center_x, center_y + text_h
+    elif position == Position.BOTTOM_CENTER:
+        return (
+            center_x - text_w // 2,
+            center_y,
+            center_x + text_w // 2,
+            center_y + text_h,
+        )
+    elif position == Position.CENTER_LEFT:
+        return (
+            center_x - text_w,
+            center_y - text_h // 2,
+            center_x,
+            center_y + text_h // 2,
+        )
+    elif position == Position.CENTER_RIGHT:
+        return (
+            center_x,
+            center_y - text_h // 2,
+            center_x + text_w,
+            center_y + text_h // 2,
+        )
+    raise ValueError(f"Unsupported position: {position}")
+
+
+def get_color_by_index(color: Color | ColorPalette, idx: int) -> Color:
+    """Resolve a color-like object to a concrete `Color` for an index."""
+    color_like = cast(Any, color)
+    # Accept ColorPalette-like objects without depending on their exact concrete class.
+    if callable(getattr(color_like, "by_idx", None)):
+        color_like = color_like.by_idx(idx)
+    if isinstance(color_like, Color):
+        return color_like
+    return Color(
+        r=int(color_like.r),
+        g=int(color_like.g),
+        b=int(color_like.b),
+        a=int(getattr(color_like, "a", 255)),
+    )
+
+
+def resolve_color(
+    color: Color | ColorPalette,
+    detections: Detections,
+    detection_idx: int,
+    color_lookup: ColorLookup | npt.NDArray[np.int_] = ColorLookup.CLASS,
+) -> Color:
+    idx = resolve_color_idx(
+        detections=detections,
+        detection_idx=detection_idx,
+        color_lookup=color_lookup,
+    )
+    if (
+        isinstance(color_lookup, ColorLookup)
+        and color_lookup == ColorLookup.TRACK
+        and idx == PENDING_TRACK_ID
+    ):
+        return PENDING_TRACK_COLOR
+    return get_color_by_index(color=color, idx=idx)
+
+
+def wrap_text(text: object, max_line_length: int | None = None) -> list[str]:
+    """
+    Wrap `text` to the specified maximum line length, respecting existing
+    newlines. Falls back to str() if `text` is not already a string.
+
+    Args:
+        text: The text (or object) to wrap.
+        max_line_length: Maximum width for each wrapped line.
+
+    Returns:
+        Wrapped lines.
+    """
+
+    if not text:
+        return [""]
+
+    if not isinstance(text, str):
+        text = str(text)
+
+    if max_line_length is None:
+        return text.splitlines() or [""]
+
+    if max_line_length <= 0:
+        raise ValueError("max_line_length must be a positive integer")
+
+    paragraphs = text.split("\n")
+    all_lines: list[str] = []
+
+    for paragraph in paragraphs:
+        if paragraph == "":
+            all_lines.append("")
+            continue
+
+        wrapped = textwrap.wrap(
+            paragraph,
+            width=max_line_length,
+            break_long_words=True,
+            replace_whitespace=False,
+            drop_whitespace=True,
+        )
+
+        all_lines.extend(wrapped or [""])
+
+    return all_lines or [""]
+
+
+def _validate_labels(labels: list[str] | None, detections: Detections) -> None:
+    """
+    Validates that the number of provided labels matches the number of detections.
+
+    Args:
+        labels: A list of labels, one for each detection. Can
+            be None.
+        detections: The detections to be labeled.
+
+    Raises:
+        ValueError: If `labels` is not None and its length does not match the number
+            of detections.
+    """
+    if labels is not None and len(labels) != len(detections):
+        raise ValueError(
+            f"The number of labels ({len(labels)}) does not match the "
+            f"number of detections ({len(detections)}). Each detection "
+            f"should have exactly 1 label."
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_labels,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_labels(labels: list[str] | None, detections: Detections) -> None:
+    void(labels, detections)
+
+
+def get_labels_text(
+    detections: Detections, custom_labels: list[str] | None
+) -> list[str]:
+    """
+    Retrieves the text labels for the detections.
+
+    If `custom_labels` are provided, they are used. Otherwise, the labels are
+    extracted from the `detections` object, prioritizing the 'class_name' field,
+    then the `class_id`, and finally using the detection index as a string.
+
+    Args:
+        detections: The detections to get labels for.
+        custom_labels: An optional list of custom labels.
+
+    Returns:
+        A list of text labels for each detection.
+
+    Raises:
+        ValueError: If `class_name` or `class_id` is present but its length
+            does not match the number of detections (e.g. `detections.data`
+            was mutated directly, bypassing `Detections` alignment checks).
+    """
+    if custom_labels is not None:
+        return custom_labels
+
+    if CLASS_NAME_DATA_FIELD in detections.data:
+        class_names = detections.data[CLASS_NAME_DATA_FIELD]
+        # `Detections.data` is normally kept aligned with `xyxy` by the
+        # dataclass's own validation, but a caller can bypass it by mutating
+        # `detections.data` directly. Fail loudly rather than silently
+        # dropping or duplicating labels.
+        if len(class_names) != len(detections):
+            raise ValueError(
+                f"'{CLASS_NAME_DATA_FIELD}' has {len(class_names)} entries "
+                f"but detections has {len(detections)} - the two must stay "
+                "aligned."
+            )
+        return [str(v) for v in class_names]
+    if detections.class_id is not None:
+        if len(detections.class_id) != len(detections):
+            raise ValueError(
+                f"'class_id' has {len(detections.class_id)} entries but "
+                f"detections has {len(detections)} - the two must stay "
+                "aligned."
+            )
+        return [str(v) for v in detections.class_id]
+    return [str(i) for i in range(len(detections))]
+
+
+def snap_boxes(
+    xyxy: npt.NDArray[np.float32],
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.float32]:
+    """
+    Shifts `label` bounding boxes into the frame so that they are fully contained
+    within the given resolution, prioritizing the top/left edge.
+    Unlike `clip_boxes`, this function does not crop boxes.
+    It moves them entirely if they exceed the frame boundaries.
+
+    Args:
+        xyxy: A numpy array of shape `(N, 4)` where each
+            row corresponds to a bounding box in the format
+            `(x_min, y_min, x_max, y_max)`.
+        resolution_wh: A tuple `(width, height)`
+            representing the resolution of the frame.
+
+    Returns:
+        A numpy array of shape `(N, 4)` with boxes shifted into frame.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.annotators.utils import snap_boxes
+        >>> xyxy = np.array([
+        ...     [-10, 10, 30, 50],     # Off left edge
+        ...     [310, 200, 350, 250],  # Off right edge
+        ...     [100, -20, 150, 30],   # Off top edge
+        ...     [200, 220, 250, 270],  # Off bottom edge
+        ...     [-20, 10, 350, 50],    # Wider than frame (370 vs 320)
+        ...     [10, -20, 30, 260]     # Taller than frame (280 vs 240)
+        ... ])
+        >>> resolution_wh = (320, 240)
+        >>> snapped_boxes = snap_boxes(xyxy=xyxy, resolution_wh=resolution_wh)
+        >>> snapped_boxes
+        array([[  0.,  10.,  40.,  50.],
+               [280., 190., 320., 240.],
+               [100.,   0., 150.,  50.],
+               [200., 190., 250., 240.],
+               [  0.,  10., 370.,  50.],
+               [ 10.,   0.,  30., 280.]], dtype=float32)
+
+        ```
+    """
+    result: npt.NDArray[np.float32] = np.array(xyxy, dtype=np.float32, copy=True)
+    width, height = resolution_wh
+
+    # X-axis (prioritize left edge)
+    left_overflow = result[:, 0] < 0
+    result[left_overflow, 0:3:2] -= result[left_overflow, 0:1]
+
+    right_overflow = (~left_overflow) & (result[:, 2] > width)
+    right_shift = width - result[right_overflow, 2]
+    result[right_overflow, 0:3:2] += right_shift[:, np.newaxis]
+
+    # Y-axis (prioritize top edge)
+    top_overflow = result[:, 1] < 0
+    result[top_overflow, 1:4:2] -= result[top_overflow, 1:2]
+
+    bottom_overflow = (~top_overflow) & (result[:, 3] > height)
+    bottom_shift = height - result[bottom_overflow, 3]
+    result[bottom_overflow, 1:4:2] += bottom_shift[:, np.newaxis]
+
+    return cast(npt.NDArray[np.float32], result.astype(np.float32, copy=False))
+
+
+class Trace:
+    def __init__(
+        self,
+        max_size: int | None = None,
+        start_frame_id: int = 0,
+        anchor: Position = Position.CENTER,
+    ) -> None:
+        self.current_frame_id = start_frame_id
+        self.max_size = max_size
+        self.anchor = anchor
+
+        self.frame_id: npt.NDArray[np.int_] = np.array([], dtype=int)
+        self.xy: npt.NDArray[np.float32] = np.empty((0, 2), dtype=np.float32)
+        self.tracker_id: npt.NDArray[np.int_] = np.array([], dtype=int)
+
+    def put(self, detections: Detections) -> None:
+        """Append a frame of detections to the trace history.
+
+        A frame that detected nothing contributes no points but still advances
+        the frame counter, keeping `max_size` a window over elapsed frames
+        rather than over populated ones. An empty frame has no anchors and no
+        `tracker_id`, so only frames that carry detections require one.
+
+        Pruning runs on the next frame that does carry detections, measures
+        the window from the advanced counter, and only fires once the distinct
+        frames held in the history — counting the frame that triggers it —
+        outnumber `max_size`. A track that had filled the window before a long
+        gap therefore starts a fresh trail, while a track whose stored history
+        stayed shorter than the window is still joined to its pre-gap points.
+
+        History is normalised on the way in: anchor points are stored as
+        `float32` and tracker ids are cast to NumPy's default integer dtype
+        (`np.int_`), so tracker ids outside that dtype's range are unsupported.
+        """
+        if len(detections) == 0:
+            xy: npt.NDArray[np.float32] = np.empty((0, 2), dtype=np.float32)
+            tracker_id: npt.NDArray[np.int_] = np.array([], dtype=int)
+        else:
+            if detections.tracker_id is None:
+                raise ValueError(
+                    "Could not put detections into Trace because "
+                    "Detections do not have tracker_id."
+                )
+            xy = np.asarray(
+                detections.get_anchors_coordinates(self.anchor), dtype=np.float32
+            )
+            tracker_id = np.asarray(detections.tracker_id, dtype=int)
+
+        frame_id: npt.NDArray[np.int_] = np.full(
+            len(detections), self.current_frame_id, dtype=int
+        )
+        self.frame_id = np.concatenate([self.frame_id, frame_id])
+        self.xy = np.concatenate([self.xy, xy])
+        self.tracker_id = np.concatenate([self.tracker_id, tracker_id])
+
+        unique_frame_id = np.unique(self.frame_id)
+
+        if self.max_size is not None and 0 < self.max_size < len(unique_frame_id):
+            max_allowed_frame_id = self.current_frame_id - self.max_size + 1
+            filtering_mask = self.frame_id >= max_allowed_frame_id
+            self.frame_id = self.frame_id[filtering_mask]
+            self.xy = self.xy[filtering_mask]
+            self.tracker_id = self.tracker_id[filtering_mask]
+
+        self.current_frame_id += 1
+
+    def get(self, tracker_id: int) -> npt.NDArray[np.float32]:
+        xy: npt.NDArray[np.float32] = np.asarray(
+            self.xy[self.tracker_id == tracker_id], dtype=np.float32
+        )
+        return xy
+
+    def reset(self) -> None:
+        """Restore the trace buffers to their initial empty state.
+
+        Clears the accumulated `frame_id`, `xy`, and `tracker_id` history and
+        rewinds `current_frame_id` to `0`, so the trace can be reused across
+        independent streams without carrying over points from a previous run.
+        """
+        self.current_frame_id = 0
+        self.frame_id = np.array([], dtype=int)
+        self.xy = np.empty((0, 2), dtype=np.float32)
+        self.tracker_id = np.array([], dtype=int)
+
+
+def hex_to_rgba(hex_color: str) -> tuple[int, int, int, int]:
+    """
+    Converts a hex color string (e.g. "#FF00FF" or "#FF00FF80") to an RGBA tuple.
+
+    Args:
+        hex_color: A hex color string.
+
+    Returns:
+        RGBA values in range 0-255.
+
+    Raises:
+        ValueError: If the format is invalid.
+
+    Examples:
+        ```pycon
+        >>> from supervision.annotators.utils import hex_to_rgba
+        >>> hex_to_rgba("#FF00FF")
+        (255, 0, 255, 255)
+        >>> hex_to_rgba("#FF00FF80")
+        (255, 0, 255, 128)
+
+        ```
+    """
+    hex_color = hex_color.strip().removeprefix("#")
+    if len(hex_color) == 6:
+        hex_color += "FF"  # default full opacity
+    if len(hex_color) != 8:
+        raise ValueError(f"Invalid hex color format: {hex_color}")
+    try:
+        r = int(hex_color[0:2], 16)
+        g = int(hex_color[2:4], 16)
+        b = int(hex_color[4:6], 16)
+        a = int(hex_color[6:8], 16)
+    except ValueError as exc:
+        raise ValueError(f"Invalid hex digits in {hex_color}") from exc
+    return (r, g, b, a)
+
+
+def rgba_to_hex(rgba: tuple[int, int, int, int]) -> str:
+    """
+    Converts an RGBA tuple (0-255 each) to a hex color string.
+
+    Args:
+        rgba: RGBA values in range 0-255.
+
+    Returns:
+        Hex color string in the format "#RRGGBBAA".
+
+    Raises:
+        ValueError: If `rgba` is not a 4-tuple or contains values outside 0-255.
+
+    Examples:
+        ```pycon
+        >>> from supervision.annotators.utils import rgba_to_hex
+        >>> rgba_to_hex((255, 0, 255, 128))
+        '#FF00FF80'
+
+        ```
+    """
+    if len(rgba) != 4 or not all(0 <= c <= 255 for c in rgba):
+        raise ValueError("RGBA must be a 4-tuple with values between 0-255.")
+    return "#{:02X}{:02X}{:02X}{:02X}".format(*rgba)
+
+
+def is_valid_hex(hex_color: str) -> bool:
+    """
+    Checks if a given string is a valid hex color.
+
+    Args:
+        hex_color: A hex color string with an optional leading "#". Supports
+            6-digit (RGB) or 8-digit (RGBA) formats.
+
+    Returns:
+        True if the string is a valid 6- or 8-digit hex color, otherwise False.
+
+    Examples:
+        ```pycon
+        >>> from supervision.annotators.utils import is_valid_hex
+        >>> is_valid_hex("#FF00FF")
+        True
+        >>> is_valid_hex("not-a-color")
+        False
+
+        ```
+    """
+    return bool(re.fullmatch(r"#?[0-9A-Fa-f]{6}([0-9A-Fa-f]{2})?", hex_color.strip()))
+
+
+def calculate_dynamic_kernel_size(x1: int, y1: int, x2: int, y2: int) -> int:
+    """
+    Computes a blur kernel size proportional to the shorter side of a bounding box.
+
+    Args:
+        x1: Left edge of the bounding box.
+        y1: Top edge of the bounding box.
+        x2: Right edge of the bounding box.
+        y2: Bottom edge of the bounding box.
+
+    Returns:
+        Kernel size as one-third of the shorter dimension, minimum 1.
+
+    Examples:
+        ```pycon
+        >>> calculate_dynamic_kernel_size(0, 0, 90, 60)
+        20
+
+        ```
+    """
+    return max(1, min(y2 - y1, x2 - x1) // 3)
+
+
+def calculate_dynamic_pixel_size(x1: int, y1: int, x2: int, y2: int) -> int:
+    """
+    Computes a pixelation size proportional to the shorter side of a bounding box.
+
+    Args:
+        x1: Left edge of the bounding box.
+        y1: Top edge of the bounding box.
+        x2: Right edge of the bounding box.
+        y2: Bottom edge of the bounding box.
+
+    Returns:
+        Pixel size as one-half of the shorter dimension, minimum 1.
+
+    Examples:
+        ```pycon
+        >>> calculate_dynamic_pixel_size(0, 0, 90, 60)
+        30
+
+        ```
+    """
+    return max(1, min(y2 - y1, x2 - x1) // 2)
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/__init__.py b/.venv/lib/python3.12/site-packages/supervision/assets/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ed213f58a8443824e88e1a2a9050bebee064109
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/assets/__init__.py
@@ -0,0 +1,4 @@
+from supervision.assets.downloader import download_assets
+from supervision.assets.list import ImageAssets, VideoAssets
+
+__all__ = ["ImageAssets", "VideoAssets", "download_assets"]
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36a02f5efb25088f52043cdbb9e88316d0e5a558
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/downloader.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/downloader.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ea1a6a2a47831fa964252d7bd2e28d990cb6dc6b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/downloader.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/list.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/list.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..452c5f81ac302a511704162cf680b89e7d945a8d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/assets/__pycache__/list.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/downloader.py b/.venv/lib/python3.12/site-packages/supervision/assets/downloader.py
new file mode 100644
index 0000000000000000000000000000000000000000..bd0ab9653293097bb339a4efc5c53f907d427b2a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/assets/downloader.py
@@ -0,0 +1,141 @@
+import os
+from hashlib import md5
+from pathlib import Path
+
+from supervision.assets.list import MEDIA_ASSETS, Assets
+from supervision.utils.file import _download_to_file
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+
+def is_md5_hash_matching(filename: str | Path, original_md5_hash: str) -> bool:
+    """
+    Check if the MD5 hash of a file matches the original hash.
+
+    Note: MD5 is used here for file integrity checking (detecting corruption),
+    not for cryptographic security purposes.
+
+    Args:
+        filename: The path to the file to be checked.
+        original_md5_hash: The original MD5 hash to compare against.
+
+    Returns:
+        True if the hashes match, False otherwise.
+    """
+    if not os.path.exists(filename):
+        return False
+
+    with open(filename, "rb") as file:
+        file_contents = file.read()
+        computed_md5_hash = md5(file_contents, usedforsecurity=False)
+
+    return computed_md5_hash.hexdigest() == original_md5_hash
+
+
+def _download_asset(filename: str, destination: Path) -> None:
+    """
+    Download asset bytes to the target destination via a temporary file.
+    """
+    _download_to_file(MEDIA_ASSETS[filename][0], destination, timeout=30.0, stream=True)
+
+
+def _download_verified_asset(
+    filename: str,
+    original_md5_hash: str,
+    destination: Path,
+    check_target: str | Path,
+    retry_on_mismatch: bool = True,
+) -> None:
+    """
+    Download an asset and reject payloads whose MD5 does not match the catalog.
+    """
+    _download_asset(filename, destination)
+
+    if is_md5_hash_matching(check_target, original_md5_hash):
+        return
+
+    logger.warning("File corrupted. Re-downloading...")
+    os.remove(check_target)
+
+    if retry_on_mismatch:
+        _download_verified_asset(
+            filename=filename,
+            original_md5_hash=original_md5_hash,
+            destination=destination,
+            check_target=check_target,
+            retry_on_mismatch=False,
+        )
+        return
+
+    raise ValueError(f"Downloaded asset {filename!r} failed MD5 verification.")
+
+
+def download_assets(
+    asset_name: Assets | str,
+    directory: str | Path | None = None,
+) -> str:
+    """
+    Download a specified asset if it doesn't already exist or is corrupted.
+
+    Args:
+        asset_name: The name or type of the asset to be downloaded.
+        directory: Optional output directory. Defaults to the current working
+            directory for backward compatibility.
+
+    Returns:
+        The downloaded asset path. When `directory` is omitted, this preserves
+        the historical filename-only return value.
+
+    Example:
+        ```pycon
+        >>> from supervision.assets import download_assets, ImageAssets, VideoAssets
+        >>> download_assets(VideoAssets.VEHICLES)  # doctest: +SKIP
+        'vehicles.mp4'
+
+        >>> download_assets(ImageAssets.PEOPLE_WALKING)  # doctest: +SKIP
+        'people-walking.jpg'
+
+        ```
+    """
+
+    filename = asset_name.filename if isinstance(asset_name, Assets) else asset_name
+    if directory is None:
+        destination = Path.cwd() / filename
+        check_target: str | Path = filename
+        return_value = filename
+    else:
+        destination_directory = Path(directory).expanduser().resolve()
+        destination = destination_directory / filename
+        check_target = str(destination)
+        return_value = str(destination)
+
+    if filename in MEDIA_ASSETS:
+        original_md5_hash = MEDIA_ASSETS[filename][1]
+        if not Path(check_target).exists():
+            logger.info("Downloading %s assets", filename)
+            _download_verified_asset(
+                filename=filename,
+                original_md5_hash=original_md5_hash,
+                destination=destination,
+                check_target=check_target,
+            )
+        else:
+            if not is_md5_hash_matching(check_target, original_md5_hash):
+                logger.warning("File corrupted. Re-downloading...")
+                os.remove(check_target)
+                _download_verified_asset(
+                    filename=filename,
+                    original_md5_hash=original_md5_hash,
+                    destination=destination,
+                    check_target=check_target,
+                )
+
+            logger.info("%s asset download complete.", filename)
+    else:
+        valid_assets = ", ".join(filename for filename in MEDIA_ASSETS.keys())
+        raise ValueError(
+            f"Invalid asset. It should be one of the following: {valid_assets}."
+        )
+
+    return return_value
diff --git a/.venv/lib/python3.12/site-packages/supervision/assets/list.py b/.venv/lib/python3.12/site-packages/supervision/assets/list.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b2a2ba4814d90e1abf922e64981d7f809ad1cca
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/assets/list.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+from enum import Enum
+
+BASE_VIDEO_URL = "https://media.roboflow.com/supervision/video-examples/"
+BASE_IMAGE_URL = "https://media.roboflow.com/supervision/image-examples/"
+
+
+class Assets(Enum):
+    filename: str
+    md5_hash: str
+
+    def __new__(cls, filename: str, md5_hash: str) -> Assets:
+        obj = object.__new__(cls)
+        obj._value_ = filename
+        obj.filename = filename
+        obj.md5_hash = md5_hash
+        return obj
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return [asset.filename for asset in cls]
+
+
+class VideoAssets(Assets):
+    """
+    Each member of this class represents a video asset. The value associated with each
+    member has a filename and hash of the video. File names and links can be seen below.
+
+    | Asset                  | Video Filename             | Video URL                                                                             |
+    |------------------------|----------------------------|---------------------------------------------------------------------------------------|
+    | `VEHICLES`             | `vehicles.mp4`             | [Link](https://media.roboflow.com/supervision/video-examples/vehicles.mp4)            |
+    | `MILK_BOTTLING_PLANT`  | `milk-bottling-plant.mp4`  | [Link](https://media.roboflow.com/supervision/video-examples/milk-bottling-plant.mp4) |
+    | `VEHICLES_2`           | `vehicles-2.mp4`           | [Link](https://media.roboflow.com/supervision/video-examples/vehicles-2.mp4)          |
+    | `GROCERY_STORE`        | `grocery-store.mp4`        | [Link](https://media.roboflow.com/supervision/video-examples/grocery-store.mp4)       |
+    | `SUBWAY`               | `subway.mp4`               | [Link](https://media.roboflow.com/supervision/video-examples/subway.mp4)              |
+    | `MARKET_SQUARE`        | `market-square.mp4`        | [Link](https://media.roboflow.com/supervision/video-examples/market-square.mp4)       |
+    | `PEOPLE_WALKING`       | `people-walking.mp4`       | [Link](https://media.roboflow.com/supervision/video-examples/people-walking.mp4)      |
+    | `BEACH`                | `beach-1.mp4`              | [Link](https://media.roboflow.com/supervision/video-examples/beach-1.mp4)             |
+    | `BASKETBALL`           | `basketball-1.mp4`         | [Link](https://media.roboflow.com/supervision/video-examples/basketball-1.mp4)        |
+    | `SKIING`               | `skiing.mp4`               | [Link](https://media.roboflow.com/supervision/video-examples/skiing.mp4)              |
+    """  # noqa: E501 // docs
+
+    VEHICLES = ("vehicles.mp4", "8155ff4e4de08cfa25f39de96483f918")
+    MILK_BOTTLING_PLANT = (
+        "milk-bottling-plant.mp4",
+        "9e8fb6e883f842a38b3d34267290bdc7",
+    )
+    VEHICLES_2 = ("vehicles-2.mp4", "830af6fba21ffbf14867a7fea595937b")
+    GROCERY_STORE = ("grocery-store.mp4", "48608fb4a8981f1c2469fa492adeec9c")
+    SUBWAY = ("subway.mp4", "453475750691fb23c56a0cffef089194")
+    MARKET_SQUARE = ("market-square.mp4", "859179bf4a21f80a8baabfdb2ed716dc")
+    PEOPLE_WALKING = ("people-walking.mp4", "0574c053c8686c3f1dc0aa3743e45cb9")
+    BEACH = ("beach-1.mp4", "4175d42fec4d450ed081523fd39e0cf8")
+    BASKETBALL = ("basketball-1.mp4", "60d94a3c7c47d16f09d342b088012ecc")
+    SKIING = ("skiing.mp4", "d30987cbab1bbc5934199cdd1b293119")
+
+
+class ImageAssets(Assets):
+    """
+    Each member of this enum represents a image asset. The value associated with each
+    member is the filename of the image.
+
+    | Asset              | Image Filename         | Video URL                                                                             |
+    |--------------------|------------------------|---------------------------------------------------------------------------------------|
+    | `PEOPLE_WALKING`   | `people-walking.jpg`   | [Link](https://media.roboflow.com/supervision/image-examples/people-walking.jpg)      |
+    | `SOCCER`           | `soccer.jpg`           | [Link](https://media.roboflow.com/supervision/image-examples/soccer.jpg)              |
+
+    """  # noqa: E501 // docs
+
+    PEOPLE_WALKING = ("people-walking.jpg", "e6bda00b47f2908eeae7df86ef995dcd")
+    SOCCER = ("soccer.jpg", "0f5a4b98abf3e3973faf9e9260a7d876")
+
+
+MEDIA_ASSETS: dict[str, tuple[str, str]] = {
+    **{
+        asset.filename: (f"{BASE_VIDEO_URL}{asset.filename}", asset.md5_hash)
+        for asset in VideoAssets
+    },
+    **{
+        asset.filename: (f"{BASE_IMAGE_URL}{asset.filename}", asset.md5_hash)
+        for asset in ImageAssets
+    },
+}
diff --git a/.venv/lib/python3.12/site-packages/supervision/classification/__init__.py b/.venv/lib/python3.12/site-packages/supervision/classification/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..361d58fa11185d0009706e384d2deb8c45e8d943
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32113ec389eb5c565006d483779a1da8d336d0c1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/classification/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/classification/core.py b/.venv/lib/python3.12/site-packages/supervision/classification/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..82a110f153e8c03ceec10e4664568c1eaf4a0c81
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/classification/core.py
@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import numpy.typing as npt
+
+if TYPE_CHECKING:
+    import torch  # type: ignore[import-not-found, unused-ignore]
+
+
+def _validate_class_ids(class_id: Any, n: int) -> None:
+    """
+    Ensure that class_id is a 1d np.ndarray with (n, ) shape.
+    """
+    is_valid = isinstance(class_id, np.ndarray) and class_id.shape == (n,)
+    if not is_valid:
+        raise ValueError("class_id must be 1d np.ndarray with (n, ) shape")
+
+
+def _validate_confidence(confidence: Any, n: int) -> None:
+    """
+    Ensure that confidence is a 1d np.ndarray with (n, ) shape.
+    """
+    if confidence is not None:
+        is_valid = isinstance(confidence, np.ndarray) and confidence.shape == (n,)
+        if not is_valid:
+            raise ValueError("confidence must be 1d np.ndarray with (n, ) shape")
+
+
+@dataclass
+class Classifications:
+    class_id: npt.NDArray[np.int_]
+    confidence: npt.NDArray[np.floating] | None = None
+
+    def __post_init__(self) -> None:
+        """
+        Validate the classification inputs.
+        """
+        n = len(self.class_id)
+
+        _validate_class_ids(self.class_id, n)
+        _validate_confidence(self.confidence, n)
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Compare classifications by value across numpy-backed fields.
+        """
+        if not isinstance(other, Classifications):
+            return NotImplemented
+        if not np.array_equal(self.class_id, other.class_id):
+            return False
+        if self.confidence is None or other.confidence is None:
+            return self.confidence is other.confidence
+        return bool(np.array_equal(self.confidence, other.confidence))
+
+    def __len__(self) -> int:
+        """
+        Returns the number of classifications.
+        """
+        return len(self.class_id)
+
+    @classmethod
+    def from_clip(cls, clip_results: torch.Tensor) -> Classifications:
+        """
+        Creates a Classifications instance from a
+        [clip](https://github.com/openai/clip) inference result.
+
+        Args:
+            clip_results: The inference result from clip model.
+
+        Returns:
+            A new Classifications object.
+
+        Example:
+            ```python
+            from PIL import Image
+            import clip
+            import supervision as sv
+
+            model, preprocess = clip.load('ViT-B/32')
+
+            image = cv2.imread(SOURCE_IMAGE_PATH)
+            image = preprocess(image).unsqueeze(0)
+
+            text = clip.tokenize(["a diagram", "a dog", "a cat"])
+            output, _ = model(image, text)
+            classifications = sv.Classifications.from_clip(output)
+            ```
+        """
+
+        confidence = clip_results.softmax(dim=-1).cpu().detach().numpy()[0]
+
+        if len(confidence) == 0:
+            return cls(
+                class_id=np.array([], dtype=np.int_),
+                confidence=np.array([], dtype=np.float32),
+            )
+
+        class_ids = np.arange(len(confidence))
+        return cls(class_id=class_ids, confidence=confidence)
+
+    @classmethod
+    def from_ultralytics(cls, ultralytics_results: Any) -> Classifications:
+        """
+        Creates a Classifications instance from a
+        [ultralytics](https://github.com/ultralytics/ultralytics) inference result.
+
+        Args:
+            ultralytics_results: The inference result from ultralytics model.
+
+        Returns:
+            A new Classifications object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            from ultralytics import YOLO
+            import supervision as sv
+
+            image = cv2.imread(SOURCE_IMAGE_PATH)
+            model = YOLO('yolov8n-cls.pt')
+
+            output = model(image)[0]
+            classifications = sv.Classifications.from_ultralytics(output)
+            ```
+        """
+        confidence = ultralytics_results.probs.data.cpu().numpy()
+        return cls(class_id=np.arange(confidence.shape[0]), confidence=confidence)
+
+    @classmethod
+    def from_timm(cls, timm_results: Any) -> Classifications:
+        """
+        Creates a Classifications instance from a
+        [timm](https://huggingface.co/docs/hub/timm) inference result.
+
+        Note:
+            Returned confidences are softmax-normalized probabilities, so
+            thresholds calibrated against raw logits may need recalibration.
+
+        Args:
+            timm_results: The inference result from timm model.
+
+        Returns:
+            A new Classifications object.
+
+        Example:
+            ```python
+            from PIL import Image
+            import timm
+            from timm.data import resolve_data_config, create_transform
+            import supervision as sv
+
+            model = timm.create_model(
+                model_name='hf-hub:nateraw/resnet50-oxford-iiit-pet',
+                pretrained=True
+            ).eval()
+
+            config = resolve_data_config({}, model=model)
+            transform = create_transform(**config)
+
+            image = Image.open(SOURCE_IMAGE_PATH).convert('RGB')
+            x = transform(image).unsqueeze(0)
+
+            output = model(x)
+
+            classifications = sv.Classifications.from_timm(output)
+            ```
+        """
+        confidence = timm_results.softmax(dim=-1).cpu().detach().numpy()[0]
+
+        if len(confidence) == 0:
+            return cls(
+                class_id=np.array([], dtype=np.int_),
+                confidence=np.array([], dtype=np.float32),
+            )
+
+        class_id = np.arange(len(confidence))
+        return cls(class_id=class_id, confidence=confidence)
+
+    def get_top_k(
+        self, k: int
+    ) -> tuple[npt.NDArray[np.int_], npt.NDArray[np.floating]]:
+        """
+        Retrieve the top k class IDs and confidences,
+            ordered in descending order by confidence.
+
+        Args:
+            k: The number of top class IDs and confidences to retrieve.
+
+        Returns:
+            A tuple containing the top k class IDs and confidences.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> classifications = sv.Classifications(
+            ...     class_id=np.array([0, 1, 2]),
+            ...     confidence=np.array([0.3, 0.9, 0.5])
+            ... )
+            >>> classifications.get_top_k(1)
+            (array([1]), array([0.9]))
+
+            ```
+        """
+        if self.confidence is None:
+            raise ValueError("top_k could not be calculated, confidence is None")
+
+        order = np.argsort(self.confidence)[::-1]
+        top_k_order = order[:k]
+        top_k_class_id = self.class_id[top_k_order]
+        top_k_confidence = self.confidence[top_k_order]
+
+        return top_k_class_id, top_k_confidence
diff --git a/.venv/lib/python3.12/site-packages/supervision/config.py b/.venv/lib/python3.12/site-packages/supervision/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..37cdc75c4635d4acda1ae269ecdf91fc3613cda0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/config.py
@@ -0,0 +1,26 @@
+CLASS_NAME_DATA_FIELD: str = "class_name"
+COCO_RAW_SEGMENTATION: str = "coco_raw_segmentation"
+#: Key for per-detection area metadata in ``Detections.data``.
+AREA_DATA_FIELD: str = "area"
+#: Key for the source image in ``Detections.metadata``.
+#:
+#: An RF-DETR / ``inference``-package convention rather than a field supervision
+#: itself populates: model connectors from those packages attach the image the
+#: predictions were produced from under this key.
+#: :class:`~supervision.detection.tools.inference_slicer.InferenceSlicer` drops it
+#: while merging slices (each slice carries a different tile) and restores the full
+#: input image afterwards.
+#: The stored value is a reference to the caller's image, not a copy — mutating
+#: ``metadata[SOURCE_IMAGE_METADATA_FIELD]`` mutates the original array.
+SOURCE_IMAGE_METADATA_FIELD: str = "source_image"
+#: Key for oriented bounding-box corner coordinates in ``Detections.data``.
+#:
+#: Value layout: ``np.ndarray`` of shape ``(N, 4, 2)``, dtype ``float32``, pixel
+#: coordinates ordered as ``[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`` per
+#: detection where the four points are the corners of the oriented box.
+#: Used by :func:`~supervision.dataset.formats.yolo.detections_to_yolo_annotations`
+#: (``is_obb=True``) and
+#: :func:`~supervision.dataset.formats.yolo.yolo_annotations_to_detections`
+#: (``is_obb=True``).
+#: Also triggers sequential mode in ``InferenceSlicer`` when present.
+ORIENTED_BOX_COORDINATES: str = "xyxyxyxy"
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/__init__.py b/.venv/lib/python3.12/site-packages/supervision/dataset/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3b596682fdca96b887ee23595d9f2e730e1a6b0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e48ce267670b4ae8f09e4746de13e1acc2e8f32a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..115d3f3b519a664e008f79dc35e33bffb0d88f97
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/core.py b/.venv/lib/python3.12/site-packages/supervision/dataset/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..d75243571610218c736f506e1c88e10e6f24d049
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/core.py
@@ -0,0 +1,1341 @@
+from __future__ import annotations
+
+import contextlib
+import os
+import shutil
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from copy import deepcopy
+from dataclasses import dataclass
+from itertools import chain
+from pathlib import Path
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+from tqdm.auto import tqdm
+
+from supervision import _cv2 as cv2
+from supervision.classification.core import Classifications
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.dataset.formats.coco import (
+    load_coco_annotations,
+    save_coco_annotations,
+)
+from supervision.dataset.formats.createml import (
+    load_createml_annotations,
+    save_createml_annotations,
+)
+from supervision.dataset.formats.labelme import (
+    load_labelme_annotations,
+    save_labelme_annotations,
+)
+from supervision.dataset.formats.pascal_voc import (
+    load_pascal_voc_annotations,
+    save_pascal_voc_annotations,
+)
+from supervision.dataset.formats.yolo import (
+    load_yolo_annotations,
+    save_data_yaml,
+    save_yolo_annotations,
+)
+from supervision.dataset.utils import (
+    build_class_index_mapping,
+    check_no_basename_collisions,
+    map_detections_class_id,
+    merge_class_lists,
+    save_dataset_images,
+    train_test_split,
+)
+from supervision.detection.core import Detections
+from supervision.utils.internal import warn_deprecated
+from supervision.utils.iterables import find_duplicates
+
+_IMAGE_FILE_EXTENSIONS = frozenset(
+    {".bmp", ".jpeg", ".jpg", ".png", ".tif", ".tiff", ".webp"}
+)
+
+
+class BaseDataset(ABC):
+    @abstractmethod
+    def __len__(self) -> int:
+        pass
+
+    @abstractmethod
+    def split(
+        self,
+        split_ratio: float = 0.8,
+        random_state: int | None = None,
+        shuffle: bool = True,
+    ) -> tuple[BaseDataset, BaseDataset]:
+        pass
+
+
+class DetectionDataset(BaseDataset):
+    """
+    Contains information about a detection dataset. Handles lazy image loading
+    and annotation retrieval, dataset splitting, conversions into multiple
+    formats.
+
+    Attributes:
+        classes: List containing dataset class names.
+        images:
+            Accepts a list of image paths. Passing a dict
+            (``Dict[str, np.ndarray]``) is deprecated in ``0.30.0`` and will
+            be removed in ``0.33.0``; use a list of paths instead.
+            When a list of paths is provided, images are loaded lazily on
+            demand, which is more memory-efficient.
+        annotations: Dictionary mapping
+            image path to annotations. The dictionary keys match
+            match the keys in `images` or entries in the list of
+            image paths.
+    """
+
+    def __init__(
+        self,
+        classes: list[str],
+        images: list[str] | dict[str, npt.NDArray[np.uint8]],
+        annotations: dict[str, Detections],
+    ) -> None:
+        self.classes = classes
+
+        if set(images) != set(annotations):
+            raise ValueError(
+                "The keys of the images and annotations dictionaries must match."
+            )
+        self.annotations = {
+            image_path: deepcopy(annotation)
+            for image_path, annotation in annotations.items()
+        }
+
+        np_classes = np.array(self.classes)
+        for image_path, annotation in self.annotations.items():
+            class_ids = annotation.class_id
+            if class_ids is None:
+                continue
+            if not np.issubdtype(class_ids.dtype, np.integer):
+                raise ValueError(
+                    f"Detection annotation for image {image_path!r} contains "
+                    f"non-integer class_id values with dtype {class_ids.dtype}."
+                )
+
+            invalid_class_ids = class_ids[
+                (class_ids < 0) | (class_ids >= len(self.classes))
+            ]
+            if len(invalid_class_ids) > 0:
+                valid_range = (
+                    "empty"
+                    if len(self.classes) == 0
+                    else f"[0, {len(self.classes) - 1}]"
+                )
+                raise ValueError(
+                    f"Detection annotation for image {image_path!r} contains "
+                    f"class_id {int(invalid_class_ids[0])}, outside the valid "
+                    f"range {valid_range} for {len(self.classes)} classes."
+                )
+
+            annotation.data[CLASS_NAME_DATA_FIELD] = np_classes[class_ids]
+
+        # Eliminate duplicates while preserving order
+        self.image_paths = list(dict.fromkeys(images))
+
+        self._images_in_memory: dict[str, npt.NDArray[np.uint8]] = {}
+        if isinstance(images, dict):
+            self._images_in_memory = images
+            warn_deprecated(
+                "Passing a `Dict[str, np.ndarray]` into `DetectionDataset` is "
+                "deprecated in `0.30.0` and will be removed in `0.33.0`. Use "
+                "a list of paths `List[str]` instead."
+            )
+
+    def _get_image(self, image_path: str) -> npt.NDArray[np.uint8]:
+        """Assumes that image is in dataset."""
+        if self._images_in_memory:
+            return self._images_in_memory[image_path]
+        image = cv2.imread(image_path)
+        if image is None:
+            raise ValueError(f"Could not read image from path: {image_path}")
+        return cast(npt.NDArray[np.uint8], image)
+
+    def __len__(self) -> int:
+        return len(self._images_in_memory) or len(self.image_paths)
+
+    def __getitem__(self, i: int) -> tuple[str, npt.NDArray[np.uint8], Detections]:
+        """
+        Returns:
+            The image path, image data,
+                and its corresponding annotation at index i.
+        """
+        image_path = self.image_paths[i]
+        image = self._get_image(image_path)
+        annotation = self.annotations[image_path]
+        return image_path, image, annotation
+
+    def __iter__(self) -> Iterator[tuple[str, npt.NDArray[np.uint8], Detections]]:
+        """
+        Iterate over the images and annotations in the dataset.
+
+        Yields:
+            Tuples containing the image path, image data, and its annotation.
+        """
+        for i in range(len(self)):
+            image_path, image, annotation = self[i]
+            yield image_path, image, annotation
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DetectionDataset):
+            return False
+
+        if self.classes != other.classes:
+            return False
+
+        if self.image_paths != other.image_paths:
+            return False
+
+        if self._images_in_memory or other._images_in_memory:
+            if not np.array_equal(
+                list(self._images_in_memory.values()),
+                list(other._images_in_memory.values()),
+            ):
+                return False
+
+        if self.annotations != other.annotations:
+            return False
+
+        return True
+
+    def split(
+        self,
+        split_ratio: float = 0.8,
+        random_state: int | None = None,
+        shuffle: bool = True,
+    ) -> tuple[DetectionDataset, DetectionDataset]:
+        """
+        Splits the dataset into two parts (training and testing)
+            using the provided split_ratio. The input dataset is not mutated.
+
+        Args:
+            split_ratio: The ratio of the training
+                set to the entire dataset.
+            random_state: The seed for the random number generator.
+                This is used for reproducibility.
+            shuffle: Whether to shuffle the data before splitting.
+
+        Returns:
+            A tuple containing
+                the training and testing datasets.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> ds = sv.DetectionDataset(
+            ...     classes=['dog', 'person'],
+            ...     images={
+            ...         'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8),
+            ...         'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8),
+            ...     },
+            ...     annotations={
+            ...         'img1.jpg': sv.Detections(xyxy=np.array([[10, 10, 20, 20]])),
+            ...         'img2.jpg': sv.Detections(xyxy=np.array([[30, 30, 40, 40]])),
+            ...     }
+            ... )
+            >>> train_ds, test_ds = ds.split(split_ratio=0.5, random_state=42)
+            >>> len(train_ds), len(test_ds)
+            (1, 1)
+
+            ```
+        """
+
+        train_paths, test_paths = train_test_split(
+            data=self.image_paths,
+            train_ratio=split_ratio,
+            random_state=random_state,
+            shuffle=shuffle,
+        )
+
+        train_annotations = {path: self.annotations[path] for path in train_paths}
+        test_annotations = {path: self.annotations[path] for path in test_paths}
+
+        train_dataset = DetectionDataset(
+            classes=self.classes,
+            images=train_paths,
+            annotations=train_annotations,
+        )
+        test_dataset = DetectionDataset(
+            classes=self.classes,
+            images=test_paths,
+            annotations=test_annotations,
+        )
+        if self._images_in_memory:
+            train_dataset._images_in_memory = {
+                path: self._images_in_memory[path] for path in train_paths
+            }
+            test_dataset._images_in_memory = {
+                path: self._images_in_memory[path] for path in test_paths
+            }
+        return train_dataset, test_dataset
+
+    @classmethod
+    def merge(cls, dataset_list: list[DetectionDataset]) -> DetectionDataset:
+        """
+        Merge a list of `DetectionDataset` objects into a single
+            `DetectionDataset` object.
+
+        This method takes a list of `DetectionDataset` objects and combines
+        their respective fields (`classes`, `images`,
+        `annotations`) into a single `DetectionDataset` object.
+
+        Args:
+            dataset_list: A list of `DetectionDataset`
+                objects to merge.
+
+        Returns:
+            A single `DetectionDataset` object containing
+            the merged data from the input list.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> ds_1 = sv.DetectionDataset(
+            ...     classes=['dog', 'person'],
+            ...     images={'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8)},
+            ...     annotations={'img1.jpg': sv.Detections.empty()}
+            ... )
+            >>> len(ds_1)
+            1
+            >>> ds_1.classes
+            ['dog', 'person']
+            >>> ds_2 = sv.DetectionDataset(
+            ...     classes=['cat'],
+            ...     images={'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8)},
+            ...     annotations={'img2.jpg': sv.Detections.empty()}
+            ... )
+            >>> len(ds_2)
+            1
+            >>> ds_2.classes
+            ['cat']
+            >>> ds_merged = sv.DetectionDataset.merge([ds_1, ds_2])
+            >>> len(ds_merged)
+            2
+            >>> ds_merged.classes
+            ['cat', 'dog', 'person']
+
+            ```
+        """
+
+        def is_in_memory(dataset: DetectionDataset) -> bool:
+            return len(dataset._images_in_memory) > 0 or len(dataset.image_paths) == 0
+
+        def is_lazy(dataset: DetectionDataset) -> bool:
+            return len(dataset._images_in_memory) == 0
+
+        all_in_memory = all([is_in_memory(dataset) for dataset in dataset_list])
+        all_lazy = all([is_lazy(dataset) for dataset in dataset_list])
+        if not all_in_memory and not all_lazy:
+            raise ValueError(
+                "Merging lazy and in-memory DetectionDatasets is not supported."
+            )
+
+        images_in_memory = {}
+        for dataset in dataset_list:
+            images_in_memory.update(dataset._images_in_memory)
+
+        image_paths = list(
+            chain.from_iterable(dataset.image_paths for dataset in dataset_list)
+        )
+        image_paths_unique = list(dict.fromkeys(image_paths))
+        if len(image_paths) != len(image_paths_unique):
+            duplicates = find_duplicates(image_paths)
+            raise ValueError(
+                f"Image paths {duplicates} are not unique across datasets."
+            )
+        image_paths = image_paths_unique
+
+        classes = merge_class_lists(
+            class_lists=[dataset.classes for dataset in dataset_list]
+        )
+
+        annotations = {}
+        for dataset in dataset_list:
+            annotations.update(dataset.annotations)
+        for dataset in dataset_list:
+            class_index_mapping = build_class_index_mapping(
+                source_classes=dataset.classes, target_classes=classes
+            )
+            for image_path in dataset.image_paths:
+                annotations[image_path] = map_detections_class_id(
+                    source_to_target_mapping=class_index_mapping,
+                    detections=annotations[image_path],
+                )
+
+        merged_dataset = cls(
+            classes=classes,
+            images=image_paths,
+            annotations=annotations,
+        )
+        if all_in_memory:
+            merged_dataset._images_in_memory = images_in_memory
+        return merged_dataset
+
+    def as_pascal_voc(
+        self,
+        images_directory_path: str | None = None,
+        annotations_directory_path: str | None = None,
+        min_image_area_percentage: float = 0.0,
+        max_image_area_percentage: float = 1.0,
+        approximation_percentage: float = 0.0,
+        show_progress: bool = False,
+    ) -> None:
+        """
+        Exports the dataset to PASCAL VOC format. This method saves the images
+        and their corresponding annotations in PASCAL VOC format. Both output
+        layouts are preflighted before any files are written so a collision in
+        either target fails without partial output.
+
+        Args:
+            images_directory_path: The path to the directory
+                where the images should be saved.
+                If not provided, images will not be saved.
+            annotations_directory_path: The path to
+                the directory where the annotations in PASCAL VOC format should be
+                saved. If not provided, annotations will not be saved.
+            min_image_area_percentage: The minimum percentage of
+                detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            max_image_area_percentage: The maximum percentage
+                of detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            approximation_percentage: The percentage of
+                polygon points to be removed from the input polygon,
+                in the range [0, 1). Argument is used only for segmentation datasets.
+            show_progress: If True, display a progress bar during saving.
+
+        Raises:
+            ValueError: If two image paths share the same basename (when
+                images_directory_path is set) or the same stem (when
+                annotations_directory_path is set), which would cause one
+                output file to overwrite another. Rename images to ensure
+                unique basenames before exporting a merged dataset.
+        """
+        if images_directory_path:
+            check_no_basename_collisions(
+                image_paths=self.image_paths,
+                key=lambda image_path: Path(image_path).name,
+                output_kind="image",
+            )
+        if annotations_directory_path:
+            check_no_basename_collisions(
+                image_paths=self.image_paths,
+                key=lambda image_path: f"{Path(image_path).stem}.xml",
+                output_kind="Pascal VOC annotation",
+            )
+
+        if images_directory_path:
+            save_dataset_images(
+                dataset=self,
+                images_directory_path=images_directory_path,
+                show_progress=show_progress,
+            )
+        if annotations_directory_path:
+            save_pascal_voc_annotations(
+                dataset=self,
+                annotations_directory_path=annotations_directory_path,
+                min_image_area_percentage=min_image_area_percentage,
+                max_image_area_percentage=max_image_area_percentage,
+                approximation_percentage=approximation_percentage,
+                show_progress=show_progress,
+            )
+
+    @classmethod
+    def from_pascal_voc(
+        cls,
+        images_directory_path: str,
+        annotations_directory_path: str,
+        force_masks: bool = False,
+        show_progress: bool = False,
+    ) -> DetectionDataset:
+        """
+        Creates a Dataset instance from PASCAL VOC formatted data.
+
+        Args:
+            images_directory_path: Path to the directory containing the images.
+            annotations_directory_path: Path to the directory
+                containing the PASCAL VOC XML annotations.
+            force_masks: If True, forces masks to
+                be loaded for all annotations, regardless of whether they are present.
+            show_progress: If True, display a progress bar during loading.
+
+        Returns:
+            A DetectionDataset instance containing
+                the loaded images and annotations.
+
+        Examples:
+            ```python
+            import roboflow
+            from roboflow import Roboflow
+            import supervision as sv
+
+            roboflow.login()
+
+            rf = Roboflow()
+
+            project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
+            dataset = project.version(PROJECT_VERSION).download("voc")
+
+            ds = sv.DetectionDataset.from_pascal_voc(
+                images_directory_path=f"{dataset.location}/train/images",
+                annotations_directory_path=f"{dataset.location}/train/labels",
+                # pass show_progress=True to enable a tqdm progress bar
+            )
+
+            ds.classes
+            # ['dog', 'person']
+            ```
+        """
+
+        classes, image_paths, annotations = load_pascal_voc_annotations(
+            images_directory_path=images_directory_path,
+            annotations_directory_path=annotations_directory_path,
+            force_masks=force_masks,
+            show_progress=show_progress,
+        )
+
+        return DetectionDataset(
+            classes=classes, images=image_paths, annotations=annotations
+        )
+
+    @classmethod
+    def from_yolo(
+        cls,
+        images_directory_path: str,
+        annotations_directory_path: str,
+        data_yaml_path: str,
+        force_masks: bool = False,
+        is_obb: bool = False,
+        show_progress: bool = False,
+    ) -> DetectionDataset:
+        """
+        Creates a Dataset instance from YOLO formatted data.
+
+        Args:
+            images_directory_path: The path to the
+                directory containing the images.
+            annotations_directory_path: The path to the directory
+                containing the YOLO annotation files.
+            data_yaml_path: The path to the data
+                YAML file containing class information.
+            force_masks: If True, forces
+                masks to be loaded for all annotations,
+                regardless of whether they are present.
+            is_obb: If True, loads the annotations in OBB format.
+                OBB annotations are defined as `[class_id, x, y, x, y, x, y, x, y]`,
+                where pairs of [x, y] are box corners.
+            show_progress: If True, display a progress bar during loading.
+
+        Returns:
+            A DetectionDataset instance
+                containing the loaded images and annotations.
+
+        Examples:
+            ```python
+            import roboflow
+            from roboflow import Roboflow
+            import supervision as sv
+
+            roboflow.login()
+            rf = Roboflow()
+
+            project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
+            dataset = project.version(PROJECT_VERSION).download("yolov5")
+
+            ds = sv.DetectionDataset.from_yolo(
+                images_directory_path=f"{dataset.location}/train/images",
+                annotations_directory_path=f"{dataset.location}/train/labels",
+                data_yaml_path=f"{dataset.location}/data.yaml",
+                # pass show_progress=True to enable a tqdm progress bar
+            )
+
+            ds.classes
+            # ['dog', 'person']
+            ```
+        """
+        classes, image_paths, annotations = load_yolo_annotations(
+            images_directory_path=images_directory_path,
+            annotations_directory_path=annotations_directory_path,
+            data_yaml_path=data_yaml_path,
+            force_masks=force_masks,
+            is_obb=is_obb,
+            show_progress=show_progress,
+        )
+        return DetectionDataset(
+            classes=classes, images=image_paths, annotations=annotations
+        )
+
+    def as_yolo(
+        self,
+        images_directory_path: str | None = None,
+        annotations_directory_path: str | None = None,
+        data_yaml_path: str | None = None,
+        min_image_area_percentage: float = 0.0,
+        max_image_area_percentage: float = 1.0,
+        approximation_percentage: float = 0.0,
+        is_obb: bool = False,
+        show_progress: bool = False,
+    ) -> None:
+        """
+        Exports the dataset to YOLO format. This method saves the
+        images and their corresponding annotations in YOLO format.
+
+        Args:
+            images_directory_path: The path to the
+                directory where the images should be saved.
+                If not provided, images will not be saved.
+            annotations_directory_path: The path to the
+                directory where the annotations in
+                YOLO format should be saved. If not provided,
+                annotations will not be saved.
+            data_yaml_path: The path where the data.yaml
+                file should be saved.
+                If not provided, the file will not be saved.
+            min_image_area_percentage: The minimum percentage of
+                detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            max_image_area_percentage: The maximum percentage
+                of detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            approximation_percentage: The percentage of polygon points to
+                be removed from the input polygon, in the range [0, 1).
+                This is useful for simplifying the annotations.
+                Argument is used only for segmentation datasets.
+            is_obb: If True, exports annotations in OBB format
+                (`class_id x1 y1 x2 y2 x3 y3 x4 y4`) using the oriented
+                corners stored in `detections.data["xyxyxyxy"]`. Mirrors
+                `from_yolo(..., is_obb=True)`. Masks are ignored when
+                `is_obb=True`.
+            show_progress: If True, display a progress bar during saving.
+
+        Raises:
+            ValueError: If two image paths share the same basename (when
+                images_directory_path is set) or the same annotation
+                file name (when annotations_directory_path is set),
+                which would cause one output file to overwrite another.
+        """
+        if is_obb and (
+            min_image_area_percentage != 0.0
+            or max_image_area_percentage != 1.0
+            or approximation_percentage != 0.0
+        ):
+            import warnings
+
+            warnings.warn(
+                "`min_image_area_percentage`, `max_image_area_percentage`, and "
+                "`approximation_percentage` have no effect when `is_obb=True`; "
+                "OBB annotations use corner coordinates directly.",
+                UserWarning,
+                stacklevel=2,
+            )
+        # Pre-flight: validate output uniqueness before writing any file
+        if images_directory_path:
+            check_no_basename_collisions(
+                image_paths=self.image_paths,
+                key=lambda image_path: Path(image_path).name,
+                output_kind="image",
+            )
+        if annotations_directory_path:
+            check_no_basename_collisions(
+                image_paths=self.image_paths,
+                key=lambda image_path: Path(image_path).stem + ".txt",
+                output_kind="YOLO annotation",
+            )
+
+        if images_directory_path is not None:
+            save_dataset_images(
+                dataset=self,
+                images_directory_path=images_directory_path,
+                show_progress=show_progress,
+            )
+        if annotations_directory_path is not None:
+            save_yolo_annotations(
+                dataset=self,
+                annotations_directory_path=annotations_directory_path,
+                min_image_area_percentage=min_image_area_percentage,
+                max_image_area_percentage=max_image_area_percentage,
+                approximation_percentage=approximation_percentage,
+                show_progress=show_progress,
+                is_obb=is_obb,
+            )
+        if data_yaml_path is not None:
+            save_data_yaml(data_yaml_path=data_yaml_path, classes=self.classes)
+
+    @classmethod
+    def from_labelme(
+        cls,
+        images_directory_path: str,
+        annotations_directory_path: str,
+        force_masks: bool = False,
+    ) -> DetectionDataset:
+        """
+        Creates a Dataset instance from LabelMe formatted data.
+
+        LabelMe stores one JSON file per image, each containing a list of
+        ``shapes``. ``rectangle`` shapes are loaded as bounding boxes and
+        ``polygon`` shapes as masks (with their bounding boxes); other shape
+        types are skipped. Class names are inferred from the labels present in
+        the files. When an image file contains a ``polygon`` shape, or when
+        ``force_masks=True`` is set, both ``rectangle`` and ``polygon`` shapes
+        produce masks: rectangles via a four-corner polygon fill.
+
+        Args:
+            images_directory_path: The path to the
+                directory containing the images.
+            annotations_directory_path: The path to the directory
+                containing the LabelMe ``.json`` annotation files.
+            force_masks: If True, forces masks to be loaded for all
+                annotations, regardless of whether polygon shapes are present.
+                Requires ``imageWidth`` and ``imageHeight`` in every JSON file.
+
+        Returns:
+            A DetectionDataset instance containing
+                the loaded images and annotations.
+
+        Raises:
+            ValueError: If an annotation is malformed - for example
+                ``imagePath`` is empty or resolves to ``..``, a shape is
+                missing its ``label`` or ``points``, or a mask is required but
+                ``imageWidth`` / ``imageHeight`` are missing or zero.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            ds = sv.DetectionDataset.from_labelme(
+                images_directory_path="",
+                annotations_directory_path="",
+            )
+
+            ds.classes
+            # ['dog', 'person']
+            ```
+        """
+        classes, image_paths, annotations = load_labelme_annotations(
+            images_directory_path=images_directory_path,
+            annotations_directory_path=annotations_directory_path,
+            force_masks=force_masks,
+        )
+        return DetectionDataset(
+            classes=classes, images=image_paths, annotations=annotations
+        )
+
+    def as_labelme(
+        self,
+        images_directory_path: str | None = None,
+        annotations_directory_path: str | None = None,
+    ) -> None:
+        """
+        Exports the dataset to LabelMe format. This method saves the images and
+        their corresponding annotations as per-image LabelMe ``.json`` files.
+        Masked detections are written as ``polygon`` shapes whose vertices
+        approximate the mask contour, so masks are not bit-exact on round-trip.
+        Because the bounding box is recomputed from the quantized polygon contour
+        on re-import, bounding boxes for masked detections may also shift by
+        approximately one pixel after a save-load cycle.
+
+        Args:
+            images_directory_path: The path to the directory
+                where the images should be saved.
+                If not provided, images will not be saved.
+            annotations_directory_path: The path to the directory where the
+                LabelMe ``.json`` files should be saved.
+                If not provided, annotations will not be saved.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            ds = sv.DetectionDataset(...)
+
+            ds.as_labelme(
+                images_directory_path="",
+                annotations_directory_path="",
+            )
+            ```
+        """
+        if images_directory_path is not None:
+            save_dataset_images(
+                dataset=self, images_directory_path=images_directory_path
+            )
+        if annotations_directory_path is not None:
+            save_labelme_annotations(
+                dataset=self,
+                annotations_directory_path=annotations_directory_path,
+            )
+
+    @classmethod
+    def from_createml(
+        cls,
+        images_directory_path: str,
+        annotations_path: str,
+        show_progress: bool = False,
+    ) -> DetectionDataset:
+        """
+        Creates a Dataset instance from CreateML formatted data.
+
+        CreateML stores object-detection annotations in a single JSON file as a
+        list of per-image entries, with each box expressed as a pixel-space
+        centre point plus width and height. Class names are inferred from the
+        labels present in the file.
+
+        Args:
+            images_directory_path: The path to the directory containing the
+                images.
+            annotations_path: The path to the CreateML json annotation file.
+            show_progress: If True, display a progress bar during loading.
+
+        Returns:
+            A DetectionDataset instance containing the loaded images and
+            annotations.
+
+        Examples:
+            ```python
+            import roboflow
+            from roboflow import Roboflow
+            import supervision as sv
+
+            roboflow.login()
+            rf = Roboflow()
+
+            project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
+            dataset = project.version(PROJECT_VERSION).download("createml")
+
+            ds = sv.DetectionDataset.from_createml(
+                images_directory_path=f"{dataset.location}/train",
+                annotations_path=f"{dataset.location}/train/_annotations.createml.json",
+            )
+
+            ds.classes
+            # ['dog', 'person']
+            ```
+        """
+        classes, image_paths, annotations = load_createml_annotations(
+            images_directory_path=images_directory_path,
+            annotations_path=annotations_path,
+            show_progress=show_progress,
+        )
+        return DetectionDataset(
+            classes=classes, images=image_paths, annotations=annotations
+        )
+
+    def as_createml(
+        self,
+        images_directory_path: str | None = None,
+        annotations_path: str | None = None,
+        show_progress: bool = False,
+    ) -> None:
+        """
+        Exports the dataset to CreateML format. This method saves the
+        images and their corresponding annotations in CreateML format.
+
+        Args:
+            images_directory_path: The path to the directory where the images
+                should be saved. If not provided, images will not be saved.
+            annotations_path: The path to the CreateML json annotation file.
+                If not provided, the annotations will not be saved.
+            show_progress: If True, display a progress bar while saving images.
+
+        Returns:
+            None. Side-effects only: writes images and/or annotation file.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            ds = sv.DetectionDataset(classes=["dog"], images=[], annotations={})
+            ds.as_createml(
+                images_directory_path="/tmp/images",
+                annotations_path="/tmp/annotations.json",
+            )
+            ```
+        """
+        if images_directory_path is not None:
+            save_dataset_images(
+                dataset=self,
+                images_directory_path=images_directory_path,
+                show_progress=show_progress,
+            )
+        if annotations_path is not None:
+            save_createml_annotations(
+                dataset=self,
+                annotations_path=annotations_path,
+            )
+
+    @classmethod
+    def from_coco(
+        cls,
+        images_directory_path: str,
+        annotations_path: str,
+        force_masks: bool = False,
+        show_progress: bool = False,
+        *,
+        use_iscrowd: bool = True,
+    ) -> DetectionDataset:
+        """
+        Creates a Dataset instance from COCO formatted data.
+
+        Args:
+            images_directory_path: The path to the
+                directory containing the images.
+            annotations_path: The path to the json annotation files.
+            force_masks: If True,
+                forces masks to be loaded for all annotations,
+                regardless of whether they are present.
+            show_progress: If True, display a progress bar during loading.
+            use_iscrowd: If True, includes COCO ``iscrowd`` and ``area``
+                annotation fields in ``Detections.data``.
+        Returns:
+            A DetectionDataset instance containing
+                the loaded images and annotations.
+
+        Examples:
+            ```python
+            import roboflow
+            from roboflow import Roboflow
+            import supervision as sv
+
+            roboflow.login()
+            rf = Roboflow()
+
+            project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
+            dataset = project.version(PROJECT_VERSION).download("coco")
+
+            ds = sv.DetectionDataset.from_coco(
+                images_directory_path=f"{dataset.location}/train",
+                annotations_path=f"{dataset.location}/train/_annotations.coco.json",
+                # pass show_progress=True to enable a tqdm progress bar
+            )
+
+            ds.classes
+            # ['dog', 'person']
+            ```
+        """
+        classes, images, annotations = load_coco_annotations(
+            images_directory_path=images_directory_path,
+            annotations_path=annotations_path,
+            force_masks=force_masks,
+            use_iscrowd=use_iscrowd,
+            show_progress=show_progress,
+        )
+        return DetectionDataset(classes=classes, images=images, annotations=annotations)
+
+    def as_coco(
+        self,
+        images_directory_path: str | None = None,
+        annotations_path: str | None = None,
+        min_image_area_percentage: float = 0.0,
+        max_image_area_percentage: float = 1.0,
+        approximation_percentage: float = 0.0,
+        starting_image_id: int = 1,
+        starting_annotation_id: int = 1,
+        show_progress: bool = False,
+    ) -> tuple[int, int]:
+        """
+        Exports the dataset to COCO format. This method saves the
+        images and their corresponding annotations in COCO format.
+
+        !!! tip
+
+            The format of the mask is determined automatically based on its structure:
+
+            - If a mask contains multiple disconnected components or holes, it will be
+            saved using the Run-Length Encoding (RLE) format for efficient storage and
+            processing.
+            - If a mask consists of a single, contiguous region without any holes, it
+            will be encoded as a polygon, preserving the outline of the object.
+
+            This automatic selection ensures that the masks are stored in the most
+            appropriate and space-efficient format, complying with COCO dataset
+            standards.
+
+        Args:
+            images_directory_path: The path to the directory
+                where the images should be saved.
+                If not provided, images will not be saved.
+            annotations_path: The path to COCO annotation file.
+            min_image_area_percentage: The minimum percentage of
+                detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            max_image_area_percentage: The maximum percentage of
+                detection area relative to
+                the image area for a detection to be included.
+                Argument is used only for segmentation datasets.
+            approximation_percentage: The percentage of polygon points
+                to be removed from the input polygon,
+                in the range [0, 1). This is useful for simplifying the annotations.
+                Argument is used only for segmentation datasets.
+            starting_image_id: First image id to assign in the exported file.
+                Defaults to ``1``. Override when exporting multiple splits into
+                a coordinated COCO collection so ids remain unique across the
+                set (see example below).
+            starting_annotation_id: First annotation id to assign in the
+                exported file. Defaults to ``1``. Override for the same
+                multi-split reason as ``starting_image_id``.
+            show_progress: If True, display a progress bar during saving.
+
+        Returns:
+            A ``(next_image_id, next_annotation_id)`` tuple containing the
+            first unused ids after this export. Feed them straight back into
+            ``starting_image_id`` and ``starting_annotation_id`` on the next
+            split so ids stay globally unique. When ``annotations_path`` is
+            ``None`` (images-only export) the starting ids are returned
+            unchanged so chaining still composes.
+
+        Example:
+            ```python
+            # Exporting train, valid, and test splits with non-colliding ids
+            # so the three annotation files can later be merged into one COCO.
+            next_image_id, next_annotation_id = train_ds.as_coco(
+                images_directory_path="out/train/images",
+                annotations_path="out/train/annotations.json",
+            )
+            next_image_id, next_annotation_id = valid_ds.as_coco(
+                images_directory_path="out/valid/images",
+                annotations_path="out/valid/annotations.json",
+                starting_image_id=next_image_id,
+                starting_annotation_id=next_annotation_id,
+            )
+            _, _ = test_ds.as_coco(
+                images_directory_path="out/test/images",
+                annotations_path="out/test/annotations.json",
+                starting_image_id=next_image_id,
+                starting_annotation_id=next_annotation_id,
+            )  # return value not needed — no further split
+            ```
+        """
+        if images_directory_path is not None:
+            save_dataset_images(
+                dataset=self,
+                images_directory_path=images_directory_path,
+                show_progress=show_progress,
+            )
+        if annotations_path is not None:
+            return save_coco_annotations(
+                dataset=self,
+                annotation_path=annotations_path,
+                min_image_area_percentage=min_image_area_percentage,
+                max_image_area_percentage=max_image_area_percentage,
+                approximation_percentage=approximation_percentage,
+                starting_image_id=starting_image_id,
+                starting_annotation_id=starting_annotation_id,
+                show_progress=show_progress,
+            )
+        return starting_image_id, starting_annotation_id
+
+
+@dataclass
+class ClassificationDataset(BaseDataset):
+    """
+    Contains information about a classification dataset, handles lazy image
+    loading, dataset splitting.
+
+    Attributes:
+        classes: List containing dataset class names.
+        images:
+            List of image paths or dictionary mapping image name to image data.
+        annotations: Dictionary mapping
+            image name to annotations.
+    """
+
+    def __init__(
+        self,
+        classes: list[str],
+        images: list[str] | dict[str, npt.NDArray[np.uint8]],
+        annotations: dict[str, Classifications],
+    ) -> None:
+        self.classes = classes
+
+        if set(images) != set(annotations):
+            raise ValueError(
+                "The keys of the images and annotations dictionaries must match."
+            )
+        self.annotations = annotations
+
+        # Eliminate duplicates while preserving order
+        self.image_paths = list(dict.fromkeys(images))
+
+        self._images_in_memory: dict[str, npt.NDArray[np.uint8]] = {}
+        if isinstance(images, dict):
+            self._images_in_memory = images
+            warn_deprecated(
+                "Passing a `Dict[str, np.ndarray]` into `ClassificationDataset` is "
+                "deprecated and will be removed in a future release. Use "
+                "a list of paths `List[str]` instead."
+            )
+
+    def _get_image(self, image_path: str) -> npt.NDArray[np.uint8]:
+        """Assumes that image is in dataset."""
+        if self._images_in_memory:
+            return self._images_in_memory[image_path]
+        image = cv2.imread(image_path)
+        if image is None:
+            raise ValueError(f"Could not read image from path: {image_path}")
+        return cast(npt.NDArray[np.uint8], image)
+
+    def __len__(self) -> int:
+        return len(self._images_in_memory) or len(self.image_paths)
+
+    def __getitem__(self, i: int) -> tuple[str, npt.NDArray[np.uint8], Classifications]:
+        """
+        Returns:
+            The image path, image data,
+                and its corresponding annotation at index i.
+        """
+        image_path = self.image_paths[i]
+        image = self._get_image(image_path)
+        annotation = self.annotations[image_path]
+        return image_path, image, annotation
+
+    def __iter__(
+        self,
+    ) -> Iterator[tuple[str, npt.NDArray[np.uint8], Classifications]]:
+        """
+        Iterate over the images and annotations in the dataset.
+
+        Yields:
+            Tuples containing the image path, image data, and its annotation.
+        """
+        for i in range(len(self)):
+            image_path, image, annotation = self[i]
+            yield image_path, image, annotation
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ClassificationDataset):
+            return False
+
+        if self.classes != other.classes:
+            return False
+
+        if self.image_paths != other.image_paths:
+            return False
+
+        if self._images_in_memory or other._images_in_memory:
+            if not np.array_equal(
+                list(self._images_in_memory.values()),
+                list(other._images_in_memory.values()),
+            ):
+                return False
+
+        if self.annotations != other.annotations:
+            return False
+
+        return True
+
+    def split(
+        self,
+        split_ratio: float = 0.8,
+        random_state: int | None = None,
+        shuffle: bool = True,
+    ) -> tuple[ClassificationDataset, ClassificationDataset]:
+        """
+        Splits the dataset into two parts (training and testing)
+            using the provided split_ratio.
+
+        Args:
+            split_ratio: The ratio of the training
+                set to the entire dataset.
+            random_state: The seed for the
+                random number generator. This is used for reproducibility.
+            shuffle: Whether to shuffle the data before splitting.
+
+        Returns:
+            A tuple containing
+            the training and testing datasets.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> cd = sv.ClassificationDataset(
+            ...     classes=['cat', 'dog'],
+            ...     images={
+            ...         'img1.jpg': np.zeros((100, 100, 3), dtype=np.uint8),
+            ...         'img2.jpg': np.zeros((100, 100, 3), dtype=np.uint8),
+            ...     },
+            ...     annotations={
+            ...         'img1.jpg': sv.Classifications(class_id=np.array([0])),
+            ...         'img2.jpg': sv.Classifications(class_id=np.array([1])),
+            ...     }
+            ... )
+            >>> train_cd, test_cd = cd.split(split_ratio=0.5, random_state=42)
+            >>> len(train_cd), len(test_cd)
+            (1, 1)
+
+            ```
+        """
+        train_paths, test_paths = train_test_split(
+            data=self.image_paths,
+            train_ratio=split_ratio,
+            random_state=random_state,
+            shuffle=shuffle,
+        )
+
+        train_input: list[str] | dict[str, npt.NDArray[np.uint8]]
+        test_input: list[str] | dict[str, npt.NDArray[np.uint8]]
+        if self._images_in_memory:
+            train_input = {path: self._images_in_memory[path] for path in train_paths}
+            test_input = {path: self._images_in_memory[path] for path in test_paths}
+        else:
+            train_input = train_paths
+            test_input = test_paths
+        train_annotations = {path: self.annotations[path] for path in train_paths}
+        test_annotations = {path: self.annotations[path] for path in test_paths}
+
+        train_dataset = ClassificationDataset(
+            classes=self.classes,
+            images=train_input,
+            annotations=train_annotations,
+        )
+        test_dataset = ClassificationDataset(
+            classes=self.classes,
+            images=test_input,
+            annotations=test_annotations,
+        )
+
+        return train_dataset, test_dataset
+
+    def as_folder_structure(
+        self, root_directory_path: str, show_progress: bool = False
+    ) -> None:
+        """
+        Saves the dataset as a multi-class folder structure.
+
+        Images assigned to the same class must have unique basenames
+        (case-insensitive). Conflicts are rejected before any files are written.
+        Image files are copied unchanged; images held in memory are encoded to the
+        format their name's extension selects.
+
+        Args:
+            root_directory_path: The path to the directory
+                where the dataset will be saved.
+            show_progress: If True, display a progress bar during saving.
+
+        Raises:
+            ValueError: If two images would be saved to the same output path.
+        """
+        output_paths = {}
+        for image_path in self.image_paths:
+            annotation = self.annotations[image_path]
+            class_id = (
+                annotation.class_id[0]
+                if annotation.confidence is None
+                else annotation.get_top_k(1)[0][0]
+            )
+            output_paths[image_path] = os.path.join(
+                self.classes[class_id], Path(image_path).name
+            )
+
+        check_no_basename_collisions(
+            image_paths=self.image_paths,
+            key=lambda path: output_paths[path],
+            output_kind="classification image",
+        )
+        os.makedirs(root_directory_path, exist_ok=True)
+
+        for class_name in self.classes:
+            os.makedirs(os.path.join(root_directory_path, class_name), exist_ok=True)
+
+        for image_path in tqdm(
+            self.image_paths,
+            desc="Saving classification images",
+            disable=not show_progress,
+        ):
+            image_save_path = os.path.join(
+                root_directory_path, output_paths[image_path]
+            )
+            if image_path in self._images_in_memory:
+                cv2.imwrite(image_save_path, self._images_in_memory[image_path])
+                continue
+            # Copy the file as `save_dataset_images` does: decoding and re-encoding it
+            # would drop alpha and bit depth and recompress lossy formats. Exporting
+            # into the folder the image was loaded from leaves it where it is.
+            with contextlib.suppress(shutil.SameFileError):
+                shutil.copyfile(image_path, image_save_path)
+
+    @classmethod
+    def from_folder_structure(
+        cls, root_directory_path: str, show_progress: bool = False
+    ) -> ClassificationDataset:
+        """
+        Load data from a multiclass folder structure into a ClassificationDataset.
+
+        Args:
+            root_directory_path: The path to the dataset directory. Hidden
+                entries, root-level files, nested directories, and files whose
+                suffix is not a supported image extension are ignored.
+            show_progress: If True, display a progress bar during loading.
+
+        Returns:
+            The dataset.
+
+        Examples:
+            ```python
+            import roboflow
+            from roboflow import Roboflow
+            import supervision as sv
+
+            roboflow.login()
+            rf = Roboflow()
+
+            project = rf.workspace(WORKSPACE_ID).project(PROJECT_ID)
+            dataset = project.version(PROJECT_VERSION).download("folder")
+
+            cd = sv.ClassificationDataset.from_folder_structure(
+                root_directory_path=f"{dataset.location}/train"
+                # pass show_progress=True to enable a tqdm progress bar
+            )
+            ```
+        """
+        root_directory = Path(root_directory_path)
+        classes = sorted(
+            {
+                entry.name
+                for entry in root_directory.iterdir()
+                if entry.is_dir() and not entry.name.startswith(".")
+            }
+        )
+
+        image_paths = []
+        annotations = {}
+
+        for class_id, class_name in enumerate(
+            tqdm(
+                classes,
+                total=len(classes),
+                desc="Loading classification dataset",
+                disable=not show_progress,
+            )
+        ):
+            class_directory = root_directory / class_name
+
+            for image_path in sorted(
+                class_directory.iterdir(), key=lambda path: path.name
+            ):
+                if image_path.name.startswith(".") or not image_path.is_file():
+                    continue
+                if image_path.suffix.lower() not in _IMAGE_FILE_EXTENSIONS:
+                    continue
+                image_paths.append(str(image_path))
+                annotations[str(image_path)] = Classifications(
+                    class_id=np.array([class_id]),
+                )
+
+        return cls(
+            classes=classes,
+            images=image_paths,
+            annotations=annotations,
+        )
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__init__.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..543a7e1eab50e3ebd40618986d7d75733b20702f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/coco.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/coco.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8a92a857e1bac5f01abcd417a2d55df3518b085
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/coco.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/createml.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/createml.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e88b0dc5072f90413076c1d443fcf552f25712bc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/createml.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/labelme.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/labelme.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b5c9ae35b7801445e9b9d02c8aedd69a3285dca
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/labelme.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/pascal_voc.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/pascal_voc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..000daaa5a21a75c6ef794ca2bcec2d7c8f469ce4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/pascal_voc.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/yolo.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/yolo.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3b987b530e5812373c553173df799d2525c92c1d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/__pycache__/yolo.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/coco.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/coco.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b2cde5837346a5b73fd50a873b92afd5618a748
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/coco.py
@@ -0,0 +1,738 @@
+from __future__ import annotations
+
+import warnings
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from tqdm.auto import tqdm
+
+from supervision.config import AREA_DATA_FIELD, COCO_RAW_SEGMENTATION
+from supervision.dataset.utils import (
+    _image_file_resolution_wh,
+    approximate_mask_with_polygons,
+    check_no_basename_collisions,
+    map_detections_class_id,
+)
+from supervision.detection.core import Detections
+from supervision.detection.utils.converters import (
+    mask_to_rle,
+    polygon_to_mask,
+    rle_to_mask,
+)
+from supervision.detection.utils.masks import contains_holes, contains_multiple_segments
+from supervision.utils.file import read_json_file, save_json_file
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+CocoDict = dict[str, Any]
+
+
+def coco_categories_to_classes(coco_categories: list[CocoDict]) -> list[str]:
+    return [
+        category["name"]
+        for category in sorted(coco_categories, key=lambda category: category["id"])
+    ]
+
+
+def build_coco_class_index_mapping(
+    coco_categories: list[CocoDict], target_classes: list[str]
+) -> dict[int, int]:
+    source_class_to_index = {
+        category["name"]: category["id"] for category in coco_categories
+    }
+    return {
+        source_class_to_index[target_class_name]: target_class_index
+        for target_class_index, target_class_name in enumerate(target_classes)
+    }
+
+
+def classes_to_coco_categories(classes: list[str]) -> list[CocoDict]:
+    """Convert a list of class names to COCO ``categories`` entries.
+
+    Category ids are emitted 1-indexed to comply with the COCO specification
+    and tools such as CVAT, which require ``category_id`` values to start at
+    ``1``. The id assigned to the class at position ``class_index`` is
+    ``class_index + 1``, keeping it consistent with the ``category_id`` written
+    by [`detections_to_coco_annotations`](#detections_to_coco_annotations).
+
+    Args:
+        classes: Class names ordered by their internal (0-indexed) class id.
+
+    Returns:
+        A list of COCO category dictionaries with 1-indexed ``id`` values.
+
+    Example:
+        ```pycon
+        >>> from supervision.dataset.formats.coco import classes_to_coco_categories
+        >>> classes_to_coco_categories(classes=["cat", "dog"])
+        [{'id': 1, 'name': 'cat', 'supercategory': 'common-objects'},
+         {'id': 2, 'name': 'dog', 'supercategory': 'common-objects'}]
+
+        ```
+    """
+    return [
+        {
+            "id": class_index + 1,
+            "name": class_name,
+            "supercategory": "common-objects",
+        }
+        for class_index, class_name in enumerate(classes)
+    ]
+
+
+def group_coco_annotations_by_image_id(
+    coco_annotations: list[CocoDict],
+) -> dict[int, list[CocoDict]]:
+    annotations: dict[int, list[CocoDict]] = {}
+    for annotation in coco_annotations:
+        image_id = annotation["image_id"]
+        if image_id not in annotations:
+            annotations[image_id] = []
+        annotations[image_id].append(annotation)
+    return annotations
+
+
+def coco_annotations_to_masks(
+    image_annotations: list[CocoDict], resolution_wh: tuple[int, int]
+) -> npt.NDArray[np.bool_]:
+    """Rasterise each annotation's RLE or polygon segmentation into one bool mask."""
+    height, width = resolution_wh[1], resolution_wh[0]
+    empty_mask: npt.NDArray[np.bool_] = np.zeros((height, width), dtype=bool)
+    masks = []
+
+    for image_annotation in image_annotations:
+        segmentation = image_annotation.get("segmentation")
+        if not segmentation:
+            # `force_masks=True` may request masks even for bbox-only annotations.
+            # Keep detection count aligned by emitting an empty mask for that object.
+            masks.append(empty_mask.copy())
+            continue
+
+        if isinstance(segmentation, dict):
+            if "counts" not in segmentation:
+                warnings.warn(
+                    "Skipping annotation "
+                    f"{image_annotation.get('id', '?')}: segmentation is a dict but "
+                    "missing 'counts' key (expected RLE format)",
+                    stacklevel=2,
+                )
+                masks.append(empty_mask.copy())
+                continue
+            masks.append(
+                rle_to_mask(rle=segmentation["counts"], resolution_wh=resolution_wh)
+            )
+            continue
+
+        if not isinstance(segmentation, list):
+            masks.append(empty_mask.copy())
+            continue
+        polygons = segmentation if isinstance(segmentation[0], list) else [segmentation]
+
+        object_mask = empty_mask.copy()
+        for polygon in polygons:
+            vertices = np.reshape(np.asarray(polygon, dtype=np.float64), (-1, 2))
+            if vertices.size == 0:
+                warnings.warn(
+                    "Skipping empty polygon while loading COCO segmentation for "
+                    f"annotation id={image_annotation.get('id')}.",
+                    stacklevel=2,
+                )
+                continue
+            if not np.isfinite(vertices).all():
+                raise ValueError(
+                    "COCO polygon segmentation for annotation "
+                    f"id={image_annotation.get('id')} has a vertex that is not a "
+                    "finite number."
+                )
+            # COCO vertices are sub-pixel floats. Round them to the nearest pixel, as
+            # the YOLO, LabelMe and Pascal VOC loaders do; casting straight to int
+            # truncates and shifts the mask up and to the left.
+            polygon_array: npt.NDArray[np.int32] = np.round(vertices).astype(np.int32)
+            # COCO polygon segmentation can contain multiple disjoint parts.
+            # Merge all parts into a single per-object mask.
+            object_mask |= polygon_to_mask(
+                polygon=polygon_array, resolution_wh=resolution_wh
+            ).astype(bool)
+
+        masks.append(object_mask)
+
+    return np.asarray(masks, dtype=bool)
+
+
+def coco_annotations_to_detections(
+    image_annotations: list[CocoDict],
+    resolution_wh: tuple[int, int],
+    with_masks: bool,
+    use_iscrowd: bool = True,
+) -> Detections:
+    """Convert COCO annotation dicts for a single image into a `Detections` object.
+
+    .. warning::
+        The returned ``Detections.class_id`` contains **raw COCO** ``category_id``
+        values, not the final 0-indexed internal class ids.  Callers **must** pass
+        the result through :func:`map_detections_class_id` with the appropriate
+        ``source_to_target_mapping`` (built by
+        :func:`build_coco_class_index_mapping`) before the ``class_id`` values are
+        meaningful.  Skipping the remap step yields 1-based ids in a field that the
+        rest of supervision treats as 0-based.
+
+    Args:
+        image_annotations: List of COCO annotation dicts for one image.
+        resolution_wh: ``(width, height)`` of the image, used for mask decoding.
+        with_masks: Whether to decode segmentation fields into binary masks.
+        use_iscrowd: When ``True``, store ``iscrowd`` and ``area`` in
+            ``Detections.data``.
+
+    Returns:
+        Detections with ``class_id`` set to raw COCO ``category_id`` values.
+        Call :func:`map_detections_class_id` on the result before use.
+        When ``with_masks=False``, ``detections.data[COCO_RAW_SEGMENTATION]`` is
+        populated as an object array (shape ``(N,)``) holding the raw polygon list or
+        RLE dict per annotation; consumed by :func:`detections_to_coco_annotations`
+        for a coordinate-preserving round-trip.
+    """
+    if not image_annotations:
+        return Detections.empty()
+
+    class_ids = [
+        image_annotation["category_id"] for image_annotation in image_annotations
+    ]
+    xyxy_list = [image_annotation["bbox"] for image_annotation in image_annotations]
+    xyxy: npt.NDArray[np.float32] = np.asarray(xyxy_list, dtype=np.float32)
+    xyxy[:, 2:4] += xyxy[:, 0:2]
+
+    data: dict[str, npt.NDArray[np.generic] | list[Any]] = {}
+    if use_iscrowd:
+        iscrowd = [
+            image_annotation.get("iscrowd", 0) for image_annotation in image_annotations
+        ]
+        area = []
+        for image_annotation in image_annotations:
+            if "area" in image_annotation:
+                area.append(image_annotation["area"])
+            elif with_masks and _with_seg_mask(image_annotation):
+                area.append(np.nan)
+            else:
+                area.append(image_annotation["bbox"][2] * image_annotation["bbox"][3])
+        data = dict(
+            iscrowd=np.asarray(iscrowd, dtype=int), area=np.asarray(area, dtype=float)
+        )
+
+    if with_masks:
+        mask = coco_annotations_to_masks(
+            image_annotations=image_annotations, resolution_wh=resolution_wh
+        )
+    else:
+        mask = None
+        # Preserve raw polygon/RLE data so as_coco() can round-trip without
+        # binary-mask encoding. Stored as an object array (one entry per detection).
+        raw_segs: npt.NDArray[np.object_] = np.empty(
+            len(image_annotations), dtype=object
+        )
+        for k, _ann in enumerate(image_annotations):
+            raw_segs[k] = _ann.get("segmentation", [])
+        data[COCO_RAW_SEGMENTATION] = raw_segs
+
+    return Detections(
+        class_id=np.asarray(class_ids, dtype=int), xyxy=xyxy, mask=mask, data=data
+    )
+
+
+def detections_to_coco_annotations(
+    detections: Detections,
+    image_id: int,
+    annotation_id: int,
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.75,
+) -> tuple[list[CocoDict], int]:
+    """Convert `Detections` to COCO ``annotations`` entries.
+
+    The internal 0-indexed ``Detections.class_id`` is serialized as a 1-indexed
+    COCO ``category_id`` (``category_id = class_id + 1``). This complies with the
+    COCO specification and tools such as CVAT, and stays consistent with the ids
+    emitted by [`classes_to_coco_categories`](#classes_to_coco_categories), so a
+    detection with internal ``class_id=k`` maps to ``category_id=k + 1``.
+
+    Args:
+        detections: The detections to convert. ``class_id`` must not be ``None``.
+        image_id: COCO ``image_id`` shared by every produced annotation.
+        annotation_id: First annotation id to assign; incremented per detection.
+        min_image_area_percentage: Lower bound on detection area / image area,
+            used only when approximating masks with polygons.
+        max_image_area_percentage: Upper bound on detection area / image area,
+            used only when approximating masks with polygons.
+        approximation_percentage: Polygon-simplification ratio in ``[0, 1)``.
+
+    Returns:
+        A ``(coco_annotations, next_annotation_id)`` tuple, where
+        ``next_annotation_id`` is one greater than the last id assigned.
+
+    Raises:
+        ValueError: If any detection has ``class_id`` equal to ``None``.
+
+    Note:
+        For ``iscrowd=0`` annotations, ``segmentation`` is a
+        ``list[list[float]]`` where each inner list encodes one polygon
+        part as flat ``[x1, y1, x2, y2, ...]`` coordinates. A single
+        object with *N* disjoint parts produces *N* inner lists.
+
+        When ``iscrowd`` is not in ``detections.data``, masks with holes
+        or multiple disjoint segments are auto-encoded as RLE
+        (``iscrowd=1``); simple single-region masks use polygon format
+        (``iscrowd=0``). Supply ``data={"iscrowd": np.array([0])}`` to
+        force polygon output regardless of mask topology.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision import Detections
+        >>> from supervision.dataset.formats.coco import (
+        ...     detections_to_coco_annotations,
+        ... )
+        >>> detections = Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32),
+        ...     class_id=np.array([0], dtype=int),
+        ... )
+        >>> annotations, next_id = detections_to_coco_annotations(
+        ...     detections=detections, image_id=1, annotation_id=1
+        ... )
+        >>> annotations[0]["category_id"]
+        1
+        >>> next_id
+        2
+
+        ```
+    """
+    coco_annotations: list[CocoDict] = []
+    for xyxy, mask, _, class_id, _, data in detections:
+        if class_id is None:
+            raise ValueError("Detections must include class_id for COCO export.")
+        box_width, box_height = xyxy[2] - xyxy[0], xyxy[3] - xyxy[1]
+        segmentation: list[list[float]] | dict[str, list[int]] = []
+        if mask is not None:
+            mask_bool = mask
+            if "iscrowd" in data:
+                iscrowd = int(np.asarray(data["iscrowd"]).item())
+            else:
+                iscrowd = int(
+                    contains_holes(mask=mask_bool)
+                    or contains_multiple_segments(mask=mask_bool)
+                )
+
+            if iscrowd:
+                segmentation = {
+                    "counts": cast(
+                        list[int], mask_to_rle(mask=mask_bool, compressed=False)
+                    ),
+                    "size": list(mask.shape[:2]),
+                }
+            else:
+                polygons = approximate_mask_with_polygons(
+                    mask=mask_bool,
+                    min_image_area_percentage=min_image_area_percentage,
+                    max_image_area_percentage=max_image_area_percentage,
+                    approximation_percentage=approximation_percentage,
+                )
+                # Small/noisy masks can be filtered out by approximation settings.
+                # Guard against empty output and keep a valid COCO annotation record.
+                if polygons:
+                    # Export ALL polygons so disjoint mask components are preserved.
+                    segmentation = [list(p.flatten()) for p in polygons]
+                else:
+                    warnings.warn(
+                        "Skipping COCO polygon segmentation for annotation "
+                        f"id={annotation_id} because mask approximation "
+                        "returned no polygons.",
+                        stacklevel=2,
+                    )
+        else:
+            iscrowd = int(np.asarray(data.get("iscrowd", 0)).item())
+            # When masks were not decoded during loading, fall back to the raw
+            # polygon/RLE stored in data["segmentation"] for a lossless round-trip.
+            raw_seg = data.get(COCO_RAW_SEGMENTATION)
+            if raw_seg is not None and bool(raw_seg):
+                if isinstance(raw_seg, dict):
+                    # RLE format — pass through unchanged
+                    segmentation = raw_seg
+                elif (
+                    isinstance(raw_seg, list)
+                    and raw_seg
+                    and not isinstance(raw_seg[0], (list, tuple))
+                ):
+                    # Flat list shorthand [x1,y1,...] — wrap to list-of-lists
+                    segmentation = [list(raw_seg)]
+                else:
+                    segmentation = list(raw_seg)
+
+        stored_area = None
+        if AREA_DATA_FIELD in data:
+            stored_area = float(np.asarray(data[AREA_DATA_FIELD]).item())
+
+        if stored_area is not None and np.isfinite(stored_area):
+            area = stored_area
+        elif mask is not None:
+            area = float(np.count_nonzero(mask))
+        else:
+            area = float(box_width * box_height)
+        coco_annotation = {
+            "id": annotation_id,
+            "image_id": image_id,
+            "category_id": int(class_id) + 1,
+            "bbox": [xyxy[0], xyxy[1], box_width, box_height],
+            "area": area,
+            "segmentation": segmentation,
+            "iscrowd": iscrowd,
+        }
+        coco_annotations.append(coco_annotation)
+        annotation_id += 1
+    return coco_annotations, annotation_id
+
+
+def get_coco_class_index_mapping(annotations_path: str) -> dict[int, int]:
+    """
+    Generates a mapping from sequential class indices to original COCO class ids.
+
+    This function is essential when working with models that expect class ids to be
+    zero-indexed and sequential (0 to 79), as opposed to the original COCO
+    dataset where category ids are non-contiguous ranging from 1 to 90 but skipping some
+    ids.
+
+    Use Cases:
+        - Evaluating models trained with COCO-style annotations where class ids
+          are sequential ranging from 0 to 79.
+        - Ensuring consistent class indexing across training, inference and evaluation,
+          when using different tools or datasets with COCO format.
+        - Reproducing results from models that assume sequential class ids (0 to 79).
+
+    How it Works:
+        - Reads the COCO annotation file in its original format (`annotations_path`).
+        - Extracts and sorts all class names by their original COCO id (1 to 90).
+        - Builds a mapping from COCO class ids (not sequential with skipped ids) to
+          new class ids (sequential ranging from 0 to 79).
+        - Returns a dictionary mapping: `{new_class_id: original_COCO_class_id}`.
+
+    Args:
+        annotations_path: Path to COCO JSON annotations file
+        (e.g., `instances_val2017.json`).
+
+    Returns:
+        A mapping from new class id (sequential ranging from 0 to 79)
+        to original COCO class id (1 to 90 with skipped ids).
+
+    Examples:
+        ```pycon
+        >>> import json
+        >>> import os
+        >>> import tempfile
+        >>> from supervision.dataset.formats.coco import get_coco_class_index_mapping
+        >>> coco_data = {
+        ...     "categories": [
+        ...         {"id": 1, "name": "person"},
+        ...         {"id": 3, "name": "car"},
+        ...     ],
+        ...     "images": [],
+        ...     "annotations": [],
+        ... }
+        >>> annotations_path = None
+        >>> try:
+        ...     with tempfile.NamedTemporaryFile(
+        ...         mode="w", suffix=".json", delete=False
+        ...     ) as f:
+        ...         annotations_path = f.name
+        ...         json.dump(coco_data, f)
+        ...     mapping = get_coco_class_index_mapping(annotations_path)
+        ...     print(mapping)
+        ... finally:
+        ...     if annotations_path is not None:
+        ...         os.remove(annotations_path)
+        {0: 1, 1: 3}
+        >>> os.path.exists(annotations_path)
+        False
+
+        ```
+    """
+    coco_data = read_json_file(annotations_path)
+    classes = coco_categories_to_classes(coco_categories=coco_data["categories"])
+    class_mapping = build_coco_class_index_mapping(
+        coco_categories=coco_data["categories"], target_classes=classes
+    )
+    return {v: k for k, v in class_mapping.items()}
+
+
+def load_coco_annotations(
+    images_directory_path: str,
+    annotations_path: str,
+    force_masks: bool = False,
+    use_iscrowd: bool = True,
+    show_progress: bool = False,
+) -> tuple[list[str], list[str], dict[str, Detections]]:
+    """
+    Load COCO annotations and convert them to `Detections`.
+
+    If `force_masks` is `False`, masks are still loaded for images whose annotations
+    include a `segmentation` field. This keeps mask handling consistent with other
+    dataset loaders that infer masks from annotation content.
+
+    Args:
+        images_directory_path: Path to the image directory.
+        annotations_path: Path to COCO JSON annotations.
+        force_masks: If `True`, always attempt to load masks.
+        use_iscrowd: If `True`, include `iscrowd` and `area` in detection data.
+        show_progress: If `True`, display a progress bar during loading.
+
+    Returns:
+        A tuple of `(classes, image_paths, annotations)` where image paths are
+        canonicalized resolved paths inside ``images_directory_path``.
+
+    Raises:
+        ValueError: If any annotation's ``file_name`` resolves to the images
+            directory itself, to a path outside the images directory (e.g. via
+            ``../`` traversal or an absolute path), or to a subdirectory instead
+            of a regular image file.
+        ValueError: If two image entries resolve to the same canonical path.
+
+    Note:
+        Each annotation's ``file_name`` is validated against
+        ``images_directory_path`` before loading. Annotations that reference
+        paths outside the directory are rejected to prevent path-traversal
+        attacks when loading user-supplied annotation files. Symlinked images
+        pointing outside the resolved images directory are also rejected.
+    """
+    coco_data = read_json_file(file_path=annotations_path)
+    classes = coco_categories_to_classes(coco_categories=coco_data["categories"])
+
+    class_index_mapping = build_coco_class_index_mapping(
+        coco_categories=coco_data["categories"], target_classes=classes
+    )
+
+    coco_images = coco_data["images"]
+    coco_annotations_groups = group_coco_annotations_by_image_id(
+        coco_annotations=coco_data["annotations"]
+    )
+
+    images = []
+    annotations = {}
+    images_directory_resolved = Path(images_directory_path).resolve()
+
+    for coco_image in tqdm(
+        coco_images,
+        total=len(coco_images),
+        desc="Loading COCO annotations",
+        disable=not show_progress,
+    ):
+        image_name, image_width, image_height = (
+            coco_image["file_name"],
+            coco_image["width"],
+            coco_image["height"],
+        )
+        image_annotations = coco_annotations_groups.get(coco_image["id"], [])
+        image_path = str(Path(images_directory_path) / Path(image_name))
+        try:
+            resolved_image_path = Path(image_path).resolve()
+        except (OSError, ValueError) as exc:
+            raise ValueError(
+                f"COCO annotation refers to image {image_name!r}, which "
+                f"produces an invalid path: {exc}"
+            ) from exc
+        if resolved_image_path == images_directory_resolved:
+            raise ValueError(
+                f"COCO annotation refers to image {image_name!r}, which "
+                f"resolves to the images directory itself "
+                f"({images_directory_resolved}). Expected a path to an "
+                "image file."
+            )
+        if images_directory_resolved not in resolved_image_path.parents:
+            raise ValueError(
+                f"COCO annotation refers to image {image_name!r}, which "
+                f"resolves to {resolved_image_path} — outside the images "
+                f"directory {images_directory_resolved}."
+            )
+        if resolved_image_path.is_dir():
+            raise ValueError(
+                f"COCO annotation refers to image {image_name!r}, which "
+                f"resolves to directory {resolved_image_path}. Expected a "
+                "path to an image file."
+            )
+        image_path = str(resolved_image_path)
+        if image_path in annotations:
+            raise ValueError(
+                f"COCO annotation file contains duplicate entries for image "
+                f"{image_name!r}. Each image must appear at most once."
+            )
+
+        with_masks = force_masks or any(
+            _with_seg_mask(annotation) for annotation in image_annotations
+        )
+        annotation = coco_annotations_to_detections(
+            image_annotations=image_annotations,
+            resolution_wh=(image_width, image_height),
+            with_masks=with_masks,
+            use_iscrowd=use_iscrowd,
+        )
+
+        annotation = map_detections_class_id(
+            source_to_target_mapping=class_index_mapping,
+            detections=annotation,
+        )
+
+        images.append(image_path)
+        annotations[image_path] = annotation
+
+    return classes, images, annotations
+
+
+def _with_seg_mask(annotation: dict[str, Any]) -> bool:
+    return bool(annotation.get("segmentation"))
+
+
+def _image_resolution_hw(dataset: DetectionDataset, image_path: str) -> tuple[int, int]:
+    """Return ``(height, width)`` for ``image_path`` without decoding pixels.
+
+    Uses the in-memory array when the dataset holds one; otherwise reads the size from
+    the file header, following its EXIF orientation the way loading the image does — the
+    same optimization the YOLO loader uses (#1636).
+    """
+    if dataset._images_in_memory:
+        image_height, image_width = dataset._images_in_memory[image_path].shape[:2]
+        return image_height, image_width
+    image_width, image_height = _image_file_resolution_wh(image_path)
+    return image_height, image_width
+
+
+def save_coco_annotations(
+    dataset: DetectionDataset,
+    annotation_path: str,
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.0,
+    starting_image_id: int = 1,
+    starting_annotation_id: int = 1,
+    show_progress: bool = False,
+) -> tuple[int, int]:
+    """Save a DetectionDataset to a COCO-format ``annotations.json`` file.
+
+    Args:
+        dataset: The DetectionDataset to write.
+        annotation_path: Output path for the COCO ``annotations.json``.
+        min_image_area_percentage: Lower bound on detection area / image area;
+            used only for segmentation datasets.
+        max_image_area_percentage: Upper bound on detection area / image area;
+            used only for segmentation datasets.
+        approximation_percentage: Polygon-simplification ratio in ``[0, 1)``;
+            used only for segmentation datasets.
+        starting_image_id: First image id to assign in the exported file.
+            Defaults to ``1``. Override when exporting multiple splits into
+            a coordinated COCO collection so ids remain unique across the set.
+        starting_annotation_id: First annotation id to assign in the exported
+            file. Defaults to ``1``. Override for the same multi-split reason
+            as ``starting_image_id``.
+        show_progress: If ``True``, display a progress bar during saving.
+
+    Returns:
+        A ``(next_image_id, next_annotation_id)`` tuple. The returned values
+        are one greater than the highest ids written, so they can be fed
+        directly back into ``starting_image_id`` and ``starting_annotation_id``
+        when exporting another split into a coordinated COCO collection
+        (see ``DetectionDataset.as_coco`` for the chaining pattern). When the
+        dataset is empty the starting ids are returned unchanged.
+
+        .. note::
+            This function ensures globally unique integer ``id`` values across
+            splits. It rejects duplicate image basenames before writing because
+            ``file_name`` is set to the bare image basename, so two input paths
+            that differ only by directory would otherwise collapse to the same
+            COCO image record.
+
+    Raises:
+        ValueError: If two image paths share the same basename and would map to
+            the same COCO ``file_name``.
+
+    Example:
+        ```python
+        import supervision as sv
+        from supervision.dataset.formats.coco import save_coco_annotations
+
+        ds = sv.DetectionDataset.from_yolo(
+            images_directory_path="train/images",
+            annotations_directory_path="train/labels",
+            data_yaml_path="data.yaml",
+        )
+        next_img_id, next_ann_id = save_coco_annotations(
+            dataset=ds, annotation_path="out/train/annotations.json"
+        )
+        # next_img_id and next_ann_id are the first unused ids — pass them
+        # to the next split to keep ids globally unique across files.
+        ```
+    """
+    if starting_image_id < 1 or starting_annotation_id < 1:
+        raise ValueError(
+            "starting_image_id and starting_annotation_id must be >= 1 "
+            "(COCO spec requires 1-indexed ids); "
+            f"got {starting_image_id=}, {starting_annotation_id=}"
+        )
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: Path(image_path).name,
+        output_kind="COCO image",
+    )
+    Path(annotation_path).parent.mkdir(parents=True, exist_ok=True)
+    licenses = [
+        {
+            "id": 1,
+            "url": "https://creativecommons.org/licenses/by/4.0/",
+            "name": "CC BY 4.0",
+        }
+    ]
+
+    coco_annotations = []
+    coco_images = []
+    coco_categories = classes_to_coco_categories(classes=dataset.classes)
+
+    image_id, annotation_id = starting_image_id, starting_annotation_id
+    for image_path in tqdm(
+        dataset.image_paths,
+        desc="Saving COCO annotations",
+        disable=not show_progress,
+    ):
+        annotation = dataset.annotations[image_path]
+        # Only the image size is needed here, so read it from the file header
+        # (or the in-memory array) instead of iterating the dataset, which
+        # would fully decode every image just to inspect its shape.
+        image_height, image_width = _image_resolution_hw(dataset, image_path)
+        image_name = f"{Path(image_path).stem}{Path(image_path).suffix}"
+        coco_image = {
+            "id": image_id,
+            "license": 1,
+            "file_name": image_name,
+            "height": image_height,
+            "width": image_width,
+            "date_captured": datetime.now().strftime("%m/%d/%Y,%H:%M:%S"),
+        }
+
+        coco_images.append(coco_image)
+        coco_annotation, annotation_id = detections_to_coco_annotations(
+            detections=annotation,
+            image_id=image_id,
+            annotation_id=annotation_id,
+            min_image_area_percentage=min_image_area_percentage,
+            max_image_area_percentage=max_image_area_percentage,
+            approximation_percentage=approximation_percentage,
+        )
+
+        coco_annotations.extend(coco_annotation)
+        image_id += 1
+
+    annotation_dict = {
+        "info": {},
+        "licenses": licenses,
+        "categories": coco_categories,
+        "images": coco_images,
+        "annotations": coco_annotations,
+    }
+    save_json_file(annotation_dict, file_path=annotation_path)
+    return image_id, annotation_id
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/createml.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/createml.py
new file mode 100644
index 0000000000000000000000000000000000000000..4bcfac2f98b0b4e9f43e585921beb4d4ffeaec87
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/createml.py
@@ -0,0 +1,334 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+from tqdm.auto import tqdm
+
+from supervision.dataset.utils import check_no_basename_collisions
+from supervision.detection.core import Detections
+from supervision.utils.file import read_json_file, save_json_file
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+CreateMLDict = dict[str, Any]
+
+
+def _resolve_image_path(images_directory_path: str, image_name: str) -> str:
+    """Resolve and validate an image path against the images directory.
+
+    Rejects annotations whose ``image`` field escapes ``images_directory_path``
+    (via ``..`` traversal, an absolute path, or a symlink pointing outside),
+    mirroring the protection used by the COCO loader. Returns the canonical
+    resolved path so aliases collapse to a single dataset entry.
+    """
+    images_directory_resolved = Path(images_directory_path).resolve()
+    image_path = Path(images_directory_path) / Path(image_name)
+    try:
+        resolved_image_path = image_path.resolve()
+    except (OSError, ValueError) as exc:
+        raise ValueError(
+            f"CreateML annotation refers to image {image_name!r}, which "
+            f"produces an invalid path: {exc}"
+        ) from exc
+    if resolved_image_path == images_directory_resolved:
+        raise ValueError(
+            f"CreateML annotation refers to image {image_name!r}, which "
+            f"resolves to the images directory itself "
+            f"({images_directory_resolved}). Expected a path to an image file."
+        )
+    if images_directory_resolved not in resolved_image_path.parents:
+        raise ValueError(
+            f"CreateML annotation refers to image {image_name!r}, which "
+            f"resolves to {resolved_image_path} — outside the images "
+            f"directory {images_directory_resolved}."
+        )
+    if resolved_image_path.is_dir():
+        raise ValueError(
+            f"CreateML annotation refers to image {image_name!r}, which "
+            f"resolves to directory {resolved_image_path}. Expected a path "
+            "to an image file."
+        )
+    return str(resolved_image_path)
+
+
+def createml_annotations_to_detections(
+    image_annotations: list[CreateMLDict], class_to_index: dict[str, int]
+) -> Detections:
+    """Convert a single image's CreateML annotations into ``Detections``.
+
+    CreateML stores each box as a pixel-space centre point plus width/height
+    (``{"x", "y", "width", "height"}``); they are converted to ``xyxy`` corners.
+
+    Args:
+        image_annotations: List of annotation dicts for one image, each containing
+            a ``"label"`` key and a ``"coordinates"`` dict with ``"x"``, ``"y"``,
+            ``"width"``, and ``"height"`` keys.
+        class_to_index: Mapping from class name to zero-based integer id.
+
+    Returns:
+        A ``Detections`` instance with ``xyxy`` boxes and ``class_id`` set.
+        Returns ``Detections.empty()`` when ``image_annotations`` is empty.
+
+    Raises:
+        ValueError: If an annotation is missing required keys (``"coordinates"``,
+            ``"label"``, or any coordinate sub-key), or if a coordinate value
+            cannot be converted to float.
+
+    Example:
+        ```pycon
+        >>> from supervision.dataset.formats.createml import (
+        ...     createml_annotations_to_detections,
+        ... )
+        >>> annotations = [
+        ...     {
+        ...         "label": "dog",
+        ...         "coordinates": {"x": 50, "y": 50, "width": 20, "height": 20},
+        ...     }
+        ... ]
+        >>> detections = createml_annotations_to_detections(annotations, {"dog": 0})
+        >>> detections.xyxy
+        array([[40., 40., 60., 60.]], dtype=float32)
+        >>> detections.class_id
+        array([0])
+
+        ```
+    """
+    if not image_annotations:
+        return Detections.empty()
+
+    xyxy = []
+    class_ids = []
+    for annotation in image_annotations:
+        try:
+            coordinates = annotation["coordinates"]
+            x_center = float(coordinates["x"])
+            y_center = float(coordinates["y"])
+            width = float(coordinates["width"])
+            height = float(coordinates["height"])
+            label = annotation["label"]
+        except (KeyError, TypeError) as exc:
+            raise ValueError(
+                f"Malformed CreateML annotation entry {annotation!r}: {exc}"
+            ) from exc
+        xyxy.append(
+            [
+                x_center - width / 2,
+                y_center - height / 2,
+                x_center + width / 2,
+                y_center + height / 2,
+            ]
+        )
+        class_ids.append(class_to_index[label])
+
+    return Detections(
+        xyxy=np.array(xyxy, dtype=np.float32),
+        class_id=np.array(class_ids, dtype=int),
+    )
+
+
+def load_createml_annotations(
+    images_directory_path: str,
+    annotations_path: str,
+    show_progress: bool = False,
+) -> tuple[list[str], list[str], dict[str, Detections]]:
+    """Load CreateML object-detection annotations and convert them to ``Detections``.
+
+    CreateML uses a single JSON file containing a list of per-image entries, each
+    holding axis-aligned bounding boxes. Class names are inferred from the labels
+    present in the file and assigned stable, sorted, zero-based ids. Because the
+    format has no explicit category list, a class with no boxes anywhere in the
+    file will not appear in the returned ``classes``.
+
+    Args:
+        images_directory_path: Path to the directory containing the images.
+        annotations_path: Path to the CreateML JSON annotation file.
+        show_progress: If ``True``, display a tqdm progress bar while loading
+            annotations.
+
+    Returns:
+        A tuple of three elements:
+
+        - ``classes`` (``list[str]``): globally sorted class names inferred from
+          all labels present in the file.
+        - ``image_paths`` (``list[str]``): canonical resolved path for every
+          entry in the JSON, in file order.
+        - ``annotations`` (``dict[str, Detections]``): mapping from canonical
+          resolved image path to its ``Detections``.
+
+    Raises:
+        ValueError: If the JSON root is not a list.
+        ValueError: If an entry is missing the required ``"image"`` key.
+        ValueError: If an annotation is missing required coordinate or label keys.
+        ValueError: If two entries resolve to the same image path.
+        ValueError: If an annotation's ``image`` field resolves to the images
+            directory itself or to a path outside it (e.g. via ``..`` traversal
+            or an absolute path).
+    """
+    createml_data = cast(
+        "list[CreateMLDict]", read_json_file(file_path=annotations_path)
+    )
+    if not isinstance(createml_data, list):
+        raise ValueError(
+            f"CreateML annotation file must contain a JSON list at the root, "
+            f"got {type(createml_data).__name__}."
+        )
+
+    try:
+        classes = sorted(
+            {
+                annotation["label"]
+                for entry in createml_data
+                for annotation in (entry.get("annotations") or [])
+            }
+        )
+    except (KeyError, TypeError) as exc:
+        raise ValueError(
+            f"Malformed CreateML annotation entry "
+            f"(missing or non-string 'label'): {exc}"
+        ) from exc
+    class_to_index = {class_name: index for index, class_name in enumerate(classes)}
+
+    image_paths: list[str] = []
+    annotations: dict[str, Detections] = {}
+    for entry in tqdm(
+        createml_data,
+        desc="Loading CreateML annotations",
+        disable=not show_progress,
+    ):
+        image_name = entry.get("image")
+        if image_name is None:
+            raise ValueError(
+                f"CreateML annotation entry is missing the required 'image' key: "
+                f"{entry!r}"
+            )
+        image_path = _resolve_image_path(
+            images_directory_path=images_directory_path, image_name=image_name
+        )
+        if image_path in annotations:
+            raise ValueError(
+                f"CreateML annotation file contains duplicate entries for image "
+                f"{image_name!r}. Each image must appear at most once."
+            )
+        annotations[image_path] = createml_annotations_to_detections(
+            image_annotations=entry.get("annotations") or [],
+            class_to_index=class_to_index,
+        )
+        image_paths.append(image_path)
+
+    return classes, image_paths, annotations
+
+
+def detections_to_createml_annotations(
+    detections: Detections, classes: list[str]
+) -> list[CreateMLDict]:
+    """Convert ``Detections`` into a list of CreateML annotation dicts.
+
+    Each bounding box is stored as a pixel-space centre point plus width and
+    height, which is the CreateML object-detection convention.
+
+    Args:
+        detections: The detections to convert. ``class_id`` must not be ``None``.
+        classes: Ordered list of class names; ``detections.class_id`` values are
+            used as indices into this list.
+
+    Returns:
+        A list of dicts, each with a ``"label"`` key (class name) and a
+        ``"coordinates"`` dict containing ``"x"``, ``"y"``, ``"width"``, and
+        ``"height"`` in pixel space.
+
+    Raises:
+        ValueError: If ``detections.class_id`` is ``None``.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.dataset.formats.createml import (
+        ...     detections_to_createml_annotations,
+        ... )
+        >>> detections = sv.Detections(
+        ...     xyxy=np.array([[40, 40, 60, 60]], dtype=np.float32),
+        ...     class_id=np.array([0], dtype=int),
+        ... )
+        >>> detections_to_createml_annotations(detections, classes=["dog"])
+        [{'label': 'dog', 'coordinates':
+          {'x': 50.0, 'y': 50.0, 'width': 20.0, 'height': 20.0}}]
+
+        ```
+    """
+    class_ids = detections.class_id
+    if class_ids is None:
+        raise ValueError(
+            "class_id is required for CreateML export, but the provided "
+            "Detections has class_id=None."
+        )
+    annotations: list[CreateMLDict] = []
+    for xyxy, class_id in zip(detections.xyxy, class_ids):
+        x_min, y_min, x_max, y_max = (float(value) for value in xyxy)
+        annotations.append(
+            {
+                "label": classes[int(class_id)],
+                "coordinates": {
+                    "x": (x_min + x_max) / 2,
+                    "y": (y_min + y_max) / 2,
+                    "width": x_max - x_min,
+                    "height": y_max - y_min,
+                },
+            }
+        )
+    return annotations
+
+
+def save_createml_annotations(
+    dataset: DetectionDataset,
+    annotations_path: str,
+) -> None:
+    """Export a ``DetectionDataset`` to a CreateML object-detection JSON file.
+
+    Only the filename component of each image path is stored in the JSON (e.g.
+    ``"img.jpg"`` rather than ``"/data/train/img.jpg"``). This matches CreateML
+    convention and means the loader reconstructs paths relative to
+    ``images_directory_path``. As a consequence, two images with the same
+    basename from different directories would collapse to the same ``"image"``
+    key, so the exporter rejects that case before writing.
+
+    Args:
+        dataset: The ``DetectionDataset`` to write.
+        annotations_path: Output path for the CreateML JSON file. Parent
+            directories are created if they do not already exist.
+
+    Raises:
+        ValueError: If two image paths share the same basename and would map to
+            the same CreateML ``image`` entry.
+
+    Example:
+        ```python
+        import supervision as sv
+        from supervision.dataset.formats.createml import save_createml_annotations
+
+        dataset = sv.DetectionDataset(classes=["dog"], images=[], annotations={})
+        save_createml_annotations(dataset, "/tmp/annotations.json")
+        ```
+    """
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: Path(image_path).name,
+        output_kind="CreateML image",
+    )
+    Path(annotations_path).parent.mkdir(parents=True, exist_ok=True)
+    createml_data: list[CreateMLDict] = [
+        {
+            "image": Path(image_path).name,
+            "annotations": detections_to_createml_annotations(
+                detections=dataset.annotations[image_path], classes=dataset.classes
+            ),
+        }
+        for image_path in dataset.image_paths
+    ]
+    save_json_file(
+        data=createml_data,  # type: ignore[arg-type]  # save_json_file accepts list at runtime
+        file_path=annotations_path,
+    )
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/labelme.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/labelme.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5c033d186c16d986697cd6ff550d0840a011270
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/labelme.py
@@ -0,0 +1,408 @@
+from __future__ import annotations
+
+import warnings
+from pathlib import Path, PureWindowsPath
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.dataset.utils import check_no_basename_collisions
+from supervision.detection.core import Detections
+from supervision.detection.utils.converters import (
+    mask_to_polygons,
+    polygon_to_mask,
+    polygon_to_xyxy,
+)
+from supervision.utils.file import (
+    list_files_with_extensions,
+    read_json_file,
+    save_json_file,
+)
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+LabelMeDict = dict[str, Any]
+# Written to every exported JSON; never read back on import.
+_LABELME_EXPORT_VERSION = "5.5.0"
+SUPPORTED_SHAPE_TYPES = ("rectangle", "polygon")
+
+__all__ = [
+    "detections_to_labelme_shapes",
+    "labelme_shapes_to_detections",
+    "load_labelme_annotations",
+    "save_labelme_annotations",
+]
+
+
+def _rectangle_to_xyxy(points: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+    x_coordinates = points[:, 0]
+    y_coordinates = points[:, 1]
+    return np.array(
+        [
+            float(x_coordinates.min()),
+            float(y_coordinates.min()),
+            float(x_coordinates.max()),
+            float(y_coordinates.max()),
+        ],
+        dtype=np.float32,
+    )
+
+
+def _xyxy_to_polygon(xyxy: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+    x_min, y_min, x_max, y_max = (float(value) for value in xyxy)
+    return np.array(
+        [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]],
+        dtype=np.float32,
+    )
+
+
+def labelme_shapes_to_detections(
+    shapes: list[LabelMeDict],
+    class_to_index: dict[str, int],
+    resolution_wh: tuple[int, int],
+    with_masks: bool,
+) -> Detections:
+    """Convert a single image's LabelMe shapes into ``Detections``.
+
+    Only ``rectangle`` and ``polygon`` shapes are imported; other shape types
+    (``circle``, ``line``, ``point``, ``linestrip``) are skipped with a warning.
+    When ``with_masks`` is ``True``, both ``rectangle`` and ``polygon`` shapes
+    produce masks: rectangles via a four-corner polygon fill.
+
+    Args:
+        shapes: List of LabelMe shape dicts for one image.
+        class_to_index: Mapping from class name to integer class ID.
+        resolution_wh: Image ``(width, height)`` used to rasterise masks.
+        with_masks: If ``True``, produce a binary mask for every detection.
+
+    Returns:
+        A :class:`Detections` instance with ``xyxy``, ``class_id``, and
+        optionally ``mask`` populated.
+
+    Raises:
+        ValueError: If a shape is missing its ``label`` or ``points`` field,
+            if a ``polygon`` has fewer than 3 points, or a ``rectangle`` has
+            fewer than 2 points.
+
+    Warns:
+        UserWarning: When unsupported shape types are encountered and skipped.
+    """
+    xyxy_list: list[npt.NDArray[np.float32]] = []
+    class_ids: list[int] = []
+    polygons: list[npt.NDArray[np.float32]] = []
+    skipped_types: set[str] = set()
+
+    for shape in shapes:
+        shape_type = shape.get("shape_type")
+        if shape_type not in SUPPORTED_SHAPE_TYPES:
+            skipped_types.add(str(shape_type))
+            continue
+        label = shape.get("label")
+        points_raw = shape.get("points")
+        if label is None or points_raw is None:
+            missing = "label" if label is None else "points"
+            raise ValueError(
+                f"LabelMe shape of type {shape_type!r} is missing the "
+                f"required {missing!r} field."
+            )
+        points = np.array(points_raw, dtype=np.float32)
+        if points.ndim != 2 or points.shape[1] != 2:
+            raise ValueError(
+                f"LabelMe shape of type {shape_type!r} (label={label!r}) has "
+                f"malformed points: expected an (N, 2) array, got shape "
+                f"{points.shape}."
+            )
+        if shape_type == "rectangle":
+            if len(points) < 2:
+                raise ValueError(
+                    f"LabelMe rectangle shape (label={label!r}) has "
+                    f"{len(points)} point(s); expected at least 2."
+                )
+            xyxy = _rectangle_to_xyxy(points)
+            polygon = _xyxy_to_polygon(xyxy)
+        else:
+            if len(points) < 3:
+                raise ValueError(
+                    f"LabelMe polygon shape (label={label!r}) has "
+                    f"{len(points)} point(s); expected at least 3."
+                )
+            xyxy = polygon_to_xyxy(polygon=points).astype(np.float32)
+            polygon = points
+        xyxy_list.append(xyxy)
+        class_ids.append(class_to_index[label])
+        if with_masks:
+            polygons.append(polygon)
+
+    if skipped_types:
+        warnings.warn(
+            f"Skipped unsupported LabelMe shape type(s) {sorted(skipped_types)}; "
+            f"only {list(SUPPORTED_SHAPE_TYPES)} are imported.",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    if not xyxy_list:
+        return Detections.empty()
+
+    xyxy = np.array(xyxy_list, dtype=np.float32)
+    class_id = np.array(class_ids, dtype=int)
+    if not with_masks:
+        return Detections(xyxy=xyxy, class_id=class_id)
+
+    mask = np.array(
+        [
+            polygon_to_mask(
+                polygon=np.round(polygon).astype(np.int32),
+                resolution_wh=resolution_wh,
+            )
+            for polygon in polygons
+        ],
+        dtype=bool,
+    )
+    return Detections(xyxy=xyxy, class_id=class_id, mask=mask)
+
+
+def load_labelme_annotations(
+    images_directory_path: str,
+    annotations_directory_path: str,
+    force_masks: bool = False,
+) -> tuple[list[str], list[str], dict[str, Detections]]:
+    """Load LabelMe annotations and convert them to ``Detections``.
+
+    LabelMe stores one JSON file per image, each containing a list of ``shapes``.
+    ``rectangle`` shapes become bounding boxes; ``polygon`` shapes become masks
+    (and their bounding boxes); other shape types are skipped with a warning.
+    When any polygon is present in a file or when ``force_masks`` is ``True``,
+    both ``rectangle`` and ``polygon`` shapes produce masks: rectangles via a
+    four-corner polygon fill. Class names are inferred from the labels present
+    across all files and assigned sorted, zero-based ids.
+
+    Each image is located by the basename of the JSON's ``imagePath`` joined to
+    ``images_directory_path``; the directory portion of ``imagePath`` (which
+    LabelMe stores relative to the JSON file) is ignored, so annotation-supplied
+    path traversal cannot escape ``images_directory_path``.
+
+    Args:
+        images_directory_path: Path to the directory containing the images.
+        annotations_directory_path: Path to the directory containing the LabelMe
+            ``.json`` files.
+        force_masks: If ``True``, load masks for every image regardless of
+            whether it contains polygon shapes.
+
+    Returns:
+        A tuple of ``(classes, image_paths, annotations)``.
+
+    Raises:
+        ValueError: If an annotation's ``imagePath`` is missing, empty, or
+            resolves to ``..`` or ``.``; if two annotation files reference the
+            same image basename; or if a polygon mask is requested for a file
+            missing ``imageWidth`` / ``imageHeight``.
+
+    Examples:
+        ```python
+        from supervision.dataset.formats.labelme import load_labelme_annotations
+
+        classes, image_paths, annotations = load_labelme_annotations(
+            images_directory_path="",
+            annotations_directory_path="",
+        )
+
+        classes
+        # ['dog', 'person']
+        ```
+    """
+    annotation_paths = sorted(
+        str(path)
+        for path in list_files_with_extensions(
+            directory=annotations_directory_path, extensions=["json"]
+        )
+    )
+
+    # Two-pass design (collect all class labels first, then assign IDs) requires
+    # materialising all annotation dicts upfront.
+    entries: list[LabelMeDict] = [
+        read_json_file(file_path=annotation_path)
+        for annotation_path in annotation_paths
+    ]
+
+    classes = sorted(
+        {
+            shape.get("label")
+            for entry in entries
+            for shape in entry.get("shapes", [])
+            if shape.get("shape_type") in SUPPORTED_SHAPE_TYPES
+        }
+        - {None}
+    )
+    class_to_index = {class_name: index for index, class_name in enumerate(classes)}
+
+    image_paths: list[str] = []
+    annotations: dict[str, Detections] = {}
+    for entry in entries:
+        shapes = entry.get("shapes", [])
+        raw_image_path = entry.get("imagePath")
+        if not raw_image_path:
+            raise ValueError(
+                "A LabelMe annotation file is missing the required "
+                "'imagePath' field or it is empty."
+            )
+        # ponytail: basename-only, no symlink resolution — images_directory_path
+        # is trusted; annotation-driven traversal is neutralised by .name.
+        # See createml._resolve_image_path for the full .resolve()+parents pattern.
+        # LabelMe writes imagePath with the separator of the OS that saved the file,
+        # so files saved on Windows hold backslashes. PureWindowsPath splits on both
+        # separators on every OS, as LabelMe does when it reads its own files.
+        image_name = PureWindowsPath(raw_image_path).name
+        if not image_name or image_name in ("..", "."):
+            raise ValueError(
+                f"LabelMe annotation has an invalid 'imagePath' {raw_image_path!r}."
+            )
+        image_path = str(Path(images_directory_path) / image_name)
+        if image_path in annotations:
+            raise ValueError(
+                f"Duplicate image basename {image_name!r} resolved from multiple "
+                "annotation files. All annotation files must reference unique "
+                "image basenames."
+            )
+        with_masks = force_masks or any(
+            shape.get("shape_type") == "polygon" for shape in shapes
+        )
+        if with_masks and not (entry.get("imageWidth") and entry.get("imageHeight")):
+            raise ValueError(
+                f"LabelMe annotation for {image_name!r} requires "
+                "'imageWidth' and 'imageHeight' to build masks, but they are "
+                "missing or zero."
+            )
+        resolution_wh = (
+            int(entry.get("imageWidth", 0)),
+            int(entry.get("imageHeight", 0)),
+        )
+        annotations[image_path] = labelme_shapes_to_detections(
+            shapes=shapes,
+            class_to_index=class_to_index,
+            resolution_wh=resolution_wh,
+            with_masks=with_masks,
+        )
+        image_paths.append(image_path)
+
+    return classes, image_paths, annotations
+
+
+def _build_shape(label: str, points: list[list[float]], shape_type: str) -> LabelMeDict:
+    return {
+        "label": label,
+        "points": points,
+        "group_id": None,
+        "description": "",
+        "shape_type": shape_type,
+        "flags": {},
+    }
+
+
+def detections_to_labelme_shapes(
+    detections: Detections, classes: list[str]
+) -> list[LabelMeDict]:
+    """Convert ``Detections`` into a list of LabelMe shape dicts.
+
+    Masked detections are exported as ``polygon`` shapes (one per connected
+    component); box-only detections — and masked detections whose mask yields no
+    polygon contour (e.g. an empty or sub-pixel mask) — are exported as
+    ``rectangle`` shapes, so no detection is silently dropped.
+
+    Args:
+        detections: The detections to export.
+        classes: List of class names indexed by ``class_id``.
+
+    Returns:
+        A list of LabelMe shape dicts ready to embed in a ``.json`` annotation.
+
+    Raises:
+        ValueError: If ``detections.class_id`` is ``None`` or if any
+            ``class_id`` value is out of range for ``classes``.
+    """
+    class_ids = detections.class_id
+    if class_ids is None:
+        raise ValueError(
+            "class_id is required for LabelMe export, but the provided "
+            "Detections has class_id=None."
+        )
+    masks = detections.mask
+    shapes: list[LabelMeDict] = []
+    for index in range(len(detections)):
+        class_index = int(class_ids[index])
+        if class_index < 0 or class_index >= len(classes):
+            raise ValueError(
+                f"class_id {class_index} at detection index {index} is out of "
+                f"range for classes list of length {len(classes)}."
+            )
+        label = classes[class_index]
+        if masks is not None:
+            mask_arr = np.asarray(masks[index], dtype=np.bool_)
+            polygons = mask_to_polygons(mask_arr)
+        else:
+            polygons = []
+        if polygons:
+            for polygon in polygons:
+                points = [[float(x), float(y)] for x, y in polygon]
+                shapes.append(_build_shape(label, points, "polygon"))
+        else:
+            x_min, y_min, x_max, y_max = (
+                float(value) for value in detections.xyxy[index]
+            )
+            points = [[x_min, y_min], [x_max, y_max]]
+            shapes.append(_build_shape(label, points, "rectangle"))
+    return shapes
+
+
+def save_labelme_annotations(
+    dataset: DetectionDataset,
+    annotations_directory_path: str,
+) -> None:
+    """Export a ``DetectionDataset`` to per-image LabelMe ``.json`` files.
+
+    Args:
+        dataset: The ``DetectionDataset`` to write.
+        annotations_directory_path: Directory where the LabelMe ``.json`` files
+            are written (created if it does not exist).
+
+    Raises:
+        ValueError: If two image paths map to the same output .json stem,
+            which would cause one annotation file to overwrite another.
+
+    Examples:
+        ```python
+        import supervision as sv
+        from supervision.dataset.formats.labelme import save_labelme_annotations
+
+        dataset = sv.DetectionDataset(classes=["dog"], images=[], annotations={})
+        save_labelme_annotations(
+            dataset=dataset,
+            annotations_directory_path="",
+        )
+        ```
+    """
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: f"{Path(image_path).stem}.json",
+        output_kind="LabelMe annotation",
+    )
+    Path(annotations_directory_path).mkdir(parents=True, exist_ok=True)
+    for image_path, image, detections in dataset:
+        image_height, image_width, _ = image.shape
+        labelme_dict: LabelMeDict = {
+            "version": _LABELME_EXPORT_VERSION,
+            "flags": {},
+            "shapes": detections_to_labelme_shapes(
+                detections=detections, classes=dataset.classes
+            ),
+            "imagePath": Path(image_path).name,
+            "imageData": None,
+            "imageHeight": int(image_height),
+            "imageWidth": int(image_width),
+        }
+        annotation_path = (
+            Path(annotations_directory_path) / f"{Path(image_path).stem}.json"
+        )
+        save_json_file(data=labelme_dict, file_path=str(annotation_path))
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/pascal_voc.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/pascal_voc.py
new file mode 100644
index 0000000000000000000000000000000000000000..80a86bc0b8e203cf93c1c59b86a23dcce9800f31
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/pascal_voc.py
@@ -0,0 +1,501 @@
+import math
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+from xml.etree.ElementTree import Element, SubElement
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+import numpy as np
+import numpy.typing as npt
+from defusedxml.ElementTree import parse, tostring
+from defusedxml.minidom import parseString
+from tqdm.auto import tqdm
+
+from supervision import _cv2 as cv2
+from supervision.dataset.utils import (
+    approximate_mask_with_polygons,
+    check_no_basename_collisions,
+)
+from supervision.detection.core import Detections
+from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy
+from supervision.utils.file import list_files_with_extensions
+
+
+def object_to_pascal_voc(
+    xyxy: npt.NDArray[np.number],
+    name: str,
+    polygon: npt.NDArray[np.number] | None = None,
+) -> Element:
+    """Build a Pascal VOC ```` XML element for one detection.
+
+    Coordinates are converted to 1-indexed Pascal VOC convention before writing.
+    The input arrays are never mutated; new arrays are allocated for the offset.
+
+    Args:
+        xyxy: Bounding box in zero-indexed pixel coordinates ``[x1, y1, x2, y2]``.
+            Shape ``(4,)``.
+        name: Class label string written to the ```` child element.
+        polygon: Optional segmentation polygon in zero-indexed pixel coordinates.
+            Shape ``(N, 2)``.
+
+    Returns:
+        An XML ``Element`` rooted at ```` containing ````,
+        ````, and optionally ```` children.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.dataset.formats.pascal_voc import object_to_pascal_voc
+        >>> elem = object_to_pascal_voc(np.array([0, 0, 9, 9]), name="cat")
+        >>> elem.find("bndbox/xmin").text
+        '1'
+        >>> elem.find("bndbox/xmax").text
+        '10'
+
+        ```
+    """
+    root = Element("object")
+
+    object_name = SubElement(root, "name")
+    object_name.text = name
+
+    # Pascal VOC coordinates are 1-indexed (https://github.com/roboflow/supervision/issues/144).
+    # Rebind to a new array instead of `+= 1`: `xyxy` is a view into the source
+    # `Detections.xyxy` (yielded by `Detections.__iter__`), so an in-place add
+    # would corrupt the caller's detections by +1 on every export.
+    xyxy = xyxy + 1
+
+    bndbox = SubElement(root, "bndbox")
+    xmin = SubElement(bndbox, "xmin")
+    xmin.text = str(int(xyxy[0]))
+    ymin = SubElement(bndbox, "ymin")
+    ymin.text = str(int(xyxy[1]))
+    xmax = SubElement(bndbox, "xmax")
+    xmax.text = str(int(xyxy[2]))
+    ymax = SubElement(bndbox, "ymax")
+    ymax.text = str(int(xyxy[3]))
+
+    if polygon is not None:
+        # 1-indexed, rebound to avoid mutating the caller's array (see above).
+        polygon = polygon + 1
+        object_polygon = SubElement(root, "polygon")
+        for index, point in enumerate(polygon, start=1):
+            x_coordinate, y_coordinate = point
+            x = SubElement(object_polygon, f"x{index}")
+            x.text = str(x_coordinate)
+            y = SubElement(object_polygon, f"y{index}")
+            y.text = str(y_coordinate)
+
+    return root
+
+
+def detections_to_pascal_voc(
+    detections: Detections,
+    classes: list[str],
+    filename: str,
+    image_shape: tuple[int, int, int],
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.75,
+) -> str:
+    """
+    Converts Detections object to Pascal VOC XML format.
+
+    Args:
+        detections: A Detections object containing bounding boxes,
+            class ids, and other relevant information.
+        classes: A list of class names corresponding to the
+            class ids in the Detections object.
+        filename: The name of the image file associated with the detections.
+        image_shape: The shape of the image
+            file associated with the detections.
+        min_image_area_percentage: Minimum detection area
+            relative to area of image associated with it.
+        max_image_area_percentage: Maximum detection area
+            relative to area of image associated with it.
+        approximation_percentage: The percentage of
+            polygon points to be removed from the input polygon, in the range [0, 1).
+    Returns:
+        An XML string in Pascal VOC format representing the detections.
+
+    Note:
+        ``detections`` is never mutated by this function; the source ``xyxy``
+        array is unchanged after the call. The function is therefore safe to
+        call multiple times on the same ``Detections`` object.
+    """
+    height, width, depth = image_shape
+
+    # Create root element
+    annotation = Element("annotation")
+
+    # Add folder element
+    folder = SubElement(annotation, "folder")
+    folder.text = "VOC"
+
+    # Add filename element
+    file_name = SubElement(annotation, "filename")
+    file_name.text = filename
+
+    # Add source element
+    source = SubElement(annotation, "source")
+    database = SubElement(source, "database")
+    database.text = "roboflow.ai"
+
+    # Add size element
+    size = SubElement(annotation, "size")
+    w = SubElement(size, "width")
+    w.text = str(width)
+    h = SubElement(size, "height")
+    h.text = str(height)
+    d = SubElement(size, "depth")
+    d.text = str(depth)
+
+    # Add segmented element
+    segmented = SubElement(annotation, "segmented")
+    segmented.text = "0"
+
+    # Add object elements
+    for xyxy, mask, _, class_id, _, _ in detections:
+        if class_id is None:
+            raise ValueError("Detections must include class_id for Pascal VOC export.")
+        if not isinstance(class_id, (int, np.integer)):
+            raise ValueError(
+                f"Detections class_id must be an integer for Pascal VOC export, "
+                f"got {type(class_id)!r}."
+            )
+        name = classes[class_id]
+        if mask is not None:
+            polygons = approximate_mask_with_polygons(
+                mask=mask,
+                min_image_area_percentage=min_image_area_percentage,
+                max_image_area_percentage=max_image_area_percentage,
+                approximation_percentage=approximation_percentage,
+            )
+            for polygon in polygons:
+                xyxy = polygon_to_xyxy(polygon=polygon)
+                next_object = object_to_pascal_voc(
+                    xyxy=xyxy, name=name, polygon=polygon
+                )
+                annotation.append(next_object)
+        else:
+            next_object = object_to_pascal_voc(xyxy=xyxy, name=name)
+            annotation.append(next_object)
+
+    # Generate XML string
+    xml_string = str(
+        parseString(tostring(annotation).decode("utf-8")).toprettyxml(indent="  ")
+    )
+    return xml_string
+
+
+def load_pascal_voc_annotations(
+    images_directory_path: str,
+    annotations_directory_path: str,
+    force_masks: bool = False,
+    show_progress: bool = False,
+) -> tuple[list[str], list[str], dict[str, Detections]]:
+    """
+    Load Pascal VOC XML annotations in sorted image-path order.
+
+    Args:
+        images_directory_path: The path to the directory containing the images.
+            Files with a ``.bmp``, ``.jpeg``, ``.jpg``, ``.png``, ``.tif``,
+            ``.tiff`` or ``.webp`` extension are loaded.
+        annotations_directory_path: The path to the directory containing the
+            PASCAL VOC annotation files.
+        force_masks: If True, forces masks to be loaded for all
+            annotations, regardless of whether they are present.
+        show_progress: If True, display a progress bar during loading.
+
+    Returns:
+        A tuple with a list of class names, a sorted list of paths to images,
+            and a dictionary with image paths as keys and corresponding
+            Detections instances as values.
+    """
+
+    image_paths = sorted(
+        str(path)
+        for path in list_files_with_extensions(
+            directory=images_directory_path,
+            extensions=["bmp", "jpeg", "jpg", "png", "tif", "tiff", "webp"],
+        )
+    )
+
+    classes: list[str] = []
+    annotations = {}
+
+    for image_path in tqdm(
+        image_paths,
+        total=len(image_paths),
+        desc="Loading Pascal VOC annotations",
+        disable=not show_progress,
+    ):
+        image_stem = Path(image_path).stem
+        annotation_path = os.path.join(annotations_directory_path, f"{image_stem}.xml")
+        if not os.path.exists(annotation_path):
+            annotations[image_path] = Detections.empty()
+            continue
+
+        tree = parse(annotation_path)
+        root = tree.getroot()
+        if root is None:
+            raise ValueError(f"Failed to parse XML root from {annotation_path}")
+
+        image = cv2.imread(image_path)
+        if image is None:
+            raise ValueError(f"Could not read image from path: {image_path}")
+        resolution_wh = (image.shape[1], image.shape[0])
+        annotation, classes = detections_from_xml_obj(
+            root, classes, resolution_wh, force_masks
+        )
+        annotations[image_path] = annotation
+
+    return classes, image_paths, annotations
+
+
+def detections_from_xml_obj(
+    root: Element,
+    classes: list[str],
+    resolution_wh: tuple[int, int],
+    force_masks: bool = False,
+) -> tuple[Detections, list[str]]:
+    """
+    Converts an XML object in Pascal VOC format to a Detections object.
+    Expected XML format:
+    
+        ...
+        
+            dog
+            
+                48
+                240
+                195
+                371
+            
+            
+                48
+                240
+                195
+                240
+                195
+                371
+                48
+                371
+            
+        
+    
+
+    Args:
+        root: Parsed Pascal VOC ```` XML element.
+        classes: Existing class names used to assign stable class ids.
+        resolution_wh: Image resolution as ``(width, height)`` for mask
+            rasterization.
+        force_masks: If True, returns a mask array for every object even when
+            no ```` element is present.
+
+    Returns:
+        A tuple containing a Detections object and an
+            updated list of class names, extended with the class names
+            from the XML object. The Detections ``class_id`` is always an
+            integer-dtype array, including the zero-```` (background)
+            case where it is empty.
+    """
+    xyxy: list[list[float]] = []
+    class_names: list[str] = []
+    masks: list[npt.NDArray[np.bool_]] = []
+    with_masks = force_masks or any(
+        _with_poly_mask(obj) for obj in root.findall("object")
+    )
+    extended_classes = classes[:]
+    for obj in root.findall("object"):
+        class_name = _get_required_text(obj, "name")
+        class_names.append(class_name)
+
+        bbox = obj.find("bndbox")
+        if bbox is None:
+            raise ValueError("Missing bndbox in Pascal VOC annotation.")
+        x1 = _parse_coordinate(_get_required_text(bbox, "xmin"), "xmin")
+        y1 = _parse_coordinate(_get_required_text(bbox, "ymin"), "ymin")
+        x2 = _parse_coordinate(_get_required_text(bbox, "xmax"), "xmax")
+        y2 = _parse_coordinate(_get_required_text(bbox, "ymax"), "ymax")
+
+        xyxy.append([x1, y1, x2, y2])
+
+        object_mask: npt.NDArray[np.bool_] = np.zeros(
+            (resolution_wh[1], resolution_wh[0]), dtype=bool
+        )
+        for polygon_element in obj.findall("polygon"):
+            polygon = parse_polygon_points(polygon_element)
+            # https://github.com/roboflow/supervision/issues/144
+            polygon -= 1
+
+            # Round only after the 1-index offset, as the YOLO and LabelMe loaders
+            # round zero-indexed vertices; rounding first would move `.5` values.
+            mask_from_polygon = polygon_to_mask(
+                polygon=np.round(polygon).astype(np.int32),
+                resolution_wh=resolution_wh,
+            )
+            object_mask |= mask_from_polygon.astype(bool)
+
+        if with_masks:
+            masks.append(object_mask)
+
+    xyxy_arr: npt.NDArray[np.float32]
+    if xyxy:
+        xyxy_arr = np.array(xyxy, dtype=np.float32)
+    else:
+        xyxy_arr = np.empty((0, 4), dtype=np.float32)
+
+    # https://github.com/roboflow/supervision/issues/144
+    xyxy_arr -= 1
+
+    for k in sorted(set(class_names)):
+        if k not in extended_classes:
+            extended_classes.append(k)
+    # dtype=int forced: on a background image class_names is empty, so
+    # np.array([]) would default to float64 and fail Detections' integer
+    # class_id validation. Redundant on the non-empty path (ints already).
+    class_id = np.array(
+        [extended_classes.index(class_name) for class_name in class_names],
+        dtype=int,
+    )
+
+    mask_arr: npt.NDArray[np.bool_] | None
+    if not with_masks:
+        mask_arr = None
+    elif masks:
+        mask_arr = np.array(masks, dtype=bool)
+    else:
+        # Background image with force_masks=True: masks is empty, and
+        # np.array([]) would collapse to shape (0,). Detections requires a 3D
+        # (0, H, W) mask, so build the empty stack explicitly.
+        mask_arr = np.empty((0, resolution_wh[1], resolution_wh[0]), dtype=bool)
+
+    annotation = Detections(
+        xyxy=xyxy_arr,
+        mask=mask_arr,
+        class_id=class_id,
+    )
+
+    return annotation, extended_classes
+
+
+def _with_poly_mask(obj: Element) -> bool:
+    return obj.find("polygon") is not None
+
+
+def _parse_coordinate(text: str, tag: str) -> float:
+    """Parse one Pascal VOC coordinate written as an integer or a decimal.
+
+    Exporters that keep sub-pixel boxes write values such as ``48.5`` or ``48.0``,
+    which ``int()`` rejects. Anything that is not a finite number still raises.
+    """
+    try:
+        value = float(text)
+    except ValueError:
+        value = math.nan
+    if not math.isfinite(value):
+        raise ValueError(f"Invalid '{tag}' value {text!r} in Pascal VOC annotation.")
+    return value
+
+
+def parse_polygon_points(polygon: Element) -> npt.NDArray[np.float64]:
+    """Parse ```` vertices, keeping decimal values as written.
+
+    Vertices stay floats so the caller can apply the 1-index offset before rounding them
+    to pixels for rasterisation.
+    """
+    coordinates: list[float] = []
+    for coord in polygon.findall(".//*"):
+        if coord.text is None:
+            raise ValueError("Missing polygon coordinate value in Pascal VOC.")
+        coordinates.append(_parse_coordinate(coord.text, coord.tag))
+    return np.array(
+        [(coordinates[i], coordinates[i + 1]) for i in range(0, len(coordinates), 2)],
+        dtype=np.float64,
+    )
+
+
+def _get_required_text(element: Element, tag: str) -> str:
+    child = element.find(tag)
+    if child is None or child.text is None:
+        raise ValueError(f"Missing '{tag}' in Pascal VOC annotation.")
+    return child.text
+
+
+def save_pascal_voc_annotations(
+    dataset: "DetectionDataset",
+    annotations_directory_path: str,
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.75,
+    show_progress: bool = False,
+) -> None:
+    """Write Pascal VOC XML annotation files for every image in *dataset*.
+
+    Files are written as UTF-8, whatever the platform's default encoding is.
+
+    Args:
+        dataset: Dataset whose annotations are saved.
+        annotations_directory_path: Destination directory for ``.xml`` files;
+            created automatically if it does not exist.
+        min_image_area_percentage: Minimum detection area as a fraction of the
+            image area. Detections below this threshold are omitted. Must be in
+            ``[0, 1]``. Default ``0.0`` keeps all detections.
+        max_image_area_percentage: Maximum detection area as a fraction of the
+            image area. Detections above this threshold are omitted. Must be in
+            ``[0, 1]``. Default ``1.0`` keeps all detections.
+        approximation_percentage: Fraction of polygon vertices to remove when
+            approximating instance masks as polygons. Range ``[0, 1)``. Default
+            ``0.75`` applies aggressive simplification.
+        show_progress: If ``True``, display a tqdm progress bar while writing
+            annotation files. Default ``False``.
+
+    Raises:
+        ValueError: If two image paths map to the same ``.xml`` output name.
+
+    Examples:
+        ```pycon
+        >>> import tempfile
+        >>> from supervision.dataset.core import DetectionDataset
+        >>> from supervision.dataset.formats.pascal_voc import (
+        ...     save_pascal_voc_annotations,
+        ... )
+        >>> dataset = DetectionDataset(classes=[], images={}, annotations={})
+        >>> with tempfile.TemporaryDirectory() as tmpdir:
+        ...     save_pascal_voc_annotations(dataset, tmpdir)
+
+        ```
+    """
+
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: f"{Path(image_path).stem}.xml",
+        output_kind="Pascal VOC annotation",
+    )
+    Path(annotations_directory_path).mkdir(parents=True, exist_ok=True)
+    for image_path, image, annotations in tqdm(
+        dataset,
+        total=len(dataset),
+        desc="Saving Pascal VOC annotations",
+        disable=not show_progress,
+    ):
+        annotation_name = Path(image_path).stem
+        annotations_path = os.path.join(
+            annotations_directory_path, f"{annotation_name}.xml"
+        )
+        image_name = Path(image_path).name
+        pascal_voc_xml = detections_to_pascal_voc(
+            detections=annotations,
+            classes=dataset.classes,
+            filename=image_name,
+            image_shape=(image.shape[0], image.shape[1], image.shape[2]),
+            min_image_area_percentage=min_image_area_percentage,
+            max_image_area_percentage=max_image_area_percentage,
+            approximation_percentage=approximation_percentage,
+        )
+        # The XML declaration names no encoding, so readers decode it as UTF-8.
+        with open(annotations_path, "w", encoding="utf-8") as f:
+            f.write(pascal_voc_xml)
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/formats/yolo.py b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/yolo.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c280ae2fe974733dc5b9d9a8fd037f66f9f8191
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/formats/yolo.py
@@ -0,0 +1,531 @@
+from __future__ import annotations
+
+import os
+import warnings
+from collections.abc import Sequence
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from tqdm.auto import tqdm
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.dataset.utils import (
+    _image_file_resolution_wh,
+    approximate_mask_with_polygons,
+    check_no_basename_collisions,
+)
+from supervision.detection.core import Detections
+from supervision.detection.utils._typing import _DetectionDataType
+from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy
+from supervision.utils.file import (
+    list_files_with_extensions,
+    read_txt_file,
+    read_yaml_file,
+    save_text_file,
+    save_yaml_file,
+)
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+
+def _parse_box(values: list[str]) -> npt.NDArray[np.float32]:
+    x_center, y_center, width, height = values
+    return np.array(
+        [
+            float(x_center) - float(width) / 2,
+            float(y_center) - float(height) / 2,
+            float(x_center) + float(width) / 2,
+            float(y_center) + float(height) / 2,
+        ],
+        dtype=np.float32,
+    )
+
+
+def _box_to_polygon(box: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+    return np.array(
+        [[box[0], box[1]], [box[2], box[1]], [box[2], box[3]], [box[0], box[3]]],
+        dtype=np.float32,
+    )
+
+
+def _parse_polygon(values: list[str]) -> npt.NDArray[np.float32]:
+    return np.array(values, dtype=np.float32).reshape(-1, 2)
+
+
+def _polygons_to_masks(
+    polygons: Sequence[npt.NDArray[np.number]], resolution_wh: tuple[int, int]
+) -> npt.NDArray[np.bool_]:
+    return np.array(
+        [
+            polygon_to_mask(
+                polygon=np.round(polygon).astype(np.int32),
+                resolution_wh=resolution_wh,
+            )
+            for polygon in polygons
+        ],
+        dtype=bool,
+    )
+
+
+def _with_seg_mask(lines: list[str]) -> bool:
+    return any([len(line.split()) > 5 for line in lines])
+
+
+def _extract_class_names(file_path: str) -> list[str]:
+    """Return class names from a YOLO data.yaml file ordered by class index.
+
+    Supports list and dict forms of the ``names`` field. Dict keys that are
+    all int-like (plain ints or digit strings) are sorted numerically so
+    class index 10 follows index 9. All-non-numeric keys are sorted
+    lexicographically. Mixed numeric/non-numeric keys raise ``ValueError``.
+    Boolean YAML keys (``true``/``false``) are excluded from numeric sorting
+    because ``bool`` is a subclass of ``int`` in Python.
+
+    Args:
+        file_path: Path to the data.yaml file.
+
+    Returns:
+        Class names in class-index order.
+
+    Raises:
+        ValueError: If the YAML root is not a mapping, if ``names`` is
+            neither a list nor a dict, or if the dict has mixed key types.
+    """
+    data: dict[str, Any] = read_yaml_file(file_path=file_path)
+    if not isinstance(data, dict):
+        raise ValueError(
+            f"Expected mapping in data.yaml at '{file_path}',"
+            f" got {type(data).__name__}."
+        )
+    names = data.get("names")
+    if isinstance(names, dict):
+        keys = list(names.keys())
+
+        def _is_int_like(key: Any) -> bool:
+            # bool subclasses int; YAML `true`/`false` must not become class indices
+            if isinstance(key, bool):
+                return False
+            if isinstance(key, int):
+                return True
+            if isinstance(key, str):
+                stripped = key.strip()
+                return stripped.isdigit()
+            return False
+
+        int_like = [_is_int_like(k) for k in keys]
+        if any(int_like) and not all(int_like):
+            mixed_numeric = [k for k, il in zip(keys, int_like) if il][:3]
+            mixed_other = [k for k, il in zip(keys, int_like) if not il][:3]
+            raise ValueError(
+                f"Expected 'names' dict in data.yaml at '{file_path}' to have either "
+                f"all numeric or all non-numeric keys, got a mix: "
+                f"numeric {mixed_numeric} and non-numeric {mixed_other} keys."
+            )
+        if all(int_like):
+            sorted_keys = sorted(keys, key=lambda k: int(k))
+        else:
+            sorted_keys = sorted(keys, key=str)
+        return [str(names[key]) for key in sorted_keys]
+    if isinstance(names, list):
+        return [str(name) for name in names]
+    raise ValueError(
+        "Expected 'names' to be a list or dict in data.yaml at "
+        f"'{file_path}', got {type(names).__name__}."
+    )
+
+
+def _image_name_to_annotation_name(image_name: str) -> str:
+    base_name, _ = os.path.splitext(image_name)
+    return base_name + ".txt"
+
+
+def _parse_class_id(value: str) -> int:
+    """Parse a YOLO class id written as an integer or as a whole decimal number.
+
+    Label files saved with ``np.savetxt`` write every column as a float, such as
+    ``1.000000000000000000e+00``, and Ultralytics reads the class column as a float, so
+    such datasets train there. Values that are not finite whole numbers still raise.
+    """
+    try:
+        return int(value)
+    except ValueError:
+        pass
+    try:
+        class_id = Decimal(value)
+    except InvalidOperation:
+        raise ValueError(
+            f"Invalid class id {value!r} in YOLO annotation; expected a whole number."
+        ) from None
+    if not class_id.is_finite() or class_id != class_id.to_integral_value():
+        raise ValueError(
+            f"Invalid class id {value!r} in YOLO annotation; expected a whole number."
+        )
+    return int(class_id)
+
+
+def yolo_annotations_to_detections(
+    lines: list[str],
+    resolution_wh: tuple[int, int],
+    with_masks: bool,
+    is_obb: bool = False,
+) -> Detections:
+    if len(lines) == 0:
+        return Detections.empty()
+
+    class_id_list: list[int] = []
+    relative_xyxy_list: list[npt.NDArray[np.number]] = []
+    relative_polygon_list: list[npt.NDArray[np.float32]] = []
+    relative_xyxyxyxy_list: list[npt.NDArray[np.float32]] = []
+    w, h = resolution_wh
+    for line in lines:
+        values = line.split()
+        class_id_list.append(_parse_class_id(values[0]))
+        if len(values) == 5:
+            box = _parse_box(values=values[1:])
+            relative_xyxy_list.append(box)
+            if with_masks:
+                relative_polygon_list.append(_box_to_polygon(box=box))
+        elif len(values) > 5:
+            polygon = _parse_polygon(values=values[1:])
+            relative_xyxy_list.append(polygon_to_xyxy(polygon=polygon))
+            if is_obb:
+                relative_xyxyxyxy_list.append(np.array(values[1:], dtype=np.float32))
+            if with_masks:
+                relative_polygon_list.append(polygon)
+
+    class_id = np.array(class_id_list, dtype=int)
+    relative_xyxy = np.array(relative_xyxy_list, dtype=np.float32)
+    xyxy = relative_xyxy * np.array([w, h, w, h], dtype=np.float32)
+    data: _DetectionDataType = {}
+
+    if is_obb:
+        relative_xyxyxyxy = np.array(relative_xyxyxyxy_list, dtype=np.float32)
+        xyxyxyxy = relative_xyxyxyxy.reshape(-1, 4, 2)
+        xyxyxyxy *= np.array([w, h], dtype=np.float32)
+        data[ORIENTED_BOX_COORDINATES] = cast(npt.NDArray[np.generic], xyxyxyxy)
+
+    if not with_masks:
+        return Detections(class_id=class_id, xyxy=xyxy, data=data)
+
+    polygons = [
+        polygon * np.array(resolution_wh, dtype=np.float32)
+        for polygon in relative_polygon_list
+    ]
+    mask = _polygons_to_masks(polygons=polygons, resolution_wh=resolution_wh)
+    return Detections(class_id=class_id, xyxy=xyxy, data=data, mask=mask)
+
+
+def load_yolo_annotations(
+    images_directory_path: str,
+    annotations_directory_path: str,
+    data_yaml_path: str,
+    force_masks: bool = False,
+    is_obb: bool = False,
+    show_progress: bool = False,
+) -> tuple[list[str], list[str], dict[str, Detections]]:
+    """
+    Loads YOLO annotations and returns class names, images,
+        and their corresponding detections.
+
+    Args:
+        images_directory_path: The path to the directory containing the images.
+        annotations_directory_path: The path to the directory
+            containing the YOLO annotation files.
+        data_yaml_path: The path to the data
+            YAML file containing class information.
+        force_masks: If True, forces masks to be loaded
+            for all annotations, regardless of whether they are present.
+            This parameter has no effect when `is_obb=True`; mask generation
+            is always disabled for OBB annotations.
+        is_obb: If True, loads the annotations in OBB format.
+            OBB annotations are defined as `[class_id, x, y, x, y, x, y, x, y]`,
+            where pairs of [x, y] are box corners.
+        show_progress: If True, display a progress bar during loading.
+
+    Returns:
+        A tuple containing a list of class names, a dictionary with
+            image names as keys and images as values, and a dictionary
+            with image names as keys and corresponding Detections instances as values.
+    """
+    if is_obb and force_masks:
+        warnings.warn(
+            "`force_masks=True` has no effect when `is_obb=True`; "
+            "mask generation is always disabled for OBB annotations.",
+            UserWarning,
+            stacklevel=2,
+        )
+    image_paths = [
+        str(path)
+        for path in list_files_with_extensions(
+            directory=images_directory_path,
+            extensions=[
+                "bmp",
+                "dng",
+                "jpg",
+                "jpeg",
+                "mpo",
+                "png",
+                "tif",
+                "tiff",
+                "webp",
+            ],
+        )
+    ]
+
+    classes = _extract_class_names(file_path=data_yaml_path)
+    annotations = {}
+
+    for image_path in tqdm(
+        image_paths,
+        total=len(image_paths),
+        desc="Loading YOLO annotations",
+        disable=not show_progress,
+    ):
+        image_stem = Path(image_path).stem
+        annotation_path = os.path.join(annotations_directory_path, f"{image_stem}.txt")
+        if not os.path.exists(annotation_path):
+            annotations[image_path] = Detections.empty()
+            continue
+
+        w, h = _image_file_resolution_wh(image_path)
+        lines = read_txt_file(file_path=annotation_path, skip_empty=True)
+        resolution_wh = (w, h)
+
+        with_masks = not is_obb and (force_masks or _with_seg_mask(lines=lines))
+        annotation = yolo_annotations_to_detections(
+            lines=lines,
+            resolution_wh=resolution_wh,
+            with_masks=with_masks,
+            is_obb=is_obb,
+        )
+        annotations[image_path] = annotation
+    return classes, image_paths, annotations
+
+
+def object_to_yolo(
+    xyxy: npt.NDArray[np.number],
+    class_id: int,
+    image_shape: tuple[int, int, int],
+    polygon: npt.NDArray[np.number] | None = None,
+) -> str:
+    h, w, _ = image_shape
+    if polygon is None:
+        xyxy_relative = xyxy / np.array([w, h, w, h], dtype=np.float32)
+        x_min, y_min, x_max, y_max = xyxy_relative
+        x_center = (x_min + x_max) / 2
+        y_center = (y_min + y_max) / 2
+        width = x_max - x_min
+        height = y_max - y_min
+        return f"{int(class_id)} {x_center:.5f} {y_center:.5f} {width:.5f} {height:.5f}"
+    else:
+        polygon_relative = polygon / np.array([w, h], dtype=np.float32)
+        polygon_relative = polygon_relative.reshape(-1)
+        polygon_parsed = " ".join([f"{value:.5f}" for value in polygon_relative])
+        return f"{int(class_id)} {polygon_parsed}"
+
+
+def detections_to_yolo_annotations(
+    detections: Detections,
+    image_shape: tuple[int, int, int],
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.75,
+    is_obb: bool = False,
+) -> list[str]:
+    """Convert detections to YOLO annotation lines.
+
+    Args:
+        detections: The detections to serialize. Each detection must have a
+            valid integer ``class_id``. When ``is_obb=True``, each non-empty
+            detection must also carry ``detections.data['xyxyxyxy']`` with
+            shape ``(N, 4, 2)``.
+        image_shape: The ``(height, width, channels)`` shape of the source
+            image, used to normalize coordinates to ``[0, 1]``.
+        min_image_area_percentage: Minimum detection area as a fraction of the
+            image area; smaller detections are omitted. Ignored when
+            ``is_obb=True``.
+        max_image_area_percentage: Maximum detection area as a fraction of the
+            image area; larger detections are omitted. Ignored when
+            ``is_obb=True``.
+        approximation_percentage: Fraction of polygon points removed during
+            contour approximation when saving mask annotations. Ignored when
+            ``is_obb=True``.
+        is_obb: If ``True``, serializes oriented bounding-box corners from
+            ``detections.data['xyxyxyxy']`` as a 9-token YOLO OBB line
+            ``class_id x1 y1 x2 y2 x3 y3 x4 y4``. Mask data is ignored.
+
+    Returns:
+        A list of YOLO annotation strings, one per detection (or one per
+        polygon for instance-segmentation annotations).
+
+    Raises:
+        ValueError: If any detection has ``class_id=None`` or a non-integer
+            ``class_id``.
+        ValueError: If ``is_obb=True`` and any non-empty detection is missing
+            ``'xyxyxyxy'`` in ``detections.data``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.core import Detections
+        >>> from supervision.dataset.formats.yolo import detections_to_yolo_annotations
+        >>> detections = Detections(
+        ...     xyxy=np.array([[10, 10, 90, 90]], dtype=np.float32),
+        ...     class_id=np.array([0]),
+        ... )
+        >>> detections_to_yolo_annotations(detections, image_shape=(100, 100, 3))
+        ['0 0.50000 0.50000 0.80000 0.80000']
+
+        ```
+    """
+    if (
+        is_obb
+        and len(detections) > 0
+        and ORIENTED_BOX_COORDINATES not in detections.data
+    ):
+        raise ValueError(
+            f"`is_obb=True` requires `'{ORIENTED_BOX_COORDINATES}'` in "
+            "`detections.data` with shape (N, 4, 2). Load OBB datasets via "
+            "`DetectionDataset.from_yolo(..., is_obb=True)` or set "
+            f"`detections.data['{ORIENTED_BOX_COORDINATES}']` "
+            "(shape (N, 4, 2)) before exporting."
+        )
+
+    if is_obb and detections.mask is not None:
+        warnings.warn(
+            "`detections.mask` is ignored when `is_obb=True`; "
+            "OBB annotations use corner coordinates from "
+            f"`detections.data['{ORIENTED_BOX_COORDINATES}']`.",
+            UserWarning,
+            stacklevel=2,
+        )
+
+    annotation: list[str] = []
+    for xyxy, mask, _, class_id, _, data in detections:
+        if class_id is None:
+            raise ValueError("Class ID is required for YOLO annotations.")
+        if not isinstance(class_id, (int, np.integer)):
+            raise ValueError(
+                f"Detections class_id must be an integer for YOLO export, "
+                f"got {type(class_id)!r}."
+            )
+        class_id_int = int(class_id)
+
+        if is_obb:
+            corners = np.asarray(data[ORIENTED_BOX_COORDINATES], dtype=np.float32)
+            if corners.shape != (4, 2):
+                raise ValueError(
+                    f"OBB data for each detection must have shape (4, 2), "
+                    f"got {corners.shape}. Ensure "
+                    f"`detections.data['{ORIENTED_BOX_COORDINATES}']` has "
+                    "shape (N, 4, 2) before exporting."
+                )
+            next_object = object_to_yolo(
+                xyxy=xyxy,
+                class_id=class_id_int,
+                image_shape=image_shape,
+                polygon=corners,
+            )
+            annotation.append(next_object)
+            continue
+
+        if mask is not None:
+            polygons = approximate_mask_with_polygons(
+                mask=mask,
+                min_image_area_percentage=min_image_area_percentage,
+                max_image_area_percentage=max_image_area_percentage,
+                approximation_percentage=approximation_percentage,
+            )
+            for polygon in polygons:
+                xyxy = polygon_to_xyxy(polygon=polygon)
+                next_object = object_to_yolo(
+                    xyxy=xyxy,
+                    class_id=class_id_int,
+                    image_shape=image_shape,
+                    polygon=polygon,
+                )
+                annotation.append(next_object)
+        else:
+            next_object = object_to_yolo(
+                xyxy=xyxy, class_id=class_id_int, image_shape=image_shape
+            )
+            annotation.append(next_object)
+    return annotation
+
+
+def save_yolo_annotations(
+    dataset: DetectionDataset,
+    annotations_directory_path: str,
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.75,
+    is_obb: bool = False,
+    show_progress: bool = False,
+) -> None:
+    """Save dataset annotations in YOLO format.
+
+    Args:
+        dataset: The dataset whose annotations are saved.
+        annotations_directory_path: Path to the directory where annotation
+            ``.txt`` files are written; created automatically if absent.
+        min_image_area_percentage: Minimum detection area as a fraction of the
+            image area; smaller detections are omitted. Ignored when
+            ``is_obb=True``.
+        max_image_area_percentage: Maximum detection area as a fraction of the
+            image area; larger detections are omitted. Ignored when
+            ``is_obb=True``.
+        approximation_percentage: Fraction of polygon points removed during
+            contour approximation when saving mask annotations. Ignored when
+            ``is_obb=True``.
+        is_obb: If ``True``, writes oriented bounding-box annotations using
+            the 9-token format ``class_id x1 y1 x2 y2 x3 y3 x4 y4``. Each
+            non-empty detection must carry ``detections.data['xyxyxyxy']``
+            with shape ``(N, 4, 2)``.
+        show_progress: If ``True``, display a tqdm progress bar while
+            saving annotations.
+
+    Examples:
+        ```pycon
+        >>> from supervision.dataset.core import DetectionDataset
+        >>> from supervision.dataset.formats.yolo import save_yolo_annotations
+        >>> dataset = DetectionDataset(classes=["cat"], images={}, annotations={})
+        >>> save_yolo_annotations(dataset, "/tmp/labels")
+
+        ```
+    """
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: _image_name_to_annotation_name(Path(image_path).name),
+        output_kind="YOLO annotation",
+    )
+    Path(annotations_directory_path).mkdir(parents=True, exist_ok=True)
+    for image_path, image, annotation in tqdm(
+        dataset,
+        total=len(dataset),
+        desc="Saving YOLO annotations",
+        disable=not show_progress,
+    ):
+        image_name = Path(image_path).name
+        yolo_annotations_name = _image_name_to_annotation_name(image_name=image_name)
+        yolo_annotations_path = os.path.join(
+            annotations_directory_path, yolo_annotations_name
+        )
+        lines = detections_to_yolo_annotations(
+            detections=annotation,
+            image_shape=image.shape,
+            min_image_area_percentage=min_image_area_percentage,
+            max_image_area_percentage=max_image_area_percentage,
+            approximation_percentage=approximation_percentage,
+            is_obb=is_obb,
+        )
+        save_text_file(lines=lines, file_path=yolo_annotations_path)
+
+
+def save_data_yaml(data_yaml_path: str, classes: list[str]) -> None:
+    data = {"nc": len(classes), "names": classes}
+    Path(data_yaml_path).parent.mkdir(parents=True, exist_ok=True)
+    save_yaml_file(data=data, file_path=data_yaml_path)
diff --git a/.venv/lib/python3.12/site-packages/supervision/dataset/utils.py b/.venv/lib/python3.12/site-packages/supervision/dataset/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2965542449dedbc1b6116d5ba605e17da0c4cc3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/dataset/utils.py
@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+__all__ = ["check_no_basename_collisions", "train_test_split"]
+
+import copy
+import os
+import random
+import shutil
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, TypeVar, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void  # type: ignore[import-untyped,unused-ignore]
+from PIL import Image
+from tqdm.auto import tqdm
+
+from supervision import _cv2 as cv2
+from supervision._cv2._image import _EXIF_ORIENTATION_TAG
+from supervision.detection.core import Detections
+from supervision.detection.utils.converters import mask_to_polygons
+from supervision.detection.utils.converters import (
+    mask_to_rle as _mask_to_rle,
+)
+from supervision.detection.utils.converters import (
+    rle_to_mask as _rle_to_mask,
+)
+from supervision.detection.utils.polygons import (
+    approximate_polygon,
+    filter_polygons_by_area,
+)
+
+_QUARTER_TURN_EXIF_ORIENTATIONS = frozenset({5, 6, 7, 8})
+
+
+def _image_file_resolution_wh(image_path: str) -> tuple[int, int]:
+    """Return the `(width, height)` at which `cv2.imread` loads an image file.
+
+    Only the file header is read, which is much faster than decoding the image (#1554).
+    Loading applies the EXIF orientation tag, and orientations 5 to 8 turn the image a
+    quarter turn, so for those the header's width and height are swapped.
+    """
+    with Image.open(image_path) as image:
+        width, height = image.size
+        orientation = image.getexif().get(_EXIF_ORIENTATION_TAG)
+    if orientation in _QUARTER_TURN_EXIF_ORIENTATIONS:
+        return height, width
+    return width, height
+
+
+@deprecated(target=_mask_to_rle, deprecated_in="0.28.0", remove_in="0.31.0")  # type: ignore[untyped-decorator]
+def mask_to_rle(
+    mask: npt.NDArray[np.bool_], compressed: bool = False
+) -> list[int] | str:
+    """Deprecated since 0.28.0.
+
+    Use `supervision.detection.utils.converters.mask_to_rle`.
+    """
+    return cast(list[int] | str, void(mask, compressed))
+
+
+@deprecated(target=_rle_to_mask, deprecated_in="0.28.0", remove_in="0.31.0")  # type: ignore[untyped-decorator]
+def rle_to_mask(
+    rle: npt.NDArray[np.integer] | list[int] | str | bytes,
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.bool_]:
+    """Deprecated since 0.28.0.
+
+    Use `supervision.detection.utils.converters.rle_to_mask`.
+    """
+    return cast(npt.NDArray[np.bool_], void(rle, resolution_wh))
+
+
+if TYPE_CHECKING:
+    from supervision.dataset.core import DetectionDataset
+
+T = TypeVar("T")
+
+
+def approximate_mask_with_polygons(
+    mask: npt.NDArray[np.bool_],
+    min_image_area_percentage: float = 0.0,
+    max_image_area_percentage: float = 1.0,
+    approximation_percentage: float = 0.0,
+) -> list[npt.NDArray[np.number]]:
+    """Filter mask polygons by area and optionally simplify them.
+
+    The default `approximation_percentage=0.0` preserves the original contour
+    unless callers explicitly ask for simplification.
+    """
+    height, width = mask.shape
+    image_area = height * width
+    minimum_detection_area = min_image_area_percentage * image_area
+    maximum_detection_area = max_image_area_percentage * image_area
+
+    polygons = cast(list[npt.NDArray[np.number]], mask_to_polygons(mask=mask))
+    if len(polygons) == 1:
+        polygons = filter_polygons_by_area(
+            polygons=polygons, min_area=None, max_area=maximum_detection_area
+        )
+    else:
+        polygons = filter_polygons_by_area(
+            polygons=polygons,
+            min_area=minimum_detection_area,
+            max_area=maximum_detection_area,
+        )
+    return [
+        approximate_polygon(polygon=polygon, percentage=approximation_percentage)
+        for polygon in polygons
+    ]
+
+
+def merge_class_lists(class_lists: list[list[str]]) -> list[str]:
+    unique_classes = set()
+
+    for class_list in class_lists:
+        for class_name in class_list:
+            unique_classes.add(class_name)
+
+    return sorted(list(unique_classes))
+
+
+def build_class_index_mapping(
+    source_classes: list[str], target_classes: list[str]
+) -> dict[int, int]:
+    """Returns the index map of source classes -> target classes."""
+    index_mapping = {}
+
+    for i, class_name in enumerate(source_classes):
+        if class_name not in target_classes:
+            raise ValueError(
+                f"Class {class_name} not found in target classes. "
+                "source_classes must be a subset of target_classes."
+            )
+        corresponding_index = target_classes.index(class_name)
+        index_mapping[i] = corresponding_index
+
+    return index_mapping
+
+
+def map_detections_class_id(
+    source_to_target_mapping: dict[int, int], detections: Detections
+) -> Detections:
+    if detections.class_id is None:
+        raise ValueError("Detections must have class_id attribute.")
+    if set(np.unique(detections.class_id)) - set(source_to_target_mapping.keys()):
+        raise ValueError(
+            "Detections class_id must be a subset of source_to_target_mapping keys."
+        )
+
+    detections_copy = copy.deepcopy(detections)
+
+    if len(detections) > 0:
+        detections_copy.class_id = np.vectorize(source_to_target_mapping.get)(
+            detections_copy.class_id
+        )
+
+    return detections_copy
+
+
+def check_no_basename_collisions(
+    image_paths: list[str],
+    key: Callable[[str], str],
+    output_kind: str,
+) -> None:
+    """Raise if two image paths would be written to the same output file.
+
+    Dataset image paths may share a basename when they originate from different
+    directories (a legal, common state after :meth:`DetectionDataset.merge`).
+    Exporting them into a single flat output directory keyed on the basename or
+    stem would silently overwrite one file with another and mispair images with
+    their annotations. This guard detects such collisions before any file is
+    written and names the colliding source paths.
+
+    Args:
+        image_paths: The dataset image paths about to be written.
+        key: Maps an image path to the output file name it would be written to.
+        output_kind: Human-readable description of the output (e.g. ``"image"``
+            or ``"YOLO annotation"``) used in the error message.
+
+    Raises:
+        ValueError: If two image paths map to the same output file name.
+
+    Examples:
+        ```pycon
+        >>> from pathlib import Path
+        >>> from supervision.dataset.utils import check_no_basename_collisions
+        >>> check_no_basename_collisions(
+        ...     ["a/img.jpg", "b/img.jpg"], lambda p: Path(p).name, "image"
+        ... )
+        Traceback (most recent call last):
+        ...
+        ValueError: Cannot export dataset: image paths 'a/img.jpg' and ...
+
+        ```
+    """
+    seen: dict[str, tuple[str, str]] = {}  # casefold(key) → (original name, image_path)
+    for image_path in image_paths:
+        output_name = key(image_path)
+        case_key = output_name.casefold()
+        if case_key in seen:
+            first_name, first_path = seen[case_key]
+            raise ValueError(
+                f"Cannot export dataset: image paths {first_path!r} and "
+                f"{image_path!r} both map to {output_kind} file {first_name!r}. "
+                "Ensure all output paths are unique before exporting."
+            )
+        seen[case_key] = (output_name, image_path)
+
+
+def save_dataset_images(
+    dataset: DetectionDataset,
+    images_directory_path: str,
+    show_progress: bool = False,
+) -> None:
+    """Save all images from a dataset to a directory.
+
+    Images already in memory are written with ``cv2.imwrite``; images stored
+    only as file paths are copied with ``shutil.copyfile``.
+
+    Args:
+        dataset: The dataset whose images are saved.
+        images_directory_path: Destination directory path; created
+            automatically if it does not exist.
+        show_progress: If ``True``, display a tqdm progress bar while
+            saving images.
+
+    Examples:
+        ```pycon
+        >>> from supervision.dataset.core import DetectionDataset
+        >>> from supervision.dataset.utils import save_dataset_images
+        >>> dataset = DetectionDataset(classes=["cat"], images={}, annotations={})
+        >>> save_dataset_images(dataset, "/tmp/images")
+
+        ```
+    """
+    check_no_basename_collisions(
+        image_paths=dataset.image_paths,
+        key=lambda image_path: Path(image_path).name,
+        output_kind="image",
+    )
+    Path(images_directory_path).mkdir(parents=True, exist_ok=True)
+    for image_path in tqdm(
+        dataset.image_paths,
+        desc="Saving images",
+        disable=not show_progress,
+    ):
+        final_path = os.path.join(images_directory_path, Path(image_path).name)
+        if image_path in dataset._images_in_memory:
+            image = dataset._images_in_memory[image_path]
+            cv2.imwrite(final_path, image)
+        else:
+            shutil.copyfile(image_path, final_path)
+
+
+def train_test_split(
+    data: list[T],
+    train_ratio: float = 0.8,
+    random_state: int | None = None,
+    shuffle: bool = True,
+) -> tuple[list[T], list[T]]:
+    """
+    Splits the data into two parts using the provided train_ratio.
+
+    Args:
+        data: The data to split.
+        train_ratio: The ratio of the training set to the entire dataset.
+        random_state: The seed for the random number generator.
+        shuffle: Whether to shuffle the data before splitting.
+
+    Returns:
+        The split data. The input list is copied and never mutated.
+
+    Examples:
+        ```pycon
+        >>> train, test = train_test_split(
+        ...     [1, 2, 3, 4, 5], train_ratio=0.6, random_state=0
+        ... )
+        >>> len(train), len(test)
+        (3, 2)
+
+        ```
+    """
+    rng = random.Random(random_state)  # noqa: S311 — dataset split, not cryptographic
+    if shuffle:
+        data = list(data)
+        rng.shuffle(data)
+    else:
+        data = list(data)  # copy to guarantee non-mutation
+
+    split_index = int(len(data) * train_ratio)
+    return data[:split_index], data[split_index:]
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__init__.py b/.venv/lib/python3.12/site-packages/supervision/detection/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfb26b3543d30103940933b4a1614ee7461027b8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/_geometry_dispatch.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/_geometry_dispatch.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0169218a6a4be3061a91a550f9f1a81f301452e0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/_geometry_dispatch.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/compact_mask.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/compact_mask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49dbba0cd2b3eeb251ec3d60877caa3149742c5a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/compact_mask.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13b3627f2bdbb4e6dea51d64efdda6bf4ee42bab
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/core.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d6508bdc0abaaef12f7ea181099dad43b2bc5425597883b56ccb7e23e8f5c90
+size 148947
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/line_zone.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/line_zone.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a10b5441edeb36a8ee56eb2a876f9579d4c7bf3c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/line_zone.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/vlm.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/vlm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d63bd75bbb44dd22c66bcf6f9a7f0b692daf0d90
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/__pycache__/vlm.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/_geometry_dispatch.py b/.venv/lib/python3.12/site-packages/supervision/detection/_geometry_dispatch.py
new file mode 100644
index 0000000000000000000000000000000000000000..b44303b1edbfa5da4d70ad2f7f4b0c123db1a4eb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/_geometry_dispatch.py
@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.utils.boxes import obb_polygon_area
+from supervision.detection.utils.iou_and_nms import (
+    OverlapMetric,
+    box_iou_batch,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.detection.utils.masks import count_mask_pixels
+
+if TYPE_CHECKING:
+    from supervision.detection.core import Detections
+
+
+def detection_area(detections: Detections) -> npt.NDArray[np.generic]:
+    """
+    Calculate detection areas using the richest geometry present.
+
+    Selection order:
+
+    1. If ``mask`` is set, return the area of each mask.
+    2. Else, if ``data[ORIENTED_BOX_COORDINATES]`` is set, return the area of
+       each oriented box.
+    3. Otherwise, return the axis-aligned box area.
+
+    Args:
+        detections: Detections whose geometry should be measured.
+
+    Returns:
+        A 1-D array containing the area of each detection.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.core import Detections
+        >>> detections = Detections(
+        ...     xyxy=np.array([[0, 0, 2, 3]], dtype=np.float32)
+        ... )
+        >>> detection_area(detections)  # doctest: +ELLIPSIS
+        array([6.], dtype=float32)
+
+        ```
+    """
+    if detections.mask is not None:
+        if isinstance(detections.mask, CompactMask):
+            return detections.mask.area
+        return count_mask_pixels(detections.mask)
+    if ORIENTED_BOX_COORDINATES in detections.data:
+        return obb_polygon_area(
+            cast(npt.NDArray[np.number], detections.data[ORIENTED_BOX_COORDINATES])
+        )
+    return detections.box_area
+
+
+def detection_iou(
+    detections_a: Detections,
+    detections_b: Detections,
+    overlap_metric: OverlapMetric | str = OverlapMetric.IOU,
+) -> npt.NDArray[np.floating]:
+    """
+    Calculate pairwise IoU using the richest geometry both operands share.
+
+    Selection order:
+
+    1. If both operands have masks, use mask IoU.
+    2. Else, if both operands have oriented-box coordinates, use OBB IoU.
+    3. Otherwise, use axis-aligned box IoU.
+
+    This is a **shared**-geometry dispatch, unlike `detection_area`'s
+    per-operand dispatch: if the two operands carry different kinds of
+    richer geometry (e.g. one has only a mask, the other only oriented-box
+    coordinates), neither is used and the axis-aligned box IoU is computed
+    instead.
+
+    Args:
+        detections_a: First set of detections.
+        detections_b: Second set of detections.
+        overlap_metric: Metric used to compute the degree of overlap.
+
+    Returns:
+        A matrix of pairwise overlaps with shape
+            ``(len(detections_a), len(detections_b))``.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.core import Detections
+        >>> detections = Detections(
+        ...     xyxy=np.array([[0, 0, 2, 2]], dtype=np.float32)
+        ... )
+        >>> detection_iou(detections, detections)  # doctest: +ELLIPSIS
+        array([[1.]], dtype=float32)
+
+        ```
+    """
+    overlap_metric = OverlapMetric.from_value(overlap_metric)
+    if detections_a.mask is not None and detections_b.mask is not None:
+        return mask_iou_batch(
+            detections_a.mask,
+            detections_b.mask,
+            overlap_metric=overlap_metric,
+        )
+
+    if (
+        ORIENTED_BOX_COORDINATES in detections_a.data
+        and ORIENTED_BOX_COORDINATES in detections_b.data
+    ):
+        return oriented_box_iou_batch(
+            cast(
+                npt.NDArray[np.number],
+                detections_a.data[ORIENTED_BOX_COORDINATES],
+            ),
+            cast(
+                npt.NDArray[np.number],
+                detections_b.data[ORIENTED_BOX_COORDINATES],
+            ),
+            overlap_metric=overlap_metric,
+        )
+
+    return box_iou_batch(
+        detections_a.xyxy,
+        detections_b.xyxy,
+        overlap_metric=overlap_metric,
+    )
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/compact_mask.py b/.venv/lib/python3.12/site-packages/supervision/detection/compact_mask.py
new file mode 100644
index 0000000000000000000000000000000000000000..38f916f3f35918ab6cec3311419be91a2f6a62dc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/compact_mask.py
@@ -0,0 +1,1706 @@
+"""Crop-RLE compact mask storage for memory-efficient instance segmentation.
+
+Dense ``(N, H, W)`` boolean masks use O(N·H·W) memory, which becomes
+prohibitive for aerial imagery (e.g. 1000 objects x 4K image ~ 8.3 GB).
+:class:`CompactMask` stores each mask as a run-length encoding of its
+bounding-box crop, reducing typical usage to tens of MB.
+
+The bounding boxes (``xyxy``) already present in ``Detections`` serve as the
+crop boundaries, so no extra metadata is required from the caller.
+
+CompactMask reduces memory footprint but does not improve computational
+speed. The ingestion path (base48 decode, column split, RLE trim) is
+Python-level and is typically slower than the dense NumPy path. The primary
+benefit is memory savings for large images with many sparse masks.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Any, cast, overload
+
+import numpy as np
+import numpy.typing as npt
+
+# _base48_decode and _delta_decode are private to the COCO RLE codec. They
+# live in converters.py and are shared by public conversion helpers here and
+# in that module.
+from supervision.detection.utils.converters import (
+    _base48_decode,
+    _delta_decode,
+    _mask_to_rle_counts,
+    _rle_counts_to_mask,
+)
+
+
+def _rle_area(rle: npt.NDArray[np.int32]) -> int:
+    """Return the number of ``True`` pixels in a run-length encoded mask.
+
+    Args:
+        rle: int32 array of run lengths as produced by :func:`_mask_to_rle_counts`.
+
+    Returns:
+        Total number of ``True`` pixels.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import _rle_area
+        >>> rle = np.array([1, 2, 1, 1, 1], dtype=np.int32)
+        >>> _rle_area(rle)
+        3
+
+        ```
+    """
+    return int(np.sum(rle[1::2]))
+
+
+def _rle_split_cols(
+    rle: npt.NDArray[np.int32],
+    crop_h: int,
+    crop_w: int,
+    x_start: int = 0,
+    x_stop: int | None = None,
+) -> list[list[int]]:
+    """Split a flat F-order RLE into per-column run lists.
+
+    With F-order (column-major) RLE the flat pixel sequence visits all rows
+    of column 0, then all rows of column 1, etc.  Each column therefore
+    contains ``crop_h`` contiguous pixels.
+
+    Runs that cross column boundaries are split at the boundary.  Each
+    returned list starts with a ``False``-run count (possibly 0), matching
+    the convention of :func:`_mask_to_rle_counts`.
+
+    When ``x_start`` and ``x_stop`` are provided, only columns in the closed
+    range ``[x_start, x_stop]`` are collected.  Pixels in skipped columns
+    are consumed without being stored, which avoids O(W) allocation when
+    only a small crop of a wide image is needed.
+
+    Note:
+        ``x_start`` uses ``np.cumsum`` + ``np.searchsorted`` to jump directly
+        to the first relevant run in O(log R) time, avoiding the O(pixel_prefix)
+        walk that previously made right-edge crops on wide images expensive.
+
+    Args:
+        rle: int32 run-length array as produced by
+            :func:`~supervision.detection.utils.converters._mask_to_rle_counts`.
+        crop_h: Number of rows (pixels per column).
+        crop_w: Number of columns.
+        x_start: First column to collect (0-indexed, inclusive).  Columns
+            before ``x_start`` are skipped.  Defaults to ``0``.
+        x_stop: Last column to collect (0-indexed, inclusive).  Processing
+            stops after column ``x_stop`` is complete.  Defaults to
+            ``crop_w - 1`` (collect all columns).
+
+    Returns:
+        List of ``x_stop - x_start + 1`` run lists.  Index ``i`` in the
+        returned list corresponds to column ``x_start + i``.  Each list
+        sums to ``crop_h``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import _rle_split_cols
+        >>> from supervision.detection.utils.converters import _mask_to_rle_counts
+        >>> mask = np.array([[True, False], [True, True]], dtype=bool)
+        >>> rle = _mask_to_rle_counts(mask)
+        >>> rle.tolist()
+        [0, 2, 1, 1]
+        >>> _rle_split_cols(rle, 2, 2)
+        [[0, 2], [1, 1]]
+        >>> _rle_split_cols(rle, 2, 2, x_start=1)
+        [[1, 1]]
+
+        ```
+    """
+    if x_stop is None:
+        x_stop = crop_w - 1
+
+    # Convert numpy int32 array to Python ints to avoid scalar boxing overhead
+    # in the inner loop (np.int32 boxing/unboxing slows pure-Python loops).
+    rle_list: list[int] = rle.tolist()
+
+    n_cols = x_stop - x_start + 1
+    per_col: list[list[int]] = [[] for _ in range(n_cols)]
+
+    # Fast-forward to the first run that overlaps column x_start using O(log R)
+    # searchsorted instead of an O(pixel_prefix) sequential walk.
+    start_pixel = x_start * crop_h
+    if start_pixel > 0 and len(rle_list) > 0:
+        cumsum_ends = np.cumsum(rle, dtype=np.int64)
+        first_run = int(np.searchsorted(cumsum_ends, start_pixel, side="right"))
+        if first_run >= len(rle_list):
+            for c in range(n_cols):
+                per_col[c] = [crop_h]
+            return per_col
+        prefix = int(cumsum_ends[first_run - 1]) if first_run > 0 else 0
+    else:
+        first_run = 0
+        prefix = 0
+
+    col = prefix // crop_h
+    row = prefix % crop_h
+
+    for run_idx in range(first_run, len(rle_list)):
+        run_len = rle_list[run_idx]
+        is_true = run_idx % 2 == 1
+        remaining = run_len
+        while remaining > 0:
+            # Past the requested range — stop early.
+            if col > x_stop:
+                remaining = 0
+                break
+            space_in_col = crop_h - row
+            take = min(remaining, space_in_col)
+            if col >= x_start:
+                local_col = col - x_start
+                if len(per_col[local_col]) == 0:
+                    if is_true:
+                        per_col[local_col].append(0)  # leading False count = 0
+                # Check if last run has same parity (True/False) as current chunk.
+                # Last element's parity: index (len-1) odd → True, even → False.
+                elif is_true == ((len(per_col[local_col]) - 1) % 2 == 1):
+                    per_col[local_col][-1] += take
+                    remaining -= take
+                    row += take
+                    if row >= crop_h:
+                        row = 0
+                        col += 1
+                    continue
+                per_col[local_col].append(take)
+            remaining -= take
+            row += take
+            if row >= crop_h:
+                row = 0
+                col += 1
+        if col > x_stop:
+            break
+
+    # Fill any empty columns (all-False).
+    for c in range(n_cols):
+        if not per_col[c]:
+            per_col[c] = [crop_h]
+
+    return per_col
+
+
+def _rle_scale_col(
+    col_runs: list[int],
+    src_h: int,
+    row_map: npt.NDArray[np.int32],
+) -> list[int]:
+    """Scale one column's run list to a new height using a precomputed row map.
+
+    Each output row is mapped to a source row via ``row_map``, which
+    implements nearest-neighbour resampling in the vertical direction.
+
+    Args:
+        col_runs: Per-column run list starting with a ``False``-run count.
+        src_h: Height of the source column (sum of ``col_runs``).
+        row_map: int32 array of length ``new_crop_h``; ``row_map[r']`` is the
+            source row index for output row ``r'``.  Use
+            ``(np.arange(new_crop_h) * src_h // new_crop_h)`` for
+            ``cv2.INTER_NEAREST``-compatible mapping.
+
+    Returns:
+        Scaled run list of total length ``len(row_map)``, always starting
+        with a ``False``-run count.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import _rle_scale_col
+        >>> col_runs = [0, 2, 2]   # F=0, T=2, F=2  → [T, T, F, F]
+        >>> row_map = np.array([0, 1, 2, 3, 0, 1, 2, 3], dtype=np.int32)
+        >>> _rle_scale_col(col_runs, 4, row_map)
+        [0, 2, 2, 2, 2]
+
+        ```
+    """
+    new_crop_h = len(row_map)
+    if new_crop_h == 0:
+        return [0]
+
+    # Reconstruct per-source-row boolean values from run list.
+    src_values: npt.NDArray[np.bool_] = np.empty(src_h, dtype=np.bool_)
+    pos = 0
+    for ri, rl in enumerate(col_runs):
+        src_values[pos : pos + rl] = ri % 2 == 1  # odd index → True
+        pos += rl
+    if pos < src_h:
+        src_values[pos:] = False  # pad truncated RLE
+
+    # Map output rows to source values.
+    out_values = src_values[row_map]
+
+    # RLE-encode the output column; vectorised via np.diff on bool view.
+    out_uint8 = out_values.view(np.uint8)
+    boundaries = np.flatnonzero(np.diff(out_uint8))
+    run_starts: npt.NDArray[np.int64] = np.empty(len(boundaries) + 1, dtype=np.int64)
+    run_ends: npt.NDArray[np.int64] = np.empty(len(boundaries) + 1, dtype=np.int64)
+    run_starts[0] = 0
+    run_starts[1:] = boundaries + 1
+    run_ends[:-1] = boundaries + 1
+    run_ends[-1] = new_crop_h
+    result_runs: list[int] = (run_ends - run_starts).tolist()
+    # RLE starts with a False count; prepend 0 if output begins with True.
+    if bool(out_values[0]):
+        result_runs.insert(0, 0)
+    return result_runs
+
+
+def _rle_join_cols(
+    scaled_cols: list[list[int]],
+    new_total: int,
+) -> npt.NDArray[np.int32]:
+    """Concatenate per-column run lists into a flat RLE, merging junctions.
+
+    Each column run list starts with a ``False``-run count. Two junction types
+    can be merged across column boundaries:
+
+    * ``False``/``False``: the trailing False run merges with the leading False
+      run of the next column (leading count may be zero).
+    * ``True``/``True``: when the accumulated output ends on a True run and the
+      next column's leading False count is zero (column starts with True), the
+      two True runs are merged to avoid inserting a zero-length False run that
+      would inflate ``len(rle)`` and skew the density metric in
+      :func:`_resize_crop`.
+
+    Args:
+        scaled_cols: List of per-column run lists, each starting with a
+            ``False``-run count.
+        new_total: Total pixel count of the output (fallback for empty input).
+
+    Returns:
+        Flat int32 RLE array starting with a ``False``-run count.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import _rle_join_cols
+        >>> cols = [[1, 2], [1, 2]]  # each col: F=1, T=2
+        >>> _rle_join_cols(cols, 6).tolist()
+        [1, 2, 1, 2]
+
+        ```
+    """
+    output_runs: list[int] = []
+    for col_runs in scaled_cols:
+        if not output_runs:
+            output_runs.extend(col_runs)
+        else:
+            last_is_true = (len(output_runs) - 1) % 2 == 1
+            # col_runs always starts with a False count → first_is_true=False
+            if not last_is_true:  # last == False == first → merge
+                output_runs[-1] += col_runs[0]
+                output_runs.extend(col_runs[1:])
+            elif col_runs[0] == 0 and len(col_runs) > 1:
+                # last run = True; column also starts True (leading False = 0)
+                # → merge to avoid a zero-length False run at the junction.
+                output_runs[-1] += col_runs[1]
+                output_runs.extend(col_runs[2:])
+            else:
+                output_runs.extend(col_runs)
+
+    return np.array(output_runs if output_runs else [new_total], dtype=np.int32)
+
+
+def _rle_trim_col_runs(col_runs: Sequence[int], y1: int, y2: int) -> list[int]:
+    """Restrict one full-height column RLE to inclusive rows ``[y1, y2]``.
+
+    Args:
+        col_runs: Run lengths for one full-height column, starting with a
+            ``False`` run.
+        y1: Inclusive top row of the crop.
+        y2: Inclusive bottom row of the crop.
+
+    Returns:
+        Run lengths for the cropped column, also starting with a ``False`` run.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.compact_mask import _rle_trim_col_runs
+        >>> # Full column F=2, T=2, F=2 (height 6); crop to rows 1..4 inclusive
+        >>> # yields rows [F, T, T, F] → F=1, T=2, F=1.
+        >>> _rle_trim_col_runs([2, 2, 2], y1=1, y2=4)
+        [1, 2, 1]
+
+        ```
+    """
+    target_height = y2 - y1 + 1
+    # Sum invariant: returned list sums to target_height.  Correctness depends
+    # on the caller (from_coco_rle) having already validated that counts sum
+    # equals img_h * img_w; no re-validation here.
+    collected: list[tuple[bool, int]] = []
+    row = 0
+    for run_idx, run_len in enumerate(col_runs):
+        is_true = run_idx % 2 == 1
+        start = row
+        end = row + int(run_len)
+        row = end
+
+        crop_start = max(start, y1)
+        crop_end = min(end, y2 + 1)
+        if crop_end > crop_start:
+            collected.append((is_true, crop_end - crop_start))
+        if row > y2:
+            break
+
+    if not collected:
+        return [target_height]
+
+    result: list[int] = []
+    if collected[0][0]:
+        result.append(0)
+    for is_true, length in collected:
+        last_is_true = bool(result) and (len(result) - 1) % 2 == 1
+        if result and last_is_true == is_true:
+            result[-1] += length
+        else:
+            result.append(length)
+    return result
+
+
+def _coco_rle_counts_to_array(counts: Any) -> npt.NDArray[np.int32]:
+    """Decode COCO RLE counts into absolute F-order run lengths.
+
+    Args:
+        counts: COCO compressed counts (``str`` or ``bytes``), or uncompressed
+            integer run lengths.
+
+    Returns:
+        One-dimensional ``int32`` run-length array.
+
+    Raises:
+        ValueError: If counts cannot be decoded into non-negative run lengths.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.compact_mask import _coco_rle_counts_to_array
+        >>> _coco_rle_counts_to_array([0, 2, 2, 2, 10])
+        array([ 0,  2,  2,  2, 10], dtype=int32)
+
+        ```
+    """
+    try:
+        if isinstance(counts, bytes):
+            counts = counts.decode("utf-8")
+        if isinstance(counts, str):
+            decoded_counts = _delta_decode(_base48_decode(counts))
+            counts_arr = np.array(decoded_counts, dtype=np.int32)
+        else:
+            # Convert to int64 first, then range-check against int32 bounds before
+            # narrowing. A direct int32 cast wraps silently on some numpy versions
+            # and raises on others; this makes overflow detection deterministic.
+            counts_arr64 = np.asarray(counts, dtype=np.int64)
+            int32_info = np.iinfo(np.int32)
+            if counts_arr64.size and (
+                counts_arr64.max() > int32_info.max
+                or counts_arr64.min() < int32_info.min
+            ):
+                raise ValueError("COCO RLE counts exceed int32 range.")
+            counts_arr = counts_arr64.astype(np.int32)
+    except (TypeError, ValueError, OverflowError) as exc:
+        raise ValueError("Invalid COCO RLE counts.") from exc
+
+    if counts_arr.ndim != 1:
+        raise ValueError("COCO RLE counts must be one-dimensional.")
+    if counts_arr.size == 0:
+        raise ValueError("COCO RLE counts cannot be empty.")
+    if np.any(counts_arr < 0):
+        raise ValueError("COCO RLE counts must be non-negative.")
+    return counts_arr
+
+
+def _rle_resize(
+    rle: npt.NDArray[np.int32],
+    crop_h: int,
+    crop_w: int,
+    new_crop_h: int,
+    new_crop_w: int,
+) -> npt.NDArray[np.int32]:
+    """Resize an F-order RLE-encoded crop via nearest-neighbour resampling.
+
+    Manipulates run lengths directly without decoding to a full 2D boolean
+    array.  Delegates to :func:`_rle_split_cols`, :func:`_rle_scale_col`,
+    and :func:`_rle_join_cols`.
+
+    The nearest-neighbour mapping ``src = floor(dst * src_size / dst_size)``
+    is bit-exact with ``cv2.INTER_NEAREST``.
+
+    Args:
+        rle: int32 array of F-order run lengths as produced by
+            :func:`~supervision.detection.utils.converters._mask_to_rle_counts`.
+            Starts with a ``False``-run count (may be 0).
+        crop_h: Height of the original crop.
+        crop_w: Width of the original crop.
+        new_crop_h: Height of the resized crop.
+        new_crop_w: Width of the resized crop.
+
+    Returns:
+        int32 array of F-order run lengths for the resized crop, starting
+        with the ``False``-run count.
+
+    Examples:
+        Upscale a 3x3 mask with a diagonal True stripe to 6x6:
+
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import _rle_resize
+        >>> from supervision.detection.utils.converters import (
+        ...     _mask_to_rle_counts, _rle_counts_to_mask,
+        ... )
+        >>> mask = np.array([
+        ...     [True,  False, False],
+        ...     [False, True,  False],
+        ...     [False, False, True ],
+        ... ], dtype=bool)
+        >>> rle = _mask_to_rle_counts(mask)
+        >>> resized_rle = _rle_resize(rle, 3, 3, 6, 6)
+        >>> result = _rle_counts_to_mask(resized_rle, 6, 6)
+        >>> result.astype(int)
+        array([[1, 1, 0, 0, 0, 0],
+               [1, 1, 0, 0, 0, 0],
+               [0, 0, 1, 1, 0, 0],
+               [0, 0, 1, 1, 0, 0],
+               [0, 0, 0, 0, 1, 1],
+               [0, 0, 0, 0, 1, 1]])
+
+        ```
+    """
+    new_total = new_crop_h * new_crop_w
+
+    if crop_h * crop_w == 0 or new_total == 0:
+        return np.array([0], dtype=np.int32)
+    if len(rle) == 1 or int(np.sum(rle[1::2])) == 0:
+        return np.array([new_total], dtype=np.int32)
+    if len(rle) == 2 and rle[0] == 0:
+        return np.array([0, new_total], dtype=np.int32)
+
+    per_col = _rle_split_cols(rle, crop_h, crop_w)
+
+    # cv2.INTER_NEAREST column mapping: src = floor(dst * src_w / dst_w)
+    col_map = (np.arange(new_crop_w) * crop_w // new_crop_w).astype(np.int32)
+
+    # cv2.INTER_NEAREST row mapping: src = floor(dst * src_h / dst_h)
+    row_map = (np.arange(new_crop_h) * crop_h // new_crop_h).astype(np.int32)
+
+    # Scale each unique source column once; reuse via cache for repeated cols.
+    col_cache: dict[int, list[int]] = {}
+    scaled_cols = []
+    for src_c in col_map:
+        src_col = int(src_c)
+        if src_col not in col_cache:
+            col_cache[src_col] = _rle_scale_col(per_col[src_col], crop_h, row_map)
+        scaled_cols.append(col_cache[src_col])
+
+    return _rle_join_cols(scaled_cols, new_total)
+
+
+# Fraction of (run_count / pixel_count) below which _rle_resize is used
+# instead of the decode → cv2 → re-encode path.  Sparse masks have few long
+# runs; dense/complex masks approach 1 run per 2 pixels.
+_L3_DENSITY_THRESHOLD: float = 0.25
+# Thread overhead outweighs gains below this mask count.
+_PARALLEL_THRESHOLD: int = 8
+# Hard ceiling on each image dimension accepted by from_coco_rle, guarding
+# against crafted payloads that allocate O(H x W) column lists.
+_MAX_IMAGE_DIMENSION: int = 32768
+# Images at or below this pixel count use a fully-vectorised numpy dense-decode
+# path inside from_coco_rle instead of the pure-Python column-split loop.
+# Crossover measured at ~8-16 K px (128x128); threshold set at 128x128 = 16 384.
+_SMALL_IMAGE_DENSE_THRESHOLD: int = 128 * 128
+
+
+def _resize_crop(
+    rle: npt.NDArray[np.int32],
+    orig_h: int,
+    orig_w: int,
+    new_h: int,
+    new_w: int,
+) -> npt.NDArray[np.int32]:
+    """Resize one RLE crop to ``(new_h, new_w)``, choosing the fastest path.
+
+    Dispatch order:
+
+    1. **All-False fast path** — returns a single False run; no decode.
+    2. **L3 direct RLE path** — used when run density is below
+       :data:`_L3_DENSITY_THRESHOLD`; manipulates run lengths without
+       allocating a 2D array.
+    3. **cv2 fallback** — decodes to ``uint8``, calls
+       ``cv2.resize(INTER_NEAREST)``, re-encodes; used for dense masks.
+
+    Args:
+        rle: int32 run-length array for the source crop.
+        orig_h: Height of the source crop.
+        orig_w: Width of the source crop.
+        new_h: Target height.
+        new_w: Target width.
+
+    Returns:
+        int32 RLE array for the resized crop.
+    """
+    from supervision import _cv2 as cv2
+
+    # All-False: skip decode entirely.
+    if _rle_area(rle) == 0:
+        return np.array([new_h * new_w], dtype=np.int32)
+
+    # L3: direct RLE arithmetic for sparse masks.
+    if len(rle) / max(1, orig_h * orig_w) < _L3_DENSITY_THRESHOLD:
+        return _rle_resize(rle, orig_h, orig_w, new_h, new_w)
+
+    # cv2 fallback for dense masks.
+    crop = _rle_counts_to_mask(rle, orig_h, orig_w)
+    resized = cv2.resize(
+        crop.view(np.uint8),
+        (new_w, new_h),
+        interpolation=cv2.INTER_NEAREST,
+    ).astype(bool)
+    return _mask_to_rle_counts(resized)
+
+
+class CompactMask:
+    """Memory-efficient crop-RLE mask storage for instance segmentation.
+
+    Instead of storing N full ``(H, W)`` boolean arrays, :class:`CompactMask`
+    encodes each mask as a run-length sequence of its bounding-box crop.  This
+    reduces memory from O(N·H·W) to roughly O(N·bbox_area), which is orders of
+    magnitude smaller for sparse masks on high-resolution images.
+
+    The class exposes a duck-typed interface compatible with ``np.ndarray``
+    masks used elsewhere in ``supervision``:
+
+    * ``mask[int]`` → dense ``(H, W)`` bool array (annotators, converters).
+    * ``mask[slice | list | ndarray]`` → new :class:`CompactMask` (filtering).
+    * ``np.asarray(mask)`` → dense ``(N, H, W)`` bool array (numpy interop).
+    * ``mask.shape``, ``mask.dtype``, ``mask.area`` — match the dense API.
+
+    :class:`CompactMask` is **not** a drop-in ``np.ndarray`` replacement.
+    When you need to call arbitrary ndarray methods (``astype``, ``reshape``,
+    ``ravel``, ``any``, ``all``, …) call :meth:`to_dense` first:
+    ``cm.to_dense().astype(np.uint8)``.  :meth:`to_dense` is the single
+    explicit materialisation boundary.
+
+    .. note:: **RLE encoding — COCO / pycocotools pixel-scan order**
+
+        :class:`CompactMask` uses **column-major (Fortran-order, F-order)**
+        run-lengths scoped to each mask's bounding-box crop, matching the
+        pixel-scan order used by the COCO API (pycocotools).  The crop scope
+        still differs from the full-image scope used by pycocotools, so a
+        :class:`CompactMask` RLE cannot be passed directly to
+        ``maskUtils.iou()`` or ``maskUtils.decode()`` without re-scoping to
+        the full canvas.  Use :meth:`to_dense` to obtain a standard boolean
+        array for pycocotools interop.
+
+        This scan order is part of CompactMask's internal RLE representation.
+        Switching from row-major (C-order) to column-major (F-order) is a
+        backward-incompatible format change for any persisted or serialized
+        :class:`CompactMask` state, including pickled objects and any
+        external storage of ``._rles``.  Older stored RLE arrays will decode
+        incorrectly under the new convention.
+
+        Migration note: load or decode legacy masks with the older version,
+        materialize them to dense boolean arrays, and then re-encode them
+        with the current version (for example via :meth:`to_dense` followed
+        by :meth:`from_dense`) before persisting them again.
+
+    Args:
+        rles: List of N int32 run-length arrays.
+        crop_shapes: Array of shape ``(N, 2)`` — ``(crop_h, crop_w)`` per mask.
+        offsets: Array of shape ``(N, 2)`` — ``(x1, y1)`` bounding-box origins.
+        image_shape: ``(H, W)`` of the full image.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.compact_mask import CompactMask
+        >>> masks = np.zeros((2, 100, 100), dtype=bool)
+        >>> masks[0, 10:20, 10:20] = True
+        >>> masks[1, 50:70, 50:80] = True
+        >>> xyxy = np.array([[10, 10, 19, 19], [50, 50, 79, 69]], dtype=np.float32)
+        >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100))
+        >>> len(cm)
+        2
+        >>> cm.shape
+        (2, 100, 100)
+
+        ```
+    """
+
+    __slots__ = ("_crop_shapes", "_image_shape", "_offsets", "_rles")
+
+    def __init__(
+        self,
+        rles: list[npt.NDArray[np.int32]],
+        crop_shapes: npt.NDArray[np.int32],
+        offsets: npt.NDArray[np.int32],
+        image_shape: tuple[int, int],
+    ) -> None:
+        self._rles: list[npt.NDArray[np.int32]] = rles
+        self._crop_shapes: npt.NDArray[np.int32] = crop_shapes  # (N,2): (h,w)
+        self._offsets: npt.NDArray[np.int32] = offsets  # (N,2): (x1,y1)
+        self._image_shape: tuple[int, int] = image_shape  # (H, W)
+
+    # ------------------------------------------------------------------
+    # Construction
+    # ------------------------------------------------------------------
+
+    @classmethod
+    def from_dense(
+        cls,
+        masks: npt.NDArray[np.bool_],
+        xyxy: npt.NDArray[np.number],
+        image_shape: tuple[int, int],
+    ) -> CompactMask:
+        """Create a :class:`CompactMask` from a dense ``(N, H, W)`` bool array.
+
+        Bounding boxes are clipped to image bounds and interpreted in the
+        supervision ``xyxy`` convention (inclusive max coordinates). A
+        box with invalid ordering (``x2 < x1`` or ``y2 < y1``) is replaced by
+        a ``1x1`` all-False crop to avoid degenerate RLE.
+
+        Args:
+            masks: Dense boolean mask array of shape ``(N, H, W)``.
+            xyxy: Bounding boxes of shape ``(N, 4)`` in ``[x1, y1, x2, y2]``
+                format.
+            image_shape: ``(H, W)`` of the full image.
+
+        Returns:
+            A new :class:`CompactMask` instance.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 100, 100), dtype=bool)
+            >>> masks[0, 10:20, 10:20] = True
+            >>> xyxy = np.array([[10, 10, 19, 19]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100))
+            >>> cm.shape
+            (1, 100, 100)
+
+            ```
+        """
+        img_h, img_w = image_shape
+        num_masks = len(masks)
+
+        if num_masks == 0:
+            return cls(
+                [],
+                np.empty((0, 2), dtype=np.int32),
+                np.empty((0, 2), dtype=np.int32),
+                image_shape,
+            )
+
+        rles: list[npt.NDArray[np.int32]] = []
+        crop_shapes_list: list[tuple[int, int]] = []
+        offsets_list: list[tuple[int, int]] = []
+
+        for mask_idx in range(num_masks):
+            x1, y1, x2, y2 = xyxy[mask_idx]
+            x1i, y1i, x2i, y2i = int(x1), int(y1), int(x2), int(y2)
+            x1c = int(max(0, min(x1i, img_w - 1)))
+            y1c = int(max(0, min(y1i, img_h - 1)))
+            crop: npt.NDArray[np.bool_]
+
+            # supervision xyxy uses inclusive max coords, so slicing must add +1.
+            if (
+                x2i < x1i
+                or y2i < y1i
+                or x2i < 0
+                or y2i < 0
+                or x1i >= img_w
+                or y1i >= img_h
+            ):
+                crop = np.zeros((1, 1), dtype=bool)
+                crop_h = 1
+                crop_w = 1
+            else:
+                x2c = int(max(0, min(x2i, img_w - 1)))
+                y2c = int(max(0, min(y2i, img_h - 1)))
+                crop = masks[mask_idx, y1c : y2c + 1, x1c : x2c + 1]
+                crop_h = y2c - y1c + 1
+                crop_w = x2c - x1c + 1
+            rles.append(_mask_to_rle_counts(crop))
+            crop_shapes_list.append((crop_h, crop_w))
+            offsets_list.append((x1c, y1c))
+
+        crop_shapes = np.array(crop_shapes_list, dtype=np.int32)
+        offsets = np.array(offsets_list, dtype=np.int32)
+        return cls(rles, crop_shapes, offsets, image_shape)
+
+    @classmethod
+    def from_coco_rle(
+        cls,
+        rles: Sequence[Mapping[str, Any]],
+        xyxy: npt.NDArray[np.floating],
+        image_shape: tuple[int, int],
+    ) -> CompactMask:
+        """Create a :class:`CompactMask` from full-frame COCO RLE masks.
+
+        Transcodes full-image COCO RLE payloads into the crop-scoped RLE format
+        used by :class:`CompactMask`. The conversion uses run-length arithmetic
+        scoped by ``xyxy`` boxes and does not materialise a dense ``(N, H, W)``
+        mask stack.
+
+        Args:
+            rles: Sequence of COCO RLE dictionaries. Each dictionary must contain
+                ``"size"`` as ``[height, width]`` and ``"counts"`` as compressed
+                counts (``str`` or ``bytes``) or uncompressed integer run lengths.
+            xyxy: Bounding boxes of shape ``(N, 4)`` in ``[x1, y1, x2, y2]``
+                format. Max coordinates follow supervision's inclusive convention.
+            image_shape: ``(H, W)`` of the full image. This must match every RLE
+                ``"size"`` value.
+
+        Returns:
+            A new :class:`CompactMask` instance.
+
+        Raises:
+            ValueError: If the RLE payloads are malformed, are not aligned with
+                ``xyxy``, or their sizes/counts do not match ``image_shape``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> # 4x4 image with a 2x2 True block at the top-left corner.
+            >>> # Uncompressed F-order COCO counts: F=0, T=2, F=2, T=2, F=10
+            >>> # (column-major: col0=[T,T,F,F], col1=[T,T,F,F], cols2-3 all F).
+            >>> rles = [{"size": [4, 4], "counts": [0, 2, 2, 2, 10]}]
+            >>> xyxy = np.array([[0, 0, 3, 3]], dtype=np.float32)
+            >>> cm = CompactMask.from_coco_rle(rles, xyxy, image_shape=(4, 4))
+            >>> cm.shape
+            (1, 4, 4)
+            >>> cm.area.tolist()
+            [4]
+
+            ```
+        """
+        img_h, img_w = (int(image_shape[0]), int(image_shape[1]))
+        if img_h <= 0 or img_w <= 0:
+            raise ValueError("image_shape must contain positive height and width.")
+        if img_h > _MAX_IMAGE_DIMENSION or img_w > _MAX_IMAGE_DIMENSION:
+            raise ValueError(
+                f"image_shape {(img_h, img_w)} exceeds the maximum allowed dimension "
+                f"of {_MAX_IMAGE_DIMENSION} pixels per side."
+            )
+
+        xyxy_arr = np.asarray(xyxy)
+        if xyxy_arr.shape != (len(rles), 4):
+            raise ValueError(
+                "xyxy must have shape (N, 4), where N matches the number of RLEs."
+            )
+
+        if len(rles) == 0:
+            return cls(
+                [],
+                np.empty((0, 2), dtype=np.int32),
+                np.empty((0, 2), dtype=np.int32),
+                (img_h, img_w),
+            )
+
+        crop_rles: list[npt.NDArray[np.int32]] = []
+        crop_shapes_list: list[tuple[int, int]] = []
+        offsets_list: list[tuple[int, int]] = []
+
+        for mask_idx, rle in enumerate(rles):
+            if not isinstance(rle, Mapping):
+                raise ValueError("Each RLE payload must be a mapping.")
+            if "size" not in rle or "counts" not in rle:
+                raise ValueError("Each RLE payload must contain 'size' and 'counts'.")
+
+            try:
+                # COCO standard: size=[height, width] (h,w order per pycocotools spec)
+                rle_h, rle_w = rle["size"]
+                rle_h = int(rle_h)
+                rle_w = int(rle_w)
+            except (TypeError, ValueError) as exc:
+                raise ValueError("RLE size must be [height, width].") from exc
+
+            if (rle_h, rle_w) != (img_h, img_w):
+                raise ValueError(
+                    f"RLE size {(rle_h, rle_w)} must match image_shape "
+                    f"{(img_h, img_w)}."
+                )
+
+            counts = _coco_rle_counts_to_array(rle["counts"])
+            if int(np.sum(counts, dtype=np.int64)) != img_h * img_w:
+                raise ValueError(
+                    "The sum of COCO RLE counts must match the image area."
+                )
+
+            x1, y1, x2, y2 = xyxy_arr[mask_idx]
+            x1i, y1i, x2i, y2i = int(x1), int(y1), int(x2), int(y2)
+            x1c = max(0, min(x1i, img_w - 1))
+            y1c = max(0, min(y1i, img_h - 1))
+
+            if (
+                x2i < x1i
+                or y2i < y1i
+                or x2i < 0
+                or y2i < 0
+                or x1i >= img_w
+                or y1i >= img_h
+            ):
+                crop_rles.append(np.array([1], dtype=np.int32))
+                crop_shapes_list.append((1, 1))
+                offsets_list.append((x1c, y1c))
+                continue
+
+            x2c = max(0, min(x2i, img_w - 1))
+            y2c = max(0, min(y2i, img_h - 1))
+            crop_h = y2c - y1c + 1
+            crop_w = x2c - x1c + 1
+
+            if img_h * img_w <= _SMALL_IMAGE_DENSE_THRESHOLD:
+                # Small image: vectorised numpy decode avoids the O(img_w)-column
+                # Python loop. Decode RLE to flat F-order bool, extract crop, and
+                # re-encode directly.
+                ends = np.cumsum(counts, dtype=np.int64)
+                starts = ends - counts.astype(np.int64)
+                # Mark True runs (odd-indexed) via difference-array decode (O(R)).
+                true_starts = starts[1::2]
+                true_ends = ends[1::2]
+                if true_starts.size > 0:
+                    indicator = np.zeros(img_h * img_w + 1, dtype=np.int32)
+                    np.add.at(indicator, true_starts, 1)
+                    np.add.at(indicator, true_ends, -1)
+                    # cumsum in int32 avoids int8 overflow; cast to uint8 (0/1).
+                    flat = np.cumsum(indicator[:-1], dtype=np.int32).astype(np.uint8)
+                else:
+                    flat = np.zeros(img_h * img_w, dtype=np.uint8)
+                # Extract crop: reshape to (img_w, img_h) F-order view, slice.
+                flat_crop = flat.reshape(img_w, img_h)[
+                    x1c : x2c + 1, y1c : y2c + 1
+                ].ravel()
+                # RLE-encode the flat crop: find value-change positions.
+                change_pos = np.where(np.diff(flat_crop.view(np.int8)))[0] + 1
+                boundaries = np.concatenate([[0], change_pos, [len(flat_crop)]])
+                run_lens = np.diff(boundaries)
+                if flat_crop[0]:
+                    run_lens = np.concatenate([[0], run_lens])
+                crop_rle_arr = run_lens.astype(np.int32)
+            else:
+                cols = _rle_split_cols(counts, img_h, img_w, x_start=x1c, x_stop=x2c)
+                selected_columns = [_rle_trim_col_runs(col, y1c, y2c) for col in cols]
+                crop_rle_arr = _rle_join_cols(selected_columns, crop_h * crop_w)
+
+            crop_rles.append(crop_rle_arr)
+            crop_shapes_list.append((crop_h, crop_w))
+            offsets_list.append((x1c, y1c))
+
+        crop_shapes = np.array(crop_shapes_list, dtype=np.int32)
+        offsets = np.array(offsets_list, dtype=np.int32)
+        return cls(crop_rles, crop_shapes, offsets, (img_h, img_w))
+
+    # ------------------------------------------------------------------
+    # Materialisation
+    # ------------------------------------------------------------------
+
+    def to_dense(self) -> npt.NDArray[np.bool_]:
+        """Materialise all masks as a dense ``(N, H, W)`` boolean array.
+
+        Returns:
+            Boolean array of shape ``(N, H, W)``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 50, 50), dtype=bool)
+            >>> masks[0, 10:20, 10:30] = True
+            >>> xyxy = np.array([[10, 10, 29, 19]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(50, 50))
+            >>> cm.to_dense().shape
+            (1, 50, 50)
+
+            ```
+        """
+        num_masks = len(self._rles)
+        img_h, img_w = self._image_shape
+        result: npt.NDArray[np.bool_] = np.zeros((num_masks, img_h, img_w), dtype=bool)
+        for mask_idx in range(num_masks):
+            crop_h, crop_w = (
+                int(self._crop_shapes[mask_idx, 0]),
+                int(self._crop_shapes[mask_idx, 1]),
+            )
+            x1, y1 = int(self._offsets[mask_idx, 0]), int(self._offsets[mask_idx, 1])
+            crop = _rle_counts_to_mask(self._rles[mask_idx], crop_h, crop_w)
+            result[mask_idx, y1 : y1 + crop_h, x1 : x1 + crop_w] = crop
+        return result
+
+    def crop(self, index: int) -> npt.NDArray[np.bool_]:
+        """Decode a single mask crop without allocating the full image array.
+
+        This is an O(crop_area) operation — ideal for annotators that only
+        need the cropped region.
+
+        Args:
+            index: Index of the mask to decode.
+
+        Returns:
+            Boolean array of shape ``(crop_h, crop_w)``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 100, 100), dtype=bool)
+            >>> masks[0, 20:30, 10:40] = True
+            >>> xyxy = np.array([[10, 20, 39, 29]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100))
+            >>> cm.crop(0).shape
+            (10, 30)
+
+            ```
+        """
+        crop_h = int(self._crop_shapes[index, 0])
+        crop_w = int(self._crop_shapes[index, 1])
+        return _rle_counts_to_mask(self._rles[index], crop_h, crop_w)
+
+    # ------------------------------------------------------------------
+    # Sequence / array protocol
+    # ------------------------------------------------------------------
+
+    def __len__(self) -> int:
+        """Return the number of masks.
+
+        Returns:
+            Number of masks N.
+
+        Examples:
+            ```pycon
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> import numpy as np
+            >>> cm = CompactMask(
+            ...     [], np.empty((0, 2), dtype=np.int32),
+            ...     np.empty((0, 2), dtype=np.int32), (100, 100))
+            >>> len(cm)
+            0
+
+            ```
+        """
+        return len(self._rles)
+
+    def __iter__(self) -> Iterator[npt.NDArray[np.bool_]]:
+        """Iterate over masks as dense ``(H, W)`` boolean arrays."""
+        for mask_idx in range(len(self)):
+            yield self[mask_idx]
+
+    @property
+    def shape(self) -> tuple[int, int, int]:
+        """Return ``(N, H, W)`` matching the dense mask convention.
+
+        Returns:
+            Tuple ``(N, H, W)``.
+
+        Examples:
+            ```pycon
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> import numpy as np
+            >>> cm = CompactMask(
+            ...     [], np.empty((0, 2), dtype=np.int32),
+            ...     np.empty((0, 2), dtype=np.int32), (480, 640))
+            >>> cm.shape
+            (0, 480, 640)
+
+            ```
+        """
+        img_h, img_w = self._image_shape
+        return (len(self), img_h, img_w)
+
+    @property
+    def image_shape(self) -> tuple[int, int]:
+        """Return ``(H, W)`` of the full image this mask is scoped to.
+
+        Returns:
+            Tuple ``(H, W)``.
+
+        Examples:
+            ```pycon
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> import numpy as np
+            >>> cm = CompactMask(
+            ...     [], np.empty((0, 2), dtype=np.int32),
+            ...     np.empty((0, 2), dtype=np.int32), (480, 640))
+            >>> cm.image_shape
+            (480, 640)
+
+            ```
+        """
+        return self._image_shape
+
+    @property
+    def offsets(self) -> npt.NDArray[np.int32]:
+        """Return per-mask crop origins as ``(x1, y1)`` integer offsets.
+
+        Returns:
+            Array of shape ``(N, 2)`` with ``int32`` offsets.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> masks[0, 2:4, 3:5] = True
+            >>> xyxy = np.array([[3, 2, 4, 3]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> cm.offsets.tolist()
+            [[3, 2]]
+
+            ```
+        """
+        return self._offsets
+
+    @property
+    def bbox_xyxy(self) -> npt.NDArray[np.int32]:
+        """Return per-mask inclusive bounding boxes in ``xyxy`` format.
+
+        Boxes are derived from crop metadata:
+        ``x2 = x1 + crop_w - 1``, ``y2 = y1 + crop_h - 1``.
+
+        Returns:
+            Array of shape ``(N, 4)`` with ``int32`` boxes
+            ``[x1, y1, x2, y2]``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> masks[0, 2:5, 3:7] = True
+            >>> xyxy = np.array([[3, 2, 6, 4]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> cm.bbox_xyxy.tolist()
+            [[3, 2, 6, 4]]
+
+            ```
+        """
+        if len(self) == 0:
+            return np.empty((0, 4), dtype=np.int32)
+
+        x1: npt.NDArray[np.int32] = self._offsets[:, 0]
+        y1: npt.NDArray[np.int32] = self._offsets[:, 1]
+        x2: npt.NDArray[np.int32] = x1 + self._crop_shapes[:, 1] - 1
+        y2: npt.NDArray[np.int32] = y1 + self._crop_shapes[:, 0] - 1
+        return np.column_stack((x1, y1, x2, y2)).astype(np.int32, copy=False)
+
+    @property
+    def dtype(self) -> np.dtype[np.bool_]:
+        """Return ``np.dtype(bool)`` — always.
+
+        Returns:
+            ``np.dtype(bool)``.
+
+        Examples:
+            ```pycon
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> import numpy as np
+            >>> cm = CompactMask(
+            ...     [], np.empty((0, 2), dtype=np.int32),
+            ...     np.empty((0, 2), dtype=np.int32), (100, 100))
+            >>> cm.dtype
+            dtype('bool')
+
+            ```
+        """
+        return np.dtype(bool)
+
+    @property
+    def area(self) -> npt.NDArray[np.int64]:
+        """Compute the area (``True`` pixel count) of each mask.
+
+        Note:
+            The implementation iterates over the N individual RLE arrays in a
+            Python loop (one :func:`_rle_area` call per mask). This is negligible
+            for typical N, but callers processing thousands of detections per
+            frame should be aware of the per-mask Python-level overhead.
+
+        Returns:
+            int64 array of shape ``(N,)`` with per-mask pixel counts.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((2, 100, 100), dtype=bool)
+            >>> masks[0, 0:10, 0:10] = True  # 100 pixels
+            >>> masks[1, 0:5, 0:5] = True    # 25 pixels
+            >>> xyxy = np.array([[0, 0, 9, 9], [0, 0, 4, 4]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100))
+            >>> cm.area.tolist()
+            [100, 25]
+
+            ```
+        """
+        return np.array([_rle_area(rle) for rle in self._rles], dtype=np.int64)
+
+    def sum(
+        self, axis: int | tuple[int, ...] | None = None
+    ) -> npt.NDArray[np.int64] | np.int64:
+        """NumPy-compatible sum with a fast path for per-mask area.
+
+        When ``axis=(1, 2)``, returns the per-mask True-pixel count via
+        :attr:`area` without materialising the full dense array.
+
+        Args:
+            axis: Axis or axes to sum over.
+
+        Returns:
+            Sum result matching NumPy semantics.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> masks[0, 0:3, 0:3] = True
+            >>> xyxy = np.array([[0, 0, 2, 2]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> cm.sum(axis=(1, 2)).tolist()
+            [9]
+
+            ```
+        """
+        if axis == (1, 2):
+            return self.area
+        return cast(npt.NDArray[np.int64] | np.int64, self.to_dense().sum(axis=axis))
+
+    @overload
+    def __getitem__(self, index: int | np.integer) -> npt.NDArray[np.bool_]: ...
+
+    @overload
+    def __getitem__(
+        self,
+        index: slice
+        | list[int]
+        | list[bool]
+        | npt.NDArray[np.int_]
+        | npt.NDArray[np.bool_],
+    ) -> CompactMask: ...
+
+    def __getitem__(
+        self,
+        index: (
+            int
+            | np.integer
+            | slice
+            | list[int]
+            | list[bool]
+            | npt.NDArray[np.int_]
+            | npt.NDArray[np.bool_]
+        ),
+    ) -> npt.NDArray[np.bool_] | CompactMask:
+        """Index into the mask collection.
+
+        * ``int`` → dense ``(H, W)`` bool array (for annotators, iterators).
+        * ``slice | list | ndarray`` → new :class:`CompactMask` (for filtering).
+
+        Args:
+            index: An integer returns a dense ``(H, W)`` mask.  Any other
+                supported index type returns a new :class:`CompactMask`.
+
+        Returns:
+            Dense ``(H, W)`` ``np.ndarray`` for integer index, or a new
+            :class:`CompactMask` for all other index types.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((3, 20, 20), dtype=bool)
+            >>> xyxy = np.array(
+            ...     [[0,0,5,5],[5,5,10,10],[10,10,15,15]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(20, 20))
+            >>> cm[0].shape        # int → dense (H, W)
+            (20, 20)
+            >>> len(cm[[0, 2]])    # list → CompactMask
+            2
+
+            ```
+        """
+        if isinstance(index, (int, np.integer)):
+            idx = int(index)
+            img_h, img_w = self._image_shape
+            result: npt.NDArray[np.bool_] = np.zeros((img_h, img_w), dtype=bool)
+            crop_h = int(self._crop_shapes[idx, 0])
+            crop_w = int(self._crop_shapes[idx, 1])
+            x1 = int(self._offsets[idx, 0])
+            y1 = int(self._offsets[idx, 1])
+            crop = _rle_counts_to_mask(self._rles[idx], crop_h, crop_w)
+            result[y1 : y1 + crop_h, x1 : x1 + crop_w] = crop
+            return result
+
+        if isinstance(index, slice):
+            selected_rles = [rle.copy() for rle in self._rles[index]]
+            return CompactMask(
+                selected_rles,
+                self._crop_shapes[index].copy(),
+                self._offsets[index].copy(),
+                self._image_shape,
+            )
+
+        # Boolean selectors and fancy index → convert to integer positions first.
+        if isinstance(index, np.ndarray) and index.dtype == bool:
+            idx_arr = np.where(index)[0]
+        elif isinstance(index, list) and all(
+            isinstance(item, (bool, np.bool_)) for item in index
+        ):
+            idx_arr = np.flatnonzero(np.asarray(index, dtype=bool))
+        else:
+            idx_arr = np.asarray(list(index), dtype=np.intp)
+
+        new_rles = [self._rles[int(mask_idx)].copy() for mask_idx in idx_arr]
+        new_crop_shapes: npt.NDArray[np.int32] = self._crop_shapes[idx_arr].copy()
+        new_offsets: npt.NDArray[np.int32] = self._offsets[idx_arr].copy()
+        return CompactMask(new_rles, new_crop_shapes, new_offsets, self._image_shape)
+
+    def __array__(
+        self, dtype: np.dtype[np.generic] | None = None
+    ) -> npt.NDArray[np.generic]:
+        """NumPy interop: materialise as a dense ``(N, H, W)`` array.
+
+        Called by ``np.asarray(compact_mask)`` and similar NumPy functions.
+
+        Args:
+            dtype: Optional dtype to cast the result to.
+
+        Returns:
+            Dense boolean array of shape ``(N, H, W)``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> xyxy = np.array([[0, 0, 5, 5]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> np.asarray(cm).shape
+            (1, 10, 10)
+
+            ```
+        """
+        result = self.to_dense()
+        if dtype is not None:
+            return result.astype(dtype)
+        return result
+
+    def __eq__(self, other: object) -> bool:
+        """Element-wise equality with another :class:`CompactMask` or ndarray.
+
+        Args:
+            other: Another :class:`CompactMask` or ``np.ndarray``.
+
+        Returns:
+            ``True`` if all masks are pixel-identical.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> xyxy = np.array([[0, 0, 5, 5]], dtype=np.float32)
+            >>> cm1 = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> cm2 = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> cm1 == cm2
+            True
+
+            ```
+        """
+        if isinstance(other, CompactMask):
+            return bool(np.array_equal(self.to_dense(), other.to_dense()))
+        if isinstance(other, np.ndarray):
+            return bool(np.array_equal(self.to_dense(), other))
+        return NotImplemented
+
+    # ------------------------------------------------------------------
+    # Collection utilities
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def merge(masks_list: list[CompactMask]) -> CompactMask:
+        """Concatenate multiple :class:`CompactMask` objects into one.
+
+        All inputs must have the same ``image_shape``.
+
+        Args:
+            masks_list: Non-empty list of :class:`CompactMask` objects.
+
+        Returns:
+            A new :class:`CompactMask` containing every mask from the inputs,
+            in order.
+
+        Raises:
+            ValueError: If ``masks_list`` is empty or image shapes differ.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks1 = np.zeros((2, 50, 50), dtype=bool)
+            >>> masks2 = np.zeros((3, 50, 50), dtype=bool)
+            >>> xyxy1 = np.array([[0,0,10,10],[10,10,20,20]], dtype=np.float32)
+            >>> xyxy2 = np.array(
+            ...     [[0,0,5,5],[5,5,10,10],[10,10,15,15]], dtype=np.float32)
+            >>> cm1 = CompactMask.from_dense(masks1, xyxy1, image_shape=(50, 50))
+            >>> cm2 = CompactMask.from_dense(masks2, xyxy2, image_shape=(50, 50))
+            >>> len(CompactMask.merge([cm1, cm2]))
+            5
+
+            ```
+        """
+        if not masks_list:
+            raise ValueError("Cannot merge an empty list of CompactMask objects.")
+
+        image_shape = masks_list[0]._image_shape
+        for cm in masks_list[1:]:
+            if cm._image_shape != image_shape:
+                raise ValueError(
+                    f"Cannot merge CompactMask objects with different image shapes: "
+                    f"{image_shape} vs {cm._image_shape}"
+                )
+
+        # list.extend is a C-level call and avoids the per-element Python
+        # bytecode overhead of a flat list comprehension.  This matters under
+        # GIL contention when multiple threads call merge concurrently.
+        new_rles: list[npt.NDArray[np.int32]] = []
+        for cm in masks_list:
+            new_rles.extend(cm._rles)
+
+        # np.concatenate handles (0, 2) arrays correctly.
+        # No .astype() needed — _crop_shapes and _offsets are already int32.
+        new_crop_shapes: npt.NDArray[np.int32] = np.concatenate(
+            [cm._crop_shapes for cm in masks_list], axis=0
+        )
+        new_offsets: npt.NDArray[np.int32] = np.concatenate(
+            [cm._offsets for cm in masks_list], axis=0
+        )
+
+        return CompactMask(new_rles, new_crop_shapes, new_offsets, image_shape)
+
+    def repack(self) -> CompactMask:
+        """Re-encode all masks using tight bounding boxes.
+
+        When the original ``xyxy`` boxes are padded or loose — common with
+        object-detector outputs and full-image boxes used in tests — each RLE
+        crop encodes more background (``False``) pixels than necessary.  This
+        method decodes every crop, trims it to the minimal rectangle that
+        contains all ``True`` pixels, and re-encodes.  All-``False`` masks are
+        normalised to a ``1x1`` all-``False`` crop.
+
+        The call is O(sum of crop areas) — suitable as a one-time cleanup
+        after accumulating many merges (e.g. after
+        :class:`~supervision.detection.tools.inference_slicer.InferenceSlicer`
+        tiles are merged).
+
+        Returns:
+            A new :class:`CompactMask` with minimal-area crops and updated
+            offsets.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 10, 10), dtype=bool)
+            >>> masks[0, 3:7, 3:7] = True
+            >>> # Deliberately loose bbox: covers the full image.
+            >>> xyxy = np.array([[0, 0, 9, 9]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(10, 10))
+            >>> repacked = cm.repack()
+            >>> repacked.offsets.tolist()  # tight origin: x1=3, y1=3
+            [[3, 3]]
+
+            ```
+        """
+        num_masks = len(self._rles)
+        if num_masks == 0:
+            return CompactMask(
+                [],
+                np.empty((0, 2), dtype=np.int32),
+                np.empty((0, 2), dtype=np.int32),
+                self._image_shape,
+            )
+
+        new_rles: list[npt.NDArray[np.int32]] = []
+        new_crop_shapes_list: list[tuple[int, int]] = []
+        new_offsets_list: list[tuple[int, int]] = []
+
+        for mask_idx in range(num_masks):
+            crop = self.crop(mask_idx)
+            x1_off = int(self._offsets[mask_idx, 0])
+            y1_off = int(self._offsets[mask_idx, 1])
+
+            rows_any = np.any(crop, axis=1)
+            cols_any = np.any(crop, axis=0)
+
+            if not rows_any.any():
+                # All-False: normalise to 1x1 to avoid zero-sized arrays.
+                new_rles.append(_mask_to_rle_counts(np.zeros((1, 1), dtype=bool)))
+                new_crop_shapes_list.append((1, 1))
+                new_offsets_list.append((x1_off, y1_off))
+                continue
+
+            y_indices = np.where(rows_any)[0]
+            x_indices = np.where(cols_any)[0]
+            y_min, y_max = int(y_indices[0]), int(y_indices[-1])
+            x_min, x_max = int(x_indices[0]), int(x_indices[-1])
+
+            tight = crop[y_min : y_max + 1, x_min : x_max + 1]
+            new_rles.append(_mask_to_rle_counts(tight))
+            new_crop_shapes_list.append((y_max - y_min + 1, x_max - x_min + 1))
+            new_offsets_list.append((x1_off + x_min, y1_off + y_min))
+
+        return CompactMask(
+            new_rles,
+            np.array(new_crop_shapes_list, dtype=np.int32),
+            np.array(new_offsets_list, dtype=np.int32),
+            self._image_shape,
+        )
+
+    # ------------------------------------------------------------------
+    # Slicer support
+    # ------------------------------------------------------------------
+
+    def with_offset(
+        self,
+        dx: int,
+        dy: int,
+        new_image_shape: tuple[int, int],
+    ) -> CompactMask:
+        """Return a new :class:`CompactMask` with adjusted offsets and image shape.
+
+        Used by :class:`~supervision.detection.tools.inference_slicer.InferenceSlicer`
+        to relocate tile-local masks into full-image coordinates without
+        materialising the dense ``(N, H, W)`` array.
+
+        Args:
+            dx: Pixels to add to every mask's ``x1`` offset.
+            dy: Pixels to add to every mask's ``y1`` offset.
+            new_image_shape: ``(H, W)`` of the full (destination) image.
+
+        Returns:
+            New :class:`CompactMask` with updated offsets and image shape.
+            Crops are clipped to stay inside ``new_image_shape``; masks fully
+            outside are represented as ``1x1`` all-False crops.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 20, 20), dtype=bool)
+            >>> xyxy = np.array([[5, 5, 15, 15]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(20, 20))
+            >>> cm2 = cm.with_offset(100, 200, new_image_shape=(400, 400))
+            >>> cm2.offsets[0].tolist()
+            [105, 205]
+
+            ```
+        """
+        new_h, new_w = new_image_shape
+        if new_h <= 0 or new_w <= 0:
+            raise ValueError("new_image_shape must contain positive dimensions")
+
+        num_masks = len(self)
+        if num_masks == 0:
+            return CompactMask(
+                [],
+                np.empty((0, 2), dtype=np.int32),
+                np.empty((0, 2), dtype=np.int32),
+                new_image_shape,
+            )
+
+        # Vectorised bounds check: compute every new [x1,y1,x2,y2] at once.
+        # For the common case (InferenceSlicer tiles that fit fully inside the
+        # new canvas) this catches the "no clipping needed" path in O(N) numpy
+        # without touching any RLE data.
+        new_offsets: npt.NDArray[np.int32] = self._offsets + np.array(
+            [dx, dy], dtype=np.int32
+        )
+        x1s = new_offsets[:, 0]
+        y1s = new_offsets[:, 1]
+        x2s = x1s + self._crop_shapes[:, 1] - 1
+        y2s = y1s + self._crop_shapes[:, 0] - 1
+
+        needs_clip: npt.NDArray[np.bool_] = (
+            (x1s < 0) | (y1s < 0) | (x2s >= new_w) | (y2s >= new_h)
+        )
+
+        if not needs_clip.any():
+            # Fast path: pure offset arithmetic, no decode/re-encode needed.
+            return CompactMask(
+                list(self._rles),
+                self._crop_shapes.copy(),
+                new_offsets,
+                new_image_shape,
+            )
+
+        # Slow path: only decode+clip+re-encode the masks that actually overflow.
+        out_rles: list[npt.NDArray[np.int32]] = []
+        out_crop_shapes: list[tuple[int, int]] = []
+        out_offsets_list: list[tuple[int, int]] = []
+
+        for mask_idx in range(num_masks):
+            x1 = int(x1s[mask_idx])
+            y1 = int(y1s[mask_idx])
+            x2 = int(x2s[mask_idx])
+            y2 = int(y2s[mask_idx])
+
+            if not needs_clip[mask_idx]:
+                out_rles.append(self._rles[mask_idx])
+                out_crop_shapes.append(
+                    (
+                        int(self._crop_shapes[mask_idx, 0]),
+                        int(self._crop_shapes[mask_idx, 1]),
+                    )
+                )
+                out_offsets_list.append((x1, y1))
+                continue
+
+            ix1 = max(0, x1)
+            iy1 = max(0, y1)
+            ix2 = min(new_w - 1, x2)
+            iy2 = min(new_h - 1, y2)
+
+            if ix1 > ix2 or iy1 > iy2:
+                anchor_x = min(max(x1, 0), new_w - 1)
+                anchor_y = min(max(y1, 0), new_h - 1)
+                out_rles.append(_mask_to_rle_counts(np.zeros((1, 1), dtype=bool)))
+                out_crop_shapes.append((1, 1))
+                out_offsets_list.append((anchor_x, anchor_y))
+                continue
+
+            crop = self.crop(mask_idx)
+            clipped = crop[iy1 - y1 : iy2 - y1 + 1, ix1 - x1 : ix2 - x1 + 1]
+            out_rles.append(_mask_to_rle_counts(clipped))
+            out_crop_shapes.append((iy2 - iy1 + 1, ix2 - ix1 + 1))
+            out_offsets_list.append((ix1, iy1))
+
+        return CompactMask(
+            out_rles,
+            np.array(out_crop_shapes, dtype=np.int32),
+            np.array(out_offsets_list, dtype=np.int32),
+            new_image_shape,
+        )
+
+    # ------------------------------------------------------------------
+    # Resize
+    # ------------------------------------------------------------------
+
+    def resize(self, new_image_shape: tuple[int, int]) -> CompactMask:
+        """Return a new CompactMask scaled to a different image resolution.
+
+        Each crop mask is resized with nearest-neighbour interpolation.
+        Sparse masks use direct RLE arithmetic (:func:`_rle_resize`); dense
+        masks fall back to ``cv2.resize(INTER_NEAREST)``.  Offsets and crop
+        dimensions are scaled proportionally to the new image size.
+
+        Performance notes:
+
+        * Coordinate arithmetic is fully vectorised (no Python loop over N).
+        * All-``False`` crops skip decode/resize entirely.
+        * For N >= 8, resize runs in a thread pool — NumPy and OpenCV
+          release the GIL so crops execute in parallel on multi-core CPUs.
+
+        Args:
+            new_image_shape: ``(H, W)`` of the target image.
+
+        Returns:
+            New :class:`CompactMask` with updated ``image_shape``, scaled
+            offsets, scaled crop shapes, and re-encoded RLE crops.
+
+        Raises:
+            ValueError: If any dimension in *new_image_shape* is ``<= 0``.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision.detection.compact_mask import CompactMask
+            >>> masks = np.zeros((1, 100, 100), dtype=bool)
+            >>> masks[0, 20:40, 30:60] = True
+            >>> xyxy = np.array([[30, 20, 59, 39]], dtype=np.float32)
+            >>> cm = CompactMask.from_dense(masks, xyxy, image_shape=(100, 100))
+            >>> small = cm.resize((50, 50))
+            >>> small.shape
+            (1, 50, 50)
+            >>> small.offsets[0].tolist()
+            [15, 10]
+
+            ```
+        """
+        from concurrent.futures import ThreadPoolExecutor
+
+        new_h, new_w = new_image_shape
+        if new_h <= 0 or new_w <= 0:
+            raise ValueError("new_image_shape must contain positive dimensions")
+
+        # fast path — identity resize; list() creates a new container but the
+        # individual RLE numpy arrays are shared (shallow copy).  Callers must
+        # not mutate returned RLE arrays in-place.
+        if (new_h, new_w) == self._image_shape:
+            return CompactMask(
+                list(self._rles),
+                self._crop_shapes.copy(),
+                self._offsets.copy(),
+                new_image_shape,
+            )
+
+        # empty guard
+        if len(self) == 0:
+            return CompactMask(
+                [],
+                np.empty((0, 2), dtype=np.int32),
+                np.empty((0, 2), dtype=np.int32),
+                new_image_shape,
+            )
+
+        img_h, img_w = self._image_shape
+        sx = new_w / img_w
+        sy = new_h / img_h
+
+        # L1 — vectorised coordinate arithmetic; no Python loop over N masks.
+        x1s = self._offsets[:, 0].astype(np.float64)
+        y1s = self._offsets[:, 1].astype(np.float64)
+        x2s = x1s + self._crop_shapes[:, 1] - 1  # inclusive right edge
+        y2s = y1s + self._crop_shapes[:, 0] - 1  # inclusive bottom edge
+
+        new_x1s = np.clip(np.round(x1s * sx), 0, new_w - 1).astype(np.int32)
+        new_y1s = np.clip(np.round(y1s * sy), 0, new_h - 1).astype(np.int32)
+        new_x2s = np.clip(np.round(x2s * sx), 0, new_w - 1).astype(np.int32)
+        new_y2s = np.clip(np.round(y2s * sy), 0, new_h - 1).astype(np.int32)
+        new_crop_ws: npt.NDArray[np.int32] = np.maximum(
+            1, new_x2s - new_x1s + 1
+        ).astype(np.int32)
+        new_crop_hs: npt.NDArray[np.int32] = np.maximum(
+            1, new_y2s - new_y1s + 1
+        ).astype(np.int32)
+
+        # L2b — parallel per-crop resize; NumPy and OpenCV release the GIL.
+        orig_crop_hs = self._crop_shapes[:, 0]
+        orig_crop_ws = self._crop_shapes[:, 1]
+
+        args = [
+            (
+                self._rles[i],
+                int(orig_crop_hs[i]),
+                int(orig_crop_ws[i]),
+                int(new_crop_hs[i]),
+                int(new_crop_ws[i]),
+            )
+            for i in range(len(self))
+        ]
+
+        n = len(self)
+        if n >= _PARALLEL_THRESHOLD:
+            with ThreadPoolExecutor(max_workers=min(n, os.cpu_count() or 4)) as pool:
+                new_rles: list[npt.NDArray[np.int32]] = list(
+                    pool.map(lambda a: _resize_crop(*a), args)
+                )
+        else:
+            new_rles = [_resize_crop(*a) for a in args]
+
+        new_crop_shapes = np.column_stack((new_crop_hs, new_crop_ws)).astype(np.int32)
+        new_offsets = np.column_stack((new_x1s, new_y1s)).astype(np.int32)
+        return CompactMask(new_rles, new_crop_shapes, new_offsets, new_image_shape)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/core.py b/.venv/lib/python3.12/site-packages/supervision/detection/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..a38bae76cc3123f5802972f319eb359b0e1dc512
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/core.py
@@ -0,0 +1,3604 @@
+from __future__ import annotations
+
+import warnings
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from functools import reduce
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void
+
+from supervision.config import (
+    CLASS_NAME_DATA_FIELD,
+    ORIENTED_BOX_COORDINATES,
+)
+from supervision.detection._geometry_dispatch import detection_area, detection_iou
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.tools.transformers import (
+    process_transformers_detection_result,
+    process_transformers_v4_segmentation_result,
+    process_transformers_v5_segmentation_result,
+)
+from supervision.detection.utils._typing import (
+    _DetectionDataType,
+    _DetectionDataValueType,
+    _MetadataType,
+)
+from supervision.detection.utils.boxes import (
+    _oriented_box_anchors,
+    _sort_box_corners,
+    xyxyxyxy_to_xyxy,
+)
+from supervision.detection.utils.converters import (
+    mask_to_xyxy,
+    polygon_to_mask,
+    rle_to_mask,
+    xywh_to_xyxy,
+)
+from supervision.detection.utils.internal import (
+    extract_ultralytics_masks,
+    get_data_item,
+    is_data_equal,
+    is_metadata_equal,
+    merge_data,
+    merge_metadata,
+    process_roboflow_result,
+)
+from supervision.detection.utils.iou_and_nms import (
+    OverlapMetric,
+    box_non_max_merge,
+    box_non_max_suppression,
+    box_soft_non_max_suppression,
+    mask_non_max_merge,
+    mask_non_max_suppression,
+    mask_soft_non_max_suppression,
+    oriented_box_non_max_merge,
+    oriented_box_non_max_suppression,
+)
+from supervision.detection.utils.masks import (
+    calculate_masks_centroids,
+)
+from supervision.detection.vlm import (
+    LMM,
+    VLM,
+    _validate_vlm_parameters,
+    from_deepseek_vl_2,
+    from_florence_2,
+    from_google_gemini_2_0,
+    from_google_gemini_2_5,
+    from_google_gemini_3_5,
+    from_moondream,
+    from_paligemma,
+    from_qwen_2_5_vl,
+    from_qwen_3_vl,
+)
+from supervision.geometry.core import Position
+from supervision.utils.internal import (
+    SupervisionWarnings,
+    get_instance_variables,
+    warn_deprecated,
+)
+from supervision.validators import (
+    _validate_data,
+    _validate_detections_fields,
+    _validate_resolution,
+)
+
+
+@dataclass
+class Detections:
+    """
+    The `sv.Detections` class in the Supervision library standardizes results from
+    various object detection and segmentation models into a consistent format. This
+    class simplifies data manipulation and filtering, providing a uniform API for
+    integration with Supervision [trackers](/trackers/), [annotators](/latest/detection/annotators/), and [tools](/detection/tools/line_zone/).
+
+    === "RF-DETR"
+
+        [RF-DETR](https://github.com/roboflow/rf-detr)'s `predict` method returns a
+        `sv.Detections` object directly, so no conversion step is needed.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from rfdetr import RFDETRMedium
+
+        model = RFDETRMedium()
+        image = cv2.imread("")
+        detections = model.predict(image[:, :, ::-1])
+        ```
+
+    === "Inference"
+
+        Use [`sv.Detections.from_inference`](/detection/core/#supervision.detection.core.Detections.from_inference)
+        method, which accepts model results from both detection and segmentation models.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from inference import get_model
+
+        model = get_model(model_id="rfdetr-small")
+        image = cv2.imread("")
+        results = model.infer(image)[0]
+        detections = sv.Detections.from_inference(results)
+        ```
+
+    === "Ultralytics"
+
+        Use [`sv.Detections.from_ultralytics`](/detection/core/#supervision.detection.core.Detections.from_ultralytics)
+        method, which accepts model results from both detection and segmentation models.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from ultralytics import YOLO
+
+        model = YOLO("yolov8n.pt")
+        image = cv2.imread("")
+        results = model(image)[0]
+        detections = sv.Detections.from_ultralytics(results)
+        ```
+
+    === "Transformers"
+
+        Use [`sv.Detections.from_transformers`](/detection/core/#supervision.detection.core.Detections.from_transformers)
+        method, which accepts model results from both detection and segmentation models.
+
+        ```python
+        import torch
+        import supervision as sv
+        from PIL import Image
+        from transformers import DetrImageProcessor, DetrForObjectDetection
+
+        processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
+        model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
+
+        image = Image.open("")
+        inputs = processor(images=image, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = model(**inputs)
+
+        width, height = image.size
+        target_size = torch.tensor([[height, width]])
+        results = processor.post_process_object_detection(
+            outputs=outputs, target_sizes=target_size)[0]
+        detections = sv.Detections.from_transformers(
+            transformers_results=results,
+            id2label=model.config.id2label)
+        ```
+
+    Attributes:
+        xyxy: An array of shape `(n, 4)` containing
+            the bounding boxes coordinates in format `[x1, y1, x2, y2]`
+        mask: An array of shape `(n, H, W)` containing the segmentation masks
+            (`bool` data type), or `None` when masks are not available, or as
+            :class:`~supervision.detection.compact_mask.CompactMask`.
+        confidence: An array of shape `(n,)` containing the confidence scores
+            of the detections, or `None` when confidence values are not available.
+        class_id: An array of shape `(n,)` containing the class ids of the
+            detections, or `None` when class ids are not available.
+        tracker_id: An array of shape `(n,)` containing the tracker ids of the
+            detections, or `None` when tracker ids are not available.
+        data: A dictionary containing additional
+            data where each key is a string representing the data type, and the value
+            is either a NumPy array or a list of corresponding data.
+        metadata: A dictionary containing collection-level metadata
+            that applies to the entire set of detections. This may include information such
+            as the video name, camera parameters, timestamp, or other global metadata.
+    """  # noqa: E501 // docs
+
+    xyxy: npt.NDArray[np.number]
+    mask: npt.NDArray[np.bool_] | CompactMask | None = None
+    confidence: npt.NDArray[np.floating] | None = None
+    class_id: npt.NDArray[np.integer] | None = None
+    tracker_id: npt.NDArray[np.integer] | None = None
+    data: _DetectionDataType = field(default_factory=dict)
+    metadata: _MetadataType = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        _validate_detections_fields(
+            xyxy=self.xyxy,
+            mask=self.mask,
+            confidence=self.confidence,
+            class_id=self.class_id,
+            tracker_id=self.tracker_id,
+            data=self.data,
+        )
+
+    def __len__(self) -> int:
+        """
+        Returns the number of detections in the Detections object.
+        """
+        return len(self.xyxy)
+
+    def __iter__(
+        self,
+    ) -> Iterator[
+        tuple[
+            npt.NDArray[np.number],
+            npt.NDArray[np.bool_] | None,
+            np.generic | None,
+            np.generic | None,
+            np.generic | None,
+            _DetectionDataType,
+        ]
+    ]:
+        """
+        Iterates over the Detections object and yield a tuple of
+        `(xyxy, mask, confidence, class_id, tracker_id, data)` for each detection.
+        """
+        for i in range(len(self.xyxy)):
+            yield (
+                self.xyxy[i],
+                self.mask[i] if self.mask is not None else None,
+                self.confidence[i] if self.confidence is not None else None,
+                self.class_id[i] if self.class_id is not None else None,
+                self.tracker_id[i] if self.tracker_id is not None else None,
+                get_data_item(self.data, i),
+            )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Detections):
+            return NotImplemented
+
+        def array_equal_or_none(
+            a: npt.NDArray[np.generic] | None,
+            b: npt.NDArray[np.generic] | None,
+        ) -> bool:
+            if a is None or b is None:
+                return a is b
+            return bool(np.array_equal(a, b))
+
+        def mask_equal(
+            a: npt.NDArray[np.generic] | CompactMask | None,
+            b: npt.NDArray[np.generic] | CompactMask | None,
+        ) -> bool:
+            if a is None or b is None:
+                return a is b
+            if isinstance(a, CompactMask):
+                return bool(a == b)
+            if isinstance(b, CompactMask):
+                return bool(b == a)
+            return bool(np.array_equal(a, b))
+
+        return all(
+            [
+                np.array_equal(self.xyxy, other.xyxy),
+                mask_equal(self.mask, other.mask),
+                array_equal_or_none(self.class_id, other.class_id),
+                array_equal_or_none(self.confidence, other.confidence),
+                array_equal_or_none(self.tracker_id, other.tracker_id),
+                is_data_equal(self.data, other.data),
+                is_metadata_equal(self.metadata, other.metadata),
+            ]
+        )
+
+    @classmethod
+    def from_yolov5(cls, yolov5_results: Any) -> Detections:
+        """
+        Creates a Detections instance from a
+        [YOLOv5](https://github.com/ultralytics/yolov5) inference result.
+
+        Args:
+            yolov5_results: The output Detections instance from YOLOv5.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import torch
+            import supervision as sv
+
+            image = cv2.imread("")
+            model = torch.hub.load('ultralytics/yolov5', 'yolov5s')
+            result = model(image)
+            detections = sv.Detections.from_yolov5(result)
+            ```
+        """
+        yolov5_detections_predictions = yolov5_results.pred[0].cpu().cpu().numpy()
+
+        return cls(
+            xyxy=yolov5_detections_predictions[:, :4],
+            confidence=yolov5_detections_predictions[:, 4],
+            class_id=yolov5_detections_predictions[:, 5].astype(int),
+        )
+
+    @classmethod
+    def from_ultralytics(cls, ultralytics_results: Any) -> Detections:
+        """
+        Creates a `sv.Detections` instance from a
+        [YOLOv8](https://github.com/ultralytics/ultralytics) inference result.
+
+        !!! Note
+
+            `from_ultralytics` is compatible with
+            [detection](https://docs.ultralytics.com/tasks/detect/),
+            [segmentation](https://docs.ultralytics.com/tasks/segment/), and
+            [OBB](https://docs.ultralytics.com/tasks/obb/) models.
+
+        Args:
+            ultralytics_results: The output Results instance from Ultralytics.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from ultralytics import YOLO
+
+            image = cv2.imread("")
+            model = YOLO('yolov8s.pt')
+            results = model(image)[0]
+            detections = sv.Detections.from_ultralytics(results)
+            ```
+        """
+
+        if hasattr(ultralytics_results, "obb") and ultralytics_results.obb is not None:
+            class_id = ultralytics_results.obb.cls.cpu().numpy().astype(int)
+            class_names = np.array([ultralytics_results.names[i] for i in class_id])
+            oriented_box_coordinates = ultralytics_results.obb.xyxyxyxy.cpu().numpy()
+            return cls(
+                xyxy=ultralytics_results.obb.xyxy.cpu().numpy(),
+                confidence=ultralytics_results.obb.conf.cpu().numpy(),
+                class_id=class_id,
+                tracker_id=(
+                    ultralytics_results.obb.id.int().cpu().numpy()
+                    if ultralytics_results.obb.id is not None
+                    else None
+                ),
+                data={
+                    ORIENTED_BOX_COORDINATES: oriented_box_coordinates,
+                    CLASS_NAME_DATA_FIELD: class_names,
+                },
+            )
+
+        if hasattr(ultralytics_results, "boxes") and ultralytics_results.boxes is None:
+            masks = extract_ultralytics_masks(ultralytics_results)
+            if masks is None:
+                empty = cls.empty()
+                empty.data = {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)}
+                return empty
+            return cls(
+                xyxy=mask_to_xyxy(masks),
+                mask=masks,
+                class_id=np.zeros(len(masks), dtype=int),
+            )
+
+        if (
+            hasattr(ultralytics_results, "boxes")
+            and ultralytics_results.boxes is not None
+        ):
+            class_id = ultralytics_results.boxes.cls.cpu().numpy().astype(int)
+            class_names = np.array([ultralytics_results.names[i] for i in class_id])
+            return cls(
+                xyxy=ultralytics_results.boxes.xyxy.cpu().numpy(),
+                confidence=ultralytics_results.boxes.conf.cpu().numpy(),
+                class_id=class_id,
+                mask=extract_ultralytics_masks(ultralytics_results),
+                tracker_id=(
+                    ultralytics_results.boxes.id.int().cpu().numpy()
+                    if ultralytics_results.boxes.id is not None
+                    else None
+                ),
+                data={CLASS_NAME_DATA_FIELD: class_names},
+            )
+
+        empty = cls.empty()
+        empty.data = {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)}
+        return empty
+
+    @classmethod
+    def from_yolo_nas(cls, yolo_nas_results: Any) -> Detections:
+        """
+        Creates a Detections instance from a
+        [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS.md)
+        inference result.
+
+        Args:
+            yolo_nas_results: The output Results instance from YOLO-NAS.
+                ImageDetectionPrediction is coming from
+                'super_gradients.training.models.prediction_results'.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            from super_gradients.training import models
+            import supervision as sv
+
+            image = cv2.imread("")
+            model = models.get('yolo_nas_l', pretrained_weights="coco")
+
+            result = list(model.predict(image, conf=0.35))[0]
+            detections = sv.Detections.from_yolo_nas(result)
+            ```
+        """
+        if np.asarray(yolo_nas_results.prediction.bboxes_xyxy).shape[0] == 0:
+            return cls.empty()
+
+        return cls(
+            xyxy=yolo_nas_results.prediction.bboxes_xyxy,
+            confidence=yolo_nas_results.prediction.confidence,
+            class_id=yolo_nas_results.prediction.labels.astype(int),
+        )
+
+    @classmethod
+    def from_tensorflow(
+        cls, tensorflow_results: dict[str, Any], resolution_wh: tuple[int, int]
+    ) -> Detections:
+        """
+        Creates a Detections instance from a
+        [Tensorflow Hub](https://www.tensorflow.org/hub/tutorials/tf2_object_detection)
+        inference result.
+
+        Args:
+            tensorflow_results: Raw output dict from a TensorFlow Hub
+                object-detection model. Must contain:
+                ``"detection_boxes"`` (shape ``[1, N, 4]``, normalized
+                ``[ymin, xmin, ymax, xmax]``), ``"detection_scores"``
+                (shape ``[1, N]``), and ``"detection_classes"``
+                (shape ``[1, N]``).
+            resolution_wh: The input image resolution as `(width, height)`.
+                Bounding boxes from Tensorflow are normalized and are scaled
+                to absolute coordinates using this resolution.
+
+        Returns:
+            A new Detections object.
+
+        Note:
+            TensorFlow Hub object-detection models return bounding boxes
+            normalized as ``[ymin, xmin, ymax, xmax]``. This method rescales
+            them to absolute pixel coordinates and reorders them to ``xyxy``
+            (``[xmin, ymin, xmax, ymax]``) before constructing the
+            :class:`Detections` object.
+
+        Example:
+            ```python
+            import tensorflow as tf
+            import tensorflow_hub as hub
+            import numpy as np
+            from supervision import _cv2 as cv2
+
+            module_handle = "https://tfhub.dev/tensorflow/centernet/hourglass_512x512_kpts/1"
+            model = hub.load(module_handle)
+            img = np.array(cv2.imread(""))
+            result = model(img)
+            detections = sv.Detections.from_tensorflow(
+                result, resolution_wh=(img.shape[1], img.shape[0])
+            )
+            ```
+        """
+
+        # Tensorflow returns normalized boxes as [ymin, xmin, ymax, xmax], so the
+        # y coordinates (cols 0, 2) scale by height and x (cols 1, 3) by width.
+        # `.numpy()` may share memory with the source tensor, so copy before the
+        # in-place scaling to avoid mutating the caller's result / double-scaling.
+        boxes = tensorflow_results["detection_boxes"][0].numpy().copy()
+        boxes[:, [0, 2]] *= resolution_wh[1]
+        boxes[:, [1, 3]] *= resolution_wh[0]
+        boxes = boxes[:, [1, 0, 3, 2]]
+        return cls(
+            xyxy=boxes,
+            confidence=tensorflow_results["detection_scores"][0].numpy(),
+            class_id=tensorflow_results["detection_classes"][0].numpy().astype(int),
+        )
+
+    @classmethod
+    def from_deepsparse(cls, deepsparse_results: Any) -> Detections:
+        """
+        Creates a Detections instance from a
+        [DeepSparse](https://github.com/neuralmagic/deepsparse)
+        inference result.
+
+        Args:
+            deepsparse_results: The output Results instance from DeepSparse.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import supervision as sv
+            from deepsparse import Pipeline
+
+            yolo_pipeline = Pipeline.create(
+                task="yolo",
+                model_path = "zoo:cv/detection/yolov5-l/pytorch/ultralytics/coco/pruned80_quant-none"
+             )
+            result = yolo_pipeline()
+            detections = sv.Detections.from_deepsparse(result)
+            ```
+        """  # noqa: E501 // docs
+
+        if np.asarray(deepsparse_results.boxes[0]).shape[0] == 0:
+            return cls.empty()
+
+        return cls(
+            xyxy=np.array(deepsparse_results.boxes[0]),
+            confidence=np.array(deepsparse_results.scores[0]),
+            class_id=np.array(deepsparse_results.labels[0]).astype(float).astype(int),
+        )
+
+    @classmethod
+    def from_mmdetection(cls, mmdet_results: Any) -> Detections:
+        """
+        Creates a Detections instance from a
+        [mmdetection](https://github.com/open-mmlab/mmdetection) and
+        [mmyolo](https://github.com/open-mmlab/mmyolo) inference result.
+
+        Args:
+            mmdet_results: The output Results instance from MMDetection.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from mmdet.apis import init_detector, inference_detector
+
+            image = cv2.imread("")
+            model = init_detector("", "", device="")
+
+            result = inference_detector(model, image)
+            detections = sv.Detections.from_mmdetection(result)
+            ```
+        """
+
+        return cls(
+            xyxy=mmdet_results.pred_instances.bboxes.cpu().numpy(),
+            confidence=mmdet_results.pred_instances.scores.cpu().numpy(),
+            class_id=mmdet_results.pred_instances.labels.cpu().numpy().astype(int),
+            mask=(
+                mmdet_results.pred_instances.masks.cpu().numpy()
+                if "masks" in mmdet_results.pred_instances
+                else None
+            ),
+        )
+
+    @classmethod
+    def from_transformers(
+        cls,
+        transformers_results: dict[str, Any],
+        id2label: dict[int, str] | None = None,
+    ) -> Detections:
+        """
+        Creates a Detections instance from object detection or panoptic, semantic
+        and instance segmentation
+        [Transformer](https://github.com/huggingface/transformers) inference result.
+
+        Args:
+            transformers_results: Inference results from your Transformers model.
+                This can be either a dictionary containing valuable outputs like
+                `scores`, `labels`, `boxes`, `masks`, `segments_info`, and
+                `segmentation`, or a `torch.Tensor` holding a segmentation map
+                where values represent class IDs.
+            id2label: A dictionary mapping class IDs to labels, typically part of
+                the `transformers` model configuration. If provided, the resulting
+                dictionary will include class names.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import torch
+            import supervision as sv
+            from PIL import Image
+            from transformers import DetrImageProcessor, DetrForObjectDetection
+
+            processor = DetrImageProcessor.from_pretrained("facebook/detr-resnet-50")
+            model = DetrForObjectDetection.from_pretrained("facebook/detr-resnet-50")
+
+            image = Image.open("")
+            inputs = processor(images=image, return_tensors="pt")
+
+            with torch.no_grad():
+                outputs = model(**inputs)
+
+            width, height = image.size
+            target_size = torch.tensor([[height, width]])
+            results = processor.post_process_object_detection(
+                outputs=outputs, target_sizes=target_size)[0]
+
+            detections = sv.Detections.from_transformers(
+                transformers_results=results,
+                id2label=model.config.id2label
+            )
+            ```
+        """
+
+        if (
+            transformers_results.__class__.__name__ == "Tensor"
+            or "segmentation" in transformers_results
+        ):
+            return cls(
+                **process_transformers_v5_segmentation_result(
+                    transformers_results, id2label
+                )
+            )
+
+        if "masks" in transformers_results or "png_string" in transformers_results:
+            return cls(
+                **process_transformers_v4_segmentation_result(
+                    transformers_results, id2label
+                )
+            )
+
+        if "boxes" in transformers_results:
+            return cls(
+                **process_transformers_detection_result(transformers_results, id2label)
+            )
+
+        else:
+            raise ValueError(
+                "The provided Transformers results do not contain any valid fields."
+                " Expected fields are 'boxes', 'masks', 'segments_info' or"
+                " 'segmentation'."
+            )
+
+    @classmethod
+    def from_detectron2(cls, detectron2_results: Any) -> Detections:
+        """
+        Create a Detections object from the
+        [Detectron2](https://github.com/facebookresearch/detectron2) inference result.
+
+        Args:
+            detectron2_results: The output of a
+                Detectron2 model containing instances with prediction data.
+
+        Returns:
+            A Detections object containing the bounding boxes,
+                class IDs, and confidences of the predictions.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from detectron2.engine import DefaultPredictor
+            from detectron2.config import get_cfg
+
+
+            image = cv2.imread("")
+            cfg = get_cfg()
+            cfg.merge_from_file("")
+            cfg.MODEL.WEIGHTS = ""
+            predictor = DefaultPredictor(cfg)
+
+            result = predictor(image)
+            detections = sv.Detections.from_detectron2(result)
+            ```
+        """
+
+        return cls(
+            xyxy=detectron2_results["instances"].pred_boxes.tensor.cpu().numpy(),
+            confidence=detectron2_results["instances"].scores.cpu().numpy(),
+            mask=(
+                detectron2_results["instances"].pred_masks.cpu().numpy()
+                if hasattr(detectron2_results["instances"], "pred_masks")
+                else None
+            ),
+            class_id=detectron2_results["instances"]
+            .pred_classes.cpu()
+            .numpy()
+            .astype(int),
+        )
+
+    @classmethod
+    def from_inference(
+        cls,
+        roboflow_result: dict[str, Any] | Any,
+        *,
+        compact_masks: bool = False,
+    ) -> Detections:
+        """
+        Create a `sv.Detections` object from the [Roboflow](https://roboflow.com/)
+        API inference result or the [Inference](https://inference.roboflow.com/)
+        package results. This method extracts bounding boxes, class IDs,
+        confidences, and class names from the Roboflow API result and encapsulates
+        them into a Detections object.
+
+        Args:
+            roboflow_result: The result from the
+                Roboflow API or Inference package containing predictions.
+            compact_masks: When `True`, return segmentation masks as
+                :class:`~supervision.detection.compact_mask.CompactMask`.
+                The default `False` preserves the existing dense NumPy mask
+                representation.
+
+                Warning:
+                    When `compact_masks=True`, the crop policy depends on how
+                    each prediction encodes its mask:
+
+                    - Native size-matched COCO-RLE (the RLE `size` equals the
+                      image size) is **cropped to the detector bounding box**
+                      (`xyxy`). For instance-segmentation models the detector
+                      box may not tightly bound the mask, so pixels beyond the
+                      box boundary are silently dropped.
+                    - Polygon-derived masks (`points`) and size-mismatched
+                      COCO-RLE masks (decoded, then resized to the image) are
+                      retained **full-frame** and lose no pixels.
+
+                    Because only the box-cropped path is lossy,
+                    `from_inference(r)` and
+                    `from_inference(r, compact_masks=True)` can return masks
+                    with different areas and IoU **only** for native
+                    size-matched COCO-RLE predictions. Use `compact_masks=True`
+                    only when the memory savings outweigh the boundary loss on
+                    that path.
+
+        Returns:
+            A Detections object containing the bounding boxes, class IDs,
+                and confidences of the predictions.
+                `detections.data["class_name"]` is always present as a
+                string-dtype NumPy array aligned with the detections; it is
+                empty (shape `(0,)`, dtype str) when `predictions` is empty
+                or absent. `detections.tracker_id` is `None` when no
+                predictions carry a tracker ID, or when only a subset do
+                (mixed batch) — in that case all tracker IDs are dropped to
+                preserve alignment with the bounding boxes. Similarly,
+                `detections.mask` is `None` when no predictions include mask
+                data, or when only a subset carry masks — all masks are dropped
+                to preserve xyxy alignment.
+                When `compact_masks=True` and all predictions carry mask data,
+                `detections.mask` is a
+                :class:`~supervision.detection.compact_mask.CompactMask` rather
+                than a dense boolean array.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from inference import get_model
+
+            image = cv2.imread("")
+            model = get_model(model_id="yolov8s-640")
+
+            result = model.infer(image)[0]
+            detections = sv.Detections.from_inference(result)
+            compact_detections = sv.Detections.from_inference(
+                result, compact_masks=True
+            )
+            ```
+        """
+        if hasattr(roboflow_result, "dict"):
+            roboflow_result = roboflow_result.dict(exclude_none=True, by_alias=True)
+        elif hasattr(roboflow_result, "json"):
+            roboflow_result = roboflow_result.json()
+        masks: npt.NDArray[np.bool_] | CompactMask | None
+        # Design note (ADR): the `compact_masks` flag changes the runtime type of
+        # `detections.mask` from `NDArray[bool_]` to `CompactMask`, so every mask
+        # consumer must branch on `isinstance(detections.mask, CompactMask)`. A
+        # typed factory / `mask_format=` enum would be cleaner but would require a
+        # deprecation cycle if introduced later.
+        if compact_masks:
+            xyxy, confidence, class_id, masks, trackers, data = process_roboflow_result(
+                roboflow_result=roboflow_result, compact_masks=True
+            )
+        else:
+            xyxy, confidence, class_id, masks, trackers, data = process_roboflow_result(
+                roboflow_result=roboflow_result
+            )
+
+        if np.asarray(xyxy).shape[0] == 0:
+            empty_detection = cls.empty()
+            empty_detection.data = data
+            return empty_detection
+
+        return cls(
+            xyxy=xyxy,
+            confidence=confidence,
+            class_id=class_id,
+            mask=masks,
+            tracker_id=trackers,
+            data=data,
+        )
+
+    @classmethod
+    def from_sam(cls, sam_result: list[dict[str, Any]]) -> Detections:
+        """
+        Creates a Detections instance from
+        [Segment Anything Model](https://github.com/facebookresearch/segment-anything)
+        inference result.
+
+        Args:
+            sam_result: The output Results instance from SAM.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import supervision as sv
+            from segment_anything import (
+                sam_model_registry,
+                SamAutomaticMaskGenerator
+             )
+
+            sam_model_reg = sam_model_registry[MODEL_TYPE]
+            sam = sam_model_reg(checkpoint=CHECKPOINT_PATH).to(device=DEVICE)
+            mask_generator = SamAutomaticMaskGenerator(sam)
+            sam_result = mask_generator.generate(IMAGE)
+            detections = sv.Detections.from_sam(sam_result=sam_result)
+            ```
+        """
+
+        sorted_generated_masks = sorted(
+            sam_result, key=lambda x: x["area"], reverse=True
+        )
+        if len(sorted_generated_masks) == 0:
+            return cls.empty()
+
+        xywh = np.array([mask["bbox"] for mask in sorted_generated_masks])
+        segmentations = [mask["segmentation"] for mask in sorted_generated_masks]
+        first_segmentation = segmentations[0]
+
+        if all(isinstance(segmentation, np.ndarray) for segmentation in segmentations):
+            mask = np.stack(segmentations, axis=0)
+        elif all(isinstance(segmentation, dict) for segmentation in segmentations):
+            image_height, image_width = cast(
+                tuple[int, int], tuple(int(v) for v in first_segmentation["size"])
+            )
+            mask = np.stack(
+                [
+                    rle_to_mask(
+                        segmentation["counts"],
+                        (image_width, image_height),
+                    )
+                    for segmentation in segmentations
+                ],
+                axis=0,
+            )
+        else:
+            raise ValueError(
+                "SAM segmentations must all be dense arrays or COCO RLE dictionaries."
+            )
+
+        xyxy = xywh_to_xyxy(xywh=xywh)
+        return cls(xyxy=xyxy, mask=mask)
+
+    @classmethod
+    def from_sam3(
+        cls, sam3_result: dict[str, Any] | Any, resolution_wh: tuple[int, int]
+    ) -> Detections:
+        """
+        Creates a Detections instance from
+        [SAM 3](https://github.com/facebookresearch/sam3) inference result.
+        Supports both PVS and PCS SAM3 segmentation formats.
+
+        Args:
+            sam3_result: The output result from SAM 3 inference, either
+                Sam3PromptResult from inference package or dict containing
+                prompt_results with polygon predictions.
+            resolution_wh: The width and height of the image used for mask
+                generation.
+
+        Returns:
+            A new Detections object. The `class_id` field contains the prompt
+                index for each polygon.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from inference.models.sam3 import SegmentAnything3
+            from inference.core.entities.requests.sam3 import Sam3Prompt
+
+            image = cv2.imread("")
+            model = SegmentAnything3(
+                model_id="sam3/sam3_final",
+                api_key=""
+            )
+
+            prompts = [
+                Sam3Prompt(type="text", text="car"),
+                Sam3Prompt(type="text", text="tire"),
+            ]
+
+            result = model.segment_image(
+                image=image,
+                prompts=prompts,
+                output_prob_thresh=0.5,
+                format="polygon"
+            )
+
+            height, width = image.shape[:2]
+            detections = sv.Detections.from_sam3(
+                sam3_result=result,
+                resolution_wh=(width, height)
+            )
+            ```
+        """
+        width, height = _validate_resolution(resolution_wh)
+
+        masks = []
+        confidences = []
+        class_ids = []
+
+        if isinstance(sam3_result, dict):
+            prompt_results = sam3_result.get("prompt_results", [])
+            if not prompt_results and "predictions" in sam3_result:
+                prompt_results = [
+                    {"predictions": sam3_result["predictions"], "prompt_index": 0}
+                ]
+        else:
+            prompt_results = getattr(sam3_result, "prompt_results", [])
+            if not prompt_results and hasattr(sam3_result, "predictions"):
+                prompt_results = [
+                    {
+                        "predictions": getattr(sam3_result, "predictions"),
+                        "prompt_index": 0,
+                    }
+                ]
+
+        for i, prompt_result in enumerate(prompt_results):
+            if isinstance(prompt_result, dict):
+                predictions = prompt_result.get("predictions", [])
+                prompt_index = prompt_result.get("prompt_index", i)
+            else:
+                predictions = getattr(prompt_result, "predictions", [])
+                prompt_index = getattr(prompt_result, "prompt_index", i)
+
+            for prediction in predictions:
+                if isinstance(prediction, dict):
+                    prediction_format = prediction.get("format")
+                    if prediction_format and prediction_format != "polygon":
+                        continue
+                    pred_masks = prediction.get("masks", [])
+                    confidence = prediction.get("confidence", 1.0)
+                else:
+                    prediction_format = getattr(prediction, "format", None)
+                    if prediction_format and prediction_format != "polygon":
+                        continue
+                    pred_masks = getattr(prediction, "masks", [])
+                    confidence = getattr(prediction, "confidence", 1.0)
+
+                if not pred_masks:
+                    continue
+
+                full_mask: npt.NDArray[np.bool_] = np.zeros((height, width), dtype=bool)
+                for poly in pred_masks:
+                    polygon = np.array(poly, dtype=np.int32)
+                    mask = polygon_to_mask(
+                        polygon=polygon, resolution_wh=(width, height)
+                    )
+                    mask = mask.astype(bool, copy=False)
+                    np.logical_or(full_mask, mask, out=full_mask)
+
+                masks.append(full_mask)
+                confidences.append(confidence)
+                class_ids.append(prompt_index)
+
+        if not masks:
+            return cls.empty()
+
+        masks_np = np.stack(masks, axis=0)
+        xyxy = mask_to_xyxy(masks_np)
+
+        return cls(
+            xyxy=xyxy.astype(np.float32),
+            mask=masks_np,
+            confidence=np.array(confidences, dtype=np.float32),
+            class_id=np.array(class_ids, dtype=int),
+        )
+
+    @classmethod
+    def from_azure_analyze_image(
+        cls, azure_result: dict[str, Any], class_map: dict[int, str] | None = None
+    ) -> Detections:
+        """
+        Creates a Detections instance from [Azure Image Analysis 4.0](
+        https://learn.microsoft.com/en-us/azure/ai-services/computer-vision/
+        concept-object-detection-40).
+
+        Args:
+            azure_result: The result from Azure Image Analysis. It should
+                contain detected objects and their bounding box coordinates.
+            class_map: A mapping of class IDs to class names. If None, a new
+                mapping is created dynamically.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import requests
+            import supervision as sv
+
+            image = open(input, "rb").read()
+
+            endpoint = "https://.cognitiveservices.azure.com/"
+            subscription_key = ""
+
+            headers = {
+                "Content-Type": "application/octet-stream",
+                "Ocp-Apim-Subscription-Key": subscription_key
+             }
+
+            response = requests.post(endpoint,
+                headers=self.headers,
+                data=image
+             ).json()
+
+            detections = sv.Detections.from_azure_analyze_image(response)
+            ```
+        """
+        if "error" in azure_result:
+            raise ValueError(
+                f"Azure API returned an error {azure_result['error']['message']}"
+            )
+
+        xyxy, confidences, class_ids = [], [], []
+
+        is_dynamic_mapping = class_map is None
+        if class_map is None:
+            class_map = {}
+
+        inverted_map: dict[str, int] = {value: key for key, value in class_map.items()}
+
+        for detection in azure_result["objectsResult"]["values"]:
+            bbox = detection["boundingBox"]
+
+            tags = detection["tags"]
+
+            x0 = bbox["x"]
+            y0 = bbox["y"]
+            x1 = x0 + bbox["w"]
+            y1 = y0 + bbox["h"]
+
+            selected_tag: dict[str, Any] | None = None
+            selected_class_id: int | None = None
+            for tag in sorted(
+                tags, key=lambda candidate: candidate["confidence"], reverse=True
+            ):
+                class_name = tag["name"]
+                class_id_val = inverted_map.get(class_name, None)
+
+                if is_dynamic_mapping and class_id_val is None:
+                    class_id_val = len(inverted_map)
+                    inverted_map[class_name] = class_id_val
+
+                if class_id_val is not None:
+                    selected_tag = tag
+                    selected_class_id = class_id_val
+                    break
+
+            if selected_tag is None:
+                if tags:
+                    warnings.warn(
+                        "Azure detection skipped because none of its tags matched "
+                        "the provided class_map.",
+                        category=SupervisionWarnings,
+                        stacklevel=2,
+                    )
+                continue
+
+            xyxy.append([x0, y0, x1, y1])
+            confidences.append(selected_tag["confidence"])
+            class_ids.append(cast(int, selected_class_id))
+
+        if len(xyxy) == 0:
+            return Detections.empty()
+
+        return cls(
+            xyxy=np.array(xyxy),
+            class_id=np.array(class_ids),
+            confidence=np.array(confidences),
+        )
+
+    @classmethod
+    def from_paddledet(cls, paddledet_result: Any) -> Detections:
+        """
+        Creates a Detections instance from
+            [PaddleDetection](https://github.com/PaddlePaddle/PaddleDetection)
+            inference result.
+
+        Args:
+            paddledet_result: The output Results instance from PaddleDet.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import supervision as sv
+            import paddle
+            from ppdet.engine import Trainer
+            from ppdet.core.workspace import load_config
+
+            weights = ()
+            config = ()
+
+            cfg = load_config(config)
+            trainer = Trainer(cfg, mode='test')
+            trainer.load_weights(weights)
+
+            paddledet_result = trainer.predict([images])[0]
+
+            detections = sv.Detections.from_paddledet(paddledet_result)
+            ```
+        """
+
+        if np.asarray(paddledet_result["bbox"][:, 2:6]).shape[0] == 0:
+            return cls.empty()
+
+        return cls(
+            xyxy=paddledet_result["bbox"][:, 2:6],
+            confidence=paddledet_result["bbox"][:, 1],
+            class_id=paddledet_result["bbox"][:, 0].astype(int),
+        )
+
+    @classmethod
+    def from_lmm(
+        cls, lmm: LMM | str, result: str | dict[str, Any], **kwargs: Any
+    ) -> Detections:
+        """
+        !!! deprecated "Deprecated"
+            `Detections.from_lmm` is **deprecated** and will be removed in `supervision-0.31.0`.
+            Please use `Detections.from_vlm` instead.
+
+        Creates a Detections object from the given result string based on the specified
+        Large Multimodal Model (LMM).
+
+        | Name                | Enum (sv.LMM)        | Tasks                   | Required parameters         | Optional parameters |
+        |---------------------|----------------------|-------------------------|-----------------------------|---------------------|
+        | PaliGemma           | `PALIGEMMA`          | detection               | `resolution_wh`             | `classes`           |
+        | PaliGemma 2         | `PALIGEMMA`          | detection               | `resolution_wh`             | `classes`           |
+        | Qwen2.5-VL          | `QWEN_2_5_VL`        | detection               | `resolution_wh`, `input_wh` | `classes`           |
+        | Qwen3-VL            | `QWEN_3_VL`          | detection               | `resolution_wh`             | `classes`           |
+        | Google Gemini 2.0   | `GOOGLE_GEMINI_2_0`  | detection               | `resolution_wh`             | `classes`           |
+        | Google Gemini 2.5   | `GOOGLE_GEMINI_2_5`  | detection, segmentation | `resolution_wh`             | `classes`           |
+        | Google Gemini 3.5   | `GOOGLE_GEMINI_3_5`  | detection, segmentation | `resolution_wh`             | `classes`           |
+        | Moondream           | `MOONDREAM`          | detection               | `resolution_wh`             |                     |
+        | DeepSeek-VL2        | `DEEPSEEK_VL_2`      | detection               | `resolution_wh`             | `classes`           |
+        | Qwen3-VL            | `QWEN_3_VL`          | detection               | `resolution_wh`             | `classes`           |
+
+        Args:
+            lmm: The type of LMM (Large Multimodal Model) to use.
+            result: The result string containing the detection data.
+            **kwargs: Additional keyword arguments required by the specified LMM.
+
+        Returns:
+            A new Detections object.
+
+        Raises:
+            ValueError: If the LMM is invalid, required arguments are missing, or
+                disallowed arguments are provided.
+            ValueError: If the specified LMM is not supported.
+
+        !!! example "PaliGemma"
+            ```python
+
+            import supervision as sv
+
+            paligemma_result = " cat"
+            detections = sv.Detections.from_lmm(
+                sv.LMM.PALIGEMMA,
+                paligemma_result,
+                resolution_wh=(1000, 1000),
+                classes=['cat', 'dog']
+            )
+            detections.xyxy
+            # array([[250., 250., 750., 750.]])
+
+            detections.class_id
+            # array([0])
+
+            detections.data
+            # {'class_name': array(['cat'], dtype='"
+                          }
+                        },
+                        {
+                          "text": "Detect all the cats and dogs in the image..."
+                        }
+                      ]
+                    }
+                  ]
+                }
+                ```
+                To get the best results from Google Gemini 2.0, use the following prompt.
+
+                ```
+                Detect all the cats and dogs in the image. The box_2d should be
+                [ymin, xmin, ymax, xmax] normalized to 0-1000.
+                ```
+
+            ```python
+            import supervision as sv
+
+            gemini_response_text = \"\"\"```json
+                [
+                    {"box_2d": [543, 40, 728, 200], "label": "cat", "id": 1},
+                    {"box_2d": [653, 352, 820, 522], "label": "dog", "id": 2}
+                ]
+            ```\"\"\"
+
+            detections = sv.Detections.from_lmm(
+                sv.LMM.GOOGLE_GEMINI_2_0,
+                gemini_response_text,
+                resolution_wh=(1000, 1000),
+                classes=['cat', 'dog'],
+            )
+
+            detections.xyxy
+            # array([[543., 40., 728., 200.], [653., 352., 820., 522.]])
+
+            detections.data
+            # {'class_name': array(['cat', 'dog'], dtype='\\n<|ref|>The giraffe at the front<|/ref|>
+                ```
+
+                **For visual grounding, use the following user prompt:**
+
+                ```
+                \\n<|grounding|>Detect the giraffes
+                ```
+
+            ```python
+            from PIL import Image
+            import supervision as sv
+
+            deepseek_vl2_result = "<|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|end▁of▁sentence|>"
+
+            detections = sv.Detections.from_vlm(
+                vlm=sv.VLM.DEEPSEEK_VL_2, result=deepseek_vl2_result, resolution_wh=image.size
+            )
+
+            detections.xyxy
+            # array([[ 420,  293,  724,  982],
+            #        [  18,   33,  458, 1084]])
+
+            detections.class_id
+            # array([0, 1])
+
+            detections.data
+            # {'class_name': array(['The giraffe at the back', 'The giraffe at the front'], dtype=' Detections:
+        """
+
+        Creates a Detections object from the given result string based on the specified
+        Vision Language Model (VLM).
+
+        | Name                | Enum (sv.VLM)        | Tasks                   | Required parameters         | Optional parameters |
+        |---------------------|----------------------|-------------------------|-----------------------------|---------------------|
+        | PaliGemma           | `PALIGEMMA`          | detection               | `resolution_wh`             | `classes`           |
+        | PaliGemma 2         | `PALIGEMMA`          | detection               | `resolution_wh`             | `classes`           |
+        | Qwen2.5-VL          | `QWEN_2_5_VL`        | detection               | `resolution_wh`, `input_wh` | `classes`           |
+        | Qwen3-VL            | `QWEN_3_VL`          | detection               | `resolution_wh`             | `classes`           |
+        | Google Gemini 2.0   | `GOOGLE_GEMINI_2_0`  | detection               | `resolution_wh`             | `classes`           |
+        | Google Gemini 2.5   | `GOOGLE_GEMINI_2_5`  | detection, segmentation | `resolution_wh`             | `classes`           |
+        | Google Gemini 3.5   | `GOOGLE_GEMINI_3_5`  | detection, segmentation | `resolution_wh`             | `classes`           |
+        | Moondream           | `MOONDREAM`          | detection               | `resolution_wh`             |                     |
+        | DeepSeek-VL2        | `DEEPSEEK_VL_2`      | detection               | `resolution_wh`             | `classes`           |
+
+        Args:
+            vlm: The type of VLM (Vision Language Model) to use.
+            result: The result string containing the detection data.
+            **kwargs: Additional keyword arguments required by the specified VLM.
+
+        Returns:
+            A new Detections object.
+
+        Raises:
+            ValueError: If the VLM is invalid, required arguments are missing, or
+                disallowed arguments are provided.
+            ValueError: If the specified VLM is not supported.
+
+        !!! example "PaliGemma"
+            ```pycon
+            >>> import supervision as sv
+
+            >>> paligemma_result = " cat"
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.PALIGEMMA,
+            ...     paligemma_result,
+            ...     resolution_wh=(1000, 1000),
+            ...     classes=['cat', 'dog']
+            ... )
+            >>> detections.xyxy
+            array([[250., 250., 750., 750.]])
+            >>> detections.class_id
+            array([0])
+            >>> detections.data
+            {'class_name': array(['cat'], dtype='>> import supervision as sv
+
+            >>> qwen_2_5_vl_result = \"\"\"```json
+            ... [
+            ...     {"bbox_2d": [139, 768, 315, 954], "label": "cat"},
+            ...     {"bbox_2d": [366, 679, 536, 849], "label": "dog"}
+            ... ]
+            ... ```\"\"\"
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.QWEN_2_5_VL,
+            ...     qwen_2_5_vl_result,
+            ...     input_wh=(1000, 1000),
+            ...     resolution_wh=(1000, 1000),
+            ...     classes=['cat', 'dog'],
+            ... )
+            >>> detections.xyxy
+            array([[139., 768., 315., 954.],
+                   [366., 679., 536., 849.]])
+            >>> detections.class_id
+            array([0, 1])
+            >>> detections.data
+            {'class_name': array(['cat', 'dog'], dtype='>> import supervision as sv
+
+            >>> qwen_3_vl_result = \"\"\"```json
+            ... [
+            ...     {"bbox_2d": [139, 768, 315, 954], "label": "cat"},
+            ...     {"bbox_2d": [366, 679, 536, 849], "label": "dog"}
+            ... ]
+            ... ```\"\"\"
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.QWEN_3_VL,
+            ...     qwen_3_vl_result,
+            ...     resolution_wh=(1000, 1000),
+            ...     classes=['cat', 'dog'],
+            ... )
+            >>> detections.xyxy
+            array([[139., 768., 315., 954.],
+                   [366., 679., 536., 849.]])
+            >>> detections.class_id
+            array([0, 1])
+            >>> detections.data
+            {'class_name': array(['cat', 'dog'], dtype='>> import supervision as sv
+
+            >>> gemini_response_text = \"\"\"```json
+            ...     [
+            ...         {"box_2d": [543, 40, 728, 200], "label": "cat", "id": 1},
+            ...         {"box_2d": [653, 352, 820, 522], "label": "dog", "id": 2}
+            ...     ]
+            ... ```\"\"\"
+
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.GOOGLE_GEMINI_2_0,
+            ...     gemini_response_text,
+            ...     resolution_wh=(1000, 1000),
+            ...     classes=['cat', 'dog'],
+            ... )
+            >>> detections.xyxy
+            array([[ 40., 543., 200., 728.],
+                   [352., 653., 522., 820.]])
+            >>> detections.data
+            {'class_name': array(['cat', 'dog'], dtype='>> detections.class_id
+            array([0, 1])
+
+            ```
+
+        !!! example "Gemini 2.5"
+
+            ??? tip "Prompt engineering"
+
+                To get the best results from Google Gemini 2.5, use the following prompt.
+
+                This prompt is designed to detect all visible objects in the image,
+                including small, distant, or partially visible ones, and to return
+                tight bounding boxes.
+
+                According to the [Gemini API documentation on image prompts](
+                https://ai.google.dev/gemini-api/docs/vision?hl=en),
+                when using a single image with text, place the text prompt after the image
+                part in the `contents` array. For example, with the `google-genai` client:
+
+                ```python
+                response = model.generate_content(
+                    [
+                        {
+                            "role": "user",
+                            "parts": [
+                                types.Part.from_bytes(image_bytes, mime_type="image/png"),
+                                types.Part.from_text(prompt),
+                            ],
+                        }
+                    ]
+                )
+                ```
+
+                This ordering has been shown to produce significantly better results in practice.
+
+                ```
+                Carefully examine this image and detect ALL visible objects, including
+                small, distant, or partially visible ones.
+
+                IMPORTANT: Focus on finding as many objects as possible, even if you are
+                only moderately confident.
+
+                Make sure each bounding box is as tight as possible.
+
+                Valid object classes: {class_list}
+
+                For each detected object, provide:
+                - "label": the exact class name from the list above
+                - "confidence": your certainty (between 0.0 and 1.0)
+                - "box_2d": the bounding box [ymin, xmin, ymax, xmax] normalized to 0-1000
+                - "mask": the binary mask of the object as a base64-encoded string
+
+                Detect everything that matches the valid classes. Do not be
+                conservative; include objects even with moderate confidence.
+
+                Return a JSON array, for example:
+                [
+                    {
+                        "label": "person",
+                        "confidence": 0.95,
+                        "box_2d": [100, 200, 300, 400],
+                        "mask": "..."
+                    },
+                    {
+                        "label": "kite",
+                        "confidence": 0.80,
+                        "box_2d": [50, 150, 250, 350],
+                        "mask": "..."
+                    }
+                ]
+                ```
+
+                When using the google-genai library, it is recommended to set
+                thinking_budget=0 in thinking_config for more direct and faster responses.
+
+                ```python
+                from google.generativeai import types
+
+                model.generate_content(
+                    ...,
+                    generation_config=generation_config,
+                    safety_settings=safety_settings,
+                    thinking_config=types.ThinkingConfig(
+                        thinking_budget=0
+                    )
+                )
+                ```
+
+                For a shorter prompt focused only on segmentation masks, you can use:
+
+                ```
+                Return a JSON list of segmentation masks. Each entry should include the
+                2D bounding box in the "box_2d" key, the segmentation mask in the "mask"
+                key, and the text label in the "label" key. Use descriptive labels.
+                ```
+
+            ```pycon
+            >>> import supervision as sv
+
+            >>> gemini_response_text = \"\"\"```json
+            ...     [
+            ...         {"box_2d": [543, 40, 728, 200], "label": "cat", "id": 1},
+            ...         {"box_2d": [653, 352, 820, 522], "label": "dog", "id": 2}
+            ...     ]
+            ... ```\"\"\"
+
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.GOOGLE_GEMINI_2_5,
+            ...     gemini_response_text,
+            ...     resolution_wh=(1000, 1000),
+            ...     classes=['cat', 'dog'],
+            ... )
+            >>> detections.xyxy
+            array([[ 40., 543., 200., 728.],
+                   [352., 653., 522., 820.]])
+            >>> detections.data
+            {'class_name': array(['cat', 'dog'], dtype='>> detections.class_id
+            array([0, 1])
+
+            ```
+
+        !!! example "Moondream"
+
+
+            ??? tip "Prompt engineering"
+
+                To get the best results from Moondream, use optimized prompts that leverage
+                its object detection capabilities effectively.
+
+                **For general object detection, use this simple prompt:**
+
+                ```
+                objects
+                ```
+
+                This single-word prompt instructs Moondream to detect all visible objects
+                and return them in the proper JSON format with normalized coordinates.
+
+
+            ```pycon
+            >>> import supervision as sv
+
+            >>> moondream_result = {
+            ...     'objects': [
+            ...         {
+            ...             'x_min': 0.5704046934843063,
+            ...             'y_min': 0.20069346576929092,
+            ...             'x_max': 0.7049859315156937,
+            ...             'y_max': 0.3012596592307091
+            ...         },
+            ...         {
+            ...             'x_min': 0.6210969910025597,
+            ...             'y_min': 0.3300672620534897,
+            ...             'x_max': 0.8417936339974403,
+            ...             'y_max': 0.4961046129465103
+            ...         }
+            ...     ]
+            ... }
+
+            >>> detections = sv.Detections.from_vlm(
+            ...     sv.VLM.MOONDREAM,
+            ...     moondream_result,
+            ...     resolution_wh=(1000, 1000),
+            ... )
+            >>> detections.xyxy  # doctest: +ELLIPSIS
+            array([[570.404..., 200.693..., 704.985..., 301.259...],
+                   [621.096..., 330.067..., 841.793..., 496.104...]])
+
+            ```
+
+        !!! example "DeepSeek-VL2"
+
+
+            ??? tip "Prompt engineering"
+
+                To get the best results from DeepSeek-VL2, use optimized prompts that leverage
+                its object detection and visual grounding capabilities effectively.
+
+                **For general object detection, use the following user prompt:**
+
+                ```
+                \\n<|ref|>The giraffe at the front<|/ref|>
+                ```
+
+                **For visual grounding, use the following user prompt:**
+
+                ```
+                \\n<|grounding|>Detect the giraffes
+                ```
+
+            ```pycon
+            >>> import supervision as sv
+
+            >>> deepseek_vl2_result = "<|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|end▁of▁sentence|>"
+
+            >>> detections = sv.Detections.from_vlm(
+            ...     vlm=sv.VLM.DEEPSEEK_VL_2,
+            ...     result=deepseek_vl2_result,
+            ...     resolution_wh=(1000, 1000),
+            ... )
+            >>> detections.xyxy
+            array([[ 580.58057 ,  270.27026 , 1000.      ,  904.9049  ],
+                   [  26.026026,   31.03103 ,  632.6326  ,  998.999   ]],
+                  dtype=float32)
+            >>> detections.class_id
+            array([0, 1])
+            >>> detections.data
+            {'class_name': array(['The giraffe at the back', 'The giraffe at the front'],
+                  dtype=' Detections:
+        """
+        Create a Detections object from the
+        [EasyOCR](https://github.com/JaidedAI/EasyOCR) result.
+
+        Results are placed in the `data` field with the key `"class_name"`.
+        When EasyOCR returns quadrilateral corners, the original corners are
+        preserved in ``ORIENTED_BOX_COORDINATES``. Call EasyOCR with
+        ``detail=1`` so bounding boxes are available; ``detail=0`` returns text
+        strings only and cannot be converted into detections.
+
+        Args:
+            easyocr_results: The output Results instance from EasyOCR.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            import supervision as sv
+            import easyocr
+
+            reader = easyocr.Reader(['en'])
+            results = reader.readtext("")
+            detections = sv.Detections.from_easyocr(results)
+            detected_text = detections["class_name"]
+            ```
+        """
+        if len(easyocr_results) == 0:
+            return cls.empty()
+
+        if isinstance(easyocr_results[0], str):
+            raise ValueError(
+                "EasyOCR results produced with detail=0 do not include bounding "
+                "boxes. Call reader.readtext(..., detail=1) instead."
+            )
+
+        bbox = np.array([result[0] for result in easyocr_results], dtype=np.float32)
+        if bbox.ndim != 3 or bbox.shape[1:] != (4, 2):
+            raise ValueError(
+                "EasyOCR results must contain four corner points per detection."
+            )
+        xyxy = np.hstack((np.min(bbox, axis=1), np.max(bbox, axis=1)))
+        confidence = np.array(
+            [
+                result[2] if len(result) > 2 and result[2] else 0
+                for result in easyocr_results
+            ]
+        )
+        ocr_text = np.array([result[1] for result in easyocr_results])
+
+        data: _DetectionDataType = {
+            CLASS_NAME_DATA_FIELD: ocr_text,
+            ORIENTED_BOX_COORDINATES: bbox,
+        }
+        return cls(
+            xyxy=xyxy.astype(np.float32),
+            confidence=confidence.astype(np.float32),
+            data=data,
+        )
+
+    @classmethod
+    def from_ncnn(cls, ncnn_results: Any) -> Detections:
+        """
+        Creates a Detections instance from the
+        [ncnn](https://github.com/Tencent/ncnn) inference result.
+        Supports object detection models.
+
+        Args:
+            ncnn_results: The output Results instance from ncnn.
+
+        Returns:
+            A new Detections object.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            from ncnn.model_zoo import get_model
+            import supervision as sv
+
+            image = cv2.imread("")
+            model = get_model(
+                "yolov8s",
+                target_size=640
+                prob_threshold=0.5,
+                nms_threshold=0.45,
+                num_threads=4,
+                use_gpu=True,
+                )
+            result = model(image)
+            detections = sv.Detections.from_ncnn(result)
+            ```
+        """
+
+        xywh, confidences, class_ids = [], [], []
+
+        if len(ncnn_results) == 0:
+            return cls.empty()
+
+        for ncnn_result in ncnn_results:
+            rect = ncnn_result.rect
+            xywh.append(
+                [
+                    rect.x.astype(np.float32),
+                    rect.y.astype(np.float32),
+                    rect.w.astype(np.float32),
+                    rect.h.astype(np.float32),
+                ]
+            )
+
+            confidences.append(ncnn_result.prob)
+            class_ids.append(ncnn_result.label)
+
+        return cls(
+            xyxy=xywh_to_xyxy(np.array(xywh, dtype=np.float32)),
+            confidence=np.array(confidences, dtype=np.float32),
+            class_id=np.array(class_ids, dtype=int),
+        )
+
+    @classmethod
+    def empty(cls) -> Detections:
+        """
+        Create an empty Detections object with no bounding boxes,
+            confidences, or class IDs.
+
+        Returns:
+            An empty Detections object.
+
+        Example:
+            ```pycon
+            >>> from supervision import Detections
+            >>> empty_detections = Detections.empty()
+            >>> empty_detections.xyxy.shape
+            (0, 4)
+
+            ```
+        """
+        return cls(
+            xyxy=np.empty((0, 4), dtype=np.float32),
+            confidence=np.array([], dtype=np.float32),
+            class_id=np.array([], dtype=int),
+        )
+
+    def is_empty(self) -> bool:
+        """
+        Check whether the `Detections` object has zero bounding boxes.
+
+        Returns:
+            `True` if there are no detections, `False` otherwise.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[10, 20, 110, 120]]),
+            ...     class_id=np.array([1]),
+            ...     tracker_id=np.array([1]),
+            ... )
+            >>> filtered = detections[detections.class_id == 99]
+            >>> filtered.is_empty()
+            True
+
+            ```
+        """
+        return len(self.xyxy) == 0
+
+    @classmethod
+    def merge(cls, detections_list: list[Detections]) -> Detections:
+        """
+        Merge a list of Detections objects into a single Detections object.
+
+        This method takes a list of Detections objects and combines their
+        respective fields (`xyxy`, `mask`, `confidence`, `class_id`, and `tracker_id`)
+        into a single Detections object.
+
+        For example, if merging Detections with 3 and 4 detected objects, this method
+        will return a Detections with 7 objects (7 entries in `xyxy`, `mask`, etc).
+
+        !!! Note
+
+            When merging, empty `Detections` objects are ignored.
+
+        !!! Note
+
+            **Mask merge policy** — the output mask type follows these rules:
+
+            * All inputs carry
+              [`CompactMask`][supervision.detection.compact_mask.CompactMask]
+              → result mask is `CompactMask`.
+            * Mixed dense `ndarray` + `CompactMask` inputs → dense masks are converted
+              to `CompactMask` via
+              [`CompactMask.from_dense`][supervision.detection.compact_mask.CompactMask.from_dense];
+              result is `CompactMask`. No full `(N, H, W)` stack is allocated.
+
+              !!! warning "Lossy conversion"
+
+                  `from_dense` crops each dense mask to its detection bounding box
+                  (`xyxy`). **True pixels outside the bounding box are silently
+                  discarded.** This matches the behaviour of
+                  `Detections.from_inference(compact_masks=True)`. If pixel-perfect
+                  preservation is required, ensure all inputs are already `CompactMask`
+                  or use the all-dense path (no `CompactMask` inputs).
+
+            * All inputs carry dense `ndarray` → result is `ndarray` (backward
+              compatible).
+            * The pairwise merge path used by
+              [`with_nms`][supervision.detection.core.Detections.with_nms] /
+              [`with_nmm`][supervision.detection.core.Detections.with_nmm]
+              (`merge_inner_detection_object_pair`) does **not** preserve `CompactMask`
+              — mixed inputs materialise to a dense `ndarray` on that path.
+
+        Args:
+            detections_list: A list of Detections objects to merge.
+
+        Returns:
+            A single Detections object containing the merged data from the input list.
+
+        Raises:
+            ValueError: If some `Detections` have a `mask` and others do not.
+            ValueError: If `CompactMask` inputs have different `image_shape` values.
+            ValueError: If a dense mask `(H, W)` shape differs from the `CompactMask`
+                `image_shape` when mixing mask types.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> detections_1 = sv.Detections(
+            ...     xyxy=np.array([[15, 15, 100, 100], [200, 200, 300, 300]]),
+            ...     class_id=np.array([1, 2]),
+            ...     data={'feature_vector': np.array([0.1, 0.2])}
+            ... )
+            >>> detections_2 = sv.Detections(
+            ...     xyxy=np.array([[30, 30, 120, 120]]),
+            ...     class_id=np.array([1]),
+            ...     data={'feature_vector': np.array([0.3])}
+            ... )
+            >>> merged_detections = sv.Detections.merge([detections_1, detections_2])
+            >>> merged_detections.xyxy
+            array([[ 15,  15, 100, 100],
+                   [200, 200, 300, 300],
+                   [ 30,  30, 120, 120]])
+            >>> merged_detections.class_id
+            array([1, 2, 1])
+            >>> merged_detections.data['feature_vector']
+            array([0.1, 0.2, 0.3])
+
+            ```
+
+        Compact mask merge example:
+
+            ```python
+            import numpy as np
+            import supervision as sv
+            from supervision.detection.compact_mask import CompactMask
+
+            H, W = 720, 1280
+            masks_a = np.zeros((2, H, W), dtype=bool)
+            masks_a[0, 100:200, 100:300] = True
+            xyxy_a = np.array([[100., 100., 299., 199.], [400., 300., 600., 500.]])
+            cm_a = CompactMask.from_dense(masks_a, xyxy_a, image_shape=(H, W))
+
+            det_compact = sv.Detections(
+                xyxy=xyxy_a, mask=cm_a, class_id=np.array([0, 1])
+            )
+
+            masks_b = np.zeros((1, H, W), dtype=bool)
+            masks_b[0, 50:100, 50:150] = True
+            xyxy_b = np.array([[50., 50., 149., 99.]])
+            det_dense = sv.Detections(xyxy=xyxy_b, mask=masks_b, class_id=np.array([2]))
+
+            # Dense mask is converted to CompactMask; no (N, H, W) stack allocated.
+            merged = sv.Detections.merge([det_compact, det_dense])
+            assert isinstance(merged.mask, CompactMask)
+            assert len(merged) == 3
+            ```
+        """
+        detections_list = [
+            detections for detections in detections_list if not detections.is_empty()
+        ]
+
+        if len(detections_list) == 0:
+            return Detections.empty()
+
+        for detections in detections_list:
+            _validate_detections_fields(
+                xyxy=detections.xyxy,
+                mask=detections.mask,
+                confidence=detections.confidence,
+                class_id=detections.class_id,
+                tracker_id=detections.tracker_id,
+                data=detections.data,
+            )
+
+        xyxy = np.vstack([d.xyxy for d in detections_list])
+
+        def stack_mask_or_none() -> npt.NDArray[np.generic] | CompactMask | None:
+            masks = [d.mask for d in detections_list]
+            if all(m is None for m in masks):
+                return None
+            if any(m is None for m in masks):
+                raise ValueError("All or none of the 'mask' fields must be None")
+            if all(isinstance(m, CompactMask) for m in masks):
+                return CompactMask.merge(cast(list[CompactMask], masks))
+            if all(not isinstance(m, CompactMask) for m in masks):
+                # All-dense: preserve backward-compatible dense stacking.
+                return cast(
+                    npt.NDArray[np.generic], np.vstack([np.asarray(m) for m in masks])
+                )
+            # Mixed dense and CompactMask: convert dense masks to CompactMask to
+            # avoid materialising a full (N, H, W) stack.
+            compact_image_shapes = {
+                m.image_shape for m in masks if isinstance(m, CompactMask)
+            }
+            if len(compact_image_shapes) != 1:
+                raise ValueError(
+                    "Cannot merge CompactMask objects with different image shapes: "
+                    f"{sorted(compact_image_shapes)}"
+                )
+            image_shape: tuple[int, int] = next(iter(compact_image_shapes))
+            compact_list: list[CompactMask] = []
+            for d, m in zip(detections_list, masks):
+                if isinstance(m, CompactMask):
+                    compact_list.append(m)
+                else:
+                    dense = np.asarray(m, dtype=bool)
+                    if dense.shape[1:] != image_shape:
+                        raise ValueError(
+                            f"Dense mask shape {dense.shape[1:]} does not match "
+                            f"CompactMask image_shape {image_shape}."
+                        )
+                    compact_list.append(
+                        CompactMask.from_dense(dense, d.xyxy, image_shape)
+                    )
+            return CompactMask.merge(compact_list)
+
+        def stack_or_none(name: str) -> npt.NDArray[np.generic] | None:
+            values = [getattr(d, name) for d in detections_list]
+            if all(v is None for v in values):
+                return None
+            if any(v is None for v in values):
+                raise ValueError(f"All or none of the '{name}' fields must be None")
+            return cast(npt.NDArray[np.generic], np.hstack(values))
+
+        mask = cast(npt.NDArray[np.bool_] | CompactMask | None, stack_mask_or_none())
+        confidence = cast(npt.NDArray[np.floating] | None, stack_or_none("confidence"))
+        class_id = cast(npt.NDArray[np.integer] | None, stack_or_none("class_id"))
+        tracker_id = cast(npt.NDArray[np.integer] | None, stack_or_none("tracker_id"))
+
+        data = merge_data([d.data for d in detections_list])
+
+        metadata_list = [detections.metadata for detections in detections_list]
+        metadata = merge_metadata(metadata_list)
+
+        return cls(
+            xyxy=xyxy,
+            mask=mask,
+            confidence=confidence,
+            class_id=class_id,
+            tracker_id=tracker_id,
+            data=data,
+            metadata=metadata,
+        )
+
+    def get_anchors_coordinates(self, anchor: Position) -> npt.NDArray[np.generic]:
+        """Compute anchor-point coordinates for each detection.
+
+        The anchor can be any position in the `Position` enum, such as
+        `CENTER`, `CENTER_LEFT`, `BOTTOM_RIGHT`, etc.
+
+        Selection order:
+
+        1. If ``data[ORIENTED_BOX_COORDINATES]`` is set and ``anchor`` is not
+           ``Position.CENTER_OF_MASS``, coordinates are computed from the
+           oriented bounding box corners (result lies on the actual rotated
+           body).
+        2. If ``anchor`` is ``Position.CENTER_OF_MASS``, the detection mask
+           centroid is returned regardless of OBB data presence.
+        3. Otherwise, the anchor is derived from the axis-aligned envelope
+           (``xyxy``).
+
+        Args:
+            anchor: Anchor position to compute. Supported positions are
+                defined in the `Position` enum.
+
+        Returns:
+            Array of shape `(n, 2)` where each row is the `[x, y]` anchor
+            coordinate for the corresponding detection.
+
+        Raises:
+            ValueError: If the provided `anchor` is not supported.
+
+        Examples:
+            Axis-aligned detection:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[0.0, 0.0, 10.0, 4.0]])
+            ... )
+            >>> detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+            array([[5., 4.]])
+
+            ```
+
+            Oriented (rotated) detection — anchor lies on the rotated body,
+            not the axis-aligned envelope:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> corners = np.array(
+            ...     [[[0.0, 0.0], [10.0, 0.0], [10.0, 4.0], [0.0, 4.0]]]
+            ... )
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[0.0, 0.0, 10.0, 4.0]]),
+            ...     data={"xyxyxyxy": corners},
+            ... )
+            >>> detections.get_anchors_coordinates(sv.Position.BOTTOM_CENTER)
+            array([[5., 4.]])
+
+            ```
+        """
+        if ORIENTED_BOX_COORDINATES in self.data and anchor != Position.CENTER_OF_MASS:
+            return cast(
+                npt.NDArray[np.generic],
+                _oriented_box_anchors(
+                    np.asarray(self.data[ORIENTED_BOX_COORDINATES]), anchor
+                ),
+            )
+
+        xyxy = self.xyxy
+
+        def coordinates(
+            x: npt.NDArray[np.number], y: npt.NDArray[np.number]
+        ) -> npt.NDArray[np.generic]:
+            return cast(npt.NDArray[np.generic], np.array([x, y]).transpose())
+
+        if anchor == Position.CENTER:
+            return coordinates(
+                (xyxy[:, 0] + xyxy[:, 2]) / 2,
+                (xyxy[:, 1] + xyxy[:, 3]) / 2,
+            )
+        elif anchor == Position.CENTER_OF_MASS:
+            if self.mask is None:
+                raise ValueError(
+                    "Cannot use `Position.CENTER_OF_MASS` without a detection mask."
+                )
+            return calculate_masks_centroids(masks=self.mask)
+        elif anchor == Position.CENTER_LEFT:
+            return coordinates(xyxy[:, 0], (xyxy[:, 1] + xyxy[:, 3]) / 2)
+        elif anchor == Position.CENTER_RIGHT:
+            return coordinates(xyxy[:, 2], (xyxy[:, 1] + xyxy[:, 3]) / 2)
+        elif anchor == Position.BOTTOM_CENTER:
+            return coordinates((xyxy[:, 0] + xyxy[:, 2]) / 2, xyxy[:, 3])
+        elif anchor == Position.BOTTOM_LEFT:
+            return coordinates(xyxy[:, 0], xyxy[:, 3])
+        elif anchor == Position.BOTTOM_RIGHT:
+            return coordinates(xyxy[:, 2], xyxy[:, 3])
+        elif anchor == Position.TOP_CENTER:
+            return coordinates((xyxy[:, 0] + xyxy[:, 2]) / 2, xyxy[:, 1])
+        elif anchor == Position.TOP_LEFT:
+            return coordinates(xyxy[:, 0], xyxy[:, 1])
+        elif anchor == Position.TOP_RIGHT:
+            return coordinates(xyxy[:, 2], xyxy[:, 1])
+
+        raise ValueError(f"{anchor} is not supported.")
+
+    def get_data(self, key: str) -> _DetectionDataValueType | None:
+        """Get a value from the detection data dictionary.
+
+        Args:
+            key: Data field name.
+
+        Returns:
+            The stored data value, or `None` when the key is absent.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision import Detections
+            >>> detections = Detections(
+            ...     xyxy=np.array([[0, 0, 1, 1]]),
+            ...     data={"class_name": np.array(["cat"])},
+            ... )
+            >>> detections.get_data("class_name").tolist()
+            ['cat']
+
+            ```
+        """
+        return self.data.get(key)
+
+    def select(
+        self,
+        index: int | np.integer[Any] | slice | list[int] | npt.NDArray[np.generic],
+    ) -> Detections:
+        """Get a subset of the Detections object.
+
+        Args:
+            index: Row index, indices, slice, or boolean mask selecting detections.
+
+        Returns:
+            A new `Detections` instance containing the selected rows. Always returns
+            a fresh copy — arrays and metadata are never shared with the original,
+            even when the selection is empty or the input has zero detections.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision import Detections
+            >>> detections = Detections(xyxy=np.array([[0, 0, 1, 1], [1, 1, 2, 2]]))
+            >>> detections.select([1]).xyxy.tolist()
+            [[1, 1, 2, 2]]
+
+            ```
+        """
+        mask: npt.NDArray[np.bool_] | CompactMask | None
+        if len(self) == 0:
+            if isinstance(self.mask, CompactMask):
+                mask = self.mask[:0]
+            elif self.mask is not None:
+                mask = self.mask[:0].copy()
+            else:
+                mask = None
+            data = {
+                key: value.copy() if isinstance(value, np.ndarray) else list(value)
+                for key, value in self.data.items()
+            }
+            return Detections(
+                xyxy=self.xyxy.copy(),
+                mask=mask,
+                confidence=(
+                    self.confidence.copy() if self.confidence is not None else None
+                ),
+                class_id=self.class_id.copy() if self.class_id is not None else None,
+                tracker_id=(
+                    self.tracker_id.copy() if self.tracker_id is not None else None
+                ),
+                data=data,
+                metadata=dict(self.metadata),
+            )
+        if isinstance(index, (int, np.integer)):
+            index = [int(index)]
+        array_index = cast(
+            slice | list[int] | npt.NDArray[np.integer | np.bool_], index
+        )
+        data = {
+            key: value.copy() if isinstance(value, np.ndarray) else list(value)
+            for key, value in get_data_item(self.data, array_index).items()
+        }
+        if isinstance(self.mask, CompactMask):
+            mask = self.mask[cast(Any, array_index)]
+        elif self.mask is not None:
+            mask = self.mask[cast(Any, array_index)].copy()
+        else:
+            mask = None
+        return Detections(
+            xyxy=self.xyxy[array_index].copy(),
+            mask=mask,
+            confidence=(
+                self.confidence[array_index].copy()
+                if self.confidence is not None
+                else None
+            ),
+            class_id=(
+                self.class_id[array_index].copy() if self.class_id is not None else None
+            ),
+            tracker_id=(
+                self.tracker_id[array_index].copy()
+                if self.tracker_id is not None
+                else None
+            ),
+            data=data,
+            metadata=dict(self.metadata),
+        )
+
+    def __getitem__(
+        self,
+        index: int
+        | np.integer[Any]
+        | slice
+        | list[int]
+        | npt.NDArray[np.generic]
+        | str,
+    ) -> Detections | list[Any] | npt.NDArray[np.generic] | None:
+        """
+        Get a subset of the Detections object or access an item from its data field.
+
+        When provided with an integer, slice, list of integers, or a numpy array, this
+        method returns a new Detections object that represents a subset of the original
+        detections. When provided with a string, it accesses the corresponding item in
+        the data dictionary.
+
+        Args:
+            index: The index, indices, or key to access a subset of the Detections
+                or an item from the data.
+
+        Returns:
+            A subset of the Detections object or an item from the data field.
+
+        Example:
+            ```python
+            import supervision as sv
+
+            detections = sv.Detections()
+
+            first_detection = detections[0]
+            first_10_detections = detections[0:10]
+            some_detections = detections[[0, 2, 4]]
+            class_0_detections = detections[detections.class_id == 0]
+            high_confidence_detections = detections[detections.confidence > 0.5]
+
+            feature_vector = detections['feature_vector']
+            ```
+        """
+        if isinstance(index, str):
+            return self.get_data(index)
+        return self.select(index)
+
+    def __setitem__(self, key: str, value: npt.NDArray[np.generic] | list[Any]) -> None:
+        """
+        Set a value in the data dictionary of the Detections object.
+
+        Args:
+            key: The key in the data dictionary to set.
+            value: The value to set for the key.
+
+        Example:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from ultralytics import YOLO
+
+            image = cv2.imread("")
+            model = YOLO('yolov8s.pt')
+
+            result = model(image)[0]
+            detections = sv.Detections.from_ultralytics(result)
+
+            detections['names'] = [
+                 model.model.names[class_id]
+                 for class_id
+                 in detections.class_id
+             ]
+            ```
+
+        Raises:
+            TypeError: If `value` is not a `np.ndarray` or `list`.
+            ValueError: If `value` has a length or shape incompatible with
+                the detection count.
+        """
+        if not isinstance(value, (np.ndarray, list)):
+            raise TypeError("Value must be a np.ndarray or a list")
+
+        if isinstance(value, list):
+            value = np.array(value)
+
+        _validate_data({key: value}, len(self))
+        self.data[key] = value
+
+    @property
+    def area(self) -> npt.NDArray[np.generic]:
+        """
+        Calculate the area of each detection in the set of object detections.
+
+        Selection order:
+
+        1. If ``mask`` is set, return the area of each mask.
+        2. Else, if ``data[ORIENTED_BOX_COORDINATES]`` is set, return the area of
+           the rotated body (shoelace formula on the four corners).
+        3. Otherwise, return the axis-aligned box area (``box_area``).
+
+        **OBB dispatch contract**: presence of ``data[ORIENTED_BOX_COORDINATES]``
+        with shape ``(N, 4, 2)`` is the canonical signal that a detection carries
+        oriented bounding box geometry. The same presence-of-key check governs
+        ``with_nms``, ``with_nmm``, and this property — always store OBB corners
+        under ``config.ORIENTED_BOX_COORDINATES`` with that shape.
+
+        **Return dtype**: ``float64`` (OBB branch and integer AABB fallback),
+        floating input dtype (floating AABB fallback), ``int64`` (mask branch).
+
+        Returns:
+            An array containing the area of each detection
+                in the format of `(area_1, area_2, ..., area_n)`,
+                where n is the number of detections.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> corners = np.array(
+            ...     [[[0, 5], [5, 10], [10, 5], [5, 0]]], dtype=np.float32
+            ... )
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32),
+            ...     class_id=np.array([0]),
+            ...     data={"xyxyxyxy": corners},
+            ... )
+            >>> detections.area
+            array([50.])
+
+            Mask branch returns ``int64`` pixel counts:
+
+            >>> mask = np.zeros((2, 10, 10), dtype=bool)
+            >>> mask[0, :3, :3] = True   # 9 pixels
+            >>> mask[1, :5, :5] = True   # 25 pixels
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array(
+            ...         [[0, 0, 10, 10], [0, 0, 10, 10]], dtype=np.float32
+            ...     ),
+            ...     mask=mask,
+            ... )
+            >>> detections.area
+            array([ 9, 25])
+
+            ```
+        """
+        return detection_area(self)
+
+    @property
+    def box_area(self) -> npt.NDArray[np.generic]:
+        """
+        Calculate the area of each bounding box in the set of object detections.
+
+        Returns:
+            An array of floats containing the area of each bounding
+            box in the format of `(area_1, area_2, ..., area_n)`,
+                where n is the number of detections. Integer coordinates
+                produce ``float64``; floating coordinates preserve their dtype.
+        """
+        xyxy = self.xyxy
+        if np.issubdtype(xyxy.dtype, np.integer):
+            # Subtract as Python integers first: converting corners to float64
+            # would collapse adjacent 64-bit coordinates above 2**53, while
+            # native integer subtraction can overflow across the dtype range.
+            integer_coordinates = xyxy.astype(object)
+            widths = integer_coordinates[:, 2] - integer_coordinates[:, 0]
+            heights = integer_coordinates[:, 3] - integer_coordinates[:, 1]
+            return np.asarray(widths, dtype=np.float64) * np.asarray(
+                heights, dtype=np.float64
+            )
+
+        widths = xyxy[:, 2] - xyxy[:, 0]
+        heights = xyxy[:, 3] - xyxy[:, 1]
+        return widths * heights
+
+    @property
+    def box_aspect_ratio(self) -> npt.NDArray[np.generic]:
+        """
+        Compute the aspect ratio (width divided by height) for each bounding box.
+
+        Returns:
+            Array of shape `(N,)` containing aspect ratios, where `N` is the
+                number of boxes (width / height for each box).
+
+        Examples:
+            ```python
+            import numpy as np
+            import supervision as sv
+
+            xyxy = np.array([
+                [10, 10, 50, 50],
+                [60, 10, 180, 50],
+                [10, 60, 50, 180],
+            ])
+
+            detections = sv.Detections(xyxy=xyxy)
+
+            detections.box_aspect_ratio
+            # array([1.0, 3.0, 0.33333333])
+
+            ar = detections.box_aspect_ratio
+            detections[(ar < 2.0) & (ar > 0.5)].xyxy
+            # array([[10., 10., 50., 50.]])
+            ```
+        """
+        widths = self.xyxy[:, 2] - self.xyxy[:, 0]
+        heights = self.xyxy[:, 3] - self.xyxy[:, 1]
+
+        aspect_ratios = np.full_like(widths, np.nan, dtype=np.float64)
+        np.divide(widths, heights, out=aspect_ratios, where=heights != 0)
+        return aspect_ratios
+
+    def to_compact_masks(self) -> Detections:
+        """Return a copy of this Detections with masks converted to CompactMask.
+
+        The dense :attr:`mask` field (``NDArray[np.bool_]``) is converted to a
+        :class:`~supervision.detection.compact_mask.CompactMask` without changing
+        mask pixels. When :attr:`mask` is already a
+        :class:`~supervision.detection.compact_mask.CompactMask` or is ``None``,
+        the instance is returned unchanged.
+
+        Note:
+            The crop boundaries are set to the **full image dimensions**, not the
+            detector bounding box. No bbox-crop memory savings apply: the RLE
+            sparsity still reduces storage versus a dense array, but the
+            ``O(bbox_area)`` savings available from
+            ``from_inference(..., compact_masks=True)`` are absent here because
+            every crop spans the whole frame. Call
+            :meth:`~supervision.detection.compact_mask.CompactMask.repack` on the
+            resulting mask to tighten crops to their bounding boxes, at the cost
+            of potential pixel loss outside those boxes.
+
+        Returns:
+            A new :class:`Detections` instance with ``mask`` set to a
+            :class:`~supervision.detection.compact_mask.CompactMask`, or ``self``
+            when conversion is not needed.
+
+        Example:
+            ```python
+            import numpy as np
+            import supervision as sv
+            detections = sv.Detections(
+                xyxy=np.array([[0, 0, 10, 10]]),
+                mask=np.ones((1, 20, 20), dtype=bool),
+            )
+            compact = detections.to_compact_masks()
+            ```
+        """
+        from supervision.detection.compact_mask import CompactMask
+
+        if self.mask is None or isinstance(self.mask, CompactMask):
+            return self
+        image_shape = (int(self.mask.shape[1]), int(self.mask.shape[2]))
+        full_image_xyxy = np.tile(
+            np.array(
+                [[0, 0, image_shape[1] - 1, image_shape[0] - 1]], dtype=np.float64
+            ),
+            (len(self), 1),
+        )
+        new = self.__class__(
+            xyxy=self.xyxy,
+            mask=CompactMask.from_dense(
+                masks=self.mask,
+                xyxy=full_image_xyxy,
+                image_shape=image_shape,
+            ),
+            confidence=self.confidence,
+            class_id=self.class_id,
+            tracker_id=self.tracker_id,
+            data=self.data,
+            metadata=dict(self.metadata),
+        )
+        return new
+
+    def _build_nms_predictions(
+        self, class_agnostic: bool, operation_name: str
+    ) -> npt.NDArray[np.floating]:
+        """Stack xyxy + confidence (+ class_id) for NMS/NMM/Soft-NMS dispatch.
+
+        Callers must already have verified `self.confidence is not None`.
+        """
+        if class_agnostic:
+            return cast(
+                npt.NDArray[np.floating],
+                np.hstack(
+                    (self.xyxy, cast(np.ndarray, self.confidence).reshape(-1, 1))
+                ),
+            )
+        if self.class_id is None:
+            raise ValueError(
+                f"Detections class_id must be given for {operation_name} to be "
+                f"executed. If you intended to perform class agnostic "
+                f"{operation_name} set class_agnostic=True."
+            )
+        return cast(
+            npt.NDArray[np.floating],
+            np.hstack(
+                (
+                    self.xyxy,
+                    cast(np.ndarray, self.confidence).reshape(-1, 1),
+                    self.class_id.reshape(-1, 1),
+                )
+            ),
+        )
+
+    def with_nms(
+        self,
+        threshold: float = 0.5,
+        class_agnostic: bool = False,
+        overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    ) -> Detections:
+        """
+        Performs non-max suppression on detection set. Dispatch order: (1) if mask
+        data present, IoU mask is used; (2) else if oriented-box coordinates
+        (``data[ORIENTED_BOX_COORDINATES]``) present, oriented-box IoU is used; (3)
+        otherwise, axis-aligned box IoU is used.
+
+        Args:
+            threshold: The intersection-over-union threshold
+                to use for non-maximum suppression. The lower the value the more
+                restrictive the NMS becomes. Defaults to 0.5.
+            class_agnostic: Whether to perform class-agnostic
+                non-maximum suppression. If True, the class_id of each detection
+                will be ignored. Defaults to False.
+            overlap_metric: Metric used to compute the degree of
+                overlap between pairs of masks or boxes (e.g., IoU, IoS).
+
+        Returns:
+            A new Detections object containing the subset of detections
+                after non-maximum suppression.
+
+        Raises:
+            ValueError: If `confidence` is None and class_agnostic is False.
+                If `class_id` is None and class_agnostic is False.
+        """
+        if len(self) == 0:
+            return self
+
+        if self.confidence is None:
+            raise ValueError(
+                "Detections confidence must be given for NMS to be executed."
+            )
+
+        predictions = self._build_nms_predictions(class_agnostic, "NMS")
+
+        if self.mask is not None:
+            indices = mask_non_max_suppression(
+                predictions=predictions,
+                masks=self.mask,
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+        elif ORIENTED_BOX_COORDINATES in self.data:
+            indices = oriented_box_non_max_suppression(
+                predictions=predictions,
+                oriented_boxes=np.asarray(self.data[ORIENTED_BOX_COORDINATES]),
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+        else:
+            indices = box_non_max_suppression(
+                predictions=predictions,
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+
+        return self.select(indices)
+
+    def with_soft_nms(
+        self,
+        sigma: float = 0.5,
+        class_agnostic: bool = False,
+        score_threshold: float | None = None,
+    ) -> Detections:
+        """
+        Performs Gaussian Soft Non-Maximum Suppression on detection set. Dispatch
+        order: (1) if mask data present, IoU mask is used; (2) otherwise,
+        axis-aligned box IoU is used. Oriented-box detections are not given
+        dedicated OBB-IoU treatment and fall back to their axis-aligned `xyxy`.
+
+        Unlike `with_nms`, which discards overlapping detections outright,
+        Soft-NMS keeps every detection and instead rescales its confidence by
+        `score *= exp(-iou**2 / sigma)` for each higher-scoring, same-category
+        overlap. By default (`score_threshold=None`) nothing is dropped — the
+        method only rescales confidence, despite the "suppression" name; pass
+        `score_threshold` to additionally filter the decayed scores into a real
+        subset, matching `with_nms`'s return contract.
+
+        Args:
+            sigma: Controls the strength of the confidence decay; must be
+                greater than `0`. The lower the value the stronger the decay.
+                No value of `sigma` reproduces `with_nms`'s hard cutoff —
+                Soft-NMS never drops detections on its own.
+            class_agnostic: Whether to perform class-agnostic Soft-NMS. If
+                True, the class_id of each detection will be ignored.
+                Defaults to False.
+            score_threshold: If given, detections whose decayed confidence is
+                at or below this value are dropped, producing a real subset
+                (like `with_nms`). If `None` (default), all detections are
+                kept, with their confidence rescaled in place on the returned
+                copy.
+
+        Returns:
+            A new Detections object with decayed confidence scores and,
+                if `score_threshold` is given, filtered to a real subset.
+                The original `Detections` instance is never modified.
+
+        Raises:
+            ValueError: If `confidence` is None.
+                If `class_id` is None and class_agnostic is False.
+                If `sigma` is not greater than `0`.
+        """
+        if len(self) == 0:
+            return self
+
+        if self.confidence is None:
+            raise ValueError(
+                "Detections confidence must be given for Soft-NMS to be executed."
+            )
+
+        predictions = self._build_nms_predictions(class_agnostic, "Soft-NMS")
+
+        if self.mask is not None:
+            decayed_confidence = mask_soft_non_max_suppression(
+                predictions=predictions,
+                masks=self.mask,
+                sigma=sigma,
+            )
+        else:
+            decayed_confidence = box_soft_non_max_suppression(
+                predictions=predictions,
+                sigma=sigma,
+            )
+
+        result = self.select(np.arange(len(self)))
+        result.confidence = decayed_confidence
+
+        if score_threshold is None:
+            return result
+        return result.select(decayed_confidence > score_threshold)
+
+    def with_nmm(
+        self,
+        threshold: float = 0.5,
+        class_agnostic: bool = False,
+        overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    ) -> Detections:
+        """
+        Perform non-maximum merging on the current set of object detections.
+        Dispatch order: (1) if mask data present, IoU mask is used; (2) else if
+        oriented-box coordinates (``data[ORIENTED_BOX_COORDINATES]``) present,
+        oriented-box IoU is used; (3) otherwise, axis-aligned box IoU is used.
+
+        Args:
+            threshold: The intersection-over-union threshold
+                to use for non-maximum merging. Defaults to 0.5.
+            class_agnostic: Whether to perform class-agnostic
+                non-maximum merging. If True, the class_id of each detection
+                will be ignored. Defaults to False.
+            overlap_metric: Metric used to compute the degree of
+                overlap between pairs of masks or boxes (e.g., IoU, IoS).
+
+        Returns:
+            A new Detections object containing the subset of detections
+                after non-maximum merging.
+
+        Note:
+            For detections carrying oriented bounding box data
+            (``data[ORIENTED_BOX_COORDINATES]``), each merge group's output OBB
+            is the tightest rectangle at the winner's orientation enclosing all
+            corners contributed by every detection in the group. The winner is
+            the highest-confidence detection in the group. The axis-aligned
+            ``xyxy`` field is updated to the tight bounding box of that rect.
+            For zero-rotation OBBs this equals the axis-aligned union exactly;
+            for rotated OBBs the merged rect inherits the winner's rotation angle.
+            Groups of size 1 keep the original OBB unchanged.
+
+        Raises:
+            ValueError: If `confidence` is None or `class_id` is None and
+                class_agnostic is False.
+
+        ![non-max-merging](https://media.roboflow.com/supervision-docs/non-max-merging.png){ align=center width="800" }
+        """  # noqa: E501 // docs
+        if len(self) == 0:
+            return self
+
+        if self.confidence is None:
+            raise ValueError(
+                "Detections confidence must be given for NMM to be executed."
+            )
+
+        predictions = self._build_nms_predictions(class_agnostic, "NMM")
+
+        if self.mask is not None:
+            merge_groups = mask_non_max_merge(
+                predictions=predictions,
+                masks=self.mask,
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+        elif ORIENTED_BOX_COORDINATES in self.data:
+            merge_groups = oriented_box_non_max_merge(
+                predictions=predictions,
+                oriented_boxes=np.asarray(self.data[ORIENTED_BOX_COORDINATES]),
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+        else:
+            merge_groups = box_non_max_merge(
+                predictions=predictions,
+                iou_threshold=threshold,
+                overlap_metric=overlap_metric,
+            )
+
+        result: list[Detections] = []
+        for merge_group in merge_groups:
+            group = [self.select(i) for i in merge_group]
+            result.append(_merge_detection_group(group))
+
+        return Detections.merge(result)
+
+
+def _merge_obb_corners(
+    corners_list: list[npt.NDArray[np.number]],
+) -> npt.NDArray[np.floating]:
+    """Merge multiple OBB corner arrays using winner-angle projection.
+
+    The first entry in *corners_list* is the winner. Its orientation angle
+    (derived from its first edge) defines the local frame in which the
+    tightest enclosing axis-aligned rectangle is computed. That rectangle is
+    then rotated back to produce the merged OBB.
+
+    Args:
+        corners_list: List of (4, 2) corner arrays. First is the winner.
+
+    Returns:
+        Merged OBB corners as a (4, 2) floating-point array. Its dtype matches
+        floating inputs and is float64 for integer inputs.
+    """
+    input_dtype = np.result_type(*[corners.dtype for corners in corners_list])
+    output_dtype = (
+        input_dtype if np.issubdtype(input_dtype, np.floating) else np.float64
+    )
+    origin = corners_list[0][0]
+    stacked = np.concatenate(corners_list, axis=0)
+    # Translate to the winner's first corner before any float math so large
+    # integer coordinates (e.g. geospatial or stitched frames) are reduced to
+    # local extents. Object arithmetic keeps those integer differences exact
+    # and avoids unsigned wrap-around for corners lying below the origin.
+    if np.issubdtype(input_dtype, np.integer):
+        all_corners = np.asarray(
+            stacked.astype(object) - origin.astype(object), dtype=np.float64
+        )
+    else:
+        all_corners = stacked.astype(np.float64, copy=False) - origin.astype(
+            np.float64, copy=False
+        )
+    # Use winner's first edge to derive orientation angle -- avoids
+    # cv2.minAreaRect surprises (e.g. 90-degree flip for wide rects). Read it
+    # off the translated corners so it inherits the same wrap-safety.
+    winner_edge = all_corners[1] - all_corners[0]
+    angle = float(np.arctan2(float(winner_edge[1]), float(winner_edge[0])))
+    cos, sin = float(np.cos(angle)), float(np.sin(angle))
+
+    # De-rotate all corners into the winner's local frame
+    to_local = np.array([[cos, -sin], [sin, cos]], dtype=np.float64)
+    local_corners = all_corners @ to_local
+    x_min = float(local_corners[:, 0].min())
+    x_max = float(local_corners[:, 0].max())
+    y_min = float(local_corners[:, 1].min())
+    y_max = float(local_corners[:, 1].max())
+
+    # Rotate the enclosing AABB back to world frame
+    to_world = np.array([[cos, sin], [-sin, cos]], dtype=np.float64)
+    merged: npt.NDArray[np.floating] = (
+        np.array(
+            [[x_min, y_min], [x_max, y_min], [x_max, y_max], [x_min, y_max]],
+            dtype=np.float64,
+        )
+        @ to_world
+    )
+    return cast(npt.NDArray[np.floating], (merged + origin).astype(output_dtype))
+
+
+def _merge_detection_group(detections: list[Detections]) -> Detections:
+    """Merge a group of single-object Detections into one merged detection.
+
+    Used internally by :meth:`Detections.with_nmm` to combine each merge group
+    into a single output detection. The highest-confidence detection is the
+    "winner" whose class_id, tracker_id, and data fields are preserved.
+
+    Args:
+        detections: List of Detections, each containing exactly one object.
+
+    Returns:
+        A single merged Detections object of length 1.
+    """
+    if len(detections) == 1:
+        return detections[0]
+
+    confidences = np.array(
+        [d.confidence[0] if d.confidence is not None else 0.0 for d in detections],
+        dtype=np.float64,
+    )
+    winner_idx = int(np.argmax(confidences))
+    winner = detections[winner_idx]
+
+    # Area-weighted confidence: each box contributes proportionally to its
+    # footprint so large overlapping boxes dominate over small slivers.
+    all_xyxy = np.array([d.xyxy[0] for d in detections])
+    widths = all_xyxy[:, 2] - all_xyxy[:, 0]
+    heights = all_xyxy[:, 3] - all_xyxy[:, 1]
+    areas = widths.astype(np.float64, copy=False) * heights.astype(
+        np.float64, copy=False
+    )
+
+    confidence: npt.NDArray[np.floating] | None
+    if winner.confidence is not None:
+        total_area = float(areas.sum())
+        if total_area > 0:
+            confidence = np.array(
+                [float(np.dot(areas, confidences) / total_area)],
+                dtype=np.float32,
+            )
+        else:
+            confidence = winner.confidence
+    else:
+        confidence = None
+
+    # OBB path: merge corners via winner-angle projection, then derive xyxy
+    # from the merged OBB so both stay consistent.
+    has_obb = ORIENTED_BOX_COORDINATES in winner.data
+    if has_obb:
+        corners_list = []
+        for det in detections:
+            c = np.asarray(det.data[ORIENTED_BOX_COORDINATES])
+            if c.ndim != 3 or c.shape[1:] != (4, 2):
+                raise ValueError(f"corners must have shape (N, 4, 2); got {c.shape}")
+            corners_list.append(c[0].reshape(4, 2))
+        merged_corners = _merge_obb_corners(corners_list)
+        xyxy = xyxyxyxy_to_xyxy(merged_corners[np.newaxis])
+        data = {**winner.data, ORIENTED_BOX_COORDINATES: merged_corners[np.newaxis]}
+    else:
+        # AABB path: union bounding box across all group members
+        xyxy = np.array(
+            [
+                [
+                    all_xyxy[:, 0].min(),
+                    all_xyxy[:, 1].min(),
+                    all_xyxy[:, 2].max(),
+                    all_xyxy[:, 3].max(),
+                ]
+            ],
+            dtype=np.float32,
+        )
+        data = winner.data
+
+    # Mask union via logical OR. Preserve CompactMask outputs without re-cropping
+    # to the merged box, because source masks may legitimately extend outside it.
+    masks = [d.mask for d in detections if d.mask is not None]
+    if masks:
+        if all(isinstance(m, CompactMask) for m in masks):
+            compact_masks = cast(list[CompactMask], masks)
+            image_shape = compact_masks[0].image_shape
+            if any(m.image_shape != image_shape for m in compact_masks):
+                raise ValueError(
+                    "Cannot merge CompactMask objects with different image shapes."
+                )
+            union_mask = np.zeros(image_shape, dtype=bool)
+            for compact_mask in compact_masks:
+                union_mask |= compact_mask.to_dense()[0]
+            union_xyxy = mask_to_xyxy(union_mask[np.newaxis]).astype(np.float32)
+            mask = CompactMask.from_dense(
+                masks=union_mask[np.newaxis],
+                xyxy=union_xyxy,
+                image_shape=image_shape,
+            )
+        else:
+            dense_masks = [
+                m.to_dense() if isinstance(m, CompactMask) else m for m in masks
+            ]
+            mask = np.logical_or.reduce(np.concatenate(dense_masks, axis=0))[np.newaxis]
+    else:
+        mask = None
+
+    metadata = merge_metadata([d.metadata for d in detections])
+
+    return Detections(
+        xyxy=xyxy,
+        mask=mask,
+        confidence=confidence,
+        class_id=winner.class_id,
+        tracker_id=winner.tracker_id,
+        data=data,
+        metadata=metadata,
+    )
+
+
+@deprecated(deprecated_in="0.29.0", remove_in="0.32.0")  # type: ignore[untyped-decorator]
+def merge_inner_detection_object_pair(
+    detections_1: Detections, detections_2: Detections
+) -> Detections:
+    """
+    Merges two Detections objects into a single Detections object.
+    Assumes each Detections contains exactly one object.
+
+    A `winning` detection is determined based on the confidence score of the two
+    input detections. This winning detection is then used to specify which
+    `class_id`, `tracker_id`, and `data` to include in the merged Detections object.
+
+    The resulting `confidence` of the merged object is calculated by the weighted
+    contribution of each detection to the merged object.
+    The bounding boxes and masks of the two input detections are merged into a
+    single bounding box and mask, respectively.
+
+    Args:
+        detections_1: The first Detections object.
+        detections_2: The second Detections object.
+
+    Returns:
+        A new Detections object, with merged attributes.
+
+    Raises:
+        ValueError: If the input Detections objects do not have exactly 1 detected
+            object.
+
+    Example:
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from inference import get_model
+
+        image = cv2.imread("")
+        model = get_model(model_id="yolov8s-640")
+
+        result = model.infer(image)[0]
+        detections = sv.Detections.from_inference(result)
+
+        merged_detections = merge_object_detection_pair(
+            detections[0], detections[1])
+        ```
+    """
+    if len(detections_1) != 1 or len(detections_2) != 1:
+        raise ValueError("Both Detections should have exactly 1 detected object.")
+
+    _validate_fields_both_defined_or_none(detections_1, detections_2)
+
+    xyxy_1 = detections_1.xyxy[0]
+    xyxy_2 = detections_2.xyxy[0]
+    if detections_1.confidence is None and detections_2.confidence is None:
+        merged_confidence = None
+    else:
+        assert detections_1.confidence is not None
+        assert detections_2.confidence is not None
+        detection_1_area = (xyxy_1[2] - xyxy_1[0]) * (xyxy_1[3] - xyxy_1[1])
+        detections_2_area = (xyxy_2[2] - xyxy_2[0]) * (xyxy_2[3] - xyxy_2[1])
+        merged_confidence = (
+            detection_1_area * detections_1.confidence[0]
+            + detections_2_area * detections_2.confidence[0]
+        ) / (detection_1_area + detections_2_area)
+        merged_confidence = np.array([merged_confidence])
+
+    merged_x1, merged_y1 = np.minimum(xyxy_1[:2], xyxy_2[:2])
+    merged_x2, merged_y2 = np.maximum(xyxy_1[2:], xyxy_2[2:])
+    merged_xyxy = np.array([[merged_x1, merged_y1, merged_x2, merged_y2]])
+
+    if detections_1.mask is None and detections_2.mask is None:
+        merged_mask = None
+    else:
+        merged_mask = np.logical_or(
+            cast(npt.NDArray[Any], detections_1.mask),
+            cast(npt.NDArray[Any], detections_2.mask),
+        )
+
+    if detections_1.confidence is None or detections_2.confidence is None:
+        winning_detection = detections_1
+    elif detections_1.confidence[0] >= detections_2.confidence[0]:
+        winning_detection = detections_1
+    else:
+        winning_detection = detections_2
+
+    metadata = merge_metadata([detections_1.metadata, detections_2.metadata])
+
+    return Detections(
+        xyxy=merged_xyxy,
+        mask=merged_mask,
+        confidence=merged_confidence,
+        class_id=winning_detection.class_id,
+        tracker_id=winning_detection.tracker_id,
+        data=winning_detection.data,
+        metadata=metadata,
+    )
+
+
+@deprecated(deprecated_in="0.29.0", remove_in="0.32.0")  # type: ignore[untyped-decorator]
+def merge_inner_detections_objects(
+    detections: list[Detections],
+    threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> Detections:
+    """
+    Given N detections each of length 1 (exactly one object inside), combine them into a
+    single detection object of length 1. The contained inner object will be the merged
+    result of all the input detections.
+
+    For example, this lets you merge N boxes into one big box, N masks into one mask,
+    etc.
+    """
+    detections_1 = detections[0]
+    for detections_2 in detections[1:]:
+        iou = detection_iou(detections_1, detections_2, overlap_metric)[0]
+        if iou < threshold:
+            break
+        detections_1 = merge_inner_detection_object_pair(detections_1, detections_2)
+    return detections_1
+
+
+@deprecated(deprecated_in="0.29.0", remove_in="0.32.0")  # type: ignore[untyped-decorator]
+def merge_inner_detections_objects_without_iou(
+    detections: list[Detections],
+) -> Detections:
+    """
+    Given N detections each of length 1 (exactly one object inside), combine them into a
+    single detection object of length 1. The contained inner object will be the merged
+    result of all the input detections.
+
+    For example, this lets you merge N boxes into one big box, N masks into one mask,
+    etc.
+    """
+    return reduce(merge_inner_detection_object_pair, detections)
+
+
+def _validate_fields_both_defined_or_none(
+    detections_1: Detections, detections_2: Detections
+) -> None:
+    """
+    Verify that for each optional field in the Detections, both instances either have
+    the field set to None or both have it set to non-None values.
+
+    `data` field is ignored.
+
+    Raises:
+        ValueError: If one field is None and the other is not, for any of the fields.
+    """
+    attributes = get_instance_variables(detections_1)
+    for attribute in attributes:
+        value_1 = getattr(detections_1, attribute)
+        value_2 = getattr(detections_2, attribute)
+
+        if (value_1 is None) != (value_2 is None):
+            raise ValueError(
+                f"Field '{attribute}' should be consistently None or not None in both "
+                "Detections."
+            )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_fields_both_defined_or_none,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_fields_both_defined_or_none(
+    detections_1: Detections, detections_2: Detections
+) -> None:
+    void(detections_1, detections_2)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/line_zone.py b/.venv/lib/python3.12/site-packages/supervision/detection/line_zone.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f1c5a63bb2d9b397ce4ed7eac999dbe23e49777
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/line_zone.py
@@ -0,0 +1,955 @@
+import math
+import warnings
+from collections import Counter, defaultdict, deque
+from collections.abc import Iterable
+from functools import lru_cache
+from itertools import islice
+from typing import Literal
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.detection.core import Detections
+from supervision.detection.utils.internal import cross_product
+from supervision.draw.color import Color
+from supervision.draw.utils import draw_rectangle, draw_text
+from supervision.geometry.core import Point, Position, Rect, Vector
+from supervision.utils.image import _overlay_image
+from supervision.utils.internal import SupervisionWarnings
+
+TEXT_MARGIN = 10
+
+
+class LineZone:
+    """
+    This class is responsible for counting the number of objects that cross a
+    predefined line.
+
+    
+
+    !!! warning
+
+        LineZone uses the `tracker_id`. Read
+        [here](/latest/trackers/) to learn how to plug
+        tracking into your inference pipeline.
+
+    Attributes:
+        in_count: The number of objects that have crossed the line from outside
+            to inside.
+        out_count: The number of objects that have crossed the line from inside
+            to outside.
+        in_count_per_class: Number of objects of each class that have
+            crossed the line from outside to inside, keyed by `class_id`
+            (`int` for classified detections, `None` for unclassified ones).
+        out_count_per_class: Number of objects of each class that have
+            crossed the line from inside to outside, keyed by `class_id`
+            (`int` for classified detections, `None` for unclassified ones).
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> def frames_generator():
+        ...     yield np.zeros((1080, 1920, 3), dtype=np.uint8)
+        ...
+        >>> start = sv.Point(x=0, y=100)
+        >>> end = sv.Point(x=200, y=100)
+        >>> line_zone = sv.LineZone(start=start, end=end)
+        >>> for frame in frames_generator():
+        ...     detections = sv.Detections(
+        ...         xyxy=np.array([[10, 110, 20, 150]]),
+        ...         tracker_id=np.array([1])
+        ...     )
+        ...     crossed_in, crossed_out = line_zone.trigger(
+        ...         detections
+        ...     )
+        ...
+        >>> line_zone.in_count, line_zone.out_count
+        (0, 0)
+        >>> for frame in frames_generator():
+        ...     detections = sv.Detections(
+        ...         xyxy=np.array([[10, 50, 20, 90]]),
+        ...         tracker_id=np.array([1])
+        ...     )
+        ...     crossed_in, crossed_out = line_zone.trigger(
+        ...         detections
+        ...     )
+        ...
+        >>> line_zone.in_count, line_zone.out_count
+        (1, 0)
+
+        ```
+    """
+
+    def __init__(
+        self,
+        start: Point,
+        end: Point,
+        triggering_anchors: Iterable[Position] = (
+            Position.TOP_LEFT,
+            Position.TOP_RIGHT,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        ),
+        minimum_crossing_threshold: int = 1,
+    ) -> None:
+        """
+        Args:
+            start: The starting point of the line.
+            end: The ending point of the line.
+            triggering_anchors: Any iterable of positions specifying which anchors
+                of the detections bounding box to consider when deciding on whether
+                the detection has passed the line counter or not. By default,
+                this contains the four corners of the detection's bounding box.
+            minimum_crossing_threshold: Detection needs to be seen on the other
+                side of the line for this many consecutive observations to be
+                considered as having crossed the line. Only frames that place the
+                detection on one side of the line count: a frame in which it is
+                temporarily missing, falls outside the line's limits, or straddles
+                the line is skipped, and neither extends the run nor resets it.
+                This is useful when dealing with unstable bounding boxes or when
+                detections may linger on the line. Excursions shorter than this
+                are treated as noise: they neither count as a crossing nor as a
+                return crossing once the detection settles back on the side it
+                started from. This holds only for excursions from a side the
+                detection is already established on — the first side it is seen
+                on, at the start of its life and again after it has been absent
+                long enough for its state to be dropped, becomes its reference
+                immediately, with no confirmation.
+        """
+        self.vector = Vector(start=start, end=end)
+        self.limits = self._calculate_region_of_interest_limits(vector=self.vector)
+        self.crossing_history_length = max(2, minimum_crossing_threshold + 1)
+        self.crossing_state_history: dict[int, deque[bool]] = defaultdict(
+            lambda: deque(maxlen=self.crossing_history_length)
+        )
+        # Last side of the line a tracker was *confirmed* on. Crossings are counted
+        # against this rather than against the oldest history entry, so a
+        # sub-threshold excursion never becomes the reference side once a reference
+        # exists, and cannot be mistaken for a crossing back to the side the tracker
+        # never left. The reference itself is seeded by the first observation with no
+        # confirmation, so a noisy first frame — at the start of a tracker's life or
+        # on its first frame back after eviction — still decides where it starts.
+        self._confirmed_crossing_side: dict[int, bool] = {}
+        # Tracks consecutive frames a tracker key has been absent; eviction
+        # requires crossing_history_length absent frames so that ByteTrack
+        # coasting gaps (single-frame detection drops) don't reset mid-crossing
+        # state prematurely.
+        self._tracker_frames_absent: dict[int, int] = {}
+        self._in_count_per_class: Counter[int | None] = Counter()
+        self._out_count_per_class: Counter[int | None] = Counter()
+        # Materialize once so we can safely accept generators without exhausting them.
+        self.triggering_anchors = list(triggering_anchors)
+        if not self.triggering_anchors:
+            raise ValueError("Triggering anchors cannot be empty.")
+        self.class_id_to_name: dict[int, str] = {}
+
+    @property
+    def in_count(self) -> int:
+        return sum(self._in_count_per_class.values())
+
+    @property
+    def out_count(self) -> int:
+        return sum(self._out_count_per_class.values())
+
+    @property
+    def in_count_per_class(self) -> dict[int | None, int]:
+        return dict(self._in_count_per_class)
+
+    @property
+    def out_count_per_class(self) -> dict[int | None, int]:
+        return dict(self._out_count_per_class)
+
+    def trigger(
+        self, detections: Detections
+    ) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
+        """
+        Update the `in_count` and `out_count` based on the objects that cross the line.
+
+        Args:
+            detections: A Detections object for which to update the counts.
+
+        Returns:
+            A tuple of two boolean NumPy arrays. The first array indicates which
+                detections have crossed the line from outside to inside. The second
+                array indicates which detections have crossed the line from inside to
+                outside.
+        """
+        crossed_in = np.full(len(detections), False)
+        crossed_out = np.full(len(detections), False)
+
+        if len(detections) == 0:
+            self._evict_stale_crossing_history(set())
+            return crossed_in, crossed_out
+
+        if detections.tracker_id is None:
+            warnings.warn(
+                "Line zone counting skipped. LineZone requires tracker_id. Refer to "
+                "https://supervision.roboflow.com/latest/trackers for more "
+                "information.",
+                category=SupervisionWarnings,
+            )
+            return crossed_in, crossed_out
+
+        class_ids: list[int | None] = (
+            list(detections.class_id)
+            if detections.class_id is not None
+            else [None] * len(detections)
+        )
+        current_keys = {int(tracker_id) for tracker_id in detections.tracker_id}
+        self._evict_stale_crossing_history(current_keys)
+        self._update_class_id_to_name(detections)
+
+        in_limits, has_any_left_trigger, has_any_right_trigger = (
+            self._compute_anchor_sides(detections)
+        )
+
+        for i, (class_id, tracker_id) in enumerate(
+            zip(class_ids, detections.tracker_id)
+        ):
+            if not in_limits[i]:
+                continue
+
+            if has_any_left_trigger[i] and has_any_right_trigger[i]:
+                continue
+
+            tracker_state = bool(has_any_left_trigger[i])
+            key = int(tracker_id)
+            crossing_history = self.crossing_state_history[key]
+            crossing_history.append(tracker_state)
+            # The first observed side seeds the reference; there is nothing to have
+            # crossed from before it.
+            confirmed_side = self._confirmed_crossing_side.setdefault(
+                key, tracker_state
+            )
+
+            # Subsumed by the confirmed-side check that follows, but not removable:
+            # this is what guarantees the deque is full — exactly
+            # crossing_history_length entries — by the time the sustained-run check
+            # below reads it. Without it a partial window would satisfy that check
+            # after a single frame on the new side.
+            if len(crossing_history) < self.crossing_history_length:
+                continue
+
+            if tracker_state == confirmed_side:
+                continue
+
+            # Only promote the new side once it has been held for the full threshold,
+            # so a flicker that reverts before the threshold elapses is discarded.
+            # The gate above leaves exactly crossing_history_length entries, so
+            # skipping the oldest one leaves precisely the minimum_crossing_threshold
+            # frames that must all be on the new side.
+            sustained_run = islice(crossing_history, 1, None)
+            if any(state != tracker_state for state in sustained_run):
+                continue
+
+            self._confirmed_crossing_side[key] = tracker_state
+
+            if tracker_state:
+                self._in_count_per_class[class_id] += 1
+                crossed_in[i] = True
+            else:
+                self._out_count_per_class[class_id] += 1
+                crossed_out[i] = True
+
+        return crossed_in, crossed_out
+
+    def _evict_stale_crossing_history(self, current_keys: set[int]) -> None:
+        for key in list(self.crossing_state_history):
+            if key in current_keys:
+                self._tracker_frames_absent.pop(key, None)
+            else:
+                absent = self._tracker_frames_absent.get(key, 0) + 1
+                if absent >= self.crossing_history_length:
+                    del self.crossing_state_history[key]
+                    self._confirmed_crossing_side.pop(key, None)
+                    self._tracker_frames_absent.pop(key, None)
+                else:
+                    self._tracker_frames_absent[key] = absent
+
+    @staticmethod
+    def _calculate_region_of_interest_limits(vector: Vector) -> tuple[Vector, Vector]:
+        magnitude = vector.magnitude
+
+        if magnitude == 0:
+            raise ValueError("The magnitude of the vector cannot be zero.")
+
+        delta_x = vector.end.x - vector.start.x
+        delta_y = vector.end.y - vector.start.y
+
+        unit_vector_x = delta_x / magnitude
+        unit_vector_y = delta_y / magnitude
+
+        perpendicular_vector_x = -unit_vector_y
+        perpendicular_vector_y = unit_vector_x
+
+        start_region_limit = Vector(
+            start=vector.start,
+            end=Point(
+                x=vector.start.x + perpendicular_vector_x,
+                y=vector.start.y + perpendicular_vector_y,
+            ),
+        )
+        end_region_limit = Vector(
+            start=vector.end,
+            end=Point(
+                x=vector.end.x - perpendicular_vector_x,
+                y=vector.end.y - perpendicular_vector_y,
+            ),
+        )
+        return start_region_limit, end_region_limit
+
+    def _compute_anchor_sides(
+        self, detections: Detections
+    ) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.bool_], npt.NDArray[np.bool_]]:
+        """
+        Find if detections' anchors are within the limit of the line
+        zone and which anchors are on its left and right side.
+
+        Assumes:
+            * At least 1 detection is provided
+            * Detections have `tracker_id`
+
+        The limit is defined as the region between the two lines,
+        perpendicular to the line zone, and passing through its start
+        and end points, as shown below:
+
+        Limits:
+        ```
+                |    IN    ↑
+                |          |
+          OUT   o---LINE---o   OUT
+                |          |
+                ↓    IN    |
+        ```
+
+        Args:
+            detections: The detections to check.
+
+        Returns:
+            All 3 arrays are boolean arrays of shape (N, ) where N is the
+                number of detections. The first array, `in_limits`, indicates
+                if the detection's anchor is within the line zone limits.
+                The second array, `has_any_left_trigger`, indicates if the
+                detection's anchor is on the left side of the line zone.
+                The third array, `has_any_right_trigger`, indicates if the
+                detection's anchor is on the right side of the line zone.
+        """
+        assert len(detections) > 0
+        assert detections.tracker_id is not None
+
+        all_anchors = np.array(
+            [
+                detections.get_anchors_coordinates(anchor)
+                for anchor in self.triggering_anchors
+            ]
+        )
+
+        cross_products_1 = cross_product(all_anchors, self.limits[0])
+        cross_products_2 = cross_product(all_anchors, self.limits[1])
+
+        # Works because limit vectors are pointing in opposite directions
+        in_limits = (cross_products_1 > 0) == (cross_products_2 > 0)
+        in_limits = np.all(in_limits, axis=0)
+
+        triggers = cross_product(all_anchors, self.vector) < 0
+        has_any_left_trigger = np.any(triggers, axis=0)
+        has_any_right_trigger = np.any(~triggers, axis=0)
+
+        return in_limits, has_any_left_trigger, has_any_right_trigger
+
+    def _update_class_id_to_name(self, detections: Detections) -> None:
+        """
+        Update the attribute keeping track of which class
+        IDs correspond to which class names.
+
+        Assumes that class_names are only provided when class_ids are.
+        """
+        class_names = detections.data.get(CLASS_NAME_DATA_FIELD)
+        assert class_names is None or detections.class_id is not None
+
+        if detections.class_id is None:
+            return
+
+        if class_names is None:
+            new_names = {class_id: str(class_id) for class_id in detections.class_id}
+        else:
+            new_names = {
+                class_id: class_name
+                for class_id, class_name in zip(detections.class_id, class_names)
+            }
+        self.class_id_to_name.update(new_names)
+
+
+class LineZoneAnnotator:
+    """
+    Draw a `LineZone` and its in/out counts on a video frame.
+
+    Use this annotator after calling `LineZone.trigger` so the rendered counts
+    reflect the latest tracked detections.
+    """
+
+    def __init__(
+        self,
+        thickness: int = 2,
+        color: Color = Color.WHITE,
+        text_thickness: int = 2,
+        text_color: Color = Color.BLACK,
+        text_scale: float = 0.5,
+        text_offset: float = 1.5,
+        text_padding: int = 10,
+        custom_in_text: str | None = None,
+        custom_out_text: str | None = None,
+        display_in_count: bool = True,
+        display_out_count: bool = True,
+        display_text_box: bool = True,
+        text_orient_to_line: bool = False,
+        text_centered: bool = True,
+    ) -> None:
+        """
+        A class for drawing the `LineZone` and its detected object count
+        on an image.
+
+        Args:
+            thickness: Line thickness.
+            color: Line color.
+            text_thickness: Text thickness.
+            text_color: Text color.
+            text_scale: Text scale.
+            text_offset: How far the text will be from the line.
+            text_padding: The empty space in the text box, surrounding the text.
+            custom_in_text: Write something else instead of "in".
+            custom_out_text: Write something else instead of "out".
+            display_in_count: Pass `False` to hide the "in" count.
+            display_out_count: Pass `False` to hide the "out" count.
+            display_text_box: Pass `False` to hide the text background box.
+            text_orient_to_line: Match text orientation to the line.
+                Recommended to set to `True`.
+            text_centered: Pass `False` to disable text centering. Useful
+                when the label overlaps something important.
+
+        """
+        self.thickness: int = thickness
+        self.color: Color = color
+        self.text_thickness: int = text_thickness
+        self.text_color: Color = text_color
+        self.text_scale: float = text_scale
+        self.text_offset: float = text_offset
+        self.text_padding: int = text_padding
+        self.in_text: str = custom_in_text if custom_in_text else "in"
+        self.out_text: str = custom_out_text if custom_out_text else "out"
+        self.display_in_count: bool = display_in_count
+        self.display_out_count: bool = display_out_count
+        self.display_text_box: bool = display_text_box
+        self.text_orient_to_line: bool = text_orient_to_line
+        self.text_centered: bool = text_centered
+
+    def annotate(
+        self, frame: npt.NDArray[np.uint8], line_counter: LineZone
+    ) -> npt.NDArray[np.uint8]:
+        """
+        Draws the line on the frame using the line zone provided.
+
+        Args:
+            frame: The image on which the line will be drawn.
+            line_counter: The line zone that will be used to draw the line.
+
+        Returns:
+            The image with the line drawn on it.
+
+        """
+        line_start = line_counter.vector.start.as_xy_int_tuple()
+        line_end = line_counter.vector.end.as_xy_int_tuple()
+        cv2.line(
+            frame,
+            line_start,
+            line_end,
+            self.color.as_bgr(),
+            self.thickness,
+            lineType=cv2.LINE_AA,
+            shift=0,
+        )
+        cv2.circle(
+            frame,
+            line_start,
+            radius=5,
+            color=self.text_color.as_bgr(),
+            thickness=-1,
+            lineType=cv2.LINE_AA,
+        )
+        cv2.circle(
+            frame,
+            line_end,
+            radius=5,
+            color=self.text_color.as_bgr(),
+            thickness=-1,
+            lineType=cv2.LINE_AA,
+        )
+
+        in_text = f"{self.in_text}: {line_counter.in_count}"
+        out_text = f"{self.out_text}: {line_counter.out_count}"
+        line_angle_degrees = self._get_line_angle(line_counter)
+
+        for text, is_shown, is_in_count in [
+            (in_text, self.display_in_count, True),
+            (out_text, self.display_out_count, False),
+        ]:
+            if not is_shown:
+                continue
+
+            if line_angle_degrees == 0 or not self.text_orient_to_line:
+                self._draw_basic_label(
+                    frame=frame,
+                    line_center=line_counter.vector.center,
+                    text=text,
+                    is_in_count=is_in_count,
+                )
+            else:
+                self._draw_oriented_label(
+                    frame=frame,
+                    line_zone=line_counter,
+                    text=text,
+                    is_in_count=is_in_count,
+                )
+
+        return frame
+
+    def _get_line_angle(self, line_zone: LineZone) -> float:
+        """
+        Calculate the line counter angle (in degrees).
+
+        Args:
+            line_zone: The line zone object.
+
+        Returns:
+            Line counter angle, in degrees.
+        """
+        start_point = line_zone.vector.start.as_xy_int_tuple()
+        end_point = line_zone.vector.end.as_xy_int_tuple()
+
+        delta_x = end_point[0] - start_point[0]
+        delta_y = end_point[1] - start_point[1]
+
+        if delta_x == 0:
+            line_angle = 90.0
+            line_angle += 180 if delta_y < 0 else 0
+        else:
+            line_angle = math.degrees(math.atan(delta_y / delta_x))
+            line_angle += 180 if delta_x < 0 else 0
+
+        return line_angle
+
+    def _calculate_anchor_in_frame(
+        self,
+        line_zone: LineZone,
+        text_width: int,
+        text_height: int,
+        is_in_count: bool,
+        label_dimension: int,
+    ) -> tuple[int, int]:
+        """
+        Calculate insertion anchor in frame to position the center of the count image.
+
+        Args:
+            line_zone: The line counter object used for counting.
+            text_width: Text width.
+            text_height: Text height.
+            is_in_count: Whether the count should be placed over or below line.
+            label_dimension: Size of the label image. Assumes the
+                label is rectangular.
+
+        Returns:
+            xy, point in an image where the label will be placed.
+        """
+        line_angle = self._get_line_angle(line_zone)
+
+        if self.text_centered:
+            mid_point = Vector(
+                start=line_zone.vector.start, end=line_zone.vector.end
+            ).center.as_xy_int_tuple()
+            anchor = list(mid_point)
+        else:
+            end_point = line_zone.vector.end.as_xy_int_tuple()
+            anchor = list(end_point)
+
+            move_along_x = int(
+                math.cos(math.radians(line_angle))
+                * (text_width / 2 + self.text_padding)
+            )
+            move_along_y = int(
+                math.sin(math.radians(line_angle))
+                * (text_width / 2 + self.text_padding)
+            )
+
+            anchor[0] -= move_along_x
+            anchor[1] -= move_along_y
+
+        move_perpendicular_x = int(
+            math.sin(math.radians(line_angle)) * (self.text_offset * text_height)
+        )
+        move_perpendicular_y = int(
+            math.cos(math.radians(line_angle)) * (self.text_offset * text_height)
+        )
+
+        if is_in_count:
+            anchor[0] += move_perpendicular_x
+            anchor[1] -= move_perpendicular_y
+        else:
+            anchor[0] -= move_perpendicular_x
+            anchor[1] += move_perpendicular_y
+
+        x1 = max(anchor[0] - label_dimension // 2, 0)
+        y1 = max(anchor[1] - label_dimension // 2, 0)
+
+        return x1, y1
+
+    def _draw_basic_label(
+        self,
+        frame: npt.NDArray[np.uint8],
+        line_center: Point,
+        text: str,
+        is_in_count: bool,
+    ) -> npt.NDArray[np.uint8]:
+        """
+        Draw the count label on the frame. For example: "out: 7".
+        The label contains horizontal text and is not rotated.
+
+        Args:
+            frame: The entire scene, on which the label will be placed.
+            line_center: The center of the line zone.
+            text: The text that will be drawn.
+            is_in_count: Whether to display the in count (above line)
+                or out count (below line).
+
+        Returns:
+            The scene with the label drawn on it.
+        """
+        _, text_height = cv2.getTextSize(
+            text, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness
+        )[0]
+
+        if is_in_count:
+            line_center.y -= int(self.text_offset * text_height)
+        else:
+            line_center.y += int(self.text_offset * text_height)
+
+        draw_text(
+            scene=frame,
+            text=text,
+            text_anchor=line_center,
+            text_color=self.text_color,
+            text_scale=self.text_scale,
+            text_thickness=self.text_thickness,
+            text_padding=self.text_padding,
+            background_color=self.color if self.display_text_box else None,
+        )
+
+        return frame
+
+    def _draw_oriented_label(
+        self,
+        frame: npt.NDArray[np.uint8],
+        line_zone: LineZone,
+        text: str,
+        is_in_count: bool,
+    ) -> npt.NDArray[np.uint8]:
+        """
+        Draw the count label on the frame. For example: "out: 7".
+        The label is oriented to match the line angle.
+
+        Args:
+            frame: The entire scene, on which the label will be placed.
+            line_zone: The line zone responsible for counting objects crossing it.
+            text: The text that will be drawn.
+            is_in_count: Whether to display the in count (above line)
+                or out count (below line).
+
+        Returns:
+            The scene with the label drawn on it.
+        """
+
+        line_angle_degrees = self._get_line_angle(line_zone)
+        label_image = self._make_label_image(
+            text,
+            text_scale=self.text_scale,
+            text_thickness=self.text_thickness,
+            text_padding=self.text_padding,
+            text_color=self.text_color,
+            text_box_show=self.display_text_box,
+            text_box_color=self.color,
+            line_angle_degrees=line_angle_degrees,
+        )
+        assert label_image.shape[0] == label_image.shape[1]
+
+        text_width, text_height = cv2.getTextSize(
+            text, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness
+        )[0]
+
+        label_anchor = self._calculate_anchor_in_frame(
+            line_zone=line_zone,
+            text_width=text_width,
+            text_height=text_height,
+            is_in_count=is_in_count,
+            label_dimension=label_image.shape[0],
+        )
+
+        frame = _overlay_image(frame, label_image, label_anchor)
+
+        return frame
+
+    @staticmethod
+    @lru_cache(maxsize=32)
+    def _make_label_image(
+        text: str,
+        *,
+        text_scale: float,
+        text_thickness: int,
+        text_padding: int,
+        text_color: Color,
+        text_box_show: bool,
+        text_box_color: Color,
+        line_angle_degrees: float,
+    ) -> npt.NDArray[np.uint8]:
+        """
+        Create the small text box displaying line zone count. E.g. "out: 7".
+
+        Args:
+            text: The text to display.
+            text_scale: The scale of the text.
+            text_thickness: The thickness of the text.
+            text_padding: The padding around the text.
+            text_color: The color of the text.
+            text_box_show: Whether to display the text box.
+            text_box_color: The color of the text box.
+            line_angle_degrees: The angle of the line in degrees.
+
+        Returns:
+            The label of shape (H, W, 4), in BGRA format.
+        """
+        text_width, text_height = cv2.getTextSize(
+            text, cv2.FONT_HERSHEY_SIMPLEX, text_scale, text_thickness
+        )[0]
+
+        annotation_dim = int((max(text_width, text_height) + text_padding * 2) * 1.5)
+        annotation_shape = (annotation_dim, annotation_dim)
+        annotation_center = Point(annotation_dim // 2, annotation_dim // 2)
+
+        annotation: npt.NDArray[np.uint8] = np.zeros(
+            (*annotation_shape, 3), dtype=np.uint8
+        )
+        annotation_alpha: npt.NDArray[np.uint8] = np.zeros(
+            (*annotation_shape, 1), dtype=np.uint8
+        )
+        draw_text(
+            scene=annotation,
+            text=text,
+            text_anchor=annotation_center,
+            text_scale=text_scale,
+            text_thickness=text_thickness,
+            text_padding=text_padding,
+            text_color=text_color,
+            background_color=text_box_color if text_box_show else None,
+        )
+        draw_text(
+            scene=annotation_alpha,
+            text=text,
+            text_anchor=annotation_center,
+            text_scale=text_scale,
+            text_thickness=text_thickness,
+            text_padding=text_padding,
+            text_color=Color.WHITE,
+            background_color=Color.WHITE if text_box_show else None,
+        )
+        annotation = np.dstack((annotation, annotation_alpha)).astype(np.uint8)
+
+        # Make sure text is displayed upright
+        if 90 < line_angle_degrees % 360 < 270:
+            annotation = cv2.flip(annotation, flipCode=-1).astype(np.uint8)
+
+        from PIL import Image
+
+        annotation = np.asarray(
+            Image.fromarray(annotation).rotate(
+                -line_angle_degrees,
+                resample=Image.Resampling.BILINEAR,
+                center=annotation_center.as_xy_float_tuple(),
+            )
+        ).astype(np.uint8)
+
+        return annotation
+
+
+class LineZoneAnnotatorMulticlass:
+    """
+    Draw per-class crossing counts for one or more `LineZone` instances.
+
+    The annotator renders a table with one row per line zone and one column per
+    class observed by the zones.
+    """
+
+    def __init__(
+        self,
+        *,
+        table_position: Literal[
+            Position.TOP_LEFT,
+            Position.TOP_RIGHT,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        ] = Position.TOP_RIGHT,
+        table_color: Color = Color.WHITE,
+        table_margin: int = 10,
+        table_padding: int = 10,
+        table_max_width: int = 400,
+        text_color: Color = Color.BLACK,
+        text_scale: float = 0.75,
+        text_thickness: int = 1,
+        force_draw_class_ids: bool = False,
+    ) -> None:
+        """
+        Draw a table showing how many items of each class crossed each line.
+
+        Args:
+            table_position: The position of the table.
+            table_color: The color of the table.
+            table_margin: The margin of the table from the image border.
+            table_padding: The padding of the table.
+            table_max_width: The maximum width of the table.
+            text_color: The color of the text.
+            text_scale: The scale of the text.
+            text_thickness: The thickness of the text.
+            force_draw_class_ids: Instead of writing the class names,
+                on the table, write the class IDs. E.g. instead of `person: 6`,
+                write `0: 6`.
+        """
+        if table_position not in {
+            Position.TOP_LEFT,
+            Position.TOP_RIGHT,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        }:
+            raise ValueError(
+                "Invalid table position. Supported values are:"
+                " TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT."
+            )
+
+        self.table_position = table_position
+        self.table_color = table_color
+        self.table_margin = table_margin
+        self.table_padding = table_padding
+        self.table_max_width = table_max_width
+        self.text_color = text_color
+        self.text_scale = text_scale
+        self.text_thickness = text_thickness
+        self.force_draw_class_ids = force_draw_class_ids
+
+    def annotate(
+        self,
+        frame: npt.NDArray[np.uint8],
+        line_zones: list[LineZone],
+        line_zone_labels: list[str] | None = None,
+    ) -> npt.NDArray[np.uint8]:
+        """
+        Draws a table with the number of objects of each class that crossed each line.
+
+        Args:
+            frame: The image on which the table will be drawn.
+            line_zones: The line zones to be annotated.
+            line_zone_labels: The labels, one for each line zone. If not
+                provided, the default labels will be used.
+
+        Returns:
+            The image with the table drawn on it.
+
+        """
+        if line_zone_labels is None:
+            line_zone_labels = [f"Line {i + 1}:" for i in range(len(line_zones))]
+        if len(line_zones) != len(line_zone_labels):
+            raise ValueError("The number of line zones and their labels must match.")
+
+        text_lines = ["Line Crossings:"]
+        for line_zone, line_zone_label in zip(line_zones, line_zone_labels):
+            text_lines.append(line_zone_label)
+            class_id_to_name = line_zone.class_id_to_name
+
+            for direction, count_per_class in [
+                ("In", line_zone.in_count_per_class),
+                ("Out", line_zone.out_count_per_class),
+            ]:
+                if not count_per_class:
+                    continue
+
+                text_lines.append(f" {direction}:")
+                for class_id, count in count_per_class.items():
+                    if self.force_draw_class_ids:
+                        class_name = str(class_id)
+                    elif class_id is None:
+                        class_name = "None"
+                    else:
+                        class_name = class_id_to_name.get(class_id, str(class_id))
+                    text_lines.append(f"  {class_name}: {count}")
+
+        table_width, table_height = 0, 0
+        for line in text_lines:
+            text_width, text_height = cv2.getTextSize(
+                line, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness
+            )[0]
+            text_height += TEXT_MARGIN
+            table_width = max(table_width, text_width)
+            table_height += text_height
+
+        table_width += 2 * self.table_padding
+        table_height += 2 * self.table_padding
+        table_max_height = frame.shape[0] - 2 * self.table_margin
+        table_height = min(table_height, table_max_height)
+        table_width = min(table_width, self.table_max_width)
+
+        position_map = {
+            Position.TOP_LEFT: (self.table_margin, self.table_margin),
+            Position.TOP_RIGHT: (
+                frame.shape[1] - table_width - self.table_margin,
+                self.table_margin,
+            ),
+            Position.BOTTOM_LEFT: (
+                self.table_margin,
+                frame.shape[0] - table_height - self.table_margin,
+            ),
+            Position.BOTTOM_RIGHT: (
+                frame.shape[1] - table_width - self.table_margin,
+                frame.shape[0] - table_height - self.table_margin,
+            ),
+        }
+        table_x1, table_y1 = position_map[self.table_position]
+
+        table_rect = Rect(
+            x=table_x1, y=table_y1, width=table_width, height=table_height
+        )
+        frame = draw_rectangle(
+            scene=frame, rect=table_rect, color=self.table_color, thickness=-1
+        )
+
+        for i, line in enumerate(text_lines):
+            _, text_height = cv2.getTextSize(
+                line, cv2.FONT_HERSHEY_SIMPLEX, self.text_scale, self.text_thickness
+            )[0]
+            text_height += TEXT_MARGIN
+            anchor_x = table_x1 + self.table_padding
+            anchor_y = table_y1 + self.table_padding + (i + 1) * text_height
+
+            cv2.putText(
+                img=frame,
+                text=line,
+                org=(anchor_x, anchor_y),
+                fontFace=cv2.FONT_HERSHEY_SIMPLEX,
+                fontScale=self.text_scale,
+                color=self.text_color.as_bgr(),
+                thickness=self.text_thickness,
+                lineType=cv2.LINE_AA,
+            )
+
+        return frame
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__init__.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c22684a92f586de43b912aab0bedba9b9ea4cea
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/csv_sink.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/csv_sink.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7cdf0a2002a84f91d82c2543adbb9fde426d81d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/csv_sink.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/inference_slicer.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/inference_slicer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8186ffb866e155beeb6b6ca0e0d86c58d28abdc3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/inference_slicer.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/json_sink.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/json_sink.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a3e1bf62462209e5e314df28851774e4a277648
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/json_sink.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/polygon_zone.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/polygon_zone.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1527e2b6c9f541e4fdfb8054cd2ef4e198a05a2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/polygon_zone.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/smoother.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/smoother.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6cb38816ce7ed82323818986958ceba91ef9c858
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/smoother.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/transformers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/transformers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32de3b43c4c085b64021e9bc19b3acad642a0133
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/tools/__pycache__/transformers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/csv_sink.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/csv_sink.py
new file mode 100644
index 0000000000000000000000000000000000000000..b954adf896fdde4f4776aac9be19fbe7a7ba4769
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/csv_sink.py
@@ -0,0 +1,280 @@
+from __future__ import annotations
+
+import csv
+import io
+import os
+from collections.abc import Iterable
+from typing import Any, Protocol
+
+import numpy as np
+
+from supervision.detection.core import Detections
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+BASE_HEADER = [
+    "x_min",
+    "y_min",
+    "x_max",
+    "y_max",
+    "class_id",
+    "confidence",
+    "tracker_id",
+]
+
+
+class WriterProtocol(Protocol):
+    def writerow(self, row: Iterable[Any]) -> Any: ...
+
+
+class CSVSink:
+    """
+    A utility class for saving detection data to a CSV file. This class is designed to
+    efficiently serialize detection objects into a CSV format, allowing for the
+    inclusion of bounding box coordinates and additional attributes like `confidence`,
+    `class_id`, and `tracker_id`.
+
+    !!! tip
+
+        CSVSink allows passing custom data alongside detection fields, providing
+        flexibility for logging various types of information.
+        When a NumPy array, list, or tuple value in custom_data (or
+        detections.data) has the same length as the detection count, each
+        element is written to the corresponding detection row; any other value
+        is broadcast to all rows.
+
+    Args:
+        file_name: The name of the CSV file where the detections will be stored.
+            Defaults to 'output.csv'.
+
+    Example:
+        ```pycon
+        >>> import supervision as sv
+        >>> import numpy as np
+        >>> import tempfile
+        >>> import os
+        >>> # Create synthetic detections
+        >>> detections = sv.Detections(
+        ...     xyxy=np.array([[10, 20, 30, 40], [50, 60, 70, 80]]),
+        ...     confidence=np.array([0.9, 0.8]),
+        ...     class_id=np.array([0, 1])
+        ... )
+        >>> # Use temporary file
+        >>> temp_file = tempfile.NamedTemporaryFile(
+        ...     mode='w', suffix='.csv', delete=False
+        ... )
+        >>> temp_file.close()
+        >>> csv_sink = sv.CSVSink(temp_file.name)
+        >>> with csv_sink as sink:
+        ...     sink.append(detections, custom_data={'frame': 0})
+        >>> os.unlink(temp_file.name)  # Clean up
+
+        ```
+    """
+
+    def __init__(self, file_name: str = "output.csv") -> None:
+        """
+        Initialize the CSVSink instance.
+
+        Args:
+            file_name: The name of the CSV file.
+        """
+        self.file_name = file_name
+        self.file: io.TextIOWrapper | None = None
+        self.writer: WriterProtocol | None = None
+        self.header_written = False
+        self.field_names: list[str] = []
+        self.deferred_field_names: list[str] = []
+
+    def __enter__(self) -> CSVSink:
+        self.open()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type | None,
+        exc_val: Exception | None,
+        exc_tb: Any | None,
+    ) -> None:
+        self.close()
+
+    def open(self) -> None:
+        """
+        Open the CSV file for writing.
+        """
+        parent_directory = os.path.dirname(self.file_name)
+        if parent_directory and not os.path.exists(parent_directory):
+            os.makedirs(parent_directory)
+
+        self.file = open(self.file_name, "w", newline="")
+        self.writer = csv.writer(self.file)
+        self.header_written = False
+        self.field_names = []
+        self.deferred_field_names = []
+
+    def close(self) -> None:
+        """
+        Close the CSV file.
+
+        When every appended batch was empty no header has been written yet, so
+        the schema remembered from the first such batch is emitted here. This
+        keeps a run that never detected anything readable as an empty table
+        rather than as a zero-byte file.
+        """
+        if self.file is None or self.file.closed:
+            return
+
+        # close() also runs from __exit__, so a writer raising here would both leak
+        # the file handle and replace the with-body's own exception. Closing in a
+        # finally keeps the handle released and lets the original error surface.
+        try:
+            if not self.header_written and self.deferred_field_names and self.writer:
+                self.field_names = self.deferred_field_names
+                self.writer.writerow(self.field_names)
+                self.header_written = True
+        finally:
+            self.file.close()
+
+    @staticmethod
+    def _slice_value(value: Any, i: int, n: int) -> Any:
+        """
+        Return the i-th element when the value stores per-detection data.
+
+        Dispatch rules:
+            - np.ndarray with ndim == 0: return as-is for broadcasting
+            - np.ndarray with len equal to n: return value[i]
+            - list or tuple with len equal to n: return value[i]
+            - any other type: return as-is for broadcasting
+
+        Args:
+            value: Custom-data field value.
+            i: Zero-based detection index.
+            n: Total number of detections.
+
+        Returns:
+            Element at position i if value is a per-detection sequence,
+            otherwise value unchanged.
+        """
+        if isinstance(value, np.ndarray):
+            return value[i] if value.ndim > 0 and len(value) == n else value
+        if isinstance(value, (list, tuple)) and len(value) == n:
+            return value[i]
+        return value
+
+    @staticmethod
+    def parse_detection_data(
+        detections: Detections, custom_data: dict[str, Any] | None = None
+    ) -> list[dict[str, Any]]:
+        """
+        Convert detections and optional custom data into per-detection rows.
+
+        Builds one dictionary per detection containing bounding box coordinates,
+        detection attributes, and any values from ``detections.data`` or
+        ``custom_data``. NumPy array, list, and tuple values in
+        ``custom_data`` with length equal to ``len(detections.xyxy)`` are
+        sliced one element per row; all other values are broadcast to every row.
+
+        Args:
+            detections: Detection data to serialize into row dictionaries.
+            custom_data: Optional extra fields to include in each row.
+
+        Returns:
+            A list of dictionaries, one per detection, containing ``xyxy``
+            coordinates, ``class_id``, ``confidence``, ``tracker_id``, and any
+            values from ``detections.data`` or ``custom_data``.
+        """
+        parsed_rows = []
+        n = len(detections.xyxy)
+        for i in range(n):
+            row = {
+                "x_min": detections.xyxy[i][0],
+                "y_min": detections.xyxy[i][1],
+                "x_max": detections.xyxy[i][2],
+                "y_max": detections.xyxy[i][3],
+                "class_id": ""
+                if detections.class_id is None
+                else str(detections.class_id[i]),
+                "confidence": ""
+                if detections.confidence is None
+                else str(detections.confidence[i]),
+                "tracker_id": ""
+                if detections.tracker_id is None
+                else str(detections.tracker_id[i]),
+            }
+
+            if hasattr(detections, "data"):
+                for key, value in detections.data.items():
+                    row[key] = CSVSink._slice_value(value, i, n)
+
+            if custom_data:
+                for key, value in custom_data.items():
+                    row[key] = CSVSink._slice_value(value, i, n)
+
+            parsed_rows.append(row)
+        return parsed_rows
+
+    def append(
+        self, detections: Detections, custom_data: dict[str, Any] | None = None
+    ) -> None:
+        """
+        Append detection data to the CSV file.
+
+        The CSV header is fixed by the first batch that actually contains
+        detections; batches with no detections write nothing and leave the
+        header undecided, so an empty first frame does not strip the columns
+        of the frames that follow. While no populated batch has appeared, the
+        schema of the first empty batch is the one ``close()`` falls back to.
+
+        Args:
+            detections: The detection data.
+            custom_data: Custom data to include. Scalars, dictionaries, and
+                other non-sequence values are broadcast to every detection in
+                this batch. NumPy arrays, lists, and tuples with length equal
+                to ``len(detections)`` are sliced per detection; other lists
+                and tuples are broadcast unchanged.
+        """
+        if not self.writer:
+            raise Exception(
+                f"Cannot append to CSV: The file '{self.file_name}' is not open."
+            )
+        field_names = CSVSink.parse_field_names(detections, custom_data)
+
+        # An empty batch produces no rows, so letting it fix the header would
+        # pin the file to a schema no detection ever contributed to and drop
+        # every extra column of the batches that follow. Remember the first
+        # such schema for close() instead, in case no batch ever carries
+        # detections; later empty batches must not redefine it, mirroring the
+        # first-populated-batch rule for the header itself.
+        if len(detections) == 0:
+            if not self.header_written and not self.deferred_field_names:
+                self.deferred_field_names = field_names
+            return
+
+        if not self.header_written:
+            self.field_names = field_names
+            self.writer.writerow(field_names)
+            self.header_written = True
+
+        if field_names != self.field_names:
+            logger.warning(
+                "Field names do not match the header. Expected: %s, given: %s",
+                self.field_names,
+                field_names,
+            )
+
+        parsed_rows = CSVSink.parse_detection_data(detections, custom_data)
+        for row in parsed_rows:
+            self.writer.writerow(
+                [row.get(field_name, "") for field_name in self.field_names]
+            )
+
+    @staticmethod
+    def parse_field_names(
+        detections: Detections, custom_data: dict[str, Any] | None = None
+    ) -> list[str]:
+        custom_keys = set(custom_data.keys()) if custom_data else set()
+        dynamic_header = sorted(
+            custom_keys | set(getattr(detections, "data", {}).keys())
+        )
+        return BASE_HEADER + dynamic_header
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/inference_slicer.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/inference_slicer.py
new file mode 100644
index 0000000000000000000000000000000000000000..5aeb279afa0cd09c55ab617bc5235da3e6af2bc8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/inference_slicer.py
@@ -0,0 +1,897 @@
+from __future__ import annotations
+
+import threading
+import warnings
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+from typing import TYPE_CHECKING, Any, Protocol, cast, runtime_checkable
+
+if TYPE_CHECKING:
+    from typing import TypeGuard
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES, SOURCE_IMAGE_METADATA_FIELD
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.utils.boxes import move_boxes, move_oriented_boxes
+from supervision.detection.utils.internal import merge_metadata_lenient
+from supervision.detection.utils.iou_and_nms import OverlapFilter, OverlapMetric
+from supervision.detection.utils.masks import move_masks
+from supervision.draw.base import ImageType
+from supervision.utils.image import crop_image, get_image_resolution_wh
+from supervision.utils.internal import SupervisionWarnings
+from supervision.utils.iterables import create_batches
+
+
+@runtime_checkable
+class WindowedRasterDataset(Protocol):
+    """Structural type for a rasterio-style dataset read window-by-window.
+
+    Matched structurally by `_is_windowed_raster` rather than by import so
+    `rasterio` stays an optional dependency — any object exposing these members
+    works. `rasterio.io.DatasetReader` satisfies this protocol.
+    """
+
+    width: int
+    height: int
+    crs: object | None
+
+    def read(self, window: Any) -> npt.NDArray[Any]: ...
+
+
+def _is_windowed_raster(image: object) -> TypeGuard[WindowedRasterDataset]:
+    """Duck-type check for a rasterio-style dataset that supports windowed reads.
+
+    Avoids importing rasterio so it remains an optional dependency. numpy arrays
+    and PIL images do not expose this combination of attributes.
+    """
+    return (
+        callable(getattr(image, "read", None))
+        and hasattr(image, "crs")
+        and hasattr(image, "width")
+        and hasattr(image, "height")
+    )
+
+
+def move_detections(
+    detections: Detections,
+    offset: npt.NDArray[Any],
+    resolution_wh: tuple[int, int] | None = None,
+) -> Detections:
+    """Translate detections by a pixel offset, repositioning boxes and masks.
+
+    Args:
+        detections: Detections object to be moved. The input is left unchanged;
+            a fresh copy is returned.
+        offset: An array of shape `(2,)` containing offset values in the
+            format `[dx, dy]`.
+        resolution_wh: The width and height of the desired mask
+            resolution. Required for segmentation detections.
+
+    Returns:
+        Repositioned Detections object.
+    """
+    detections = detections.select(slice(None))
+    detections.xyxy = move_boxes(xyxy=detections.xyxy, offset=offset)
+    if ORIENTED_BOX_COORDINATES in detections.data:
+        detections.data[ORIENTED_BOX_COORDINATES] = move_oriented_boxes(
+            xyxyxyxy=cast(
+                npt.NDArray[np.number], detections.data[ORIENTED_BOX_COORDINATES]
+            ),
+            offset=offset,
+        )
+    if detections.mask is not None:
+        if resolution_wh is None:
+            raise ValueError(
+                "Resolution width and height are required for moving segmentation "
+                "detections. This should be the same as (width, height) of image shape."
+            )
+        if isinstance(detections.mask, CompactMask):
+            # Preserve move_masks clipping semantics without dense materialisation.
+            detections.mask = detections.mask.with_offset(
+                dx=int(offset[0]),
+                dy=int(offset[1]),
+                new_image_shape=(resolution_wh[1], resolution_wh[0]),
+            )
+        else:
+            detections.mask = move_masks(
+                masks=detections.mask, offset=offset, resolution_wh=resolution_wh
+            )
+    return detections
+
+
+class InferenceSlicer:
+    """
+    Perform tiled inference on large images by slicing them into overlapping patches.
+
+    This class divides an input image into overlapping slices of configurable size
+    and overlap, runs inference on each slice through a user-provided callback, and
+    merges the resulting detections. The slicing process allows efficient processing
+    of large images with limited resources while preserving detection accuracy via
+    configurable overlap and post-processing of overlaps. Uses multi-threading for
+    parallel slice inference.
+
+    Args:
+        callback: Inference function called for each slice (or batch of slices).
+
+            When ``batch_size=1`` (default) the function receives a single
+            ``np.ndarray`` and must return a single
+            :class:`~supervision.detection.core.Detections` — the original
+            single-image contract, fully backward-compatible.
+
+            When ``batch_size > 1`` the function receives
+            ``list[np.ndarray]`` (one array per slice) and must return
+            ``list[Detections]`` of the **same length** in the same order.
+            A length mismatch or non-list return raises :exc:`ValueError`.
+
+            The two signatures are **not interchangeable**: a callback written
+            for ``batch_size=1`` will fail when ``batch_size > 1``, and vice
+            versa.
+        slice_wh: Size of each slice `(width, height)`. If int, both width and
+            height are set to this value.
+        overlap_wh: Overlap size `(width, height)` between slices. If int, both
+            width and height are set to this value.
+        overlap_filter: Strategy to merge overlapping detections
+            (`NON_MAX_SUPPRESSION`, `NON_MAX_MERGE`, or `NONE`).
+        iou_threshold: IOU threshold used in merging overlap filtering.
+        overlap_metric: Metric to compute overlap (`IOU` or `IOS`).
+        thread_workers: Number of threads for concurrent slice inference.
+            Must be a positive integer. When the first slice returns oriented
+            bounding boxes (OBB), Supervision probes additional slices until a
+            non-empty result is found, then falls back to sequential processing
+            for all remaining slices to avoid thread-safety issues in common OBB
+            inference backends. When passing a rasterio-style dataset, tile reads
+            are serialized via an internal lock regardless of this setting —
+            model inference runs in parallel, but ``raster.read()`` is protected.
+            Note: the first slice always runs synchronously
+            regardless of this setting, so for grids with few slices
+            (e.g. two-slice images) effective parallelism is reduced.
+        compact_masks: If ``True``, dense ``(N, H, W)`` boolean mask
+            arrays returned by the callback are immediately converted to a
+            :class:`~supervision.detection.compact_mask.CompactMask`. This
+            keeps masks in run-length-encoded form for the entire pipeline —
+            merge, NMS, and annotation — avoiding the large ``(N, H, W)``
+            allocations that cause OOM on high-resolution images with many
+            objects. IoU and NMS are computed directly on the RLE crops
+            without ever materialising a full ``(N, H, W)`` array.
+            Defaults to ``False`` for backward compatibility.
+
+            When ``compact_masks=True``, each detection's CompactMask crop spans
+            the entire slice tile bbox (not the tight detection bbox). Call
+            :meth:`~supervision.detection.compact_mask.CompactMask.repack` on the
+            merged result to tighten crops to the detection bounding boxes.
+        batch_size: Number of slices passed to the callback per call.
+            Defaults to ``1``, which uses the single-image callback contract
+            (``np.ndarray`` → :class:`~supervision.detection.core.Detections`).
+            Set to ``> 1`` to enable the batch callback contract
+            (``list[np.ndarray]`` → ``list[Detections]``).
+
+            For GPU-backed models, prefer ``batch_size > 1`` with
+            ``thread_workers=1``. A single batched forward pass is faster than
+            concurrent single-image calls that compete for the same CUDA device,
+            and avoids multiplying peak VRAM by ``thread_workers * batch_size``.
+            Must be a positive integer.
+
+    Raises:
+        ValueError: If ``slice_wh``, ``overlap_wh``, or ``thread_workers`` are
+            invalid or inconsistent.
+        ValueError: If ``batch_size < 1``.
+        ValueError: If the callback returns a non-list when ``batch_size > 1``.
+        ValueError: If the callback returns a list whose length differs from the
+            number of slices passed when ``batch_size > 1``.
+
+    Example:
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from rfdetr import RFDETRMedium
+
+        model = RFDETRMedium()
+
+        def callback(tile):
+            return model.predict(tile)
+
+        slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100)
+
+        image = cv2.imread("example.png")
+        detections = slicer(image)
+        ```
+
+        ```python
+        import supervision as sv
+        from PIL import Image
+        from ultralytics import YOLO
+
+        model = YOLO("yolo11m.pt")
+
+        def callback(tile):
+            results = model(tile)[0]
+            return sv.Detections.from_ultralytics(results)
+
+        slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100)
+
+        image = Image.open("example.png")
+        detections = slicer(image)
+        ```
+
+        ```python
+        import rasterio
+        import supervision as sv
+
+        def callback(tile):  # tile is (H, W, C); select/convert bands as needed
+            ...
+
+        slicer = sv.InferenceSlicer(callback, slice_wh=640, overlap_wh=100)
+
+        with rasterio.open("large_orthomosaic.tif") as dataset:
+            detections = slicer(dataset)
+        ```
+
+        Passing an open rasterio dataset reads each tile lazily via a windowed
+        read, so multi-GB GeoTIFFs never need to be loaded into memory at once.
+        `rasterio` is an optional dependency installable via
+        `pip install "supervision[geotiff]"`.
+
+        Batch inference — pass multiple slices per callback call for GPU models
+        that benefit from batched forward passes:
+
+        ```python
+        from supervision import _cv2 as cv2
+        import numpy as np
+        import supervision as sv
+
+        # Batch callback: receives list[np.ndarray], returns list[Detections]
+        def batch_callback(tiles: list[np.ndarray]) -> list[sv.Detections]:
+            # Run your model on the batch; return one Detections per tile.
+            return [sv.Detections.empty() for _ in tiles]
+
+        slicer = sv.InferenceSlicer(
+            callback=batch_callback,
+            slice_wh=640,
+            overlap_wh=100,
+            batch_size=8,
+            thread_workers=1,  # recommended for GPU: batch not threads
+        )
+
+        image = cv2.imread("example.png")
+        detections = slicer(image)
+        ```
+    """
+
+    def __init__(
+        self,
+        callback: (
+            Callable[[ImageType], Detections]
+            | Callable[[list[npt.NDArray[Any]]], list[Detections]]
+        ),
+        slice_wh: int | tuple[int, int] = 640,
+        overlap_wh: int | tuple[int, int] = 100,
+        overlap_filter: OverlapFilter | str = OverlapFilter.NON_MAX_SUPPRESSION,
+        iou_threshold: float = 0.5,
+        overlap_metric: OverlapMetric | str = OverlapMetric.IOU,
+        thread_workers: int = 1,
+        compact_masks: bool = False,
+        batch_size: int = 1,
+    ):
+        slice_wh_norm = self._normalize_slice_wh(slice_wh)
+        overlap_wh_norm = self._normalize_overlap_wh(overlap_wh)
+
+        self._validate_overlap(slice_wh=slice_wh_norm, overlap_wh=overlap_wh_norm)
+
+        if thread_workers < 1:
+            raise ValueError(
+                "`thread_workers` must be a positive integer. "
+                f"Received: {thread_workers}"
+            )
+        if batch_size < 1:
+            raise ValueError(
+                f"`batch_size` must be a positive integer. Received: {batch_size}"
+            )
+
+        self.slice_wh = slice_wh_norm
+        self.overlap_wh = overlap_wh_norm
+        self.iou_threshold = iou_threshold
+        self.overlap_metric = OverlapMetric.from_value(overlap_metric)
+        self.overlap_filter = OverlapFilter.from_value(overlap_filter)
+        # Stored as single-image type; batch path calls with list[ndarray] via
+        # _run_callback_batch which suppresses the arg-type mismatch there.
+        self.callback: Callable[[npt.NDArray[Any]], Detections] = callback  # type: ignore[assignment]
+        self.thread_workers = thread_workers
+        self.compact_masks = compact_masks
+        self.batch_size = batch_size
+        self._out_of_slice_bounds_warned: bool = False
+        self._out_of_slice_bounds_lock = threading.Lock()
+        self._obb_thread_workers_warned: bool = False
+        self._obb_thread_workers_lock = threading.Lock()
+        self._dropped_metadata_warned: bool = False
+        self._dropped_metadata_lock = threading.Lock()
+        self._raster_read_lock = threading.Lock()
+
+    def __call__(self, image: ImageType | WindowedRasterDataset) -> Detections:
+        """
+        Perform tiled inference on the full image and return merged detections.
+
+        The first slice always runs synchronously so the output type can be
+        inspected before committing to a threading strategy. Detections are
+        merged in a deterministic order: the first slice is always at index 0,
+        followed by any probe slices, then the remaining slices in source order.
+        If oriented bounding boxes are detected, all remaining slices are
+        processed sequentially and a ``SupervisionWarnings`` warning is emitted
+        once per slicer instance.
+
+        Per-slice ``metadata`` is merged leniently: a key survives only when
+        every slice carries it with an equal value; otherwise it is dropped and
+        a ``SupervisionWarnings`` warning is emitted once per slicer instance,
+        naming the dropped keys — a key meant to be global (``video_name``,
+        ``camera_id``, …) would otherwise vanish silently. The merged
+        ``metadata`` dict returned is always freshly built, never the same
+        dict object as any slice's own metadata.
+
+        ``source_image`` is the one metadata key handled specially: it is
+        removed from every slice before the lenient merge, then reattached
+        afterward as a reference to ``image`` itself — not a copy, and not the
+        per-slice tile — for in-memory input (array or PIL image); a windowed
+        raster dataset has no full in-memory image to give back, so its result
+        carries no ``source_image``. Because the stored value is a reference,
+        mutating the returned ``metadata["source_image"]`` mutates the caller's
+        own ``image``, and every ``Detections`` derived from the result via
+        ``select()``, ``__getitem__``, or ``with_nms()`` shares that same
+        reference — a long-lived derived result (e.g. held across a video
+        processing loop) keeps the full input frame alive.
+
+        Args:
+            image: The full image to run inference on. In addition to in-memory
+                images (NumPy arrays or PIL images), this also accepts an open
+                rasterio-style dataset. When a dataset is provided, each tile is
+                read lazily via a windowed read instead of loading the whole image
+                into memory, enabling tiled inference on multi-GB GeoTIFFs. Tiles
+                read from a dataset preserve the source dtype (e.g. ``uint16`` for
+                16-bit sensors) and keep every band; convert or select bands to
+                the dtype/channels your model expects inside the callback.
+
+        Returns:
+            Merged detections across all slices.
+
+        Raises:
+            ValueError: If ``image`` is a rasterio-style dataset whose CRS is
+                geographic (non-projected). Reproject to a projected CRS
+                (e.g. with ``gdalwarp``) before calling.
+        """
+        detections_list: list[Detections] = []
+        resolution_wh = self._get_resolution_wh(image)
+
+        offsets = self._generate_offset(
+            resolution_wh=resolution_wh,
+            slice_wh=self.slice_wh,
+            overlap_wh=self.overlap_wh,
+        )
+
+        if self.batch_size > 1:
+            batched = list(create_batches(offsets, self.batch_size))
+            # Run first batch synchronously: fail-fast type validation + OBB probe.
+            first_batch_results = self._run_callback_batch(image, batched[0])
+            detections_list.extend(first_batch_results)
+            obb_detected = any(
+                ORIENTED_BOX_COORDINATES in det.data for det in first_batch_results
+            )
+            if obb_detected and self.thread_workers > 1:
+                with self._obb_thread_workers_lock:
+                    if not self._obb_thread_workers_warned:
+                        self._obb_thread_workers_warned = True
+                        warnings.warn(
+                            "InferenceSlicer detected oriented bounding boxes while "
+                            "`thread_workers > 1`. Remaining batches will be processed "
+                            "sequentially because many OBB inference backends are not "
+                            "thread-safe and can crash when shared across threads.",
+                            category=SupervisionWarnings,
+                            stacklevel=2,
+                        )
+            remaining_batches = batched[1:]
+            if self.thread_workers == 1 or obb_detected:
+                for offset_batch in remaining_batches:
+                    detections_list.extend(
+                        self._run_callback_batch(image, offset_batch)
+                    )
+            else:
+                with ThreadPoolExecutor(max_workers=self.thread_workers) as executor:
+                    # `Executor.map` yields in submission order, so batches merge in
+                    # source order no matter which thread finishes first.
+                    for batch_detections in executor.map(
+                        partial(self._run_callback_batch, image), remaining_batches
+                    ):
+                        detections_list.extend(batch_detections)
+
+            return self._merge_and_filter(detections_list, image)
+
+        first_offset = offsets[0]
+        first_detections = self._run_callback(image, first_offset)
+        detections_list.append(first_detections)
+
+        remaining_offsets = offsets[1:]
+        obb_detected = ORIENTED_BOX_COORDINATES in first_detections.data
+        should_run_sequentially = self.thread_workers <= 1 or obb_detected
+
+        probe_index = 0
+        if not should_run_sequentially and len(first_detections) == 0:
+            while probe_index < len(remaining_offsets):
+                probe_offset = remaining_offsets[probe_index]
+                probe_detections = self._run_callback(image, probe_offset)
+                detections_list.append(probe_detections)
+                probe_index += 1
+
+                if ORIENTED_BOX_COORDINATES in probe_detections.data:
+                    obb_detected = True
+                    should_run_sequentially = True
+                    break
+
+                if len(probe_detections) > 0:
+                    break
+
+        remaining_offsets = remaining_offsets[probe_index:]
+
+        if should_run_sequentially:
+            if self.thread_workers > 1 and obb_detected:
+                with self._obb_thread_workers_lock:
+                    if not self._obb_thread_workers_warned:
+                        self._obb_thread_workers_warned = True
+                        warnings.warn(
+                            "InferenceSlicer detected oriented bounding boxes while "
+                            "`thread_workers > 1`. Remaining slices will be processed "
+                            "sequentially because many OBB inference backends are not "
+                            "thread-safe and can crash when shared across threads.",
+                            category=SupervisionWarnings,
+                            stacklevel=2,
+                        )
+            for offset in remaining_offsets:
+                detections_list.append(self._run_callback(image, offset))
+        else:
+            with ThreadPoolExecutor(max_workers=self.thread_workers) as executor:
+                # `Executor.map` yields in submission order, so slices merge in
+                # source order no matter which thread finishes first.
+                detections_list.extend(
+                    executor.map(partial(self._run_callback, image), remaining_offsets)
+                )
+
+        return self._merge_and_filter(detections_list, image)
+
+    def _merge_and_filter(
+        self,
+        detections_list: list[Detections],
+        image: ImageType | WindowedRasterDataset,
+    ) -> Detections:
+        """Merge per-slice detections, apply the overlap filter, restore the source.
+
+        The source image is attached only after filtering. Overlap filters propagate
+        ``metadata`` forward untouched, so the output is identical either way — but
+        ``NON_MAX_MERGE`` compares metadata values per merge group, and a whole
+        ``(H, W, C)`` array compared once per group dominates the filter's runtime.
+
+        Args:
+            detections_list: Per-slice detections in full-image coordinates.
+            image: The full image the slices were cut from.
+
+        Returns:
+            The merged, overlap-filtered detections.
+        """
+        merged, had_source_image = self._merge_slice_detections(detections_list, image)
+        filtered = self._apply_overlap_filter(merged)
+        if had_source_image:
+            filtered.metadata[SOURCE_IMAGE_METADATA_FIELD] = image
+        return filtered
+
+    def _merge_slice_detections(
+        self,
+        detections_list: list[Detections],
+        image: ImageType | WindowedRasterDataset,
+    ) -> tuple[Detections, bool]:
+        """Merge per-slice detections, reconciling their metadata leniently.
+
+        Metadata keys that disagree across slices, or that only some slices carry,
+        are dropped rather than raising — slices legitimately differ in per-tile
+        metadata. The source image is the one such key worth recovering: when any
+        slice carried it, the caller restores the full input image — array or PIL
+        alike, but not a windowed raster, which has no full in-memory image to hand
+        back. Any other key lost this way is reported once per slicer instance,
+        since a key the user meant to be global (``video_name``, ``camera_id``, …)
+        would otherwise vanish silently.
+
+        Because the source image is restored wholesale, it is removed from every
+        slice up front: leaving it in would make the lenient merge — and every
+        downstream merge group of ``NON_MAX_MERGE`` — compare whole image arrays
+        only to overwrite the result afterwards. Slices of a windowed raster keep
+        the key, since nothing restores it for them.
+
+        Args:
+            detections_list: Per-slice detections in full-image coordinates.
+            image: The full image the slices were cut from.
+
+        Returns:
+            The merged detections before overlap filtering, and whether any slice
+            carried a source image that the caller should restore.
+        """
+        non_empty = [d for d in detections_list if not d.is_empty()]
+
+        restorable = not _is_windowed_raster(image)
+        had_source_image = False
+        if restorable:
+            for d in non_empty:
+                if SOURCE_IMAGE_METADATA_FIELD in d.metadata:
+                    del d.metadata[SOURCE_IMAGE_METADATA_FIELD]
+                    had_source_image = True
+
+        merged_metadata, dropped_keys = merge_metadata_lenient(
+            [d.metadata for d in non_empty]
+        )
+
+        # `Detections.merge` would re-compare the same metadata and raise on the
+        # conflicts just resolved, so hand it empty dicts and attach the result.
+        for d in non_empty:
+            d.metadata = {}
+        merged = Detections.merge(detections_list=detections_list)
+        merged.metadata = merged_metadata
+
+        self._warn_dropped_metadata(dropped_keys)
+
+        return merged, had_source_image
+
+    def _warn_dropped_metadata(self, dropped_keys: set[str]) -> None:
+        """Warn once per slicer instance about metadata keys lost while merging."""
+        if not dropped_keys or self._dropped_metadata_warned:
+            return
+        with self._dropped_metadata_lock:
+            # Re-check under the lock so concurrent calls warn exactly once.
+            if self._dropped_metadata_warned:
+                return
+            self._dropped_metadata_warned = True
+            keys = ", ".join(sorted(dropped_keys))
+            warnings.warn(
+                "InferenceSlicer dropped metadata keys that were not identical "
+                f"across all slices: {keys}. Metadata must agree on every slice to "
+                "survive merging. If the value is genuinely per-detection, store it "
+                "in `Detections.data` instead, which is merged per detection.",
+                category=SupervisionWarnings,
+                stacklevel=2,
+            )
+
+    def _get_resolution_wh(
+        self, image: ImageType | WindowedRasterDataset
+    ) -> tuple[int, int]:
+        """Return ``(width, height)`` for the image, validating CRS for rasters."""
+        if _is_windowed_raster(image):
+            crs = image.crs
+            if crs is not None and not getattr(crs, "is_projected", True):
+                raise ValueError(
+                    "InferenceSlicer requires a projected coordinate reference "
+                    "system for pixel-space tiled inference on a raster dataset. "
+                    f"The provided dataset uses a geographic CRS ({crs}). Reproject "
+                    "it to a projected CRS (e.g. with `gdalwarp`) before slicing."
+                )
+            return (image.width, image.height)
+        return get_image_resolution_wh(image)
+
+    def _apply_overlap_filter(self, merged: Detections) -> Detections:
+        """Apply the configured overlap filter strategy to merged detections."""
+        if self.overlap_filter == OverlapFilter.NONE:
+            return merged
+        if self.overlap_filter == OverlapFilter.NON_MAX_SUPPRESSION:
+            return merged.with_nms(
+                threshold=self.iou_threshold,
+                overlap_metric=self.overlap_metric,
+            )
+        if self.overlap_filter == OverlapFilter.NON_MAX_MERGE:
+            return merged.with_nmm(
+                threshold=self.iou_threshold,
+                overlap_metric=self.overlap_metric,
+            )
+        warnings.warn(
+            f"Invalid overlap filter strategy: {self.overlap_filter}",
+            category=SupervisionWarnings,
+        )
+        return merged
+
+    def _run_callback(
+        self, image: ImageType | WindowedRasterDataset, offset: npt.NDArray[Any]
+    ) -> Detections:
+        """
+        Run detection callback on a sliced portion of the image and adjust coordinates.
+
+        Args:
+            image: The full image.
+            offset: Coordinates `(x_min, y_min, x_max, y_max)` defining
+                the slice region.
+
+        Returns:
+            Detections adjusted to the full image coordinate system.
+        """
+        if _is_windowed_raster(image):
+            x_min, y_min, x_max, y_max = (int(v) for v in offset)
+            # rasterio tuple window: ((row_start, row_stop), (col_start, col_stop))
+            window = ((y_min, y_max), (x_min, x_max))
+            with self._raster_read_lock:
+                bands = image.read(window=window)  # shape (channels, height, width)
+            image_slice = np.ascontiguousarray(
+                np.transpose(bands, (1, 2, 0))
+            )  # -> (H, W, C)
+            resolution_wh = (image.width, image.height)
+        else:
+            image_slice = crop_image(image=image, xyxy=offset)
+            resolution_wh = get_image_resolution_wh(image)
+
+        detections = self.callback(image_slice)
+
+        if (
+            self.compact_masks
+            and detections.mask is not None
+            and isinstance(detections.mask, np.ndarray)
+        ):
+            slice_w, slice_h = get_image_resolution_wh(image_slice)
+            full_slice_xyxy = np.tile(
+                np.array([[0, 0, slice_w - 1, slice_h - 1]], dtype=np.float64),
+                (len(detections), 1),
+            )
+            detections.mask = CompactMask.from_dense(
+                detections.mask,
+                full_slice_xyxy,
+                image_shape=(slice_h, slice_w),
+            )
+
+        # Fast-path: skip locking and bounds checking when the warning has already
+        # been emitted or when there are no detections to inspect.
+        needs_warning_check = (
+            not self._out_of_slice_bounds_warned and len(detections) > 0
+        )
+
+        if needs_warning_check:
+            with self._out_of_slice_bounds_lock:
+                # Re-check under the lock to ensure correctness with multiple threads.
+                if not self._out_of_slice_bounds_warned and len(detections) > 0:
+                    slice_width = offset[2] - offset[0]
+                    slice_height = offset[3] - offset[1]
+                    x_exceeds = np.any(detections.xyxy[:, [0, 2]] > slice_width)
+                    y_exceeds = np.any(detections.xyxy[:, [1, 3]] > slice_height)
+                    x_negative = np.any(detections.xyxy[:, [0, 2]] < 0)
+                    y_negative = np.any(detections.xyxy[:, [1, 3]] < 0)
+                    if x_exceeds or y_exceeds or x_negative or y_negative:
+                        self._out_of_slice_bounds_warned = True
+                        msg = (
+                            "Detections returned by the callback have coordinates "
+                            "outside the slice bounds. This may be caused by the "
+                            "callback running inference on the full image instead of "
+                            "the provided image slice. Ensure your callback uses the "
+                            "input slice for inference, not the original "
+                            "full-resolution image."
+                        )
+                        warnings.warn(msg, category=SupervisionWarnings, stacklevel=2)
+        detections = move_detections(
+            detections=detections,
+            offset=offset[:2],
+            resolution_wh=resolution_wh,
+        )
+        return detections
+
+    def _run_callback_batch(
+        self,
+        image: ImageType | WindowedRasterDataset,
+        offsets: list[npt.NDArray[Any]],
+    ) -> list[Detections]:
+        """Run batch inference callback on multiple slices.
+
+        Args:
+            image: The full image or rasterio dataset.
+            offsets: List of slice coordinates `(x_min, y_min, x_max, y_max)`.
+
+        Returns:
+            Detections adjusted to full-image coordinates, one per offset.
+        """
+        if _is_windowed_raster(image):
+            slices = []
+            for offset in offsets:
+                x_min, y_min, x_max, y_max = (int(v) for v in offset)
+                window = ((y_min, y_max), (x_min, x_max))
+                with self._raster_read_lock:
+                    bands = image.read(window=window)
+                slices.append(np.ascontiguousarray(np.transpose(bands, (1, 2, 0))))
+            resolution_wh = (image.width, image.height)
+        else:
+            slices = [crop_image(image=image, xyxy=offset) for offset in offsets]
+            resolution_wh = get_image_resolution_wh(image)
+
+        batch_callback = cast(
+            Callable[[list[npt.NDArray[Any]]], list[Detections]], self.callback
+        )
+        detections_in_slices = batch_callback(slices)
+        if not isinstance(detections_in_slices, list):
+            raise ValueError(
+                "Callback must return `list[Detections]` when `batch_size > 1`. "
+                f"Got: {type(detections_in_slices)}"
+            )
+        if len(detections_in_slices) != len(offsets):
+            raise ValueError(
+                f"Callback returned {len(detections_in_slices)} Detections "
+                f"for {len(offsets)} slices. Lengths must match."
+            )
+
+        if self.compact_masks:
+            for det, image_slice in zip(detections_in_slices, slices):
+                if det.mask is not None and isinstance(det.mask, np.ndarray):
+                    slice_w, slice_h = get_image_resolution_wh(image_slice)
+                    full_slice_xyxy = np.tile(
+                        np.array([[0, 0, slice_w - 1, slice_h - 1]], dtype=np.float64),
+                        (len(det), 1),
+                    )
+                    det.mask = CompactMask.from_dense(
+                        det.mask,
+                        full_slice_xyxy,
+                        image_shape=(slice_h, slice_w),
+                    )
+
+        if not self._out_of_slice_bounds_warned:
+            for det, offset in zip(detections_in_slices, offsets):
+                if self._out_of_slice_bounds_warned or len(det) == 0:
+                    continue
+                with self._out_of_slice_bounds_lock:
+                    if not self._out_of_slice_bounds_warned and len(det) > 0:
+                        slice_width = offset[2] - offset[0]
+                        slice_height = offset[3] - offset[1]
+                        x_exceeds = np.any(det.xyxy[:, [0, 2]] > slice_width)
+                        y_exceeds = np.any(det.xyxy[:, [1, 3]] > slice_height)
+                        x_negative = np.any(det.xyxy[:, [0, 2]] < 0)
+                        y_negative = np.any(det.xyxy[:, [1, 3]] < 0)
+                        if x_exceeds or y_exceeds or x_negative or y_negative:
+                            self._out_of_slice_bounds_warned = True
+                            warnings.warn(
+                                "Detections returned by the callback have coordinates "
+                                "outside the slice bounds. This may be caused by the "
+                                "callback running inference on the full image instead "
+                                "of the provided image slice. Ensure your callback "
+                                "uses the input slice for inference, not the original "
+                                "full-resolution image.",
+                                category=SupervisionWarnings,
+                                stacklevel=2,
+                            )
+
+        return [
+            move_detections(
+                detections=det, offset=offset[:2], resolution_wh=resolution_wh
+            )
+            for det, offset in zip(detections_in_slices, offsets)
+        ]
+
+    @staticmethod
+    def _normalize_slice_wh(
+        slice_wh: int | tuple[int, int],
+    ) -> tuple[int, int]:
+        if isinstance(slice_wh, int):
+            if slice_wh <= 0:
+                raise ValueError(
+                    f"`slice_wh` must be a positive integer. Received: {slice_wh}"
+                )
+            return slice_wh, slice_wh
+
+        if isinstance(slice_wh, tuple) and len(slice_wh) == 2:
+            width, height = slice_wh
+            if width <= 0 or height <= 0:
+                raise ValueError(
+                    f"`slice_wh` values must be positive. Received: {slice_wh}"
+                )
+            return width, height
+
+        raise ValueError(
+            "`slice_wh` must be an int or a tuple of two positive integers "
+            "(slice_w, slice_h). "
+            f"Received: {slice_wh}"
+        )
+
+    @staticmethod
+    def _normalize_overlap_wh(
+        overlap_wh: int | tuple[int, int],
+    ) -> tuple[int, int]:
+        if isinstance(overlap_wh, int):
+            if overlap_wh < 0:
+                raise ValueError(
+                    "`overlap_wh` must be a non negative integer. "
+                    f"Received: {overlap_wh}"
+                )
+            return overlap_wh, overlap_wh
+
+        if isinstance(overlap_wh, tuple) and len(overlap_wh) == 2:
+            overlap_w, overlap_h = overlap_wh
+            if overlap_w < 0 or overlap_h < 0:
+                raise ValueError(
+                    f"`overlap_wh` values must be non negative. Received: {overlap_wh}"
+                )
+            return overlap_w, overlap_h
+
+        raise ValueError(
+            "`overlap_wh` must be an int or a tuple of two non negative integers "
+            "(overlap_w, overlap_h). "
+            f"Received: {overlap_wh}"
+        )
+
+    @staticmethod
+    def _generate_offset(
+        resolution_wh: tuple[int, int],
+        slice_wh: tuple[int, int],
+        overlap_wh: tuple[int, int],
+    ) -> npt.NDArray[Any]:
+        """
+        Generate bounding boxes defining the coordinates of image slices with overlap.
+
+        Args:
+            resolution_wh: Image resolution `(width, height)`.
+            slice_wh: Size of each slice `(width, height)`.
+            overlap_wh: Overlap size between slices `(width, height)`.
+
+        Returns:
+            Array of shape `(num_slices, 4)` with each row as
+                `(x_min, y_min, x_max, y_max)` coordinates for a slice.
+        """
+        slice_width, slice_height = slice_wh
+        image_width, image_height = resolution_wh
+        overlap_width, overlap_height = overlap_wh
+
+        stride_x = slice_width - overlap_width
+        stride_y = slice_height - overlap_height
+
+        def _compute_axis_starts(
+            image_size: int,
+            slice_size: int,
+            stride: int,
+        ) -> list[int]:
+            if image_size <= slice_size:
+                return [0]
+
+            if stride == slice_size:
+                return list(np.arange(0, image_size, stride).tolist())
+
+            last_start = image_size - slice_size
+            starts: list[int] = list(np.arange(0, last_start, stride).tolist())
+            if not starts or starts[-1] != last_start:
+                starts.append(last_start)
+            return starts
+
+        x_starts = _compute_axis_starts(
+            image_size=image_width,
+            slice_size=slice_width,
+            stride=stride_x,
+        )
+        y_starts = _compute_axis_starts(
+            image_size=image_height,
+            slice_size=slice_height,
+            stride=stride_y,
+        )
+
+        x_min, y_min = np.meshgrid(x_starts, y_starts)
+        x_max = np.clip(x_min + slice_width, 0, image_width)
+        y_max = np.clip(y_min + slice_height, 0, image_height)
+
+        offsets: npt.NDArray[Any] = np.stack(
+            [x_min, y_min, x_max, y_max],
+            axis=-1,
+        ).reshape(-1, 4)
+
+        return offsets
+
+    @staticmethod
+    def _validate_overlap(
+        slice_wh: tuple[int, int],
+        overlap_wh: tuple[int, int],
+    ) -> None:
+        overlap_w, overlap_h = overlap_wh
+        slice_w, slice_h = slice_wh
+
+        if overlap_w < 0 or overlap_h < 0:
+            raise ValueError(
+                "Overlap values must be greater than or equal to 0. "
+                f"Received: {overlap_wh}"
+            )
+
+        if overlap_w >= slice_w or overlap_h >= slice_h:
+            raise ValueError(
+                "`overlap_wh` must be smaller than `slice_wh` in both dimensions "
+                f"to keep a positive stride. Received overlap_wh={overlap_wh}, "
+                f"slice_wh={slice_wh}."
+            )
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/json_sink.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/json_sink.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e1ffda4feb361527e256cbfbba75d8bd89909fa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/json_sink.py
@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import io
+import json
+import os
+from typing import Any
+
+import numpy as np
+
+from supervision.detection.core import Detections
+
+
+class JSONSink:
+    """
+    A utility class for saving detection data to a JSON file. This class is designed to
+    efficiently serialize detection objects into a JSON format, allowing for the
+    inclusion of bounding box coordinates and additional attributes like `confidence`,
+    `class_id`, and `tracker_id`.
+
+    !!! tip
+
+        JSONSink allows passing custom data alongside detection fields, providing
+        flexibility for logging various types of information.
+        When a NumPy array, list, or tuple value in custom_data (or
+        detections.data) has the same length as the detection count, each
+        element is written to the corresponding detection row; any other value
+        is broadcast to all rows.
+        NumPy scalars (e.g. ``np.int64``, ``np.float32``) are serialized as
+        JSON numbers; NumPy arrays are serialized as JSON arrays.
+
+    Args:
+        file_name: The name of the JSON file where the detections will be stored.
+            Defaults to 'output.json'.
+
+    Example:
+        ```python
+        import supervision as sv
+        from rfdetr import RFDETRMedium
+
+        model = RFDETRMedium()
+        json_sink = sv.JSONSink()
+        frames_generator = sv.get_video_frames_generator("")
+
+        with json_sink as sink:
+            for frame in frames_generator:
+                detections = model.predict(frame[:, :, ::-1])
+                sink.append(detections, custom_data={"":""})
+        ```
+    """
+
+    def __init__(self, file_name: str = "output.json") -> None:
+        """
+        Initialize the JSONSink instance.
+
+        Args:
+            file_name: The name of the JSON file.
+        """
+        self.file_name = file_name
+        self.file: io.TextIOWrapper | None = None
+        self.data: list[dict[str, Any]] = []
+
+    def __enter__(self) -> JSONSink:
+        self.open()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type | None,
+        exc_val: Exception | None,
+        exc_tb: Any | None,
+    ) -> None:
+        self.write_and_close()
+
+    def open(self) -> None:
+        """
+        Open the JSON file for writing.
+        """
+        parent_directory = os.path.dirname(self.file_name)
+        if parent_directory and not os.path.exists(parent_directory):
+            os.makedirs(parent_directory)
+
+        self.file = open(self.file_name, "w")
+        self.data = []
+
+    @staticmethod
+    def _json_default(value: Any) -> Any:
+        """Return a JSON-serializable equivalent of a NumPy scalar or array.
+
+        Called as the ``default`` hook by :func:`json.dump`. Converts
+        :class:`numpy.generic` scalars via ``.item()`` and
+        :class:`numpy.ndarray` instances via ``.tolist()``.
+
+        Args:
+            value: Object the standard JSON encoder could not serialize.
+
+        Returns:
+            A Python scalar or nested list equivalent of ``value``.
+
+        Raises:
+            TypeError: If ``value`` is neither a NumPy scalar nor an ndarray.
+        """
+        if isinstance(value, np.generic):
+            return value.item()
+        if isinstance(value, np.ndarray):
+            return value.tolist()
+        raise TypeError(
+            f"Object of type {type(value).__name__} is not JSON serializable"
+        )
+
+    def write_and_close(self) -> None:
+        """
+        Write and close the JSON file.
+        """
+        if self.file:
+            try:
+                json.dump(
+                    self.data, self.file, indent=4, default=JSONSink._json_default
+                )
+            finally:
+                self.file.close()
+
+    @staticmethod
+    def _slice_value(value: Any, i: int, n: int) -> Any:
+        """
+        Return the i-th element when the value stores per-detection data.
+
+        Dispatch rules:
+            - np.ndarray with ndim == 0: return as-is for broadcasting
+            - np.ndarray with len equal to n: return value[i]
+            - list or tuple with len equal to n: return value[i]
+            - any other type: return as-is for broadcasting
+
+        Args:
+            value: Custom-data field value.
+            i: Zero-based detection index.
+            n: Total number of detections.
+
+        Returns:
+            Element at position i if value is a per-detection sequence,
+            otherwise value unchanged.
+        """
+        if isinstance(value, np.ndarray):
+            return value[i] if value.ndim > 0 and len(value) == n else value
+        if isinstance(value, (list, tuple)) and len(value) == n:
+            return value[i]
+        return value
+
+    @staticmethod
+    def parse_detection_data(
+        detections: Detections, custom_data: dict[str, Any] | None = None
+    ) -> list[dict[str, Any]]:
+        """
+        Convert detections and optional custom data into per-detection rows.
+
+        Builds one dictionary per detection containing bounding box coordinates,
+        detection attributes, and any values from ``detections.data`` or
+        ``custom_data``. NumPy array, list, and tuple values in
+        ``custom_data`` with length equal to ``len(detections.xyxy)`` are
+        sliced one element per row; all other values are broadcast to every row.
+
+        Args:
+            detections: Detection data to serialize into row dictionaries.
+            custom_data: Optional extra fields to include in each row.
+
+        Returns:
+            A list of dictionaries, one per detection, containing ``xyxy``
+            coordinates, ``class_id``, ``confidence``, ``tracker_id``, and any
+            values from ``detections.data`` or ``custom_data``.
+        """
+        parsed_rows = []
+        n = len(detections.xyxy)
+        for i in range(n):
+            row = {
+                "x_min": float(detections.xyxy[i][0]),
+                "y_min": float(detections.xyxy[i][1]),
+                "x_max": float(detections.xyxy[i][2]),
+                "y_max": float(detections.xyxy[i][3]),
+                "class_id": ""
+                if detections.class_id is None
+                else int(detections.class_id[i]),
+                "confidence": ""
+                if detections.confidence is None
+                else float(detections.confidence[i]),
+                "tracker_id": ""
+                if detections.tracker_id is None
+                else int(detections.tracker_id[i]),
+            }
+
+            if hasattr(detections, "data"):
+                for key, value in detections.data.items():
+                    row[key] = JSONSink._slice_value(value, i, n)
+
+            if custom_data:
+                for key, value in custom_data.items():
+                    row[key] = JSONSink._slice_value(value, i, n)
+
+            parsed_rows.append(row)
+        return parsed_rows
+
+    def append(
+        self, detections: Detections, custom_data: dict[str, Any] | None = None
+    ) -> None:
+        """
+        Append detection data to the JSON file.
+
+        Args:
+            detections: The detection data.
+            custom_data: Custom data to include. Scalars, dictionaries, and
+                other non-sequence values are broadcast to every detection in
+                this batch. NumPy arrays, lists, and tuples with length equal
+                to ``len(detections)`` are sliced per detection; other lists
+                and tuples are broadcast unchanged.
+        """
+        parsed_rows = JSONSink.parse_detection_data(detections, custom_data)
+        self.data.extend(parsed_rows)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/polygon_zone.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/polygon_zone.py
new file mode 100644
index 0000000000000000000000000000000000000000..62e378964c39d4269765bc3d4cd1e2e0eb83a37c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/polygon_zone.py
@@ -0,0 +1,272 @@
+from collections.abc import Iterable
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import Detections
+from supervision import _cv2 as cv2
+from supervision.detection.utils.converters import (
+    MIN_POLYGON_POINT_COUNT,
+    polygon_to_mask,
+)
+from supervision.draw.color import Color
+from supervision.draw.utils import draw_filled_polygon, draw_polygon, draw_text
+from supervision.geometry.core import Position
+from supervision.geometry.utils import get_polygon_center
+
+
+class PolygonZone:
+    """
+    A class for defining a polygon-shaped zone within a frame for detecting objects.
+
+    !!! warning
+
+        PolygonZone uses the `tracker_id`. Read
+        [here](/latest/trackers/) to learn how to plug
+        tracking into your inference pipeline.
+
+    Attributes:
+        polygon: A polygon represented by a numpy array of shape
+            `(N, 2)`, containing the `x`, `y` coordinates of the points.
+        triggering_anchors: Any iterable of positions specifying
+            which anchors of the detections bounding box to consider when deciding on
+            whether the detection fits within the PolygonZone
+            (default: (sv.Position.BOTTOM_CENTER,)).
+        require_all_anchors: If `True` (default), a detection is considered inside
+            the zone only when *every* anchor in `triggering_anchors` is inside.
+            If `False`, the detection triggers as soon as *any* anchor is inside.
+            Has no effect when `triggering_anchors` has a single entry.
+            This is anchor-based, not a true geometric box/polygon intersection
+            test: it fires only when a listed anchor point lands inside the mask.
+            Use mask/IoU-based approaches instead when full-overlap semantics are
+            required.
+        current_count: The current count of detected objects within the zone
+        mask: The 2D bool mask for the polygon zone
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> polygon = np.array([[100, 200], [200, 100], [300, 200], [200, 300]])
+        >>> polygon_zone = sv.PolygonZone(polygon=polygon)
+        >>> detections = sv.Detections(
+        ...     xyxy=np.array([[180, 100, 220, 200], [400, 400, 450, 500]])
+        ... )
+        >>> is_detections_in_zone = polygon_zone.trigger(detections)
+        >>> is_detections_in_zone
+        array([ True, False])
+        >>> polygon_zone.current_count
+        1
+
+        ```
+
+        ```pycon
+        >>> polygon = np.array([[0, 0], [100, 0], [100, 100], [0, 100]])
+        >>> polygon_zone = sv.PolygonZone(
+        ...     polygon=polygon,
+        ...     triggering_anchors=[sv.Position.TOP_LEFT, sv.Position.BOTTOM_RIGHT],
+        ...     require_all_anchors=False,
+        ... )
+        >>> detections = sv.Detections(xyxy=np.array([[80, 80, 120, 120]]))
+        >>> polygon_zone.trigger(detections)
+        array([ True])
+
+        ```
+    """
+
+    def __init__(
+        self,
+        polygon: npt.NDArray[np.int64],
+        triggering_anchors: Iterable[Position] = (Position.BOTTOM_CENTER,),
+        require_all_anchors: bool = True,
+    ) -> None:
+        """Build a zone from a polygon.
+
+        Args:
+            polygon: Zone boundary of shape `(N, 2)` holding the `x`, `y`
+                coordinates of its vertices.
+            triggering_anchors: Which anchors of a detection's bounding box
+                decide whether it falls inside the zone.
+            require_all_anchors: Whether every triggering anchor must be inside
+                for the detection to count, rather than any one of them.
+
+        Raises:
+            ValueError: If `polygon` is not of shape `(N, 2)`, has fewer than
+                `MIN_POLYGON_POINT_COUNT` vertices, or `triggering_anchors` is
+                empty.
+        """
+        polygon = np.asarray(polygon)
+        if polygon.ndim != 2 or polygon.shape[-1] != 2:
+            raise ValueError(f"Polygon must have shape (N, 2); got {polygon.shape}.")
+        # Fewer than three vertices enclose no area, so the mask below comes out
+        # empty or a bare line and the zone silently never triggers. Reject it
+        # here rather than let a zone that can never count look like a zone that
+        # simply saw nothing. Zero vertices additionally breaks `np.max`.
+        if len(polygon) < MIN_POLYGON_POINT_COUNT:
+            raise ValueError(
+                f"Polygon must have at least {MIN_POLYGON_POINT_COUNT} vertices "
+                f"to enclose an area; got {len(polygon)}."
+            )
+
+        self.polygon = polygon.astype(int)
+        # Materialize once so we can safely accept generators without exhausting them.
+        self.triggering_anchors = list(triggering_anchors)
+        if not self.triggering_anchors:
+            raise ValueError("Triggering anchors cannot be empty.")
+        self.require_all_anchors = require_all_anchors
+
+        self.current_count = 0
+
+        x_max, y_max = np.max(polygon, axis=0)
+        self.mask = polygon_to_mask(
+            polygon=polygon, resolution_wh=(x_max + 2, y_max + 2)
+        )
+
+    def trigger(self, detections: Detections) -> npt.NDArray[np.bool_]:
+        """
+        Determines if the detections are within the polygon zone.
+
+        Anchor points are calculated from original (unclipped) detection boxes to
+        avoid per-zone clipping shifting anchor positions. This prevents a single
+        detection from being counted in multiple non-overlapping zones due to
+        clipping artifacts, although overlapping zones may still legitimately
+        contain the same detection.
+
+        Args:
+            detections: The detections to be checked against the polygon zone
+
+        Returns:
+            A boolean numpy array indicating
+                if each detection is within the polygon zone
+        """
+        if len(detections) == 0:
+            self.current_count = 0
+            return cast(npt.NDArray[np.bool_], np.array([], dtype=bool))
+
+        all_anchors = np.array(
+            [
+                np.rint(detections.get_anchors_coordinates(anchors)).astype(int)
+                for anchors in self.triggering_anchors
+            ]
+        )
+
+        mask_h, mask_w = self.mask.shape
+        x, y = all_anchors[:, :, 0], all_anchors[:, :, 1]
+        in_bounds = (x >= 0) & (y >= 0) & (x < mask_w) & (y < mask_h)
+        x_safe = np.clip(x, 0, mask_w - 1)
+        y_safe = np.clip(y, 0, mask_h - 1)
+        anchor_hits = in_bounds & self.mask[y_safe, x_safe]
+        reduce = np.all if self.require_all_anchors else np.any
+        is_in_zone = reduce(anchor_hits, axis=0)
+        self.current_count = int(np.sum(is_in_zone))
+        return cast(npt.NDArray[np.bool_], is_in_zone.astype(bool))
+
+
+class PolygonZoneAnnotator:
+    """
+    A class for annotating a polygon-shaped zone within a frame with a count of
+    detected objects.
+
+    Attributes:
+        zone: The polygon zone to be annotated
+        color: The color to draw the polygon lines, default is white
+        thickness: The thickness of the polygon lines, default is 2
+        text_color: The color of the text on the polygon, default is black
+        text_scale: The scale of the text on the polygon, default is 0.5
+        text_thickness: The thickness of the text on the polygon, default is 1
+        text_padding: The padding around the text on the polygon, default is 10
+        font: The font type for the text on the polygon,
+            default is cv2.FONT_HERSHEY_SIMPLEX
+        center: The center of the polygon for text placement
+        display_in_zone_count: Show the label of the zone or not. Default is True
+        opacity: The opacity of zone filling when drawn on the scene. Default is 0
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> polygon = np.array([[100, 200], [200, 100], [300, 200], [200, 300]])
+        >>> polygon_zone = sv.PolygonZone(polygon=polygon)
+        >>> zone_annotator = sv.PolygonZoneAnnotator(zone=polygon_zone, thickness=2)
+        >>> scene = np.zeros((400, 400, 3), dtype=np.uint8)
+        >>> annotated_scene = zone_annotator.annotate(scene=scene)
+        >>> annotated_scene.shape
+        (400, 400, 3)
+
+        ```
+    """
+
+    def __init__(
+        self,
+        zone: PolygonZone,
+        color: Color = Color.WHITE,
+        thickness: int = 2,
+        text_color: Color = Color.BLACK,
+        text_scale: float = 0.5,
+        text_thickness: int = 1,
+        text_padding: int = 10,
+        display_in_zone_count: bool = True,
+        opacity: float = 0,
+    ) -> None:
+        self.zone = zone
+        self.color = color
+        self.thickness = thickness
+        self.text_color = text_color
+        self.text_scale = text_scale
+        self.text_thickness = text_thickness
+        self.text_padding = text_padding
+        self.font = cv2.FONT_HERSHEY_SIMPLEX
+        self.center = get_polygon_center(polygon=zone.polygon)
+        self.display_in_zone_count = display_in_zone_count
+        self.opacity = opacity
+
+    def annotate(
+        self, scene: npt.NDArray[Any], label: str | None = None
+    ) -> npt.NDArray[Any]:
+        """
+        Annotates the polygon zone within a frame with a count of detected objects.
+
+        Args:
+            scene: The image on which the polygon zone will be annotated
+            label: A label for the count of detected objects
+                within the polygon zone (default: None)
+
+        Returns:
+            The image with the polygon zone and count of detected objects
+        """
+        if self.opacity == 0:
+            annotated_frame = draw_polygon(
+                scene=scene,
+                polygon=self.zone.polygon,
+                color=self.color,
+                thickness=self.thickness,
+            )
+        else:
+            annotated_frame = draw_filled_polygon(
+                scene=scene.copy(),
+                polygon=self.zone.polygon,
+                color=self.color,
+                opacity=self.opacity,
+            )
+            annotated_frame = draw_polygon(
+                scene=annotated_frame,
+                polygon=self.zone.polygon,
+                color=self.color,
+                thickness=self.thickness,
+            )
+
+        if self.display_in_zone_count:
+            annotated_frame = draw_text(
+                scene=annotated_frame,
+                text=str(self.zone.current_count) if label is None else label,
+                text_anchor=self.center,
+                background_color=self.color,
+                text_color=self.text_color,
+                text_scale=self.text_scale,
+                text_thickness=self.text_thickness,
+                text_padding=self.text_padding,
+                text_font=self.font,
+            )
+
+        return cast(npt.NDArray[Any], annotated_frame)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/smoother.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/smoother.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b5612b1542a2e9c5689164c140b376f7704f5fa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/smoother.py
@@ -0,0 +1,255 @@
+import warnings
+from collections import defaultdict, deque
+from copy import deepcopy
+
+import numpy as np
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.core import Detections
+from supervision.detection.utils.boxes import xyxyxyxy_to_xyxy
+from supervision.utils.internal import SupervisionWarnings
+
+
+def _align_oriented_corners(corners: np.ndarray, reference: np.ndarray) -> np.ndarray:
+    """Align OBB corner starts and winding with a reference representation."""
+    variants = [corners, corners[:, ::-1]]
+    candidates = np.stack(
+        [
+            np.roll(candidate, shift, axis=1)
+            for candidate in variants
+            for shift in range(4)
+        ]
+    )
+    distances = np.sum((candidates - reference[None, ...]) ** 2, axis=(-2, -1))
+    best = np.argmin(distances, axis=0)
+    return np.asarray(candidates[best, np.arange(corners.shape[0])])
+
+
+class DetectionsSmoother:
+    """
+    A utility class for smoothing detections over multiple frames in video tracking.
+    It maintains a history of detections for each track and provides smoothed
+    predictions based on these histories.
+
+    
+
+    !!! warning
+
+        - `DetectionsSmoother` requires the `tracker_id` for each detection. Refer to
+          [Roboflow Trackers](/latest/trackers/) for
+          information on integrating tracking into your inference pipeline.
+        - This class is not compatible with segmentation models.
+        - When detections in a frame disagree on confidence presence — some tracks
+          carry confidence scores and others do not — `confidence` is set to `None`
+          for all smoothed detections in that frame.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> smoother = sv.DetectionsSmoother(length=3)
+        >>> detections_1 = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     confidence=np.array([0.5]),
+        ...     tracker_id=np.array([1])
+        ... )
+        >>> detections_2 = sv.Detections(
+        ...     xyxy=np.array([[2, 2, 12, 12]]),
+        ...     confidence=np.array([0.7]),
+        ...     tracker_id=np.array([1])
+        ... )
+        >>> smoothed = smoother.update_with_detections(detections_1)
+        >>> smoothed.xyxy
+        array([[ 0.,  0., 10., 10.]])
+        >>> smoothed = smoother.update_with_detections(detections_2)
+        >>> smoothed.xyxy
+        array([[ 1.,  1., 11., 11.]])
+        >>> smoothed.confidence
+        array([0.6])
+
+        ```
+
+
+        ```python
+        import supervision as sv
+
+        from rfdetr import RFDETRMedium
+
+        video_info = sv.VideoInfo.from_video_path(video_path="")
+        frame_generator = sv.get_video_frames_generator(
+            source_path="")
+
+        model = RFDETRMedium()
+        tracker = sv.ByteTrack(frame_rate=video_info.fps)
+        smoother = sv.DetectionsSmoother()
+
+        box_annotator = sv.BoxAnnotator()
+
+        with sv.VideoSink("", video_info=video_info) as sink:
+            for frame in frame_generator:
+                detections = model.predict(frame[:, :, ::-1])
+                detections = tracker.update_with_detections(detections)
+                detections = smoother.update_with_detections(detections)
+
+                annotated_frame = box_annotator.annotate(frame.copy(), detections)
+                sink.write_frame(annotated_frame)
+        ```
+    """
+
+    def __init__(self, length: int = 5) -> None:
+        """
+        Args:
+            length: The maximum number of frames to consider for smoothing
+                detections. Defaults to 5.
+        """
+        self.tracks: defaultdict[int, deque[Detections | None]] = defaultdict(
+            lambda: deque(maxlen=length)
+        )
+
+    def reset(self) -> None:
+        """
+        Clears the per-track detection history so the smoother can be reused
+        across independent streams without carrying over frames from a
+        previous stream. The configured window `length` is preserved.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> smoother = sv.DetectionsSmoother()
+            >>> detections = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     confidence=np.array([0.5]),
+            ...     tracker_id=np.array([1])
+            ... )
+            >>> _ = smoother.update_with_detections(detections)
+            >>> len(smoother.tracks)
+            1
+            >>> smoother.reset()
+            >>> len(smoother.tracks)
+            0
+
+            ```
+        """
+        self.tracks.clear()
+
+    def update_with_detections(self, detections: Detections) -> Detections:
+        """
+        Updates the smoother with a new set of detections from a frame.
+
+        Args:
+            detections: The detections to add to the smoother.
+        """
+
+        if detections.tracker_id is None:
+            warnings.warn(
+                "Smoothing skipped. DetectionsSmoother requires tracker_id. Refer to "
+                "https://supervision.roboflow.com/latest/trackers for more "
+                "information.",
+                category=SupervisionWarnings,
+            )
+            return detections
+
+        for detection_idx in range(len(detections)):
+            tracker_id_value = detections.tracker_id[detection_idx]
+            tracker_id = int(tracker_id_value)
+
+            self.tracks[tracker_id].append(detections.select(detection_idx))
+
+        active_ids = set(detections.tracker_id.tolist())
+
+        for track_id in self.tracks.keys():
+            if track_id not in active_ids:
+                self.tracks[track_id].append(None)
+
+        for track_id in list(self.tracks.keys()):
+            if all(d is None for d in self.tracks[track_id]):
+                del self.tracks[track_id]
+
+        current_track_ids = active_ids
+        return self.get_smoothed_detections(track_ids=current_track_ids)
+
+    def get_track(self, track_id: int) -> Detections | None:
+        """Return the smoothed `Detections` for a single track.
+
+        Averages `xyxy` over all valid (non-`None`) frames in the track window.
+        `confidence` is averaged only over frames that carry it; frames with
+        `confidence=None` are excluded. When every valid frame carries compatible
+        oriented-box corners, those corners are aligned and averaged too, and
+        `xyxy` is derived from their resulting envelope. Mixed or incompatible
+        oriented-box metadata is dropped to keep the returned geometry consistent.
+        Returns `None` when the track is unknown or its entire window is empty.
+
+        Args:
+            track_id: The tracker ID whose smoothed detection to retrieve.
+
+        Returns:
+            Smoothed `Detections` for the track, or `None` if the track is
+            unknown or all frames in its window are empty.
+        """
+        track = self.tracks.get(track_id, None)
+        if track is None:
+            return None
+
+        valid: list[Detections] = [d for d in track if d is not None]
+        if len(valid) == 0:
+            return None
+
+        ret = deepcopy(valid[0])
+        ret.xyxy = np.mean(np.stack([d.xyxy for d in valid], axis=0), axis=0)
+        # Average confidence only over frames that carry it; frames with
+        # confidence=None contribute nothing to the mean. Retain None when
+        # no frame in the window carries confidence.
+        confidences = [d.confidence for d in valid if d.confidence is not None]
+        ret.confidence = np.mean(np.array(confidences), axis=0) if confidences else None
+
+        corner_sets = [
+            np.asarray(d.data[ORIENTED_BOX_COORDINATES])
+            for d in valid
+            if ORIENTED_BOX_COORDINATES in d.data
+        ]
+        if len(corner_sets) == len(valid) and len({c.shape for c in corner_sets}) == 1:
+            reference = corner_sets[0]
+            aligned = [
+                _align_oriented_corners(corners, reference) for corners in corner_sets
+            ]
+            smoothed_corners = np.mean(np.stack(aligned, axis=0), axis=0)
+            ret.data[ORIENTED_BOX_COORDINATES] = smoothed_corners
+            ret.xyxy = xyxyxyxy_to_xyxy(smoothed_corners)
+        else:
+            ret.data.pop(ORIENTED_BOX_COORDINATES, None)
+
+        return ret
+
+    def get_smoothed_detections(self, track_ids: set[int] | None = None) -> Detections:
+        """Return the smoothed detections for the requested active tracks.
+
+        Args:
+            track_ids: Optional set of track IDs to include in the output. When
+                provided, tracks absent from the current frame are excluded from the
+                emitted detections but their history stays cached.
+        """
+        tracked_detections = []
+        for track_id in self.tracks:
+            if track_ids is not None and track_id not in track_ids:
+                continue
+            track = self.get_track(track_id)
+            if track is not None:
+                tracked_detections.append(track)
+
+        # Detections.merge requires all-or-none for optional fields.
+        # When tracks disagree on confidence presence, drop it from all to
+        # prevent ValueError inside Detections.merge (stack_or_none invariant).
+        if tracked_detections and any(d.confidence is None for d in tracked_detections):
+            for d in tracked_detections:
+                d.confidence = None
+
+        detections = Detections.merge(tracked_detections)
+        if len(detections) == 0:
+            detections.tracker_id = np.array([], dtype=int)
+
+        return detections
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/tools/transformers.py b/.venv/lib/python3.12/site-packages/supervision/detection/tools/transformers.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f03f2d4440c1b91e22c03361434e88a3ba7fbd2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/tools/transformers.py
@@ -0,0 +1,279 @@
+from __future__ import annotations
+
+import io
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.detection.utils.converters import mask_to_xyxy
+
+
+def process_transformers_detection_result(
+    detection_result: dict[str, Any], id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process the result of Transformers object detection functions such as
+    `post_process` (v4) and `post_process_detection` (v5).
+
+    Args:
+        detection_result: Dictionary containing detection results with keys
+            'boxes', 'labels', and 'scores'.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed detection result including bounding boxes, confidence scores,
+            class IDs, and data.
+    """
+    class_ids = detection_result["labels"].cpu().detach().numpy().astype(int)
+    data = append_class_names_to_data(class_ids, id2label, {})
+
+    return dict(
+        xyxy=detection_result["boxes"].cpu().detach().numpy(),
+        confidence=detection_result["scores"].cpu().detach().numpy(),
+        class_id=class_ids,
+        data=data,
+    )
+
+
+def process_transformers_v4_segmentation_result(
+    segmentation_result: dict[str, Any], id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process the result of Transformers segmentation functions such as
+    `post_process_panoptic`, `post_process_segmentation`, and `post_process_instance`
+    (v4).
+
+    Args:
+        segmentation_result: Dictionary containing segmentation results with keys
+            'masks', 'labels', and 'scores'.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed segmentation result including bounding boxes, masks, confidence
+            scores, class IDs, and data.
+    """
+    if "png_string" in segmentation_result:
+        return process_transformers_v4_panoptic_segmentation_result(
+            segmentation_result, id2label
+        )
+    else:
+        boxes = None
+        if "boxes" in segmentation_result:
+            boxes = segmentation_result["boxes"].cpu().detach().numpy()
+        masks = segmentation_result["masks"].cpu().detach().numpy().astype(bool)
+        class_ids = segmentation_result["labels"].cpu().detach().numpy().astype(int)
+
+        return dict(
+            xyxy=boxes if boxes is not None else mask_to_xyxy(masks),
+            mask=np.squeeze(masks, axis=1) if boxes is not None else masks,
+            confidence=segmentation_result["scores"].cpu().detach().numpy(),
+            class_id=class_ids,
+            data=append_class_names_to_data(class_ids, id2label, {}),
+        )
+
+
+def process_transformers_v5_segmentation_result(
+    segmentation_result: Any, id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process the result of Transformers segmentation functions such as
+    `post_process_semantic_segmentation`, `post_process_instance_segmentation`, and
+    `post_process_panoptic_segmentation` (v5).
+
+    Args:
+        segmentation_result: Either a dictionary containing segmentation results
+            (`segments_info` and `segmentation`) or a tensor object
+            representing a semantic segmentation map.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed segmentation result including bounding boxes, masks, confidence
+            scores, class IDs, and data.
+    """
+    if segmentation_result.__class__.__name__ == "Tensor":
+        segmentation_array = segmentation_result.cpu().detach().numpy()
+        return process_transformers_v5_panoptic_segmentation_result(
+            segmentation_array, id2label
+        )
+    return process_transformers_v5_semantic_or_instance_segmentation_result(
+        cast(dict[str, Any], segmentation_result), id2label
+    )
+
+
+def process_transformers_v5_semantic_or_instance_segmentation_result(
+    segmentation_result: dict[str, Any], id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process the result of Transformers segmentation functions such as
+    `post_process_semantic_segmentation` and `post_process_instance_segmentation` (v5).
+
+    Args:
+        segmentation_result: Dictionary containing segmentation results with keys
+            `segments_info` and `segmentation`. `segmentation` is either a
+            `(height, width)` map of segment ids or, for
+            `post_process_instance_segmentation(return_binary_maps=True)`, a
+            `(num_segments, height, width)` stack of binary maps.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed segmentation result including bounding boxes, masks, confidence
+            scores, class IDs, and data.
+    """
+    segments_info = segmentation_result["segments_info"]
+    segmentation_array = segmentation_result["segmentation"].cpu().detach().numpy()
+    scores = np.array([segment["score"] for segment in segments_info], dtype=float)
+    class_ids = np.array([segment["label_id"] for segment in segments_info], dtype=int)
+    if len(segments_info) == 0:
+        masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+    elif segmentation_array.ndim == 3:
+        # Binary maps are stacked in the order segment ids were assigned, so each
+        # segment's `id` indexes its own map. Reading the maps directly also keeps
+        # pixels shared by overlapping instances, which a segment-id map drops.
+        segment_ids = [segment["id"] for segment in segments_info]
+        masks = segmentation_array[segment_ids].astype(bool)
+    else:
+        masks = np.array(
+            [segmentation_array == segment["id"] for segment in segments_info]
+        ).astype(bool)
+    data = append_class_names_to_data(class_ids, id2label, {})
+
+    return dict(
+        xyxy=mask_to_xyxy(masks),
+        mask=masks,
+        confidence=scores,
+        class_id=class_ids,
+        data=data,
+    )
+
+
+def process_transformers_v4_panoptic_segmentation_result(
+    segmentation_result: dict[str, Any], id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process the result of the Transformers function `post_process_panoptic` (v4).
+
+    Args:
+        segmentation_result: Dictionary containing segmentation results with keys
+            such as 'png_string' and 'segments_info'.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed segmentation result including bounding boxes, masks,
+            class IDs, and data.
+    """
+    segments_info = segmentation_result["segments_info"]
+    png_string = segmentation_result["png_string"]
+    class_ids = np.array(
+        [segment["category_id"] for segment in segments_info], dtype=int
+    )
+    segmentation_array = png_string_to_segmentation_array(png_string=png_string)
+    if len(segments_info) == 0:
+        masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+    else:
+        masks = np.array(
+            [segmentation_array == segment["id"] for segment in segments_info]
+        ).astype(bool)
+    data = append_class_names_to_data(class_ids, id2label, {})
+
+    return dict(
+        xyxy=mask_to_xyxy(masks),
+        mask=masks,
+        class_id=class_ids,
+        data=data,
+    )
+
+
+def process_transformers_v5_panoptic_segmentation_result(
+    segmentation_array: npt.NDArray[Any], id2label: dict[int, str] | None
+) -> dict[str, Any]:
+    """
+    Process a v5 Transformers semantic segmentation tensor.
+
+    Args:
+        segmentation_array: Segmentation array where unique values are class IDs.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+
+    Returns:
+        Processed segmentation result including bounding boxes, masks,
+            class IDs, and data.
+    """
+    class_ids = np.unique(segmentation_array).astype(int)
+    if len(class_ids) == 0:
+        masks = np.empty((0, *segmentation_array.shape), dtype=bool)
+    else:
+        masks = np.stack(
+            [segmentation_array == class_id for class_id in class_ids], axis=0
+        ).astype(bool)
+    data = append_class_names_to_data(class_ids, id2label, {})
+    return dict(xyxy=mask_to_xyxy(masks), mask=masks, class_id=class_ids, data=data)
+
+
+def png_string_to_segmentation_array(png_string: bytes) -> npt.NDArray[Any]:
+    """
+    Convert a PNG byte string to a panoptic segmentation array.
+
+    Args:
+        png_string: A byte string representing the PNG image.
+
+    Returns:
+        A segmentation ID array with shape (H, W), where each unique value
+            represents a different object or category. RGB-encoded panoptic
+            PNGs are decoded as little-endian 24-bit integers; alpha is ignored.
+    """
+    image = Image.open(io.BytesIO(png_string))
+    mask = np.array(image, dtype=np.uint8)
+    if mask.ndim == 2:
+        return mask.astype(np.uint32)
+    if mask.shape[2] < 3:
+        raise ValueError("Panoptic PNG masks must have at least 3 channels.")
+
+    segmentation = (
+        mask[:, :, 0].astype(np.uint32)
+        + (mask[:, :, 1].astype(np.uint32) << 8)
+        + (mask[:, :, 2].astype(np.uint32) << 16)
+    )
+    return cast(npt.NDArray[Any], segmentation)
+
+
+def append_class_names_to_data(
+    class_ids: npt.NDArray[Any],
+    id2label: dict[int, str] | None,
+    data: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """
+    Helper function to create or append to a data dictionary with class names if
+    available.
+
+    Args:
+        class_ids: Array of class IDs.
+        id2label: A dictionary mapping class IDs to labels,
+            typically part of the `transformers` model configuration. If provided, the
+            resulting dictionary will include class names.
+        data: An existing data dictionary to append to.
+
+    Returns:
+        Dictionary containing class names if id2label is provided.
+    """
+    if data is None:
+        data = {}
+
+    if id2label is not None:
+        class_names = np.array([id2label[class_id] for class_id in class_ids])
+        data[CLASS_NAME_DATA_FIELD] = class_names
+
+    return data
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__init__.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..253a503891017ef997cd43d495be9dec767b9667
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/_typing.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/_typing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..503f150c4ed451d96ad21dbb720bdd500b5b8e4b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/_typing.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/boxes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/boxes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69a67aa8768af1ac49d1c29094c6497523165a4a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/boxes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/converters.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/converters.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d7d7091a9424561abe7b011cca5f4102186c41b7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/converters.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/internal.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/internal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7954129929a8fb7c077dc4bb52b9c4cf88c720fd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/internal.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/iou_and_nms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/iou_and_nms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd7e113591982e54db3811f0ebffb5cf990e78ce
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/iou_and_nms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/masks.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/masks.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e7fe74d8633f4140c289eb0abd087a60854745f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/masks.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/polygons.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/polygons.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a0bb62f7ebc12ad4603574dc509b938e4a49f5e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/polygons.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/vlms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/vlms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a1b9c5588573b920b6916bcc873268a2d8bf01a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/detection/utils/__pycache__/vlms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/_typing.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/_typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b903ab367ddf05a963f8c1446908c5c8be34bac
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/_typing.py
@@ -0,0 +1,8 @@
+from typing import Any, TypeAlias
+
+import numpy as np
+import numpy.typing as npt
+
+_DetectionDataValueType: TypeAlias = npt.NDArray[np.generic] | list[Any]
+_DetectionDataType: TypeAlias = dict[str, _DetectionDataValueType]
+_MetadataType: TypeAlias = dict[str, Any]
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/boxes.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/boxes.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b18f221b3920b218e66b28d614d3f9eb20f12d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/boxes.py
@@ -0,0 +1,638 @@
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import (  # type: ignore[import-untyped,unused-ignore]
+    TargetMode,
+    deprecated,
+)
+
+from supervision.detection.utils.iou_and_nms import box_iou_batch
+from supervision.geometry.core import Position
+
+
+def clip_boxes(
+    xyxy: npt.NDArray[np.number],
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.number]:
+    """
+    Clips bounding boxes coordinates to fit within the frame resolution.
+
+    Args:
+        xyxy: A numpy array of shape `(N, 4)` where each
+            row corresponds to a bounding box in
+            the format `(x_min, y_min, x_max, y_max)`.
+        resolution_wh: A tuple of the form
+            `(width, height)` representing the resolution of the frame.
+
+    Returns:
+        A numpy array of shape `(N, 4)` where each row
+            corresponds to a bounding box with coordinates clipped to fit
+            within the frame resolution.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 20, 300, 200],
+        ...     [15, 25, 350, 450],
+        ...     [-10, -20, 30, 40]
+        ... ])
+        >>> sv.clip_boxes(xyxy=xyxy, resolution_wh=(320, 240))
+        array([[ 10,  20, 300, 200],
+               [ 15,  25, 320, 240],
+               [  0,   0,  30,  40]])
+
+        ```
+    """
+    result: npt.NDArray[np.number] = np.copy(xyxy)
+    width, height = resolution_wh
+    result[:, [0, 2]] = result[:, [0, 2]].clip(0, width)
+    result[:, [1, 3]] = result[:, [1, 3]].clip(0, height)
+    return result
+
+
+def pad_boxes(
+    xyxy: npt.NDArray[np.number],
+    px: int,
+    py: int | None = None,
+) -> npt.NDArray[np.number]:
+    """
+    Pads bounding boxes coordinates with a constant padding.
+
+    Args:
+        xyxy: A numpy array of shape `(N, 4)` where each
+            row corresponds to a bounding box in the format
+            `(x_min, y_min, x_max, y_max)`.
+        px: The padding value to be added to both the left and right sides of
+            each bounding box.
+        py: The padding value to be added to both the top and bottom
+            sides of each bounding box. If not provided, `px` will be used for both
+            dimensions.
+
+    Returns:
+        A numpy array of shape `(N, 4)` where each row corresponds to a
+            bounding box with coordinates padded according to the provided padding
+            values. Integer inputs produce `int64` output, or `float64` if a padded
+            coordinate exceeds the `int64` range. Floating-point inputs preserve
+            their dtype.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 20, 30, 40],
+        ...     [15, 25, 35, 45]
+        ... ])
+        >>> sv.pad_boxes(xyxy=xyxy, px=5, py=10)
+        array([[ 5, 10, 35, 50],
+               [10, 15, 40, 55]])
+
+        ```
+    """
+    if py is None:
+        py = px
+
+    integer_input = np.issubdtype(xyxy.dtype, np.integer)
+    padding: list[int] | npt.NDArray[Any] = [px, py]
+    if integer_input:
+        px, py = int(px), int(py)
+        exact_integer_limit = np.iinfo(np.int64).max // 2
+        is_safe_to_cast = max(abs(px), abs(py)) <= exact_integer_limit and np.all(
+            xyxy <= exact_integer_limit
+            if np.issubdtype(xyxy.dtype, np.unsignedinteger)
+            else (xyxy >= -exact_integer_limit) & (xyxy <= exact_integer_limit)
+        )
+        # Use exact Python integers only when int64 intermediates could overflow.
+        result = xyxy.astype(np.int64 if is_safe_to_cast else object)
+        padding = np.asarray([px, py], dtype=result.dtype)
+    else:
+        result = cast(npt.NDArray[Any], xyxy.copy())
+    result[:, [0, 1]] -= padding
+    result[:, [2, 3]] += padding
+
+    if integer_input and result.dtype == object:
+        limits = np.iinfo(np.int64)
+        fits_int64 = np.all((result >= limits.min) & (result <= limits.max))
+        return cast(
+            npt.NDArray[np.number],
+            np.asarray(result, dtype=np.int64 if fits_int64 else np.float64),
+        )
+    return cast(npt.NDArray[np.number], result)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=TargetMode.ARGS_REMAP,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+    args_mapping={"normalized_xyxy": "xyxy"},
+)
+def denormalize_boxes(
+    xyxy: npt.NDArray[np.number],
+    resolution_wh: tuple[int, int],
+    normalization_factor: float = 1.0,
+    normalized_xyxy: npt.NDArray[np.number] | None = None,
+) -> npt.NDArray[np.number]:
+    """
+    Convert normalized bounding box coordinates to absolute pixel coordinates.
+
+    Multiplies each bounding box coordinate by image size and divides by
+    `normalization_factor`, mapping values from normalized `[0, normalization_factor]`
+    to absolute pixel values for a given resolution.
+
+    Args:
+        xyxy: Normalized bounding boxes of shape `(N, 4)`,
+            where each row is `(x_min, y_min, x_max, y_max)`, values in
+            `[0, normalization_factor]`.
+        resolution_wh: Target image resolution as `(width, height)`.
+        normalization_factor: Maximum value of input coordinate range.
+            Defaults to `1.0`.
+
+    Returns:
+        Array of shape `(N, 4)` with absolute coordinates in
+            `(x_min, y_min, x_max, y_max)` format.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [0.1, 0.2, 0.5, 0.6],
+        ...     [0.3, 0.4, 0.7, 0.8],
+        ...     [0.2, 0.1, 0.6, 0.5]
+        ... ])
+        >>> sv.denormalize_boxes(xyxy, (1280, 720))
+        array([[128., 144., 640., 432.],
+               [384., 288., 896., 576.],
+               [256.,  72., 768., 360.]])
+
+        ```
+
+        ```pycon
+        >>> xyxy = np.array([
+        ...     [256., 128., 768., 640.]
+        ... ])
+        >>> sv.denormalize_boxes(xyxy, (1280, 720), normalization_factor=1024.0)
+        array([[320.,  90., 960., 450.]])
+
+        ```
+    """
+    width, height = resolution_wh
+
+    # Preserve floating caller dtypes; integer inputs need float64 to retain
+    # fractional pixel coordinates rather than silently truncating them.
+    scale_dtype = (
+        xyxy.dtype if np.issubdtype(xyxy.dtype, np.inexact) else np.dtype(np.float64)
+    )
+    scale = np.array([width, height, width, height], dtype=scale_dtype)
+    scale /= normalization_factor
+
+    return xyxy * scale
+
+
+def _sort_box_corners(
+    xyxy: npt.NDArray[np.number],
+) -> npt.NDArray[np.number]:
+    """Order each box's corners so that `x_min <= x_max` and `y_min <= y_max`.
+
+    `Detections.xyxy` is defined as `(x_min, y_min, x_max, y_max)`, and every
+    box operation in the library relies on that ordering: `box_iou_batch`
+    clamps its intersection widths at zero, so a box whose corners arrive
+    swapped scores an IoU of `0` even against itself. `box_area` hides the
+    problem rather than surfacing it, because negating both sides leaves their
+    product positive. Sorting the corner pairs restores the invariant without
+    moving the region a box describes; a correctly ordered box is unchanged.
+
+    Args:
+        xyxy: Boxes of shape `(N, 4)`, each row `(x_min, y_min, x_max, y_max)`,
+            possibly with either corner pair transposed.
+
+    Returns:
+        Boxes of shape `(N, 4)` with both corner pairs in ascending order.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.boxes import _sort_box_corners
+        >>> _sort_box_corners(np.array([[300.0, 320.0, 200.0, 80.0]]))
+        array([[200.,  80., 300., 320.]])
+
+        ```
+    """
+    xyxy = np.asarray(xyxy)
+    if xyxy.size == 0:
+        return xyxy
+    x_min = np.minimum(xyxy[:, 0], xyxy[:, 2])
+    x_max = np.maximum(xyxy[:, 0], xyxy[:, 2])
+    y_min = np.minimum(xyxy[:, 1], xyxy[:, 3])
+    y_max = np.maximum(xyxy[:, 1], xyxy[:, 3])
+    return cast(npt.NDArray[np.number], np.stack([x_min, y_min, x_max, y_max], axis=-1))
+
+
+def move_boxes(
+    xyxy: npt.NDArray[np.number], offset: npt.NDArray[np.integer]
+) -> npt.NDArray[np.number]:
+    """
+    Args:
+        xyxy: An array of shape `(n, 4)` containing the
+            bounding boxes coordinates in format `[x1, y1, x2, y2]`
+        offset: An array of shape `(2,)` containing offset values in format
+            is `[dx, dy]`.
+
+    Returns:
+        Repositioned bounding boxes.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 10, 20, 20],
+        ...     [30, 30, 40, 40]
+        ... ])
+        >>> offset = np.array([5, 5])
+        >>> sv.move_boxes(xyxy=xyxy, offset=offset)
+        array([[15, 15, 25, 25],
+               [35, 35, 45, 45]])
+
+        ```
+    """
+    return xyxy + np.hstack([offset, offset])
+
+
+def move_oriented_boxes(
+    xyxyxyxy: npt.NDArray[np.number], offset: npt.NDArray[np.integer]
+) -> npt.NDArray[np.number]:
+    """
+    Args:
+        xyxyxyxy: An array of shape `(n, 4, 2)` containing the
+        oriented bounding boxes coordinates in format
+        `[[x1, y1], [x2, y2], [x3, y3], [x3, y3]]`
+        offset: An array of shape `(2,)` containing offset values in format
+            is `[dx, dy]`.
+
+    Returns:
+        Repositioned bounding boxes.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.boxes import move_oriented_boxes
+        >>> xyxyxyxy = np.array([
+        ...     [
+        ...         [20, 10],
+        ...         [10, 20],
+        ...         [20, 30],
+        ...         [30, 20]
+        ...     ],
+        ...     [
+        ...         [30, 30],
+        ...         [20, 40],
+        ...         [30, 50],
+        ...         [40, 40]
+        ...     ]
+        ... ])
+        >>> offset = np.array([5, 5])
+        >>> move_oriented_boxes(xyxyxyxy=xyxyxyxy, offset=offset)
+        array([[[25, 15],
+                [15, 25],
+                [25, 35],
+                [35, 25]],
+        
+               [[35, 35],
+                [25, 45],
+                [35, 55],
+                [45, 45]]])
+
+        ```
+    """
+    return xyxyxyxy + offset
+
+
+def obb_polygon_area(corners: npt.NDArray[np.number]) -> npt.NDArray[np.float64]:
+    """Compute the area of N oriented bounding boxes using the shoelace formula.
+
+    Args:
+        corners: OBB corner coordinates with shape `(N, 4, 2)`.
+
+    Returns:
+        Area of each box as a 1-D float64 array of shape `(N,)`.
+
+    Raises:
+        ValueError: If `corners` does not have shape `(N, 4, 2)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.boxes import obb_polygon_area
+        >>> corners = np.array([[[0, 5], [5, 10], [10, 5], [5, 0]]], dtype=np.float32)
+        >>> obb_polygon_area(corners)
+        array([50.])
+
+        ```
+    """
+    corners = cast(npt.NDArray[np.number], np.asarray(corners))
+    if corners.ndim != 3 or corners.shape[-2:] != (4, 2):
+        raise ValueError(f"corners must have shape (N, 4, 2); got {corners.shape}")
+    # Translate each box before the shoelace products so representable integer
+    # coordinates with large origins (e.g. geospatial or stitched frames) are
+    # reduced to local extents before conversion to float64. Float inputs that
+    # were already quantized retain their input precision.
+    origin = corners[:, 0:1, :]
+    if np.issubdtype(corners.dtype, np.integer):
+        # Object arithmetic avoids unsigned underflow and signed overflow before
+        # the exact integer differences are converted to float64.
+        translated = np.asarray(
+            corners.astype(object) - origin.astype(object), dtype=np.float64
+        )
+    else:
+        translated = corners.astype(np.float64, copy=False) - origin.astype(
+            np.float64, copy=False
+        )
+    x = translated[..., 0]
+    y = translated[..., 1]
+    cross = x * np.roll(y, -1, axis=-1) - y * np.roll(x, -1, axis=-1)
+    return cast(npt.NDArray[np.float64], 0.5 * np.abs(np.sum(cross, axis=-1)))
+
+
+def xyxyxyxy_to_xyxy(
+    xyxyxyxy: npt.NDArray[np.number],
+) -> npt.NDArray[np.number]:
+    """Convert oriented bounding box corners to axis-aligned bounding boxes.
+
+    Args:
+        xyxyxyxy: OBB corner coordinates with shape `(N, 4, 2)` where each
+            box is represented as `[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`.
+
+    Returns:
+        Axis-aligned bounding boxes as an array of shape `(N, 4)`
+            in `(x_min, y_min, x_max, y_max)` format.
+
+    Raises:
+        ValueError: If `xyxyxyxy` does not have shape `(N, 4, 2)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> corners = np.array([
+        ...     [[0, 0], [10, 0], [10, 5], [0, 5]],
+        ...     [[5, 5], [15, 5], [15, 10], [5, 10]],
+        ... ], dtype=np.float32)
+        >>> sv.xyxyxyxy_to_xyxy(corners)
+        array([[ 0.,  0., 10.,  5.],
+               [ 5.,  5., 15., 10.]], dtype=float32)
+
+        ```
+    """
+    xyxyxyxy = cast(npt.NDArray[np.number], np.asarray(xyxyxyxy))
+    if xyxyxyxy.ndim != 3 or xyxyxyxy.shape[-2:] != (4, 2):
+        raise ValueError(f"xyxyxyxy must have shape (N, 4, 2); got {xyxyxyxy.shape}")
+    x_min = xyxyxyxy[..., 0].min(axis=-1)
+    y_min = xyxyxyxy[..., 1].min(axis=-1)
+    x_max = xyxyxyxy[..., 0].max(axis=-1)
+    y_max = xyxyxyxy[..., 1].max(axis=-1)
+    return cast(npt.NDArray[np.number], np.stack([x_min, y_min, x_max, y_max], axis=-1))
+
+
+# Anchor position -> (sx, sy) offset from the box center, in units of the box
+# half-width and half-height. Image coordinates, so +y points down.
+_ANCHOR_OFFSETS: dict[Position, tuple[float, float]] = {
+    Position.CENTER: (0.0, 0.0),
+    Position.CENTER_LEFT: (-1.0, 0.0),
+    Position.CENTER_RIGHT: (1.0, 0.0),
+    Position.TOP_CENTER: (0.0, -1.0),
+    Position.BOTTOM_CENTER: (0.0, 1.0),
+    Position.TOP_LEFT: (-1.0, -1.0),
+    Position.TOP_RIGHT: (1.0, -1.0),
+    Position.BOTTOM_LEFT: (-1.0, 1.0),
+    Position.BOTTOM_RIGHT: (1.0, 1.0),
+}
+
+
+def _oriented_box_anchors(
+    xyxyxyxy: npt.NDArray[np.number], anchor: Position
+) -> npt.NDArray[np.float64]:
+    """Locate an anchor point on each oriented bounding box.
+
+    The returned point always lies on the oriented rectangle itself: corners map
+    to corners, side anchors to side midpoints, and `CENTER` to the box center.
+    For an axis-aligned box the result matches the anchor derived from the
+    envelope, so this is a drop-in replacement that stops the anchor from drifting
+    off a rotated body.
+
+    Args:
+        xyxyxyxy: OBB corner coordinates with shape `(N, 4, 2)` in winding order,
+            each box as `[[x1, y1], [x2, y2], [x3, y3], [x4, y4]]`.
+        anchor: The anchor position to locate. `Position.CENTER_OF_MASS` is not
+            supported here, as it is defined on a mask rather than a box.
+
+    Returns:
+        Anchor coordinates as an array of shape `(N, 2)`.
+
+    Raises:
+        ValueError: If `xyxyxyxy` does not have shape `(N, 4, 2)`, or the anchor
+            is not supported.
+
+    Note:
+        Corners must be in consecutive winding order (clockwise or
+        counter-clockwise). Non-sequential ordering (e.g. diagonal pairs)
+        silently produces incorrect results.
+
+        Width and height are determined by x-axis projection of each half-side
+        vector. When a box rotates past ``arctan(w/h)`` (approx. 68 deg for a
+        10 x 4 box) the assigned *width* side flips discontinuously, producing
+        a jump in anchor position (~``|w - h|`` pixels for ``BOTTOM_CENTER``).
+        The anchor always lies on the box; the effect is cosmetic for static
+        images but visible on rotating objects in video.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.boxes import _oriented_box_anchors
+        >>> from supervision.geometry.core import Position
+        >>> corners = np.array(
+        ...     [[[0, 0], [10, 0], [10, 4], [0, 4]]], dtype=np.float32
+        ... )
+        >>> _oriented_box_anchors(corners, Position.BOTTOM_CENTER)
+        array([[5., 4.]])
+
+        ```
+    """
+    corners = np.asarray(xyxyxyxy, dtype=np.float64)
+    if corners.ndim != 3 or corners.shape[-2:] != (4, 2):
+        raise ValueError(f"xyxyxyxy must have shape (N, 4, 2); got {corners.shape}")
+    if anchor not in _ANCHOR_OFFSETS:
+        raise ValueError(f"{anchor} is not supported.")
+    sx, sy = _ANCHOR_OFFSETS[anchor]
+
+    center = corners.mean(axis=1)
+    # Two perpendicular half-side vectors per box.
+    half_side_a = (corners[:, 1] - corners[:, 0]) / 2
+    half_side_b = (corners[:, 2] - corners[:, 1]) / 2
+
+    # Map each box's own sides onto the image axes: the side more aligned with
+    # the x-axis plays the role of width, the other of height. This makes the
+    # offsets collapse to the axis-aligned frame when the box is not rotated.
+    is_width = np.abs(half_side_a[:, 0]) >= np.abs(half_side_b[:, 0])
+    width = np.where(is_width[:, None], half_side_a, half_side_b)
+    height = np.where(is_width[:, None], half_side_b, half_side_a)
+    # Point width toward +x and height toward +y so the offset signs are stable.
+    width = np.where((width[:, 0] < 0)[:, None], -width, width)
+    height = np.where((height[:, 1] < 0)[:, None], -height, height)
+
+    return cast(npt.NDArray[np.float64], center + sx * width + sy * height)
+
+
+def scale_boxes(
+    xyxy: npt.NDArray[np.number], factor: float
+) -> npt.NDArray[np.floating]:
+    """
+    Scale the dimensions of bounding boxes.
+
+    Args:
+        xyxy: An integer or floating-point array of shape `(n, 4)` containing
+            bounding box coordinates in format `[x1, y1, x2, y2]`.
+        factor: A float value representing the factor by which the box
+            dimensions are scaled. A factor greater than 1 enlarges the boxes, while a
+            factor less than 1 shrinks them.
+
+    Returns:
+        Scaled bounding boxes. Integer input arrays produce `float64` output;
+        floating-point inputs preserve their existing dtype.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 10, 20, 20],
+        ...     [30, 30, 40, 40]
+        ... ])
+        >>> sv.scale_boxes(xyxy=xyxy, factor=1.5)
+        array([[ 7.5,  7.5, 22.5, 22.5],
+               [27.5, 27.5, 42.5, 42.5]])
+
+        ```
+    """
+    if np.issubdtype(xyxy.dtype, np.integer):
+        exact_integer_limit = 2**52
+        is_safe_to_cast = np.all(
+            xyxy <= exact_integer_limit
+            if np.issubdtype(xyxy.dtype, np.unsignedinteger)
+            else (xyxy >= -exact_integer_limit) & (xyxy <= exact_integer_limit)
+        )
+        if is_safe_to_cast:
+            xyxy = xyxy.astype(np.float64)
+        elif np.isfinite(factor):
+            # Preserve 64-bit integer precision through both final-corner
+            # expressions. Converting the center first can change the final
+            # float64 rounding near 2**53.
+            factor_numerator, factor_denominator = factor.as_integer_ratio()
+            integer_coordinates = xyxy.astype(object)
+            coordinate_sum = integer_coordinates[:, :2] + integer_coordinates[:, 2:]
+            coordinate_size = integer_coordinates[:, 2:] - integer_coordinates[:, :2]
+            denominator = 2 * factor_denominator
+            lower = np.asarray(
+                (
+                    coordinate_sum * factor_denominator
+                    - coordinate_size * factor_numerator
+                )
+                / denominator,
+                dtype=np.float64,
+            )
+            upper = np.asarray(
+                (
+                    coordinate_sum * factor_denominator
+                    + coordinate_size * factor_numerator
+                )
+                / denominator,
+                dtype=np.float64,
+            )
+            return cast(
+                npt.NDArray[np.floating], np.concatenate((lower, upper), axis=1)
+            )
+        else:
+            xyxy = xyxy.astype(np.float64)
+
+    centers = cast(npt.NDArray[np.floating], (xyxy[:, :2] + xyxy[:, 2:]) / 2)
+    new_sizes = cast(npt.NDArray[np.floating], (xyxy[:, 2:] - xyxy[:, :2]) * factor)
+    return cast(
+        npt.NDArray[np.floating],
+        np.concatenate((centers - new_sizes / 2, centers + new_sizes / 2), axis=1),
+    )
+
+
+def spread_out_boxes(
+    xyxy: npt.NDArray[np.number],
+    max_iterations: int = 100,
+) -> npt.NDArray[np.number]:
+    """
+    Spread out boxes that overlap with each other.
+
+    Args:
+        xyxy: Numpy array of shape (N, 4) where N is the number of boxes.
+        max_iterations: Maximum number of iterations to run the algorithm for.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.boxes import spread_out_boxes
+        >>> xyxy = np.array([
+        ...     [10, 10, 20, 20],
+        ...     [12, 12, 22, 22]
+        ... ])
+        >>> spread_out = spread_out_boxes(xyxy=xyxy, max_iterations=10)
+        >>> # The boxes should be moved apart
+        >>> bool(spread_out[0, 0] < 10 and spread_out[0, 1] < 10)
+        True
+        >>> bool(spread_out[1, 0] > 12 and spread_out[1, 1] > 12)
+        True
+
+        ```
+    """
+    if len(xyxy) == 0:
+        return xyxy
+
+    xyxy_padded = cast(npt.NDArray[Any], pad_boxes(xyxy, px=1))
+    for _ in range(max_iterations):
+        # NxN
+        iou = box_iou_batch(xyxy_padded, xyxy_padded)
+        np.fill_diagonal(iou, 0)
+        if np.all(iou == 0):
+            break
+
+        overlap_mask = iou > 0
+
+        # Nx2
+        centers = (xyxy_padded[:, :2] + xyxy_padded[:, 2:]) / 2
+
+        # NxNx2
+        delta_centers = centers[:, np.newaxis, :] - centers[np.newaxis, :, :]
+        delta_centers *= overlap_mask[:, :, np.newaxis]
+
+        # Nx2
+        delta_sum = np.sum(delta_centers, axis=1)
+        delta_magnitude = np.linalg.norm(delta_sum, axis=1, keepdims=True)
+        direction_vectors = np.divide(
+            delta_sum,
+            delta_magnitude,
+            out=np.zeros_like(delta_sum),
+            where=delta_magnitude != 0,
+        )
+
+        force_vectors = np.sum(iou, axis=1)
+        force_vectors = force_vectors[:, np.newaxis] * direction_vectors
+
+        force_vectors *= 10
+        force_vectors[(force_vectors > 0) & (force_vectors < 2)] = 2
+        force_vectors[(force_vectors < 0) & (force_vectors > -2)] = -2
+
+        force_vectors = force_vectors.astype(int)
+
+        xyxy_padded[:, [0, 1]] += force_vectors
+        xyxy_padded[:, [2, 3]] += force_vectors
+
+    return pad_boxes(xyxy_padded, px=-1)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/converters.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/converters.py
new file mode 100644
index 0000000000000000000000000000000000000000..f327e94dbddf927dee6992de5f9d8807e01c4efd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/converters.py
@@ -0,0 +1,837 @@
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+
+MIN_POLYGON_POINT_COUNT = 3
+CoordinateConvention = Literal["inclusive", "exclusive"]
+
+
+def xyxy_to_polygons(box: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """
+    Convert an array of boxes to an array of polygons.
+    Retains the input datatype.
+
+    Args:
+        box: An array of boxes (N, 4), where each box is represented as a
+            list of four coordinates in the format `(x_min, y_min, x_max, y_max)`.
+
+    Returns:
+        An array of polygons (N, 4, 2), where each polygon is
+            represented as a list of four coordinates in the format `(x, y)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> box = np.array([[10, 20, 30, 40]])
+        >>> sv.xyxy_to_polygons(box)
+        array([[[10, 20],
+                [30, 20],
+                [30, 40],
+                [10, 40]]])
+
+        ```
+    """
+    polygon = np.zeros((box.shape[0], 4, 2), dtype=box.dtype)
+    polygon[:, :, 0] = box[:, [0, 2, 2, 0]]
+    polygon[:, :, 1] = box[:, [1, 1, 3, 3]]
+    return polygon
+
+
+def polygon_to_mask(
+    polygon: npt.NDArray[np.number],
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.uint8]:
+    """Generate a mask from a polygon.
+
+    Args:
+        polygon: The polygon for which the mask should be generated,
+            given as a list of vertices.
+        resolution_wh: The width and height of the desired resolution.
+
+    Returns:
+        The generated 2D mask, where the polygon is marked with
+            `1`s and the rest is filled with `0`s.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> polygon = np.array([[2, 2], [6, 2], [6, 6], [2, 6]])
+        >>> mask = sv.polygon_to_mask(polygon, resolution_wh=(10, 10))
+        >>> int(mask.sum())
+        25
+
+        ```
+    """
+    width, height = map(int, resolution_wh)
+    mask = np.zeros((height, width), dtype=np.uint8)
+    cv2.fillPoly(mask, [polygon.astype(np.int32)], color=(1,))
+    return mask
+
+
+def xywh_to_xyxy(xywh: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """
+    Converts bounding box coordinates from `(x, y, width, height)`
+    format to `(x_min, y_min, x_max, y_max)` format.
+
+    Args:
+        xywh: A numpy array of shape `(N, 4)` where each row
+            corresponds to a bounding box in the format `(x, y, width, height)`.
+
+    Returns:
+        A numpy array of shape `(N, 4)` where each row corresponds
+            to a bounding box in the format `(x_min, y_min, x_max, y_max)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xywh = np.array([
+        ...     [10, 20, 30, 40],
+        ...     [15, 25, 35, 45]
+        ... ])
+        >>> sv.xywh_to_xyxy(xywh=xywh)
+        array([[10, 20, 40, 60],
+               [15, 25, 50, 70]])
+
+        ```
+    """
+    xyxy = xywh.copy()
+    xyxy[:, 2] = xywh[:, 0] + xywh[:, 2]
+    xyxy[:, 3] = xywh[:, 1] + xywh[:, 3]
+    return cast(npt.NDArray[np.number], np.asarray(xyxy))
+
+
+def xyxy_to_xywh(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """
+    Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)`
+    format to `(x, y, width, height)` format.
+
+    Args:
+        xyxy: A numpy array of shape `(N, 4)` where each row
+            corresponds to a bounding box in the format `(x_min, y_min, x_max,
+            y_max)`.
+
+    Returns:
+        A numpy array of shape `(N, 4)` where each row corresponds
+            to a bounding box in the format `(x, y, width, height)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 20, 40, 60],
+        ...     [15, 25, 50, 70]
+        ... ])
+        >>> sv.xyxy_to_xywh(xyxy=xyxy)
+        array([[10, 20, 30, 40],
+               [15, 25, 35, 45]])
+
+        ```
+    """
+    xywh = xyxy.copy()
+    xywh[:, 2] = xyxy[:, 2] - xyxy[:, 0]
+    xywh[:, 3] = xyxy[:, 3] - xyxy[:, 1]
+    return cast(npt.NDArray[np.number], np.asarray(xywh))
+
+
+def xcycwh_to_xyxy(xcycwh: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """
+    Converts bounding box coordinates from `(center_x, center_y, width, height)`
+    format to `(x_min, y_min, x_max, y_max)` format.
+
+    Args:
+        xcycwh: A numpy array of shape `(N, 4)` where each row
+            corresponds to a bounding box in the format `(center_x, center_y, width,
+            height)`.
+
+    Returns:
+        A numpy array of shape `(N, 4)` where each row corresponds
+            to a bounding box in the format `(x_min, y_min, x_max, y_max)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xcycwh = np.array([
+        ...     [50.0, 50.0, 20.0, 30.0],
+        ...     [30.0, 40.0, 10.0, 15.0]
+        ... ])
+        >>> sv.xcycwh_to_xyxy(xcycwh=xcycwh)
+        array([[40. , 35. , 60. , 65. ],
+               [25. , 32.5, 35. , 47.5]])
+
+        ```
+    """
+    # Build the result from the half-extent arithmetic instead of writing into a
+    # copy of the input. Half of an odd width or height is fractional, so an
+    # integer input array would silently truncate those coordinates; letting the
+    # division set the output dtype keeps them exact.
+    center_x = xcycwh[:, 0]
+    center_y = xcycwh[:, 1]
+    half_width = xcycwh[:, 2] / 2
+    half_height = xcycwh[:, 3] / 2
+    xyxy = np.column_stack(
+        (
+            center_x - half_width,
+            center_y - half_height,
+            center_x + half_width,
+            center_y + half_height,
+        )
+    )
+    return cast(npt.NDArray[np.number], xyxy)
+
+
+def xyxy_to_xcycarh(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.floating]:
+    """
+    Converts bounding box coordinates from `(x_min, y_min, x_max, y_max)`
+    into measurement space to format `(center x, center y, aspect ratio, height)`,
+    where the aspect ratio is `width / height`.
+
+    Args:
+        xyxy: Bounding box in format `(x1, y1, x2, y2)`.
+            Expected shape is `(N, 4)`.
+    Returns:
+        Bounding box in format
+            `(center x, center y, aspect ratio, height)`. Shape `(N, 4)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> xyxy = np.array([
+        ...     [10, 20, 40, 60],
+        ...     [15, 25, 50, 70]
+        ... ])
+        >>> sv.xyxy_to_xcycarh(xyxy=xyxy)  # doctest: +ELLIPSIS
+        array([[25.        , 40.        ,  0.75      , 40.        ],
+               [32.5       , 47.5       ,  0.77..., 45.        ]])
+
+        ```
+
+    """
+    if xyxy.size == 0:
+        return np.empty((0, 4), dtype=float)
+
+    x1, y1, x2, y2 = xyxy.T
+    width = x2 - x1
+    height = y2 - y1
+    center_x = x1 + width / 2
+    center_y = y1 + height / 2
+
+    aspect_ratio = np.divide(
+        width,
+        height,
+        out=np.zeros_like(width, dtype=float),
+        where=height != 0,
+    )
+    result = np.column_stack((center_x, center_y, aspect_ratio, height))
+    return result.astype(float)
+
+
+def mask_to_xyxy(
+    masks: npt.NDArray[np.bool_],
+    coordinate_convention: CoordinateConvention = "inclusive",
+) -> npt.NDArray[np.int_]:
+    """
+    Converts a 3D `np.array` of 2D bool masks into a 2D `np.array` of bounding boxes.
+
+    Args:
+        masks: A 3D `np.array` of shape `(N, H, W)` containing 2D bool masks.
+        coordinate_convention: How to interpret the returned max corner.
+            Use `"inclusive"` to preserve the legacy Supervision behavior,
+            where `x_max` and `y_max` are the last covered pixel. Use
+            `"exclusive"` for half-open boxes that match area and IoU arithmetic.
+
+    Returns:
+        A 2D `np.array` of shape `(N, 4)` containing the bounding boxes
+            `(x_min, y_min, x_max, y_max)` for each mask.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> masks = np.array([
+        ...     [[False, False, False],
+        ...      [False,  True,  True],
+        ...      [False,  True,  True]],
+        ... ])
+        >>> sv.mask_to_xyxy(masks)
+        array([[1, 1, 2, 2]])
+
+        ```
+    """
+    n, height, width = masks.shape
+    if masks.size == 0:
+        return np.zeros((n, 4), dtype=int)
+
+    # Reduce the mask stack to per-row / per-column occupancy, then read the
+    # tight bounds straight off those 1D profiles instead of scanning every
+    # pixel of every mask with `np.where`.
+    rows_any = cast(npt.NDArray[np.bool_], masks.any(axis=2))  # (N, H)
+    cols_any = cast(npt.NDArray[np.bool_], masks.any(axis=1))  # (N, W)
+
+    x_min = cols_any.argmax(axis=1)
+    y_min = rows_any.argmax(axis=1)
+
+    if coordinate_convention == "inclusive":
+        x_max = width - 1 - cols_any[:, ::-1].argmax(axis=1)
+        y_max = height - 1 - rows_any[:, ::-1].argmax(axis=1)
+    elif coordinate_convention == "exclusive":
+        x_max = width - cols_any[:, ::-1].argmax(axis=1)
+        y_max = height - rows_any[:, ::-1].argmax(axis=1)
+    else:
+        raise ValueError(
+            "coordinate_convention must be 'inclusive' or 'exclusive', "
+            f"got {coordinate_convention!r}."
+        )
+
+    xyxy = np.stack((x_min, y_min, x_max, y_max), axis=1).astype(int)
+    # Empty masks have no bounds; keep the original all-zeros box for them.
+    xyxy[~rows_any.any(axis=1)] = 0
+    return xyxy
+
+
+def xyxy_to_mask(
+    boxes: npt.NDArray[np.number],
+    resolution_wh: tuple[int, int],
+    coordinate_convention: CoordinateConvention = "inclusive",
+) -> npt.NDArray[np.bool_]:
+    """
+    Converts a 2D `np.ndarray` of bounding boxes into a 3D `np.ndarray` of bool masks.
+
+    Args:
+        boxes: A 2D `np.ndarray` of shape `(N, 4)` containing bounding boxes
+            `(x_min, y_min, x_max, y_max)`.
+        resolution_wh: A tuple `(width, height)` specifying the resolution of
+            the output masks.
+        coordinate_convention: How to interpret `x_max` and `y_max`.
+            Use `"inclusive"` for closed boxes with the legacy Supervision
+            convention. Use `"exclusive"` for half-open boxes that align with
+            box area and IoU calculations.
+
+    Returns:
+        A 3D `np.ndarray` of shape `(N, height, width)` containing 2D bool masks
+            for each bounding box.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> boxes = np.array([[0, 0, 2, 2]])
+        >>> sv.xyxy_to_mask(boxes, (5, 5))
+        array([[[ True,  True,  True, False, False],
+                [ True,  True,  True, False, False],
+                [ True,  True,  True, False, False],
+                [False, False, False, False, False],
+                [False, False, False, False, False]]])
+        >>> boxes = np.array([[0, 0, 1, 1], [3, 3, 4, 4]])
+        >>> sv.xyxy_to_mask(boxes, (5, 5))
+        array([[[ True,  True, False, False, False],
+                [ True,  True, False, False, False],
+                [False, False, False, False, False],
+                [False, False, False, False, False],
+                [False, False, False, False, False]],
+        
+               [[False, False, False, False, False],
+                [False, False, False, False, False],
+                [False, False, False, False, False],
+                [False, False, False,  True,  True],
+                [False, False, False,  True,  True]]])
+
+        ```
+    """
+    width, height = resolution_wh
+    n = boxes.shape[0]
+    masks = np.zeros((n, height, width), dtype=bool)
+
+    for i, (x_min, y_min, x_max, y_max) in enumerate(boxes):
+        x_min = max(0, int(x_min))
+        y_min = max(0, int(y_min))
+        if coordinate_convention == "inclusive":
+            x_max = min(width - 1, int(x_max))
+            y_max = min(height - 1, int(y_max))
+            if x_max >= x_min and y_max >= y_min:
+                masks[i, y_min : y_max + 1, x_min : x_max + 1] = True
+        elif coordinate_convention == "exclusive":
+            x_max = min(width, int(x_max))
+            y_max = min(height, int(y_max))
+            if x_max > x_min and y_max > y_min:
+                masks[i, y_min:y_max, x_min:x_max] = True
+        else:
+            raise ValueError(
+                "coordinate_convention must be 'inclusive' or 'exclusive', "
+                f"got {coordinate_convention!r}."
+            )
+
+    return masks
+
+
+def mask_to_polygons(mask: npt.NDArray[np.bool_]) -> list[npt.NDArray[np.int32]]:
+    """
+    Converts a binary mask to a list of polygons.
+
+    Args:
+        mask: A binary mask represented as a 2D NumPy array of shape `(H, W)`,
+            where H and W are the height and width of the mask, respectively.
+
+    Returns:
+        A list of polygons, where each polygon is represented by a NumPy array
+            of shape `(N, 2)`, containing the `x`, `y` coordinates of the
+            points. Polygons with fewer points than `MIN_POLYGON_POINT_COUNT = 3`
+            are excluded from the output.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.zeros((10, 10), dtype=bool)
+        >>> mask[2:6, 2:6] = True
+        >>> sv.mask_to_polygons(mask)
+        [array([[2, 2],
+               [2, 5],
+               [5, 5],
+               [5, 2]], dtype=int32)]
+
+        ```
+    """
+
+    contours = cv2.find_contours(mask.astype(np.uint8))
+    return [
+        np.squeeze(contour, axis=1)
+        for contour in contours
+        if contour.shape[0] >= MIN_POLYGON_POINT_COUNT
+    ]
+
+
+def _base48_decode(s: str) -> list[int]:
+    """Decode a COCO base-48 string to raw (delta-encoded) integers.
+
+    Implements the variable-length base-48 codec from the COCO API
+    (pycocotools). Each integer is encoded across one or more 6-bit
+    characters: bits 0-4 carry data; bit 5 signals continuation; bit 4
+    of the final character signals a negative value.
+
+    This is the pure codec layer — call :func:`_delta_decode` on the
+    result to obtain absolute run-length counts.
+
+    Args:
+        s: COCO compressed RLE string.
+
+    Returns:
+        Raw delta-encoded integers, one per run.
+
+    Raises:
+        ValueError: If the string is truncated mid-integer.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.converters import _base48_decode
+        >>> _base48_decode("52203")
+        [5, 2, 2, 0, 3]
+
+        ```
+    """
+    values: list[int] = []
+    i = 0
+    while i < len(s):
+        x = 0
+        k = 0
+        more = True
+        while more:
+            if i >= len(s):
+                raise ValueError(
+                    f"Malformed compressed RLE string: unexpected end at position {i}"
+                )
+            c = ord(s[i]) - 48
+            x |= (c & 0x1F) << (5 * k)
+            more = bool(c & 0x20)
+            i += 1
+            k += 1
+            if not more and (c & 0x10):
+                x |= ~0 << (5 * k)
+        values.append(x)
+    return values
+
+
+def _base48_encode(values: list[int]) -> str:
+    """Encode raw (delta-encoded) integers to a COCO base-48 string.
+
+    The inverse of :func:`_base48_decode`. Applies the same variable-length
+    base-48 codec used by pycocotools.
+
+    Apply :func:`_delta_encode` to absolute run-length counts before calling
+    this function to produce a valid COCO compressed RLE string.
+
+    Args:
+        values: Raw (delta-encoded) integers to encode.
+
+    Returns:
+        COCO base-48 encoded string.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.converters import _base48_encode
+        >>> _base48_encode([5, 2, 2, 0, 3])
+        '52203'
+
+        ```
+    """
+    chars: list[str] = []
+    for x in values:
+        more = True
+        while more:
+            c = x & 0x1F
+            x >>= 5
+            more = (x != -1) if (c & 0x10) else (x != 0)
+            if more:
+                c |= 0x20
+            chars.append(chr(c + 48))
+    return "".join(chars)
+
+
+def _delta_decode(values: list[int]) -> list[int]:
+    """Undo COCO delta encoding: ``counts[i] += counts[i - 2]`` for ``i > 2``.
+
+    The COCO compressed RLE format stores run lengths as deltas relative to
+    the count two positions earlier (starting at index 3). This function
+    converts those relative values back to absolute run lengths.
+
+    Args:
+        values: Raw delta-encoded integers from :func:`_base48_decode`.
+
+    Returns:
+        Absolute run-length counts (alternating background / foreground).
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.converters import _delta_decode
+        >>> _delta_decode([5, 2, 2, 0, 3])
+        [5, 2, 2, 2, 5]
+
+        ```
+    """
+    # The recurrence ``counts[i] += counts[i - 2]`` for ``i >= 3`` decomposes
+    # into two independent stride-2 chains: the odd indices (1, 3, 5, ...) and
+    # the even indices from 2 onward (2, 4, 6, ...). A cumulative sum over each
+    # chain recovers the absolute counts. Index 0 is absolute and untouched.
+    # int64 accumulation avoids overflow; ``tolist`` returns native Python ints.
+    counts = np.asarray(values, dtype=np.int64)
+    counts[1::2] = np.cumsum(counts[1::2])
+    counts[2::2] = np.cumsum(counts[2::2])
+    return cast("list[int]", counts.tolist())
+
+
+def _delta_encode(counts: list[int]) -> list[int]:
+    """Apply COCO delta encoding: ``d[i] = counts[i] - counts[i - 2]`` for ``i > 2``.
+
+    The inverse of :func:`_delta_decode`. Converts absolute run lengths to
+    the relative representation required by the COCO compressed RLE format.
+
+    Args:
+        counts: Absolute run-length counts (alternating background / foreground).
+
+    Returns:
+        Delta-encoded integers ready for :func:`_base48_encode`.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.converters import _delta_encode
+        >>> _delta_encode([5, 2, 2, 2, 5])
+        [5, 2, 2, 0, 3]
+
+        ```
+    """
+    deltas = list(counts)
+    for i in range(3, len(deltas)):
+        deltas[i] = counts[i] - counts[i - 2]
+    return deltas
+
+
+def is_compressed_rle(rle: object) -> bool:
+    """Return ``True`` if ``rle`` is a COCO compressed RLE (``str`` or ``bytes``).
+
+    Use this to branch between the compressed-string pipeline
+    (:func:`_base48_decode` → :func:`_delta_decode`) and the uncompressed
+    integer-list / array pipeline before calling :func:`rle_to_mask`.
+
+    Args:
+        rle: Candidate RLE value to inspect.
+
+    Returns:
+        ``True`` for ``str`` or ``bytes`` inputs; ``False`` otherwise.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.converters import is_compressed_rle
+        >>> is_compressed_rle("52203")
+        True
+        >>> is_compressed_rle([5, 2, 2, 2, 5])
+        False
+
+        ```
+    """
+    return isinstance(rle, (str, bytes))
+
+
+def _mask_to_rle_counts(mask_2d: npt.NDArray[Any]) -> npt.NDArray[np.int32]:
+    """Encode a 2D boolean mask as COCO F-order run lengths (int32 array).
+
+    Pixels are scanned column-by-column (Fortran order), matching the COCO /
+    pycocotools RLE convention. The first value is always the count of leading
+    ``False`` pixels (may be 0 if the mask starts with ``True``).
+
+    This is the shared low-level encoder used by both :func:`mask_to_rle` and
+    :class:`~supervision.detection.compact_mask.CompactMask`.
+
+    Args:
+        mask_2d: 2D boolean array of shape ``(H, W)``.
+
+    Returns:
+        int32 array of run lengths starting with the False count.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.converters import _mask_to_rle_counts
+        >>> mask = np.array([[False, True], [True, False]])
+        >>> _mask_to_rle_counts(mask).tolist()
+        [1, 2, 1]
+
+        ```
+    """
+    flat = np.asarray(mask_2d, dtype=np.bool_).ravel(order="F")
+    if len(flat) == 0:
+        return np.array([0], dtype=np.int32)
+
+    changes = np.diff(flat.view(np.uint8))
+    boundaries = np.where(changes != 0)[0] + 1
+    positions = np.concatenate(([0], boundaries, [len(flat)]))
+    run_lengths = np.diff(positions).astype(np.int32)
+
+    if flat[0]:
+        run_lengths = np.concatenate(([np.int32(0)], run_lengths))
+
+    return run_lengths
+
+
+def _rle_counts_to_mask(
+    rle: npt.NDArray[np.int32], height: int, width: int
+) -> npt.NDArray[np.bool_]:
+    """Decode COCO F-order run lengths back to a 2D boolean mask.
+
+    This is the shared low-level decoder used by both :func:`rle_to_mask` and
+    :class:`~supervision.detection.compact_mask.CompactMask`.
+
+    Args:
+        rle: int32 array of run lengths as produced by :func:`_mask_to_rle_counts`.
+        height: Height of the output mask.
+        width: Width of the output mask.
+
+    Returns:
+        2D boolean array of shape ``(height, width)``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.converters import _rle_counts_to_mask
+        >>> rle = np.array([0, 1, 2, 1], dtype=np.int32)
+        >>> _rle_counts_to_mask(rle, 2, 2)
+        array([[ True, False],
+               [False,  True]])
+
+        ```
+    """
+    is_true = np.arange(len(rle)) % 2 == 1
+    flat: npt.NDArray[np.bool_] = np.repeat(is_true, rle)
+    num_pixels = height * width
+    if len(flat) < num_pixels:
+        flat = np.pad(flat, (0, num_pixels - len(flat)))
+    return cast(
+        npt.NDArray[np.bool_], flat[:num_pixels].reshape(height, width, order="F")
+    )
+
+
+def rle_to_mask(
+    rle: npt.NDArray[np.integer[Any]] | list[int] | str | bytes,
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.bool_]:
+    """
+    Converts a COCO run-length encoding (RLE) to a binary mask.
+
+    Implements the COCO RLE format used by ``pycocotools``: pixels are counted
+    in **column-major (Fortran) order** — top-to-bottom within each column,
+    left-to-right across columns. This is the opposite of the row-major order
+    used by NumPy's default ``'C'`` layout. Passing RLE data produced by a
+    different row-major convention will yield an incorrect mask.
+
+    Args:
+        rle: The COCO RLE data in one of the following formats:
+
+            - A 1D array or list of integers (uncompressed COCO RLE, where
+              values at even indices are background run-lengths and values at
+              odd indices are foreground run-lengths, both counted column-major).
+            - A compressed COCO RLE string or bytes, as produced by
+              ``pycocotools.mask.encode``.
+        resolution_wh: The width (w) and height (h)
+            of the desired binary mask.
+
+    Returns:
+        The generated 2D Boolean mask of shape `(h, w)`, where the foreground object is
+            marked with `True`'s and the rest is filled with `False`'s.
+
+    Raises:
+        ValueError: If the sum of pixels encoded in RLE differs from the
+            number of pixels in the expected mask (computed based on resolution_wh).
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = sv.rle_to_mask([5, 2, 2, 2, 5], (4, 4))
+        >>> mask  # doctest: +NORMALIZE_WHITESPACE
+        array([[False, False, False, False],
+               [False,  True,  True, False],
+               [False,  True,  True, False],
+               [False, False, False, False]])
+
+        >>> mask = sv.rle_to_mask("52203", (4, 4))
+        >>> mask  # doctest: +NORMALIZE_WHITESPACE
+        array([[False, False, False, False],
+               [False,  True,  True, False],
+               [False,  True,  True, False],
+               [False, False, False, False]])
+
+        ```
+    """
+    if isinstance(rle, bytes):
+        rle = rle.decode("utf-8")
+    if isinstance(rle, str):
+        counts: npt.NDArray[np.int32] = np.array(
+            _delta_decode(_base48_decode(rle)), dtype=np.int32
+        )
+    elif isinstance(rle, list):
+        counts = np.array(rle, dtype=np.int32)
+    else:
+        counts = np.asarray(rle, dtype=np.int32)
+
+    width, height = resolution_wh
+
+    if width * height != np.sum(counts):
+        raise ValueError(
+            "the sum of the number of pixels in the RLE must be the same "
+            "as the number of pixels in the expected mask"
+        )
+
+    return _rle_counts_to_mask(counts, height, width)
+
+
+def mask_to_rle(
+    mask: npt.NDArray[np.bool_], compressed: bool = False
+) -> list[int] | str:
+    """
+    Converts a binary mask into a COCO run-length encoding (RLE).
+
+    Produces RLE in the COCO format used by ``pycocotools``: pixels are counted
+    in **column-major (Fortran) order** — top-to-bottom within each column,
+    left-to-right across columns. The output is directly compatible with
+    ``pycocotools.mask.decode`` and COCO annotation JSON files.
+
+    Args:
+        mask: 2D binary mask where `True` indicates foreground
+            object and `False` indicates background.
+        compressed: If ``True``, return a compressed COCO RLE string
+            compatible with ``pycocotools``. If ``False`` (default),
+            return a list of integers.
+
+    Returns:
+        The COCO run-length encoded mask. When ``compressed`` is ``False``,
+            values of a list with even indices represent the number of pixels
+            assigned as background (`False`), values of a list with odd indices
+            represent the number of pixels assigned as foreground object (`True`),
+            both counted in column-major order.
+            When ``compressed`` is ``True``, a COCO compressed RLE string.
+
+    Raises:
+        ValueError: If input mask is not 2D or is empty.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([
+        ...     [True, True, True, True],
+        ...     [True, True, True, True],
+        ...     [True, True, True, True],
+        ...     [True, True, True, True],
+        ... ])
+        >>> rle = sv.mask_to_rle(mask)
+        >>> [int(x) for x in rle]
+        [0, 16]
+
+        ```
+
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([
+        ...     [False, False, False, False],
+        ...     [False, True,  True,  False],
+        ...     [False, True,  True,  False],
+        ...     [False, False, False, False],
+        ... ])
+        >>> rle = sv.mask_to_rle(mask)
+        >>> [int(x) for x in rle]
+        [5, 2, 2, 2, 5]
+
+        >>> sv.mask_to_rle(mask, compressed=True)
+        '52203'
+
+        ```
+
+    ![mask_to_rle](https://media.roboflow.com/supervision-docs/
+    mask-to-rle.png){ align=center width="800" }
+    """
+    if mask.ndim != 2:
+        raise ValueError("Input mask must be 2D")
+    if mask.size == 0:
+        raise ValueError("Input mask cannot be empty")
+
+    counts: list[int] = cast(list[int], _mask_to_rle_counts(mask).tolist())
+    if compressed:
+        return _base48_encode(_delta_encode(counts))
+    return counts
+
+
+def polygon_to_xyxy(polygon: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """
+    Converts a polygon represented by a NumPy array into a bounding box.
+
+    Args:
+        polygon: A polygon represented by a NumPy array of shape `(N, 2)`,
+            containing the `x`, `y` coordinates of the points.
+
+    Returns:
+        A 1D NumPy array containing the bounding box
+            `(x_min, y_min, x_max, y_max)` of the input polygon.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> polygon = np.array([[10, 20], [30, 20], [30, 40], [10, 40]])
+        >>> sv.polygon_to_xyxy(polygon)
+        array([10, 20, 30, 40])
+
+        ```
+    """
+    x_min, y_min = np.min(polygon, axis=0)
+    x_max, y_max = np.max(polygon, axis=0)
+    return np.array([x_min, y_min, x_max, y_max])
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/internal.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/internal.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c3dd7eb1d12daf23cd22a8cfb019188ac567609
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/internal.py
@@ -0,0 +1,806 @@
+import logging
+from itertools import chain
+from typing import Any, Literal, cast, overload
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.utils._typing import _DetectionDataType, _MetadataType
+from supervision.detection.utils.converters import polygon_to_mask, rle_to_mask
+from supervision.geometry.core import Vector
+
+logger = logging.getLogger(__name__)
+
+
+def _full_image_xyxy(
+    count: int,
+    image_height: int,
+    image_width: int,
+    dtype: npt.DTypeLike = np.float64,
+) -> npt.NDArray[Any]:
+    """Return full-frame inclusive boxes for lossless mask compaction."""
+    return np.tile(
+        np.array([[0, 0, image_width - 1, image_height - 1]], dtype=dtype),
+        (count, 1),
+    )
+
+
+def _valid_rle_payload(prediction: dict[str, Any]) -> dict[str, Any] | None:
+    """Return the first valid RLE payload from ``rle`` then ``rle_mask``."""
+    for key in ("rle", "rle_mask"):
+        rle_data = prediction.get(key)
+        if isinstance(rle_data, dict) and {"size", "counts"}.issubset(rle_data):
+            return rle_data
+    return None
+
+
+def extract_ultralytics_masks(yolov8_results: Any) -> npt.NDArray[np.bool_] | None:
+    """Extract boolean masks from Ultralytics results, cropping letterbox padding.
+
+    Handles the case where the inference resolution differs from the original image
+    shape by computing the letterbox padding offsets, cropping them out, and resizing
+    each proto mask back to `orig_shape`. Thresholds at 0.5 to match Ultralytics'
+    semantics and avoid dilating masks through float interpolation.
+
+    Args:
+        yolov8_results: Ultralytics results object with `.masks` and `.orig_shape`.
+
+    Returns:
+        Boolean array of shape `(N, H, W)` aligned with the detections, or `None`
+        when no masks are present.
+    """
+    if not yolov8_results.masks:
+        return None
+
+    orig_shape = yolov8_results.orig_shape
+    inference_shape = tuple(yolov8_results.masks.data.shape[1:])
+
+    pad = (0, 0)
+
+    if inference_shape != orig_shape:
+        gain = min(
+            inference_shape[0] / orig_shape[0],
+            inference_shape[1] / orig_shape[1],
+        )
+        pad = (
+            (inference_shape[1] - orig_shape[1] * gain) / 2,
+            (inference_shape[0] - orig_shape[0] * gain) / 2,
+        )
+
+    top, left = int(pad[1]), int(pad[0])
+    bottom, right = int(inference_shape[0] - pad[1]), int(inference_shape[1] - pad[0])
+
+    mask_maps = []
+    masks = yolov8_results.masks.data.cpu().numpy()
+    for i in range(masks.shape[0]):
+        mask = masks[i]
+        mask = mask[top:bottom, left:right]
+
+        if mask.shape != orig_shape:
+            # `cv2.resize` interpolates the float proto mask, so threshold at 0.5
+            # (matching Ultralytics' own semantics) instead of casting every
+            # nonzero interpolated value to True, which would dilate the mask.
+            mask = cv2.resize(mask, (orig_shape[1], orig_shape[0])) > 0.5
+        # else: slice-crop (no interpolation) preserves the binary 0/1 float values
+        # produced by Ultralytics; the final np.asarray(..., dtype=bool) is equivalent.
+
+        mask_maps.append(mask)
+
+    return cast(npt.NDArray[np.bool_], np.asarray(mask_maps, dtype=bool))
+
+
+def _resolve_rle_mask(
+    rle_data: dict[str, Any],
+    image_height: int,
+    image_width: int,
+    compact_masks: bool,
+) -> tuple[npt.NDArray[np.bool_] | None, dict[str, Any] | None]:
+    """Decode one RLE prediction into (dense_mask, compact_pending).
+
+    Returns ``(dense_mask, None)`` when ``compact_masks=False`` or when the
+    RLE size does not match the image size (fall back to dense decode).
+    Returns ``(None, rle_data)`` when ``compact_masks=True`` and the RLE size
+    matches, deferring the item to the post-loop batch call.
+    Returns ``(None, None)`` on decode failure (caller should skip mask).
+
+    Args:
+        rle_data: Validated COCO RLE dict with ``"size"`` and ``"counts"`` keys.
+        image_height: Full-image height in pixels.
+        image_width: Full-image width in pixels.
+        compact_masks: Whether to return a deferred item for batch processing.
+
+    Returns:
+        A 2-tuple ``(dense_mask, pending)`` where at most one element is
+        non-``None``.
+    """
+    try:
+        h, w = rle_data["size"]
+        if compact_masks and (h, w) == (image_height, image_width):
+            # Sizes match; defer to the post-loop CompactMask.from_coco_rle call.
+            return None, rle_data
+        if compact_masks and (h, w) != (image_height, image_width):
+            logger.debug(
+                "compact_masks=True: RLE size %s does not match image "
+                "size (%d, %d); falling back to dense decode.",
+                (h, w),
+                image_height,
+                image_width,
+            )
+        mask: npt.NDArray[np.bool_] = rle_to_mask(rle_data["counts"], (w, h))
+        if (h, w) != (image_height, image_width):
+            mask = cv2.resize(
+                mask.astype(np.uint8),
+                (image_width, image_height),
+                interpolation=cv2.INTER_NEAREST,
+            ).astype(bool)
+        return mask, None
+    except (ValueError, AssertionError, KeyError, TypeError, OverflowError) as exc:
+        logger.warning(
+            "Failed to decode RLE mask payload; falling back to box-only "
+            "detection. Reason: %s",
+            exc,
+        )
+        return None, None
+
+
+def _all_present_or_none(
+    values: list[Any],
+    label: str,
+    dtype: npt.DTypeLike,
+) -> npt.NDArray[Any] | None:
+    # Identity check (`v is None`) is required when values may contain numpy arrays:
+    # `None in values` triggers element-wise comparison and raises ValueError.
+    missing = sum(v is None for v in values)
+    if 0 < missing < len(values):
+        logger.warning(
+            "Partial %s in batch; dropping all to preserve alignment with xyxy.", label
+        )
+    if not values or missing > 0:
+        return None
+    return np.array(values, dtype=dtype)
+
+
+def _decode_compact_masks(
+    coco_rle_pending: list[tuple[int, Any, list[float]]],
+    polygon_compact_map: dict[int, CompactMask],
+    image_height: int,
+    image_width: int,
+    n_predictions: int,
+) -> CompactMask | None:
+    """Decode deferred COCO-RLE entries and merge with polygon compact masks.
+
+    Attempts a single batched ``CompactMask.from_coco_rle`` call for all pending
+    items to eliminate per-prediction call overhead on the happy path.  On any
+    decode failure the call is retried per-prediction so that one malformed RLE
+    payload does not abort the entire batch.
+
+    Isolation note: this function isolates the *decode* step only.  If the
+    per-prediction fallback still leaves some predictions without masks, the
+    mixed-modality guard drops ALL masks to preserve alignment with ``xyxy``.
+
+    Args:
+        coco_rle_pending: Deferred COCO-RLE items collected during the prediction
+            loop, each as ``(xyxy_idx, rle_dict, bbox)``.
+        polygon_compact_map: Already-decoded polygon masks keyed by ``xyxy_idx``.
+        image_height: Frame height in pixels.
+        image_width: Frame width in pixels.
+        n_predictions: Total number of accepted predictions; used by the
+            mixed-modality alignment guard.
+
+    Returns:
+        A merged ``CompactMask`` when all predictions that carry masks decoded
+        successfully, or ``None`` when no masks are present or the
+        mixed-modality guard triggers.
+
+    Examples:
+        ```pycon
+        >>> _decode_compact_masks([], {}, 1080, 1920, 5) is None
+        True
+
+        ```
+    """
+    coco_compact_map: dict[int, CompactMask] = {}
+    if coco_rle_pending:
+        pending_indices = [t[0] for t in coco_rle_pending]
+        pending_rles = [t[1] for t in coco_rle_pending]
+        pending_xyxy = np.array([t[2] for t in coco_rle_pending], dtype=np.float64)
+        try:
+            batch_cm = CompactMask.from_coco_rle(
+                pending_rles, pending_xyxy, (image_height, image_width)
+            )
+            for local_idx, global_idx in enumerate(pending_indices):
+                coco_compact_map[global_idx] = batch_cm[local_idx : local_idx + 1]
+        except (ValueError, AssertionError, KeyError, TypeError, OverflowError) as exc:
+            logger.warning(
+                "Batch compact RLE decode failed (%s); retrying "
+                "per-prediction for fault isolation.",
+                exc,
+            )
+            for xyxy_idx, rle_dict, bbox in coco_rle_pending:
+                try:
+                    single_cm = CompactMask.from_coco_rle(
+                        [rle_dict],
+                        np.array([bbox], dtype=np.float64),
+                        (image_height, image_width),
+                    )
+                    coco_compact_map[xyxy_idx] = single_cm[0:1]
+                except (
+                    ValueError,
+                    AssertionError,
+                    KeyError,
+                    TypeError,
+                    OverflowError,
+                ) as per_exc:
+                    logger.warning(
+                        "Compact RLE decode failed for prediction at index %d; "
+                        "dropping that mask. Reason: %s",
+                        xyxy_idx,
+                        per_exc,
+                    )
+    all_compact = {**coco_compact_map, **polygon_compact_map}
+    compact_parts: list[CompactMask] = [
+        all_compact[i] for i in sorted(all_compact.keys())
+    ]
+    if 0 < len(compact_parts) < n_predictions:
+        logger.warning(
+            "Mixed-modality compact batch: %d of %d predictions carry masks; "
+            "dropping all masks to preserve alignment with xyxy.",
+            len(compact_parts),
+            n_predictions,
+        )
+        compact_parts = []
+    return CompactMask.merge(compact_parts) if compact_parts else None
+
+
+@overload
+def process_roboflow_result(
+    roboflow_result: dict[str, Any],
+    *,
+    compact_masks: Literal[False] = False,
+) -> tuple[
+    npt.NDArray[np.floating],
+    npt.NDArray[np.floating],
+    npt.NDArray[np.integer],
+    npt.NDArray[np.bool_] | None,
+    npt.NDArray[np.integer] | None,
+    _DetectionDataType,
+]: ...
+
+
+@overload
+def process_roboflow_result(
+    roboflow_result: dict[str, Any],
+    *,
+    compact_masks: Literal[True],
+) -> tuple[
+    npt.NDArray[np.floating],
+    npt.NDArray[np.floating],
+    npt.NDArray[np.integer],
+    CompactMask | None,
+    npt.NDArray[np.integer] | None,
+    _DetectionDataType,
+]: ...
+
+
+def process_roboflow_result(
+    roboflow_result: dict[str, Any],
+    *,
+    compact_masks: bool = False,
+) -> tuple[
+    npt.NDArray[np.floating],
+    npt.NDArray[np.floating],
+    npt.NDArray[np.integer],
+    npt.NDArray[np.bool_] | CompactMask | None,
+    npt.NDArray[np.integer] | None,
+    _DetectionDataType,
+]:
+    """Parse a Roboflow API or Inference package result into detection arrays.
+
+    The returned ``data`` dict always contains ``CLASS_NAME_DATA_FIELD`` as a
+    string-dtype NumPy array. When ``predictions`` is empty, the array has
+    shape ``(0,)`` with ``dtype=str``, preserving dtype contracts for callers
+    that mix empty and non-empty results.
+
+    Args:
+        roboflow_result: Raw dict from the Roboflow REST API or the Inference
+            package (after ``.dict()`` serialisation).
+        compact_masks: When ``True``, return segmentation masks as
+            :class:`~supervision.detection.compact_mask.CompactMask` instead of
+            a dense boolean array when mask data is present.
+
+    Returns:
+        A 6-tuple of ``(xyxy, confidence, class_id, masks, tracker_ids, data)``
+        where each array is aligned with the others. ``masks`` is ``None``
+        when no predictions include mask data, or when only a subset do
+        (mixed-modality batch) — in that case all masks are dropped to preserve
+        alignment with ``xyxy``. Note: a single malformed polygon prediction
+        (fewer than 3 points) in an otherwise fully-segmented batch causes all
+        masks to be dropped from the result; the detection itself is kept as a
+        box-only entry with a ``logger.warning``. When ``compact_masks=True``
+        and masks are
+        present, ``masks`` is a :class:`CompactMask`; otherwise it is a dense
+        boolean array. ``tracker_ids`` is ``None`` when no predictions carry a
+        tracker ID, or when only a subset do (mixed batch) — in that case all
+        tracker IDs are dropped to preserve alignment with ``xyxy``.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.internal import process_roboflow_result
+        >>> result = {"predictions": [], "image": {"width": 100, "height": 100}}
+        >>> _, _, _, _, _, data = process_roboflow_result(result)
+        >>> data["class_name"].dtype.kind
+        'U'
+
+        ```
+    """
+    if not roboflow_result["predictions"]:
+        return (
+            np.empty((0, 4), dtype=np.float64),
+            np.empty(0, dtype=np.float64),
+            np.empty(0, dtype=np.int64),
+            None,
+            None,
+            {CLASS_NAME_DATA_FIELD: np.empty(0, dtype=str)},
+        )
+
+    xyxy: list[list[float]] = []
+    confidence: list[float] = []
+    class_id: list[int] = []
+    class_name: list[str] = []
+    masks: list[npt.NDArray[np.bool_] | None] = []
+    # Deferred COCO-RLE processing: collect validated pairs here, then after the
+    # loop attempt a single batched from_coco_rle call (happy path). If that batch
+    # call fails, fall back to decoding each pending prediction individually for
+    # fault isolation.
+    _coco_rle_pending: list[tuple[int, Any, list[float]]] = []  # (xyxy_idx, rle, bbox)
+    _polygon_compact_map: dict[int, CompactMask] = {}  # xyxy_idx → CompactMask
+    tracker_ids: list[int | None] = []
+
+    image_width = int(roboflow_result["image"]["width"])
+    image_height = int(roboflow_result["image"]["height"])
+
+    for prediction in roboflow_result["predictions"]:
+        x = prediction["x"]
+        y = prediction["y"]
+        width = prediction["width"]
+        height = prediction["height"]
+        x_min = x - width / 2
+        y_min = y - height / 2
+        x_max = x_min + width
+        y_max = y_min + height
+
+        rle_data = _valid_rle_payload(prediction)
+        mask: npt.NDArray[np.bool_] | None = None
+        compact_mask: CompactMask | None = None
+        if rle_data is not None:
+            _dense, _pending = _resolve_rle_mask(
+                rle_data, image_height, image_width, compact_masks
+            )
+            if _dense is None and _pending is None:
+                # Decode failed; treat as no-mask prediction.
+                rle_data = None
+            elif _pending is None:
+                # Dense result: compact_masks=False, or size-mismatch fallback.
+                mask = _dense
+                if compact_masks and mask is not None:
+                    compact_mask = CompactMask.from_dense(
+                        masks=mask[np.newaxis, ...],
+                        xyxy=_full_image_xyxy(1, image_height, image_width),
+                        image_shape=(image_height, image_width),
+                    )
+            # else: _pending set → deferred to batch; mask and compact_mask stay None
+        if rle_data is not None:
+            xyxy_idx = len(xyxy)
+            xyxy.append([x_min, y_min, x_max, y_max])
+            class_id.append(prediction["class_id"])
+            class_name.append(prediction["class"])
+            confidence.append(prediction["confidence"])
+            if compact_masks:
+                if compact_mask is not None:
+                    # Fallback dense path (size mismatch): compact_mask always set.
+                    _polygon_compact_map[xyxy_idx] = compact_mask
+                else:
+                    # Main COCO-RLE path: (h, w) == image size; defer to batch.
+                    # Pass the detector bbox so _rle_split_cols only walks
+                    # crop columns, not the full image width.
+                    _coco_rle_pending.append(
+                        (
+                            xyxy_idx,
+                            rle_data,
+                            [x_min, y_min, x_max, y_max],
+                        )
+                    )
+            elif mask is not None:
+                masks.append(mask)
+            tracker_ids.append(prediction.get("tracker_id"))
+        elif "points" not in prediction:
+            xyxy.append([x_min, y_min, x_max, y_max])
+            class_id.append(prediction["class_id"])
+            class_name.append(prediction["class"])
+            confidence.append(prediction["confidence"])
+            masks.append(None)
+            tracker_ids.append(prediction.get("tracker_id"))
+        elif len(prediction["points"]) >= 3:
+            polygon = np.array(
+                [[point["x"], point["y"]] for point in prediction["points"]], dtype=int
+            )
+            mask = polygon_to_mask(
+                polygon, resolution_wh=(image_width, image_height)
+            ).astype(bool)
+            xyxy_idx = len(xyxy)
+            xyxy.append([x_min, y_min, x_max, y_max])
+            class_id.append(prediction["class_id"])
+            class_name.append(prediction["class"])
+            confidence.append(prediction["confidence"])
+            if compact_masks:
+                _polygon_compact_map[xyxy_idx] = CompactMask.from_dense(
+                    masks=mask[np.newaxis, ...],
+                    xyxy=_full_image_xyxy(1, image_height, image_width),
+                    image_shape=(image_height, image_width),
+                )
+            else:
+                masks.append(mask)
+            tracker_ids.append(prediction.get("tracker_id"))
+        else:
+            logger.warning(
+                "Invalid polygon prediction with fewer than 3 points; falling back "
+                "to box-only detection."
+            )
+            xyxy.append([x_min, y_min, x_max, y_max])
+            class_id.append(prediction["class_id"])
+            class_name.append(prediction["class"])
+            confidence.append(prediction["confidence"])
+            masks.append(None)
+            tracker_ids.append(prediction.get("tracker_id"))
+
+    xyxy_arr: npt.NDArray[np.floating] = (
+        np.array(xyxy, dtype=np.float64) if len(xyxy) > 0 else np.empty((0, 4))
+    )
+    confidence_arr: npt.NDArray[np.floating] = (
+        np.array(confidence, dtype=np.float64) if len(confidence) > 0 else np.empty(0)
+    )
+    class_id_arr: npt.NDArray[np.integer] = (
+        np.array(class_id, dtype=np.int64)
+        if len(class_id) > 0
+        else np.empty(0, dtype=np.int64)
+    )
+    class_name_arr: npt.NDArray[np.str_] = (
+        np.array(class_name) if len(class_name) > 0 else np.empty(0, dtype=str)
+    )
+    masks_arr: npt.NDArray[np.bool_] | CompactMask | None
+    if compact_masks:
+        masks_arr = _decode_compact_masks(
+            _coco_rle_pending,
+            _polygon_compact_map,
+            image_height,
+            image_width,
+            len(xyxy),
+        )
+    else:
+        masks_arr = _all_present_or_none(masks, "mask", dtype=bool)
+    tracker_id_arr: npt.NDArray[np.integer] | None = _all_present_or_none(
+        tracker_ids, "tracker_id", dtype=np.int64
+    )
+    data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: class_name_arr}
+
+    return (
+        xyxy_arr,
+        confidence_arr,
+        class_id_arr,
+        masks_arr,
+        tracker_id_arr,
+        data,
+    )
+
+
+def is_data_equal(
+    data_a: _DetectionDataType,
+    data_b: _DetectionDataType,
+) -> bool:
+    """
+    Compares the data payloads of two Detections instances.
+
+    Args:
+        data_a, data_b: The data payloads of the instances.
+
+    Returns:
+        True if the data payloads are equal, False otherwise.
+    """
+    return set(data_a.keys()) == set(data_b.keys()) and all(
+        np.array_equal(data_a[key], data_b[key]) for key in data_a
+    )
+
+
+def is_metadata_equal(metadata_a: _MetadataType, metadata_b: _MetadataType) -> bool:
+    """
+    Compares the metadata payloads of two Detections instances.
+
+    Args:
+        metadata_a, metadata_b: The metadata payloads of the instances.
+
+    Returns:
+        True if the metadata payloads are equal, False otherwise.
+    """
+    return set(metadata_a.keys()) == set(metadata_b.keys()) and all(
+        metadata_values_equal(metadata_a[key], metadata_b[key]) for key in metadata_a
+    )
+
+
+def merge_data(
+    data_list: list[_DetectionDataType],
+) -> _DetectionDataType:
+    """
+    Merges the data payloads of a list of Detections instances.
+
+    Warning: Assumes that empty detections were filtered-out before passing data to
+    this function.
+
+    Args:
+        data_list: The data payloads of the Detections instances. Each data payload
+            is a dictionary with the same keys, and the values are either lists or
+            npt.NDArray[np.generic].
+
+    Returns:
+        A single data payload containing the merged data, preserving the original data
+            types (list or npt.NDArray[np.generic]).
+
+    Raises:
+        ValueError: If data values within a single object have different lengths or if
+            dictionaries have different keys.
+    """
+    if not data_list:
+        return {}
+
+    all_keys_sets = [set(data.keys()) for data in data_list]
+    if not all(keys_set == all_keys_sets[0] for keys_set in all_keys_sets):
+        raise ValueError("All data dictionaries must have the same keys to merge.")
+
+    for data in data_list:
+        lengths = [len(value) for value in data.values()]
+        if len(set(lengths)) > 1:
+            raise ValueError(
+                "All data values within a single object must have equal length."
+            )
+
+    merged_data: dict[str, Any] = {key: [] for key in all_keys_sets[0]}
+    for data in data_list:
+        for key in data:
+            merged_data[key].append(data[key])
+
+    for key in merged_data:
+        if all(isinstance(item, list) for item in merged_data[key]):
+            merged_data[key] = list(chain.from_iterable(merged_data[key]))
+        elif all(isinstance(item, np.ndarray) for item in merged_data[key]):
+            ndim = merged_data[key][0].ndim
+            if ndim == 1:
+                merged_data[key] = np.hstack(merged_data[key])
+            elif ndim > 1:
+                merged_data[key] = np.vstack(merged_data[key])
+            else:
+                raise ValueError(f"Unexpected array dimension for key '{key}'.")
+        else:
+            raise ValueError(
+                f"Inconsistent data types for key '{key}'. Only np.ndarray and list "
+                f"types are allowed."
+            )
+
+    return cast(_DetectionDataType, merged_data)
+
+
+def metadata_values_equal(value_a: Any, value_b: Any) -> bool:
+    """Check whether two metadata values can merge into one.
+
+    The predicate is total: any value type may be passed, and comparisons that a
+    type does not support resolve to `False` rather than propagating an exception.
+
+    Args:
+        value_a, value_b: The metadata values to compare.
+
+    Returns:
+        True if both values are considered equal, False otherwise.
+    """
+    if isinstance(value_a, np.ndarray) and isinstance(value_b, np.ndarray):
+        # `equal_nan` makes an array holding NaN equal to itself, but NumPy rejects
+        # the argument for non-floating dtypes, so it is only passed when both
+        # operands are float arrays.
+        both_floating = np.issubdtype(value_a.dtype, np.floating) and np.issubdtype(
+            value_b.dtype, np.floating
+        )
+        if both_floating:
+            return bool(np.array_equal(value_a, value_b, equal_nan=True))
+        return bool(np.array_equal(value_a, value_b))
+    if isinstance(value_a, np.ndarray) or isinstance(value_b, np.ndarray):
+        return False
+    try:
+        return bool(value_a == value_b)
+    except (ValueError, RuntimeError, TypeError):
+        # Containers of arrays (list/dict/tuple of ndarray) and tensor types return
+        # an elementwise result whose truth value is ambiguous; treat as unequal.
+        return False
+
+
+def merge_metadata(metadata_list: list[_MetadataType]) -> _MetadataType:
+    """
+    Merge metadata from a list of metadata dictionaries.
+
+    This function combines the metadata dictionaries. If a key appears in more than one
+    dictionary, the values must be identical for the merge to succeed.
+
+    Warning: Assumes that empty detections were filtered-out before passing metadata to
+    this function.
+
+    Args:
+        metadata_list: A list of metadata dictionaries to merge.
+
+    Returns:
+        A single merged metadata dictionary.
+
+    Raises:
+        ValueError: If there are conflicting values for the same key or if
+            dictionaries have different keys.
+    """
+    if not metadata_list:
+        return {}
+
+    all_keys_sets = [set(metadata.keys()) for metadata in metadata_list]
+    if not all(keys_set == all_keys_sets[0] for keys_set in all_keys_sets):
+        raise ValueError("All metadata dictionaries must have the same keys to merge.")
+
+    merged_metadata: _MetadataType = {}
+    for metadata in metadata_list:
+        for key, value in metadata.items():
+            if key not in merged_metadata:
+                merged_metadata[key] = value
+                continue
+
+            other_value = merged_metadata[key]
+            if not metadata_values_equal(value, other_value):
+                if isinstance(value, np.ndarray) or isinstance(other_value, np.ndarray):
+                    raise ValueError(
+                        f"Conflicting metadata for key: '{key}': "
+                        f"{type(value)}, {type(other_value)}."
+                    )
+                raise ValueError(f"Conflicting metadata for key: '{key}'.")
+
+    return merged_metadata
+
+
+def merge_metadata_lenient(
+    metadata_list: list[_MetadataType],
+) -> tuple[_MetadataType, set[str]]:
+    """Merge metadata dictionaries, dropping keys that cannot be reconciled.
+
+    Unlike :func:`merge_metadata`, which raises on any disagreement, this variant
+    applies a lenient policy: a key survives only when every dictionary carries it
+    and all of its values compare equal under
+    :func:`metadata_values_equal`. Every other key is dropped and reported back so
+    the caller can react to the loss.
+
+    A single traversal both detects conflicts and builds the merged dictionary;
+    the surviving value is the one from the first dictionary that carried the key.
+
+    Warning: Assumes that empty detections were filtered-out before passing metadata
+    to this function.
+
+    Args:
+        metadata_list: A list of metadata dictionaries to merge.
+
+    Returns:
+        A 2-tuple of the merged metadata dictionary and the set of dropped keys.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.internal import merge_metadata_lenient
+        >>> merge_metadata_lenient([{"a": 1, "b": 2}, {"a": 1, "b": 3}])
+        ({'a': 1}, {'b'})
+
+        ```
+    """
+    merged_metadata: _MetadataType = {}
+    occurrences: dict[str, int] = {}
+    conflicting: set[str] = set()
+
+    for metadata in metadata_list:
+        for key, value in metadata.items():
+            occurrences[key] = occurrences.get(key, 0) + 1
+            if key in conflicting:
+                continue
+            if key not in merged_metadata:
+                merged_metadata[key] = value
+            elif not metadata_values_equal(merged_metadata[key], value):
+                conflicting.add(key)
+
+    dropped_keys = {
+        key
+        for key, count in occurrences.items()
+        if key in conflicting or count != len(metadata_list)
+    }
+    return {
+        key: value for key, value in merged_metadata.items() if key not in dropped_keys
+    }, dropped_keys
+
+
+def get_data_item(
+    data: _DetectionDataType,
+    index: int | slice | list[int] | npt.NDArray[np.integer | np.bool_],
+) -> _DetectionDataType:
+    """
+    Retrieve a subset of the data dictionary based on the given index.
+
+    Args:
+        data: The data dictionary of the Detections object.
+        index: The index or indices specifying the subset to retrieve.
+
+    Returns:
+        A subset of the data dictionary corresponding to the specified index.
+    """
+    subset_data: _DetectionDataType = {}
+    for key, value in data.items():
+        if isinstance(value, np.ndarray):
+            subset_data[key] = value[index]
+        elif isinstance(value, list):
+            if isinstance(index, slice):
+                subset_data[key] = value[index]
+            elif isinstance(index, list):
+                subset_data[key] = [value[i] for i in index]
+            elif isinstance(index, np.ndarray):
+                if index.dtype == bool:
+                    subset_data[key] = [
+                        value[i] for i, index_value in enumerate(index) if index_value
+                    ]
+                else:
+                    subset_data[key] = [value[i] for i in index]
+            elif isinstance(index, int):
+                subset_data[key] = [value[index]]
+            else:
+                raise TypeError(f"Unsupported index type: {type(index)}")
+        else:
+            raise TypeError(f"Unsupported data type for key '{key}': {type(value)}")
+
+    return subset_data
+
+
+def cross_product(
+    anchors: npt.NDArray[np.number], vector: Vector
+) -> npt.NDArray[np.number]:
+    """Get signed z-component of cross product (2-D determinant) per anchor.
+
+    Replaces the deprecated `np.cross` 2-D path (NumPy 2.0) with an explicit
+    determinant: ``a[..., 0] * b[..., 1] - a[..., 1] * b[..., 0]``.
+
+    Args:
+        anchors: Array of anchors of shape (number of anchors, detections, 2).
+        vector: Vector to calculate cross product with.
+
+    Returns:
+        Array of signed cross-product values, shape (number of anchors,
+        detections). Positive = anchor is to the left of the vector direction;
+        negative = to the right; zero = on the line.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.geometry.core import Point, Vector
+        >>> anchors = np.array([[[10.0, 5.0]], [[20.0, 5.0]]])
+        >>> vector = Vector(start=Point(0, 0), end=Point(1, 0))
+        >>> cross_product(anchors, vector)
+        array([[5.],
+               [5.]])
+
+        ```
+    """
+    vector_at_zero = np.array(
+        [
+            vector.end.x - vector.start.x,
+            vector.end.y - vector.start.y,
+        ]
+    )
+    vector_start = np.array([vector.start.x, vector.start.y])
+    diff = anchors - vector_start
+    return cast(
+        npt.NDArray[np.number],
+        vector_at_zero[0] * diff[..., 1] - vector_at_zero[1] * diff[..., 0],
+    )
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/iou_and_nms.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/iou_and_nms.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f378e481fe36665fdcb8337ed5d03a9406c6128
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/iou_and_nms.py
@@ -0,0 +1,1851 @@
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable, Sequence
+from enum import Enum
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.utils.converters import mask_to_xyxy
+from supervision.utils.internal import warn_deprecated
+
+
+class OverlapFilter(Enum):
+    """
+    Enum specifying the strategy for filtering overlapping detections.
+
+    Attributes:
+        NONE: Do not filter detections based on overlap.
+        NON_MAX_SUPPRESSION: Filter detections using non-max suppression. This means,
+            detections that overlap by more than a set threshold will be discarded,
+            except for the one with the highest confidence.
+        NON_MAX_MERGE: Merge detections with non-max merging. This means,
+            detections that overlap by more than a set threshold will be merged
+            into a single detection.
+    """
+
+    NONE = "none"
+    NON_MAX_SUPPRESSION = "non_max_suppression"
+    NON_MAX_MERGE = "non_max_merge"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return list(map(lambda member: member.value, cls))
+
+    @classmethod
+    def from_value(cls, value: OverlapFilter | str) -> OverlapFilter:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            value = value.lower()
+            try:
+                return cls(value)
+            except ValueError:
+                raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}")
+        raise ValueError(
+            f"Invalid value type: {type(value)}. Must be an instance of "
+            f"{cls.__name__} or str."
+        )
+
+
+class OverlapMetric(Enum):
+    """
+    Enum specifying the metric for measuring overlap between detections.
+
+    Attributes:
+        IOU: Intersection over Union. A region-overlap metric that compares
+            two shapes (usually bounding boxes or masks) by normalising the
+            shared area with the area of their union.
+        IOS: Intersection over Smaller, a region-overlap metric that compares
+            two shapes (usually bounding boxes or masks) by normalising the
+            shared area with the smaller of the two shapes.
+    """
+
+    IOU = "IOU"
+    IOS = "IOS"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return list(map(lambda member: member.value, cls))
+
+    @classmethod
+    def from_value(cls, value: OverlapMetric | str) -> OverlapMetric:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            value = value.upper()
+            try:
+                return cls(value)
+            except ValueError:
+                raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}")
+        raise ValueError(
+            f"Invalid value type: {type(value)}. Must be an instance of "
+            f"{cls.__name__} or str."
+        )
+
+
+def _validate_iou_threshold(iou_threshold: float) -> None:
+    """Raise `ValueError` when an IoU threshold falls outside `[0, 1]`."""
+    if not 0 <= iou_threshold <= 1:
+        raise ValueError(
+            "Value of `iou_threshold` must be in the closed range from 0 to 1, "
+            f"{iou_threshold} given."
+        )
+
+
+def _coordinate_difference(upper: np.number, lower: np.number) -> float:
+    """Subtract box coordinates without overflowing integer NumPy scalars."""
+    return float(np.asarray(upper).item() - np.asarray(lower).item())
+
+
+def box_iou(
+    box_true: list[float] | npt.NDArray[np.number],
+    box_detection: list[float] | npt.NDArray[np.number],
+    overlap_metric: OverlapMetric | str = OverlapMetric.IOU,
+) -> float:
+    """
+    Compute overlap metric between two bounding boxes.
+
+    Supports standard IOU (intersection-over-union) and IOS
+    (intersection-over-smaller-area) metrics. Returns the overlap value in range
+    `[0, 1]`. Integer coordinates are subtracted before conversion to floating
+    point so large origins remain precise while area products avoid integer overflow.
+
+    Args:
+        box_true: Ground truth box in format
+          `(x_min, y_min, x_max, y_max)`.
+        box_detection: Detected box in format
+          `(x_min, y_min, x_max, y_max)`.
+        overlap_metric: Overlap type.
+          Use `OverlapMetric.IOU` for IOU or
+          `OverlapMetric.IOS` for IOS. Defaults to `OverlapMetric.IOU`.
+
+    Returns:
+        Overlap value between boxes in `[0, 1]`.
+
+    Raises:
+        TypeError: If either box contains complex coordinates.
+        ValueError: If `overlap_metric` is not IOU or IOS.
+
+    Examples:
+        ```pycon
+        >>> import supervision as sv
+        >>> box_true = [100, 100, 200, 200]
+        >>> box_detection = [150, 150, 250, 250]
+        >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOU)
+        0.142857...
+        >>> sv.box_iou(box_true, box_detection, overlap_metric=sv.OverlapMetric.IOS)
+        0.25
+
+        ```
+    """
+    overlap_metric = OverlapMetric.from_value(overlap_metric)
+    box_true_array = np.asarray(box_true)
+    box_detection_array = np.asarray(box_detection)
+    if np.iscomplexobj(box_true_array) or np.iscomplexobj(box_detection_array):
+        raise TypeError("box coordinates must be real-valued")
+
+    x_min_true, y_min_true, x_max_true, y_max_true = box_true_array
+    x_min_det, y_min_det, x_max_det, y_max_det = box_detection_array
+
+    x_min_inter = max(x_min_true, x_min_det)
+    y_min_inter = max(y_min_true, y_min_det)
+    x_max_inter = min(x_max_true, x_max_det)
+    y_max_inter = min(y_max_true, y_max_det)
+
+    inter_w = max(0.0, _coordinate_difference(x_max_inter, x_min_inter))
+    inter_h = max(0.0, _coordinate_difference(y_max_inter, y_min_inter))
+
+    area_inter = inter_w * inter_h
+
+    area_true = _coordinate_difference(x_max_true, x_min_true) * _coordinate_difference(
+        y_max_true, y_min_true
+    )
+    area_det = _coordinate_difference(x_max_det, x_min_det) * _coordinate_difference(
+        y_max_det, y_min_det
+    )
+
+    if overlap_metric == OverlapMetric.IOU:
+        area_norm = area_true + area_det - area_inter
+    elif overlap_metric == OverlapMetric.IOS:
+        area_norm = min(area_true, area_det)
+    else:
+        raise ValueError(
+            f"overlap_metric {overlap_metric} is not supported, "
+            "only 'IOU' and 'IOS' are supported"
+        )
+
+    if area_norm <= 0.0:
+        return 0.0
+
+    return float(area_inter / area_norm)
+
+
+def box_iou_batch(
+    boxes_true: npt.NDArray[np.number],
+    boxes_detection: npt.NDArray[np.number],
+    overlap_metric: OverlapMetric | str = OverlapMetric.IOU,
+) -> npt.NDArray[np.float32]:
+    """
+    Compute pairwise overlap scores between batches of bounding boxes.
+
+    Supports standard IOU (intersection-over-union) and IOS
+    (intersection-over-smaller-area) metrics for all `boxes_true` and
+    `boxes_detection` pairs. Returns a matrix of overlap values in range
+    `[0, 1]`, matching each box from the first batch to each from the second.
+
+    Args:
+        boxes_true: Array of reference boxes in
+            shape `(N, 4)` as `(x_min, y_min, x_max, y_max)`.
+        boxes_detection: Array of detected boxes in
+            shape `(M, 4)` as `(x_min, y_min, x_max, y_max)`.
+        overlap_metric: Overlap type.
+            Use `OverlapMetric.IOU` for intersection-over-union,
+            `OverlapMetric.IOS` for intersection-over-smaller-area.
+            Defaults to `OverlapMetric.IOU`.
+
+    Returns:
+        Overlap matrix of shape `(N, M)`, where entry
+            `[i, j]` is the overlap between `boxes_true[i]` and
+            `boxes_detection[j]`.
+
+    Raises:
+        ValueError: If `overlap_metric` is not IOU or IOS.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> boxes_true = np.array([
+        ...     [100, 100, 200, 200],
+        ...     [300, 300, 400, 400]
+        ... ])
+        >>> boxes_detection = np.array([
+        ...     [150, 150, 250, 250],
+        ...     [320, 320, 420, 420]
+        ... ])
+        >>> sv.box_iou_batch(
+        ...     boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOU
+        ... )
+        array([[0.14285..., 0.        ],
+               [0.        , 0.47058...]], dtype=float32)
+        >>> sv.box_iou_batch(
+        ...     boxes_true, boxes_detection, overlap_metric=sv.OverlapMetric.IOS
+        ... )
+        array([[0.25, 0.  ],
+               [0.  , 0.64]], dtype=float32)
+
+        ```
+    """
+    overlap_metric = OverlapMetric.from_value(overlap_metric)
+    # Upcast the corners to float64 right after unpacking so every subtraction
+    # and multiplication below runs in float64. This prevents integer-dtype
+    # overflow: an int32 box area such as 50000 * 50000 = 2.5e9 wraps to a
+    # negative value in int32 before any later cast could run, yielding wrong
+    # (often zero) IoU. Upcasting here also gives full float64 precision to
+    # float64/int64 callers. It does NOT recover precision already lost when a
+    # caller stores coordinates as float32 upstream, because that float32
+    # rounding happens before this function is ever called. The final matrix is
+    # cast back to float32 to preserve the public return-type contract.
+    x_min_true, y_min_true, x_max_true, y_max_true = boxes_true.T.astype(np.float64)
+    x_min_det, y_min_det, x_max_det, y_max_det = boxes_detection.T.astype(np.float64)
+    count_true, count_det = boxes_true.shape[0], boxes_detection.shape[0]
+
+    if count_true == 0 or count_det == 0:
+        return cast(
+            npt.NDArray[np.float32], np.empty((count_true, count_det), dtype=np.float32)
+        )
+
+    x_min_inter = np.empty((count_true, count_det), dtype=np.float64)
+    x_max_inter = np.empty_like(x_min_inter)
+    y_min_inter = np.empty_like(x_min_inter)
+    y_max_inter = np.empty_like(x_min_inter)
+
+    np.maximum(x_min_true[:, None], x_min_det[None, :], out=x_min_inter)
+    np.minimum(x_max_true[:, None], x_max_det[None, :], out=x_max_inter)
+    np.maximum(y_min_true[:, None], y_min_det[None, :], out=y_min_inter)
+    np.minimum(y_max_true[:, None], y_max_det[None, :], out=y_max_inter)
+
+    # we reuse x_max_inter and y_max_inter to store inter_w and inter_h
+    np.subtract(x_max_inter, x_min_inter, out=x_max_inter)  # inter_w
+    np.subtract(y_max_inter, y_min_inter, out=y_max_inter)  # inter_h
+    np.clip(x_max_inter, 0.0, None, out=x_max_inter)
+    np.clip(y_max_inter, 0.0, None, out=y_max_inter)
+
+    area_inter = x_max_inter * y_max_inter  # inter_w * inter_h
+
+    area_true = (x_max_true - x_min_true) * (y_max_true - y_min_true)
+    area_det = (x_max_det - x_min_det) * (y_max_det - y_min_det)
+
+    if overlap_metric == OverlapMetric.IOU:
+        area_norm = area_true[:, None] + area_det[None, :] - area_inter
+    elif overlap_metric == OverlapMetric.IOS:
+        area_norm = np.minimum(area_true[:, None], area_det[None, :])
+    else:
+        raise ValueError(
+            f"overlap_metric {overlap_metric} is not supported, "
+            "only 'IOU' and 'IOS' are supported"
+        )
+
+    out: npt.NDArray[np.float32] = np.zeros_like(area_inter, dtype=np.float32)
+    np.divide(area_inter, area_norm, out=out, where=area_norm > 0)
+    return out
+
+
+def box_iou_batch_with_jaccard(
+    boxes_true: Sequence[Sequence[float]],
+    boxes_detection: Sequence[Sequence[float]],
+    is_crowd: Sequence[bool],
+) -> npt.NDArray[np.float64]:
+    """
+    Calculate the intersection over union (IoU) between detection bounding boxes (dt)
+    and ground-truth bounding boxes (gt).
+    Reference: https://github.com/rafaelpadilla/review_object_detection_metrics
+
+    Args:
+        boxes_true: Sequence of ground-truth bounding boxes in the
+            format [x, y, width, height].
+        boxes_detection: Sequence of detection bounding boxes in the
+            format [x, y, width, height].
+        is_crowd: Sequence indicating if each ground-truth bounding box
+            is a crowd region or not.
+
+    Note:
+        This function expects bounding boxes in ``[x, y, width, height]`` format
+        (COCO convention). All other batch IoU functions in this module use
+        ``[x_min, y_min, x_max, y_max]``.
+
+        NaN coordinates propagate silently: if any box value is ``NaN``, the
+        corresponding IoU values will be ``NaN``.
+
+    Returns:
+        Array of IoU values of shape ``(len(boxes_detection), len(boxes_true))``,
+        where row ``i`` contains the IoU of detection ``i`` against all ground-truth
+        boxes, and column ``j`` contains the IoU of all detections against ground-truth
+        box ``j``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> boxes_true = [
+        ...     [10, 20, 30, 40],  # x, y, w, h
+        ...     [15, 25, 35, 45]
+        ... ]
+        >>> boxes_detection = [
+        ...     [12, 22, 28, 38],
+        ...     [16, 26, 36, 46]
+        ... ]
+        >>> is_crowd = [False, False]
+        >>> ious = sv.box_iou_batch_with_jaccard(
+        ...     boxes_true=boxes_true,
+        ...     boxes_detection=boxes_detection,
+        ...     is_crowd=is_crowd
+        ... )
+        >>> ious  # doctest: +ELLIPSIS
+        array([[0.886..., 0.496...],
+               [0.4  ..., 0.862...]])
+
+        ```
+    """
+    if len(is_crowd) != len(boxes_true):
+        raise ValueError(
+            f"`is_crowd` length ({len(is_crowd)}) must match "
+            f"`boxes_true` length ({len(boxes_true)})."
+        )
+    if len(boxes_detection) == 0 or len(boxes_true) == 0:
+        return np.empty((len(boxes_detection), len(boxes_true)), dtype=np.float64)
+
+    # Smallest number to avoid division by zero.
+    eps = np.spacing(1)
+    gt = np.asarray(boxes_true, dtype=np.float64)
+    dt = np.asarray(boxes_detection, dtype=np.float64)
+    crowd = np.asarray(is_crowd, dtype=bool)
+
+    # Boxes are [x, y, w, h]. Build the far corners as `x2 = x + w` (rather than
+    # reusing `w`) so that the area/intersection arithmetic is bit-identical to
+    # the per-pair reference it replaces.
+    gt_x2, gt_y2 = gt[:, 0] + gt[:, 2], gt[:, 1] + gt[:, 3]
+    dt_x2, dt_y2 = dt[:, 0] + dt[:, 2], dt[:, 1] + dt[:, 3]
+
+    # Pairwise intersection: rows index detections, columns index ground truth.
+    inter_x1 = np.maximum(dt[:, 0][:, None], gt[:, 0][None, :])
+    inter_y1 = np.maximum(dt[:, 1][:, None], gt[:, 1][None, :])
+    inter_x2 = np.minimum(dt_x2[:, None], gt_x2[None, :])
+    inter_y2 = np.minimum(dt_y2[:, None], gt_y2[None, :])
+    area_inter = np.maximum(inter_x2 - inter_x1, 0.0) * np.maximum(
+        inter_y2 - inter_y1, 0.0
+    )
+
+    area_det = np.maximum(dt_x2 - dt[:, 0], 0.0) * np.maximum(dt_y2 - dt[:, 1], 0.0)
+    area_gt = np.maximum(gt_x2 - gt[:, 0], 0.0) * np.maximum(gt_y2 - gt[:, 1], 0.0)
+
+    # For a crowd ground truth a detection may match any subregion, so its union
+    # collapses to the detection area; otherwise use the standard box union.
+    iou: npt.NDArray[np.float64] = np.empty((len(dt), len(gt)), dtype=np.float64)
+    if not np.any(crowd):
+        area_norm = area_det[:, None] + area_gt[None, :] - area_inter + eps
+    else:
+        area_norm = np.where(
+            crowd[None, :],
+            area_det[:, None] + eps,
+            area_det[:, None] + area_gt[None, :] - area_inter + eps,
+        )
+    np.divide(area_inter, area_norm, out=iou)
+    return iou
+
+
+def _polygon_areas(polygons: npt.NDArray[np.number]) -> npt.NDArray[np.float64]:
+    """Compute the area of each oriented-box polygon using the shoelace formula.
+
+    Each polygon is translated to its own first corner before the shoelace
+    products, keeping representable integer coordinates with large origins (e.g.
+    geospatial frames) local before conversion to float64. Float inputs that
+    were already quantized retain their input precision.
+
+    Args:
+        polygons: ``(N, 4, 2)`` array of polygon corners.
+
+    Returns:
+        ``(N,)`` array of polygon areas.
+    """
+    origin = polygons[:, 0:1, :]
+    if np.issubdtype(polygons.dtype, np.integer):
+        translated = np.asarray(
+            polygons.astype(object) - origin.astype(object), dtype=np.float64
+        )
+    else:
+        polygons_float = polygons.astype(np.float64, copy=False)
+        translated = polygons_float - origin.astype(np.float64, copy=False)
+    x = translated[:, :, 0]
+    y = translated[:, :, 1]
+    cross = x * np.roll(y, -1, axis=1) - np.roll(x, -1, axis=1) * y
+    return cast(npt.NDArray[np.float64], 0.5 * np.abs(cross.sum(axis=1)))
+
+
+def _aabb_envelopes(polygons: npt.NDArray[np.number]) -> npt.NDArray[np.number]:
+    """Compute the axis-aligned bounding envelope of each oriented box.
+
+    Args:
+        polygons: ``(N, 4, 2)`` array of polygon corners.
+
+    Returns:
+        ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)`` envelopes.
+    """
+    xs = polygons[:, :, 0]
+    ys = polygons[:, :, 1]
+    return np.stack(
+        [xs.min(axis=1), ys.min(axis=1), xs.max(axis=1), ys.max(axis=1)], axis=1
+    )
+
+
+def _overlapping_envelope_pairs(
+    envelopes_true: npt.NDArray[np.number],
+    envelopes_detection: npt.NDArray[np.number],
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]:
+    """Return index pairs ``(i, j)`` whose axis-aligned envelopes overlap.
+
+    Uses a fused boolean evaluation to halve peak transient memory compared to
+    named-intermediate form (4 separate NxM float64 arrays vs 1 boolean array).
+
+    Note:
+        This gate is a correctness guarantee, not an approximation: if two
+        axis-aligned bounding boxes do not overlap, the convex polygons they
+        contain cannot overlap either.
+
+    Args:
+        envelopes_true: ``(N, 4)`` array of ``(x_min, y_min, x_max, y_max)``
+            envelopes for the ground-truth boxes.
+        envelopes_detection: ``(M, 4)`` array of ``(x_min, y_min, x_max, y_max)``
+            envelopes for the detection boxes.
+
+    Returns:
+        A pair of 1-D index arrays ``(rows, cols)`` identifying the overlapping
+        pairs.
+    """
+    et = envelopes_true[:, None, :]
+    ed = envelopes_detection[None, :, :]
+    overlap = (
+        np.minimum(et[..., 2], ed[..., 2]) > np.maximum(et[..., 0], ed[..., 0])
+    ) & (np.minimum(et[..., 3], ed[..., 3]) > np.maximum(et[..., 1], ed[..., 1]))
+    return cast(tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]], np.nonzero(overlap))
+
+
+def oriented_box_iou_batch(
+    boxes_true: npt.NDArray[np.number],
+    boxes_detection: npt.NDArray[np.number],
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.floating]:
+    """
+    Compute pairwise overlap scores between two sets of oriented bounding boxes
+    using the configured `overlap_metric`.
+
+    Overlap areas are computed exactly via convex-polygon intersection, gated by
+    a cheap axis-aligned envelope pre-filter — no rasterization is involved, so
+    the result is exact (free of pixel-quantization error) and independent of the
+    coordinate magnitudes.
+
+    `boxes_true` and `boxes_detection` are expected to be in
+    `((x1, y1), (x2, y2), (x3, y3), (x4, y4))` format.
+
+    Note:
+        Inputs must be **convex** quads with finite coordinates. Self-intersecting
+        or non-convex polygons produce undefined results via
+        ``cv2.intersectConvexConvex``. NaN or Inf coordinates propagate silently
+        as ``0.0`` — validate inputs before calling if needed.
+
+        When ``boxes_true is boxes_detection`` (the same Python object, not just
+        equal values), the function computes only the upper triangle of the
+        matrix and mirrors it. This optimization is used automatically by the
+        NMS/NMM callers that pass the same array twice. A defensive ``.copy()``
+        at the call site would disable the optimization silently — see the
+        NMS caller comment for context.
+
+    Args:
+        boxes_true: A `np.ndarray` representing ground-truth boxes.
+            `shape = (N, 4, 2)` where `N` is number of true objects.
+            Last axis convention: `[..., 0]` = x-coordinates,
+            `[..., 1]` = y-coordinates.
+        boxes_detection: A `np.ndarray` representing detection boxes.
+            `shape = (M, 4, 2)` where `M` is number of detected objects.
+            Last axis convention: `[..., 0]` = x-coordinates,
+            `[..., 1]` = y-coordinates.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of oriented boxes (e.g., IoU, IoS).
+
+    Returns:
+        Overlap matrix of shape `(N, M)`, where entry `[i, j]` is the overlap
+        score between `boxes_true[i]` and `boxes_detection[j]`, in the range
+        `[0, 1]` under the configured :attr:`overlap_metric`.
+
+    Raises:
+        ValueError: If ``boxes_true`` or ``boxes_detection`` is 3-D with inner
+            dimensions other than ``(4, 2)``.
+        ValueError: If ``boxes_true`` or ``boxes_detection`` is 2-D with a
+            column count other than 8.
+        ValueError: If ``boxes_true`` or ``boxes_detection`` is not 2-D or 3-D.
+        ValueError: If ``overlap_metric`` is not
+            :attr:`~supervision.config.OverlapMetric.IOU` or
+            :attr:`~supervision.config.OverlapMetric.IOS`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> a = np.array([[[0, 0], [2, 0], [2, 2], [0, 2]]], dtype=np.float32)
+        >>> b = np.array([[[1, 0], [3, 0], [3, 2], [1, 2]]], dtype=np.float32)
+        >>> sv.oriented_box_iou_batch(a, b)  # doctest: +ELLIPSIS
+        array([[0.333...]])
+
+        ```
+    """
+
+    for name, arr in (("boxes_true", boxes_true), ("boxes_detection", boxes_detection)):
+        if arr.ndim == 3 and arr.shape[1:] != (4, 2):
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 4, 2) "
+                f"— each box must have exactly 4 corners with (x, y) coordinates."
+            )
+        elif arr.ndim == 2 and arr.shape[1] != 8:
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 8) for flat "
+                f"YOLO format or (N, 4, 2) for corner format."
+            )
+        elif arr.ndim not in (2, 3):
+            raise ValueError(
+                f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}."
+            )
+
+    if overlap_metric == OverlapMetric.IOU:
+        normalize_by_union = True
+    elif overlap_metric == OverlapMetric.IOS:
+        normalize_by_union = False
+    else:
+        raise ValueError(
+            f"overlap_metric {overlap_metric} is not supported, "
+            "only 'IOU' and 'IOS' are supported"
+        )
+
+    # Capture identity before reshape: NMS / NMM pass the same array twice, so
+    # the matrix is symmetric and we can compute only its upper triangle.
+    is_self_comparison = boxes_true is boxes_detection
+    boxes_true = boxes_true.reshape(-1, 4, 2)
+    boxes_detection = boxes_detection.reshape(-1, 4, 2)
+
+    n, m = len(boxes_true), len(boxes_detection)
+    if n == 0 or m == 0:
+        return np.zeros((n, m), dtype=np.float64)
+
+    areas_true = _polygon_areas(boxes_true)
+    areas_detection = _polygon_areas(boxes_detection)
+
+    envelopes_true = _aabb_envelopes(boxes_true)
+    envelopes_detection = (
+        envelopes_true if is_self_comparison else _aabb_envelopes(boxes_detection)
+    )
+    rows, cols = _overlapping_envelope_pairs(envelopes_true, envelopes_detection)
+    if is_self_comparison:
+        upper = rows <= cols
+        rows, cols = rows[upper], cols[upper]
+
+    ious: npt.NDArray[np.float64] = np.zeros((n, m), dtype=np.float64)
+    local_origins_true = envelopes_true[:, :2]
+    local_origins_detection = envelopes_detection[:, :2]
+    if np.issubdtype(boxes_true.dtype, np.integer):
+        local_polygons_true = np.asarray(
+            boxes_true.astype(object) - local_origins_true[:, None, :].astype(object),
+            dtype=np.float32,
+        )
+    else:
+        local_polygons_true = (boxes_true - local_origins_true[:, None, :]).astype(
+            np.float32
+        )
+    if np.issubdtype(boxes_detection.dtype, np.integer):
+        local_polygons_detection = np.asarray(
+            boxes_detection.astype(object)
+            - local_origins_detection[:, None, :].astype(object),
+            dtype=np.float32,
+        )
+    else:
+        local_polygons_detection = (
+            boxes_detection - local_origins_detection[:, None, :]
+        ).astype(np.float32)
+    # Float32 inputs already have quantized origins, so their envelope minima
+    # can be reused without loss. Float64 inputs may retain unit differences at
+    # large origins; keep their pair offsets in float64 until each pair's local
+    # cast instead of rounding absolute minima to float32 up front.
+    origins_true_float32 = (
+        local_origins_true if boxes_true.dtype == np.float32 else None
+    )
+    origins_detection_float32 = (
+        local_origins_detection if boxes_detection.dtype == np.float32 else None
+    )
+    polygon_i_buffer = np.empty((4, 2), dtype=np.float32)
+    polygon_j_buffer = np.empty((4, 2), dtype=np.float32)
+    for i, j in zip(rows, cols):
+        # Rebase precomputed local polygons to the shared overlap origin. This
+        # preserves translation-invariant float32 geometry without repeating
+        # corner reductions and casts for every candidate pair.
+        if origins_true_float32 is not None and origins_detection_float32 is not None:
+            origin_i = origins_true_float32[i]
+            origin_j = origins_detection_float32[j]
+        else:
+            origin_i = local_origins_true[i]
+            origin_j = local_origins_detection[j]
+        pair_origin = np.minimum(origin_i, origin_j)
+        offset_i = (origin_i - pair_origin).astype(np.float32, copy=False)
+        offset_j = (origin_j - pair_origin).astype(np.float32, copy=False)
+        np.add(local_polygons_true[i], offset_i, out=polygon_i_buffer)
+        np.add(local_polygons_detection[j], offset_j, out=polygon_j_buffer)
+        intersection, _ = cv2.intersectConvexConvex(polygon_i_buffer, polygon_j_buffer)
+        if intersection <= 0:
+            continue
+        denominator = (
+            areas_true[i] + areas_detection[j] - intersection
+            if normalize_by_union
+            else min(areas_true[i], areas_detection[j])
+        )
+        if denominator > 0:
+            score = intersection / denominator
+            ious[i, j] = score
+            if is_self_comparison:
+                ious[j, i] = score
+
+    # DO NOT remove this clip. cv2.intersectConvexConvex computes in float32
+    # internally while polygon areas are computed in float64; the intersection
+    # area can exceed the float64 area by ~25 ULP (~1e-7), producing raw IoU
+    # or IoS values microscopically above 1.0 for identical boxes. The clip is
+    # load-bearing, not defensive duplication.
+    return cast(npt.NDArray[np.floating], np.clip(ious, 0.0, 1.0))
+
+
+def compact_mask_iou_batch(
+    masks_true: Any,
+    masks_detection: Any,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.floating]:
+    """Compute pairwise overlap between two :class:`CompactMask` collections.
+
+    Avoids materialising full ``(N, H, W)`` arrays by:
+
+    1. Vectorised bounding-box pre-filter — pairs whose boxes do not overlap
+       get IoU = 0 without any mask decoding.
+    2. Sub-crop decoding — for overlapping pairs, only the intersection region
+       of each crop is decoded and compared.
+    3. Crop caching — each individual crop is decoded at most once even when it
+       participates in many pairs.
+
+    The result is numerically identical to running the dense
+    :func:`mask_iou_batch` on ``np.asarray(masks_true)`` /
+    ``np.asarray(masks_detection)``.
+
+    Args:
+        masks_true: :class:`~supervision.detection.compact_mask.CompactMask`
+            holding the ground-truth masks.
+        masks_detection: :class:`~supervision.detection.compact_mask.CompactMask`
+            holding the detection masks.
+        overlap_metric: :class:`OverlapMetric` — ``IOU`` or ``IOS``.
+
+    Returns:
+        Float array of shape ``(N1, N2)`` with pairwise overlap values.
+    """
+    n1: int = len(masks_true)
+    n2: int = len(masks_detection)
+    result: npt.NDArray[np.floating] = np.zeros((n1, n2), dtype=float)
+
+    if n1 == 0 or n2 == 0:
+        return result
+
+    areas_a: npt.NDArray[np.int64] = masks_true.area
+    areas_b: npt.NDArray[np.int64] = masks_detection.area
+
+    # Inclusive per-mask bounding boxes obtained from public accessors.
+    # bbox_xyxy: (N, 4) → (x1, y1, x2, y2)
+    bboxes_a: npt.NDArray[np.int32] = masks_true.bbox_xyxy.astype(np.int32)
+    x1a: npt.NDArray[np.int32] = bboxes_a[:, 0]
+    y1a: npt.NDArray[np.int32] = bboxes_a[:, 1]
+    x2a: npt.NDArray[np.int32] = bboxes_a[:, 2]
+    y2a: npt.NDArray[np.int32] = bboxes_a[:, 3]
+
+    bboxes_b: npt.NDArray[np.int32] = masks_detection.bbox_xyxy.astype(np.int32)
+    x1b: npt.NDArray[np.int32] = bboxes_b[:, 0]
+    y1b: npt.NDArray[np.int32] = bboxes_b[:, 1]
+    x2b: npt.NDArray[np.int32] = bboxes_b[:, 2]
+    y2b: npt.NDArray[np.int32] = bboxes_b[:, 3]
+
+    # Pairwise intersection bounding box — shape (N1, N2).
+    ix1: npt.NDArray[np.int32] = np.maximum(x1a[:, None], x1b[None, :])
+    iy1: npt.NDArray[np.int32] = np.maximum(y1a[:, None], y1b[None, :])
+    ix2: npt.NDArray[np.int32] = np.minimum(x2a[:, None], x2b[None, :])
+    iy2: npt.NDArray[np.int32] = np.minimum(y2a[:, None], y2b[None, :])
+    bbox_overlap: npt.NDArray[np.bool_] = (ix1 <= ix2) & (iy1 <= iy2)
+
+    # Decode each crop at most once, even if it participates in many pairs.
+    crops_a: dict[int, npt.NDArray[np.bool_]] = {}
+    crops_b: dict[int, npt.NDArray[np.bool_]] = {}
+
+    for idx_pair in np.argwhere(bbox_overlap):
+        idx_a, idx_b = int(idx_pair[0]), int(idx_pair[1])
+
+        if idx_a not in crops_a:
+            crops_a[idx_a] = masks_true.crop(idx_a)
+        if idx_b not in crops_b:
+            crops_b[idx_b] = masks_detection.crop(idx_b)
+
+        lx1 = int(ix1[idx_a, idx_b])
+        ly1 = int(iy1[idx_a, idx_b])
+        lx2 = int(ix2[idx_a, idx_b])
+        ly2 = int(iy2[idx_a, idx_b])
+
+        ox_a, oy_a = int(x1a[idx_a]), int(y1a[idx_a])
+        sub_a = crops_a[idx_a][ly1 - oy_a : ly2 - oy_a + 1, lx1 - ox_a : lx2 - ox_a + 1]
+
+        ox_b, oy_b = int(x1b[idx_b]), int(y1b[idx_b])
+        sub_b = crops_b[idx_b][ly1 - oy_b : ly2 - oy_b + 1, lx1 - ox_b : lx2 - ox_b + 1]
+
+        inter = int(np.logical_and(sub_a, sub_b).sum())
+        area_a_i = int(areas_a[idx_a])
+        area_b_j = int(areas_b[idx_b])
+
+        if overlap_metric == OverlapMetric.IOU:
+            union = area_a_i + area_b_j - inter
+            result[idx_a, idx_b] = inter / union if union > 0 else 0.0
+        elif overlap_metric == OverlapMetric.IOS:
+            small = min(area_a_i, area_b_j)
+            result[idx_a, idx_b] = inter / small if small > 0 else 0.0
+        else:
+            raise ValueError(
+                f"overlap_metric {overlap_metric} is not supported, "
+                "only 'IOU' and 'IOS' are supported"
+            )
+
+    return result
+
+
+def _mask_iou_batch_split(
+    masks_true: npt.NDArray[Any],
+    masks_detection: npt.NDArray[Any],
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.floating]:
+    """
+    Internal function.
+    Compute Intersection over Union (IoU) of two sets of masks -
+        `masks_true` and `masks_detection`.
+
+    Args:
+        masks_true: 3D `np.ndarray` representing ground-truth masks.
+        masks_detection: 3D `np.ndarray` representing detection masks.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+
+    Returns:
+        Pairwise IoU of masks from `masks_true` and `masks_detection`.
+    """
+    # The overlap of two binary masks is the dot product of their flattened
+    # pixels, so the whole (N, M) intersection matrix is a single matmul.
+    # float32 counts pixels exactly up to 2**24; for larger masks (beyond
+    # ~4096x4096) we promote to float64 so the counts stay exact.
+    pixels = int(np.prod(masks_true.shape[1:]))
+    count_dtype = np.float32 if pixels <= 2**24 else np.float64
+    true_flat = cast(
+        npt.NDArray[np.floating],
+        masks_true.reshape(masks_true.shape[0], pixels).astype(count_dtype, copy=False),
+    )
+    detection_flat = cast(
+        npt.NDArray[np.floating],
+        masks_detection.reshape(masks_detection.shape[0], pixels).astype(
+            count_dtype, copy=False
+        ),
+    )
+    with np.errstate(divide="ignore", over="ignore", invalid="ignore"):
+        intersection_area: npt.NDArray[np.floating[Any]] = true_flat @ detection_flat.T
+
+    masks_true_area = true_flat.sum(axis=1)
+    masks_detection_area = detection_flat.sum(axis=1)
+
+    if overlap_metric == OverlapMetric.IOU:
+        union_area = masks_true_area[:, None] + masks_detection_area - intersection_area
+        ious = np.divide(
+            intersection_area,
+            union_area,
+            out=np.zeros_like(intersection_area, dtype=float),
+            where=union_area != 0,
+        )
+    elif overlap_metric == OverlapMetric.IOS:
+        # ios = intersection_area / min(area1, area2)
+        small_area = np.minimum(masks_true_area[:, None], masks_detection_area)
+        ious = np.divide(
+            intersection_area,
+            small_area,
+            out=np.zeros_like(intersection_area, dtype=float),
+            where=small_area != 0,
+        )
+    else:
+        raise ValueError(
+            f"overlap_metric {overlap_metric} is not supported, "
+            "only 'IOU' and 'IOS' are supported"
+        )
+
+    ious = np.nan_to_num(ious)
+    return cast(npt.NDArray[np.floating], ious)
+
+
+def mask_iou_batch(
+    masks_true: npt.NDArray[Any] | CompactMask,
+    masks_detection: npt.NDArray[Any] | CompactMask,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    memory_limit: int = 1024 * 5,
+) -> npt.NDArray[np.floating]:
+    """
+    Compute Intersection over Union (IoU) of two sets of masks -
+        `masks_true` and `masks_detection`.
+
+    Accepts both dense ``(N, H, W)`` boolean arrays and
+    :class:`~supervision.detection.compact_mask.CompactMask` objects.
+    When both inputs are :class:`~supervision.detection.compact_mask.CompactMask`,
+    the computation uses :func:`compact_mask_iou_batch` to avoid materialising
+    full ``(N, H, W)`` arrays.
+
+    Args:
+        masks_true: 3D `np.ndarray` representing ground-truth masks.
+        masks_detection: 3D `np.ndarray` representing detection masks.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+        memory_limit: Memory limit in MB, default is 1024 * 5 MB (5GB).
+            Controls chunking of ``masks_true`` so that flattened detection
+            masks plus each chunk's buffers stay within this limit. A
+            ``UserWarning`` is raised when ``masks_detection`` alone
+            exceeds the limit, as chunking cannot reduce peak memory
+            below that floor. Ignored when both inputs are
+            :class:`~supervision.detection.compact_mask.CompactMask`.
+
+    Returns:
+        Pairwise IoU of masks from `masks_true` and `masks_detection`.
+
+    Raises:
+        ValueError: If ``masks_true`` or ``masks_detection`` are not 3D
+            ``(N, H, W)`` arrays, or if they do not share the same
+            spatial dimensions ``(H, W)``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> masks_true = np.zeros((1, 4, 4), dtype=bool)
+        >>> masks_true[:, :2, :2] = True
+        >>> masks_detection = np.zeros((1, 4, 4), dtype=bool)
+        >>> masks_detection[:, :3, :3] = True
+        >>> sv.mask_iou_batch(masks_true, masks_detection)
+        array([[0.44444445]])
+
+        ```
+    """
+
+    if isinstance(masks_true, CompactMask) and isinstance(masks_detection, CompactMask):
+        return compact_mask_iou_batch(masks_true, masks_detection, overlap_metric)
+
+    # Materialise any CompactMask that was passed alongside a dense array.
+    if isinstance(masks_true, CompactMask):
+        masks_true = np.asarray(masks_true)
+    if isinstance(masks_detection, CompactMask):
+        masks_detection = np.asarray(masks_detection)
+
+    if masks_true.ndim != 3 or masks_detection.ndim != 3:
+        raise ValueError(
+            "masks_true and masks_detection must be 3D (N, H, W); got "
+            f"ndim={masks_true.ndim} and ndim={masks_detection.ndim}."
+        )
+    if masks_true.shape[1:] != masks_detection.shape[1:]:
+        raise ValueError(
+            "masks_true and masks_detection must share the same (H, W); got "
+            f"{masks_true.shape[1:]} and {masks_detection.shape[1:]}."
+        )
+    # A single pass already handles empty inputs and avoids np.vstack([]) below.
+    if masks_true.shape[0] == 0 or masks_detection.shape[0] == 0:
+        return _mask_iou_batch_split(masks_true, masks_detection, overlap_metric)
+
+    # Peak memory of a single matmul pass: the flattened detection masks (shared
+    # across chunks) plus, per true-mask row, its flattened pixels and the three
+    # (N, M) matrices it touches (intersection, denominator and output). The
+    # previous (N, M, H, W) estimate overcounted by a factor of M and forced
+    # needless chunking now that the intersection is a matmul.
+    pixels = masks_true.shape[1] * masks_true.shape[2]
+    itemsize = 4 if pixels <= 2**24 else 8
+    limit_bytes = memory_limit * 1024 * 1024
+    detection_bytes = masks_detection.shape[0] * pixels * itemsize
+    per_true_row = pixels * itemsize + 3 * masks_detection.shape[0] * 8
+    if detection_bytes > limit_bytes > 0:
+        warnings.warn(
+            f"detection masks ({detection_bytes // 1024 // 1024} MB) exceed "
+            f"memory_limit ({memory_limit} MB); chunking cannot reduce peak "
+            "memory below this floor.",
+            UserWarning,
+            stacklevel=2,
+        )
+    if detection_bytes + masks_true.shape[0] * per_true_row <= limit_bytes:
+        return _mask_iou_batch_split(masks_true, masks_detection, overlap_metric)
+
+    ious = []
+    step = max((limit_bytes - detection_bytes) // per_true_row, 1)
+    for chunk_start in range(0, masks_true.shape[0], step):
+        ious.append(
+            _mask_iou_batch_split(
+                masks_true[chunk_start : chunk_start + step],
+                masks_detection,
+                overlap_metric,
+            )
+        )
+
+    return cast(npt.NDArray[np.floating], np.vstack(ious))
+
+
+def mask_non_max_suppression(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[Any] | CompactMask,
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    mask_dimension: int = 640,
+) -> npt.NDArray[np.bool_]:
+    """
+    Perform Non-Maximum Suppression (NMS) on segmentation predictions.
+
+    IoU is computed exactly on the full-resolution masks for both dense and
+    :class:`~supervision.detection.compact_mask.CompactMask` inputs.  The
+    ``mask_dimension`` parameter is kept for backward compatibility but is no
+    longer used — dense masks are **not** resized before IoU computation.
+
+    Args:
+        predictions: A 2D array of object detection predictions in
+            the format of `(x_min, y_min, x_max, y_max, score)`
+            or `(x_min, y_min, x_max, y_max, score, class)`. Shape: `(N, 5)` or
+            `(N, 6)`, where N is the number of predictions.
+        masks: A 3D array of binary masks corresponding to the predictions.
+            Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the
+            dimensions of each mask.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum suppression.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+        mask_dimension: Deprecated, no longer used. Kept for backward
+            compatibility.
+
+    Returns:
+        A boolean array indicating which predictions to keep after
+            non-maximum suppression.
+
+    Raises:
+        ValueError: If `iou_threshold` is not within the closed range
+            from `0` to `1`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> masks = np.zeros((2, 4, 4), dtype=bool)
+        >>> masks[:, :2, :2] = True
+        >>> sv.mask_non_max_suppression(predictions, masks, iou_threshold=0.5)
+        array([ True, False])
+
+        ```
+    """
+    _validate_iou_threshold(iou_threshold)
+    rows, columns = predictions.shape
+
+    if columns == 5:
+        predictions = np.c_[predictions, np.zeros(rows)]
+
+    sort_index = predictions[:, 4].argsort()[::-1]
+    predictions = predictions[sort_index]
+    masks = masks[sort_index]
+
+    ious = mask_iou_batch(masks, masks, overlap_metric)
+    categories = predictions[:, 5]
+
+    keep = np.ones(rows, dtype=bool)
+    for row_idx in range(rows):
+        if keep[row_idx]:
+            condition = (ious[row_idx] > iou_threshold) & (
+                categories[row_idx] == categories
+            )
+            keep[row_idx + 1 :] = np.where(
+                condition[row_idx + 1 :], False, keep[row_idx + 1 :]
+            )
+
+    return cast(npt.NDArray[np.bool_], keep[sort_index.argsort()])
+
+
+def mask_soft_non_max_suppression(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[Any] | CompactMask,
+    sigma: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    mask_dimension: int = 640,
+) -> npt.NDArray[np.floating]:
+    """
+    Perform Soft Non-Maximum Suppression (Soft-NMS) on segmentation predictions.
+
+    Unlike `mask_non_max_suppression`, which discards overlapping masks outright,
+    Soft-NMS keeps every detection and instead rescales its confidence by
+    `score *= exp(-iou**2 / sigma)` for each higher-scoring, same-category
+    overlap — the caller decides whether and where to threshold the result.
+    A smaller `sigma` produces a stronger decay.
+
+    The 3rd positional parameter here is `sigma`, not `iou_threshold` as in
+    `mask_non_max_suppression` — Soft-NMS has no threshold to suppress at, only
+    a decay strength, so the two signatures intentionally diverge at that
+    position.
+
+    IoU is computed exactly on the full-resolution masks for both dense and
+    :class:`~supervision.detection.compact_mask.CompactMask` inputs. The
+    `mask_dimension` parameter is kept for signature parity with
+    `mask_non_max_suppression` but is not used — dense masks are **not** resized
+    before IoU computation.
+
+    Args:
+        predictions: A 2D array of object detection predictions in
+            the format of `(x_min, y_min, x_max, y_max, score)`
+            or `(x_min, y_min, x_max, y_max, score, class)`. Shape: `(N, 5)` or
+            `(N, 6)`, where N is the number of predictions.
+        masks: A 3D array of binary masks corresponding to the predictions.
+            Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the
+            dimensions of each mask.
+        sigma: Controls the strength of the confidence decay; must be greater
+            than `0`. No value of `sigma` reproduces hard
+            `mask_non_max_suppression` output — Soft-NMS never drops masks, only
+            rescales confidence.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+        mask_dimension: Deprecated, unused. Kept for signature parity with
+            `mask_non_max_suppression`.
+
+    Returns:
+        An array containing the updated (decayed) confidence scores, in the
+            same order as the input `predictions`.
+
+    Raises:
+        ValueError: If `sigma` is not greater than `0`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> masks = np.zeros((2, 4, 4), dtype=bool)
+        >>> masks[:, :2, :2] = True
+        >>> sv.mask_soft_non_max_suppression(predictions, masks, sigma=0.5)
+        array([0.9       , 0.10826823])
+
+        ```
+    """
+    _validate_sigma(sigma)
+    rows, columns = predictions.shape
+
+    if columns == 5:
+        predictions = np.c_[predictions, np.zeros(rows)]
+
+    sort_index = predictions[:, 4].argsort()[::-1]
+    predictions = predictions[sort_index]
+    masks = masks[sort_index]
+
+    ious = mask_iou_batch(masks, masks, overlap_metric)
+    categories = predictions[:, 5]
+
+    decayed = _soft_nms_decay_from_iou_matrix(
+        ious, categories, predictions[:, 4], sigma
+    )
+    return decayed[sort_index.argsort()]
+
+
+def _prepare_predictions_for_nms(
+    predictions: npt.NDArray[np.floating],
+) -> tuple[npt.NDArray[np.int_], npt.NDArray[np.floating], npt.NDArray[np.floating]]:
+    """Add an agnostic class column when missing, sort by descending score.
+
+    Returns the score-descending sort index, the reordered predictions, and the
+    category vector for the loop callers to consume.
+    """
+    rows, columns = predictions.shape
+    if columns == 5:
+        predictions = np.c_[predictions, np.zeros(rows)]
+    sort_index = np.flip(predictions[:, 4].argsort())
+    predictions = predictions[sort_index]
+    categories = predictions[:, 5]
+    return sort_index, predictions, categories
+
+
+def _nms_loop_from_iou_matrix(
+    ious: npt.NDArray[np.floating],
+    categories: npt.NDArray[np.floating],
+    iou_threshold: float,
+) -> npt.NDArray[np.bool_]:
+    """Greedy NMS suppression loop given a precomputed pairwise IoU matrix.
+
+    Assumes `ious` is square with row/column order matching `categories`.
+    Detections sharing a category whose IoU exceeds `iou_threshold` are dropped
+    in favour of the higher-confidence entry.
+    """
+    rows = len(ious)
+    ious = ious - np.eye(rows)
+    keep: npt.NDArray[np.bool_] = np.ones(rows, dtype=bool)
+    for index, (iou, category) in enumerate(zip(ious, categories)):
+        if not keep[index]:
+            continue
+        condition = (iou > iou_threshold) & (categories == category)
+        keep = keep & ~condition
+    return keep
+
+
+def _validate_sigma(sigma: float) -> None:
+    """Raise `ValueError` when a Soft-NMS `sigma` is not strictly positive."""
+    if not sigma > 0:
+        raise ValueError(f"Value of `sigma` must be greater than 0, {sigma} given.")
+
+
+def _soft_nms_decay_from_iou_matrix(
+    ious: npt.NDArray[np.floating],
+    categories: npt.NDArray[np.floating],
+    scores: npt.NDArray[np.floating],
+    sigma: float,
+) -> npt.NDArray[np.floating]:
+    """Vectorized Gaussian Soft-NMS confidence decay given a precomputed IoU matrix.
+
+    Assumes `ious`, `categories`, and `scores` are all sorted by descending score
+    (as produced by `_prepare_predictions_for_nms`), and that `ious` is square with
+    row/column order matching `categories`. Each detection's score is decayed once
+    per higher-scoring, same-category detection that precedes it — equivalent to
+    the reference single-pass (no re-sort) Soft-NMS loop, computed as a single
+    vectorized closed form: `decayed[j] = scores[j] * exp(-sum_i(ious[i, j]**2) /
+    sigma)` summed over same-category `i < j`.
+    """
+    rows = len(ious)
+    same_category = categories[:, None] == categories[None, :]
+    precedes = np.triu(np.ones((rows, rows), dtype=bool), k=1)
+    weighted_iou_sq = np.where(precedes & same_category, ious**2, 0.0)
+    decay_exponent = weighted_iou_sq.sum(axis=0)
+    return cast(npt.NDArray[np.floating], scores * np.exp(-decay_exponent / sigma))
+
+
+def box_non_max_suppression(
+    predictions: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.bool_]:
+    """
+    Perform Non-Maximum Suppression (NMS) on object detection predictions.
+
+    Args:
+        predictions: An array of object detection predictions in
+            the format of `(x_min, y_min, x_max, y_max, score)`
+            or `(x_min, y_min, x_max, y_max, score, class)`.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum suppression.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of boxes (e.g., IoU, IoS).
+
+    Returns:
+        A boolean array indicating which predictions to keep after
+            non-maximum suppression.
+
+    Raises:
+        ValueError: If `iou_threshold` is not within the closed range
+            from `0` to `1`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> sv.box_non_max_suppression(predictions, iou_threshold=0.5)
+        array([ True, False])
+
+        ```
+    """
+    _validate_iou_threshold(iou_threshold)
+    sort_index, predictions, categories = _prepare_predictions_for_nms(predictions)
+    ious = box_iou_batch(predictions[:, :4], predictions[:, :4], overlap_metric)
+    keep = _nms_loop_from_iou_matrix(ious, categories, iou_threshold)
+    result: npt.NDArray[np.bool_] = keep[sort_index.argsort()]
+    return result
+
+
+def box_soft_non_max_suppression(
+    predictions: npt.NDArray[np.floating],
+    sigma: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.floating]:
+    """
+    Perform Soft Non-Maximum Suppression (Soft-NMS) on object detection predictions.
+
+    Unlike `box_non_max_suppression`, which discards overlapping boxes outright,
+    Soft-NMS keeps every detection and instead rescales its confidence by
+    `score *= exp(-iou**2 / sigma)` for each higher-scoring, same-category
+    overlap — the caller decides whether and where to threshold the result.
+    A smaller `sigma` produces a stronger decay.
+
+    Args:
+        predictions: An array of object detection predictions in
+            the format of `(x_min, y_min, x_max, y_max, score)`
+            or `(x_min, y_min, x_max, y_max, score, class)`.
+        sigma: Controls the strength of the confidence decay; must be greater
+            than `0`. No value of `sigma` reproduces hard
+            `box_non_max_suppression` output — Soft-NMS never drops boxes, only
+            rescales confidence.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of boxes (e.g., IoU, IoS).
+
+    Returns:
+        An array containing the updated (decayed) confidence scores, in the
+            same order as the input `predictions`.
+
+    Raises:
+        ValueError: If `sigma` is not greater than `0`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> sv.box_soft_non_max_suppression(predictions, sigma=0.5)
+        array([0.9       , 0.10826823])
+
+        ```
+    """
+    _validate_sigma(sigma)
+    sort_index, predictions, categories = _prepare_predictions_for_nms(predictions)
+    ious = box_iou_batch(predictions[:, :4], predictions[:, :4], overlap_metric)
+    decayed = _soft_nms_decay_from_iou_matrix(
+        ious, categories, predictions[:, 4], sigma
+    )
+    result_scores: npt.NDArray[np.floating] = decayed[sort_index.argsort()]
+    return result_scores
+
+
+def _group_overlapping_masks(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[np.bool_],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """
+    Apply greedy version of non-maximum merging to avoid detecting too many
+
+    Args:
+        predictions: An array of shape `(n, 5)` containing
+            the bounding boxes coordinates in format `[x1, y1, x2, y2]`
+            and the confidence scores.
+        masks: A 3D array of binary masks corresponding to
+            the predictions.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum suppression. Defaults to 0.5.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+
+    Returns:
+        Groups of prediction indices to be merged.
+            Each group may have 1 or more elements.
+    """
+    merge_groups: list[list[int]] = []
+
+    scores = predictions[:, 4]
+    order = scores.argsort()
+
+    while len(order) > 0:
+        idx = int(order[-1])
+
+        order = order[:-1]
+        if len(order) == 0:
+            merge_groups.append([idx])
+            break
+
+        merge_candidate = masks[idx][None, ...]
+        candidate_groups = [idx]
+        while len(order) > 0:
+            ious = mask_iou_batch(masks[order], merge_candidate, overlap_metric)
+            above_threshold: npt.NDArray[np.bool_] = ious.flatten() >= iou_threshold
+            if not above_threshold.any():
+                break
+            above_idx = order[above_threshold]
+            merge_candidate = np.logical_or.reduce(
+                np.concatenate([masks[above_idx], merge_candidate]),
+                axis=0,
+                keepdims=True,
+            )
+            candidate_groups.extend(np.flip(above_idx).tolist())
+            order = order[~above_threshold]
+
+        merge_groups.append(candidate_groups)
+    return merge_groups
+
+
+def mask_non_max_merge(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[Any] | CompactMask,
+    iou_threshold: float = 0.5,
+    *args: Any,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    mask_dimension: int = 640,
+) -> list[list[int]]:
+    """
+    Perform Non-Maximum Merging (NMM) on segmentation predictions.
+
+    Args:
+        predictions: A 2D array of object detection predictions in
+            the format of `(x_min, y_min, x_max, y_max, score)`
+            or `(x_min, y_min, x_max, y_max, score, class)`. Shape: `(N, 5)` or
+            `(N, 6)`, where N is the number of predictions.
+        masks: A 3D array of binary masks corresponding to the predictions.
+            Shape: `(N, H, W)`, where N is the number of predictions, and H, W are the
+            dimensions of each mask.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum merging.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of masks (e.g., IoU, IoS).
+        mask_dimension: Deprecated in `0.30.0`, removed in `0.33.0`. No longer
+            used; the parameter is silently ignored. Passing `mask_dimension`
+            positionally emits a deprecation warning.
+
+    Returns:
+        A list of groups of prediction indices. Each inner list contains
+            the indices of predictions whose masks overlap above `iou_threshold`
+            according to the chosen `overlap_metric`, and should be merged or
+            kept together as a single detection by non-maximum merging.
+
+    Raises:
+        ValueError: If `iou_threshold` is not within the closed range
+            from `0` to `1`.
+        TypeError: If more than five positional arguments are passed.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> masks = np.zeros((2, 4, 4), dtype=bool)
+        >>> masks[:, :2, :2] = True
+        >>> sv.mask_non_max_merge(predictions, masks, iou_threshold=0.5)
+        [[0, 1]]
+
+        ```
+    """
+
+    _validate_iou_threshold(iou_threshold)
+    if len(args) > 2:
+        raise TypeError(
+            "mask_non_max_merge accepts at most five positional arguments. "
+            "Pass overlap_metric and mask_dimension by keyword."
+        )
+    if args:
+        warn_deprecated(
+            "Passing `overlap_metric` or `mask_dimension` positionally to "
+            "`mask_non_max_merge` is deprecated in `0.30.0` and will be removed "
+            "in `0.33.0`. Pass them by keyword instead."
+        )
+        first = args[0]
+        if isinstance(first, OverlapMetric):
+            overlap_metric = first
+        else:
+            mask_dimension = cast(int, first)
+        if len(args) == 2:
+            second = args[1]
+            if isinstance(first, OverlapMetric):
+                mask_dimension = cast(int, second)
+            else:
+                overlap_metric = cast(OverlapMetric, second)
+
+    del mask_dimension
+
+    def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]:
+        if isinstance(masks, CompactMask):
+            return _group_overlapping_masks_pairwise(
+                predictions[global_indices],
+                masks[global_indices],
+                iou_threshold,
+                overlap_metric,
+            )
+        return _group_overlapping_masks(
+            predictions[global_indices],
+            masks[global_indices],
+            iou_threshold,
+            overlap_metric,
+        )
+
+    return _non_max_merge_per_category(predictions, group_within)
+
+
+def _update_mask_candidate(
+    masks: npt.NDArray[Any] | CompactMask,
+    candidate: npt.NDArray[Any] | CompactMask,
+    above_idx: npt.NDArray[np.int_],
+) -> npt.NDArray[Any] | CompactMask:
+    if isinstance(masks, CompactMask):
+        compact_candidate = cast(CompactMask, candidate)
+        union_mask = np.logical_or.reduce(
+            np.concatenate([masks[above_idx].to_dense(), compact_candidate.to_dense()]),
+            axis=0,
+            keepdims=True,
+        )
+        return CompactMask.from_dense(
+            masks=union_mask,
+            xyxy=mask_to_xyxy(union_mask),
+            image_shape=masks.image_shape,
+        )
+    dense_candidate = cast(npt.NDArray[Any], candidate)
+    dense_union: npt.NDArray[Any] = np.logical_or.reduce(
+        np.concatenate([masks[above_idx], dense_candidate]),
+        axis=0,
+        keepdims=True,
+    )
+    return dense_union
+
+
+def _greedy_nmm_via_mask_candidate(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[Any] | CompactMask,
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """Group masks by exact overlap while updating the merged candidate union."""
+    merge_groups: list[list[int]] = []
+    scores = predictions[:, 4]
+    order = scores.argsort()
+    while len(order) > 0:
+        idx = int(order[-1])
+        order = order[:-1]
+        if len(order) == 0:
+            merge_groups.append([idx])
+            break
+        candidate = masks[[idx]]
+        merge_group = [idx]
+        while len(order) > 0:
+            ious = mask_iou_batch(masks[order], candidate, overlap_metric).flatten()
+            above_threshold = ious >= iou_threshold
+            if not above_threshold.any():
+                break
+            above_idx = order[above_threshold]
+            candidate = _update_mask_candidate(masks, candidate, above_idx)
+            merge_group.extend(np.flip(above_idx).tolist())
+            order = order[~above_threshold]
+        merge_groups.append(merge_group)
+    return merge_groups
+
+
+def _group_overlapping_masks_pairwise(
+    predictions: npt.NDArray[np.floating],
+    masks: npt.NDArray[Any] | CompactMask,
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    return _greedy_nmm_via_mask_candidate(
+        predictions, masks, iou_threshold, overlap_metric
+    )
+
+
+def _non_max_merge_per_category(
+    predictions: npt.NDArray[np.floating],
+    group_within: Callable[[npt.NDArray[np.int_]], list[list[int]]],
+) -> list[list[int]]:
+    """Dispatch NMM grouping per class, then translate local indices back to
+    the global row positions of ``predictions``.
+
+    ``group_within(global_indices)`` must return merge groups expressed in
+    terms of *positions inside `global_indices`*, not absolute row positions.
+    When ``predictions`` has no class column, a single pass over all rows is
+    performed instead of per-category iteration.
+    """
+    if predictions.shape[1] == 5:
+        global_indices = np.arange(len(predictions), dtype=int)
+        return [
+            global_indices[group].tolist() for group in group_within(global_indices)
+        ]
+
+    category_ids = predictions[:, 5]
+    merge_groups: list[list[int]] = []
+    for category_id in np.unique(category_ids):
+        curr_indices = np.where(category_ids == category_id)[0]
+        for local_group in group_within(curr_indices):
+            merge_groups.append(curr_indices[local_group].tolist())
+
+    for merge_group in merge_groups:
+        if len(merge_group) == 0:
+            raise ValueError(
+                f"Empty group detected when non-max-merging detections: {merge_groups}"
+            )
+    return merge_groups
+
+
+def _group_overlapping_boxes(
+    predictions: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """
+    Apply greedy version of non-maximum merging to avoid detecting too many
+    overlapping bounding boxes for a given object.
+
+    Args:
+        predictions: An array of shape `(n, 5)` containing
+            the bounding boxes coordinates in format `[x1, y1, x2, y2]`
+            and the confidence scores.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum suppression. Defaults to 0.5.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of boxes (e.g., IoU, IoS).
+
+    Returns:
+        Groups of prediction indices to be merged.
+            Each group may have 1 or more elements.
+    """
+    merge_groups: list[list[int]] = []
+    scores = predictions[:, 4]
+    order = scores.argsort()
+    while len(order) > 0:
+        idx = int(order[-1])
+        order = order[:-1]
+        if len(order) == 0:
+            merge_groups.append([idx])
+            break
+        ious = box_iou_batch(
+            predictions[order][:, :4],
+            predictions[idx : idx + 1, :4],
+            overlap_metric,
+        ).flatten()
+        above_threshold = ious >= iou_threshold
+        merge_group = [idx, *np.flip(order[above_threshold]).tolist()]
+        merge_groups.append(merge_group)
+        order = order[~above_threshold]
+    return merge_groups
+
+
+def box_non_max_merge(
+    predictions: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """
+    Apply greedy version of non-maximum merging per category to avoid detecting
+    too many overlapping bounding boxes for a given object.
+
+    Args:
+        predictions: An array of shape `(n, 5)` or `(n, 6)`
+            containing the bounding boxes coordinates in format `[x1, y1, x2, y2]`,
+            the confidence scores and class_ids. Omit class_id column to allow
+            detections of different classes to be merged.
+        iou_threshold: The intersection-over-union threshold
+            to use for non-maximum suppression. Defaults to 0.5.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of boxes (e.g., IoU, IoS).
+
+    Returns:
+        list[list[int]]: Groups of prediction indices be merged.
+            Each group may have 1 or more elements.
+
+    Raises:
+        ValueError: If `iou_threshold` is not within the closed range
+            from `0` to `1`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> predictions = np.array([
+        ...     [0, 0, 4, 4, 0.9, 0],
+        ...     [0, 0, 4, 4, 0.8, 0],
+        ... ])
+        >>> sv.box_non_max_merge(predictions, iou_threshold=0.5)
+        [[0, 1]]
+
+        ```
+    """
+    _validate_iou_threshold(iou_threshold)
+
+    def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]:
+        return _group_overlapping_boxes(
+            predictions[global_indices], iou_threshold, overlap_metric
+        )
+
+    return _non_max_merge_per_category(predictions, group_within)
+
+
+def oriented_box_non_max_suppression(
+    predictions: npt.NDArray[np.floating],
+    oriented_boxes: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> npt.NDArray[np.bool_]:
+    """
+    Perform Non-Maximum Suppression on oriented bounding box predictions.
+
+    Overlap is computed via :func:`oriented_box_iou_batch` on the four
+    corners of each box, so detections whose axis-aligned bounding boxes
+    overlap heavily but whose oriented bodies do not are kept — unlike
+    :func:`box_non_max_suppression`, which would suppress them.
+
+    Args:
+        predictions: An array of object detection predictions in the
+            format ``(x_min, y_min, x_max, y_max, score)`` or
+            ``(x_min, y_min, x_max, y_max, score, class)``. Shape ``(N, 5)``
+            or ``(N, 6)``. Only the score (column 4) and optional class
+            (column 5) are read; the axis-aligned coordinates are not used.
+        oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four
+            ``(x, y)`` corners of each oriented box, aligned with
+            ``predictions`` row-by-row.
+        iou_threshold: The intersection-over-union threshold to use for
+            non-maximum suppression.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of oriented boxes (e.g., IoU, IoS).
+
+    Returns:
+        A boolean array of shape ``(N,)`` indicating which predictions
+            to keep after non-maximum suppression.
+
+    Raises:
+        ValueError: If ``iou_threshold`` is not within the closed range
+            from 0 to 1.
+        ValueError: If ``predictions`` and ``oriented_boxes`` have
+            mismatched lengths or invalid shapes.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> oriented_boxes = np.array([
+        ...     [[10, 10], [50, 10], [50, 30], [10, 30]],
+        ...     [[11, 11], [51, 11], [51, 31], [11, 31]],
+        ... ], dtype=np.float32)
+        >>> predictions = np.array([
+        ...     [10, 10, 50, 30, 0.9, 0],
+        ...     [11, 11, 51, 31, 0.8, 0],
+        ... ], dtype=np.float32)
+        >>> keep = sv.oriented_box_non_max_suppression(
+        ...     predictions=predictions,
+        ...     oriented_boxes=oriented_boxes,
+        ...     iou_threshold=0.5,
+        ... )
+        >>> keep
+        array([ True, False])
+
+        ```
+    """
+    _validate_iou_threshold(iou_threshold)
+    for name, arr in (("predictions", predictions), ("oriented_boxes", oriented_boxes)):
+        if name == "predictions":
+            if arr.ndim != 2 or arr.shape[1] not in (5, 6):
+                raise ValueError(
+                    f"`{name}` has shape {arr.shape}; expected (N, 5) or (N, 6)."
+                )
+            continue
+        if arr.ndim == 3 and arr.shape[1:] != (4, 2):
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 4, 2) "
+                f"— each box must have exactly 4 corners with (x, y) coordinates."
+            )
+        elif arr.ndim == 2 and arr.shape[1] != 8:
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 8) for flat "
+                f"YOLO format or (N, 4, 2) for corner format."
+            )
+        elif arr.ndim not in (2, 3):
+            raise ValueError(
+                f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}."
+            )
+    if len(predictions) != len(oriented_boxes):
+        raise ValueError(
+            f"`predictions` and `oriented_boxes` must have the same length, "
+            f"got {len(predictions)} and {len(oriented_boxes)}."
+        )
+    sort_index, _, categories = _prepare_predictions_for_nms(predictions)
+    oriented_boxes = oriented_boxes[sort_index]
+    # same object intentional — triggers upper-triangle optimization
+    ious = oriented_box_iou_batch(oriented_boxes, oriented_boxes, overlap_metric)
+    keep = _nms_loop_from_iou_matrix(ious, categories, iou_threshold)
+    result: npt.NDArray[np.bool_] = keep[sort_index.argsort()]
+    return result
+
+
+def _group_overlapping_oriented_boxes(
+    predictions: npt.NDArray[np.floating],
+    oriented_boxes: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """
+    Greedy non-maximum merging on oriented boxes. Mirrors
+    :func:`_group_overlapping_boxes` but uses :func:`oriented_box_iou_batch`.
+    """
+    merge_groups: list[list[int]] = []
+    scores = predictions[:, 4]
+    order = scores.argsort()
+    while len(order) > 0:
+        idx = int(order[-1])
+        order = order[:-1]
+        if len(order) == 0:
+            merge_groups.append([idx])
+            break
+        ious = oriented_box_iou_batch(
+            oriented_boxes[order],
+            oriented_boxes[idx][None, ...],
+            overlap_metric,
+        ).flatten()
+        above_threshold = ious >= iou_threshold
+        merge_group = [idx, *np.flip(order[above_threshold]).tolist()]
+        merge_groups.append(merge_group)
+        order = order[~above_threshold]
+    return merge_groups
+
+
+def oriented_box_non_max_merge(
+    predictions: npt.NDArray[np.floating],
+    oriented_boxes: npt.NDArray[np.floating],
+    iou_threshold: float = 0.5,
+    overlap_metric: OverlapMetric = OverlapMetric.IOU,
+) -> list[list[int]]:
+    """
+    Perform Non-Maximum Merging on oriented bounding box predictions,
+    grouped per category.
+
+    Mirrors :func:`box_non_max_merge` but uses oriented-box IoU, so groups
+    of rotated detections sharing the same body — rather than the same
+    axis-aligned bounding box — are merged.
+
+    Args:
+        predictions: An array of shape ``(n, 5)`` or ``(n, 6)`` containing
+            the axis-aligned coordinates ``[x1, y1, x2, y2]``, confidence
+            scores, and optionally class ids. Only the score and optional
+            class are used by the grouping logic; overlap is computed on
+            ``oriented_boxes``.
+        oriented_boxes: Array of shape ``(N, 4, 2)`` containing the four
+            ``(x, y)`` corners of each oriented box.
+        iou_threshold: The intersection-over-union threshold to use for
+            non-maximum merging.
+        overlap_metric: Metric used to compute the degree of overlap
+            between pairs of oriented boxes (e.g., IoU, IoS).
+
+    Returns:
+        Groups of prediction indices to be merged. Each group may have 1
+            or more elements.
+
+    Raises:
+        ValueError: If ``iou_threshold`` is not within the closed range
+            from 0 to 1.
+        ValueError: If ``predictions`` and ``oriented_boxes`` have
+            mismatched lengths or invalid shapes.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> oriented_boxes = np.array([
+        ...     [[10, 10], [50, 10], [50, 30], [10, 30]],
+        ...     [[11, 11], [51, 11], [51, 31], [11, 31]],
+        ... ], dtype=np.float32)
+        >>> predictions = np.array([
+        ...     [10, 10, 50, 30, 0.9, 0],
+        ...     [11, 11, 51, 31, 0.8, 0],
+        ... ], dtype=np.float32)
+        >>> groups = sv.oriented_box_non_max_merge(
+        ...     predictions=predictions,
+        ...     oriented_boxes=oriented_boxes,
+        ...     iou_threshold=0.5,
+        ... )
+        >>> len(groups)
+        1
+
+        ```
+    """
+    for name, arr in (("predictions", predictions), ("oriented_boxes", oriented_boxes)):
+        if name == "predictions":
+            if arr.ndim != 2 or arr.shape[1] not in (5, 6):
+                raise ValueError(
+                    f"`{name}` has shape {arr.shape}; expected (N, 5) or (N, 6)."
+                )
+            continue
+        if arr.ndim == 3 and arr.shape[1:] != (4, 2):
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 4, 2) "
+                f"— each box must have exactly 4 corners with (x, y) coordinates."
+            )
+        elif arr.ndim == 2 and arr.shape[1] != 8:
+            raise ValueError(
+                f"`{name}` has shape {arr.shape}; expected (N, 8) for flat "
+                f"YOLO format or (N, 4, 2) for corner format."
+            )
+        elif arr.ndim not in (2, 3):
+            raise ValueError(
+                f"`{name}` must be 2-D (N, 8) or 3-D (N, 4, 2), got shape {arr.shape}."
+            )
+    if len(predictions) != len(oriented_boxes):
+        raise ValueError(
+            f"`predictions` and `oriented_boxes` must have the same length, "
+            f"got {len(predictions)} and {len(oriented_boxes)}."
+        )
+    _validate_iou_threshold(iou_threshold)
+
+    def group_within(global_indices: npt.NDArray[np.int_]) -> list[list[int]]:
+        return _group_overlapping_oriented_boxes(
+            predictions[global_indices],
+            oriented_boxes[global_indices],
+            iou_threshold,
+            overlap_metric,
+        )
+
+    return _non_max_merge_per_category(predictions, group_within)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/masks.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/masks.py
new file mode 100644
index 0000000000000000000000000000000000000000..14a5b0b352ffa536f23c14b580a5fba3ec4bce67
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/masks.py
@@ -0,0 +1,639 @@
+from typing import Any, Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision._cv2._components import _contains_holes
+from supervision.detection.compact_mask import CompactMask
+
+
+def count_mask_pixels(masks: npt.NDArray[np.bool_]) -> npt.NDArray[np.int64]:
+    """Count the number of True pixels in each mask.
+
+    Uses ``np.count_nonzero`` (no axis), which dispatches to a SIMD popcount
+    over the raw bool buffer and is ~6x faster than ``np.sum(mask, axis=(1, 2))``.
+
+    Args:
+        masks: Boolean mask array of shape ``(N, H, W)``.
+
+    Returns:
+        Int64 array of shape ``(N,)`` with the True-pixel count per mask.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.masks import count_mask_pixels
+        >>> m = np.zeros((2, 4, 4), dtype=bool)
+        >>> m[0, :2, :2] = True  # 4 pixels
+        >>> m[1, :3, :3] = True  # 9 pixels
+        >>> count_mask_pixels(m)
+        array([4, 9])
+
+        ```
+    """
+    return np.fromiter(
+        (np.count_nonzero(m) for m in masks), dtype=np.int64, count=len(masks)
+    )
+
+
+def move_masks(
+    masks: npt.NDArray[np.bool_],
+    offset: npt.NDArray[np.integer],
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[np.bool_]:
+    """
+    Offset the masks in an array by the specified (x, y) amount.
+
+    Args:
+        masks: A 3D array of binary masks corresponding to the
+            predictions. Shape: `(N, H, W)`, where N is the number of predictions, and
+            H, W are the dimensions of each mask.
+        offset: An array of shape `(2,)` containing int values
+            `[dx, dy]`. Supports both positive and negative values for bidirectional
+            movement.
+        resolution_wh: The width and height of the desired mask
+            resolution.
+
+    Returns:
+        Repositioned masks, optionally padded to the specified shape.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([[[False, False, False, False],
+        ...                   [False, True,  True,  False],
+        ...                   [False, True,  True,  False],
+        ...                   [False, False, False, False]]], dtype=bool)
+        >>> offset = np.array([1, 1])
+        >>> sv.move_masks(mask, offset, resolution_wh=(4, 4))
+        array([[[False, False, False, False],
+                [False, False, False, False],
+                [False, False,  True,  True],
+                [False, False,  True,  True]]])
+        >>> offset = np.array([-2, 2])
+        >>> sv.move_masks(mask, offset, resolution_wh=(4, 4))
+        array([[[False, False, False, False],
+                [False, False, False, False],
+                [False, False, False, False],
+                [ True, False, False, False]]])
+
+        ```
+    """
+    mask_array = np.full((masks.shape[0], resolution_wh[1], resolution_wh[0]), False)
+
+    if offset[0] < 0:
+        source_x_start = -offset[0]
+        source_x_end = min(masks.shape[2], resolution_wh[0] - offset[0])
+        destination_x_start = 0
+        destination_x_end = min(resolution_wh[0], masks.shape[2] + offset[0])
+    else:
+        source_x_start = 0
+        source_x_end = min(masks.shape[2], resolution_wh[0] - offset[0])
+        destination_x_start = offset[0]
+        destination_x_end = offset[0] + source_x_end - source_x_start
+
+    if offset[1] < 0:
+        source_y_start = -offset[1]
+        source_y_end = min(masks.shape[1], resolution_wh[1] - offset[1])
+        destination_y_start = 0
+        destination_y_end = min(resolution_wh[1], masks.shape[1] + offset[1])
+    else:
+        source_y_start = 0
+        source_y_end = min(masks.shape[1], resolution_wh[1] - offset[1])
+        destination_y_start = offset[1]
+        destination_y_end = offset[1] + source_y_end - source_y_start
+
+    if source_x_end > source_x_start and source_y_end > source_y_start:
+        mask_array[
+            :,
+            destination_y_start:destination_y_end,
+            destination_x_start:destination_x_end,
+        ] = masks[:, source_y_start:source_y_end, source_x_start:source_x_end]
+
+    return mask_array
+
+
+def calculate_masks_centroids(
+    masks: npt.NDArray[np.bool_] | CompactMask,
+) -> npt.NDArray[np.int_]:
+    """
+    Calculate the centroids of binary masks in a tensor.
+
+    Args:
+        masks: A 3D NumPy array of shape (num_masks, height, width).
+            Each 2D array in the tensor represents a binary mask.
+            Also accepts a :class:`~supervision.detection.compact_mask.CompactMask`.
+
+    Returns:
+        A 2D NumPy array of shape (num_masks, 2), where each row contains the x and y
+            coordinates (in that order) of the centroid of the corresponding mask.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> masks = np.zeros((1, 10, 10), dtype=bool)
+        >>> masks[0, 2:6, 2:6] = True
+        >>> sv.calculate_masks_centroids(masks)
+        array([[4, 4]])
+
+        ```
+    """
+    if isinstance(masks, CompactMask):
+        # Compute centroids per-crop to avoid materialising the full (N, H, W) array.
+        n = len(masks)
+        if n == 0:
+            return cast(npt.NDArray[np.int_], np.empty((0, 2), dtype=int))
+
+        centroids: npt.NDArray[np.float64] = np.zeros((n, 2), dtype=np.float64)
+        for i in range(n):
+            crop = masks.crop(i)
+            crop_h, crop_w = crop.shape
+            x1 = int(masks.offsets[i, 0])
+            y1 = int(masks.offsets[i, 1])
+            total = int(crop.sum())
+            if total == 0:
+                centroids[i] = [0.0, 0.0]
+                continue
+            # Match the +0.5 offset used by the dense implementation.
+            crop_rows, crop_cols = np.indices((crop_h, crop_w))
+            cx = float(np.sum((crop_cols + 0.5)[crop])) / total + x1
+            cy = float(np.sum((crop_rows + 0.5)[crop])) / total + y1
+            centroids[i] = [cx, cy]
+
+        return cast(npt.NDArray[np.int_], centroids.astype(int))
+
+    _num_masks, height, width = masks.shape
+    total_pixels: npt.NDArray[np.int64] = count_mask_pixels(masks)
+
+    # offset for 1-based indexing
+    vertical_indices, horizontal_indices = np.indices((height, width)) + 0.5
+    # avoid division by zero for empty masks
+    total_pixels[total_pixels == 0] = 1
+
+    def sum_over_mask(
+        indices: npt.NDArray[np.floating], axis: tuple[list[int], list[int]]
+    ) -> npt.NDArray[np.floating]:
+        return cast(npt.NDArray[np.floating], np.tensordot(masks, indices, axes=axis))
+
+    aggregation_axis: tuple[list[int], list[int]] = ([1, 2], [0, 1])
+    centroid_x = sum_over_mask(horizontal_indices, aggregation_axis) / total_pixels
+    centroid_y = sum_over_mask(vertical_indices, aggregation_axis) / total_pixels
+
+    return cast(
+        npt.NDArray[np.int_], np.column_stack((centroid_x, centroid_y)).astype(int)
+    )
+
+
+def contains_holes(mask: npt.NDArray[np.bool_]) -> bool:
+    """
+    Checks if the binary mask contains holes (background pixels fully enclosed by
+    foreground pixels).
+
+    Args:
+        mask: 2D binary mask where `True` indicates foreground
+            object and `False` indicates background.
+
+    Returns:
+        True if holes are detected, False otherwise.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([
+        ...     [0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0],
+        ...     [0, 1, 0, 1, 0],
+        ...     [0, 1, 1, 1, 0],
+        ...     [0, 0, 0, 0, 0]
+        ... ]).astype(bool)
+        >>> sv.contains_holes(mask=mask)
+        True
+        >>> mask = np.array([
+        ...     [0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0],
+        ...     [0, 1, 1, 1, 0],
+        ...     [0, 1, 1, 1, 0],
+        ...     [0, 0, 0, 0, 0]
+        ... ]).astype(bool)
+        >>> sv.contains_holes(mask=mask)
+        False
+
+        ```
+
+    ![contains_holes](https://media.roboflow.com/supervision-docs/contains-holes.png){ align=center width="800" }
+    """  # noqa E501 // docs
+    return _contains_holes(mask)
+
+
+def contains_multiple_segments(
+    mask: npt.NDArray[np.bool_], connectivity: int = 4
+) -> bool:
+    """
+    Checks if the binary mask contains multiple unconnected foreground segments.
+
+    Args:
+        mask: 2D binary mask where `True` indicates foreground
+            object and `False` indicates background.
+        connectivity: Default: 4 is 4-way connectivity, which means that
+            foreground pixels are the part of the same segment/component
+            if their edges touch.
+            Alternatively: 8 for 8-way connectivity, when foreground pixels are
+            connected by their edges or corners touch.
+
+    Returns:
+        True when the mask contains multiple not connected components, False otherwise.
+
+    Raises:
+        ValueError: If connectivity(int) parameter value is not 4 or 8.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([
+        ...     [0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 0, 1, 1],
+        ...     [0, 1, 1, 0, 1, 1],
+        ...     [0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0, 0],
+        ...     [0, 1, 1, 1, 0, 0]
+        ... ]).astype(bool)
+        >>> sv.contains_multiple_segments(mask=mask, connectivity=4)
+        True
+        >>> mask = np.array([
+        ...     [0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 1, 1],
+        ...     [0, 1, 1, 1, 1, 1],
+        ...     [0, 1, 1, 1, 1, 1],
+        ...     [0, 1, 1, 1, 1, 1],
+        ...     [0, 0, 0, 0, 0, 0]
+        ... ]).astype(bool)
+        >>> sv.contains_multiple_segments(mask=mask, connectivity=4)
+        False
+
+        ```
+
+    ![contains_multiple_segments](https://media.roboflow.com/supervision-docs/contains-multiple-segments.png){ align=center width="800" }
+    """  # noqa E501 // docs
+    if connectivity != 4 and connectivity != 8:
+        raise ValueError(
+            "Incorrect connectivity value. Possible connectivity values: 4 or 8."
+        )
+    mask_uint8 = mask.astype(np.uint8)
+    labels = np.zeros_like(mask_uint8, dtype=np.int32)
+    number_of_labels, _ = cv2.connectedComponents(
+        mask_uint8, labels, connectivity=connectivity
+    )
+    return bool(number_of_labels > 2)
+
+
+def resize_masks(
+    masks: npt.NDArray[np.bool_], max_dimension: int = 640
+) -> npt.NDArray[np.bool_]:
+    """
+    Resize all masks in the array to have a maximum dimension of max_dimension,
+    maintaining aspect ratio.
+
+    Args:
+        masks: 3D array of binary masks with shape (N, H, W).
+        max_dimension: The maximum dimension for the resized masks.
+
+    Returns:
+        Array of resized masks.
+    """
+    max_height: int = masks.shape[1]
+    max_width: int = masks.shape[2]
+    scale = min(1.0, max_dimension / max_height, max_dimension / max_width)
+    if scale == 1.0:
+        return masks
+
+    new_height = int(scale * max_height)
+    new_width = int(scale * max_width)
+
+    x = np.linspace(0, max_width - 1, new_width).astype(int)
+    y = np.linspace(0, max_height - 1, new_height).astype(int)
+    xv, yv = np.meshgrid(x, y)
+
+    resized_masks = masks[:, yv, xv]
+
+    return resized_masks.reshape(masks.shape[0], new_height, new_width)
+
+
+def _chamfer_distances(main_mask: npt.NDArray[np.bool_]) -> npt.NDArray[np.int64]:
+    """Return OpenCV 3x3 L2 chamfer distances as fixed-point integers."""
+    height, width = main_mask.shape
+    horizontal_vertical = 62587
+    diagonal = 89738
+    infinity = np.iinfo(np.int64).max // 4
+    distances = np.where(main_mask, 0, infinity).astype(np.int64)
+    horizontal_costs = np.arange(width, dtype=np.int64) * horizontal_vertical
+
+    for row in range(height):
+        current = distances[row]
+        if row:
+            previous = distances[row - 1]
+            upper_left = np.full(width, infinity, dtype=np.int64)
+            upper_right = np.full(width, infinity, dtype=np.int64)
+            upper_left[1:] = previous[:-1] + diagonal
+            upper_right[:-1] = previous[1:] + diagonal
+            current = np.minimum.reduce(
+                (current, previous + horizontal_vertical, upper_left, upper_right)
+            )
+        distances[row] = (
+            np.minimum.accumulate(current - horizontal_costs) + horizontal_costs
+        )
+
+    for row in range(height - 1, -1, -1):
+        current = distances[row]
+        if row + 1 < height:
+            following = distances[row + 1]
+            lower_left = np.full(width, infinity, dtype=np.int64)
+            lower_right = np.full(width, infinity, dtype=np.int64)
+            lower_left[1:] = following[:-1] + diagonal
+            lower_right[:-1] = following[1:] + diagonal
+            current = np.minimum.reduce(
+                (current, following + horizontal_vertical, lower_left, lower_right)
+            )
+        reversed_current = current[::-1]
+        distances[row] = (
+            np.minimum.accumulate(reversed_current - horizontal_costs)
+            + horizontal_costs
+        )[::-1]
+
+    return distances
+
+
+def filter_segments_by_distance(
+    mask: npt.NDArray[np.bool_],
+    absolute_distance: float | None = 100.0,
+    relative_distance: float | None = None,
+    connectivity: int = 8,
+    mode: Literal["edge", "centroid"] = "edge",
+) -> npt.NDArray[np.bool_]:
+    """
+    Keep the largest connected component and any other components within a distance
+    threshold.
+
+    Distance can be absolute in pixels or relative to the image diagonal.
+
+    Args:
+        mask: Boolean mask HxW.
+        absolute_distance: Max allowed distance in pixels to the main component.
+            Ignored if `relative_distance` is provided.
+        relative_distance: Fraction of the diagonal. If set, threshold = fraction * sqrt(H^2 + W^2).
+        connectivity: Defines which neighboring pixels are considered connected.
+            - 4-connectedness: Only orthogonal neighbors.
+              ```
+              [ ][X][ ]
+              [X][O][X]
+              [ ][X][ ]
+              ```
+            - 8-connectedness: Includes diagonal neighbors.
+              ```
+              [X][X][X]
+              [X][O][X]
+              [X][X][X]
+              ```
+            Default is 8.
+        mode: Defines how distance between components is measured.
+            - "edge": Uses distance between nearest edges (via distance transform).
+            - "centroid": Uses distance between component centroids.
+
+    Returns:
+        Boolean mask after filtering.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> mask = np.array([
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ...     [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        ... ], dtype=bool)
+        >>> sv.filter_segments_by_distance(
+        ...     mask,
+        ...     absolute_distance=3,
+        ...     mode="edge",
+        ...     connectivity=8
+        ... ).astype(int)
+        array([[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+               [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
+
+        ```
+
+        The nearby 2x2 block at columns 6-7 is kept because its edge distance
+        is within 3 pixels. The distant block at columns 9-10 is removed.
+    """  # noqa E501 // docs
+    if mask.dtype != bool:
+        raise TypeError("mask must be boolean")
+
+    height, width = mask.shape
+    if not np.any(mask):
+        return cast(npt.NDArray[np.bool_], mask.copy())
+
+    image = cast(npt.NDArray[np.uint8], mask.astype(np.uint8))
+    components = cv2.connectedComponentsWithStats(image, connectivity=connectivity)
+    num_labels = int(components[0])
+    labels = cast(npt.NDArray[np.int32], components[1])
+    stats = cast(npt.NDArray[np.int32], components[2])
+    centroids = cast(npt.NDArray[np.float64], components[3])
+
+    if num_labels <= 1:
+        return cast(npt.NDArray[np.bool_], mask.copy())
+
+    areas = stats[1:, cv2.CC_STAT_AREA]
+    max_area = int(areas.max())
+    candidates = 1 + np.flatnonzero(areas == max_area)
+    # Use coordinates for equal-area ties so native and fallback labels agree.
+    main_label = min(
+        (int(label) for label in candidates),
+        key=lambda label: (int(stats[label, 0]), int(stats[label, 1]), label),
+    )
+
+    if relative_distance is not None:
+        diagonal = float(np.hypot(height, width))
+        threshold = float(relative_distance) * diagonal
+    elif absolute_distance is not None:
+        threshold = float(absolute_distance)
+    else:
+        raise ValueError("Either absolute_distance or relative_distance must be set.")
+
+    keep_labels: npt.NDArray[np.bool_] = np.zeros(num_labels, dtype=bool)
+    keep_labels[main_label] = True
+
+    if mode == "centroid":
+        differences = centroids[1:] - centroids[main_label]
+        distances = np.sqrt(np.sum(differences**2, axis=1))
+        nearby = 1 + np.where(distances <= threshold)[0]
+        keep_labels[nearby] = True
+    elif mode == "edge":
+        main_mask = labels == main_label
+        if np.isnan(threshold) or threshold < 0:
+            nearby_main = np.zeros_like(main_mask)
+        elif np.isposinf(threshold):
+            nearby_main = np.ones_like(main_mask)
+        else:
+            fixed_distances = _chamfer_distances(main_mask)
+            distances = fixed_distances.astype(np.float32) / 65536
+            nearby_main = distances <= threshold
+        for label in range(1, num_labels):
+            if label == main_label:
+                continue
+            component = labels == label
+            if not np.any(component):
+                continue
+            if np.any(nearby_main & component):
+                keep_labels[label] = True
+    else:
+        raise ValueError("mode must be 'edge' or 'centroid'")
+
+    return keep_labels[labels]
+
+
+def mask_to_roi(mask: npt.NDArray[np.bool_]) -> tuple[int, int, int, int] | None:
+    """Return exclusive ``(x1, y1, x2, y2)`` bounds for true mask pixels.
+
+    Use this helper when you need NumPy slice semantics. Unlike
+    :func:`~supervision.detection.utils.converters.mask_to_xyxy`, this
+    function uses exclusive upper bounds (``+1``) and returns ``None`` for
+    empty masks instead of zeros. The inclusive ``mask_to_xyxy`` convention
+    stays in place for compatibility with CompactMask and box-based adapters.
+
+    Args:
+        mask: 2D boolean array of shape ``(H, W)``.
+
+    Returns:
+        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when the mask
+        has no true pixels.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.detection.utils.masks import mask_to_roi
+        >>> mask = np.zeros((10, 10), dtype=bool)
+        >>> mask[2:5, 3:6] = True
+        >>> mask_to_roi(mask)
+        (3, 2, 6, 5)
+
+        ```
+    """
+    rows = np.flatnonzero(np.any(mask, axis=1))
+    if len(rows) == 0:
+        return None
+    cols = np.flatnonzero(np.any(mask, axis=0))
+    return int(cols[0]), int(rows[0]), int(cols[-1]) + 1, int(rows[-1]) + 1
+
+
+_mask_to_roi = mask_to_roi
+
+
+def _compact_masks_to_roi(
+    masks: CompactMask,
+    image_shape: tuple[int, int],
+) -> tuple[int, int, int, int] | None:
+    """Return exclusive bounding-box union for compact masks.
+
+    Uses crop metadata (offsets + shapes) — no RLE decode required.
+
+    Args:
+        masks: Compact mask collection.
+        image_shape: Image dimensions as ``(height, width)``.
+
+    Returns:
+        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when empty.
+    """
+    if len(masks) == 0:
+        return None
+    image_h, image_w = image_shape
+    bboxes = masks.bbox_xyxy  # shape (N, 4), inclusive int32
+    x_min = int(bboxes[:, 0].min())
+    y_min = int(bboxes[:, 1].min())
+    x_max = int(bboxes[:, 2].max()) + 1  # convert inclusive to exclusive
+    y_max = int(bboxes[:, 3].max()) + 1
+    return (
+        max(0, x_min),
+        max(0, y_min),
+        min(image_w, x_max),
+        min(image_h, y_max),
+    )
+
+
+def _masks_to_roi(
+    masks: CompactMask | npt.NDArray[Any],
+    image_shape: tuple[int, int],
+    xyxy: npt.NDArray[np.number] | None = None,
+) -> tuple[int, int, int, int] | None:
+    """Return exclusive true-pixel bounds for dense or compact masks.
+
+    Args:
+        masks: Dense boolean mask array of shape ``(N, H, W)`` or ``(H, W)``,
+            or a :class:`~supervision.detection.compact_mask.CompactMask`.
+        image_shape: Image dimensions as ``(height, width)``.
+        xyxy: Optional detection boxes of shape ``(N, 4)`` in
+            ``[x1, y1, x2, y2]`` format. When provided, the dense path
+            first checks whether all true pixels fall within the box union;
+            if so the box bounds are returned without a full pixel scan.
+
+    Returns:
+        Exclusive ``(x1, y1, x2, y2)`` bounds, or ``None`` when no true
+        pixels exist.
+    """
+    if isinstance(masks, CompactMask):
+        return _compact_masks_to_roi(masks=masks, image_shape=image_shape)
+    mask_array = np.asarray(masks, dtype=bool)
+    if mask_array.size == 0 or not mask_array.any():
+        return None
+    # Fast path: union of detection boxes (O(N)) avoids a full N·H·W pixel scan
+    # when boxes are mask-derived. Guard it with an `any()` check over the ROI so
+    # loose boxes cannot clip true pixels that lie outside the box union.
+    if xyxy is not None and len(xyxy) > 0:
+        image_h, image_w = image_shape
+        box_roi = (
+            max(0, int(np.floor(xyxy[:, 0].min()))),
+            max(0, int(np.floor(xyxy[:, 1].min()))),
+            min(image_w, int(np.floor(xyxy[:, 2].max())) + 1),
+            min(image_h, int(np.floor(xyxy[:, 3].max())) + 1),
+        )
+        x1, y1, x2, y2 = box_roi
+        if x1 < x2 and y1 < y2:
+            union = mask_array if mask_array.ndim == 2 else np.any(mask_array, axis=0)
+            # Return box bounds only when all true pixels fall within the box.
+            # Slice-based checks avoid allocating a full-frame copy.
+            if (
+                union[y1:y2, x1:x2].any()
+                and not union[:y1].any()
+                and not union[y2:].any()
+                and not union[y1:y2, :x1].any()
+                and not union[y1:y2, x2:].any()
+            ):
+                return box_roi
+            return mask_to_roi(union)
+    if mask_array.ndim == 2:
+        union = mask_array
+    else:
+        union = np.any(mask_array, axis=0)
+    return mask_to_roi(union)
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/polygons.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/polygons.py
new file mode 100644
index 0000000000000000000000000000000000000000..9810d0fb3fec7c1e11d3dfca44d91d04217e8ef4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/polygons.py
@@ -0,0 +1,167 @@
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+
+
+def _to_local_cv2_polygon(
+    polygon: npt.NDArray[np.number],
+) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.number]]:
+    """Translate a polygon to a local float32 coordinate system for OpenCV.
+
+    Integer subtraction uses object arithmetic so unsigned and signed inputs do
+    not wrap before conversion. Translating first preserves representable local
+    geometry when absolute coordinates exceed float32 precision.
+    """
+    origin = polygon.min(axis=0)
+    if np.issubdtype(polygon.dtype, np.integer):
+        local_polygon = np.asarray(
+            polygon.astype(object) - origin.astype(object), dtype=np.float32
+        )
+    else:
+        local_polygon = (
+            polygon.astype(np.float64, copy=False)
+            - origin.astype(np.float64, copy=False)
+        ).astype(np.float32)
+    return local_polygon, origin
+
+
+def filter_polygons_by_area(
+    polygons: list[npt.NDArray[np.number]],
+    min_area: float | None = None,
+    max_area: float | None = None,
+) -> list[npt.NDArray[np.number]]:
+    """
+    Filters a list of polygons based on their area.
+
+    Args:
+        polygons: A list of polygons, where each polygon is
+            represented by a NumPy array of shape `(N, 2)`,
+            containing the `x`, `y` coordinates of the points.
+        min_area: The minimum area threshold.
+            Only polygons with an area greater than or equal to this value
+            will be included in the output. If set to None,
+            no minimum area constraint will be applied.
+        max_area: The maximum area threshold.
+            Only polygons with an area less than or equal to this value
+            will be included in the output. If set to None,
+            no maximum area constraint will be applied.
+
+    Returns:
+        A new list of polygons containing only those with
+            areas within the specified thresholds.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> small = np.array([[0, 0], [2, 0], [2, 2], [0, 2]])
+        >>> big = np.array([[0, 0], [10, 0], [10, 10], [0, 10]])
+        >>> sv.filter_polygons_by_area([small, big], min_area=50)
+        [array([[ 0,  0],
+               [10,  0],
+               [10, 10],
+               [ 0, 10]])]
+
+        ```
+    """
+    if min_area is None and max_area is None:
+        return polygons
+    areas = [cv2.contourArea(_to_local_cv2_polygon(polygon)[0]) for polygon in polygons]
+    return [
+        polygon
+        for polygon, area in zip(polygons, areas)
+        if (min_area is None or area >= min_area)
+        and (max_area is None or area <= max_area)
+    ]
+
+
+def approximate_polygon(
+    polygon: npt.NDArray[np.number], percentage: float, epsilon_step: float = 0.05
+) -> npt.NDArray[np.number]:
+    """
+    Approximates a given polygon by reducing a certain percentage of points.
+
+    This function uses the Ramer-Douglas-Peucker algorithm to simplify the input
+    polygon by reducing the number of points while preserving the general shape.
+
+    Args:
+        polygon: A 2D NumPy array of shape `(N, 2)` containing
+            the `x`, `y` coordinates of the input polygon's points.
+        percentage: The percentage of points to be removed from the
+            input polygon, in the range `[0, 1)`.
+        epsilon_step: Approximation accuracy step, must be positive.
+            Epsilon is the maximum distance between the original curve
+            and its approximation.
+
+    Returns:
+        A new 2D NumPy array of shape `(M, 2)` containing the `x`, `y`
+            coordinates of the approximated polygon's points. `M` is at most
+            `floor(N * (1 - percentage))` (minimum 3). Because epsilon
+            advances in discrete `epsilon_step` increments, `M` may be
+            noticeably smaller than the budget when a single step crosses
+            the target band. At least 3 points are always kept; when further
+            simplification would collapse the polygon below 3 points the last
+            valid approximation is returned and `M` may exceed the budget.
+
+    Raises:
+        ValueError: If `percentage` is outside the range `[0, 1)`.
+        ValueError: If `epsilon_step` is not positive.
+
+    Examples:
+        Reduce a polygon to at most half its original point count:
+
+        ```pycon
+        >>> import numpy as np
+        >>> polygon = np.array([[0, 0], [10, 0], [10, 10], [0, 10],
+        ...                     [5, 10], [5, 5], [3, 7], [1, 9]])
+        >>> result = approximate_polygon(polygon, percentage=0.5)
+        >>> result.shape[1]
+        2
+        >>> len(result) <= max(int(len(polygon) * 0.5), 3)
+        True
+
+        Polygon already at or below target — returned unchanged:
+
+        >>> tiny = np.array([[0, 0], [5, 0], [2, 4]])
+        >>> approximate_polygon(tiny, percentage=0.5) is tiny
+        True
+
+        ```
+    """
+
+    if percentage < 0 or percentage >= 1:
+        raise ValueError("Percentage must be in the range [0, 1).")
+    if epsilon_step <= 0:
+        raise ValueError("epsilon_step must be positive.")
+
+    target_points = max(int(len(polygon) * (1 - percentage)), 3)
+
+    if len(polygon) <= target_points:
+        return polygon
+
+    original_dtype = polygon.dtype
+    cv_polygon, origin = _to_local_cv2_polygon(polygon)
+
+    epsilon: float = 0
+    approximated_points = polygon
+    while len(approximated_points) > target_points:
+        epsilon += epsilon_step
+        candidate = np.squeeze(
+            cv2.approxPolyDP(cv_polygon, epsilon, closed=True), axis=1
+        )
+        # Stop before the approximation collapses below a valid polygon; keep the
+        # last result with at least three points.
+        if len(candidate) < 3:
+            break
+        if np.issubdtype(original_dtype, np.integer):
+            approximated_points = np.asarray(
+                candidate.astype(original_dtype).astype(object) + origin.astype(object),
+                dtype=original_dtype,
+            )
+        else:
+            approximated_points = (
+                candidate.astype(np.float64) + origin.astype(np.float64)
+            ).astype(original_dtype)
+
+    return approximated_points
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/utils/vlms.py b/.venv/lib/python3.12/site-packages/supervision/detection/utils/vlms.py
new file mode 100644
index 0000000000000000000000000000000000000000..24a784e5442ed70c6d714d5a759cb4eccf80ef69
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/utils/vlms.py
@@ -0,0 +1,97 @@
+def edit_distance(string_1: str, string_2: str, case_sensitive: bool = True) -> int:
+    """
+    Calculates the minimum number of single-character edits required
+    to transform one string into another. Allowed operations are insertion,
+    deletion, and substitution.
+
+    Args:
+        string_1: The source string to be transformed.
+        string_2: The target string to transform into.
+        case_sensitive: Whether comparison should be case-sensitive.
+            Defaults to True.
+
+    Returns:
+        The minimum number of edits required to convert `string_1`
+        into `string_2`.
+
+    Examples:
+        ```pycon
+        >>> import supervision as sv
+        >>> sv.edit_distance("hello", "hello")
+        0
+        >>> sv.edit_distance("Test", "test", case_sensitive=True)
+        1
+        >>> sv.edit_distance("abc", "xyz")
+        3
+        >>> sv.edit_distance("hello", "")
+        5
+        >>> sv.edit_distance("", "")
+        0
+        >>> sv.edit_distance("hello world", "helloworld")
+        1
+
+        ```
+    """
+    if not case_sensitive:
+        string_1 = string_1.lower()
+        string_2 = string_2.lower()
+
+    if len(string_1) < len(string_2):
+        string_1, string_2 = string_2, string_1
+
+    prev_row = list(range(len(string_2) + 1))
+    curr_row = [0] * (len(string_2) + 1)
+
+    for i in range(1, len(string_1) + 1):
+        curr_row[0] = i
+        for j in range(1, len(string_2) + 1):
+            if string_1[i - 1] == string_2[j - 1]:
+                substitution_cost = 0
+            else:
+                substitution_cost = 1
+            curr_row[j] = min(
+                prev_row[j] + 1,
+                curr_row[j - 1] + 1,
+                prev_row[j - 1] + substitution_cost,
+            )
+        prev_row, curr_row = curr_row, prev_row
+
+    return prev_row[len(string_2)]
+
+
+def fuzzy_match_index(
+    candidates: list[str],
+    query: str,
+    threshold: int,
+    case_sensitive: bool = True,
+) -> int | None:
+    """
+    Searches for the first string in `candidates` whose edit distance
+    to `query` is less than or equal to `threshold`.
+
+    Args:
+        candidates: List of strings to search.
+        query: String to compare against the candidates.
+        threshold: Maximum allowed edit distance for a match.
+        case_sensitive: Whether matching should be case-sensitive.
+
+    Returns:
+        Index of the first matching string in candidates,
+        or None if no match is found.
+
+    Examples:
+        ```pycon
+        >>> from supervision.detection.utils.vlms import fuzzy_match_index
+        >>> fuzzy_match_index(["cat", "dog", "rat"], "dat", threshold=1)
+        0
+        >>> fuzzy_match_index(["alpha", "beta", "gamma"], "bata", threshold=1)
+        1
+        >>> fuzzy_match_index(["one", "two", "three"], "xyz", threshold=2) is None
+        True
+
+        ```
+    """
+    for idx, candidate in enumerate(candidates):
+        if edit_distance(candidate, query, case_sensitive=case_sensitive) <= threshold:
+            return idx
+    return None
diff --git a/.venv/lib/python3.12/site-packages/supervision/detection/vlm.py b/.venv/lib/python3.12/site-packages/supervision/detection/vlm.py
new file mode 100644
index 0000000000000000000000000000000000000000..90c135eeba479cd5ce3bcabd13eef46533d7cf0d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/detection/vlm.py
@@ -0,0 +1,999 @@
+from __future__ import annotations
+
+import ast
+import base64
+import io
+import json
+import re
+from enum import Enum
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void
+from PIL import Image
+
+from supervision.detection.utils.boxes import _sort_box_corners, denormalize_boxes
+from supervision.detection.utils.converters import polygon_to_mask, polygon_to_xyxy
+from supervision.utils.internal import warn_deprecated
+from supervision.validators import _validate_resolution
+
+
+class LMM(Enum):
+    """
+    Enum specifying supported Large Multimodal Models (LMMs).
+
+    !!! deprecated "Deprecated"
+
+        `LMM` is deprecated and will be removed in `supervision-0.31.0`.
+        Use `VLM` instead.
+
+    Attributes:
+        PALIGEMMA: Google's PaliGemma vision-language model.
+        FLORENCE_2: Microsoft's Florence-2 vision-language model.
+        QWEN_2_5_VL: Qwen2.5-VL open vision-language model from Alibaba.\
+        QWEN_3_VL: Qwen3-VL open vision-language model from Alibaba.
+        GOOGLE_GEMINI_2_0: Google Gemini 2.0 vision-language model.
+        GOOGLE_GEMINI_2_5: Google Gemini 2.5 vision-language model.
+        MOONDREAM: The Moondream vision-language model.
+    """
+
+    PALIGEMMA = "paligemma"
+    FLORENCE_2 = "florence_2"
+    QWEN_2_5_VL = "qwen_2_5_vl"
+    QWEN_3_VL = "qwen_3_vl"
+    DEEPSEEK_VL_2 = "deepseek_vl_2"
+    GOOGLE_GEMINI_2_0 = "gemini_2_0"
+    GOOGLE_GEMINI_2_5 = "gemini_2_5"
+    MOONDREAM = "moondream"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return [c.value for c in cls]
+
+    @classmethod
+    def from_value(cls, value: LMM | str) -> LMM:
+        warn_deprecated(
+            "`LMM` is deprecated since `supervision-0.27.0` and will be removed in "
+            "`supervision-0.31.0`. Use `VLM` instead."
+        )
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            value = value.lower()
+            try:
+                return cls(value)
+            except ValueError:
+                raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}")
+        raise ValueError(
+            f"Invalid value type: {type(value)}. Must be an instance of "
+            f"{cls.__name__} or str."
+        )
+
+
+class VLM(Enum):
+    """
+    Enum specifying supported Vision-Language Models (VLMs).
+
+    Attributes:
+        PALIGEMMA: Google's PaliGemma vision-language model.
+        FLORENCE_2: Microsoft's Florence-2 vision-language model.
+        QWEN_2_5_VL: Qwen2.5-VL open vision-language model from Alibaba.
+        QWEN_3_VL: Qwen3-VL open vision-language model from Alibaba.
+        GOOGLE_GEMINI_2_0: Google Gemini 2.0 vision-language model.
+        GOOGLE_GEMINI_2_5: Google Gemini 2.5 vision-language model.
+        GOOGLE_GEMINI_3_5: Google Gemini 3.5 vision-language model.
+        MOONDREAM: The Moondream vision-language model.
+    """
+
+    PALIGEMMA = "paligemma"
+    FLORENCE_2 = "florence_2"
+    QWEN_2_5_VL = "qwen_2_5_vl"
+    QWEN_3_VL = "qwen_3_vl"
+    DEEPSEEK_VL_2 = "deepseek_vl_2"
+    GOOGLE_GEMINI_2_0 = "gemini_2_0"
+    GOOGLE_GEMINI_2_5 = "gemini_2_5"
+    GOOGLE_GEMINI_3_5 = "gemini_3_5"
+    MOONDREAM = "moondream"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        return [c.value for c in cls]
+
+    @classmethod
+    def from_value(cls, value: VLM | str) -> VLM:
+        if isinstance(value, cls):
+            return value
+        if isinstance(value, str):
+            value = value.lower()
+            try:
+                return cls(value)
+            except ValueError:
+                raise ValueError(f"Invalid value: {value}. Must be one of {cls.list()}")
+        raise ValueError(
+            f"Invalid value type: {type(value)}. Must be an instance of "
+            f"{cls.__name__} or str."
+        )
+
+
+RESULT_TYPES: dict[VLM, type] = {
+    VLM.PALIGEMMA: str,
+    VLM.FLORENCE_2: dict,
+    VLM.QWEN_2_5_VL: str,
+    VLM.QWEN_3_VL: str,
+    VLM.DEEPSEEK_VL_2: str,
+    VLM.GOOGLE_GEMINI_2_0: str,
+    VLM.GOOGLE_GEMINI_2_5: str,
+    VLM.GOOGLE_GEMINI_3_5: str,
+    VLM.MOONDREAM: dict,
+}
+
+REQUIRED_ARGUMENTS: dict[VLM, list[str]] = {
+    VLM.PALIGEMMA: ["resolution_wh"],
+    VLM.FLORENCE_2: ["resolution_wh"],
+    VLM.QWEN_2_5_VL: ["input_wh", "resolution_wh"],
+    VLM.QWEN_3_VL: ["resolution_wh"],
+    VLM.DEEPSEEK_VL_2: ["resolution_wh"],
+    VLM.GOOGLE_GEMINI_2_0: ["resolution_wh"],
+    VLM.GOOGLE_GEMINI_2_5: ["resolution_wh"],
+    VLM.GOOGLE_GEMINI_3_5: ["resolution_wh"],
+    VLM.MOONDREAM: ["resolution_wh"],
+}
+
+ALLOWED_ARGUMENTS: dict[VLM, list[str]] = {
+    VLM.PALIGEMMA: ["resolution_wh", "classes"],
+    VLM.FLORENCE_2: ["resolution_wh"],
+    VLM.QWEN_2_5_VL: ["input_wh", "resolution_wh", "classes"],
+    VLM.QWEN_3_VL: ["resolution_wh", "classes"],
+    VLM.DEEPSEEK_VL_2: ["resolution_wh", "classes"],
+    VLM.GOOGLE_GEMINI_2_0: ["resolution_wh", "classes"],
+    VLM.GOOGLE_GEMINI_2_5: ["resolution_wh", "classes"],
+    VLM.GOOGLE_GEMINI_3_5: ["resolution_wh", "classes"],
+    VLM.MOONDREAM: ["resolution_wh"],
+}
+
+SUPPORTED_TASKS_FLORENCE_2 = [
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+    "",
+]
+
+
+def _validate_vlm_parameters(
+    vlm: VLM | str, result: Any, kwargs: dict[str, Any]
+) -> VLM:
+    """
+    Validates the parameters and result type for a given Vision-Language Model (VLM).
+
+    Args:
+        vlm: The VLM enum or string specifying the model.
+        result: The result object to validate (type depends on VLM).
+        kwargs: Dictionary of arguments to validate against required/allowed lists.
+
+    Returns:
+        The validated VLM enum value.
+
+    Raises:
+        ValueError: If the VLM, result type, or arguments are invalid.
+    """
+    if isinstance(vlm, str):
+        try:
+            vlm = VLM(vlm.lower())
+        except ValueError:
+            raise ValueError(
+                f"Invalid vlm value: {vlm}. Must be one of {[e.value for e in VLM]}"
+            )
+
+    if not isinstance(result, RESULT_TYPES[vlm]):
+        raise ValueError(
+            f"Invalid VLM result type: {type(result)}. Must be {RESULT_TYPES[vlm]}"
+        )
+
+    required_args = REQUIRED_ARGUMENTS.get(vlm, [])
+    for arg in required_args:
+        if arg not in kwargs:
+            raise ValueError(f"Missing required argument: {arg}")
+
+    allowed_args = ALLOWED_ARGUMENTS.get(vlm, [])
+    for arg in kwargs:
+        if arg not in allowed_args:
+            raise ValueError(f"Argument {arg} is not allowed for {vlm.name}")
+
+    return vlm
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_vlm_parameters,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_vlm_parameters(vlm: VLM | str, result: Any, kwargs: dict[str, Any]) -> VLM:
+    return void(vlm, result, kwargs)  # type: ignore[no-any-return]
+
+
+def from_paligemma(
+    result: str, resolution_wh: tuple[int, int], classes: list[str] | None = None
+) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]:
+    """
+    Parse bounding boxes from paligemma-formatted text, scale them to the specified
+    resolution, and optionally filter by classes.
+
+    Args:
+        result: String containing paligemma-formatted locations and labels.
+        resolution_wh: tuple (width, height) to which we scale the box coordinates.
+        classes: Optional list of valid class names. If provided, boxes and labels not
+            in this list are filtered out.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of
+            shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an
+            optional array of shape `(n,)` with class indices, and `class_name`
+            is an array of shape `(n,)` with class labels.
+    """
+
+    w, h = _validate_resolution(resolution_wh)
+
+    pattern = re.compile(
+        r"(?) ([\w\s\-]+)"
+    )
+    matches = pattern.findall(result)
+    matches_arr: npt.NDArray[Any] = np.array(matches) if matches else np.empty((0, 5))
+
+    if matches_arr.shape[0] == 0:
+        return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty(0, dtype=str)
+
+    xyxy_arr = np.array(matches_arr[:, [1, 0, 3, 2]], dtype=float)
+    xyxy_arr = xyxy_arr.astype(int) / 1024 * np.array([w, h, w, h])
+    class_name = np.char.strip(matches_arr[:, 4].astype(str))
+    class_id: npt.NDArray[Any] | None = None
+
+    if classes is not None:
+        mask = np.array([name in classes for name in class_name], dtype=bool)
+        xyxy_arr = xyxy_arr[mask]
+        class_name = class_name[mask]
+        class_id = np.array([classes.index(name) for name in class_name])
+
+    return xyxy_arr, class_id, class_name
+
+
+def recover_truncated_qwen_2_5_vl_response(text: str) -> Any | None:
+    """
+    Attempt to recover and parse a truncated or malformed JSON snippet from Qwen-2.5-VL
+    output.
+
+    This utility extracts a JSON-like portion from a string that may be truncated or
+    malformed, cleans trailing commas, and attempts to parse it into a Python object.
+
+    Args:
+        text: Raw text containing the JSON snippet possibly truncated or
+            incomplete.
+
+    Returns:
+        Parsed Python object (usually list) if recovery and parsing succeed;
+            otherwise `None`.
+    """
+    try:
+        first_bracket = text.find("[")
+        if first_bracket == -1:
+            return None
+        snippet = text[first_bracket:]
+
+        last_brace = snippet.rfind("}")
+        if last_brace == -1:
+            return None
+
+        snippet = snippet[: last_brace + 1]
+
+        prefix_end = snippet.find("[")
+        if prefix_end == -1:
+            return None
+
+        prefix = snippet[: prefix_end + 1]
+        body = snippet[prefix_end + 1 :].rstrip()
+
+        if body.endswith(","):
+            body = body[:-1].rstrip()
+
+        repaired = prefix + body + "]"
+
+        return json.loads(repaired)
+    except Exception:
+        return None
+
+
+def from_qwen_2_5_vl(
+    result: str,
+    input_wh: tuple[int, int],
+    resolution_wh: tuple[int, int],
+    classes: list[str] | None = None,
+) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]:
+    """
+    Parse and rescale bounding boxes and class labels from Qwen-2.5-VL JSON output.
+
+    The JSON is expected to be enclosed in triple backticks with the format:
+      ```json
+      [
+          {"bbox_2d": [x1, y1, x2, y2], "label": "some class name"},
+          ...
+      ]
+      ```
+
+    Args:
+        result: String containing Qwen-2.5-VL JSON bounding box and label data.
+        input_wh: Width and height of the coordinate space where boxes
+            are normalized.
+        resolution_wh: Target width and height to scale bounding boxes.
+        classes: Optional list of valid class names to filter results. If provided,
+            only boxes with labels in this list are returned.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of
+            shape `(N, 4)` in `(x_min, y_min, x_max, y_max)` format, `class_id`
+            is an optional array of shape `(N,)` with class indices, and
+            `class_name` is an array of shape `(N,)` with class names.
+    """
+
+    in_w, in_h = _validate_resolution(input_wh)
+    out_w, out_h = _validate_resolution(resolution_wh)
+
+    text = result.strip()
+    text = re.sub(r"^```(json)?", "", text, flags=re.IGNORECASE).strip()
+    text = re.sub(r"```$", "", text).strip()
+
+    start = text.find("[")
+    end = text.rfind("]")
+    if start != -1 and end != -1 and end > start:
+        text = text[start : end + 1].strip()
+
+    try:
+        data = json.loads(text)
+    except json.JSONDecodeError:
+        repaired = recover_truncated_qwen_2_5_vl_response(text)
+        if repaired is not None:
+            data = repaired
+        else:
+            try:
+                data = ast.literal_eval(text)
+            except (ValueError, SyntaxError, TypeError):
+                return (
+                    np.empty((0, 4)),
+                    np.empty((0,), dtype=int),
+                    np.empty((0,), dtype=str),
+                )
+
+    if not isinstance(data, list):
+        return (np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str))
+
+    boxes_list = []
+    labels_list = []
+
+    for item in data:
+        if not isinstance(item, dict) or "bbox_2d" not in item or "label" not in item:
+            continue
+        boxes_list.append(item["bbox_2d"])
+        labels_list.append(item["label"])
+
+    if not boxes_list:
+        return (np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str))
+
+    xyxy = np.array(boxes_list, dtype=float)
+    class_name = np.array(labels_list, dtype=str)
+
+    xyxy = xyxy / [in_w, in_h, in_w, in_h]
+    xyxy = xyxy * [out_w, out_h, out_w, out_h]
+
+    class_id = None
+
+    if classes is not None:
+        mask = np.array([label in classes for label in class_name], dtype=bool)
+        xyxy = xyxy[mask]
+        class_name = class_name[mask]
+        class_id = np.array([classes.index(label) for label in class_name], dtype=int)
+
+    return xyxy, class_id, class_name
+
+
+def from_qwen_3_vl(
+    result: str,
+    resolution_wh: tuple[int, int],
+    classes: list[str] | None = None,
+) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]:
+    """
+    Parse and scale bounding boxes from Qwen-3-VL style JSON output.
+
+    Args:
+        result: String containing the Qwen-3-VL JSON output.
+        resolution_wh: Target resolution `(width, height)` to scale bounding boxes.
+        classes: Optional list of valid classes to filter results.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of
+            shape `(N, 4)` in `(x_min, y_min, x_max, y_max)` format scaled to
+            `resolution_wh`, `class_id` is an optional array of class indices,
+            and `class_name` is an array of class names.
+    """
+    return from_qwen_2_5_vl(
+        result=result,
+        input_wh=(1000, 1000),
+        resolution_wh=resolution_wh,
+        classes=classes,
+    )
+
+
+def from_deepseek_vl_2(
+    result: str, resolution_wh: tuple[int, int], classes: list[str] | None = None
+) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]:
+    """
+    Parse bounding boxes from deepseek-vl2-formatted text, scale them to the specified
+    resolution, and optionally filter by classes.
+
+    The DeepSeek-VL2 output typically contains pairs of <|ref|> ... <|/ref|> labels
+    and <|det|> ... <|/det|> bounding box definitions. Each <|det|> section may
+    contain one or more bounding boxes in the form [[x1, y1, x2, y2], [x1, y1, x2, y2], ...]
+    (scaled to 0..999). For example:
+
+    ```
+    <|ref|>The giraffe at the back<|/ref|><|det|>[[580, 270, 999, 904]]<|/det|><|ref|>The giraffe at the front<|/ref|><|det|>[[26, 31, 632, 998]]<|/det|><|end▁of▁sentence|>
+    ```
+
+    Args:
+        result: String containing deepseek-vl2-formatted locations and labels.
+        resolution_wh: Tuple (width, height) to which we scale the box coordinates.
+        classes: Optional list of valid class names. If provided, boxes and labels not
+            in this list are filtered out.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of
+            shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an
+            optional array of shape `(n,)` with class indices, and `class_name`
+            is an array of shape `(n,)` with class labels. When the input
+            contains no detections (or all are filtered by `classes`), returns
+            `(np.empty((0, 4)), np.empty(0), np.empty(0))`.
+    """  # noqa: E501
+
+    width, height = resolution_wh
+    label_segments = re.findall(r"<\|ref\|>(.*?)<\|/ref\|>", result, flags=re.S)
+    detection_segments = re.findall(r"<\|det\|>(.*?)<\|/det\|>", result, flags=re.S)
+
+    if len(label_segments) != len(detection_segments):
+        raise ValueError(
+            f"Number of ref tags ({len(label_segments)}) "
+            f"and det tags ({len(detection_segments)}) in the result must be equal."
+        )
+
+    xyxy_list: list[list[float]] = []
+    class_name_list: list[str] = []
+    for label, detection_blob in zip(label_segments, detection_segments):
+        current_class_name = label.strip()
+        for box in re.findall(r"\[(.*?)\]", detection_blob):
+            x1, y1, x2, y2 = map(float, box.strip("[]").split(","))
+            xyxy_list.append(
+                [
+                    (x1 / 999 * width),
+                    (y1 / 999 * height),
+                    (x2 / 999 * width),
+                    (y2 / 999 * height),
+                ]
+            )
+            class_name_list.append(current_class_name)
+
+    xyxy = (
+        np.array(xyxy_list, dtype=np.float32)
+        if xyxy_list
+        else np.empty((0, 4), dtype=np.float32)
+    )
+    class_name = (
+        np.array(class_name_list) if class_name_list else np.array([], dtype=object)
+    )
+
+    if classes is not None:
+        mask = np.array([name in classes for name in class_name], dtype=bool)
+        xyxy = xyxy[mask]
+        class_name = class_name[mask]
+        class_id = np.array([classes.index(name) for name in class_name])
+    else:
+        unique_classes = sorted(list(set(class_name)))
+        class_to_id = {name: i for i, name in enumerate(unique_classes)}
+        class_id = np.array([class_to_id[name] for name in class_name])
+
+    return xyxy, class_id, class_name
+
+
+def from_florence_2(
+    result: dict[str, Any], resolution_wh: tuple[int, int]
+) -> tuple[
+    npt.NDArray[Any],
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any] | None,
+]:
+    """
+    Parse results from the Florence 2 multi-model model.
+    https://huggingface.co/microsoft/Florence-2-large
+
+    Args:
+        result: dict containing the model output
+        resolution_wh: (output_width, output_height) to which we rescale the boxes.
+
+    Returns:
+        A tuple of `(xyxy, labels, masks, obb_boxes)` where `xyxy` is an array
+            of shape `(n, 4)` in format `[x1, y1, x2, y2]`, `labels` is an
+            optional array of shape `(n,)` with class labels, `masks` is an
+            optional array of shape `(n, h, w)` with segmentation masks, and
+            `obb_boxes` is an optional array of shape `(n, 4, 2)` with oriented
+            bounding boxes.
+
+    Raises:
+        ValueError: If the top-level Florence 2 payload has multiple tasks or
+            if a task payload is malformed.
+    """
+    if len(result) != 1:
+        raise ValueError(f"Expected result with a single element. Got: {result}")
+    task = next(iter(result.keys()))
+    if task not in SUPPORTED_TASKS_FLORENCE_2:
+        raise ValueError(
+            f"{task} not supported. Supported tasks are: {SUPPORTED_TASKS_FLORENCE_2}"
+        )
+    result = result[task]
+
+    if task in ["", "", ""]:
+        xyxy = np.array(result["bboxes"], dtype=np.float32)
+        labels = np.array(result["labels"])
+        return xyxy, labels, None, None
+
+    if task == "":
+        xyxy = np.array(result["bboxes"], dtype=np.float32)
+        # provides labels, but they are ["", "", "", ...]
+        return xyxy, None, None, None
+
+    if task == "":
+        xyxyxyxy = np.array(result["quad_boxes"], dtype=np.float32)
+        xyxyxyxy = xyxyxyxy.reshape(-1, 4, 2)
+        xyxy = np.array([polygon_to_xyxy(polygon) for polygon in xyxyxyxy])
+        labels = np.array(result["labels"])
+        return xyxy, labels, None, xyxyxyxy
+
+    if task in ["", ""]:
+        xyxy_list: list[npt.NDArray[Any]] = []
+        masks_list: list[npt.NDArray[Any]] = []
+        for polygons_of_same_class in result["polygons"]:
+            for polygon in polygons_of_same_class:
+                polygon = np.reshape(polygon, (-1, 2)).astype(np.int32)
+                mask = polygon_to_mask(polygon, resolution_wh).astype(bool)
+                masks_list.append(mask)
+                xyxy_box = polygon_to_xyxy(polygon)
+                xyxy_list.append(xyxy_box)
+            # per-class labels also provided, but they are ["", "", "", ...]
+            # when we figure out how to set class names, we can do
+            # zip(result["labels"], result["polygons"])
+        xyxy = np.array(xyxy_list, dtype=np.float32)
+        masks = np.array(masks_list)
+        return xyxy, None, masks, None
+
+    if task == "":
+        xyxy = np.array(result["bboxes"], dtype=np.float32)
+        labels = np.array(result["bboxes_labels"])
+        # Also has "polygons" and "polygons_labels", but they don't seem to be used
+        return xyxy, labels, None, None
+
+    if task in ["", ""]:
+        if not isinstance(result, str):
+            raise ValueError(f"Expected string as {task} result, got {type(result)}")
+
+        if result == "No object detected.":
+            return np.empty((0, 4), dtype=np.float32), np.array([]), None, None
+
+        pattern = re.compile(r"")
+        match = pattern.search(result)
+        if match is None:
+            raise ValueError(
+                f"Expected string to end in location tags, but got {result}"
+            )
+
+        w, h = _validate_resolution(resolution_wh)
+        xyxy = np.array([match.groups()], dtype=np.float32)
+        xyxy *= np.array([w, h, w, h]) / 1000
+        result_string = result[: match.start()]
+        labels = np.array([result_string])
+        return xyxy, labels, None, None
+
+    raise RuntimeError(f"Unimplemented task: {task}")
+
+
+def _recover_gemini_json_objects(text: str) -> list[Any]:
+    """
+    Salvage individual JSON objects from a malformed Gemini JSON array.
+
+    Scans for balanced `{...}` spans and parses each independently, keeping the
+    ones that decode into a `dict` and skipping the rest. This recovers the valid
+    entries from an array that a single `json.loads` would reject wholesale, such
+    as one whose objects contain a mid-array syntax error or a missing key.
+
+    Args:
+        text: The (fence-stripped) response text that failed `json.loads`.
+
+    Returns:
+        The list of successfully parsed objects, which may be empty.
+    """
+    objects: list[Any] = []
+    depth = 0
+    start = None
+    for index, char in enumerate(text):
+        if char == "{":
+            if depth == 0:
+                start = index
+            depth += 1
+        elif char == "}" and depth > 0:
+            depth -= 1
+            if depth == 0 and start is not None:
+                try:
+                    parsed = json.loads(text[start : index + 1])
+                except json.JSONDecodeError:
+                    parsed = None
+                if isinstance(parsed, dict):
+                    objects.append(parsed)
+                start = None
+    return objects
+
+
+def from_google_gemini_2_0(
+    result: str,
+    resolution_wh: tuple[int, int],
+    classes: list[str] | None = None,
+) -> tuple[npt.NDArray[Any], npt.NDArray[Any] | None, npt.NDArray[Any]]:
+    """
+    Parse and scale bounding boxes from Google Gemini style
+    [JSON output](https://ai.google.dev/gemini-api/docs/vision?lang=python).
+
+    The JSON is expected to be enclosed in triple backticks with the format:
+        ```json
+        [
+            {"box_2d": [x1, y1, x2, y2], "label": "some class name"},
+            ...
+        ]
+        ```
+
+    For example:
+        ```json
+        [
+            {"box_2d": [10, 20, 110, 120], "label": "cat"},
+            {"box_2d": [50, 100, 150, 200], "label": "dog"}
+        ]
+        ```
+
+    Args:
+        result: String containing the JSON snippet enclosed by triple backticks.
+        resolution_wh: (output_width, output_height) to which we rescale the boxes.
+        classes: Optional list of valid class names. If provided, returned boxes/labels
+            are filtered to only those classes found here.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name)` where `xyxy` is an array of
+            shape `(n, 4)` in format `[x1, y1, x2, y2]`, `class_id` is an
+            optional array of shape `(n,)` with class indices, and `class_name`
+            is an array of shape `(n,)` with class labels.
+
+    """
+
+    w, h = _validate_resolution(resolution_wh)
+
+    lines = result.splitlines()
+    for i, line in enumerate(lines):
+        if line == "```json":
+            result = "\n".join(lines[i + 1 :])
+            result = result.split("```")[0]
+            break
+
+    try:
+        data = json.loads(result)
+    except json.JSONDecodeError:
+        data = _recover_gemini_json_objects(result)
+
+    if not isinstance(data, list):
+        return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str)
+
+    labels = []
+    xyxy = []
+
+    for item in data:
+        if not isinstance(item, dict) or "box_2d" not in item or "label" not in item:
+            continue
+        labels.append(item["label"])
+        box = item["box_2d"]
+        # Gemini bbox order is [y_min, x_min, y_max, x_max]
+        xyxy.append([box[1], box[0], box[3], box[2]])
+
+    if len(xyxy) == 0:
+        return np.empty((0, 4)), np.empty((0,), dtype=int), np.empty((0,), dtype=str)
+
+    xyxy = denormalize_boxes(
+        np.array(xyxy, dtype=np.float64),
+        resolution_wh=(w, h),
+        normalization_factor=1000,
+    )
+    class_name = np.array(labels)
+    class_id = None
+
+    if classes is not None:
+        mask = np.array([name in classes for name in class_name], dtype=bool)
+        xyxy = xyxy[mask]
+        class_name = class_name[mask]
+        class_id = np.array([classes.index(name) for name in class_name])
+
+    return xyxy, class_id, class_name
+
+
+def from_google_gemini_2_5(
+    result: str,
+    resolution_wh: tuple[int, int],
+    classes: list[str] | None = None,
+) -> tuple[
+    npt.NDArray[Any],
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any],
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any] | None,
+]:
+    """
+    Parse and scale bounding boxes and masks from Google Gemini 2.5 style
+    [JSON output](https://ai.google.dev/gemini-api/docs/vision?lang=python).
+
+    The JSON is expected to be enclosed in triple backticks with the format:
+        ```json
+        [
+            {
+                "box_2d": [x1, y1, x2, y2],
+                "mask": "data:image/png;base64,...",
+                "label": "some class name",
+                "confidence": 0.95,
+            },
+            ...
+        ]
+        ```
+
+    Args:
+        result: String containing the JSON snippet enclosed by triple backticks.
+        resolution_wh: (output_width, output_height) to which we rescale the boxes.
+        classes: Optional list of valid class names. If provided, returned boxes/labels
+            are filtered to only those classes found here.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name, confidence, masks)` where
+            `xyxy` is an array of shape `(n, 4)` in format `[x1, y1, x2, y2]`,
+            `class_id` is an array of shape `(n,)` with class indices,
+            `class_name` is an array of shape `(n,)` with class labels,
+            `confidence` is an optional array of shape `(n,)` with confidence
+            scores, and `masks` is an optional array of shape `(n, h, w)` with
+            segmentation masks.
+    """
+    w, h = _validate_resolution(resolution_wh)
+
+    lines = result.splitlines()
+    for i, line in enumerate(lines):
+        if line == "```json":
+            result = "\n".join(lines[i + 1 :])
+            result = result.split("```")[0]
+            break
+
+    try:
+        data = json.loads(result)
+    except json.JSONDecodeError:
+        data = _recover_gemini_json_objects(result)
+
+    if not isinstance(data, list):
+        return (
+            np.empty((0, 4)),
+            np.array([], dtype=int),
+            np.array([], dtype=str),
+            np.array([], dtype=float),
+            None,
+        )
+
+    boxes_list: list[Any] = []
+    labels_list: list[str] = []
+    confidence_list: list[float] | None = []
+    masks_list: list[npt.NDArray[Any]] | None = []
+
+    for item in data:
+        if not isinstance(item, dict) or "box_2d" not in item or "label" not in item:
+            continue
+        labels_list.append(item["label"])
+        box = item["box_2d"]
+        # Gemini bbox order is [y_min, x_min, y_max, x_max]
+        absolute_box = denormalize_boxes(
+            np.array([[box[1], box[0], box[3], box[2]]]).astype(np.float64),
+            resolution_wh=(w, h),
+            normalization_factor=1000,
+        )
+        absolute_bbox = _sort_box_corners(absolute_box)[0]
+        boxes_list.append(absolute_bbox)
+
+        if "mask" in item:
+            if masks_list is not None:
+                png_str = item["mask"]
+                if not isinstance(png_str, str) or not png_str.startswith(
+                    "data:image/png;base64,"
+                ):
+                    # Malformed mask: keep an empty mask but still fall through to
+                    # the confidence handling below, so the per-item arrays stay
+                    # aligned (a `continue` here desynced confidence vs boxes).
+                    masks_list.append(np.zeros((h, w), dtype=bool))
+                else:
+                    png_str = png_str.removeprefix("data:image/png;base64,")
+                    try:
+                        png_bytes = base64.b64decode(png_str)
+                        mask_img = Image.open(io.BytesIO(png_bytes)).convert("L")
+                    except Exception:
+                        masks_list.append(np.zeros((h, w), dtype=bool))
+                    else:
+                        y_min, y_max = int(absolute_bbox[1]), int(absolute_bbox[3])
+                        x_min, x_max = int(absolute_bbox[0]), int(absolute_bbox[2])
+
+                        bbox_height = y_max - y_min
+                        bbox_width = x_max - x_min
+
+                        if bbox_height > 0 and bbox_width > 0:
+                            mask_img = mask_img.resize(
+                                (bbox_width, bbox_height),
+                                resample=Image.Resampling.BILINEAR,
+                            )
+                            np_mask: npt.NDArray[np.bool_] = np.zeros(
+                                (h, w), dtype=bool
+                            )
+                            np_mask[y_min:y_max, x_min:x_max] = np.array(mask_img) > 0
+                            masks_list.append(np_mask)
+                        else:
+                            masks_list.append(np.zeros((h, w), dtype=bool))
+        else:
+            masks_list = None
+
+        if "confidence" in item:
+            if confidence_list is not None:
+                confidence_list.append(item["confidence"])
+        else:
+            confidence_list = None
+
+    if not boxes_list:
+        return (
+            np.empty((0, 4)),
+            np.array([], dtype=int),
+            np.array([], dtype=str),
+            np.array([], dtype=float),
+            None,
+        )
+
+    xyxy = np.array(boxes_list, dtype=float)
+    class_name = np.array(labels_list)
+    class_id: npt.NDArray[Any]
+
+    if classes is not None:
+        mask = np.array([name in classes for name in class_name], dtype=bool)
+        xyxy = xyxy[mask]
+        class_name = class_name[mask]
+        class_id = np.array([classes.index(name) for name in class_name])
+        if masks_list is not None:
+            masks_list = [m for m, keep in zip(masks_list, mask) if keep]
+
+        if confidence_list is not None:
+            confidence_list = [c for c, keep in zip(confidence_list, mask) if keep]
+    else:
+        unique_labels = sorted(list(set(class_name)))
+        label_to_id = {label: i for i, label in enumerate(unique_labels)}
+        class_id = np.array([label_to_id[name] for name in class_name])
+
+    confidence = (
+        np.array(confidence_list, dtype=float) if confidence_list is not None else None
+    )
+    masks = np.array(masks_list) if masks_list is not None else None
+
+    return (
+        xyxy,
+        class_id,
+        class_name,
+        confidence,
+        masks,
+    )
+
+
+def from_google_gemini_3_5(
+    result: str,
+    resolution_wh: tuple[int, int],
+    classes: list[str] | None = None,
+) -> tuple[
+    npt.NDArray[Any],
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any],
+    npt.NDArray[Any] | None,
+    npt.NDArray[Any] | None,
+]:
+    """
+    Parse and scale bounding boxes and masks from Google Gemini 3.5 style JSON output.
+
+    Gemini 3.5 emits the same detection JSON as Gemini 2.5 (`box_2d` in
+    `[y_min, x_min, y_max, x_max]` normalized to 0-1000, plus `label` and optional
+    `mask`/`confidence`), so parsing delegates to `from_google_gemini_2_5`.
+
+    Args:
+        result: String containing the JSON snippet enclosed by triple backticks.
+        resolution_wh: (output_width, output_height) to which we rescale the boxes.
+        classes: Optional list of valid class names. If provided, returned boxes/labels
+            are filtered to only those classes found here.
+
+    Returns:
+        A tuple of `(xyxy, class_id, class_name, confidence, masks)` matching the
+            `from_google_gemini_2_5` return contract.
+    """
+    return from_google_gemini_2_5(result, resolution_wh, classes)
+
+
+def from_moondream(
+    result: dict[str, Any],
+    resolution_wh: tuple[int, int],
+) -> npt.NDArray[Any]:
+    """
+    Parse and scale bounding boxes from moondream JSON output.
+
+    The JSON is expected to have a key "objects" with a list of dictionaries:
+      {
+          "objects": [
+              {"x_min": 0.1, "y_min": 0.2, "x_max": 0.3, "y_max": 0.4},
+              ...
+          ]
+      }
+
+      For Example:
+      {
+          "objects": [
+              {"x_min": 0.1, "y_min": 0.2, "x_max": 0.3, "y_max": 0.4},
+              {"x_min": 0.5, "y_min": 0.6, "x_max": 0.7, "y_max": 0.8}
+          ]
+      }
+
+    Args:
+        result: Dictionary containing the JSON output from the model.
+        resolution_wh: (output_width, output_height) to which we rescale the boxes.
+
+    Returns:
+        An array of shape `(n, 4)` containing the bounding boxes coordinates
+            in format `[x1, y1, x2, y2]`.
+    """
+
+    w, h = resolution_wh
+    if w <= 0 or h <= 0:
+        raise ValueError(
+            f"Both dimensions in resolution_wh must be positive. Got ({w}, {h})."
+        )
+
+    if "objects" not in result or not isinstance(result["objects"], list):
+        return np.empty((0, 4), dtype=float)
+
+    xyxy = []
+
+    for item in result["objects"]:
+        if not all(k in item for k in ["x_min", "y_min", "x_max", "y_max"]):
+            continue
+
+        x_min = item["x_min"]
+        y_min = item["y_min"]
+        x_max = item["x_max"]
+        y_max = item["y_max"]
+
+        xyxy.append([x_min, y_min, x_max, y_max])
+
+    if len(xyxy) == 0:
+        return cast(npt.NDArray[Any], np.empty((0, 4)))
+
+    return cast(
+        npt.NDArray[Any],
+        denormalize_boxes(
+            np.array(xyxy).astype(np.float64),
+            resolution_wh=(w, h),
+        ),
+    )
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/__init__.py b/.venv/lib/python3.12/site-packages/supervision/draw/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c71a42a4045876e8beff66d7357534e04c97a272
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/base.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/base.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9977f9ac08bdf594849d26a55067011534320d40
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/base.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/color.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/color.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00f91b28bb9d26c1d9f96cc0c1bd1b89c39c2561
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/color.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b67a1e12aa66d3750cd7dfa9737dbc2182f141a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/draw/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/base.py b/.venv/lib/python3.12/site-packages/supervision/draw/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f3d50c6a3a3b08803226d115ddc9c93fa474828
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/draw/base.py
@@ -0,0 +1,14 @@
+from typing import TypeVar
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+ImageType = TypeVar("ImageType", npt.NDArray[np.uint8], Image.Image)
+"""
+An image of type `np.ndarray` or `PIL.Image.Image`.
+
+Unlike a `Union`, ensures the type remains consistent. If a function
+takes an `ImageType` argument and returns an `ImageType`, when you
+pass an `np.ndarray`, you will get an `np.ndarray` back.
+"""
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/color.py b/.venv/lib/python3.12/site-packages/supervision/draw/color.py
new file mode 100644
index 0000000000000000000000000000000000000000..c99f4ccafaabf1d9af038b3724b8ce2dc3c4f159
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/draw/color.py
@@ -0,0 +1,598 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, cast
+
+from supervision.utils.internal import classproperty
+
+DEFAULT_COLOR_PALETTE = [
+    "A351FB",
+    "FF4040",
+    "FFA1A0",
+    "FF7633",
+    "FFB633",
+    "D1D435",
+    "4CFB12",
+    "94CF1A",
+    "40DE8A",
+    "1B9640",
+    "00D6C1",
+    "2E9CAA",
+    "00C4FF",
+    "364797",
+    "6675FF",
+    "0019EF",
+    "863AFF",
+    "530087",
+    "CD3AFF",
+    "FF97CA",
+    "FF39C9",
+]
+
+LEGACY_COLOR_PALETTE = [
+    "#A351FB",
+    "#E6194B",
+    "#3CB44B",
+    "#FFE119",
+    "#0082C8",
+    "#F58231",
+    "#911EB4",
+    "#46F0F0",
+    "#F032E6",
+    "#D2F53C",
+    "#FABEBE",
+    "#008080",
+    "#E6BEFF",
+    "#AA6E28",
+    "#FFFAC8",
+    "#800000",
+    "#AAFFC3",
+]
+
+ROBOFLOW_COLOR_PALETTE = ["C28DFC", "A351FB", "8315F9", "6706CE", "5905B3", "4D049A"]
+
+
+def _validate_color_hex(color_hex: str) -> None:
+    color_hex = color_hex.lstrip("#")
+    if not all(c in "0123456789abcdefABCDEF" for c in color_hex):
+        raise ValueError("Invalid characters in color hash")
+    if len(color_hex) not in (3, 4, 6, 8):
+        raise ValueError("Invalid length of color hash")
+
+
+@dataclass
+class Color:
+    """
+    Represents a color in RGBA format.
+
+    This class provides methods to work with colors, including creating colors from hex
+    codes, converting colors to hex strings, RGB tuples, BGR tuples, RGBA tuples,
+    and BGRA tuples.
+
+    Attributes:
+        r: Red channel value (0-255).
+        g: Green channel value (0-255).
+        b: Blue channel value (0-255).
+        a: Alpha channel value (0-255). Default is 255 (fully opaque).
+
+    Example:
+        ```pycon
+        >>> import supervision as sv
+        >>> sv.Color.WHITE
+        Color(r=255, g=255, b=255)
+
+        ```
+
+    | Constant   | Hex Code   | RGB               |
+    |------------|------------|-------------------|
+    | `WHITE`    | `#FFFFFF`  | `(255, 255, 255)` |
+    | `BLACK`    | `#000000`  | `(0, 0, 0)`       |
+    | `GREY`     | `#808080`  | `(128, 128, 128)` |
+    | `RED`      | `#FF0000`  | `(255, 0, 0)`     |
+    | `GREEN`    | `#00FF00`  | `(0, 255, 0)`     |
+    | `BLUE`     | `#0000FF`  | `(0, 0, 255)`     |
+    | `YELLOW`   | `#FFFF00`  | `(255, 255, 0)`   |
+    | `ROBOFLOW` | `#A351FB`  | `(163, 81, 251)`  |
+    """
+
+    r: int
+    g: int
+    b: int
+    a: int = 255
+
+    def __post_init__(self) -> None:
+        """Validate that direct Color construction uses byte-sized channels."""
+        if not (
+            0 <= self.r <= 255
+            and 0 <= self.g <= 255
+            and 0 <= self.b <= 255
+            and 0 <= self.a <= 255
+        ):
+            raise ValueError(
+                "Color values must be in range 0-255, "
+                f"got ({self.r}, {self.g}, {self.b}, {self.a})"
+            )
+
+    @classmethod
+    def from_hex(cls, color_hex: str) -> Color:
+        """
+        Create a Color instance from a hex string.
+
+        Args:
+            color_hex: The hex string representing the color. This string can
+                start with '#' followed by 3, 4, 6, or 8 hexadecimal characters.
+                For 3- or 4-character codes, each character is doubled to form the
+                full hex code.
+
+        Returns:
+            An instance representing the color.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color.from_hex('#ff00ff')
+            Color(r=255, g=0, b=255)
+            >>> sv.Color.from_hex('#f0f')
+            Color(r=255, g=0, b=255)
+
+            >>> sv.Color.from_hex('#ff00ff80')
+            Color(r=255, g=0, b=255, a=128)
+            >>> sv.Color.from_hex('#f0f8')
+            Color(r=255, g=0, b=255, a=136)
+
+            ```
+        """
+        _validate_color_hex(color_hex)
+        color_hex = color_hex.lstrip("#")
+        if len(color_hex) == 3:
+            color_hex = "".join(c * 2 for c in color_hex)
+        elif len(color_hex) == 4:
+            color_hex = "".join(c * 2 for c in color_hex)
+
+        if len(color_hex) == 6:
+            r, g, b = (int(color_hex[i : i + 2], 16) for i in range(0, 6, 2))
+            return cls(r, g, b)
+        else:  # len(color_hex) == 8
+            r, g, b, a = (int(color_hex[i : i + 2], 16) for i in range(0, 8, 2))
+            return cls(r, g, b, a)
+
+    @classmethod
+    def from_rgb_tuple(cls, color_tuple: tuple[int, int, int]) -> Color:
+        """
+        Create a Color instance from an RGB tuple.
+
+        Args:
+            color_tuple: A tuple representing the color in RGB format, where each
+                element is an integer in the range 0-255.
+
+        Returns:
+            An instance representing the color.
+
+        Raises:
+            ValueError: If any RGB value is outside the range 0-255.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color.from_rgb_tuple((255, 255, 0))
+            Color(r=255, g=255, b=0)
+
+            ```
+        """
+        r, g, b = color_tuple
+        if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+            raise ValueError(f"RGB values must be in range 0-255, got ({r}, {g}, {b})")
+        return cls(r=r, g=g, b=b)
+
+    @classmethod
+    def from_bgr_tuple(cls, color_tuple: tuple[int, int, int]) -> Color:
+        """
+        Create a Color instance from a BGR tuple.
+
+        Args:
+            color_tuple: A tuple representing the color in BGR format, where each
+                element is an integer in the range 0-255.
+
+        Returns:
+            An instance representing the color.
+
+        Raises:
+            ValueError: If any BGR value is outside the range 0-255.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color.from_bgr_tuple((0, 255, 255))
+            Color(r=255, g=255, b=0)
+
+            ```
+        """
+        b, g, r = color_tuple
+        if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255):
+            raise ValueError(f"BGR values must be in range 0-255, got ({b}, {g}, {r})")
+        return cls(r=r, g=g, b=b)
+
+    @classmethod
+    def from_rgba_tuple(cls, color_tuple: tuple[int, int, int, int]) -> Color:
+        """
+        Create a Color instance from an RGBA tuple.
+
+        Args:
+            color_tuple: A tuple representing the color in RGBA format, where each
+                element is an integer in the range 0-255.
+
+        Returns:
+            An instance representing the color.
+
+        Raises:
+            ValueError: If any RGBA value is outside the range 0-255.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color.from_rgba_tuple((255, 255, 0, 128))
+            Color(r=255, g=255, b=0, a=128)
+
+            ```
+        """
+        r, g, b, a = color_tuple
+        if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255 and 0 <= a <= 255):
+            raise ValueError(
+                f"RGBA values must be in range 0-255, got ({r}, {g}, {b}, {a})"
+            )
+        return cls(r=r, g=g, b=b, a=a)
+
+    @classmethod
+    def from_bgra_tuple(cls, color_tuple: tuple[int, int, int, int]) -> Color:
+        """
+        Create a Color instance from a BGRA tuple.
+
+        Args:
+            color_tuple: A tuple representing the color in BGRA format, where each
+                element is an integer in the range 0-255.
+
+        Returns:
+            An instance representing the color.
+
+        Raises:
+            ValueError: If any BGRA value is outside the range 0-255.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color.from_bgra_tuple((0, 255, 255, 128))
+            Color(r=255, g=255, b=0, a=128)
+
+            ```
+        """
+        b, g, r, a = color_tuple
+        if not (0 <= r <= 255 and 0 <= g <= 255 and 0 <= b <= 255 and 0 <= a <= 255):
+            raise ValueError(
+                f"BGRA values must be in range 0-255, got ({b}, {g}, {r}, {a})"
+            )
+        return cls(r=r, g=g, b=b, a=a)
+
+    def as_hex(self) -> str:
+        """
+        Converts the Color instance to a hex string.
+
+        Returns:
+            The hexadecimal color string. Returns `#RRGGBBAA` if alpha is not 255,
+                otherwise returns `#RRGGBB`.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color(r=255, g=255, b=0).as_hex()
+            '#ffff00'
+
+            >>> sv.Color(r=255, g=0, b=255, a=128).as_hex()
+            '#ff00ff80'
+
+            ```
+        """
+        if self.a != 255:
+            return f"#{self.r:02x}{self.g:02x}{self.b:02x}{self.a:02x}"
+        return f"#{self.r:02x}{self.g:02x}{self.b:02x}"
+
+    def as_rgb(self) -> tuple[int, int, int]:
+        """
+        Returns the color as an RGB tuple.
+
+        Returns:
+            RGB tuple.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color(r=255, g=255, b=0).as_rgb()
+            (255, 255, 0)
+
+            ```
+        """
+        return self.r, self.g, self.b
+
+    def as_bgr(self) -> tuple[int, int, int]:
+        """
+        Returns the color as a BGR tuple.
+
+        Returns:
+            BGR tuple.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color(r=255, g=255, b=0).as_bgr()
+            (0, 255, 255)
+
+            ```
+        """
+        return self.b, self.g, self.r
+
+    def as_rgba(self) -> tuple[int, int, int, int]:
+        """
+        Returns the color as an RGBA tuple.
+
+        Returns:
+            RGBA tuple.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color(r=255, g=255, b=0, a=128).as_rgba()
+            (255, 255, 0, 128)
+
+            ```
+        """
+        return self.r, self.g, self.b, self.a
+
+    def as_bgra(self) -> tuple[int, int, int, int]:
+        """
+        Returns the color as a BGRA tuple.
+
+        Returns:
+            BGRA tuple.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.Color(r=255, g=255, b=0, a=128).as_bgra()
+            (0, 255, 255, 128)
+
+            ```
+        """
+        return self.b, self.g, self.r, self.a
+
+    @classproperty
+    def WHITE(cls) -> Color:
+        return Color.from_hex("#FFFFFF")
+
+    @classproperty
+    def BLACK(cls) -> Color:
+        return Color.from_hex("#000000")
+
+    @classproperty
+    def GREY(cls) -> Color:
+        return Color.from_hex("#808080")
+
+    @classproperty
+    def RED(cls) -> Color:
+        return Color.from_hex("#FF0000")
+
+    @classproperty
+    def GREEN(cls) -> Color:
+        return Color.from_hex("#00FF00")
+
+    @classproperty
+    def BLUE(cls) -> Color:
+        return Color.from_hex("#0000FF")
+
+    @classproperty
+    def YELLOW(cls) -> Color:
+        return Color.from_hex("#FFFF00")
+
+    @classproperty
+    def ROBOFLOW(cls) -> Color:
+        return Color.from_hex("#A351FB")
+
+    def __hash__(self) -> int:
+        return hash((self.r, self.g, self.b, self.a))
+
+    def __repr__(self) -> str:
+        if self.a == 255:
+            return f"Color(r={self.r}, g={self.g}, b={self.b})"
+        return f"Color(r={self.r}, g={self.g}, b={self.b}, a={self.a})"
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, Color)
+            and self.r == other.r
+            and self.g == other.g
+            and self.b == other.b
+            and self.a == other.a
+        )
+
+
+@dataclass
+class ColorPalette:
+    colors: list[Color]
+
+    @classproperty
+    def DEFAULT(cls) -> ColorPalette:
+        """
+        Returns a default color palette.
+
+        Returns:
+            A ColorPalette instance with default colors.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.ColorPalette.DEFAULT  # doctest: +ELLIPSIS
+            ColorPalette(colors=[Color(r=163, g=81, b=251), Color(r=255, g=64, b=64), ...])
+
+            ```
+
+        ![default-color-palette](https://media.roboflow.com/
+        supervision-annotator-examples/default-color-palette.png)
+        """  # noqa: E501 // docs
+        return ColorPalette.from_hex(color_hex_list=DEFAULT_COLOR_PALETTE)
+
+    @classproperty
+    def ROBOFLOW(cls) -> ColorPalette:
+        """
+        Returns a Roboflow color palette.
+
+        Returns:
+            A ColorPalette instance with Roboflow colors.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.ColorPalette.ROBOFLOW  # doctest: +ELLIPSIS
+            ColorPalette(colors=[Color(r=194, g=141, b=252), Color(r=163, g=81, b=251), ...])
+
+            ```
+
+        ![roboflow-color-palette](https://media.roboflow.com/
+        supervision-annotator-examples/roboflow-color-palette.png)
+        """  # noqa: E501 // docs
+        return ColorPalette.from_hex(color_hex_list=ROBOFLOW_COLOR_PALETTE)
+
+    @classproperty
+    def LEGACY(cls) -> ColorPalette:
+        return ColorPalette.from_hex(color_hex_list=LEGACY_COLOR_PALETTE)
+
+    @classmethod
+    def from_hex(cls, color_hex_list: list[str]) -> ColorPalette:
+        """
+        Create a ColorPalette instance from a list of hex strings.
+
+        Args:
+            color_hex_list: List of color hex strings.
+
+        Returns:
+            A ColorPalette instance.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> colors = ['#ff0000', '#00ff00', '#0000ff']
+            >>> sv.ColorPalette.from_hex(colors)  # doctest: +ELLIPSIS
+            ColorPalette(colors=[Color(r=255, g=0, b=0), Color(r=0, g=255, b=0), ...])
+
+            ```
+        """
+        colors = [Color.from_hex(color_hex) for color_hex in color_hex_list]
+        return cls(colors)
+
+    @classmethod
+    def from_matplotlib(cls, palette_name: str, color_count: int) -> ColorPalette:
+        """
+        Create a ColorPalette instance from a Matplotlib color palette.
+
+        Args:
+            palette_name: Name of the Matplotlib palette.
+            color_count: Number of colors to sample from the palette.
+
+        Returns:
+            A ColorPalette instance.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> sv.ColorPalette.from_matplotlib('viridis', 5)  # doctest: +ELLIPSIS
+            ColorPalette(colors=[Color(r=68, g=1, b=84), Color(r=58, g=82, b=139), ...])
+
+            ```
+
+        ![visualized_color_palette](https://media.roboflow.com/
+        supervision-annotator-examples/visualized_color_palette.png)
+        """
+        if color_count < 1:
+            raise ValueError("color_count must be greater than or equal to 1")
+
+        # Keep pyplot lazy so importing color utilities does not import matplotlib.
+        import matplotlib.pyplot as plt
+
+        mpl_palette = plt.get_cmap(palette_name)
+        if hasattr(mpl_palette, "resampled"):
+            mpl_palette = mpl_palette.resampled(color_count)
+
+        if hasattr(mpl_palette, "colors"):
+            colors = mpl_palette.colors
+        else:
+            # A single color samples the palette start and avoids division by zero.
+            positions = (
+                [0.0]
+                if color_count == 1
+                else [i / (color_count - 1) for i in range(color_count)]
+            )
+            colors = [mpl_palette(position) for position in positions]
+
+        return cls(
+            [Color(int(r * 255), int(g * 255), int(b * 255)) for r, g, b, _ in colors]
+        )
+
+    def by_idx(self, idx: int) -> Color:
+        """
+        Return the color at a given index in the palette.
+
+        Args:
+            idx: Index of the color in the palette.
+
+        Returns:
+            Color at the given index.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> colors = ['#ff0000', '#00ff00', '#0000ff']
+            >>> color_palette = sv.ColorPalette.from_hex(colors)
+            >>> color_palette.by_idx(1)
+            Color(r=0, g=255, b=0)
+
+            ```
+        """
+        if not self.colors:
+            raise ValueError("ColorPalette must contain at least one color")
+        # Modulo preserves Python-like wrapping for negative and oversized indexes.
+        idx = idx % len(self.colors)
+        return self.colors[idx]
+
+    def __len__(self) -> int:
+        """
+        Returns the number of colors in the palette.
+
+        Returns:
+            The number of colors.
+        """
+        return len(self.colors)
+
+
+def unify_to_bgr(color: tuple[int, int, int] | Color) -> tuple[int, int, int]:
+    """
+    Converts a color input in multiple formats to a standardized BGR format.
+
+    Args:
+        color: The color input to be converted,
+            which can be either a tuple of BGR values or an instance of a Color class.
+
+    Returns:
+        The color in BGR format as a tuple of three integers.
+
+    Example:
+        ```pycon
+        >>> from supervision.draw.color import unify_to_bgr, Color
+        >>> unify_to_bgr(Color.WHITE)
+        (255, 255, 255)
+        >>> unify_to_bgr((0, 255, 255))
+        (0, 255, 255)
+
+        ```
+    """
+    if issubclass(type(color), Color):
+        color = cast(Color, color)
+        return color.as_bgr()
+    color = cast(tuple[int, int, int], color)
+    return color
diff --git a/.venv/lib/python3.12/site-packages/supervision/draw/utils.py b/.venv/lib/python3.12/site-packages/supervision/draw/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4de1cf97c7a3600300e53052b23d86522be91b8e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/draw/utils.py
@@ -0,0 +1,550 @@
+import os
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision.draw.color import Color
+from supervision.geometry.core import Point, Rect
+
+
+def draw_line(
+    scene: npt.NDArray[np.uint8],
+    start: Point,
+    end: Point,
+    color: Color = Color.ROBOFLOW,
+    thickness: int = 2,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draws a line on a given scene.
+
+    Args:
+        scene: The scene on which the line will be drawn
+        start: The starting point of the line
+        end: The end point of the line
+        color: The color of the line, defaults to Color.ROBOFLOW
+        thickness: The thickness of the line
+
+    Returns:
+        The scene with the line drawn on it
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_line
+        >>> from supervision.draw.color import Color
+        >>> from supervision.geometry.core import Point
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> scene = draw_line(
+        ...     scene, start=Point(x=10, y=10), end=Point(x=90, y=90), color=Color.RED
+        ... )
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    cv2.line(
+        scene,
+        start.as_xy_int_tuple(),
+        end.as_xy_int_tuple(),
+        color.as_bgr(),
+        thickness=thickness,
+    )
+    return scene
+
+
+def draw_rectangle(
+    scene: npt.NDArray[np.uint8],
+    rect: Rect,
+    color: Color = Color.ROBOFLOW,
+    thickness: int = 2,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draws a rectangle on an image.
+
+    Args:
+        scene: The scene on which the rectangle will be drawn
+        rect: The rectangle to be drawn
+        color: The color of the rectangle
+        thickness: The thickness of the rectangle border
+
+    Returns:
+        The scene with the rectangle drawn on it
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_rectangle
+        >>> from supervision.draw.color import Color
+        >>> from supervision.geometry.core import Rect
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> rect = Rect(x=10, y=10, width=50, height=30)
+        >>> scene = draw_rectangle(scene, rect, color=Color.RED)
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    cv2.rectangle(
+        scene,
+        rect.top_left.as_xy_int_tuple(),
+        rect.bottom_right.as_xy_int_tuple(),
+        color.as_bgr(),
+        thickness=thickness,
+    )
+    return scene
+
+
+def draw_filled_rectangle(
+    scene: npt.NDArray[np.uint8],
+    rect: Rect,
+    color: Color = Color.ROBOFLOW,
+    opacity: float = 1,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draws a filled rectangle on an image.
+
+    Args:
+        scene: The scene on which the rectangle will be drawn
+        rect: The rectangle to be drawn
+        color: The color of the rectangle
+        opacity: The opacity of rectangle when drawn on the scene.
+
+    Returns:
+        The scene with the rectangle drawn on it
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_filled_rectangle
+        >>> from supervision.draw.color import Color
+        >>> from supervision.geometry.core import Rect
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> rect = Rect(x=10, y=10, width=50, height=30)
+        >>> scene = draw_filled_rectangle(scene, rect, color=Color.RED, opacity=0.5)
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    if opacity == 1:
+        cv2.rectangle(
+            scene,
+            rect.top_left.as_xy_int_tuple(),
+            rect.bottom_right.as_xy_int_tuple(),
+            color.as_bgr(),
+            -1,
+        )
+    else:
+        scene_with_annotations = scene.copy()
+        cv2.rectangle(
+            scene_with_annotations,
+            rect.top_left.as_xy_int_tuple(),
+            rect.bottom_right.as_xy_int_tuple(),
+            color.as_bgr(),
+            -1,
+        )
+        cv2.addWeighted(
+            scene_with_annotations, opacity, scene, 1 - opacity, gamma=0, dst=scene
+        )
+
+    return scene
+
+
+def draw_rounded_rectangle(
+    scene: npt.NDArray[np.uint8],
+    rect: Rect,
+    color: Color,
+    border_radius: int,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draws a rounded rectangle on an image.
+
+    Args:
+        scene: The image on which the rounded rectangle will be drawn.
+        rect: The rectangle to be drawn.
+        color: The color of the rounded rectangle.
+        border_radius: The radius of the corner rounding in pixels. Values <= 0
+            (or values clamped to 0 when the rectangle is too small) draw a
+            plain filled rectangle with square corners. Note: previously,
+            a negative value that remained negative after clamping would raise
+            ``cv2.error``; it now draws square corners silently.
+
+    Returns:
+        The image with the rounded rectangle drawn on it.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_rounded_rectangle
+        >>> from supervision.draw.color import Color
+        >>> from supervision.geometry.core import Rect
+        >>> scene = np.zeros((200, 300, 3), dtype=np.uint8)
+        >>> rect = Rect(x=20, y=30, width=120, height=80)
+        >>> scene = draw_rounded_rectangle(scene, rect, Color.RED, border_radius=0)
+        >>> scene.shape
+        (200, 300, 3)
+
+        ```
+    """
+    x1, y1, x2, y2 = rect.as_xyxy_int_tuple()
+    width, height = x2 - x1, y2 - y1
+    border_radius = min(border_radius, min(width, height) // 2)
+
+    if border_radius <= 0:
+        # square corners: a single fill rectangle (the common default), rather
+        # than two rectangles plus four zero-radius corner circles
+        cv2.rectangle(
+            img=scene,
+            pt1=(x1, y1),
+            pt2=(x2, y2),
+            color=color.as_bgr(),
+            thickness=-1,
+        )
+        return scene
+
+    rectangle_coordinates = [
+        ((x1 + border_radius, y1), (x2 - border_radius, y2)),
+        ((x1, y1 + border_radius), (x2, y2 - border_radius)),
+    ]
+    circle_centers = [
+        (x1 + border_radius, y1 + border_radius),
+        (x2 - border_radius, y1 + border_radius),
+        (x1 + border_radius, y2 - border_radius),
+        (x2 - border_radius, y2 - border_radius),
+    ]
+
+    for coordinates in rectangle_coordinates:
+        cv2.rectangle(
+            img=scene,
+            pt1=coordinates[0],
+            pt2=coordinates[1],
+            color=color.as_bgr(),
+            thickness=-1,
+        )
+    for center in circle_centers:
+        cv2.circle(
+            img=scene,
+            center=center,
+            radius=border_radius,
+            color=color.as_bgr(),
+            thickness=-1,
+        )
+    return scene
+
+
+def draw_polygon(
+    scene: npt.NDArray[np.uint8],
+    polygon: npt.NDArray[np.int_],
+    color: Color = Color.ROBOFLOW,
+    thickness: int = 2,
+) -> npt.NDArray[np.uint8]:
+    """Draw a polygon on a scene.
+
+    Args:
+        scene: The scene to draw the polygon on.
+        polygon: The polygon to be drawn, given as a list of vertices.
+        color: The color of the polygon. Defaults to Color.ROBOFLOW.
+        thickness: The thickness of the polygon lines, by default 2.
+
+    Returns:
+        The scene with the polygon drawn on it.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_polygon
+        >>> from supervision.draw.color import Color
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> polygon = np.array([[10, 10], [90, 10], [90, 90], [10, 90]])
+        >>> scene = draw_polygon(scene, polygon, color=Color.RED)
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    cv2.polylines(
+        scene, [polygon], isClosed=True, color=color.as_bgr(), thickness=thickness
+    )
+    return scene
+
+
+def draw_filled_polygon(
+    scene: npt.NDArray[np.uint8],
+    polygon: npt.NDArray[np.int_],
+    color: Color = Color.ROBOFLOW,
+    opacity: float = 1,
+) -> npt.NDArray[np.uint8]:
+    """Draw a filled polygon on a scene.
+
+    Args:
+        scene: The scene to draw the polygon on.
+        polygon: The polygon to be drawn, given as a list of vertices.
+        color: The color of the polygon. Defaults to Color.ROBOFLOW.
+        opacity: The opacity of polygon when drawn on the scene.
+
+    Returns:
+        The scene with the polygon drawn on it.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_filled_polygon
+        >>> from supervision.draw.color import Color
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> polygon = np.array([[10, 10], [90, 10], [90, 90], [10, 90]])
+        >>> scene = draw_filled_polygon(scene, polygon, color=Color.RED, opacity=0.5)
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    if opacity == 1:
+        cv2.fillPoly(scene, [polygon], color=color.as_bgr())
+    else:
+        scene_with_annotations = scene.copy()
+        cv2.fillPoly(scene_with_annotations, [polygon], color=color.as_bgr())
+        cv2.addWeighted(
+            scene_with_annotations, opacity, scene, 1 - opacity, gamma=0, dst=scene
+        )
+
+    return scene
+
+
+def draw_text(
+    scene: npt.NDArray[np.uint8],
+    text: str,
+    text_anchor: Point,
+    text_color: Color = Color.BLACK,
+    text_scale: float = 0.5,
+    text_thickness: int = 1,
+    text_padding: int = 10,
+    text_font: int = cv2.FONT_HERSHEY_SIMPLEX,
+    background_color: Color | None = None,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draw text with background on a scene.
+
+    Args:
+        scene: A numpy ndarray representing the image, typically of shape
+            (H, W, 3) for a color BGR image or (H, W) for grayscale,
+            with dtype uint8.
+        text: The text to be drawn.
+        text_anchor: The anchor point for the text, represented as a
+            Point object with x and y attributes.
+        text_color: The color of the text. Defaults to black.
+        text_scale: The scale of the text. Defaults to 0.5.
+        text_thickness: The thickness of the text. Defaults to 1.
+        text_padding: The amount of padding to add around the text
+            when drawing a rectangle in the background. Defaults to 10.
+        text_font: The font to use for the text.
+            Defaults to cv2.FONT_HERSHEY_SIMPLEX.
+        background_color: The color of the background rectangle,
+            if one is to be drawn. Defaults to None.
+
+    Returns:
+        The input scene with the text drawn on it.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.geometry.core import Point
+        >>> from supervision.draw.utils import draw_text
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> text_anchor = Point(x=50, y=50)
+        >>> scene = draw_text(
+        ...     scene=scene, text="Hello, world!", text_anchor=text_anchor
+        ... )
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+    text_width, text_height = cv2.getTextSize(
+        text=text,
+        fontFace=text_font,
+        fontScale=text_scale,
+        thickness=text_thickness,
+    )[0]
+
+    text_anchor_x, text_anchor_y = text_anchor.as_xy_int_tuple()
+
+    text_rect = Rect(
+        x=text_anchor_x - text_width // 2,
+        y=text_anchor_y - text_height // 2,
+        width=text_width,
+        height=text_height,
+    ).pad(text_padding)
+
+    if background_color is not None:
+        scene = draw_filled_rectangle(
+            scene=scene, rect=text_rect, color=background_color
+        )
+
+    cv2.putText(
+        img=scene,
+        text=text,
+        org=(text_anchor_x - text_width // 2, text_anchor_y + text_height // 2),
+        fontFace=text_font,
+        fontScale=text_scale,
+        color=text_color.as_bgr(),
+        thickness=text_thickness,
+        lineType=cv2.LINE_AA,
+    )
+    return scene
+
+
+def draw_image(
+    scene: npt.NDArray[np.uint8],
+    image: str | npt.NDArray[np.uint8],
+    opacity: float,
+    rect: Rect,
+) -> npt.NDArray[np.uint8]:
+    """
+    Draws an image onto a given scene with specified opacity and dimensions.
+
+    Args:
+        scene: Background image where the new image will be drawn.
+        image: Image to draw, either a file path or an already-loaded image array.
+            A 2-D grayscale image is not accepted, whether it is passed as an array
+            or read from a path; convert it to BGR first, for example with
+            `cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)`. A 16-bit image read from a
+            path is scaled down to the 8 bits of the scene.
+        opacity: Opacity of the image to be drawn.
+        rect: Rectangle specifying where to draw the image.
+
+    Returns:
+        The updated scene.
+
+    Raises:
+        FileNotFoundError: If the image path does not exist.
+        OSError: If the image path exists but cannot be decoded.
+        ValueError: If the image is not 3-D with 3 (BGR) or 4 (BGRA) channels, or
+            for invalid opacity or rectangle dimensions.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.draw.utils import draw_image
+        >>> from supervision.geometry.core import Rect
+        >>> scene = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> image = np.full((40, 40, 3), 255, dtype=np.uint8)
+        >>> rect = Rect(x=10, y=10, width=40, height=40)
+        >>> scene = draw_image(scene, image, opacity=0.8, rect=rect)
+        >>> scene.shape
+        (100, 100, 3)
+
+        ```
+    """
+
+    # Validate and load image
+    if isinstance(image, str):
+        if not os.path.exists(image):
+            raise FileNotFoundError(f"Image path ('{image}') does not exist.")
+        loaded_image = cv2.imread(image, cv2.IMREAD_UNCHANGED)
+        if loaded_image is None:
+            raise OSError(f"Could not decode image path ('{image}').")
+        if loaded_image.dtype == np.uint16:
+            # IMREAD_UNCHANGED keeps a 16-bit PNG at 16 bits, which the blend into
+            # the 8-bit scene saturates to 255; keep the high byte instead.
+            loaded_image = np.clip(np.rint(loaded_image / 256), 0, 255).astype(np.uint8)
+        image_np = cast(npt.NDArray[np.uint8], loaded_image)
+    else:
+        image_np = image
+
+    if image_np.ndim != 3 or image_np.shape[2] not in (3, 4):
+        raise ValueError("Image must have 3 or 4 channels.")
+
+    # Validate opacity
+    if not 0.0 <= opacity <= 1.0:
+        raise ValueError("Opacity must be between 0.0 and 1.0.")
+
+    rect_x = int(rect.x)
+    rect_y = int(rect.y)
+    rect_width = int(rect.width)
+    rect_height = int(rect.height)
+    # Validate rectangle dimensions
+    if (
+        rect_x < 0
+        or rect_y < 0
+        or rect_x + rect_width > scene.shape[1]
+        or rect_y + rect_height > scene.shape[0]
+    ):
+        raise ValueError("Invalid rectangle dimensions.")
+
+    # Resize and isolate alpha channel
+    image_np = cast(
+        npt.NDArray[np.uint8], cv2.resize(image_np, (rect_width, rect_height))
+    )
+    alpha_channel = (
+        image_np[:, :, 3]
+        if image_np.shape[2] == 4
+        else np.ones((rect_height, rect_width), dtype=image_np.dtype) * 255
+    )
+    alpha_scaled = cv2.convertScaleAbs(alpha_channel * opacity)
+
+    # Perform blending
+    scene_roi = scene[rect_y : rect_y + rect_height, rect_x : rect_x + rect_width]
+    alpha_float = alpha_scaled.astype(np.float32) / 255.0
+    blended_roi = cv2.convertScaleAbs(
+        (1 - alpha_float[..., np.newaxis]) * scene_roi
+        + alpha_float[..., np.newaxis] * image_np[:, :, :3]
+    )
+
+    # Update the scene
+    scene[rect_y : rect_y + rect_height, rect_x : rect_x + rect_width] = blended_roi
+
+    return scene
+
+
+def calculate_optimal_text_scale(resolution_wh: tuple[int, int]) -> float:
+    """
+    Calculate optimal font scale based on image resolution. Adjusts font scale
+    proportionally to the smallest dimension of the given image resolution for
+    consistent readability.
+
+    Args:
+        resolution_wh: A tuple of `(width, height)` of the image in pixels.
+
+    Returns:
+        Recommended font scale factor.
+
+    Examples:
+        ```pycon
+        >>> import supervision as sv
+        >>> sv.calculate_optimal_text_scale((1920, 1080))
+        1.08
+        >>> sv.calculate_optimal_text_scale((640, 480))
+        0.48
+
+        ```
+    """
+    return min(resolution_wh) * 1e-3
+
+
+def calculate_optimal_line_thickness(resolution_wh: tuple[int, int]) -> int:
+    """
+    Calculate optimal line thickness based on image resolution. Adjusts the line
+    thickness for readability depending on the smallest dimension of the provided
+    image resolution.
+
+    Args:
+        resolution_wh: A tuple of `(width, height)` of the image in pixels.
+
+    Returns:
+        Recommended line thickness in pixels.
+
+    Examples:
+        ```pycon
+        >>> import supervision as sv
+        >>> sv.calculate_optimal_line_thickness((1920, 1080))
+        4
+        >>> sv.calculate_optimal_line_thickness((640, 480))
+        2
+
+        ```
+    """
+    if min(resolution_wh) < 1080:
+        return 2
+    return 4
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/__init__.py b/.venv/lib/python3.12/site-packages/supervision/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e20a06665e0c83af82484379835147420fa7f248
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67439fe955c88aa1e84c40cc45a409362653eb3d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81f0d5bed84fee2592e6853108e48626afc52c42
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/geometry/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/core.py b/.venv/lib/python3.12/site-packages/supervision/geometry/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f41e9bc30f3743fe5fe635d9428233a98f52a11
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/geometry/core.py
@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from math import sqrt
+
+
+class Position(Enum):
+    """
+    Enum representing the position of an anchor point.
+    """
+
+    CENTER = "CENTER"
+    CENTER_LEFT = "CENTER_LEFT"
+    CENTER_RIGHT = "CENTER_RIGHT"
+    TOP_CENTER = "TOP_CENTER"
+    TOP_LEFT = "TOP_LEFT"
+    TOP_RIGHT = "TOP_RIGHT"
+    BOTTOM_LEFT = "BOTTOM_LEFT"
+    BOTTOM_CENTER = "BOTTOM_CENTER"
+    BOTTOM_RIGHT = "BOTTOM_RIGHT"
+    CENTER_OF_MASS = "CENTER_OF_MASS"
+
+    @classmethod
+    def list(cls) -> list[str]:
+        """Return all position values in their definition order."""
+        return [position.value for position in cls]
+
+
+@dataclass
+class Point:
+    """
+    Represents a point in 2D space.
+
+    Attributes:
+        x: The x-coordinate of the point.
+        y: The y-coordinate of the point.
+
+    Example:
+        ```pycon
+        >>> from supervision.geometry.core import Point
+        >>> point = Point(x=10.0, y=20.0)
+        >>> point.as_xy_int_tuple()
+        (10, 20)
+        >>> point.as_xy_float_tuple()
+        (10.0, 20.0)
+
+        ```
+    """
+
+    x: float
+    y: float
+
+    def as_xy_int_tuple(self) -> tuple[int, int]:
+        """
+        Returns the point as a tuple of integers.
+
+        Returns:
+            The point as (x, y) integers.
+        """
+        return int(self.x), int(self.y)
+
+    def as_xy_float_tuple(self) -> tuple[float, float]:
+        """
+        Returns the point as a tuple of floats.
+
+        Returns:
+            The point as (x, y) floats.
+        """
+        return self.x, self.y
+
+
+@dataclass
+class Vector:
+    """
+    Represents a vector in 2D space, defined by a start and an end point.
+
+    Attributes:
+        start: The starting point of the vector.
+        end: The end point of the vector.
+
+    Example:
+        ```pycon
+        >>> from supervision.geometry.core import Point, Vector
+        >>> start_point = Point(x=0.0, y=0.0)
+        >>> end_point = Point(x=3.0, y=4.0)
+        >>> vector = Vector(start=start_point, end=end_point)
+        >>> vector.magnitude
+        5.0
+        >>> vector.center
+        Point(x=1.5, y=2.0)
+
+        ```
+    """
+
+    start: Point
+    end: Point
+
+    @property
+    def magnitude(self) -> float:
+        """
+        Calculate the magnitude (length) of the vector.
+
+        Returns:
+            The magnitude of the vector.
+        """
+        dx = self.end.x - self.start.x
+        dy = self.end.y - self.start.y
+        return sqrt(dx**2 + dy**2)
+
+    @property
+    def center(self) -> Point:
+        """
+        Calculate the center point of the vector.
+
+        Returns:
+            The center point of the vector.
+        """
+        return Point(
+            x=(self.start.x + self.end.x) / 2,
+            y=(self.start.y + self.end.y) / 2,
+        )
+
+    def cross_product(self, point: Point) -> float:
+        """
+        Calculate the 2D cross product (also known as the vector product or outer
+        product) of the vector and a point, treated as vectors in 2D space.
+
+        Args:
+            point: The point to be evaluated, treated as the endpoint of a
+                vector originating from the 'start' of the main vector.
+
+        Returns:
+            The scalar value of the cross product. It is positive if 'point'
+                lies to the left of the vector (when moving from 'start' to 'end'),
+                negative if it lies to the right, and 0 if it is collinear with the
+                vector.
+        """
+        dx_vector = self.end.x - self.start.x
+        dy_vector = self.end.y - self.start.y
+        dx_point = point.x - self.start.x
+        dy_point = point.y - self.start.y
+        return (dx_vector * dy_point) - (dy_vector * dx_point)
+
+
+@dataclass
+class Rect:
+    """
+    Represents a rectangle in 2D space.
+
+    Attributes:
+        x: The x-coordinate of the top-left corner of the rectangle.
+        y: The y-coordinate of the top-left corner of the rectangle.
+        width: The width of the rectangle.
+        height: The height of the rectangle.
+
+    Example:
+        ```pycon
+        >>> from supervision.geometry.core import Rect
+        >>> rect = Rect(x=10.0, y=20.0, width=30.0, height=40.0)
+        >>> rect.top_left
+        Point(x=10.0, y=20.0)
+        >>> rect.bottom_right
+        Point(x=40.0, y=60.0)
+        >>> rect.as_xyxy_int_tuple()
+        (10, 20, 40, 60)
+
+        ```
+    """
+
+    x: float
+    y: float
+    width: float
+    height: float
+
+    @classmethod
+    def from_xyxy(cls, xyxy: tuple[float, float, float, float]) -> Rect:
+        """Create a rectangle from `(x_min, y_min, x_max, y_max)` coordinates."""
+        x1, y1, x2, y2 = xyxy
+        return cls(x=x1, y=y1, width=x2 - x1, height=y2 - y1)
+
+    @property
+    def top_left(self) -> Point:
+        """Return the top-left corner as a `Point`."""
+        return Point(x=self.x, y=self.y)
+
+    @property
+    def bottom_right(self) -> Point:
+        """Return the bottom-right corner as a `Point`."""
+        return Point(x=self.x + self.width, y=self.y + self.height)
+
+    def pad(self, padding: int) -> Rect:
+        """Return a rectangle expanded by `padding` pixels on every side."""
+        return Rect(
+            x=self.x - padding,
+            y=self.y - padding,
+            width=self.width + 2 * padding,
+            height=self.height + 2 * padding,
+        )
+
+    def as_xyxy_int_tuple(self) -> tuple[int, int, int, int]:
+        """Return `(x_min, y_min, x_max, y_max)` coordinates as integers."""
+        return (
+            int(self.x),
+            int(self.y),
+            int(self.x + self.width),
+            int(self.y + self.height),
+        )
diff --git a/.venv/lib/python3.12/site-packages/supervision/geometry/utils.py b/.venv/lib/python3.12/site-packages/supervision/geometry/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a6db11efd0396989ba363cc3e4ff2eb24567701
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/geometry/utils.py
@@ -0,0 +1,56 @@
+import numpy as np
+import numpy.typing as npt
+
+from supervision.geometry.core import Point
+
+
+def get_polygon_center(polygon: npt.NDArray[np.number]) -> Point:
+    """
+    Calculate the center of a polygon. The center is calculated as the center
+    of the solid figure formed by the points of the polygon
+
+    Args:
+        polygon: A 2-dimensional numpy ndarray representing the vertices of the
+            polygon.
+
+    Returns:
+        The center of the polygon, represented as a Point object with x and y
+            attributes.
+
+    Raises:
+        ValueError: If the polygon has no vertices.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> polygon = np.array([[0, 0], [0, 2], [2, 2], [2, 0]])
+        >>> center = sv.get_polygon_center(polygon=polygon)
+        >>> float(center.x)
+        1.0
+        >>> float(center.y)
+        1.0
+
+        ```
+    """
+
+    # This is one of the 3 candidate algorithms considered for centroid calculation.
+    # For a more detailed discussion, see PR #1084 and commit eb33176
+
+    if len(polygon) == 0:
+        raise ValueError("Polygon must have at least one vertex.")
+
+    origin = polygon[0].astype(np.float64, copy=False)
+    polygon = polygon.astype(np.float64, copy=False) - origin
+    shift_polygon = np.roll(polygon, -1, axis=0)
+    signed_areas = (
+        polygon[..., 0] * shift_polygon[..., 1]
+        - polygon[..., 1] * shift_polygon[..., 0]
+    ) / 2
+    if signed_areas.sum() == 0:
+        center = (np.mean(polygon, axis=0) + origin).round()
+        return Point(x=center[0], y=center[1])
+    centroids = (polygon + shift_polygon) / 3.0
+    center = (np.average(centroids, axis=0, weights=signed_areas) + origin).round()
+
+    return Point(x=center[0], y=center[1])
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/__init__.py b/.venv/lib/python3.12/site-packages/supervision/key_points/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..535df136293d660fd48cb8039534d17fb87cfba4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/annotators.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/annotators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e96d7ae1d1b74e9d597027981d4e8a92beb69989
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/annotators.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5100cc1b50df867c72d17ff0c7dd39303ce8442
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/skeletons.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/skeletons.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..197d70585240ab1490fee77fb4fb6c6461ec96e3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/key_points/__pycache__/skeletons.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/annotators.py b/.venv/lib/python3.12/site-packages/supervision/key_points/annotators.py
new file mode 100644
index 0000000000000000000000000000000000000000..b61e87212d908005ed5066599ca1c640cb3db44b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/key_points/annotators.py
@@ -0,0 +1,1016 @@
+from abc import ABC, abstractmethod
+from collections.abc import Sequence
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision import _cv2 as cv2
+from supervision.detection.utils.boxes import pad_boxes, spread_out_boxes
+from supervision.draw.base import ImageType
+from supervision.draw.color import Color
+from supervision.draw.utils import draw_rounded_rectangle
+from supervision.geometry.core import Rect
+from supervision.key_points.core import KeyPoints
+from supervision.key_points.skeletons import SKELETONS_BY_VERTEX_COUNT
+from supervision.utils.conversion import ensure_cv2_image_for_class_method
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+
+def _validate_edge_indices(edge: tuple[int, int], vertex_count: int) -> tuple[int, int]:
+    """Validate 1-based skeleton edges and return zero-based vertex indexes."""
+    vertex_a, vertex_b = edge
+    if not (1 <= vertex_a <= vertex_count and 1 <= vertex_b <= vertex_count):
+        raise ValueError(
+            "Edge indices must use the 1-based convention and be within the "
+            f"available keypoint range [1, {vertex_count}], got {edge}."
+        )
+    # Public skeleton definitions are 1-based; keypoint arrays are zero-based.
+    return vertex_a - 1, vertex_b - 1
+
+
+def _has_finite_coordinates(point: npt.ArrayLike) -> bool:
+    """Report whether a keypoint carries coordinates that can be rasterized.
+
+    Pose estimators mark an undetected or occluded keypoint with `NaN` rather than
+    dropping it, and `KeyPoints` accepts those values, so annotators receive them
+    routinely. Every drawing helper below converts a coordinate to `int`, which
+    raises on `NaN` and on an infinity, and `np.allclose(point, 0)` does not catch
+    either. `KeyPoints.as_detections` already excludes non-finite coordinates; this
+    keeps the annotators on the same rule instead of aborting the whole frame.
+    """
+    return bool(np.isfinite(point).all())
+
+
+class BaseKeyPointAnnotator(ABC):
+    @abstractmethod
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        pass
+
+
+class VertexAnnotator(BaseKeyPointAnnotator):
+    """
+    A class that specializes in drawing skeleton vertices on images. It uses
+    specified key points to determine the locations where the vertices should be
+    drawn.
+    """
+
+    def __init__(
+        self,
+        color: Color = Color.ROBOFLOW,
+        radius: int = 4,
+    ) -> None:
+        """
+        Args:
+            color: The color to use for annotating key points.
+            radius: The radius of the circles used to represent the key points.
+        """
+        self.color = color
+        self.radius = radius
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        """Annotates the given scene with skeleton vertices based on the provided key
+        points. It draws circles at each key point location. Anchors marked as not
+        visible via ``key_points.visible``, and anchors whose coordinates are not
+        finite, are skipped.
+
+        Args:
+            scene: The image where skeleton vertices will be drawn. `ImageType` is a
+                flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`.
+            key_points: A collection of key points where each key point consists of x
+                and y coordinates.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ... )
+            >>> annotator = sv.VertexAnnotator(
+            ...     color=sv.Color.ROBOFLOW, radius=10
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+        """
+        if len(key_points) == 0:
+            return scene
+
+        for detection_index, xy in enumerate(key_points.xy):
+            for point_index, (x, y) in enumerate(xy):
+                if np.allclose((x, y), 0) or not _has_finite_coordinates((x, y)):
+                    continue
+                if (
+                    key_points.visible is not None
+                    and not key_points.visible[detection_index, point_index]
+                ):
+                    continue
+                cv2.circle(
+                    img=scene,
+                    center=(int(x), int(y)),
+                    radius=self.radius,
+                    color=self.color.as_bgr(),
+                    thickness=-1,
+                )
+
+        return scene
+
+
+class EdgeAnnotator(BaseKeyPointAnnotator):
+    """
+    A class that specializes in drawing skeleton edges on images using specified key
+    points. It connects key points with lines to form the skeleton structure.
+    """
+
+    def __init__(
+        self,
+        color: Color = Color.ROBOFLOW,
+        thickness: int = 2,
+        edges: (
+            Sequence[tuple[int, int]] | dict[int, Sequence[tuple[int, int]]] | None
+        ) = None,
+    ) -> None:
+        """
+        Args:
+            color: The color to use for the edges.
+            thickness: The thickness of the edges.
+            edges: The edges to draw. If set to ``None``, will attempt to
+                auto-detect the skeleton by vertex count. A
+                ``Sequence[tuple[int, int]]`` applies a single skeleton to
+                every instance. A ``dict[int, Sequence[tuple[int, int]]]``
+                maps ``class_id`` to skeleton edges, enabling correct
+                rendering for datasets with multiple skeleton types.
+        """
+        self.color = color
+        self.thickness = thickness
+        self.edges = edges
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        """Annotates the given scene by drawing lines between specified key points to
+        form edges. Edges where either endpoint is marked as not visible via
+        ``key_points.visible``, or where either endpoint has a non-finite coordinate,
+        are skipped.
+
+        Args:
+            scene: The image where skeleton edges will be drawn. `ImageType` is a
+                flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`.
+            key_points: A collection of key points where each key point consists of x
+                and y coordinates.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            Single-skeleton example:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ... )
+            >>> annotator = sv.EdgeAnnotator(
+            ...     color=sv.Color.ROBOFLOW,
+            ...     thickness=3,
+            ...     edges=[(1, 2), (1, 3)],
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+
+            Multi-skeleton example with per-class edges:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]],
+            ...          [[700, 300], [650, 500], [0, 0]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0, 1]),
+            ...     visible=np.array(
+            ...         [[True, True, True],
+            ...          [True, True, False]],
+            ...     ),
+            ... )
+            >>> annotator = sv.EdgeAnnotator(
+            ...     color=sv.Color.ROBOFLOW,
+            ...     thickness=3,
+            ...     edges={0: [(1, 2), (1, 3)], 1: [(1, 2)]},
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+        """
+        if len(key_points) == 0:
+            return scene
+
+        for detection_index, xy in enumerate(key_points.xy):
+            if isinstance(self.edges, dict):
+                class_id = (
+                    int(key_points.class_id[detection_index])
+                    if key_points.class_id is not None
+                    else None
+                )
+                if class_id is None:
+                    raise ValueError(
+                        "edges is a dict but class_id is None; "
+                        "KeyPoints must have class_id set."
+                    )
+                if class_id not in self.edges:
+                    raise ValueError(f"No edges defined for class_id={class_id}.")
+                edges = self.edges[class_id]
+            elif self.edges:
+                edges = self.edges
+            else:
+                _looked_up = SKELETONS_BY_VERTEX_COUNT.get(len(xy))
+                if not _looked_up:
+                    logger.warning("No skeleton found with %d vertices", len(xy))
+                    continue
+                edges = _looked_up
+
+            for edge in edges:
+                idx_a, idx_b = _validate_edge_indices(edge=edge, vertex_count=len(xy))
+                xy_a = xy[idx_a]
+                xy_b = xy[idx_b]
+                if np.allclose(xy_a, 0) or np.allclose(xy_b, 0):
+                    continue
+                if not _has_finite_coordinates(xy_a) or not _has_finite_coordinates(
+                    xy_b
+                ):
+                    continue
+                if key_points.visible is not None:
+                    if (
+                        not key_points.visible[detection_index, idx_a]
+                        or not key_points.visible[detection_index, idx_b]
+                    ):
+                        continue
+
+                cv2.line(
+                    img=scene,
+                    pt1=(int(xy_a[0]), int(xy_a[1])),
+                    pt2=(int(xy_b[0]), int(xy_b[1])),
+                    color=self.color.as_bgr(),
+                    thickness=self.thickness,
+                )
+
+        return scene
+
+
+class _BaseVertexEllipseAnnotator(BaseKeyPointAnnotator):
+    """Private base for ellipse-based keypoint annotators.
+
+    Handles sigma/color validation, sorting, covariance extraction and
+    eigendecomposition shared by all VertexEllipse* variants.
+    """
+
+    def __init__(
+        self,
+        sigma: float | Sequence[float] = (1.0, 2.0, 3.0),
+        color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED),
+        max_axis: float | None = None,
+    ) -> None:
+        sigma_seq: Sequence[float] = (
+            (sigma,) if isinstance(sigma, (int, float)) else sigma
+        )
+        color_seq: Sequence[Color] = (color,) if isinstance(color, Color) else color
+
+        if len(sigma_seq) == 0:
+            raise ValueError("sigma must contain at least one value")
+        if any(s <= 0 for s in sigma_seq):
+            raise ValueError("All sigma values must be positive")
+        if max_axis is not None and max_axis <= 0:
+            raise ValueError("max_axis must be positive when provided")
+        if len(color_seq) != len(sigma_seq):
+            raise ValueError(
+                f"color length ({len(color_seq)}) must match "
+                f"sigma length ({len(sigma_seq)})"
+            )
+
+        sorted_indices = sorted(
+            range(len(sigma_seq)), key=lambda i: sigma_seq[i], reverse=True
+        )
+        self.sigma = [sigma_seq[i] for i in sorted_indices]
+        self.color = [color_seq[i] for i in sorted_indices]
+        self.max_axis = max_axis
+
+    def _get_covariances(self, key_points: KeyPoints) -> npt.NDArray[np.float32]:
+        covariances = key_points.data.get("covariance")
+        if covariances is None:
+            raise ValueError(
+                "key_points.data must contain 'covariance' with shape (N, K, 2, 2)."
+            )
+        covariances_array = cast(
+            npt.NDArray[np.float32], np.asarray(covariances, dtype=np.float32)
+        )
+        expected_shape = (*key_points.xy.shape[:2], 2, 2)
+        if covariances_array.shape != expected_shape:
+            raise ValueError(
+                f"Expected covariance shape {expected_shape}, "
+                f"got {covariances_array.shape}."
+            )
+        return covariances_array
+
+    def _decompose_covariance(
+        self, covariance: npt.NDArray[np.float32]
+    ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]] | None:
+        """Eigendecompose a 2x2 covariance, returning sorted (eigenvalues, vectors)."""
+        if not np.isfinite(covariance).all():
+            return None
+        try:
+            eigenvalues, eigenvectors = np.linalg.eigh(covariance.astype(np.float64))
+        except np.linalg.LinAlgError:
+            return None
+        if not np.isfinite(eigenvalues).all() or np.any(eigenvalues <= 0):
+            return None
+        order = np.argsort(eigenvalues)[::-1]
+        return eigenvalues[order], eigenvectors[:, order]
+
+    def _iter_ellipse_params(
+        self, key_points: KeyPoints
+    ) -> list[list[tuple[tuple[int, int], tuple[int, int], float, float, Color]]]:
+        """Return ellipse params grouped by sigma level (outermost first)."""
+        covariances = self._get_covariances(key_points)
+        levels: list[
+            list[tuple[tuple[int, int], tuple[int, int], float, float, Color]]
+        ] = [[] for _ in self.sigma]
+        for detection_index, xy in enumerate(key_points.xy):
+            for point_index, (x, y) in enumerate(xy):
+                if np.allclose((x, y), 0) or not _has_finite_coordinates((x, y)):
+                    continue
+                if (
+                    key_points.visible is not None
+                    and not key_points.visible[detection_index, point_index]
+                ):
+                    continue
+                covariance = covariances[detection_index, point_index]
+                decomposition = self._decompose_covariance(covariance)
+                if decomposition is None:
+                    continue
+                eigenvalues, eigenvectors = decomposition
+                angle = float(
+                    np.degrees(np.arctan2(eigenvectors[1, 0], eigenvectors[0, 0]))
+                )
+                center = (round(x), round(y))
+                for level_idx, (sigma, color) in enumerate(zip(self.sigma, self.color)):
+                    axes = sigma * np.sqrt(eigenvalues)
+                    if self.max_axis is not None:
+                        axes = np.minimum(axes, self.max_axis)
+                    axis_lengths = (
+                        max(1, round(axes[0])),
+                        max(1, round(axes[1])),
+                    )
+                    levels[level_idx].append(
+                        (center, axis_lengths, angle, sigma, color)
+                    )
+        return levels
+
+
+class VertexEllipseAreaAnnotator(_BaseVertexEllipseAnnotator):
+    """
+    Draws filled semi-transparent covariance ellipses at multiple sigma levels
+    around each keypoint, each ring in a different color.  This produces a
+    bullseye-like uncertainty visualization where inner rings represent higher
+    probability density.
+
+    !!! warning
+
+        This annotator uses `key_points.data["covariance"]` with shape
+        `(N, K, 2, 2)` in pixel coordinates.
+    """
+
+    def __init__(
+        self,
+        sigma: float | Sequence[float] = (1.0, 2.0, 3.0),
+        color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED),
+        opacity: float = 0.4,
+        max_axis: float | None = None,
+    ) -> None:
+        """
+        Args:
+            sigma: Sigma multipliers for each ring, drawn from outermost to
+                innermost.  Accepts a single float or a sequence of floats.
+                Defaults to ``(1.0, 2.0, 3.0)``.
+            color: The color for each sigma level.  Accepts a single
+                ``Color`` or a sequence of colors (one per sigma level).
+                Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``.
+            opacity: Opacity of the overlay mask. Must be between ``0`` and
+                ``1``.
+            max_axis: Optional cap for ellipse semi-axis lengths in pixels.
+        """
+        super().__init__(sigma=sigma, color=color, max_axis=max_axis)
+        self.opacity = opacity
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        """Draws filled semi-transparent covariance ellipses around each keypoint.
+        Keypoints marked as not visible via ``key_points.visible``, and keypoints whose
+        coordinates are not finite, are skipped.
+
+        Args:
+            scene: The image to annotate. ``ImageType`` accepts either
+                ``numpy.ndarray`` or ``PIL.Image.Image``.
+            key_points: Key points with covariance data in
+                ``key_points.data["covariance"]``.
+
+        Returns:
+            The annotated image, matching the type of ``scene``.
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ...     data={
+            ...         "covariance": np.array(
+            ...             [[[[800, 0], [0, 400]],
+            ...               [[400, 0], [0, 800]],
+            ...               [[600, 0], [0, 600]]]],
+            ...             dtype=np.float32,
+            ...         )
+            ...     },
+            ... )
+            >>> annotator = sv.VertexEllipseAreaAnnotator(
+            ...     sigma=[1.0, 2.0],
+            ...     color=[sv.Color.GREEN, sv.Color.RED],
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+        """
+        if len(key_points) == 0:
+            return scene
+
+        overlay = scene.copy()
+        for level in self._iter_ellipse_params(key_points):
+            for center, axis_lengths, angle, _sigma, color in level:
+                cv2.ellipse(
+                    img=overlay,
+                    center=center,
+                    axes=axis_lengths,
+                    angle=angle,
+                    startAngle=0,
+                    endAngle=360,
+                    color=color.as_bgr(),
+                    thickness=-1,
+                    lineType=cv2.LINE_AA,
+                )
+
+        cv2.addWeighted(overlay, self.opacity, scene, 1 - self.opacity, 0, dst=scene)
+        return scene
+
+
+class VertexEllipseOutlineAnnotator(_BaseVertexEllipseAnnotator):
+    """
+    Draws stroke-only concentric covariance ellipse rings at multiple sigma
+    levels around each keypoint.
+
+    !!! warning
+
+        This annotator uses `key_points.data["covariance"]` with shape
+        `(N, K, 2, 2)` in pixel coordinates.
+    """
+
+    def __init__(
+        self,
+        sigma: float | Sequence[float] = (1.0, 2.0, 3.0),
+        color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED),
+        thickness: int = 2,
+        max_axis: float | None = None,
+    ) -> None:
+        """
+        Args:
+            sigma: Sigma multipliers for each ring, drawn from outermost to
+                innermost.  Accepts a single float or a sequence of floats.
+                Defaults to ``(1.0, 2.0, 3.0)``.
+            color: The color for each sigma level.  Accepts a single
+                ``Color`` or a sequence of colors (one per sigma level).
+                Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``.
+            thickness: Line thickness of the ellipse outlines.
+            max_axis: Optional cap for ellipse semi-axis lengths in pixels.
+        """
+        super().__init__(sigma=sigma, color=color, max_axis=max_axis)
+        self.thickness = thickness
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        """Draws stroke-only covariance ellipse outlines around each keypoint. Keypoints
+        marked as not visible via ``key_points.visible``, and keypoints whose
+        coordinates are not finite, are skipped.
+
+        Args:
+            scene: The image to annotate. ``ImageType`` accepts either
+                ``numpy.ndarray`` or ``PIL.Image.Image``.
+            key_points: Key points with covariance data in
+                ``key_points.data["covariance"]``.
+
+        Returns:
+            The annotated image, matching the type of ``scene``.
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ...     data={
+            ...         "covariance": np.array(
+            ...             [[[[800, 0], [0, 400]],
+            ...               [[400, 0], [0, 800]],
+            ...               [[600, 0], [0, 600]]]],
+            ...             dtype=np.float32,
+            ...         )
+            ...     },
+            ... )
+            >>> annotator = sv.VertexEllipseOutlineAnnotator(
+            ...     sigma=[1.0, 2.0],
+            ...     color=[sv.Color.GREEN, sv.Color.RED],
+            ...     thickness=2,
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+        """
+        if len(key_points) == 0:
+            return scene
+
+        for level in self._iter_ellipse_params(key_points):
+            for center, axis_lengths, angle, _sigma, color in level:
+                cv2.ellipse(
+                    img=scene,
+                    center=center,
+                    axes=axis_lengths,
+                    angle=angle,
+                    startAngle=0,
+                    endAngle=360,
+                    color=color.as_bgr(),
+                    thickness=self.thickness,
+                    lineType=cv2.LINE_AA,
+                )
+
+        return scene
+
+
+class VertexEllipseHaloAnnotator(_BaseVertexEllipseAnnotator):
+    """
+    Draws filled covariance ellipses with a radial fade: full opacity at the
+    center, smoothly falling off to zero at the ellipse boundary.  The falloff
+    follows a power curve controlled by ``decay``, producing a soft glow that
+    is strongest near the keypoint.
+
+    !!! warning
+
+        This annotator uses `key_points.data["covariance"]` with shape
+        `(N, K, 2, 2)` in pixel coordinates.
+    """
+
+    _DECAY: float = 2.0
+
+    def __init__(
+        self,
+        sigma: float | Sequence[float] = (1.0, 2.0, 3.0),
+        color: Color | Sequence[Color] = (Color.GREEN, Color.YELLOW, Color.RED),
+        opacity: float = 0.6,
+        max_axis: float | None = None,
+    ) -> None:
+        """
+        Args:
+            sigma: Sigma multipliers for each ring, drawn from outermost to
+                innermost.  Accepts a single float or a sequence of floats.
+                Defaults to ``(1.0, 2.0, 3.0)``.
+            color: The color for each sigma level.  Accepts a single
+                ``Color`` or a sequence of colors (one per sigma level).
+                Defaults to ``(Color.GREEN, Color.YELLOW, Color.RED)``.
+            opacity: Peak opacity at the ellipse center. Must be between ``0``
+                and ``1``.
+            max_axis: Optional cap for ellipse semi-axis lengths in pixels.
+        """
+        super().__init__(sigma=sigma, color=color, max_axis=max_axis)
+        self.opacity = opacity
+
+    @ensure_cv2_image_for_class_method
+    def annotate(self, scene: ImageType, key_points: KeyPoints) -> ImageType:
+        """Draws radially-fading covariance ellipses around each keypoint. Keypoints
+        marked as not visible via ``key_points.visible``, and keypoints whose
+        coordinates are not finite, are skipped.
+
+        Args:
+            scene: The image to annotate. ``ImageType`` accepts either
+                ``numpy.ndarray`` or ``PIL.Image.Image``.
+            key_points: Key points with covariance data in
+                ``key_points.data["covariance"]``.
+
+        Returns:
+            The annotated image, matching the type of ``scene``.
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ...     data={
+            ...         "covariance": np.array(
+            ...             [[[[800, 0], [0, 400]],
+            ...               [[400, 0], [0, 800]],
+            ...               [[600, 0], [0, 600]]]],
+            ...             dtype=np.float32,
+            ...         )
+            ...     },
+            ... )
+            >>> annotator = sv.VertexEllipseHaloAnnotator(
+            ...     sigma=[1.0, 2.0],
+            ...     color=[sv.Color.GREEN, sv.Color.RED],
+            ... )
+            >>> result = annotator.annotate(image.copy(), key_points)
+
+            ```
+        """
+        if len(key_points) == 0:
+            return scene
+
+        h, w = scene.shape[:2]
+        composite: npt.NDArray[np.float32] = scene.astype(np.float32)
+
+        for level in self._iter_ellipse_params(key_points):
+            for center, axis_lengths, angle, _sigma, color in level:
+                ax, ay = axis_lengths
+                if ax == 0 or ay == 0:
+                    continue
+
+                pad = 2
+                roi_half_w = ax + pad
+                roi_half_h = ay + pad
+                cx, cy = center
+
+                x_min = max(cx - roi_half_w, 0)
+                x_max = min(cx + roi_half_w, w)
+                y_min = max(cy - roi_half_h, 0)
+                y_max = min(cy + roi_half_h, h)
+                if x_min >= x_max or y_min >= y_max:
+                    continue
+
+                ys = np.arange(y_min, y_max, dtype=np.float32) - cy
+                xs = np.arange(x_min, x_max, dtype=np.float32) - cx
+                grid_x, grid_y = np.meshgrid(xs, ys)
+
+                angle_rad = np.radians(-angle)
+                cos_a = np.cos(angle_rad)
+                sin_a = np.sin(angle_rad)
+                rx = grid_x * cos_a - grid_y * sin_a
+                ry = grid_x * sin_a + grid_y * cos_a
+
+                dist_sq = (rx / ax) ** 2 + (ry / ay) ** 2
+                inside = dist_sq <= 1.0
+
+                falloff = np.zeros_like(dist_sq)
+                falloff[inside] = (1.0 - dist_sq[inside]) ** self._DECAY
+
+                scaled_alpha = falloff * self.opacity
+
+                bgr = np.array(color.as_bgr(), dtype=np.float32)
+                roi = composite[y_min:y_max, x_min:x_max]
+                alpha_3 = scaled_alpha[:, :, np.newaxis]
+                roi[:] = roi * (1 - alpha_3) + bgr * alpha_3
+
+        np.copyto(scene, composite.astype(np.uint8))
+        return scene
+
+
+VertexEllipseAnnotator = VertexEllipseAreaAnnotator
+
+
+class VertexLabelAnnotator:
+    """
+    A class that draws labels of skeleton vertices on images. It uses specified key
+    points to determine the locations where the vertices should be drawn.
+    """
+
+    def __init__(
+        self,
+        color: Color | list[Color] = Color.ROBOFLOW,
+        text_color: Color | list[Color] = Color.WHITE,
+        text_scale: float = 0.5,
+        text_thickness: int = 1,
+        text_padding: int = 10,
+        border_radius: int = 0,
+        smart_position: bool = False,
+    ):
+        """
+        Args:
+            color: The color to use for each keypoint label. If a list is
+                provided, the colors will be used in order for each keypoint.
+            text_color: The color to use for the labels. If a list is
+                provided, the colors will be used in order for each keypoint.
+            text_scale: The scale of the text.
+            text_thickness: The thickness of the text.
+            text_padding: The padding around the text.
+            border_radius: The radius of the rounded corners of the boxes.
+                Set to a high value to produce circles.
+            smart_position: Spread out the labels to avoid overlap.
+        """
+        self.border_radius: int = border_radius
+        self.color: Color | list[Color] = color
+        self.text_color: Color | list[Color] = text_color
+        self.text_scale: float = text_scale
+        self.text_thickness: int = text_thickness
+        self.text_padding: int = text_padding
+        self.smart_position = smart_position
+
+    @ensure_cv2_image_for_class_method
+    def annotate(
+        self,
+        scene: ImageType,
+        key_points: KeyPoints,
+        labels: list[str] | dict[int, list[str]] | None = None,
+    ) -> ImageType:
+        """Draws labels at skeleton vertex positions on the image. Vertices marked not
+        visible via ``key_points.visible``, and vertices whose coordinates are not
+        finite, are skipped.
+
+        Args:
+            scene: The image where vertex labels will be drawn. `ImageType` is a
+                flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`.
+            key_points: A collection of key points where each key point consists of x
+                and y coordinates.
+            labels: Labels to display at each keypoint. If ``None``, keypoint
+                indices are used. A ``list[str]`` applies the same labels to
+                every instance. A ``dict[int, list[str]]`` maps ``class_id``
+                to per-class label lists, enabling correct labeling for
+                datasets with multiple skeleton types.
+
+        Returns:
+            The annotated image, matching the type of `scene` (`numpy.ndarray`
+                or `PIL.Image.Image`)
+
+        Raises:
+            TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+        Example:
+            Single-skeleton example:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0]),
+            ...     visible=np.array([[True, True, True]]),
+            ... )
+            >>> annotator = sv.VertexLabelAnnotator(
+            ...     color=sv.Color.ROBOFLOW,
+            ...     text_color=sv.Color.WHITE,
+            ...     border_radius=5,
+            ... )
+            >>> result = annotator.annotate(
+            ...     scene=image.copy(),
+            ...     key_points=key_points,
+            ...     labels=["head", "L-foot", "R-foot"],
+            ... )
+
+            ```
+
+            Multi-skeleton example with per-class labels:
+
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> image = np.zeros((800, 800, 3), dtype=np.uint8)
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array(
+            ...         [[[400, 200], [300, 500], [500, 500]],
+            ...          [[700, 300], [650, 500], [0, 0]]],
+            ...         dtype=np.float32,
+            ...     ),
+            ...     class_id=np.array([0, 1]),
+            ...     visible=np.array(
+            ...         [[True, True, True],
+            ...          [True, True, False]],
+            ...     ),
+            ... )
+            >>> annotator = sv.VertexLabelAnnotator(
+            ...     color=sv.Color.ROBOFLOW,
+            ...     text_color=sv.Color.WHITE,
+            ...     border_radius=5,
+            ... )
+            >>> result = annotator.annotate(
+            ...     scene=image.copy(),
+            ...     key_points=key_points,
+            ...     labels={
+            ...         0: ["head", "L-foot", "R-foot"],
+            ...         1: ["top", "bottom", "pad"],
+            ...     },
+            ... )
+
+            ```
+        """
+        font = cv2.FONT_HERSHEY_SIMPLEX
+
+        skeletons_count, points_count, _ = key_points.xy.shape
+        if skeletons_count == 0:
+            return scene
+
+        all_anchors: list[tuple[int, int]] = []
+        all_labels: list[str] = []
+        all_colors: list[Color] = []
+        all_text_colors: list[Color] = []
+
+        for i in range(skeletons_count):
+            xy = key_points.xy[i]
+
+            class_id = (
+                int(key_points.class_id[i]) if key_points.class_id is not None else None
+            )
+            instance_labels = self._resolve_labels(labels, points_count, class_id)
+            instance_colors = self._resolve_color_list(self.color, points_count)
+            instance_text_colors = self._resolve_color_list(
+                self.text_color, points_count
+            )
+
+            for j in range(points_count):
+                if not _has_finite_coordinates(xy[j]):
+                    continue
+                if key_points.visible is not None:
+                    if not key_points.visible[i, j]:
+                        continue
+                elif np.allclose(xy[j], 0):
+                    continue
+
+                anchor = (int(xy[j][0]), int(xy[j][1]))
+                all_anchors.append(anchor)
+                all_labels.append(instance_labels[j])
+                all_colors.append(instance_colors[j])
+                all_text_colors.append(instance_text_colors[j])
+
+        if not all_anchors:
+            return scene
+
+        xyxy = np.array(
+            [
+                self.get_text_bounding_box(
+                    text=label,
+                    font=font,
+                    text_scale=self.text_scale,
+                    text_thickness=self.text_thickness,
+                    center_coordinates=anchor,
+                )
+                for anchor, label in zip(all_anchors, all_labels)
+            ]
+        )
+        xyxy_padded = pad_boxes(xyxy=xyxy, px=self.text_padding)
+
+        if self.smart_position:
+            xyxy_padded = spread_out_boxes(xyxy_padded)
+            xyxy = pad_boxes(xyxy=xyxy_padded, px=-self.text_padding)
+
+        for text, color, text_color, box, box_padded in zip(
+            all_labels, all_colors, all_text_colors, xyxy, xyxy_padded
+        ):
+            draw_rounded_rectangle(
+                scene=scene,
+                rect=Rect.from_xyxy(box_padded),
+                color=color,
+                border_radius=self.border_radius,
+            )
+            cv2.putText(
+                img=scene,
+                text=text,
+                org=(box[0], box[3]),
+                fontFace=font,
+                fontScale=self.text_scale,
+                color=text_color.as_bgr(),
+                thickness=self.text_thickness,
+                lineType=cv2.LINE_AA,
+            )
+
+        return scene
+
+    @staticmethod
+    def get_text_bounding_box(
+        text: str,
+        font: int,
+        text_scale: float,
+        text_thickness: int,
+        center_coordinates: tuple[int, int],
+    ) -> tuple[int, int, int, int]:
+        text_w, text_h = cv2.getTextSize(
+            text=text,
+            fontFace=font,
+            fontScale=text_scale,
+            thickness=text_thickness,
+        )[0]
+        center_x, center_y = center_coordinates
+        return (
+            center_x - text_w // 2,
+            center_y - text_h // 2,
+            center_x + text_w // 2,
+            center_y + text_h // 2,
+        )
+
+    @staticmethod
+    def _resolve_labels(
+        labels: list[str] | dict[int, list[str]] | None,
+        points_count: int,
+        class_id: int | None = None,
+    ) -> list[str]:
+        """Return the label list for a single instance."""
+        if labels is None:
+            return [str(j) for j in range(points_count)]
+
+        resolved: list[str]
+        if isinstance(labels, dict):
+            if class_id is None:
+                raise ValueError(
+                    "labels is a dict but class_id is None; "
+                    "KeyPoints must have class_id set."
+                )
+            if class_id not in labels:
+                raise ValueError(f"No labels defined for class_id={class_id}.")
+            resolved = labels[class_id]
+        else:
+            resolved = labels
+
+        if len(resolved) != points_count:
+            raise ValueError(
+                f"Number of labels ({len(resolved)}) must match "
+                f"number of key points ({points_count})."
+            )
+        return resolved
+
+    @staticmethod
+    def _resolve_color_list(
+        colors: Color | list[Color],
+        points_count: int,
+    ) -> list[Color]:
+        """Return a per-keypoint color list for a single instance."""
+        if isinstance(colors, list):
+            if len(colors) != points_count:
+                raise ValueError(
+                    f"Number of colors ({len(colors)}) must match "
+                    f"number of key points ({points_count})."
+                )
+            return colors
+        return [colors] * points_count
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/core.py b/.venv/lib/python3.12/site-packages/supervision/key_points/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e25add99fb32f8044ea4e460feac9e7b1671b78
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/key_points/core.py
@@ -0,0 +1,1499 @@
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable, Iterator
+from dataclasses import dataclass, field
+from typing import Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import CLASS_NAME_DATA_FIELD
+from supervision.detection.core import Detections
+from supervision.detection.utils._typing import (
+    _DetectionDataType,
+    _DetectionDataValueType,
+)
+from supervision.detection.utils.internal import (
+    get_data_item,
+    is_data_equal,
+    merge_data,
+)
+from supervision.detection.utils.iou_and_nms import (
+    OverlapMetric,
+    box_non_max_suppression,
+)
+from supervision.utils.internal import warn_deprecated
+from supervision.validators import _validate_keypoints_fields
+
+logger = logging.getLogger(__name__)
+
+Index1D = (
+    int | slice | list[int] | list[bool] | npt.NDArray[np.int_] | npt.NDArray[np.bool_]
+)
+Index2D = tuple[Index1D, Index1D]
+_RowIndexInput = int | np.integer[Any] | npt.NDArray[np.generic] | list[Any] | slice
+_NormalizedRowIndex = npt.NDArray[np.generic] | list[Any] | slice
+
+
+def _optional_array_equal(
+    first: npt.NDArray[np.generic] | None,
+    second: npt.NDArray[np.generic] | None,
+) -> bool:
+    if first is None or second is None:
+        return first is None and second is None
+    return np.array_equal(first, second)
+
+
+def _normalize_row_index(
+    i: _RowIndexInput,
+) -> _NormalizedRowIndex:
+    """Normalise *i* to a 1-D row index for 1-D per-object fields.
+
+    Handles:
+    - Python int or np.integer scalar  -> np.array([int(i)])
+    - boolean np.ndarray (any shape)   -> np.flatnonzero(i.ravel())
+    - non-bool 0-d np.ndarray          -> reshaped to shape (1,)
+    - list of bool                     -> np.flatnonzero(np.array(i))
+    - slice, list of ints, 1-D ndarray -> returned as-is
+    """
+    if isinstance(i, (int, np.integer)):
+        return cast(_NormalizedRowIndex, np.array([int(i)]))
+    if isinstance(i, np.ndarray) and i.dtype == bool:
+        return cast(_NormalizedRowIndex, np.flatnonzero(i.ravel()))
+    if isinstance(i, np.ndarray) and i.ndim == 0:
+        return cast(_NormalizedRowIndex, i.reshape(1))
+    if isinstance(i, list) and i and all(isinstance(x, bool) for x in i):
+        return cast(_NormalizedRowIndex, np.flatnonzero(np.array(i)))
+    return i
+
+
+@dataclass(init=False)
+class KeyPoints:
+    """
+    The `sv.KeyPoints` class in the Supervision library standardizes results from
+    various keypoint detection and pose estimation models into a consistent format. This
+    class simplifies data manipulation and filtering, providing a uniform API for
+    integration with Supervision [keypoints annotators](/latest/keypoint/annotators).
+
+    === "RF-DETR"
+
+        [RF-DETR](https://github.com/roboflow/rf-detr) keypoint models return
+        `sv.KeyPoints` directly from `model.predict()` — no additional
+        conversion is needed.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from rfdetr import RFDETRKeypointPreview
+
+        image = cv2.imread("")
+        model = RFDETRKeypointPreview()
+
+        key_points = model.predict(image)
+        ```
+
+    === "Ultralytics"
+
+        Use [`sv.KeyPoints.from_ultralytics`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_ultralytics)
+        method, which accepts [YOLOv8-pose](https://docs.ultralytics.com/models/yolov8/), [YOLO11-pose](https://docs.ultralytics.com/models/yolo11/)
+        [pose](https://docs.ultralytics.com/tasks/pose/) result.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from ultralytics import YOLO
+
+        image = cv2.imread("")
+        model = YOLO('yolo11s-pose.pt')
+
+        result = model(image)[0]
+        key_points = sv.KeyPoints.from_ultralytics(result)
+        ```
+
+    === "Inference"
+
+        Use [`sv.KeyPoints.from_inference`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_inference)
+        method, which accepts [Inference](https://inference.roboflow.com/) pose result.
+
+        ```python
+        from supervision import _cv2 as cv2
+        import supervision as sv
+        from inference import get_model
+
+        image = cv2.imread("")
+        model = get_model(model_id="", api_key="")
+
+        result = model.infer(image)[0]
+        key_points = sv.KeyPoints.from_inference(result)
+        ```
+
+    === "MediaPipe"
+
+        Use [`sv.KeyPoints.from_mediapipe`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_mediapipe)
+        method, which accepts [MediaPipe](https://github.com/google-ai-edge/mediapipe)
+        pose result.
+
+
+        ```python
+        from supervision import _cv2 as cv2
+        import mediapipe as mp
+        import supervision as sv
+
+        image = cv2.imread("")
+        image_height, image_width, _ = image.shape
+        mediapipe_image = mp.Image(
+            image_format=mp.ImageFormat.SRGB,
+            data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+        options = mp.tasks.vision.PoseLandmarkerOptions(
+            base_options=mp.tasks.BaseOptions(
+                model_asset_path="pose_landmarker_heavy.task"
+            ),
+            running_mode=mp.tasks.vision.RunningMode.IMAGE,
+            num_poses=2)
+
+        PoseLandmarker = mp.tasks.vision.PoseLandmarker
+        with PoseLandmarker.create_from_options(options) as landmarker:
+            pose_landmarker_result = landmarker.detect(mediapipe_image)
+
+        key_points = sv.KeyPoints.from_mediapipe(
+            pose_landmarker_result, (image_width, image_height))
+        ```
+
+    === "Transformers"
+
+        Use [`sv.KeyPoints.from_transformers`](/latest/keypoint/core/#supervision.key_points.core.KeyPoints.from_transformers)
+        method, which accepts [ViTPose](https://huggingface.co/docs/transformers/en/model_doc/vitpose) result.
+
+        ```python
+        from PIL import Image
+        import requests
+        import supervision as sv
+        import torch
+        from transformers import (
+            AutoProcessor,
+            RTDetrForObjectDetection,
+            VitPoseForPoseEstimation,
+        )
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        image = Image.open("")
+
+        DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365"
+
+        detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True)
+        detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=DEVICE)
+
+        inputs = detection_processor(images=frame, return_tensors="pt").to(DEVICE)
+
+        with torch.no_grad():
+            outputs = detection_model(**inputs)
+
+        target_size = torch.tensor([(frame.height, frame.width)])
+        results = detection_processor.post_process_object_detection(
+            outputs, target_sizes=target_size, threshold=0.3)
+
+        detections = sv.Detections.from_transformers(results[0])
+        boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy)
+
+        POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple"
+
+        pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID)
+        pose_estimation_model = VitPoseForPoseEstimation.from_pretrained(
+            POSE_ESTIMATION_MODEL_ID, device_map=DEVICE)
+
+        inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(DEVICE)
+
+        with torch.no_grad():
+            outputs = pose_estimation_model(**inputs)
+
+        results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes])
+        key_point = sv.KeyPoints.from_transformers(results[0])
+        ```
+
+    Attributes:
+        xy: An array of shape `(n, m, 2)` containing
+            `n` detected objects, each composed of `m` equally-sized
+            sets of key points, where each point is `[x, y]`.
+        class_id: An array of shape
+            `(n,)` containing the class ids of the detected objects.
+        keypoint_confidence: An array of shape
+            `(n, m)` containing the confidence scores of each keypoint.
+        detection_confidence: An array of shape
+            `(n,)` containing the detection-level confidence scores.
+        visible: An optional boolean array of shape
+            `(n, m)` indicating which keypoints are visible. When ``None``,
+            all keypoints are treated as visible. Set this to filter anchors
+            without removing data: ``key_points.visible = key_points.keypoint_confidence > 0.3``.
+        data: A dictionary containing additional
+            data where each key is a string representing the data type, and the value
+            is either a NumPy array or a list of corresponding data of length `n`
+            (one entry per detected object).
+    """  # noqa: E501 // docs
+
+    xy: npt.NDArray[np.float32]
+    class_id: npt.NDArray[np.int_] | None = None
+    keypoint_confidence: npt.NDArray[np.float32] | None = None
+    detection_confidence: npt.NDArray[np.float32] | None = None
+    visible: npt.NDArray[np.bool_] | None = None
+    data: _DetectionDataType = field(default_factory=dict)
+
+    def __init__(
+        self,
+        xy: npt.NDArray[np.float32],
+        class_id: npt.NDArray[np.int_] | None = None,
+        keypoint_confidence: npt.NDArray[np.float32] | None = None,
+        detection_confidence: npt.NDArray[np.float32] | None = None,
+        visible: npt.NDArray[np.bool_] | None = None,
+        data: _DetectionDataType | None = None,
+        *,
+        confidence: npt.NDArray[np.float32] | None = None,
+    ) -> None:
+        """Initialize KeyPoints.
+
+        Args:
+            xy: Array of shape `(n, m, 2)` with keypoint coordinates.
+            class_id: Array of shape `(n,)` with class IDs. Defaults to None.
+            keypoint_confidence: Array of shape `(n, m)` with per-keypoint
+                confidence scores. Defaults to None.
+            detection_confidence: Array of shape `(n,)` with detection-level
+                confidence scores. Defaults to None.
+            visible: Boolean array of shape `(n, m)` indicating visible
+                keypoints. Defaults to None.
+            data: Dictionary of additional per-detection data arrays.
+                Defaults to an empty dict.
+            confidence: Deprecated since `0.29.0`, removed in `0.32.0`.
+                Use ``keypoint_confidence`` instead. Raises ``ValueError``
+                if passed together with ``keypoint_confidence``.
+
+        Raises:
+            ValueError: If both ``confidence`` and ``keypoint_confidence``
+                are provided.
+        """
+        if confidence is not None:
+            if keypoint_confidence is not None:
+                raise ValueError(
+                    "Cannot pass both 'confidence' and 'keypoint_confidence'. "
+                    "'confidence' is deprecated — use 'keypoint_confidence' only."
+                )
+            warn_deprecated(
+                "'confidence' parameter in `KeyPoints()` is deprecated since "
+                "`0.29.0` and will be removed in `0.32.0`. Use "
+                "'keypoint_confidence' instead."
+            )
+            keypoint_confidence = confidence
+
+        self.xy = xy
+        self.class_id = class_id
+        self.keypoint_confidence = keypoint_confidence
+        self.detection_confidence = detection_confidence
+        self.visible = visible
+        self.data = data if data is not None else {}
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        _validate_keypoints_fields(
+            xy=self.xy,
+            class_id=self.class_id,
+            confidence=self.keypoint_confidence,
+            detection_confidence=self.detection_confidence,
+            visible=self.visible,
+            data=self.data,
+        )
+
+    @property
+    def confidence(self) -> npt.NDArray[np.float32] | None:
+        """Deprecated since 0.29.0. Use ``keypoint_confidence`` instead."""
+        warn_deprecated(
+            "'KeyPoints.confidence' is deprecated since 0.29.0 and will be "
+            "removed in 0.32.0. Use 'KeyPoints.keypoint_confidence' instead."
+        )
+        return self.keypoint_confidence
+
+    @confidence.setter
+    def confidence(self, value: npt.NDArray[np.float32] | None) -> None:
+        warn_deprecated(
+            "'KeyPoints.confidence' is deprecated since 0.29.0 and will be "
+            "removed in 0.32.0. Use 'KeyPoints.keypoint_confidence' instead."
+        )
+        self.keypoint_confidence = value
+
+    def __len__(self) -> int:
+        """
+        Returns the number of objects in the `sv.KeyPoints` object.
+
+        Returns:
+            The number of objects.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> xy = np.array([[[10, 20], [30, 40]]], dtype=np.float32)
+            >>> key_points = sv.KeyPoints(xy=xy)
+            >>> len(key_points)
+            1
+
+            ```
+        """
+        return len(self.xy)
+
+    def __iter__(
+        self,
+    ) -> Iterator[
+        tuple[
+            npt.NDArray[np.float32],
+            npt.NDArray[np.float32] | None,
+            npt.NDArray[np.int_] | None,
+            _DetectionDataType,
+        ]
+    ]:
+        """
+        Iterates over the Keypoint object and yield a tuple of
+        `(xy, keypoint_confidence, class_id, data)` for each object detection.
+        """
+        for i in range(len(self.xy)):
+            yield (
+                self.xy[i],
+                self.keypoint_confidence[i]
+                if self.keypoint_confidence is not None
+                else None,
+                self.class_id[i] if self.class_id is not None else None,
+                get_data_item(self.data, i),
+            )
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, KeyPoints):
+            return NotImplemented
+        return all(
+            [
+                np.array_equal(self.xy, other.xy),
+                _optional_array_equal(self.class_id, other.class_id),
+                _optional_array_equal(
+                    self.keypoint_confidence, other.keypoint_confidence
+                ),
+                _optional_array_equal(
+                    self.detection_confidence, other.detection_confidence
+                ),
+                _optional_array_equal(self.visible, other.visible),
+                is_data_equal(self.data, other.data),
+            ]
+        )
+
+    @classmethod
+    def from_inference(cls, inference_result: Any) -> KeyPoints:
+        """
+        Create a `sv.KeyPoints` object from the [Roboflow](https://roboflow.com/)
+        API inference result or the [Inference](https://inference.roboflow.com/)
+        package results.
+
+        Args:
+            inference_result: The result from the
+                Roboflow API or Inference package containing predictions with keypoints.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates, class IDs,
+                class names, and confidences of each keypoint.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from inference import get_model
+
+            image = cv2.imread("")
+            model = get_model(model_id="", api_key="")
+
+            result = model.infer(image)[0]
+            key_points = sv.KeyPoints.from_inference(result)
+            ```
+
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from inference_sdk import InferenceHTTPClient
+
+            image = cv2.imread("")
+            client = InferenceHTTPClient(
+                api_url="https://detect.roboflow.com",
+                api_key=""
+            )
+
+            result = client.infer(image, model_id="")
+            key_points = sv.KeyPoints.from_inference(result)
+            ```
+        """
+        if isinstance(inference_result, list):
+            raise ValueError(
+                "from_inference() operates on a single result at a time."
+                "You can retrieve it like so:  inference_result = model.infer(image)[0]"
+            )
+
+        if hasattr(inference_result, "dict"):
+            inference_result = inference_result.dict(exclude_none=True, by_alias=True)
+        elif hasattr(inference_result, "json"):
+            inference_result = inference_result.json()
+        if not inference_result.get("predictions"):
+            return cls.empty()
+
+        predictions = inference_result["predictions"]
+
+        # Inference omits every key point scored below the request's
+        # `keypoint_confidence`, so objects can list different key points. Each key
+        # point's `class_id` is its index in the skeleton; placing it there keeps
+        # skeleton edges on the right joints. Results without that field fall back
+        # to list order. Omitted slots stay at (0, 0) with zero confidence, the
+        # missing-key-point marker that the annotators and `as_detections` skip.
+        slots = [
+            [
+                keypoint.get("class_id", position)
+                for position, keypoint in enumerate(prediction["keypoints"])
+            ]
+            for prediction in predictions
+        ]
+        keypoint_count = max(
+            (max(object_slots) + 1 for object_slots in slots if object_slots),
+            default=0,
+        )
+
+        xy = np.zeros((len(predictions), keypoint_count, 2), dtype=np.float32)
+        confidence = np.zeros((len(predictions), keypoint_count), dtype=np.float32)
+        for object_index, (prediction, object_slots) in enumerate(
+            zip(predictions, slots)
+        ):
+            for slot, keypoint in zip(object_slots, prediction["keypoints"]):
+                xy[object_index, slot] = (keypoint["x"], keypoint["y"])
+                confidence[object_index, slot] = keypoint["confidence"]
+
+        class_id = np.array([prediction["class_id"] for prediction in predictions])
+        class_names = np.array([prediction["class"] for prediction in predictions])
+        data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: class_names}
+
+        return cls(
+            xy=xy,
+            keypoint_confidence=confidence,
+            class_id=class_id.astype(int),
+            data=data,
+        )
+
+    @classmethod
+    def from_mediapipe(
+        cls, mediapipe_results: Any, resolution_wh: tuple[int, int]
+    ) -> KeyPoints:
+        """
+        Creates a `sv.KeyPoints` instance from a
+        [MediaPipe](https://github.com/google-ai-edge/mediapipe)
+        pose landmark detection inference result.
+
+        Args:
+            mediapipe_results: The output results from Mediapipe. It supports pose
+                and face landmarks from `PoseLandmarker`, `FaceLandmarker` and the
+                legacy ones from `Pose` and `FaceMesh`.
+            resolution_wh: A tuple of the form `(width, height)` representing the
+                resolution of the frame.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates and
+                confidences of each keypoint.
+
+        !!! tip
+            Before you start, download model bundles from the
+            [MediaPipe website](https://ai.google.dev/edge/mediapipe/solutions/vision/pose_landmarker/index#models).
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import mediapipe as mp
+            import supervision as sv
+
+            image = cv2.imread("")
+            image_height, image_width, _ = image.shape
+            mediapipe_image = mp.Image(
+                image_format=mp.ImageFormat.SRGB,
+                data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+            options = mp.tasks.vision.PoseLandmarkerOptions(
+                base_options=mp.tasks.BaseOptions(
+                    model_asset_path="pose_landmarker_heavy.task"
+                ),
+                running_mode=mp.tasks.vision.RunningMode.IMAGE,
+                num_poses=2)
+
+            PoseLandmarker = mp.tasks.vision.PoseLandmarker
+            with PoseLandmarker.create_from_options(options) as landmarker:
+                pose_landmarker_result = landmarker.detect(mediapipe_image)
+
+            key_points = sv.KeyPoints.from_mediapipe(
+                pose_landmarker_result, (image_width, image_height))
+            ```
+
+            ```python
+            from supervision import _cv2 as cv2
+            import mediapipe as mp
+            import supervision as sv
+
+            image = cv2.imread("")
+            image_height, image_width, _ = image.shape
+            mediapipe_image = mp.Image(
+                image_format=mp.ImageFormat.SRGB,
+                data=cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+
+            options = mp.tasks.vision.FaceLandmarkerOptions(
+                base_options=mp.tasks.BaseOptions(
+                    model_asset_path="face_landmarker.task"
+                ),
+                output_face_blendshapes=True,
+                output_facial_transformation_matrixes=True,
+                num_faces=2)
+
+            FaceLandmarker = mp.tasks.vision.FaceLandmarker
+            with FaceLandmarker.create_from_options(options) as landmarker:
+                face_landmarker_result = landmarker.detect(mediapipe_image)
+
+            key_points = sv.KeyPoints.from_mediapipe(
+                face_landmarker_result, (image_width, image_height))
+            ```
+
+        """
+        if hasattr(mediapipe_results, "pose_landmarks"):
+            results = mediapipe_results.pose_landmarks
+            if not isinstance(mediapipe_results.pose_landmarks, list):
+                if mediapipe_results.pose_landmarks is None:
+                    results = []
+                else:
+                    results = [
+                        [
+                            landmark
+                            for landmark in mediapipe_results.pose_landmarks.landmark
+                        ]
+                    ]
+        elif hasattr(mediapipe_results, "face_landmarks"):
+            results = mediapipe_results.face_landmarks
+        elif hasattr(mediapipe_results, "multi_face_landmarks"):
+            if mediapipe_results.multi_face_landmarks is None:
+                results = []
+            else:
+                results = [
+                    face_landmark.landmark
+                    for face_landmark in mediapipe_results.multi_face_landmarks
+                ]
+        else:
+            # Reject unsupported MediaPipe-like payloads before landmark parsing.
+            raise ValueError(
+                "Unsupported MediaPipe result type. Expected an object with "
+                "pose_landmarks, face_landmarks, or multi_face_landmarks."
+            )
+
+        if len(results) == 0:
+            return cls.empty()
+
+        xy = []
+        confidence = []
+        for pose in results:
+            prediction_xy = []
+            prediction_confidence = []
+            for landmark in pose:
+                keypoint_xy = [
+                    landmark.x * resolution_wh[0],
+                    landmark.y * resolution_wh[1],
+                ]
+                prediction_xy.append(keypoint_xy)
+                prediction_confidence.append(landmark.visibility)
+
+            xy.append(prediction_xy)
+            confidence.append(prediction_confidence)
+
+        return cls(
+            xy=np.array(xy, dtype=np.float32),
+            keypoint_confidence=np.array(confidence, dtype=np.float32),
+        )
+
+    @classmethod
+    def from_ultralytics(cls, ultralytics_results: Any) -> KeyPoints:
+        """
+        Creates a `sv.KeyPoints` instance from a
+        [YOLOv8](https://github.com/ultralytics/ultralytics) pose inference result.
+
+        Args:
+            ultralytics_results: The output Results instance from YOLOv8.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates, class IDs,
+                and class names, and confidences of each keypoint.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from ultralytics import YOLO
+
+            image = cv2.imread("")
+            model = YOLO('yolov8s-pose.pt')
+
+            result = model(image)[0]
+            key_points = sv.KeyPoints.from_ultralytics(result)
+            ```
+        """
+        if ultralytics_results.keypoints.xy.numel() == 0:
+            return cls.empty()
+
+        xy = ultralytics_results.keypoints.xy.cpu().numpy()
+        class_id = ultralytics_results.boxes.cls.cpu().numpy().astype(int)
+        class_names = np.array([ultralytics_results.names[i] for i in class_id])
+
+        # Models trained with a two-value `kpt_shape` report no per-keypoint
+        # visibility, and Ultralytics exposes `keypoints.conf` as `None` for them.
+        keypoints_conf = ultralytics_results.keypoints.conf
+        confidence = None if keypoints_conf is None else keypoints_conf.cpu().numpy()
+        data: _DetectionDataType = {CLASS_NAME_DATA_FIELD: class_names}
+        return cls(xy=xy, class_id=class_id, keypoint_confidence=confidence, data=data)
+
+    @classmethod
+    def from_yolo_nas(cls, yolo_nas_results: Any) -> KeyPoints:
+        """
+        Create a `sv.KeyPoints` instance from a [YOLO-NAS](https://github.com/Deci-AI/super-gradients/blob/master/YOLONAS-POSE.md)
+        pose inference results.
+
+        Args:
+            yolo_nas_results: The output object from YOLO NAS.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates, class IDs,
+                and class names, and confidences of each keypoint.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import torch
+            import supervision as sv
+            import super_gradients
+
+            image = cv2.imread("")
+
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            model = super_gradients.training.models.get(
+                "yolo_nas_pose_s", pretrained_weights="coco_pose").to(device)
+
+            results = model.predict(image, conf=0.1)
+            key_points = sv.KeyPoints.from_yolo_nas(results)
+            ```
+        """
+        if len(yolo_nas_results.prediction.poses) == 0:
+            return cls.empty()
+
+        xy = yolo_nas_results.prediction.poses[:, :, :2]
+        confidence = yolo_nas_results.prediction.poses[:, :, 2]
+
+        # yolo_nas_results treats params differently.
+        # prediction.labels may not exist, whereas class_names might be None
+        if hasattr(yolo_nas_results.prediction, "labels"):
+            class_id = yolo_nas_results.prediction.labels  # np.array[int]
+        else:
+            class_id = None
+
+        data: _DetectionDataType = {}
+        if class_id is not None and yolo_nas_results.class_names is not None:
+            class_names = []
+            for c_id in class_id:
+                name = yolo_nas_results.class_names[c_id]  # tuple[str]
+                class_names.append(name)
+            data[CLASS_NAME_DATA_FIELD] = class_names
+
+        return cls(
+            xy=xy,
+            keypoint_confidence=confidence,
+            class_id=class_id,
+            data=data,
+        )
+
+    @classmethod
+    def from_detectron2(cls, detectron2_results: Any) -> KeyPoints:
+        """
+        Create a `sv.KeyPoints` object from the
+        [Detectron2](https://github.com/facebookresearch/detectron2) inference result.
+
+        Args:
+            detectron2_results: The output of a
+                Detectron2 model containing instances with prediction data.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates, class IDs,
+                and class names, and confidences of each keypoint.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from detectron2.engine import DefaultPredictor
+            from detectron2.config import get_cfg
+
+
+            image = cv2.imread("")
+            cfg = get_cfg()
+            cfg.merge_from_file("")
+            cfg.MODEL.WEIGHTS = ""
+            predictor = DefaultPredictor(cfg)
+
+            result = predictor(image)
+            keypoints = sv.KeyPoints.from_detectron2(result)
+            ```
+        """
+
+        if hasattr(detectron2_results["instances"], "pred_keypoints"):
+            if detectron2_results["instances"].pred_keypoints.cpu().numpy().size == 0:
+                return cls.empty()
+            return cls(
+                xy=detectron2_results["instances"]
+                .pred_keypoints.cpu()
+                .numpy()[:, :, :2],
+                keypoint_confidence=detectron2_results["instances"]
+                .pred_keypoints.cpu()
+                .numpy()[:, :, 2],
+                class_id=detectron2_results["instances"]
+                .pred_classes.cpu()
+                .numpy()
+                .astype(int),
+            )
+        else:
+            return cls.empty()
+
+    @classmethod
+    def from_transformers(cls, transformers_results: Any) -> KeyPoints:
+        """
+        Create a `sv.KeyPoints` object from the
+        [Transformers](https://github.com/huggingface/transformers) inference result.
+
+        Args:
+            transformers_results: The output of a
+                Transformers model containing instances with prediction data.
+
+        Returns:
+            A `sv.KeyPoints` object containing the keypoint coordinates, class IDs,
+                and class names, and confidences of each keypoint.
+
+        Examples:
+            ```python
+            from PIL import Image
+            import requests
+            import supervision as sv
+            import torch
+            from transformers import (
+                AutoProcessor,
+                RTDetrForObjectDetection,
+                VitPoseForPoseEstimation,
+            )
+
+            device = "cuda" if torch.cuda.is_available() else "cpu"
+            image = Image.open("")
+
+            DETECTION_MODEL_ID = "PekingU/rtdetr_r50vd_coco_o365"
+
+            detection_processor = AutoProcessor.from_pretrained(DETECTION_MODEL_ID, use_fast=True)
+            detection_model = RTDetrForObjectDetection.from_pretrained(DETECTION_MODEL_ID, device_map=device)
+
+            inputs = detection_processor(images=frame, return_tensors="pt").to(device)
+
+            with torch.no_grad():
+                outputs = detection_model(**inputs)
+
+            target_size = torch.tensor([(frame.height, frame.width)])
+            results = detection_processor.post_process_object_detection(
+                outputs, target_sizes=target_size, threshold=0.3)
+
+            detections = sv.Detections.from_transformers(results[0])
+            boxes = sv.xyxy_to_xywh(detections[detections.class_id == 0].xyxy)
+
+            POSE_ESTIMATION_MODEL_ID = "usyd-community/vitpose-base-simple"
+
+            pose_estimation_processor = AutoProcessor.from_pretrained(POSE_ESTIMATION_MODEL_ID)
+            pose_estimation_model = VitPoseForPoseEstimation.from_pretrained(
+                POSE_ESTIMATION_MODEL_ID, device_map=device)
+
+            inputs = pose_estimation_processor(frame, boxes=[boxes], return_tensors="pt").to(device)
+
+            with torch.no_grad():
+                outputs = pose_estimation_model(**inputs)
+
+            results = pose_estimation_processor.post_process_pose_estimation(outputs, boxes=[boxes])
+            key_point = sv.KeyPoints.from_transformers(results[0])
+            ```
+
+        """  # noqa: E501 // docs
+
+        if "keypoints" in transformers_results[0]:
+            if transformers_results[0]["keypoints"].cpu().numpy().size == 0:
+                return cls.empty()
+
+            result_data = [
+                (
+                    result["keypoints"].cpu().numpy(),
+                    result["scores"].cpu().numpy(),
+                )
+                for result in transformers_results
+            ]
+
+            xy, scores = zip(*result_data)
+
+            return cls(
+                xy=np.stack(xy).astype(np.float32),
+                keypoint_confidence=np.stack(scores).astype(np.float32),
+                class_id=np.arange(len(xy)).astype(int),
+            )
+        else:
+            return cls.empty()
+
+    def _get_by_2d_bool_mask(self, mask: npt.NDArray[np.bool_]) -> KeyPoints:
+        """Filter keypoints using a 2D boolean mask of shape `(n, m)`.
+
+        This method selects the **same set of keypoints from every object**, so
+        every row of `mask` must contain the same number of `True` values.  The
+        result is a new `KeyPoints` whose keypoint count is that uniform `k`.
+
+        This is suitable for use cases such as *"keep only the left-side joints for
+        all persons"* — where the selected joint indices are identical across objects.
+
+        It is **not** suitable for per-object confidence filtering
+        (`kp[kp.confidence > 0.5]`) when the threshold yields a different number of
+        passing keypoints per object, because NumPy cannot represent a ragged
+        `(n, ?, 2)` array.  For that pattern either process objects individually or
+        zero out low-confidence entries in-place via `kp.confidence`.
+
+        For the single-object case (`n == 1`) any boolean mask always satisfies the
+        uniform-count requirement, so `kp[kp.confidence > 0.5]` works as expected.
+
+        Args:
+            mask: A boolean array of shape `(n, m)` where `n` is the number of
+                objects and `m` is the number of keypoints per object.  Every row
+                must select the same number of keypoints so that the result can be
+                stored in a uniform `(n, k, ...)` array.
+
+        Returns:
+            A new `KeyPoints` instance containing only the keypoints selected by
+            the mask for each object.
+
+        Raises:
+            ValueError: If `mask.shape[0]` does not match the number of objects, if
+                `mask.shape[1]` does not match the number of keypoints, or if
+                different rows of the mask select different numbers of `True` values.
+        """
+        n = len(self.xy)
+        if mask.shape[0] != n:
+            raise ValueError(
+                f"2D boolean mask row count {mask.shape[0]} does not match "
+                f"object count {n}."
+            )
+        if mask.shape[1] != self.xy.shape[1]:
+            raise ValueError(
+                f"2D boolean mask column count {mask.shape[1]} does not match "
+                f"keypoint count {self.xy.shape[1]}."
+            )
+        counts = np.sum(mask, axis=1)
+        if n > 0 and not np.all(counts == counts[0]):
+            raise ValueError(
+                "Cannot filter keypoints with a 2D boolean mask where rows have "
+                "different numbers of True values. "
+                "All objects must select the same number of keypoints. "
+                f"Got counts per object: {counts.tolist()}"
+            )
+        k = int(counts[0]) if n > 0 else 0
+        xy_selected = np.zeros((n, k, self.xy.shape[2]), dtype=self.xy.dtype)
+        keypoint_confidence_selected: npt.NDArray[np.float32] | None = None
+        if self.keypoint_confidence is not None:
+            keypoint_confidence_selected = cast(
+                npt.NDArray[np.float32],
+                np.zeros((n, k), dtype=self.keypoint_confidence.dtype),
+            )
+        visible_selected: npt.NDArray[np.bool_] | None = None
+        if self.visible is not None:
+            visible_selected = np.zeros((n, k), dtype=bool)
+        for row in range(n):
+            row_indices = np.flatnonzero(mask[row])
+            xy_selected[row] = self.xy[row, row_indices]
+            if (
+                keypoint_confidence_selected is not None
+                and self.keypoint_confidence is not None
+            ):
+                keypoint_confidence_selected[row] = self.keypoint_confidence[
+                    row, row_indices
+                ]
+            if visible_selected is not None and self.visible is not None:
+                visible_selected[row] = self.visible[row, row_indices]
+        detection_confidence_selected = None
+        if self.detection_confidence is not None:
+            detection_confidence_selected = self.detection_confidence.copy()
+
+        class_id_selected = None
+        if self.class_id is not None:
+            class_id_selected = self.class_id.copy()
+
+        data_selected = get_data_item(self.data, slice(None))
+
+        return KeyPoints(
+            xy=xy_selected,
+            keypoint_confidence=keypoint_confidence_selected,
+            detection_confidence=detection_confidence_selected,
+            visible=visible_selected,
+            class_id=class_id_selected,
+            data=data_selected,
+        )
+
+    def get_data(self, key: str) -> _DetectionDataValueType | None:
+        """Get a value from the keypoint data dictionary.
+
+        Args:
+            key: Data field name.
+
+        Returns:
+            The stored data value, or `None` when the key is absent.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision import KeyPoints
+            >>> key_points = KeyPoints(
+            ...     xy=np.array([[[0, 0]]]),
+            ...     data={"class_name": np.array(["person"])},
+            ... )
+            >>> key_points.get_data("class_name").tolist()
+            ['person']
+
+            ```
+        """
+        return self.data.get(key)
+
+    def select(
+        self,
+        index: Index1D | Index2D,
+    ) -> KeyPoints:
+        """Get a subset of the KeyPoints object.
+
+        Supports detection-level (skeleton) filtering, keypoint-level (anchor)
+        filtering, and combined tuple indexing.
+
+        Args:
+            index: Index, indices, slice, or boolean mask selecting key points.
+
+        Returns:
+            A new `KeyPoints` instance containing the selected rows or anchors.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> from supervision import KeyPoints
+            >>> key_points = KeyPoints(xy=np.array([[[0, 1]], [[2, 3]]]))
+            >>> key_points.select([1]).xy.tolist()
+            [[[2, 3]]]
+
+            ```
+        """
+        if isinstance(index, np.ndarray) and index.ndim == 2 and index.dtype == bool:
+            return self._get_by_2d_bool_mask(cast(npt.NDArray[np.bool_], index))
+
+        if not isinstance(index, tuple):
+            index = (index, slice(None))
+
+        i, j = index
+
+        if isinstance(i, int):
+            i = [i]
+
+        if isinstance(i, list) and i and all(isinstance(x, bool) for x in i):
+            i = np.array(i)
+        if isinstance(j, list) and j and all(isinstance(x, bool) for x in j):
+            j = np.array(j)
+
+        if isinstance(i, np.ndarray) and i.dtype == bool:
+            i = np.flatnonzero(i)
+        if isinstance(j, np.ndarray) and j.dtype == bool:
+            j = np.flatnonzero(j)
+
+        raw_i = i
+
+        if (
+            isinstance(i, (list, np.ndarray))
+            and isinstance(j, (list, np.ndarray))
+            and not np.isscalar(i)
+            and not np.isscalar(j)
+        ):
+            i_ix, j_ix = np.ix_(cast(Any, i), cast(Any, j))
+            i = cast(Any, i_ix)
+            j = cast(Any, j_ix)
+
+        row_i = _normalize_row_index(raw_i)
+
+        xy_selected = self.xy[i, j]
+
+        keypoint_confidence_selected = None
+        if self.keypoint_confidence is not None:
+            keypoint_confidence_selected = self.keypoint_confidence[i, j]
+
+        detection_confidence_selected = None
+        if self.detection_confidence is not None:
+            detection_confidence_selected = self.detection_confidence[row_i]
+
+        visible_selected = None
+        if self.visible is not None:
+            visible_selected = self.visible[i, j]
+
+        class_id_selected = self.class_id[row_i] if self.class_id is not None else None
+
+        data_selected = get_data_item(self.data, cast(Any, row_i))
+
+        if xy_selected.ndim == 1:
+            xy_selected = xy_selected.reshape(1, 1, 2)
+            if keypoint_confidence_selected is not None:
+                keypoint_confidence_selected = keypoint_confidence_selected.reshape(
+                    1, 1
+                )
+            if visible_selected is not None:
+                visible_selected = visible_selected.reshape(1, 1)
+        elif xy_selected.ndim == 2:
+            if np.isscalar(index[0]) or (
+                isinstance(index[0], np.ndarray) and index[0].ndim == 0
+            ):
+                xy_selected = xy_selected[np.newaxis, ...]
+                if keypoint_confidence_selected is not None:
+                    keypoint_confidence_selected = keypoint_confidence_selected[
+                        np.newaxis, ...
+                    ]
+                if visible_selected is not None:
+                    visible_selected = visible_selected[np.newaxis, ...]
+            elif np.isscalar(index[1]) or (
+                isinstance(index[1], np.ndarray) and index[1].ndim == 0
+            ):
+                xy_selected = xy_selected[:, np.newaxis, :]
+                if keypoint_confidence_selected is not None:
+                    keypoint_confidence_selected = keypoint_confidence_selected[
+                        :, np.newaxis
+                    ]
+                if visible_selected is not None:
+                    visible_selected = visible_selected[:, np.newaxis]
+
+        return KeyPoints(
+            xy=xy_selected,
+            keypoint_confidence=keypoint_confidence_selected,
+            detection_confidence=detection_confidence_selected,
+            visible=visible_selected,
+            class_id=class_id_selected,
+            data=data_selected,
+        )
+
+    def __getitem__(
+        self,
+        index: Index1D | Index2D | str,
+    ) -> KeyPoints | npt.NDArray[np.generic] | list[Any] | None:
+        """
+        Get a subset of the KeyPoints object or access an item from its data field.
+
+        Supports detection-level (skeleton) filtering, keypoint-level (anchor)
+        filtering, combined tuple indexing, and data field access by string key.
+
+        Args:
+            index: The index, indices, or key to access a subset of the KeyPoints
+                or an item from the data.
+
+        Returns:
+            A subset of the KeyPoints object or an item from the data field.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            key_points = sv.KeyPoints(...)
+
+            # detection-level filtering (returns KeyPoints)
+            high_conf = key_points[key_points.detection_confidence > 0.5]
+            class_0 = key_points[key_points.class_id == 0]
+
+            # keypoint-level filtering (returns KeyPoints)
+            visible = key_points[key_points.keypoint_confidence > 0.3]
+
+            # indexing
+            first = key_points[0]
+            first_two = key_points[0:2]
+            subset = key_points[[0, 2]]
+
+            # anchor selection (uniform across all skeletons)
+            nose_and_eyes = key_points[:, [0, 1, 2]]
+
+            # data field access
+            class_names = key_points['class_name']
+            ```
+        """
+        if isinstance(index, str):
+            return self.get_data(index)
+        return self.select(index)
+
+    def __setitem__(self, key: str, value: npt.NDArray[np.generic] | list[Any]) -> None:
+        """
+        Set a value in the data dictionary of the `sv.KeyPoints` object.
+
+        Args:
+            key: The key in the data dictionary to set.
+            value: The value to set for the key.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from ultralytics import YOLO
+
+            image = cv2.imread("")
+            model = YOLO('yolov8s.pt')
+
+            result = model(image)[0]
+            key_points = sv.KeyPoints.from_ultralytics(result)
+
+            key_points['class_name'] = [
+                 model.model.names[class_id]
+                 for class_id
+                 in key_points.class_id
+             ]
+            ```
+        """
+        if not isinstance(value, (np.ndarray, list)):
+            raise TypeError("Value must be a np.ndarray or a list")
+
+        if isinstance(value, list):
+            value = np.array(value)
+
+        self.data[key] = value
+
+    @classmethod
+    def empty(cls) -> KeyPoints:
+        """
+        Create an empty KeyPoints object with no key points.
+
+        Returns:
+            An empty `sv.KeyPoints` object.
+
+        Examples:
+            ```pycon
+            >>> import supervision as sv
+            >>> key_points = sv.KeyPoints.empty()
+            >>> len(key_points)
+            0
+
+            ```
+        """
+        return cls(xy=np.empty((0, 0, 2), dtype=np.float32))
+
+    def is_empty(self) -> bool:
+        """
+        Returns `True` if the `KeyPoints` object is considered empty.
+
+        Returns:
+            `True` if the object is empty, `False` otherwise.
+
+        Example:
+            ```pycon
+            >>> import supervision as sv
+            >>> key_points = sv.KeyPoints.empty()
+            >>> key_points.is_empty()
+            True
+
+            ```
+        """
+        return len(self) == 0
+
+    @classmethod
+    def merge(cls, key_points_list: list[KeyPoints]) -> KeyPoints:
+        """
+        Merge a list of KeyPoints objects into a single KeyPoints object.
+
+        This method takes a list of KeyPoints objects and combines their
+        respective fields (`xy`, `class_id`, `keypoint_confidence`,
+        `detection_confidence`, and `visible`) into a single KeyPoints object.
+        The `data` dictionaries are merged key-wise, following the same rules
+        as `Detections.merge`.
+
+        For example, if merging KeyPoints with 2 and 3 skeletons, this method
+        will return a KeyPoints with 5 skeletons (5 entries in `xy`, etc).
+
+        !!! Note
+
+            When merging, empty `KeyPoints` objects are ignored.
+
+        Args:
+            key_points_list: A list of KeyPoints objects to merge.
+
+        Returns:
+            A single KeyPoints object containing the merged data from the input list.
+
+        Raises:
+            ValueError: If the non-empty inputs do not share the same number
+                of keypoints per skeleton.
+            ValueError: If the non-empty inputs do not share the same
+                coordinate depth (`xy.shape[2]`) per skeleton.
+            ValueError: If some inputs have a field set (`class_id`,
+                `keypoint_confidence`, `detection_confidence`, or `visible`)
+                and others do not.
+            ValueError: If the input `data` dictionaries do not share the
+                same keys.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> key_points_1 = sv.KeyPoints(
+            ...     xy=np.array([[[10, 10], [20, 20]]], dtype=np.float32),
+            ...     class_id=np.array([0]),
+            ...     data={'class_name': np.array(['person'])},
+            ... )
+            >>> key_points_2 = sv.KeyPoints(
+            ...     xy=np.array([[[30, 30], [40, 40]]], dtype=np.float32),
+            ...     class_id=np.array([1]),
+            ...     data={'class_name': np.array(['dog'])},
+            ... )
+            >>> merged = sv.KeyPoints.merge([key_points_1, key_points_2])
+            >>> len(merged)
+            2
+            >>> merged.class_id
+            array([0, 1])
+            >>> merged.data['class_name']
+            array(['person', 'dog'], dtype=' 1:
+            raise ValueError(
+                "All KeyPoints must have the same number of keypoints per "
+                f"skeleton to be merged; got counts {sorted(keypoint_counts)}."
+            )
+
+        keypoint_depths = {key_points.xy.shape[2] for key_points in key_points_list}
+        if len(keypoint_depths) > 1:
+            raise ValueError(
+                "All KeyPoints must have the same coordinate depth per "
+                f"skeleton to be merged; got depths {sorted(keypoint_depths)}."
+            )
+
+        xy = np.vstack([key_points.xy for key_points in key_points_list])
+
+        def stack_or_none(name: str) -> npt.NDArray[np.generic] | None:
+            values = [getattr(key_points, name) for key_points in key_points_list]
+            if all(value is None for value in values):
+                return None
+            if any(value is None for value in values):
+                raise ValueError(f"All or none of the '{name}' fields must be None")
+            return cast(npt.NDArray[np.generic], np.concatenate(values, axis=0))
+
+        class_id = cast(npt.NDArray[np.int_] | None, stack_or_none("class_id"))
+        keypoint_confidence = cast(
+            npt.NDArray[np.float32] | None, stack_or_none("keypoint_confidence")
+        )
+        detection_confidence = cast(
+            npt.NDArray[np.float32] | None, stack_or_none("detection_confidence")
+        )
+        visible = cast(npt.NDArray[np.bool_] | None, stack_or_none("visible"))
+
+        data = merge_data([key_points.data for key_points in key_points_list])
+
+        return cls(
+            xy=xy,
+            class_id=class_id,
+            keypoint_confidence=keypoint_confidence,
+            detection_confidence=detection_confidence,
+            visible=visible,
+            data=data,
+        )
+
+    def with_nms(
+        self,
+        threshold: float = 0.5,
+        class_agnostic: bool = False,
+        overlap_metric: OverlapMetric = OverlapMetric.IOU,
+    ) -> KeyPoints:
+        """Performs non-max suppression on the keypoint detections. Bounding boxes are
+        derived from valid keypoints of each skeleton, and standard box NMS is applied.
+        A keypoint is considered valid when its coordinates are finite and not all-zero,
+        and its `visible` flag is `True` (if `visible` is set). A skeleton left without
+        a valid keypoint keeps a zero-area box, so it overlaps nothing and passes
+        through.
+
+        Args:
+            threshold: The intersection-over-union threshold to use for
+                non-maximum suppression. Must be in [0, 1]. Defaults to 0.5.
+            class_agnostic: Whether to perform class-agnostic non-maximum
+                suppression. If True, the class_id of each detection will be
+                ignored. Defaults to False.
+            overlap_metric: Metric used to compute the degree of overlap
+                between pairs of bounding boxes. Defaults to
+                `OverlapMetric.IOU`.
+
+        Returns:
+            A new `sv.KeyPoints` object after non-maximum suppression.
+
+        Raises:
+            ValueError: If `detection_confidence` is None.
+            ValueError: If `class_agnostic` is False and `class_id`
+                is None.
+
+        Examples:
+            ```python
+            from supervision import _cv2 as cv2
+            import supervision as sv
+            from rfdetr import RFDETRKeypointPreview
+
+            image = cv2.imread("")
+            model = RFDETRKeypointPreview()
+
+            key_points = model.predict(image)
+            key_points = key_points.with_nms(threshold=0.5)
+            ```
+        """
+        if len(self) == 0:
+            return self
+
+        if self.detection_confidence is None:
+            raise ValueError(
+                "KeyPoints detection_confidence must be given for NMS to be executed."
+            )
+
+        if not class_agnostic and self.class_id is None:
+            raise ValueError(
+                "KeyPoints class_id must be given for NMS to be executed. If "
+                "you intended to perform class agnostic NMS set "
+                "class_agnostic=True."
+            )
+
+        xy = self.xy
+        # A non-finite keypoint marks an undetected joint, so it must not reach the
+        # box: `xy == 0` does not catch it and `np.min`/`np.max` propagate it into
+        # every corner, leaving an all-`NaN` box that compares False against every
+        # IoU threshold and therefore suppresses nothing. `as_detections` applies
+        # the same rule.
+        valid = ~np.all(xy == 0, axis=-1) & np.isfinite(xy).all(axis=-1)
+        if self.visible is not None:
+            valid = valid & self.visible
+        has_valid = valid.any(axis=1)
+        x_min = np.min(np.where(valid, xy[..., 0], np.inf), axis=1)
+        y_min = np.min(np.where(valid, xy[..., 1], np.inf), axis=1)
+        x_max = np.max(np.where(valid, xy[..., 0], -np.inf), axis=1)
+        y_max = np.max(np.where(valid, xy[..., 1], -np.inf), axis=1)
+        xyxy = np.stack([x_min, y_min, x_max, y_max], axis=1).astype(np.float32)
+        # Skeletons left without a single valid keypoint would otherwise carry the
+        # `inf` sentinels above; a zero-area box keeps them out of every overlap.
+        xyxy[~has_valid] = 0.0
+
+        if class_agnostic:
+            predictions = np.hstack([xyxy, self.detection_confidence.reshape(-1, 1)])
+        else:
+            class_id = cast(npt.NDArray[np.int_], self.class_id)
+            predictions = np.hstack(
+                [
+                    xyxy,
+                    self.detection_confidence.reshape(-1, 1),
+                    class_id.reshape(-1, 1),
+                ]
+            )
+
+        keep = box_non_max_suppression(
+            predictions=predictions,
+            iou_threshold=threshold,
+            overlap_metric=overlap_metric,
+        )
+
+        return self.select(keep)
+
+    def as_detections(
+        self, selected_keypoint_indices: Iterable[int] | None = None
+    ) -> Detections:
+        """Convert a KeyPoints object to a Detections object. This approximates the
+        bounding box of the detected object by taking the bounding box that fits all key
+        points. Key points that are missing (`[0, 0]`), not finite, or marked not
+        visible via `visible` are left out, as in `with_nms`, and a skeleton with no
+        other key point is dropped.
+
+        Args:
+            selected_keypoint_indices: The
+                indices of the key points to include in the bounding box
+                calculation. This helps focus on a subset of key points,
+                e.g. when some are occluded. Captures all key points by
+                default. An empty sequence (`[]`) is treated the same as
+                `None` and selects all key points.
+
+        Returns:
+            detections: The converted detections object.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> key_points = sv.KeyPoints(
+            ...     xy=np.array([[[10, 20], [30, 40]]], dtype=np.float32)
+            ... )
+            >>> detections = key_points.as_detections()
+            >>> detections.xyxy
+            array([[10., 20., 30., 40.]], dtype=float32)
+
+            ```
+        """
+        # Inference can retain objects after every keypoint is omitted; an empty
+        # keypoint axis has no coordinates from which to construct a detection box.
+        if self.is_empty() or self.xy.shape[1] == 0:
+            return Detections.empty()
+
+        xy = self.xy
+        indices: npt.NDArray[np.intp] | None = None
+        if selected_keypoint_indices is not None:
+            candidate = np.asarray(list(selected_keypoint_indices), dtype=np.intp)
+            if candidate.size > 0:
+                indices = candidate
+        if indices is not None:
+            xy = xy[:, indices, :]
+
+        # [0, 0] is used by some frameworks to indicate a missing keypoint. Non-finite
+        # coordinates cannot form a valid detection box, so both cases are excluded.
+        valid = ~np.all(xy == 0, axis=2) & np.isfinite(xy).all(axis=2)  # (N, M)
+        # Callers hide unreliable keypoints through `visible` instead of removing
+        # them; `with_nms` already builds its boxes from visible keypoints only.
+        if self.visible is not None:
+            valid &= self.visible if indices is None else self.visible[:, indices]
+        has_valid = valid.any(axis=1)  # (N,)
+
+        x, y = xy[:, :, 0], xy[:, :, 1]
+        x_min = np.where(valid, x, np.inf).min(axis=1)
+        y_min = np.where(valid, y, np.inf).min(axis=1)
+        x_max = np.where(valid, x, -np.inf).max(axis=1)
+        y_max = np.where(valid, y, -np.inf).max(axis=1)
+
+        xyxy = np.stack((x_min, y_min, x_max, y_max), axis=1).astype(np.float32)
+        # Skeletons with no valid keypoints keep the original empty [0, 0, 0, 0] box.
+        xyxy[~has_valid] = 0.0
+
+        if self.detection_confidence is not None:
+            confidence = self.detection_confidence.astype(np.float32)
+        elif self.keypoint_confidence is not None:
+            keypoint_confidence = self.keypoint_confidence
+            if indices is not None:
+                keypoint_confidence = keypoint_confidence[:, indices]
+            confidence = keypoint_confidence.mean(axis=1).astype(np.float32)
+        else:
+            confidence = None
+
+        detections = Detections(xyxy=xyxy, confidence=confidence)
+        detections.class_id = self.class_id
+        detections.data = self.data
+        detections = detections.select(has_valid)
+
+        return detections
diff --git a/.venv/lib/python3.12/site-packages/supervision/key_points/skeletons.py b/.venv/lib/python3.12/site-packages/supervision/key_points/skeletons.py
new file mode 100644
index 0000000000000000000000000000000000000000..71edfd657ba9f7ee28cf7f9280d15b579685580e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/key_points/skeletons.py
@@ -0,0 +1,2646 @@
+from enum import Enum
+
+Edges = tuple[tuple[int, int], ...]
+
+
+class Skeleton(Enum):
+    COCO = (
+        (1, 2),
+        (1, 3),
+        (2, 3),
+        (2, 4),
+        (3, 5),
+        (6, 12),
+        (6, 7),
+        (6, 8),
+        (7, 13),
+        (7, 9),
+        (8, 10),
+        (9, 11),
+        (12, 13),
+        (14, 12),
+        (15, 13),
+        (16, 14),
+        (17, 15),
+    )
+
+    GHUM = (
+        (1, 2),
+        (1, 5),
+        (2, 3),
+        (3, 4),
+        (4, 8),
+        (5, 6),
+        (6, 7),
+        (7, 9),
+        (10, 11),
+        (12, 13),
+        (12, 14),
+        (12, 24),
+        (13, 15),
+        (13, 25),
+        (14, 16),
+        (15, 17),
+        (16, 18),
+        (15, 19),
+        (16, 22),
+        (17, 19),
+        (17, 21),
+        (17, 23),
+        (18, 20),
+        (19, 21),
+        (24, 25),
+        (24, 26),
+        (25, 27),
+        (26, 28),
+        (27, 29),
+        (28, 30),
+        (28, 32),
+        (29, 31),
+        (29, 33),
+        (30, 32),
+        (31, 33),
+    )
+
+    FACEMESH_TESSELATION_NO_IRIS = (
+        (128, 35),
+        (35, 140),
+        (140, 128),
+        (12, 1),
+        (1, 38),
+        (38, 12),
+        (233, 232),
+        (232, 121),
+        (121, 233),
+        (73, 38),
+        (38, 40),
+        (40, 73),
+        (129, 122),
+        (122, 48),
+        (48, 129),
+        (233, 122),
+        (122, 129),
+        (129, 233),
+        (105, 70),
+        (70, 68),
+        (68, 105),
+        (176, 172),
+        (172, 149),
+        (149, 176),
+        (119, 51),
+        (51, 102),
+        (102, 119),
+        (74, 40),
+        (40, 41),
+        (41, 74),
+        (10, 152),
+        (152, 109),
+        (109, 10),
+        (49, 116),
+        (116, 132),
+        (132, 49),
+        (195, 205),
+        (205, 212),
+        (212, 195),
+        (75, 41),
+        (41, 186),
+        (186, 75),
+        (81, 43),
+        (43, 184),
+        (184, 81),
+        (41, 93),
+        (93, 187),
+        (187, 41),
+        (231, 230),
+        (230, 119),
+        (119, 231),
+        (203, 213),
+        (213, 215),
+        (215, 203),
+        (84, 19),
+        (19, 18),
+        (18, 84),
+        (77, 62),
+        (62, 147),
+        (147, 77),
+        (161, 30),
+        (30, 31),
+        (31, 161),
+        (57, 158),
+        (158, 174),
+        (174, 57),
+        (107, 205),
+        (205, 195),
+        (195, 107),
+        (136, 215),
+        (215, 193),
+        (193, 136),
+        (204, 166),
+        (166, 99),
+        (99, 204),
+        (22, 72),
+        (72, 69),
+        (69, 22),
+        (52, 46),
+        (46, 5),
+        (5, 52),
+        (145, 25),
+        (25, 24),
+        (24, 145),
+        (78, 147),
+        (147, 92),
+        (92, 78),
+        (206, 51),
+        (51, 188),
+        (188, 206),
+        (202, 201),
+        (201, 19),
+        (19, 202),
+        (92, 107),
+        (107, 183),
+        (183, 92),
+        (91, 92),
+        (92, 182),
+        (182, 91),
+        (86, 85),
+        (85, 18),
+        (18, 86),
+        (207, 204),
+        (204, 37),
+        (37, 207),
+        (149, 172),
+        (172, 141),
+        (141, 149),
+        (93, 41),
+        (41, 40),
+        (40, 93),
+        (194, 190),
+        (190, 245),
+        (245, 194),
+        (160, 159),
+        (159, 29),
+        (29, 160),
+        (248, 247),
+        (247, 162),
+        (162, 248),
+        (237, 4),
+        (4, 197),
+        (197, 237),
+        (55, 69),
+        (69, 105),
+        (105, 55),
+        (194, 169),
+        (169, 9),
+        (9, 194),
+        (118, 229),
+        (229, 32),
+        (32, 118),
+        (190, 194),
+        (194, 56),
+        (56, 190),
+        (99, 98),
+        (98, 100),
+        (100, 99),
+        (127, 48),
+        (48, 101),
+        (101, 127),
+        (167, 80),
+        (80, 219),
+        (219, 167),
+        (156, 155),
+        (155, 27),
+        (27, 156),
+        (210, 50),
+        (50, 132),
+        (132, 210),
+        (136, 137),
+        (137, 151),
+        (151, 136),
+        (48, 127),
+        (127, 218),
+        (218, 48),
+        (224, 53),
+        (53, 54),
+        (54, 224),
+        (46, 52),
+        (52, 135),
+        (135, 46),
+        (212, 171),
+        (171, 141),
+        (141, 212),
+        (68, 70),
+        (70, 109),
+        (109, 68),
+        (44, 107),
+        (107, 92),
+        (92, 44),
+        (231, 120),
+        (120, 121),
+        (121, 231),
+        (227, 131),
+        (131, 248),
+        (248, 227),
+        (64, 54),
+        (54, 53),
+        (53, 64),
+        (239, 21),
+        (21, 243),
+        (243, 239),
+        (47, 71),
+        (71, 157),
+        (157, 47),
+        (79, 63),
+        (63, 97),
+        (97, 79),
+        (47, 54),
+        (54, 64),
+        (64, 47),
+        (144, 35),
+        (35, 228),
+        (228, 144),
+        (124, 118),
+        (118, 112),
+        (112, 124),
+        (45, 126),
+        (126, 20),
+        (20, 45),
+        (237, 135),
+        (135, 52),
+        (52, 237),
+        (217, 207),
+        (207, 206),
+        (206, 217),
+        (155, 154),
+        (154, 23),
+        (23, 155),
+        (40, 38),
+        (38, 168),
+        (168, 40),
+        (201, 202),
+        (202, 209),
+        (209, 201),
+        (37, 143),
+        (143, 101),
+        (101, 37),
+        (58, 213),
+        (213, 203),
+        (203, 58),
+        (21, 61),
+        (61, 100),
+        (100, 21),
+        (29, 159),
+        (159, 158),
+        (158, 29),
+        (36, 227),
+        (227, 114),
+        (114, 36),
+        (161, 160),
+        (160, 28),
+        (28, 161),
+        (205, 203),
+        (203, 211),
+        (211, 205),
+        (114, 226),
+        (226, 47),
+        (47, 114),
+        (44, 203),
+        (203, 205),
+        (205, 44),
+        (63, 77),
+        (77, 78),
+        (78, 63),
+        (138, 124),
+        (124, 117),
+        (117, 138),
+        (42, 39),
+        (39, 73),
+        (73, 42),
+        (204, 130),
+        (130, 143),
+        (143, 204),
+        (65, 99),
+        (99, 241),
+        (241, 65),
+        (50, 103),
+        (103, 65),
+        (65, 50),
+        (42, 74),
+        (74, 75),
+        (75, 42),
+        (213, 217),
+        (217, 208),
+        (208, 213),
+        (43, 75),
+        (75, 185),
+        (185, 43),
+        (170, 171),
+        (171, 212),
+        (212, 170),
+        (171, 150),
+        (150, 177),
+        (177, 171),
+        (106, 67),
+        (67, 70),
+        (70, 106),
+        (123, 7),
+        (7, 169),
+        (169, 123),
+        (124, 148),
+        (148, 188),
+        (188, 124),
+        (97, 78),
+        (78, 91),
+        (91, 97),
+        (66, 56),
+        (56, 108),
+        (108, 66),
+        (90, 91),
+        (91, 181),
+        (181, 90),
+        (102, 101),
+        (101, 121),
+        (121, 102),
+        (64, 106),
+        (106, 105),
+        (105, 64),
+        (94, 138),
+        (138, 228),
+        (228, 94),
+        (16, 87),
+        (87, 86),
+        (86, 16),
+        (130, 103),
+        (103, 50),
+        (50, 130),
+        (15, 88),
+        (88, 87),
+        (87, 15),
+        (56, 9),
+        (9, 10),
+        (10, 56),
+        (101, 48),
+        (48, 122),
+        (122, 101),
+        (146, 24),
+        (24, 23),
+        (23, 146),
+        (89, 90),
+        (90, 180),
+        (180, 89),
+        (7, 123),
+        (123, 197),
+        (197, 7),
+        (89, 96),
+        (96, 97),
+        (97, 89),
+        (139, 173),
+        (173, 137),
+        (137, 139),
+        (216, 59),
+        (59, 173),
+        (173, 216),
+        (116, 49),
+        (49, 220),
+        (220, 116),
+        (43, 81),
+        (81, 82),
+        (82, 43),
+        (196, 4),
+        (4, 52),
+        (52, 196),
+        (44, 147),
+        (147, 62),
+        (62, 44),
+        (172, 176),
+        (176, 200),
+        (200, 172),
+        (82, 83),
+        (83, 39),
+        (39, 82),
+        (54, 47),
+        (47, 226),
+        (226, 54),
+        (145, 164),
+        (164, 111),
+        (111, 145),
+        (53, 66),
+        (66, 67),
+        (67, 53),
+        (230, 229),
+        (229, 118),
+        (118, 230),
+        (35, 128),
+        (128, 235),
+        (235, 35),
+        (108, 109),
+        (109, 70),
+        (70, 108),
+        (110, 109),
+        (109, 152),
+        (152, 110),
+        (49, 65),
+        (65, 236),
+        (236, 49),
+        (63, 79),
+        (79, 192),
+        (192, 63),
+        (130, 210),
+        (210, 127),
+        (127, 130),
+        (112, 36),
+        (36, 144),
+        (144, 112),
+        (118, 124),
+        (124, 51),
+        (51, 118),
+        (223, 66),
+        (66, 53),
+        (53, 223),
+        (20, 126),
+        (126, 142),
+        (142, 20),
+        (222, 56),
+        (56, 66),
+        (66, 222),
+        (4, 196),
+        (196, 198),
+        (198, 4),
+        (26, 8),
+        (8, 34),
+        (34, 26),
+        (221, 238),
+        (238, 45),
+        (45, 221),
+        (71, 72),
+        (72, 140),
+        (140, 71),
+        (123, 194),
+        (194, 246),
+        (246, 123),
+        (248, 131),
+        (131, 34),
+        (34, 248),
+        (72, 22),
+        (22, 163),
+        (163, 72),
+        (171, 170),
+        (170, 151),
+        (151, 171),
+        (189, 175),
+        (175, 197),
+        (197, 189),
+        (217, 187),
+        (187, 93),
+        (93, 217),
+        (3, 98),
+        (98, 168),
+        (168, 3),
+        (142, 126),
+        (126, 242),
+        (242, 142),
+        (165, 168),
+        (168, 38),
+        (38, 165),
+        (73, 39),
+        (39, 13),
+        (13, 73),
+        (39, 83),
+        (83, 14),
+        (14, 39),
+        (64, 69),
+        (69, 72),
+        (72, 64),
+        (227, 36),
+        (36, 112),
+        (112, 227),
+        (102, 51),
+        (51, 206),
+        (206, 102),
+        (207, 93),
+        (93, 166),
+        (166, 207),
+        (210, 199),
+        (199, 218),
+        (218, 210),
+        (166, 168),
+        (168, 98),
+        (98, 166),
+        (221, 116),
+        (116, 219),
+        (219, 221),
+        (134, 113),
+        (113, 244),
+        (244, 134),
+        (240, 239),
+        (239, 242),
+        (242, 240),
+        (215, 136),
+        (136, 170),
+        (170, 215),
+        (191, 174),
+        (174, 134),
+        (134, 191),
+        (172, 209),
+        (209, 33),
+        (33, 172),
+        (126, 45),
+        (45, 238),
+        (238, 126),
+        (87, 88),
+        (88, 179),
+        (179, 87),
+        (86, 87),
+        (87, 180),
+        (180, 86),
+        (85, 86),
+        (86, 181),
+        (181, 85),
+        (84, 85),
+        (85, 182),
+        (182, 84),
+        (202, 84),
+        (84, 183),
+        (183, 202),
+        (138, 94),
+        (94, 133),
+        (133, 138),
+        (77, 63),
+        (63, 184),
+        (184, 77),
+        (62, 77),
+        (77, 185),
+        (185, 62),
+        (58, 62),
+        (62, 186),
+        (186, 58),
+        (213, 58),
+        (58, 187),
+        (187, 213),
+        (215, 208),
+        (208, 188),
+        (188, 215),
+        (35, 144),
+        (144, 157),
+        (157, 35),
+        (80, 240),
+        (240, 238),
+        (238, 80),
+        (124, 138),
+        (138, 178),
+        (178, 124),
+        (45, 2),
+        (2, 5),
+        (5, 45),
+        (202, 195),
+        (195, 33),
+        (33, 202),
+        (65, 103),
+        (103, 130),
+        (130, 65),
+        (214, 216),
+        (216, 139),
+        (139, 214),
+        (60, 167),
+        (167, 220),
+        (220, 60),
+        (243, 100),
+        (100, 98),
+        (98, 243),
+        (3, 95),
+        (95, 142),
+        (142, 3),
+        (76, 60),
+        (60, 236),
+        (236, 76),
+        (25, 111),
+        (111, 229),
+        (229, 25),
+        (26, 131),
+        (131, 227),
+        (227, 26),
+        (24, 25),
+        (25, 230),
+        (230, 24),
+        (23, 24),
+        (24, 231),
+        (231, 23),
+        (27, 23),
+        (23, 232),
+        (232, 27),
+        (113, 27),
+        (27, 233),
+        (233, 113),
+        (190, 191),
+        (191, 244),
+        (244, 190),
+        (222, 57),
+        (57, 191),
+        (191, 222),
+        (29, 57),
+        (57, 222),
+        (222, 29),
+        (28, 29),
+        (29, 223),
+        (223, 28),
+        (30, 28),
+        (28, 224),
+        (224, 30),
+        (31, 30),
+        (30, 225),
+        (225, 31),
+        (248, 31),
+        (31, 226),
+        (226, 248),
+        (239, 80),
+        (80, 21),
+        (21, 239),
+        (167, 60),
+        (60, 76),
+        (76, 167),
+        (61, 76),
+        (76, 241),
+        (241, 61),
+        (148, 178),
+        (178, 216),
+        (216, 148),
+        (21, 80),
+        (80, 167),
+        (167, 21),
+        (188, 148),
+        (148, 214),
+        (214, 188),
+        (113, 234),
+        (234, 245),
+        (245, 113),
+        (234, 129),
+        (129, 246),
+        (246, 234),
+        (129, 115),
+        (115, 189),
+        (189, 129),
+        (115, 218),
+        (218, 175),
+        (175, 115),
+        (132, 116),
+        (116, 221),
+        (221, 132),
+        (218, 199),
+        (199, 237),
+        (237, 218),
+        (199, 132),
+        (132, 135),
+        (135, 199),
+        (178, 133),
+        (133, 59),
+        (59, 178),
+        (144, 36),
+        (36, 125),
+        (125, 144),
+        (111, 164),
+        (164, 8),
+        (8, 111),
+        (229, 111),
+        (111, 26),
+        (26, 229),
+        (357, 390),
+        (390, 369),
+        (369, 357),
+        (12, 303),
+        (303, 268),
+        (268, 12),
+        (453, 351),
+        (351, 350),
+        (350, 453),
+        (303, 304),
+        (304, 270),
+        (270, 303),
+        (358, 344),
+        (344, 278),
+        (278, 358),
+        (453, 454),
+        (454, 358),
+        (358, 453),
+        (334, 333),
+        (333, 298),
+        (298, 334),
+        (176, 153),
+        (153, 378),
+        (378, 176),
+        (348, 349),
+        (349, 331),
+        (331, 348),
+        (304, 305),
+        (305, 271),
+        (271, 304),
+        (10, 337),
+        (337, 338),
+        (338, 10),
+        (279, 280),
+        (280, 361),
+        (361, 279),
+        (419, 263),
+        (263, 432),
+        (432, 419),
+        (305, 409),
+        (409, 410),
+        (410, 305),
+        (311, 416),
+        (416, 408),
+        (408, 311),
+        (271, 410),
+        (410, 411),
+        (411, 271),
+        (451, 349),
+        (349, 348),
+        (348, 451),
+        (423, 431),
+        (431, 435),
+        (435, 423),
+        (314, 315),
+        (315, 18),
+        (18, 314),
+        (307, 308),
+        (308, 376),
+        (376, 307),
+        (388, 389),
+        (389, 261),
+        (261, 388),
+        (287, 415),
+        (415, 399),
+        (399, 287),
+        (336, 407),
+        (407, 419),
+        (419, 336),
+        (365, 368),
+        (368, 417),
+        (417, 365),
+        (424, 359),
+        (359, 328),
+        (328, 424),
+        (252, 285),
+        (285, 299),
+        (299, 252),
+        (282, 6),
+        (6, 5),
+        (5, 282),
+        (374, 375),
+        (375, 254),
+        (254, 374),
+        (308, 321),
+        (321, 322),
+        (322, 308),
+        (426, 428),
+        (428, 412),
+        (412, 426),
+        (422, 314),
+        (314, 19),
+        (19, 422),
+        (322, 406),
+        (406, 407),
+        (407, 322),
+        (321, 405),
+        (405, 406),
+        (406, 321),
+        (316, 17),
+        (17, 18),
+        (18, 316),
+        (427, 426),
+        (426, 267),
+        (267, 427),
+        (378, 401),
+        (401, 370),
+        (370, 378),
+        (323, 392),
+        (392, 270),
+        (270, 323),
+        (418, 466),
+        (466, 465),
+        (465, 418),
+        (387, 258),
+        (258, 259),
+        (259, 387),
+        (467, 261),
+        (261, 389),
+        (389, 467),
+        (457, 400),
+        (400, 420),
+        (420, 457),
+        (285, 333),
+        (333, 334),
+        (334, 285),
+        (418, 286),
+        (286, 9),
+        (9, 418),
+        (347, 341),
+        (341, 262),
+        (262, 347),
+        (414, 442),
+        (442, 286),
+        (286, 414),
+        (328, 461),
+        (461, 329),
+        (329, 328),
+        (356, 372),
+        (372, 330),
+        (330, 356),
+        (393, 440),
+        (440, 439),
+        (439, 393),
+        (383, 342),
+        (342, 257),
+        (257, 383),
+        (430, 421),
+        (421, 361),
+        (361, 430),
+        (365, 395),
+        (395, 380),
+        (380, 365),
+        (278, 344),
+        (344, 438),
+        (438, 278),
+        (444, 445),
+        (445, 284),
+        (284, 444),
+        (276, 441),
+        (441, 364),
+        (364, 276),
+        (432, 263),
+        (263, 370),
+        (370, 432),
+        (298, 339),
+        (339, 338),
+        (338, 298),
+        (274, 376),
+        (376, 322),
+        (322, 274),
+        (451, 452),
+        (452, 350),
+        (350, 451),
+        (447, 343),
+        (343, 468),
+        (468, 447),
+        (294, 335),
+        (335, 283),
+        (283, 294),
+        (459, 462),
+        (462, 463),
+        (463, 459),
+        (277, 354),
+        (354, 384),
+        (384, 277),
+        (309, 325),
+        (325, 326),
+        (326, 309),
+        (277, 301),
+        (301, 294),
+        (294, 277),
+        (373, 346),
+        (346, 448),
+        (448, 373),
+        (353, 346),
+        (346, 341),
+        (341, 353),
+        (275, 2),
+        (2, 20),
+        (20, 275),
+        (457, 249),
+        (249, 282),
+        (282, 457),
+        (437, 428),
+        (428, 426),
+        (426, 437),
+        (382, 257),
+        (257, 253),
+        (253, 382),
+        (270, 392),
+        (392, 394),
+        (394, 270),
+        (201, 200),
+        (200, 429),
+        (429, 201),
+        (267, 331),
+        (331, 330),
+        (330, 267),
+        (288, 274),
+        (274, 423),
+        (423, 288),
+        (251, 463),
+        (463, 329),
+        (329, 251),
+        (259, 287),
+        (287, 385),
+        (385, 259),
+        (266, 354),
+        (354, 343),
+        (343, 266),
+        (388, 260),
+        (260, 258),
+        (258, 388),
+        (425, 432),
+        (432, 431),
+        (431, 425),
+        (343, 354),
+        (354, 277),
+        (277, 343),
+        (274, 336),
+        (336, 425),
+        (425, 274),
+        (293, 326),
+        (326, 308),
+        (308, 293),
+        (367, 448),
+        (448, 346),
+        (346, 367),
+        (272, 304),
+        (304, 303),
+        (303, 272),
+        (424, 267),
+        (267, 372),
+        (372, 424),
+        (295, 456),
+        (456, 461),
+        (461, 295),
+        (280, 279),
+        (279, 295),
+        (295, 280),
+        (272, 273),
+        (273, 305),
+        (305, 272),
+        (433, 435),
+        (435, 428),
+        (428, 433),
+        (273, 408),
+        (408, 409),
+        (409, 273),
+        (395, 431),
+        (431, 432),
+        (432, 395),
+        (396, 370),
+        (370, 401),
+        (401, 396),
+        (335, 334),
+        (334, 300),
+        (300, 335),
+        (352, 418),
+        (418, 169),
+        (169, 352),
+        (353, 281),
+        (281, 412),
+        (412, 353),
+        (326, 320),
+        (320, 321),
+        (321, 326),
+        (296, 297),
+        (297, 337),
+        (337, 296),
+        (320, 404),
+        (404, 405),
+        (405, 320),
+        (331, 349),
+        (349, 350),
+        (350, 331),
+        (294, 299),
+        (299, 334),
+        (334, 294),
+        (324, 455),
+        (455, 448),
+        (448, 324),
+        (16, 17),
+        (17, 316),
+        (316, 16),
+        (359, 430),
+        (430, 280),
+        (280, 359),
+        (15, 16),
+        (16, 317),
+        (317, 15),
+        (286, 337),
+        (337, 10),
+        (10, 286),
+        (330, 350),
+        (350, 351),
+        (351, 330),
+        (375, 381),
+        (381, 253),
+        (253, 375),
+        (319, 403),
+        (403, 404),
+        (404, 319),
+        (7, 198),
+        (198, 420),
+        (420, 7),
+        (319, 320),
+        (320, 326),
+        (326, 319),
+        (368, 365),
+        (365, 366),
+        (366, 368),
+        (436, 368),
+        (368, 398),
+        (398, 436),
+        (345, 439),
+        (439, 440),
+        (440, 345),
+        (273, 272),
+        (272, 312),
+        (312, 273),
+        (196, 6),
+        (6, 282),
+        (282, 196),
+        (274, 288),
+        (288, 292),
+        (292, 274),
+        (397, 429),
+        (429, 200),
+        (200, 397),
+        (312, 272),
+        (272, 269),
+        (269, 312),
+        (284, 445),
+        (445, 446),
+        (446, 284),
+        (374, 255),
+        (255, 340),
+        (340, 374),
+        (283, 335),
+        (335, 297),
+        (297, 283),
+        (450, 348),
+        (348, 347),
+        (347, 450),
+        (265, 448),
+        (448, 455),
+        (455, 265),
+        (337, 297),
+        (297, 300),
+        (300, 337),
+        (339, 11),
+        (11, 152),
+        (152, 339),
+        (279, 440),
+        (440, 456),
+        (456, 279),
+        (293, 408),
+        (408, 416),
+        (416, 293),
+        (359, 372),
+        (372, 356),
+        (356, 359),
+        (341, 346),
+        (346, 373),
+        (373, 341),
+        (347, 348),
+        (348, 281),
+        (281, 347),
+        (443, 444),
+        (444, 283),
+        (283, 443),
+        (20, 95),
+        (95, 371),
+        (371, 20),
+        (442, 443),
+        (443, 296),
+        (296, 442),
+        (249, 420),
+        (420, 198),
+        (198, 249),
+        (264, 256),
+        (256, 360),
+        (360, 264),
+        (441, 276),
+        (276, 275),
+        (275, 441),
+        (301, 384),
+        (384, 369),
+        (369, 301),
+        (352, 413),
+        (413, 466),
+        (466, 352),
+        (264, 468),
+        (468, 467),
+        (467, 264),
+        (302, 369),
+        (369, 390),
+        (390, 302),
+        (396, 379),
+        (379, 380),
+        (380, 396),
+        (413, 352),
+        (352, 420),
+        (420, 413),
+        (437, 427),
+        (427, 323),
+        (323, 437),
+        (3, 165),
+        (165, 394),
+        (394, 3),
+        (371, 463),
+        (463, 462),
+        (462, 371),
+        (165, 1),
+        (1, 268),
+        (268, 165),
+        (303, 12),
+        (12, 13),
+        (13, 303),
+        (269, 13),
+        (13, 14),
+        (14, 269),
+        (294, 301),
+        (301, 302),
+        (302, 294),
+        (447, 262),
+        (262, 341),
+        (341, 447),
+        (331, 267),
+        (267, 426),
+        (426, 331),
+        (427, 424),
+        (424, 392),
+        (392, 427),
+        (430, 356),
+        (356, 438),
+        (438, 430),
+        (392, 328),
+        (328, 327),
+        (327, 392),
+        (441, 458),
+        (458, 439),
+        (439, 441),
+        (342, 383),
+        (383, 363),
+        (363, 342),
+        (460, 458),
+        (458, 462),
+        (462, 460),
+        (435, 431),
+        (431, 395),
+        (395, 435),
+        (415, 464),
+        (464, 363),
+        (363, 415),
+        (397, 370),
+        (370, 263),
+        (263, 397),
+        (355, 462),
+        (462, 458),
+        (458, 355),
+        (317, 404),
+        (404, 403),
+        (403, 317),
+        (316, 405),
+        (405, 404),
+        (404, 316),
+        (315, 406),
+        (406, 405),
+        (405, 315),
+        (314, 407),
+        (407, 406),
+        (406, 314),
+        (422, 419),
+        (419, 407),
+        (407, 422),
+        (367, 402),
+        (402, 362),
+        (362, 367),
+        (307, 409),
+        (409, 408),
+        (408, 307),
+        (292, 410),
+        (410, 409),
+        (409, 292),
+        (288, 411),
+        (411, 410),
+        (410, 288),
+        (433, 437),
+        (437, 411),
+        (411, 433),
+        (435, 417),
+        (417, 412),
+        (412, 435),
+        (265, 369),
+        (369, 384),
+        (384, 265),
+        (310, 439),
+        (439, 458),
+        (458, 310),
+        (353, 377),
+        (377, 402),
+        (402, 353),
+        (275, 276),
+        (276, 5),
+        (5, 275),
+        (422, 429),
+        (429, 263),
+        (263, 422),
+        (295, 328),
+        (328, 359),
+        (359, 295),
+        (434, 417),
+        (417, 368),
+        (368, 434),
+        (290, 456),
+        (456, 440),
+        (440, 290),
+        (463, 371),
+        (371, 327),
+        (327, 463),
+        (3, 327),
+        (327, 371),
+        (371, 3),
+        (306, 461),
+        (461, 456),
+        (456, 306),
+        (255, 450),
+        (450, 449),
+        (449, 255),
+        (256, 262),
+        (262, 447),
+        (447, 256),
+        (254, 451),
+        (451, 450),
+        (450, 254),
+        (253, 452),
+        (452, 451),
+        (451, 253),
+        (257, 453),
+        (453, 452),
+        (452, 257),
+        (342, 454),
+        (454, 453),
+        (453, 342),
+        (414, 465),
+        (465, 464),
+        (464, 414),
+        (442, 414),
+        (414, 415),
+        (415, 442),
+        (259, 443),
+        (443, 442),
+        (442, 259),
+        (258, 444),
+        (444, 443),
+        (443, 258),
+        (260, 445),
+        (445, 444),
+        (444, 260),
+        (261, 446),
+        (446, 445),
+        (445, 261),
+        (468, 343),
+        (343, 446),
+        (446, 468),
+        (460, 459),
+        (459, 251),
+        (251, 460),
+        (290, 393),
+        (393, 291),
+        (291, 290),
+        (291, 329),
+        (329, 461),
+        (461, 291),
+        (377, 434),
+        (434, 436),
+        (436, 377),
+        (251, 291),
+        (291, 393),
+        (393, 251),
+        (412, 417),
+        (417, 434),
+        (434, 412),
+        (342, 464),
+        (464, 465),
+        (465, 342),
+        (454, 465),
+        (465, 466),
+        (466, 454),
+        (358, 466),
+        (466, 413),
+        (413, 358),
+        (344, 413),
+        (413, 400),
+        (400, 344),
+        (361, 364),
+        (364, 441),
+        (441, 361),
+        (438, 400),
+        (400, 457),
+        (457, 438),
+        (421, 457),
+        (457, 364),
+        (364, 421),
+        (402, 436),
+        (436, 289),
+        (289, 402),
+        (373, 384),
+        (384, 354),
+        (354, 373),
+        (340, 256),
+        (256, 250),
+        (250, 340),
+        (449, 262),
+        (262, 256),
+        (256, 449),
+        (134, 244),
+        (244, 191),
+        (191, 134),
+        (134, 156),
+        (156, 113),
+        (113, 134),
+        (34, 247),
+        (247, 248),
+        (248, 34),
+        (34, 131),
+        (131, 26),
+        (26, 34),
+        (399, 385),
+        (385, 287),
+        (287, 399),
+        (363, 399),
+        (399, 415),
+        (415, 363),
+        (363, 464),
+        (464, 342),
+        (342, 363),
+        (264, 360),
+        (360, 468),
+        (468, 264),
+        (264, 250),
+        (250, 256),
+        (256, 264),
+        (467, 468),
+        (468, 261),
+        (261, 467),
+        (76, 61),
+        (61, 167),
+        (167, 76),
+        (239, 240),
+        (240, 80),
+        (80, 239),
+        (163, 128),
+        (128, 140),
+        (140, 163),
+        (73, 12),
+        (12, 38),
+        (38, 73),
+        (122, 233),
+        (233, 121),
+        (121, 122),
+        (74, 73),
+        (73, 40),
+        (40, 74),
+        (115, 129),
+        (129, 48),
+        (48, 115),
+        (234, 233),
+        (233, 129),
+        (129, 234),
+        (104, 105),
+        (105, 68),
+        (68, 104),
+        (153, 176),
+        (176, 149),
+        (149, 153),
+        (120, 119),
+        (119, 102),
+        (102, 120),
+        (75, 74),
+        (74, 41),
+        (41, 75),
+        (108, 10),
+        (10, 109),
+        (109, 108),
+        (50, 49),
+        (49, 132),
+        (132, 50),
+        (33, 195),
+        (195, 212),
+        (212, 33),
+        (185, 75),
+        (75, 186),
+        (186, 185),
+        (192, 81),
+        (81, 184),
+        (184, 192),
+        (186, 41),
+        (41, 187),
+        (187, 186),
+        (120, 231),
+        (231, 119),
+        (119, 120),
+        (211, 203),
+        (203, 215),
+        (215, 211),
+        (85, 84),
+        (84, 18),
+        (18, 85),
+        (78, 77),
+        (77, 147),
+        (147, 78),
+        (162, 161),
+        (161, 31),
+        (31, 162),
+        (191, 57),
+        (57, 174),
+        (174, 191),
+        (183, 107),
+        (107, 195),
+        (195, 183),
+        (139, 136),
+        (136, 193),
+        (193, 139),
+        (130, 204),
+        (204, 99),
+        (99, 130),
+        (55, 22),
+        (22, 69),
+        (69, 55),
+        (6, 52),
+        (52, 5),
+        (5, 6),
+        (146, 145),
+        (145, 24),
+        (24, 146),
+        (91, 78),
+        (78, 92),
+        (92, 91),
+        (208, 206),
+        (206, 188),
+        (188, 208),
+        (84, 202),
+        (202, 19),
+        (19, 84),
+        (182, 92),
+        (92, 183),
+        (183, 182),
+        (181, 91),
+        (91, 182),
+        (182, 181),
+        (17, 86),
+        (86, 18),
+        (18, 17),
+        (206, 207),
+        (207, 37),
+        (37, 206),
+        (177, 149),
+        (149, 141),
+        (141, 177),
+        (166, 93),
+        (93, 40),
+        (40, 166),
+        (246, 194),
+        (194, 245),
+        (245, 246),
+        (28, 160),
+        (160, 29),
+        (29, 28),
+        (31, 248),
+        (248, 162),
+        (162, 31),
+        (175, 237),
+        (237, 197),
+        (197, 175),
+        (104, 55),
+        (55, 105),
+        (105, 104),
+        (56, 194),
+        (194, 9),
+        (9, 56),
+        (112, 118),
+        (118, 32),
+        (32, 112),
+        (222, 190),
+        (190, 56),
+        (56, 222),
+        (241, 99),
+        (99, 100),
+        (100, 241),
+        (143, 127),
+        (127, 101),
+        (101, 143),
+        (220, 167),
+        (167, 219),
+        (219, 220),
+        (113, 156),
+        (156, 27),
+        (27, 113),
+        (199, 210),
+        (210, 132),
+        (132, 199),
+        (170, 136),
+        (136, 151),
+        (151, 170),
+        (115, 48),
+        (48, 218),
+        (218, 115),
+        (225, 224),
+        (224, 54),
+        (54, 225),
+        (221, 46),
+        (46, 135),
+        (135, 221),
+        (33, 212),
+        (212, 141),
+        (141, 33),
+        (110, 68),
+        (68, 109),
+        (109, 110),
+        (147, 44),
+        (44, 92),
+        (92, 147),
+        (232, 231),
+        (231, 121),
+        (121, 232),
+        (114, 227),
+        (227, 248),
+        (248, 114),
+        (106, 64),
+        (64, 53),
+        (53, 106),
+        (242, 239),
+        (239, 243),
+        (243, 242),
+        (125, 47),
+        (47, 157),
+        (157, 125),
+        (96, 79),
+        (79, 97),
+        (97, 96),
+        (71, 47),
+        (47, 64),
+        (64, 71),
+        (117, 144),
+        (144, 228),
+        (228, 117),
+        (117, 124),
+        (124, 112),
+        (112, 117),
+        (2, 45),
+        (45, 20),
+        (20, 2),
+        (4, 237),
+        (237, 52),
+        (52, 4),
+        (208, 217),
+        (217, 206),
+        (206, 208),
+        (27, 155),
+        (155, 23),
+        (23, 27),
+        (166, 40),
+        (40, 168),
+        (168, 166),
+        (200, 201),
+        (201, 209),
+        (209, 200),
+        (102, 37),
+        (37, 101),
+        (101, 102),
+        (44, 58),
+        (58, 203),
+        (203, 44),
+        (243, 21),
+        (21, 100),
+        (100, 243),
+        (57, 29),
+        (29, 158),
+        (158, 57),
+        (125, 36),
+        (36, 114),
+        (114, 125),
+        (30, 161),
+        (161, 28),
+        (28, 30),
+        (212, 205),
+        (205, 211),
+        (211, 212),
+        (125, 114),
+        (114, 47),
+        (47, 125),
+        (107, 44),
+        (44, 205),
+        (205, 107),
+        (97, 63),
+        (63, 78),
+        (78, 97),
+        (228, 138),
+        (138, 117),
+        (117, 228),
+        (74, 42),
+        (42, 73),
+        (73, 74),
+        (37, 204),
+        (204, 143),
+        (143, 37),
+        (236, 65),
+        (65, 241),
+        (241, 236),
+        (49, 50),
+        (50, 65),
+        (65, 49),
+        (43, 42),
+        (42, 75),
+        (75, 43),
+        (215, 213),
+        (213, 208),
+        (208, 215),
+        (184, 43),
+        (43, 185),
+        (185, 184),
+        (211, 170),
+        (170, 212),
+        (212, 211),
+        (141, 171),
+        (171, 177),
+        (177, 141),
+        (105, 106),
+        (106, 70),
+        (70, 105),
+        (194, 123),
+        (123, 169),
+        (169, 194),
+        (51, 124),
+        (124, 188),
+        (188, 51),
+        (90, 97),
+        (97, 91),
+        (91, 90),
+        (67, 66),
+        (66, 108),
+        (108, 67),
+        (180, 90),
+        (90, 181),
+        (181, 180),
+        (120, 102),
+        (102, 121),
+        (121, 120),
+        (69, 64),
+        (64, 105),
+        (105, 69),
+        (235, 94),
+        (94, 228),
+        (228, 235),
+        (17, 16),
+        (16, 86),
+        (86, 17),
+        (210, 130),
+        (130, 50),
+        (50, 210),
+        (16, 15),
+        (15, 87),
+        (87, 16),
+        (108, 56),
+        (56, 10),
+        (10, 108),
+        (121, 101),
+        (101, 122),
+        (122, 121),
+        (154, 146),
+        (146, 23),
+        (23, 154),
+        (179, 89),
+        (89, 180),
+        (180, 179),
+        (198, 7),
+        (7, 197),
+        (197, 198),
+        (90, 89),
+        (89, 97),
+        (97, 90),
+        (136, 139),
+        (139, 137),
+        (137, 136),
+        (139, 216),
+        (216, 173),
+        (173, 139),
+        (219, 116),
+        (116, 220),
+        (220, 219),
+        (42, 43),
+        (43, 82),
+        (82, 42),
+        (6, 196),
+        (196, 52),
+        (52, 6),
+        (58, 44),
+        (44, 62),
+        (62, 58),
+        (209, 172),
+        (172, 200),
+        (200, 209),
+        (42, 82),
+        (82, 39),
+        (39, 42),
+        (225, 54),
+        (54, 226),
+        (226, 225),
+        (25, 145),
+        (145, 111),
+        (111, 25),
+        (106, 53),
+        (53, 67),
+        (67, 106),
+        (119, 230),
+        (230, 118),
+        (118, 119),
+        (228, 35),
+        (35, 235),
+        (235, 228),
+        (67, 108),
+        (108, 70),
+        (70, 67),
+        (11, 110),
+        (110, 152),
+        (152, 11),
+        (220, 49),
+        (49, 236),
+        (236, 220),
+        (184, 63),
+        (63, 192),
+        (192, 184),
+        (143, 130),
+        (130, 127),
+        (127, 143),
+        (117, 112),
+        (112, 144),
+        (144, 117),
+        (119, 118),
+        (118, 51),
+        (51, 119),
+        (224, 223),
+        (223, 53),
+        (53, 224),
+        (95, 20),
+        (20, 142),
+        (142, 95),
+        (223, 222),
+        (222, 66),
+        (66, 223),
+        (197, 4),
+        (4, 198),
+        (198, 197),
+        (46, 221),
+        (221, 45),
+        (45, 46),
+        (157, 71),
+        (71, 140),
+        (140, 157),
+        (189, 123),
+        (123, 246),
+        (246, 189),
+        (140, 72),
+        (72, 163),
+        (163, 140),
+        (150, 171),
+        (171, 151),
+        (151, 150),
+        (123, 189),
+        (189, 197),
+        (197, 123),
+        (207, 217),
+        (217, 93),
+        (93, 207),
+        (165, 3),
+        (3, 168),
+        (168, 165),
+        (243, 142),
+        (142, 242),
+        (242, 243),
+        (1, 165),
+        (165, 38),
+        (38, 1),
+        (12, 73),
+        (73, 13),
+        (13, 12),
+        (13, 39),
+        (39, 14),
+        (14, 13),
+        (71, 64),
+        (64, 72),
+        (72, 71),
+        (32, 227),
+        (227, 112),
+        (112, 32),
+        (37, 102),
+        (102, 206),
+        (206, 37),
+        (204, 207),
+        (207, 166),
+        (166, 204),
+        (127, 210),
+        (210, 218),
+        (218, 127),
+        (99, 166),
+        (166, 98),
+        (98, 99),
+        (238, 221),
+        (221, 219),
+        (219, 238),
+        (238, 240),
+        (240, 242),
+        (242, 238),
+        (211, 215),
+        (215, 170),
+        (170, 211),
+        (141, 172),
+        (172, 33),
+        (33, 141),
+        (242, 126),
+        (126, 238),
+        (238, 242),
+        (180, 87),
+        (87, 179),
+        (179, 180),
+        (181, 86),
+        (86, 180),
+        (180, 181),
+        (182, 85),
+        (85, 181),
+        (181, 182),
+        (183, 84),
+        (84, 182),
+        (182, 183),
+        (195, 202),
+        (202, 183),
+        (183, 195),
+        (178, 138),
+        (138, 133),
+        (133, 178),
+        (185, 77),
+        (77, 184),
+        (184, 185),
+        (186, 62),
+        (62, 185),
+        (185, 186),
+        (187, 58),
+        (58, 186),
+        (186, 187),
+        (217, 213),
+        (213, 187),
+        (187, 217),
+        (193, 215),
+        (215, 188),
+        (188, 193),
+        (140, 35),
+        (35, 157),
+        (157, 140),
+        (219, 80),
+        (80, 238),
+        (238, 219),
+        (148, 124),
+        (124, 178),
+        (178, 148),
+        (46, 45),
+        (45, 5),
+        (5, 46),
+        (209, 202),
+        (202, 33),
+        (33, 209),
+        (99, 65),
+        (65, 130),
+        (130, 99),
+        (193, 214),
+        (214, 139),
+        (139, 193),
+        (236, 60),
+        (60, 220),
+        (220, 236),
+        (142, 243),
+        (243, 98),
+        (98, 142),
+        (98, 3),
+        (3, 142),
+        (142, 98),
+        (241, 76),
+        (76, 236),
+        (236, 241),
+        (230, 25),
+        (25, 229),
+        (229, 230),
+        (32, 26),
+        (26, 227),
+        (227, 32),
+        (231, 24),
+        (24, 230),
+        (230, 231),
+        (232, 23),
+        (23, 231),
+        (231, 232),
+        (233, 27),
+        (27, 232),
+        (232, 233),
+        (234, 113),
+        (113, 233),
+        (233, 234),
+        (245, 190),
+        (190, 244),
+        (244, 245),
+        (190, 222),
+        (222, 191),
+        (191, 190),
+        (223, 29),
+        (29, 222),
+        (222, 223),
+        (224, 28),
+        (28, 223),
+        (223, 224),
+        (225, 30),
+        (30, 224),
+        (224, 225),
+        (226, 31),
+        (31, 225),
+        (225, 226),
+        (114, 248),
+        (248, 226),
+        (226, 114),
+        (100, 61),
+        (61, 241),
+        (241, 100),
+        (214, 148),
+        (148, 216),
+        (216, 214),
+        (61, 21),
+        (21, 167),
+        (167, 61),
+        (193, 188),
+        (188, 214),
+        (214, 193),
+        (244, 113),
+        (113, 245),
+        (245, 244),
+        (245, 234),
+        (234, 246),
+        (246, 245),
+        (246, 129),
+        (129, 189),
+        (189, 246),
+        (189, 115),
+        (115, 175),
+        (175, 189),
+        (135, 132),
+        (132, 221),
+        (221, 135),
+        (175, 218),
+        (218, 237),
+        (237, 175),
+        (237, 199),
+        (199, 135),
+        (135, 237),
+        (216, 178),
+        (178, 59),
+        (59, 216),
+        (157, 144),
+        (144, 125),
+        (125, 157),
+        (26, 111),
+        (111, 8),
+        (8, 26),
+        (32, 229),
+        (229, 26),
+        (26, 32),
+        (265, 357),
+        (357, 369),
+        (369, 265),
+        (1, 12),
+        (12, 268),
+        (268, 1),
+        (452, 453),
+        (453, 350),
+        (350, 452),
+        (268, 303),
+        (303, 270),
+        (270, 268),
+        (351, 358),
+        (358, 278),
+        (278, 351),
+        (351, 453),
+        (453, 358),
+        (358, 351),
+        (300, 334),
+        (334, 298),
+        (298, 300),
+        (397, 176),
+        (176, 378),
+        (378, 397),
+        (281, 348),
+        (348, 331),
+        (331, 281),
+        (270, 304),
+        (304, 271),
+        (271, 270),
+        (152, 10),
+        (10, 338),
+        (338, 152),
+        (345, 279),
+        (279, 361),
+        (361, 345),
+        (425, 419),
+        (419, 432),
+        (432, 425),
+        (271, 305),
+        (305, 410),
+        (410, 271),
+        (273, 311),
+        (311, 408),
+        (408, 273),
+        (323, 271),
+        (271, 411),
+        (411, 323),
+        (450, 451),
+        (451, 348),
+        (348, 450),
+        (433, 423),
+        (423, 435),
+        (435, 433),
+        (19, 314),
+        (314, 18),
+        (18, 19),
+        (292, 307),
+        (307, 376),
+        (376, 292),
+        (260, 388),
+        (388, 261),
+        (261, 260),
+        (425, 336),
+        (336, 419),
+        (419, 425),
+        (435, 365),
+        (365, 417),
+        (417, 435),
+        (392, 424),
+        (424, 328),
+        (328, 392),
+        (302, 252),
+        (252, 299),
+        (299, 302),
+        (276, 282),
+        (282, 5),
+        (5, 276),
+        (255, 374),
+        (374, 254),
+        (254, 255),
+        (376, 308),
+        (308, 322),
+        (322, 376),
+        (281, 426),
+        (426, 412),
+        (412, 281),
+        (201, 422),
+        (422, 19),
+        (19, 201),
+        (336, 322),
+        (322, 407),
+        (407, 336),
+        (322, 321),
+        (321, 406),
+        (406, 322),
+        (315, 316),
+        (316, 18),
+        (18, 315),
+        (424, 427),
+        (427, 267),
+        (267, 424),
+        (397, 378),
+        (378, 370),
+        (370, 397),
+        (271, 323),
+        (323, 270),
+        (270, 271),
+        (414, 418),
+        (418, 465),
+        (465, 414),
+        (386, 387),
+        (387, 259),
+        (259, 386),
+        (249, 457),
+        (457, 420),
+        (420, 249),
+        (299, 285),
+        (285, 334),
+        (334, 299),
+        (169, 418),
+        (418, 9),
+        (9, 169),
+        (449, 347),
+        (347, 262),
+        (262, 449),
+        (418, 414),
+        (414, 286),
+        (286, 418),
+        (327, 328),
+        (328, 329),
+        (329, 327),
+        (278, 356),
+        (356, 330),
+        (330, 278),
+        (310, 393),
+        (393, 439),
+        (439, 310),
+        (382, 383),
+        (383, 257),
+        (257, 382),
+        (280, 430),
+        (430, 361),
+        (361, 280),
+        (366, 365),
+        (365, 380),
+        (380, 366),
+        (356, 278),
+        (278, 438),
+        (438, 356),
+        (283, 444),
+        (444, 284),
+        (284, 283),
+        (282, 276),
+        (276, 364),
+        (364, 282),
+        (396, 432),
+        (432, 370),
+        (370, 396),
+        (300, 298),
+        (298, 338),
+        (338, 300),
+        (336, 274),
+        (274, 322),
+        (322, 336),
+        (349, 451),
+        (451, 350),
+        (350, 349),
+        (360, 447),
+        (447, 468),
+        (468, 360),
+        (284, 294),
+        (294, 283),
+        (283, 284),
+        (251, 459),
+        (459, 463),
+        (463, 251),
+        (301, 277),
+        (277, 384),
+        (384, 301),
+        (293, 309),
+        (309, 326),
+        (326, 293),
+        (284, 277),
+        (277, 294),
+        (294, 284),
+        (265, 373),
+        (373, 448),
+        (448, 265),
+        (347, 353),
+        (353, 341),
+        (341, 347),
+        (355, 275),
+        (275, 20),
+        (20, 355),
+        (364, 457),
+        (457, 282),
+        (282, 364),
+        (427, 437),
+        (437, 426),
+        (426, 427),
+        (381, 382),
+        (382, 253),
+        (253, 381),
+        (268, 270),
+        (270, 394),
+        (394, 268),
+        (422, 201),
+        (201, 429),
+        (429, 422),
+        (372, 267),
+        (267, 330),
+        (330, 372),
+        (433, 288),
+        (288, 423),
+        (423, 433),
+        (291, 251),
+        (251, 329),
+        (329, 291),
+        (386, 259),
+        (259, 385),
+        (385, 386),
+        (447, 266),
+        (266, 343),
+        (343, 447),
+        (387, 388),
+        (388, 258),
+        (258, 387),
+        (423, 425),
+        (425, 431),
+        (431, 423),
+        (446, 343),
+        (343, 277),
+        (277, 446),
+        (423, 274),
+        (274, 425),
+        (425, 423),
+        (307, 293),
+        (293, 308),
+        (308, 307),
+        (353, 367),
+        (367, 346),
+        (346, 353),
+        (269, 272),
+        (272, 303),
+        (303, 269),
+        (359, 424),
+        (424, 372),
+        (372, 359),
+        (328, 295),
+        (295, 461),
+        (461, 328),
+        (332, 280),
+        (280, 295),
+        (295, 332),
+        (304, 272),
+        (272, 305),
+        (305, 304),
+        (437, 433),
+        (433, 428),
+        (428, 437),
+        (305, 273),
+        (273, 409),
+        (409, 305),
+        (396, 395),
+        (395, 432),
+        (432, 396),
+        (379, 396),
+        (396, 401),
+        (401, 379),
+        (297, 335),
+        (335, 300),
+        (300, 297),
+        (7, 352),
+        (352, 169),
+        (169, 7),
+        (377, 353),
+        (353, 412),
+        (412, 377),
+        (308, 326),
+        (326, 321),
+        (321, 308),
+        (286, 296),
+        (296, 337),
+        (337, 286),
+        (321, 320),
+        (320, 405),
+        (405, 321),
+        (330, 331),
+        (331, 350),
+        (350, 330),
+        (335, 294),
+        (294, 334),
+        (334, 335),
+        (367, 324),
+        (324, 448),
+        (448, 367),
+        (317, 16),
+        (16, 316),
+        (316, 317),
+        (332, 359),
+        (359, 280),
+        (280, 332),
+        (318, 15),
+        (15, 317),
+        (317, 318),
+        (9, 286),
+        (286, 10),
+        (10, 9),
+        (278, 330),
+        (330, 351),
+        (351, 278),
+        (254, 375),
+        (375, 253),
+        (253, 254),
+        (320, 319),
+        (319, 404),
+        (404, 320),
+        (352, 7),
+        (7, 420),
+        (420, 352),
+        (325, 319),
+        (319, 326),
+        (326, 325),
+        (398, 368),
+        (368, 366),
+        (366, 398),
+        (289, 436),
+        (436, 398),
+        (398, 289),
+        (279, 345),
+        (345, 440),
+        (440, 279),
+        (311, 273),
+        (273, 312),
+        (312, 311),
+        (249, 196),
+        (196, 282),
+        (282, 249),
+        (376, 274),
+        (274, 292),
+        (292, 376),
+        (176, 397),
+        (397, 200),
+        (200, 176),
+        (313, 312),
+        (312, 269),
+        (269, 313),
+        (277, 284),
+        (284, 446),
+        (446, 277),
+        (391, 374),
+        (374, 340),
+        (340, 391),
+        (296, 283),
+        (283, 297),
+        (297, 296),
+        (449, 450),
+        (450, 347),
+        (347, 449),
+        (357, 265),
+        (265, 455),
+        (455, 357),
+        (338, 337),
+        (337, 300),
+        (300, 338),
+        (338, 339),
+        (339, 152),
+        (152, 338),
+        (295, 279),
+        (279, 456),
+        (456, 295),
+        (309, 293),
+        (293, 416),
+        (416, 309),
+        (430, 359),
+        (359, 356),
+        (356, 430),
+        (266, 341),
+        (341, 373),
+        (373, 266),
+        (353, 347),
+        (347, 281),
+        (281, 353),
+        (296, 443),
+        (443, 283),
+        (283, 296),
+        (355, 20),
+        (20, 371),
+        (371, 355),
+        (286, 442),
+        (442, 296),
+        (296, 286),
+        (196, 249),
+        (249, 198),
+        (198, 196),
+        (458, 441),
+        (441, 275),
+        (275, 458),
+        (302, 301),
+        (301, 369),
+        (369, 302),
+        (418, 352),
+        (352, 466),
+        (466, 418),
+        (252, 302),
+        (302, 390),
+        (390, 252),
+        (395, 396),
+        (396, 380),
+        (380, 395),
+        (400, 413),
+        (413, 420),
+        (420, 400),
+        (411, 437),
+        (437, 323),
+        (323, 411),
+        (327, 3),
+        (3, 394),
+        (394, 327),
+        (355, 371),
+        (371, 462),
+        (462, 355),
+        (394, 165),
+        (165, 268),
+        (268, 394),
+        (269, 303),
+        (303, 13),
+        (13, 269),
+        (313, 269),
+        (269, 14),
+        (14, 313),
+        (299, 294),
+        (294, 302),
+        (302, 299),
+        (266, 447),
+        (447, 341),
+        (341, 266),
+        (281, 331),
+        (331, 426),
+        (426, 281),
+        (323, 427),
+        (427, 392),
+        (392, 323),
+        (421, 430),
+        (430, 438),
+        (438, 421),
+        (394, 392),
+        (392, 327),
+        (327, 394),
+        (345, 441),
+        (441, 439),
+        (439, 345),
+        (459, 460),
+        (460, 462),
+        (462, 459),
+        (365, 435),
+        (435, 395),
+        (395, 365),
+        (429, 397),
+        (397, 263),
+        (263, 429),
+        (275, 355),
+        (355, 458),
+        (458, 275),
+        (318, 317),
+        (317, 403),
+        (403, 318),
+        (317, 316),
+        (316, 404),
+        (404, 317),
+        (316, 315),
+        (315, 405),
+        (405, 316),
+        (315, 314),
+        (314, 406),
+        (406, 315),
+        (314, 422),
+        (422, 407),
+        (407, 314),
+        (324, 367),
+        (367, 362),
+        (362, 324),
+        (293, 307),
+        (307, 408),
+        (408, 293),
+        (307, 292),
+        (292, 409),
+        (409, 307),
+        (292, 288),
+        (288, 410),
+        (410, 292),
+        (288, 433),
+        (433, 411),
+        (411, 288),
+        (428, 435),
+        (435, 412),
+        (412, 428),
+        (373, 265),
+        (265, 384),
+        (384, 373),
+        (460, 310),
+        (310, 458),
+        (458, 460),
+        (367, 353),
+        (353, 402),
+        (402, 367),
+        (2, 275),
+        (275, 5),
+        (5, 2),
+        (419, 422),
+        (422, 263),
+        (263, 419),
+        (332, 295),
+        (295, 359),
+        (359, 332),
+        (436, 434),
+        (434, 368),
+        (368, 436),
+        (393, 290),
+        (290, 440),
+        (440, 393),
+        (329, 463),
+        (463, 327),
+        (327, 329),
+        (95, 3),
+        (3, 371),
+        (371, 95),
+        (290, 306),
+        (306, 456),
+        (456, 290),
+        (340, 255),
+        (255, 449),
+        (449, 340),
+        (360, 256),
+        (256, 447),
+        (447, 360),
+        (255, 254),
+        (254, 450),
+        (450, 255),
+        (254, 253),
+        (253, 451),
+        (451, 254),
+        (253, 257),
+        (257, 452),
+        (452, 253),
+        (257, 342),
+        (342, 453),
+        (453, 257),
+        (415, 414),
+        (414, 464),
+        (464, 415),
+        (287, 442),
+        (442, 415),
+        (415, 287),
+        (287, 259),
+        (259, 442),
+        (442, 287),
+        (259, 258),
+        (258, 443),
+        (443, 259),
+        (258, 260),
+        (260, 444),
+        (444, 258),
+        (260, 261),
+        (261, 445),
+        (445, 260),
+        (261, 468),
+        (468, 446),
+        (446, 261),
+        (310, 460),
+        (460, 251),
+        (251, 310),
+        (306, 290),
+        (290, 291),
+        (291, 306),
+        (306, 291),
+        (291, 461),
+        (461, 306),
+        (402, 377),
+        (377, 436),
+        (436, 402),
+        (310, 251),
+        (251, 393),
+        (393, 310),
+        (377, 412),
+        (412, 434),
+        (434, 377),
+        (454, 342),
+        (342, 465),
+        (465, 454),
+        (358, 454),
+        (454, 466),
+        (466, 358),
+        (344, 358),
+        (358, 413),
+        (413, 344),
+        (438, 344),
+        (344, 400),
+        (400, 438),
+        (345, 361),
+        (361, 441),
+        (441, 345),
+        (421, 438),
+        (438, 457),
+        (457, 421),
+        (361, 421),
+        (421, 364),
+        (364, 361),
+        (362, 402),
+        (402, 289),
+        (289, 362),
+        (266, 373),
+        (373, 354),
+        (354, 266),
+        (391, 340),
+        (340, 250),
+        (250, 391),
+        (340, 449),
+        (449, 256),
+        (256, 340),
+    )
+
+    FACEMESH_TESSELATION = (
+        (474, 474),
+        (475, 476),
+        (476, 477),
+        (477, 478),
+        (478, 475),
+        (469, 469),
+        (470, 471),
+        (471, 472),
+        (472, 473),
+        (473, 470),
+        *FACEMESH_TESSELATION_NO_IRIS,
+    )
+
+
+SKELETONS_BY_EDGE_COUNT: dict[int, Edges] = {}
+SKELETONS_BY_VERTEX_COUNT: dict[int, Edges] = {}
+
+for skeleton in Skeleton:
+    SKELETONS_BY_EDGE_COUNT[len(skeleton.value)] = skeleton.value
+
+    unique_vertices = {vertex for edge in skeleton.value for vertex in edge}
+    SKELETONS_BY_VERTEX_COUNT[len(unique_vertices)] = skeleton.value
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/__init__.py b/.venv/lib/python3.12/site-packages/supervision/keypoint/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7bda3ed844283d59695b96d1bffa1a1801b56ff5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/keypoint/__init__.py
@@ -0,0 +1,13 @@
+from supervision.utils.internal import warn_deprecated
+
+warn_deprecated(
+    "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed "
+    "in `0.31.0`. Please use 'supervision.key_points' instead."
+)
+
+from supervision.key_points.annotators import (
+    EdgeAnnotator,
+    VertexAnnotator,
+    VertexLabelAnnotator,
+)
+from supervision.key_points.core import KeyPoints
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..78917392d62a620a4f3fb626b4741abcb5398f04
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/annotators.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/annotators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a51ebcbf0db480de173891252a113e96a4f1c3d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/annotators.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66aa48e97d8461718231ce1cc674ee7e4aa41c85
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/keypoint/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/annotators.py b/.venv/lib/python3.12/site-packages/supervision/keypoint/annotators.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bb0a3aef44b1cd6345e2e32bb067cf2ea268493
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/keypoint/annotators.py
@@ -0,0 +1,13 @@
+from supervision.utils.internal import warn_deprecated
+
+warn_deprecated(
+    "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed "
+    "in `0.31.0`. Please use 'supervision.key_points' instead."
+)
+
+from supervision.key_points.annotators import (  # noqa: E402, F401
+    BaseKeyPointAnnotator,
+    EdgeAnnotator,
+    VertexAnnotator,
+    VertexLabelAnnotator,
+)
diff --git a/.venv/lib/python3.12/site-packages/supervision/keypoint/core.py b/.venv/lib/python3.12/site-packages/supervision/keypoint/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc0115540501648e6b7b17967e7e7d1ad452c664
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/keypoint/core.py
@@ -0,0 +1,8 @@
+from supervision.utils.internal import warn_deprecated
+
+warn_deprecated(
+    "The 'supervision.keypoint' module is deprecated in `0.27.0` and will be removed "
+    "in `0.31.0`. Please use 'supervision.key_points' instead."
+)
+
+from supervision.key_points.core import KeyPoints  # noqa: E402, F401
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__init__.py b/.venv/lib/python3.12/site-packages/supervision/metrics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1cba4c1886465d76502bafb23ef827c12317ab4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/__init__.py
@@ -0,0 +1,40 @@
+from supervision.metrics.core import (
+    AveragingMethod,
+    Metric,
+    MetricTarget,
+)
+from supervision.metrics.f1_score import F1Score, F1ScoreResult
+from supervision.metrics.mean_average_precision import (
+    MeanAveragePrecision,
+    MeanAveragePrecisionResult,
+)
+from supervision.metrics.mean_average_recall import (
+    MeanAverageRecall,
+    MeanAverageRecallResult,
+)
+from supervision.metrics.precision import Precision, PrecisionResult
+from supervision.metrics.recall import Recall, RecallResult
+from supervision.metrics.utils.object_size import (
+    ObjectSizeCategory,
+    get_detection_size_category,
+    get_object_size_category,
+)
+
+__all__ = [
+    "AveragingMethod",
+    "F1Score",
+    "F1ScoreResult",
+    "MeanAveragePrecision",
+    "MeanAveragePrecisionResult",
+    "MeanAverageRecall",
+    "MeanAverageRecallResult",
+    "Metric",
+    "MetricTarget",
+    "ObjectSizeCategory",
+    "Precision",
+    "PrecisionResult",
+    "Recall",
+    "RecallResult",
+    "get_detection_size_category",
+    "get_object_size_category",
+]
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95063effbfbbc7d2cb0f08fe8b2bcec009879baf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a226368f913af647966f7ef25386f9203b76eeb4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/detection.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/detection.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc492bb8f2e5639a0c5abdfcc580b605cb6179ec
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/detection.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/f1_score.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/f1_score.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe8d2310ea304c22f9d9e2108f3894f280b9e7e2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/f1_score.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_precision.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_precision.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7351c06607ff53e8681ec4b50ca791f62d437709
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_precision.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_recall.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_recall.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eca7c95658aa87c030d87639d943a4f874e9a8d8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/mean_average_recall.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/precision.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/precision.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d1ff2f286e6b5ab571d84f8365f5692ca938c5c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/precision.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/recall.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/recall.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb3a83a019c1d40320084682162cc29577bd370d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/__pycache__/recall.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/core.py b/.venv/lib/python3.12/site-packages/supervision/metrics/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..347b61dda18bba316925fc590f5c43d553ad98d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/core.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, Generic, TypeVar
+
+R = TypeVar("R")
+
+
+class Metric(ABC, Generic[R]):
+    """
+    The base class for all supervision metrics.
+    """
+
+    @abstractmethod
+    def update(self, *args: Any, **kwargs: Any) -> Metric[R]:
+        """
+        Add data to the metric, without computing the result.
+        Return the metric itself to allow method chaining.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def reset(self) -> None:
+        """
+        Reset internal metric state.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def compute(self, *args: Any, **kwargs: Any) -> R:
+        """
+        Compute the metric from the internal state and return the result.
+        """
+        raise NotImplementedError
+
+
+class MetricTarget(Enum):
+    """
+    Specifies what type of detection is used to compute the metric.
+
+    Attributes:
+        BOXES: xyxy bounding boxes
+        MASKS: Binary masks
+        ORIENTED_BOUNDING_BOXES: Oriented bounding boxes (OBB)
+    """
+
+    BOXES = "boxes"
+    MASKS = "masks"
+    ORIENTED_BOUNDING_BOXES = "obb"
+
+
+class AveragingMethod(Enum):
+    """
+    Defines different ways of averaging the metric results.
+
+    Suppose, before returning the final result, a metric is computed for each class.
+    How do you combine those to get the final number?
+
+    Attributes:
+        MACRO: Calculate the metric for each class and average the results. The simplest
+            averaging method, but it does not take class imbalance into account.
+        MICRO: Calculate the metric globally by counting the total true positives, false
+            positives, and false negatives. Micro averaging is useful when you want to
+            give more importance to classes with more samples. It's also more
+            appropriate if you have an imbalance in the number of instances per class.
+        WEIGHTED: Calculate the metric for each class and average the results, weighted
+            by the number of true instances of each class. Use weighted averaging if
+            you want to take class imbalance into account.
+    """
+
+    MACRO = "macro"
+    MICRO = "micro"
+    WEIGHTED = "weighted"
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/detection.py b/.venv/lib/python3.12/site-packages/supervision/metrics/detection.py
new file mode 100644
index 0000000000000000000000000000000000000000..569150176690c8e83ba49c017a07741c47df276c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/detection.py
@@ -0,0 +1,1633 @@
+from __future__ import annotations
+
+import warnings
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import (  # type: ignore[import-untyped,unused-ignore]
+    TargetMode,
+    deprecated,
+    deprecated_class,
+    void,
+)
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.dataset.core import DetectionDataset
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.metrics.core import MetricTarget
+from supervision.metrics.utils.matching import _greedy_match
+
+if TYPE_CHECKING:
+    from matplotlib.figure import Figure
+
+
+def _assert_supported_target(metric_target: MetricTarget) -> None:
+    if metric_target == MetricTarget.MASKS:
+        raise ValueError(
+            "MetricTarget.MASKS is not currently supported for ConfusionMatrix."
+        )
+
+
+def _validated_class_ids(
+    values: npt.NDArray[np.float32],
+    num_classes: int,
+    role: str,
+) -> npt.NDArray[np.int64]:
+    """Return class ids that are safe to use as confusion-matrix indexes."""
+    if values.size == 0:
+        return np.asarray(values, dtype=np.int64)
+
+    finite = np.isfinite(values)
+    integral = values == np.floor(values)
+    if not np.all(finite & integral):
+        raise ValueError(f"{role} class ids must be finite integers.")
+
+    class_ids = values.astype(np.int64)
+    invalid = (class_ids < 0) | (class_ids >= num_classes)
+    if np.any(invalid):
+        invalid_values = np.unique(class_ids[invalid]).tolist()
+        raise ValueError(
+            f"{role} class ids must be in [0, {num_classes - 1}], got {invalid_values}."
+        )
+    return class_ids
+
+
+def detections_to_tensor(
+    detections: Detections,
+    with_confidence: bool = False,
+    metric_target: MetricTarget = MetricTarget.BOXES,
+) -> npt.NDArray[np.float32]:
+    """
+    Convert Supervision Detections to a numpy tensor for metric computation.
+
+    Args:
+        detections: Detections/Targets in the format of sv.Detections.
+        with_confidence: Whether to include confidence as the last column.
+        metric_target: The type of detection data to use.
+            Supports `MetricTarget.BOXES` and
+            `MetricTarget.ORIENTED_BOUNDING_BOXES`.
+
+    Returns:
+        Detections as a float32 numpy array. Shape depends on `metric_target`
+        and `with_confidence`:
+
+        | `metric_target`                        | `with_confidence` | shape     |
+        |----------------------------------------|-------------------|-----------|
+        | `MetricTarget.BOXES`                   | `False`           | `(N, 5)`  |
+        | `MetricTarget.BOXES`                   | `True`            | `(N, 6)`  |
+        | `MetricTarget.ORIENTED_BOUNDING_BOXES` | `False`           | `(N, 9)`  |
+        | `MetricTarget.ORIENTED_BOUNDING_BOXES` | `True`            | `(N, 10)` |
+
+        Column layout:
+
+        - `BOXES`: ``[x_min, y_min, x_max, y_max, class_id [, confidence]]``
+        - `ORIENTED_BOUNDING_BOXES`:
+          ``[x1, y1, x2, y2, x3, y3, x4, y4, class_id [, confidence]]``
+
+    Raises:
+        ValueError: If `metric_target` is `MetricTarget.MASKS`.
+        ValueError: If `detections.class_id` is `None`.
+        ValueError: If `with_confidence=True` and `detections.confidence` is `None`.
+        ValueError: If `metric_target` is `MetricTarget.ORIENTED_BOUNDING_BOXES`
+            and `detections.data` does not contain `ORIENTED_BOX_COORDINATES`,
+            or if the stored array does not have exactly `N * 8` elements.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics.core import MetricTarget
+        >>> from supervision.config import ORIENTED_BOX_COORDINATES
+        >>> detections = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9]),
+        ... )
+        >>> tensor = detections_to_tensor(detections, with_confidence=True)
+        >>> tensor.shape
+        (1, 6)
+        >>> obb_coords = np.array([[0, 0, 10, 0, 10, 10, 0, 10]], dtype=np.float32)
+        >>> det_obb = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32),
+        ...     class_id=np.array([0]),
+        ...     data={ORIENTED_BOX_COORDINATES: obb_coords},
+        ... )
+        >>> tensor_obb = detections_to_tensor(
+        ...     det_obb, metric_target=MetricTarget.ORIENTED_BOUNDING_BOXES
+        ... )
+        >>> tensor_obb.shape
+        (1, 9)
+
+        ```
+    """
+    _assert_supported_target(metric_target)
+
+    if detections.class_id is None:
+        raise ValueError(
+            "ConfusionMatrix can only be calculated for Detections with class_id"
+        )
+
+    box_data: npt.NDArray[np.float32]
+    if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+        obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+        if obb is None:
+            if len(detections) > 0:
+                raise ValueError(
+                    "ORIENTED_BOUNDING_BOXES requested, but "
+                    f"{ORIENTED_BOX_COORDINATES} is missing from detections.data"
+                )
+            box_data = np.empty((0, 8), dtype=np.float32)
+        else:
+            obb_arr = np.asarray(obb, dtype=np.float32)
+            # Normalize (N, 4, 2) → (N, 8) as produced by from_ultralytics.
+            if obb_arr.ndim == 3 and obb_arr.shape[1:] == (4, 2):
+                obb_arr = obb_arr.reshape(-1, 8)
+            if obb_arr.size != len(detections) * 8:
+                raise ValueError(
+                    f"Expected {ORIENTED_BOX_COORDINATES} to contain "
+                    f"{len(detections) * 8} elements "
+                    f"(N={len(detections)} detections x 8 coordinates), "
+                    f"but got {obb_arr.size}. "
+                    "Each OBB must be stored as [x1, y1, x2, y2, x3, y3, x4, y4]."
+                )
+            box_data = obb_arr.reshape(-1, 8)
+    else:
+        box_data = np.asarray(detections.xyxy, dtype=np.float32)
+
+    arrays_to_concat = [
+        box_data,
+        np.expand_dims(detections.class_id.astype(np.float32), 1),
+    ]
+
+    if with_confidence:
+        if detections.confidence is None:
+            raise ValueError(
+                "ConfusionMatrix can only be calculated for Detections with confidence"
+            )
+        arrays_to_concat.append(np.expand_dims(detections.confidence, 1))
+
+    result: npt.NDArray[np.float32] = np.concatenate(arrays_to_concat, axis=1)
+    return result
+
+
+def _validate_input_tensors(
+    predictions: list[npt.NDArray[np.float32]],
+    targets: list[npt.NDArray[np.float32]],
+    metric_target: MetricTarget = MetricTarget.BOXES,
+) -> None:
+    """
+    Checks for shape consistency of input tensors.
+    """
+    if len(predictions) != len(targets):
+        raise ValueError(
+            f"Number of predictions ({len(predictions)}) and"
+            f"targets ({len(targets)}) must be equal."
+        )
+    if len(predictions) > 0:
+        if not isinstance(predictions[0], np.ndarray) or not isinstance(
+            targets[0], np.ndarray
+        ):
+            raise ValueError(
+                "Predictions and targets must be lists of numpy arrays. "
+                f"Got {type(predictions[0])} and {type(targets[0])} instead."
+            )
+
+        expected_pred_cols = (
+            10 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 6
+        )
+        expected_target_cols = (
+            9 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 5
+        )
+
+        if predictions[0].shape[1] != expected_pred_cols:
+            raise ValueError(
+                f"Predictions must have shape (N, {expected_pred_cols}). "
+                f"Got {predictions[0].shape} instead."
+            )
+        if targets[0].shape[1] != expected_target_cols:
+            raise ValueError(
+                f"Targets must have shape (N, {expected_target_cols}). "
+                f"Got {targets[0].shape} instead."
+            )
+
+
+def _split_detections_by_outcome(
+    predictions: Detections,
+    targets: Detections,
+    conf_threshold: float,
+    iou_threshold: float,
+    metric_target: MetricTarget = MetricTarget.BOXES,
+) -> tuple[Detections, Detections, Detections]:
+    """
+    Split detections into true positives, false positives, and false negatives.
+
+    Matching follows the same attribution logic as
+    ``ConfusionMatrix.evaluate_detection_batch``:
+    - matches are computed globally across classes
+    - same-class matches are prioritized
+    - higher-IoU matches are preferred
+    - each prediction and target can be matched at most once
+
+    Cross-class spatial matches are treated as:
+    - false positives for the prediction
+    - false negatives for the target
+
+    Args:
+        predictions: Predicted detections for a single image.
+        targets: Ground-truth detections for a single image.
+        conf_threshold: Confidence threshold; predictions below this are excluded.
+        iou_threshold: IoU threshold; candidate pairs below this are not matched.
+        metric_target: Coordinate representation to use for IoU computation.
+            Use ``MetricTarget.ORIENTED_BOUNDING_BOXES`` for rotated-box datasets.
+
+    Returns:
+        A 3-tuple ``(true_positives, false_positives, false_negatives)`` where
+        each element is a ``Detections`` instance sliced from the input arrays.
+    """
+
+    if predictions.class_id is None:
+        raise ValueError("Predictions must contain class_id values.")
+
+    if targets.class_id is None:
+        raise ValueError("Targets must contain class_id values.")
+
+    target_class_ids = targets.class_id
+
+    if predictions.confidence is None:
+        filtered_predictions = predictions
+    else:
+        prediction_confidence = np.asarray(predictions.confidence, dtype=np.float32)
+        filtered_predictions = predictions.select(
+            prediction_confidence >= conf_threshold
+        )
+
+    filtered_prediction_class_ids = filtered_predictions.class_id
+    if filtered_prediction_class_ids is None:
+        raise ValueError("Predictions must contain class_id values.")
+
+    prediction_count = len(filtered_predictions)
+    target_count = len(targets)
+
+    tp_indices: list[int] = []
+    fp_indices: list[int] = []
+    fn_indices: list[int] = []
+
+    if prediction_count == 0:
+        fn_indices = list(range(target_count))
+        return (
+            filtered_predictions.select(tp_indices),
+            filtered_predictions.select(fp_indices),
+            targets.select(fn_indices),
+        )
+
+    if target_count == 0:
+        fp_indices = list(range(prediction_count))
+        return (
+            filtered_predictions.select(tp_indices),
+            filtered_predictions.select(fp_indices),
+            targets.select(fn_indices),
+        )
+
+    # IoU computation mirrors evaluate_detection_batch — keep in sync if either changes.
+    if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+        iou_matrix = oriented_box_iou_batch(
+            boxes_true=np.asarray(
+                targets.data[ORIENTED_BOX_COORDINATES], dtype=np.float32
+            ).reshape(len(targets), 8),
+            boxes_detection=np.asarray(
+                filtered_predictions.data[ORIENTED_BOX_COORDINATES], dtype=np.float32
+            ).reshape(len(filtered_predictions), 8),
+        )
+    else:
+        iou_matrix = box_iou_batch(
+            boxes_true=targets.xyxy,
+            boxes_detection=filtered_predictions.xyxy,
+        )
+
+    target_candidate_indices, prediction_candidate_indices = np.where(
+        iou_matrix > iou_threshold
+    )
+
+    matched_predictions: npt.NDArray[np.bool_] = np.zeros(prediction_count, dtype=bool)
+    matched_targets: npt.NDArray[np.bool_] = np.zeros(target_count, dtype=bool)
+
+    cross_class_prediction_indices: list[int] = []
+    cross_class_target_indices: list[int] = []
+
+    if len(target_candidate_indices) > 0:
+        candidate_ious = iou_matrix[
+            target_candidate_indices,
+            prediction_candidate_indices,
+        ]
+
+        same_class_candidates = (
+            target_class_ids[target_candidate_indices]
+            == filtered_prediction_class_ids[prediction_candidate_indices]
+        )
+
+        candidate_order = np.lexsort(
+            (
+                -candidate_ious,
+                ~same_class_candidates,
+            )
+        )
+
+        for candidate_index in candidate_order:
+            target_index = int(target_candidate_indices[candidate_index])
+            prediction_index = int(prediction_candidate_indices[candidate_index])
+
+            if matched_predictions[prediction_index] or matched_targets[target_index]:
+                continue
+
+            matched_predictions[prediction_index] = True
+            matched_targets[target_index] = True
+
+            prediction_class = filtered_prediction_class_ids[prediction_index]
+            target_class = target_class_ids[target_index]
+
+            if prediction_class == target_class:
+                tp_indices.append(prediction_index)
+            else:
+                cross_class_prediction_indices.append(prediction_index)
+                cross_class_target_indices.append(target_index)
+
+    fp_indices.extend(np.flatnonzero(~matched_predictions).tolist())
+    fn_indices.extend(np.flatnonzero(~matched_targets).tolist())
+
+    fp_indices.extend(cross_class_prediction_indices)
+    fn_indices.extend(cross_class_target_indices)
+
+    return (
+        filtered_predictions.select(tp_indices),
+        filtered_predictions.select(fp_indices),
+        targets.select(fn_indices),
+    )
+
+
+def _build_error_labels(
+    detections: Detections,
+    class_names: list[str] | None,
+) -> list[str]:
+    """Build per-detection label strings for annotation panels.
+
+    Produces labels like ``"cat 0.95"`` (class name + confidence when available)
+    or numeric class-id strings when ``class_names`` is ``None``.
+
+    Args:
+        detections: Detections whose labels to build.
+        class_names: Optional list mapping class integer ids to name strings.
+
+    Returns:
+        List of label strings, one per detection. Returns empty strings when
+        ``detections.class_id`` is ``None``.
+    """
+    if detections.class_id is None:
+        return [""] * len(detections)
+
+    labels: list[str] = []
+    for index, class_id in enumerate(detections.class_id):
+        if class_names is not None and 0 <= int(class_id) < len(class_names):
+            class_label = class_names[int(class_id)]
+        else:
+            class_label = str(int(class_id))
+
+        confidence = ""
+        if detections.confidence is not None:
+            confidence = f" {detections.confidence[index]:.2f}"
+
+        labels.append(f"{class_label}{confidence}")
+
+    return labels
+
+
+def _get_annotation_parameters(
+    scene: npt.NDArray[np.uint8],
+) -> tuple[int, float, int, int, int]:
+    """Compute adaptive annotation parameters scaled to the panel size.
+
+    Args:
+        scene: The image panel for which to compute parameters.
+
+    Returns:
+        A 5-tuple ``(box_thickness, text_scale, text_thickness, text_padding,
+        font_size)`` where all values are ``int`` except ``text_scale`` (``float``).
+    """
+    height, width = scene.shape[:2]
+    panel_size = max(min(height, width), 1)
+    grid_factor = 2
+
+    font_size = max(18, round(panel_size / (26 * grid_factor)))
+    box_thickness = max(2, round(font_size / 5))
+    text_scale = float(max(1.0, font_size / 20.0))
+    text_thickness = max(1, round(font_size / 15.0))
+    text_padding = max(6, round(font_size / 3))
+
+    return box_thickness, text_scale, text_thickness, text_padding, font_size
+
+
+def _annotate_detection_panel(
+    scene: npt.NDArray[np.uint8],
+    detections: Detections,
+    title: str,
+    class_names: list[str] | None,
+    annotation_parameters: tuple[int, float, int, int, int],
+) -> npt.NDArray[np.uint8]:
+    """Render detections onto a copy of ``scene`` with a title overlay.
+
+    Args:
+        scene: Source image panel (not mutated).
+        detections: Detections to annotate on the panel.
+        title: Text label rendered in the top-left corner of the panel.
+        class_names: Optional list mapping class integer ids to name strings.
+        annotation_parameters: Pre-computed parameters from
+            ``_get_annotation_parameters``.
+
+    Returns:
+        Annotated copy of ``scene`` as a ``np.uint8`` array.
+    """
+    from supervision import (
+        _cv2 as cv2,  # lazy: only needed when save_directory_path is set
+    )
+    from supervision.annotators.core import BoxAnnotator, LabelAnnotator
+    from supervision.annotators.utils import ColorLookup
+    from supervision.draw.color import ColorPalette
+
+    panel = scene.copy()
+
+    box_thickness, text_scale, text_thickness, text_padding, font_size = (
+        annotation_parameters
+    )
+
+    if len(detections) > 0:
+        box_annotator = BoxAnnotator(
+            color=ColorPalette.DEFAULT,
+            color_lookup=ColorLookup.CLASS,
+            thickness=box_thickness,
+        )
+        label_annotator = LabelAnnotator(
+            color=ColorPalette.DEFAULT,
+            color_lookup=ColorLookup.CLASS,
+            text_scale=text_scale,
+            text_thickness=text_thickness,
+            text_padding=text_padding,
+        )
+        labels = _build_error_labels(detections, class_names)
+        panel = box_annotator.annotate(panel, detections)
+        panel = cast(
+            npt.NDArray[np.uint8],
+            label_annotator.annotate(cast(Any, panel), detections, labels=labels),
+        )
+
+    title_scale = float(max(1.0, font_size / 18.0))
+    title_thickness = max(2, round(font_size / 8))
+    panel_height, panel_width = panel.shape[:2]
+    (title_width, title_height), title_baseline = cv2.getTextSize(
+        title,
+        cv2.FONT_HERSHEY_SIMPLEX,
+        title_scale,
+        title_thickness,
+    )
+    title_x = max(0, min(text_padding, panel_width - title_width - 1))
+    title_y = max(title_height + text_padding, 0)
+    title_y = min(title_y, max(panel_height - title_baseline - 1, 0))
+
+    cv2.putText(
+        panel,
+        title,
+        (title_x, title_y),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        title_scale,
+        (240, 240, 240),
+        title_thickness,
+        cv2.LINE_AA,
+    )
+    panel_array: npt.NDArray[np.uint8] = panel
+    return panel_array
+
+
+def _save_detection_validation_visualization(
+    scene: npt.NDArray[np.uint8],
+    predictions: Detections,
+    targets: Detections,
+    save_path: Path,
+    conf_threshold: float,
+    iou_threshold: float,
+    class_names: list[str] | None,
+    metric_target: MetricTarget = MetricTarget.BOXES,
+) -> None:
+    """Build and save a 2x2 GT/TP/FP/FN mosaic for one image.
+
+    Splits ``predictions`` into true-positive, false-positive, and false-negative
+    groups using the same matching logic as
+    ``ConfusionMatrix.evaluate_detection_batch``, renders four annotation panels,
+    concatenates them into a 2x2 grid, and writes the result to ``save_path``.
+
+    A ``UserWarning`` is emitted if ``cv2.imwrite`` fails (e.g. unsupported
+    extension or permission error); the benchmark loop continues regardless.
+
+    Args:
+        scene: The original image for this dataset entry.
+        predictions: Raw model predictions for ``scene``.
+        targets: Ground-truth annotations for ``scene``.
+        save_path: Destination file path for the mosaic image.
+        conf_threshold: Confidence threshold forwarded to
+            ``_split_detections_by_outcome``.
+        iou_threshold: IoU threshold forwarded to ``_split_detections_by_outcome``.
+        class_names: Optional list mapping class integer ids to name strings.
+        metric_target: Coordinate representation used for IoU matching.
+    """
+    from supervision import (
+        _cv2 as cv2,  # lazy: only needed when save_directory_path is set
+    )
+
+    tp_predictions, fp_predictions, fn_targets = _split_detections_by_outcome(
+        predictions=predictions,
+        targets=targets,
+        conf_threshold=conf_threshold,
+        iou_threshold=iou_threshold,
+        metric_target=metric_target,
+    )
+
+    annotation_parameters = _get_annotation_parameters(scene)
+
+    gt_panel = _annotate_detection_panel(
+        scene=scene,
+        detections=targets,
+        title="Ground Truth",
+        class_names=class_names,
+        annotation_parameters=annotation_parameters,
+    )
+    tp_panel = _annotate_detection_panel(
+        scene=scene,
+        detections=tp_predictions,
+        title="True Positives",
+        class_names=class_names,
+        annotation_parameters=annotation_parameters,
+    )
+    fp_panel = _annotate_detection_panel(
+        scene=scene,
+        detections=fp_predictions,
+        title="False Positives",
+        class_names=class_names,
+        annotation_parameters=annotation_parameters,
+    )
+    fn_panel = _annotate_detection_panel(
+        scene=scene,
+        detections=fn_targets,
+        title="False Negatives",
+        class_names=class_names,
+        annotation_parameters=annotation_parameters,
+    )
+
+    top_row = np.concatenate((gt_panel, tp_panel), axis=1)
+    bottom_row = np.concatenate((fp_panel, fn_panel), axis=1)
+    result = np.concatenate((top_row, bottom_row), axis=0)
+
+    panel_height = result.shape[0] // 2
+    panel_width = result.shape[1] // 2
+    divider_thickness = max(1, min(8, min(panel_height, panel_width) // 32))
+
+    cv2.rectangle(
+        result,
+        (0, 0),
+        (result.shape[1] - 1, result.shape[0] - 1),
+        (255, 255, 255),
+        thickness=divider_thickness,
+    )
+
+    center_x = result.shape[1] // 2
+    center_y = result.shape[0] // 2
+    cv2.line(
+        result,
+        (center_x, 0),
+        (center_x, result.shape[0] - 1),
+        (255, 255, 255),
+        divider_thickness,
+    )
+    cv2.line(
+        result,
+        (0, center_y),
+        (result.shape[1] - 1, center_y),
+        (255, 255, 255),
+        divider_thickness,
+    )
+
+    write_success = cv2.imwrite(str(save_path), result)
+    if not write_success:
+        warnings.warn(
+            f"Failed to write validation image to '{save_path}'.",
+            UserWarning,
+            stacklevel=2,
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_input_tensors,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_input_tensors(
+    predictions: list[npt.NDArray[np.float32]],
+    targets: list[npt.NDArray[np.float32]],
+) -> None:
+    void(predictions, targets)
+
+
+@dataclass
+class ConfusionMatrix:
+    """
+    Confusion matrix for object detection tasks.
+
+    Attributes:
+        matrix: An 2D `np.ndarray` of shape `(len(classes) + 1, len(classes) + 1)`
+            containing the number of `TP`, `FP`, `FN` and `TN` for each class.
+        classes: Model class names.
+        conf_threshold: Detection confidence threshold between `0` and `1`.
+            Detections with lower confidence will be excluded from the matrix.
+        iou_threshold: Detection IoU threshold between `0` and `1`.
+            Detections with lower IoU will be classified as `FP`.
+        metric_target: The type of detection data used for IoU computation.
+            Informational metadata set by `from_detections` and `from_tensors`.
+            Excluded from `__eq__` comparisons — two `ConfusionMatrix` instances
+            with identical `matrix`, `classes`, `conf_threshold`, and
+            `iou_threshold` compare as equal regardless of `metric_target`.
+    """
+
+    matrix: npt.NDArray[np.int32]
+    classes: list[str]
+    conf_threshold: float
+    iou_threshold: float
+    metric_target: MetricTarget = MetricTarget.BOXES
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ConfusionMatrix):
+            return NotImplemented
+        return (
+            np.array_equal(self.matrix, other.matrix)
+            and self.classes == other.classes
+            and self.conf_threshold == other.conf_threshold
+            and self.iou_threshold == other.iou_threshold
+        )
+
+    __hash__ = None  # type: ignore[assignment]
+
+    @classmethod
+    def from_detections(
+        cls,
+        predictions: list[Detections],
+        targets: list[Detections],
+        classes: list[str],
+        conf_threshold: float = 0.3,
+        iou_threshold: float = 0.5,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+    ) -> ConfusionMatrix:
+        """
+        Calculate confusion matrix based on predicted and ground-truth detections.
+
+        Args:
+            targets: Detections objects from ground-truth.
+            predictions: Detections objects predicted by the model.
+            classes: Model class names.
+            conf_threshold: Detection confidence threshold between `0` and `1`.
+                Detections with lower confidence will be excluded.
+            iou_threshold: Detection IoU threshold between `0` and `1`.
+                Detections with lower IoU will be classified as `FP`.
+            metric_target: The type of detection data to use.
+                Supports `MetricTarget.BOXES` (default) and
+                `MetricTarget.ORIENTED_BOUNDING_BOXES`. When using
+                `MetricTarget.ORIENTED_BOUNDING_BOXES`, each `Detections`
+                object must include OBB coordinates in
+                `detections.data[ORIENTED_BOX_COORDINATES]` as a float32
+                array of shape `(N, 8)` (flat) or `(N, 4, 2)` (as stored by
+                `from_ultralytics`); both are normalised to `(N, 8)` internally.
+                `MetricTarget.MASKS` is not supported.
+
+        Returns:
+            New instance of ConfusionMatrix.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> targets = [
+            ...     sv.Detections(
+            ...         xyxy=np.array([[0, 0, 10, 10], [50, 50, 60, 60]]),
+            ...         class_id=np.array([0, 0])
+            ...     )
+            ... ]
+            >>> predictions = [
+            ...     sv.Detections(
+            ...         xyxy=np.array([[0, 0, 10, 10], [100, 100, 110, 110]]),
+            ...         class_id=np.array([0, 0]),
+            ...         confidence=np.array([0.9, 0.8])
+            ...     )
+            ... ]
+            >>> confusion_matrix = sv.ConfusionMatrix.from_detections(
+            ...     predictions=predictions,
+            ...     targets=targets,
+            ...     classes=['person']
+            ... )
+            >>> confusion_matrix.matrix
+            array([[1, 1],
+                   [1, 0]], dtype=int32)
+
+            ```
+        """
+        prediction_tensors = []
+        target_tensors = []
+        for prediction, target in zip(predictions, targets):
+            prediction_tensors.append(
+                detections_to_tensor(
+                    prediction, with_confidence=True, metric_target=metric_target
+                )
+            )
+            target_tensors.append(
+                detections_to_tensor(
+                    target, with_confidence=False, metric_target=metric_target
+                )
+            )
+        return cls.from_tensors(
+            predictions=prediction_tensors,
+            targets=target_tensors,
+            classes=classes,
+            conf_threshold=conf_threshold,
+            iou_threshold=iou_threshold,
+            metric_target=metric_target,
+        )
+
+    @classmethod
+    def from_tensors(
+        cls,
+        predictions: list[npt.NDArray[np.float32]],
+        targets: list[npt.NDArray[np.float32]],
+        classes: list[str],
+        conf_threshold: float = 0.3,
+        iou_threshold: float = 0.5,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+    ) -> ConfusionMatrix:
+        """
+        Calculate confusion matrix based on predicted and ground-truth detections.
+
+        Args:
+            predictions: Each element of the list describes a single
+                image and has `shape = (M, 6)` or `shape = (M, 10)` depending on
+                `metric_target`.
+                If `MetricTarget.BOXES`, each row is in
+                `(x_min, y_min, x_max, y_max, class, conf)` format.
+                If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in
+                `(x1, y1, x2, y2, x3, y3, x4, y4, class, conf)` format.
+            targets: Each element of the list describes a single
+                image and has `shape = (N, 5)` or `shape = (N, 9)` depending on
+                `metric_target`.
+                If `MetricTarget.BOXES`, each row is in
+                `(x_min, y_min, x_max, y_max, class)` format.
+                If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in
+                `(x1, y1, x2, y2, x3, y3, x4, y4, class)` format.
+            classes: Model class names.
+            conf_threshold: Detection confidence threshold between `0` and `1`.
+                Detections with lower confidence will be excluded.
+            iou_threshold: Detection iou threshold between `0` and `1`.
+                Detections with lower iou will be classified as `FP`.
+            metric_target: The type of detection data to use.
+                Determines expected tensor shapes (see Args above for column
+                layouts). `MetricTarget.MASKS` is not supported.
+
+        Returns:
+            New instance of ConfusionMatrix.
+
+        Examples:
+            ```pycon
+            >>> import supervision as sv
+            >>> import numpy as np
+            >>> targets = [
+            ...     np.array([
+            ...         [0.0, 0.0, 3.0, 3.0, 0],
+            ...         [2.0, 2.0, 5.0, 5.0, 0],
+            ...         [6.0, 1.0, 8.0, 3.0, 1],
+            ...     ])
+            ... ]
+            >>> predictions = [
+            ...     np.array([
+            ...         [0.0, 0.0, 3.0, 3.0, 0, 0.9],
+            ...         [0.1, 0.1, 3.0, 3.0, 0, 0.9],
+            ...         [6.0, 1.0, 8.0, 3.0, 1, 0.8],
+            ...     ])
+            ... ]
+            >>> confusion_matrix = sv.ConfusionMatrix.from_tensors(
+            ...     predictions=predictions,
+            ...     targets=targets,
+            ...     classes=['person', 'dog']
+            ... )
+            >>> confusion_matrix.matrix
+            array([[1, 0, 1],
+                   [0, 1, 0],
+                   [1, 0, 0]], dtype=int32)
+
+            ```
+        """
+        _assert_supported_target(metric_target)
+        _validate_input_tensors(predictions, targets, metric_target=metric_target)
+
+        num_classes = len(classes)
+        matrix: npt.NDArray[np.int32] = np.zeros(
+            (num_classes + 1, num_classes + 1), dtype=np.int32
+        )
+        for true_batch, detection_batch in zip(targets, predictions):
+            matrix += cls.evaluate_detection_batch(
+                predictions=detection_batch,
+                targets=true_batch,
+                num_classes=num_classes,
+                conf_threshold=conf_threshold,
+                iou_threshold=iou_threshold,
+                metric_target=metric_target,
+            )
+        return cls(
+            matrix=matrix,
+            classes=classes,
+            conf_threshold=conf_threshold,
+            iou_threshold=iou_threshold,
+            metric_target=metric_target,
+        )
+
+    @staticmethod
+    def evaluate_detection_batch(
+        predictions: npt.NDArray[np.float32],
+        targets: npt.NDArray[np.float32],
+        num_classes: int,
+        conf_threshold: float,
+        iou_threshold: float,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+    ) -> npt.NDArray[np.int32]:
+        """
+        Calculate confusion matrix for a batch of detections for a single image.
+
+        Args:
+            predictions: Batch prediction. Describes a single image and
+                has `shape = (M, 6)` or `shape = (M, 10)` depending on
+                `metric_target`.
+                If `MetricTarget.BOXES`, each row is in
+                `(x_min, y_min, x_max, y_max, class, conf)` format.
+                If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in
+                `(x1, y1, x2, y2, x3, y3, x4, y4, class, conf)` format.
+            targets: Batch target labels. Describes a single image and
+                has `shape = (N, 5)` or `shape = (N, 9)` depending on
+                `metric_target`.
+                If `MetricTarget.BOXES`, each row is in
+                `(x_min, y_min, x_max, y_max, class)` format.
+                If `MetricTarget.ORIENTED_BOUNDING_BOXES`, each row is in
+                `(x1, y1, x2, y2, x3, y3, x4, y4, class)` format.
+            num_classes: Number of classes.
+            conf_threshold: Detection confidence threshold between `0` and `1`.
+                Detections with lower confidence will be excluded.
+            iou_threshold: Detection iou threshold between `0` and `1`.
+                Detections with lower iou will be classified as `FP`.
+            metric_target: The type of detection data to use.
+                Determines IoU function (`box_iou_batch` vs
+                `oriented_box_iou_batch`) and coordinate column count.
+                `MetricTarget.MASKS` is not supported.
+
+        Returns:
+            Confusion matrix based on a single image.
+        """
+        _assert_supported_target(metric_target)
+
+        expected_pred_cols = (
+            10 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 6
+        )
+        expected_target_cols = (
+            9 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 5
+        )
+        if predictions.ndim != 2 or predictions.shape[1] != expected_pred_cols:
+            raise ValueError(
+                f"Predictions must have shape (M, {expected_pred_cols}). "
+                f"Got {predictions.shape} instead."
+            )
+        if targets.ndim != 2 or targets.shape[1] != expected_target_cols:
+            raise ValueError(
+                f"Targets must have shape (N, {expected_target_cols}). "
+                f"Got {targets.shape} instead."
+            )
+
+        result_matrix: npt.NDArray[np.int32] = np.zeros(
+            (num_classes + 1, num_classes + 1), dtype=np.int32
+        )
+
+        # Filter predictions by confidence threshold
+        coords_dim = 8 if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES else 4
+        class_id_idx = coords_dim
+        conf_idx = coords_dim + 1
+
+        confidence = predictions[:, conf_idx]
+        detection_batch_filtered = predictions[confidence >= conf_threshold]
+
+        if len(detection_batch_filtered) == 0:
+            true_classes = _validated_class_ids(
+                targets[:, class_id_idx], num_classes, "Target"
+            )
+            for gt_class in true_classes:
+                result_matrix[gt_class, num_classes] += 1
+            return result_matrix
+
+        if len(targets) == 0:
+            detection_classes = _validated_class_ids(
+                detection_batch_filtered[:, class_id_idx], num_classes, "Prediction"
+            )
+            for det_class in detection_classes:
+                result_matrix[num_classes, det_class] += 1
+            return result_matrix
+
+        true_classes = _validated_class_ids(
+            targets[:, class_id_idx], num_classes, "Target"
+        )
+        detection_classes = _validated_class_ids(
+            detection_batch_filtered[:, class_id_idx], num_classes, "Prediction"
+        )
+        true_boxes = targets[:, :coords_dim]
+        detection_boxes = detection_batch_filtered[:, :coords_dim]
+
+        # Calculate IoU matrix
+        if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            iou_batch = oriented_box_iou_batch(
+                boxes_true=true_boxes, boxes_detection=detection_boxes
+            )
+        else:
+            iou_batch = box_iou_batch(
+                boxes_true=true_boxes, boxes_detection=detection_boxes
+            )
+
+        # Find all valid matches (IoU > threshold, regardless of class)
+        # Use vectorized operations to avoid nested Python loops
+        iou_mask = iou_batch > iou_threshold
+        gt_indices, det_indices = np.nonzero(iou_mask)
+
+        # If no pairs exceed the IoU threshold, skip matching
+        if gt_indices.size == 0:
+            valid_matches = []
+        else:
+            ious = iou_batch[gt_indices, det_indices]
+            gt_match_classes = true_classes[gt_indices]
+            det_match_classes = detection_classes[det_indices]
+            class_matches = gt_match_classes == det_match_classes
+
+            # Sort matches by class match first (True before False),
+            # then by IoU descending.
+            # np.lexsort sorts by the last key first, in ascending order.
+            # We use ~class_matches so that True becomes 0
+            # and False becomes 1 (True first),
+            # and -ious so that larger IoUs come first.
+            sort_indices = np.lexsort((-ious, ~class_matches))
+
+            # Build list of matches in the same format as before:
+            # (gt_idx, det_idx, iou, class_match)
+            valid_matches = [
+                (
+                    int(gt_indices[idx]),
+                    int(det_indices[idx]),
+                    float(ious[idx]),
+                    bool(class_matches[idx]),
+                )
+                for idx in sort_indices
+            ]
+        # Greedily assign matches, ensuring each GT
+        # and detection is matched at most once
+        matched_gt_idx = set()
+        matched_det_idx = set()
+
+        for gt_idx, det_idx, iou, class_match in valid_matches:
+            if gt_idx not in matched_gt_idx and det_idx not in matched_det_idx:
+                # Valid spatial match - record the class prediction
+                gt_class = true_classes[gt_idx]
+                det_class = detection_classes[det_idx]
+
+                # This handles both correct classification (TP) and misclassification
+                result_matrix[gt_class, det_class] += 1
+                matched_gt_idx.add(gt_idx)
+                matched_det_idx.add(det_idx)
+
+        # Count unmatched ground truth as FN
+        for gt_idx, gt_class in enumerate(true_classes):
+            if gt_idx not in matched_gt_idx:
+                result_matrix[gt_class, num_classes] += 1
+
+        # Count unmatched detections as FP
+        for det_idx, det_class in enumerate(detection_classes):
+            if det_idx not in matched_det_idx:
+                result_matrix[num_classes, det_class] += 1
+
+        return result_matrix
+
+    @staticmethod
+    def _drop_extra_matches(
+        matches: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.float32]:
+        """
+        Deduplicate matches. If there are multiple matches for the same true or
+        predicted box, only the one with the highest IoU is kept.
+        """
+        if matches.shape[0] > 0:
+            matches = matches[matches[:, 2].argsort()[::-1]]
+            matches = matches[np.unique(matches[:, 1], return_index=True)[1]]
+            matches = matches[matches[:, 2].argsort()[::-1]]
+            matches = matches[np.unique(matches[:, 0], return_index=True)[1]]
+        result: npt.NDArray[np.float32] = matches
+        return result
+
+    @classmethod
+    def benchmark(
+        cls,
+        dataset: DetectionDataset,
+        callback: Callable[[npt.NDArray[np.uint8]], Detections],
+        conf_threshold: float = 0.3,
+        iou_threshold: float = 0.5,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+        *,
+        save_directory_path: str | Path | None = None,
+    ) -> ConfusionMatrix:
+        """
+        Calculate confusion matrix from dataset and callback function.
+
+        Args:
+            dataset: Object detection dataset used for evaluation.
+            callback: Function that takes an image as input and returns a
+                Detections object.
+            conf_threshold: Detection confidence threshold between `0` and `1`.
+                Detections with lower confidence will be excluded.
+            iou_threshold: Detection IoU threshold between `0` and `1`.
+                Detections with lower IoU will be classified as `FP`.
+            save_directory_path: Optional directory where per-image validation
+                result grids are saved using the original image filenames. Images
+                are written directly to this directory (no subdirectory is added).
+                When ``None`` (default), no images are saved.
+            metric_target: The type of detection data to use.
+                Supports `MetricTarget.BOXES` and
+                `MetricTarget.ORIENTED_BOUNDING_BOXES`. Passed through to
+                `from_detections`. `MetricTarget.MASKS` is not supported.
+
+        Returns:
+            New instance of ConfusionMatrix.
+
+        Example:
+            ```python
+            import supervision as sv
+            from rfdetr import RFDETRMedium
+
+            dataset = sv.DetectionDataset.from_yolo(...)
+
+            model = RFDETRMedium()
+            def callback(image: np.ndarray) -> sv.Detections:
+                return model.predict(image[:, :, ::-1])
+
+            confusion_matrix = sv.ConfusionMatrix.benchmark(
+                dataset = dataset,
+                callback = callback
+            )
+
+            print(confusion_matrix.matrix)
+            # np.array([
+            #     [0., 0., 0., 0.],
+            #     [0., 1., 0., 1.],
+            #     [0., 1., 1., 0.],
+            #     [1., 1., 0., 0.]
+            # ])
+            ```
+        """
+        if save_directory_path is not None:
+            save_directory = Path(save_directory_path)
+            save_directory.mkdir(parents=True, exist_ok=True)
+
+        predictions, targets = [], []
+        for index, (image_name, image, annotation) in enumerate(dataset):
+            predictions_batch = callback(image)
+            predictions.append(predictions_batch)
+            targets.append(annotation)
+
+            if save_directory_path is not None:
+                if isinstance(image_name, Path):
+                    image_filename = image_name.name
+                elif isinstance(image_name, str):
+                    image_filename = Path(image_name).name
+                else:
+                    image_filename = f"image_{index:06d}.jpg"
+
+                if Path(image_filename).suffix == "":
+                    image_filename = f"{image_filename}.jpg"
+
+                save_path = save_directory / image_filename
+                if save_path.exists():
+                    warnings.warn(
+                        f"Validation image '{image_filename}' already exists at "
+                        f"'{save_path}' and will be overwritten.",
+                        UserWarning,
+                        stacklevel=2,
+                    )
+                _save_detection_validation_visualization(
+                    scene=image,
+                    predictions=predictions_batch,
+                    targets=annotation,
+                    save_path=save_path,
+                    conf_threshold=conf_threshold,
+                    iou_threshold=iou_threshold,
+                    class_names=dataset.classes,
+                    metric_target=metric_target,
+                )
+        return cls.from_detections(
+            predictions=predictions,
+            targets=targets,
+            classes=dataset.classes,
+            conf_threshold=conf_threshold,
+            iou_threshold=iou_threshold,
+            metric_target=metric_target,
+        )
+
+    def plot(
+        self,
+        save_path: str | None = None,
+        title: str | None = None,
+        classes: list[str] | None = None,
+        normalize: bool = False,
+        fig_size: tuple[int, int] = (12, 10),
+    ) -> Figure:
+        """
+        Create confusion matrix plot and save it at selected location.
+
+        Args:
+            save_path: Path to save the plot. If not provided,
+                plot will be displayed.
+            title: Title of the plot.
+            classes: List of classes to be displayed on the plot.
+                If not provided, all classes will be displayed.
+            normalize: If True, normalize the confusion matrix.
+            fig_size: Size of the plot.
+
+        Returns:
+            Confusion matrix plot.
+        """
+        from matplotlib import pyplot as plt
+
+        # Cast to float so that the NaN masking below never hits an integer
+        # matrix (assigning NaN into an int array raises ValueError).
+        array = self.matrix.astype(np.float64)
+
+        if normalize:
+            eps = 1e-8
+            array = array / (array.sum(0).reshape(1, -1) + eps)
+
+        array[array < 0.005] = np.nan
+
+        fig, ax = plt.subplots(figsize=fig_size, tight_layout=True, facecolor="white")
+
+        class_names = classes if classes is not None else self.classes
+        use_labels_for_ticks = class_names is not None and (0 < len(class_names) < 99)
+        if use_labels_for_ticks:
+            x_tick_labels = [*class_names, "FN"]
+            y_tick_labels = [*class_names, "FP"]
+            num_ticks = len(x_tick_labels)
+        else:
+            x_tick_labels = None
+            y_tick_labels = None
+            num_ticks = len(array)
+        im = ax.imshow(array, cmap="Blues")
+
+        cbar = ax.figure.colorbar(im, ax=ax)
+        cbar.mappable.set_clim(vmin=0, vmax=float(np.nanmax(array)))
+
+        if x_tick_labels is None:
+            tick_interval = 2
+        else:
+            tick_interval = 1
+        ax.set_xticks(np.arange(0, num_ticks, tick_interval), labels=x_tick_labels)
+        ax.set_yticks(np.arange(0, num_ticks, tick_interval), labels=y_tick_labels)
+
+        plt.setp(ax.get_xticklabels(), rotation=90, ha="right", rotation_mode="default")
+
+        labelsize = 10 if num_ticks < 50 else 8
+        ax.tick_params(axis="both", which="both", labelsize=labelsize)
+
+        if num_ticks < 30:
+            for i in range(array.shape[0]):
+                for j in range(array.shape[1]):
+                    n_preds = array[i, j]
+                    if not np.isnan(n_preds):
+                        ax.text(
+                            j,
+                            i,
+                            f"{n_preds:.2f}" if normalize else f"{n_preds:.0f}",
+                            ha="center",
+                            va="center",
+                            color="black"
+                            if n_preds < 0.5 * np.nanmax(array)
+                            else "white",
+                        )
+
+        if title:
+            ax.set_title(title, fontsize=20)
+
+        ax.set_xlabel("Predicted")
+        ax.set_ylabel("True")
+        ax.set_facecolor("white")
+        if save_path:
+            fig.savefig(
+                save_path, dpi=250, facecolor=fig.get_facecolor(), transparent=True
+            )
+        return fig
+
+
+@deprecated_class(
+    target=TargetMode.NOTIFY,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+@dataclass(frozen=True)
+class MeanAveragePrecision:
+    """
+    !!! deprecated "Deprecated"
+        `MeanAveragePrecision` is **deprecated** and will be removed in
+        `supervision-0.31.0`.
+
+        The deprecated implementation provides results that are inconsistent with
+        `pycocotools`. Please use
+        `supervision.metrics.mean_average_precision.MeanAveragePrecision` instead,
+        which matches the results of `pycocotools` and is now the recommended approach.
+
+    Mean Average Precision for object detection tasks.
+
+    Attributes:
+        map50_95: Mean Average Precision (mAP) calculated over IoU thresholds
+            ranging from `0.50` to `0.95` with a step size of `0.05`.
+        map50: Mean Average Precision (mAP) calculated specifically at
+            an IoU threshold of `0.50`.
+        map75: Mean Average Precision (mAP) calculated specifically at
+            an IoU threshold of `0.75`.
+        per_class_ap50_95: Average Precision (AP) values calculated over
+            IoU thresholds ranging from `0.50` to `0.95` with a step size of `0.05`,
+            provided for each individual class.
+    """
+
+    map50_95: float
+    map50: float
+    map75: float
+    per_class_ap50_95: npt.NDArray[np.float64]
+
+    @classmethod
+    def from_detections(
+        cls,
+        predictions: list[Detections],
+        targets: list[Detections],
+    ) -> MeanAveragePrecision:
+        """
+        Calculate mean average precision based on predicted and ground-truth detections.
+
+        Args:
+            targets: Detections objects from ground-truth.
+            predictions: Detections objects predicted by the model.
+        Returns:
+            New instance of ConfusionMatrix.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> targets = [
+            ...     sv.Detections(
+            ...         xyxy=np.array([[0, 0, 10, 10]]),
+            ...         class_id=np.array([0])
+            ...     )
+            ... ]
+            >>> predictions = [
+            ...     sv.Detections(
+            ...         xyxy=np.array([[0, 0, 10, 10]]),
+            ...         class_id=np.array([0]),
+            ...         confidence=np.array([0.9])
+            ...     )
+            ... ]
+            >>> mAP = sv.MeanAveragePrecision.from_detections(
+            ...     predictions=predictions,
+            ...     targets=targets,
+            ... )
+            >>> round(float(mAP.map50), 2)
+            1.0
+
+            ```
+        """
+        prediction_tensors = []
+        target_tensors = []
+        for prediction, target in zip(predictions, targets):
+            prediction_tensors.append(
+                detections_to_tensor(prediction, with_confidence=True)
+            )
+            target_tensors.append(detections_to_tensor(target, with_confidence=False))
+        return cls.from_tensors(
+            predictions=prediction_tensors,
+            targets=target_tensors,
+        )
+
+    @classmethod
+    def benchmark(
+        cls,
+        dataset: DetectionDataset,
+        callback: Callable[[npt.NDArray[np.uint8]], Detections],
+    ) -> MeanAveragePrecision:
+        """
+        Calculate mean average precision from dataset and callback function.
+
+        Args:
+            dataset: Object detection dataset used for evaluation.
+            callback: Function that takes
+                an image as input and returns Detections object.
+        Returns:
+            New instance of MeanAveragePrecision.
+
+        Example:
+            ```python
+            import supervision as sv
+            from rfdetr import RFDETRMedium
+
+            dataset = sv.DetectionDataset.from_yolo(...)
+
+            model = RFDETRMedium()
+            def callback(image: np.ndarray) -> sv.Detections:
+                return model.predict(image[:, :, ::-1])
+
+            mean_average_precision = sv.MeanAveragePrecision.benchmark(
+                dataset = dataset,
+                callback = callback
+            )
+
+            print(mean_average_precision.map50_95)
+            # 0.433
+            ```
+        """
+        predictions, targets = [], []
+        for _, image, annotation in dataset:
+            predictions_batch = callback(image)
+            predictions.append(predictions_batch)
+            targets.append(annotation)
+        return cls.from_detections(
+            predictions=predictions,
+            targets=targets,
+        )
+
+    @classmethod
+    def from_tensors(
+        cls,
+        predictions: list[npt.NDArray[np.float32]],
+        targets: list[npt.NDArray[np.float32]],
+    ) -> MeanAveragePrecision:
+        """
+        Calculate Mean Average Precision based on predicted and ground-truth
+            detections at different threshold.
+
+        Args:
+            predictions: Each element of the list describes
+                a single image and has `shape = (M, 6)` where `M` is
+                the number of detected objects. Each row is expected to be
+                in `(x_min, y_min, x_max, y_max, class, conf)` format.
+            targets: Each element of the list describes a single
+                image and has `shape = (N, 5)` where `N` is the
+                number of ground-truth objects. Each row is expected to be in
+                `(x_min, y_min, x_max, y_max, class)` format. An empty array
+                (``N = 0``) represents a background image; all predictions on
+                that image count as false positives and reduce AP accordingly.
+
+        Returns:
+            MeanAveragePrecision: New instance computed from the provided
+                predictions and targets.
+
+        Examples:
+            ```pycon
+            >>> import supervision as sv
+            >>> import numpy as np
+            >>> targets = [
+            ...     np.array([
+            ...         [0.0, 0.0, 3.0, 3.0, 0],
+            ...         [2.0, 2.0, 5.0, 5.0, 0],
+            ...         [6.0, 1.0, 8.0, 3.0, 1],
+            ...     ])
+            ... ]
+            >>> predictions = [
+            ...     np.array([
+            ...         [0.0, 0.0, 3.0, 3.0, 0, 0.9],
+            ...         [0.1, 0.1, 3.0, 3.0, 0, 0.9],
+            ...         [6.0, 1.0, 8.0, 3.0, 1, 0.8],
+            ...     ])
+            ... ]
+            >>> mAP = sv.MeanAveragePrecision.from_tensors(
+            ...     predictions=predictions,
+            ...     targets=targets,
+            ... )
+            >>> round(float(mAP.map50), 2)
+            0.75
+
+            >>> bg_pred = [np.array([[0., 0., 10., 10., 0, 0.9]], dtype=np.float32)]
+            >>> bg_tgt = [np.zeros((0, 5), dtype=np.float32)]
+            >>> mAP_bg = sv.MeanAveragePrecision.from_tensors(
+            ...     predictions=bg_pred,
+            ...     targets=bg_tgt,
+            ... )
+            >>> float(mAP_bg.map50)
+            0.0
+
+            ```
+        """
+        _validate_input_tensors(predictions, targets)
+        iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32)
+        stats = []
+
+        # Gather matching stats for predictions and targets
+        for true_objs, predicted_objs in zip(targets, predictions):
+            if predicted_objs.shape[0] == 0:
+                if true_objs.shape[0]:
+                    stats.append(
+                        (
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            *np.zeros((2, 0)),
+                            true_objs[:, 4],
+                        )
+                    )
+                continue
+
+            if true_objs.shape[0]:
+                matches = cls._match_detection_batch(
+                    predicted_objs, true_objs, iou_thresholds
+                )
+                stats.append(
+                    (
+                        matches,
+                        predicted_objs[:, 5],
+                        predicted_objs[:, 4],
+                        true_objs[:, 4],
+                    )
+                )
+            else:
+                # Background image: no GT boxes, so all predictions are FP matches.
+                # This lowers AP for classes that appear in at least one GT image
+                # elsewhere; classes absent from all GT images are excluded from AP
+                # (they never appear in true_class_ids and are skipped by the AP loop).
+                stats.append(
+                    (
+                        np.zeros(
+                            (predicted_objs.shape[0], iou_thresholds.size), dtype=bool
+                        ),
+                        predicted_objs[:, 5],
+                        predicted_objs[:, 4],
+                        np.zeros((0,), dtype=np.float32),
+                    )
+                )
+
+        # Compute average precisions if any matches exist
+        if stats:
+            concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)]
+            average_precisions = cls._average_precisions_per_class(
+                cast(npt.NDArray[np.bool_], concatenated_stats[0]),
+                cast(npt.NDArray[np.float32], concatenated_stats[1]),
+                cast(npt.NDArray[np.int32], concatenated_stats[2]),
+                cast(npt.NDArray[np.int32], concatenated_stats[3]),
+            )
+            if average_precisions.size == 0:
+                # All images had no ground-truth objects; FPs recorded but no class
+                # to accumulate AP over → return 0.0 rather than NaN.
+                map50, map75, map50_95 = 0.0, 0.0, 0.0
+            else:
+                map50 = float(average_precisions[:, 0].mean())
+                map75 = float(average_precisions[:, 5].mean())
+                map50_95 = float(average_precisions.mean())
+        else:
+            map50, map75, map50_95 = 0, 0, 0
+            average_precisions = np.array([])
+
+        return cls(
+            map50_95=map50_95,
+            map50=map50,
+            map75=map75,
+            per_class_ap50_95=average_precisions,
+        )
+
+    @staticmethod
+    def compute_average_precision(
+        recall: npt.NDArray[np.float64],
+        precision: npt.NDArray[np.float64],
+    ) -> float:
+        """
+        Compute the average precision using 101-point interpolation (COCO), given
+            the recall and precision curves.
+
+        Args:
+            recall: The recall curve.
+            precision: The precision curve.
+
+        Returns:
+            Average precision.
+        """
+        extended_recall = np.concatenate(([0.0], recall, [1.0]))
+        extended_precision = np.concatenate(([0.0], precision, [0.0]))
+        max_accumulated_precision = np.flip(
+            np.maximum.accumulate(np.flip(extended_precision))
+        )
+        interpolated_recall_levels = np.linspace(0, 1, 101)
+        recall_indices = np.searchsorted(
+            extended_recall, interpolated_recall_levels, side="left"
+        )
+        interpolated_precision = max_accumulated_precision[recall_indices]
+        average_precision = np.mean(interpolated_precision)
+
+        return float(average_precision)
+
+    @staticmethod
+    def _match_detection_batch(
+        predictions: npt.NDArray[np.float32],
+        targets: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        """
+        Match predictions with target labels based on IoU levels.
+
+        Args:
+            predictions: Batch prediction. Describes a single image and
+                has `shape = (M, 6)` where `M` is the number of detected objects.
+                Each row is expected to be in
+                `(x_min, y_min, x_max, y_max, class, conf)` format.
+            targets: Batch target labels. Describes a single image and
+                has `shape = (N, 5)` where `N` is the number of ground-truth objects.
+                Each row is expected to be in
+                `(x_min, y_min, x_max, y_max, class)` format.
+            iou_thresholds: Array contains different IoU thresholds.
+
+        Returns:
+            Matched prediction with target labels result.
+        """
+        num_predictions, num_iou_levels = predictions.shape[0], iou_thresholds.shape[0]
+        correct = np.zeros((num_predictions, num_iou_levels), dtype=bool)
+        iou = box_iou_batch(targets[:, :4], predictions[:, :4])
+        correct_class = targets[:, 4:5] == predictions[:, 4]
+
+        for i, iou_level in enumerate(iou_thresholds):
+            matched_indices = np.where((iou >= iou_level) & correct_class)
+
+            for t, p in _greedy_match(iou, matched_indices):
+                correct[p, i] = True
+        result: npt.NDArray[np.bool_] = correct
+        return result
+
+    @staticmethod
+    def _average_precisions_per_class(
+        matches: npt.NDArray[np.bool_],
+        prediction_confidence: npt.NDArray[np.float32],
+        prediction_class_ids: npt.NDArray[np.int32],
+        true_class_ids: npt.NDArray[np.int32],
+        eps: float = 1e-16,
+    ) -> npt.NDArray[np.float64]:
+        """
+        Compute the average precision, given the recall and precision curves.
+        Source: https://github.com/rafaelpadilla/Object-Detection-Metrics.
+
+        Args:
+            matches: True positives.
+            prediction_confidence: Objectness value from 0-1.
+            prediction_class_ids: Predicted object classes.
+            true_class_ids: True object classes.
+            eps: Small value to prevent division by zero.
+
+        Returns:
+            Average precision for different IoU levels.
+        """
+        sorted_indices = np.argsort(-prediction_confidence)
+        matches = matches[sorted_indices]
+        prediction_class_ids = prediction_class_ids[sorted_indices]
+
+        unique_classes, class_counts = np.unique(true_class_ids, return_counts=True)
+        num_classes = unique_classes.shape[0]
+
+        average_precisions: npt.NDArray[np.float64] = np.zeros(
+            (num_classes, matches.shape[1]), dtype=np.float64
+        )
+
+        for class_idx, class_id in enumerate(unique_classes):
+            is_class = prediction_class_ids == class_id
+            total_true = class_counts[class_idx]
+            total_prediction = is_class.sum()
+
+            if total_prediction == 0 or total_true == 0:
+                continue
+
+            false_positives = (1 - matches[is_class]).cumsum(0)
+            true_positives = matches[is_class].cumsum(0)
+            recall = true_positives / (total_true + eps)
+            precision = true_positives / (true_positives + false_positives)
+
+            for iou_level_idx in range(matches.shape[1]):
+                average_precisions[class_idx, iou_level_idx] = (
+                    MeanAveragePrecision.compute_average_precision(
+                        recall[:, iou_level_idx], precision[:, iou_level_idx]
+                    )
+                )
+
+        result: npt.NDArray[np.float64] = average_precisions
+        return result
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/f1_score.py b/.venv/lib/python3.12/site-packages/supervision/metrics/f1_score.py
new file mode 100644
index 0000000000000000000000000000000000000000..a8c1402d56db8352c80ea8117c0f5a27400cbc47
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/f1_score.py
@@ -0,0 +1,819 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.draw.color import LEGACY_COLOR_PALETTE
+from supervision.metrics.core import AveragingMethod, Metric, MetricTarget
+from supervision.metrics.utils.matching import (
+    _match_detection_batch_with_target_indices,
+)
+from supervision.metrics.utils.object_size import (
+    ObjectSizeCategory,
+    get_detection_size_category,
+)
+from supervision.metrics.utils.utils import ensure_pandas_installed
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class F1Score(Metric["F1ScoreResult"]):
+    """
+    F1 Score is a metric used to evaluate object detection models. It is the harmonic
+    mean of precision and recall, calculated at different IoU thresholds.
+
+    In simple terms, F1 Score is a measure of a model's balance between precision and
+    recall (accuracy and completeness), calculated as:
+
+    `F1 = 2 * (precision * recall) / (precision + recall)`
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics import F1Score
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> f1_metric = F1Score()
+        >>> f1_result = f1_metric.update(predictions, targets).compute()
+        >>> round(float(f1_result.f1_50), 2)
+        1.0
+
+        ```
+
+    ![example_plot](
+        https://media.roboflow.com/supervision-docs/metrics/f1_plot_example.png
+    ){ align=center width="800" }
+    """
+
+    def __init__(
+        self,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+        averaging_method: AveragingMethod = AveragingMethod.WEIGHTED,
+    ):
+        """
+        Initialize the F1Score metric.
+
+        Args:
+            metric_target: The type of detection data to use.
+            averaging_method: The averaging method used to compute the
+                F1 scores. Determines how the F1 scores are aggregated across classes.
+        """
+        self._metric_target = metric_target
+        self.averaging_method = averaging_method
+
+        self._predictions_list: list[Detections] = []
+        self._targets_list: list[Detections] = []
+
+    def reset(self) -> None:
+        """
+        Reset the metric to its initial state, clearing all stored data.
+        """
+        self._predictions_list = []
+        self._targets_list = []
+
+    def update(
+        self,
+        predictions: Detections | list[Detections],
+        targets: Detections | list[Detections],
+    ) -> F1Score:
+        """
+        Add new predictions and targets to the metric, but do not compute the result.
+
+        Args:
+            predictions: The predicted detections.
+            targets: The target detections.
+
+        Returns:
+            The updated metric instance.
+        """
+        if not isinstance(predictions, list):
+            predictions = [predictions]
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        if len(predictions) != len(targets):
+            raise ValueError(
+                f"The number of predictions ({len(predictions)}) and"
+                f" targets ({len(targets)}) during the update must be the same."
+            )
+
+        self._predictions_list.extend(predictions)
+        self._targets_list.extend(targets)
+
+        return self
+
+    def compute(self) -> F1ScoreResult:
+        """
+        Calculate the F1 score metric based on the stored predictions and ground-truth
+        data, at different IoU thresholds.
+
+        Returns:
+            The F1 score metric result.
+        """
+        result = self._compute(self._predictions_list, self._targets_list)
+        result.small_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL
+        )
+        result.medium_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM
+        )
+        result.large_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE
+        )
+
+        return result
+
+    def _compute(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory = ObjectSizeCategory.ANY,
+    ) -> F1ScoreResult:
+        """Build per-image stats tuples and delegate to class-level computation.
+
+        Each stats tuple is
+        ``(matches, ignored_matches, confidence, class_ids, true_class_ids)``:
+        - Both empty: skip (no information).
+        - Targets empty, predictions present: all predictions are FPs; true_class_ids
+          is ``zeros((0,))``.
+        - Targets present: IoU matching produces ``matches`` array.
+        """
+        iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32)
+        stats: list[Any] = []
+
+        for predictions, targets in zip(predictions_list, targets_list):
+            prediction_contents = self._detections_content(predictions)
+            target_contents = self._detections_content(targets)
+            prediction_size_mask = np.ones(len(predictions), dtype=bool)
+            target_size_mask = np.ones(len(targets), dtype=bool)
+            if size_category != ObjectSizeCategory.ANY:
+                if len(predictions) > 0:
+                    prediction_size_mask = (
+                        get_detection_size_category(predictions, self._metric_target)
+                        == size_category.value
+                    )
+                if len(targets) > 0:
+                    target_size_mask = (
+                        get_detection_size_category(targets, self._metric_target)
+                        == size_category.value
+                    )
+
+            if len(targets) == 0 and len(predictions) > 0:
+                # Only predictions are present (e.g. a background image); every
+                # prediction is a false positive.
+                if predictions.class_id is None or predictions.confidence is None:
+                    raise ValueError(
+                        "F1Score metric requires `class_id` and `confidence` "
+                        "on predictions."
+                    )
+                prediction_class_ids = np.asarray(predictions.class_id, dtype=np.int32)[
+                    prediction_size_mask
+                ]
+                prediction_confidence = np.asarray(
+                    predictions.confidence, dtype=np.float32
+                )[prediction_size_mask]
+                if len(prediction_class_ids) == 0:
+                    continue
+                stats.append(
+                    (
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        prediction_confidence,
+                        prediction_class_ids,
+                        np.zeros((0,), dtype=np.int32),
+                    )
+                )
+            elif len(targets) > 0:
+                if predictions.class_id is None or targets.class_id is None:
+                    raise ValueError(
+                        "F1Score metric requires `class_id` on both predictions "
+                        "and targets."
+                    )
+                if len(predictions) == 0:
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[
+                        target_size_mask
+                    ]
+                    if len(target_class_ids) == 0:
+                        continue
+                    stats.append(
+                        (
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0,), dtype=np.float32),
+                            np.zeros((0,), dtype=int),
+                            target_class_ids,
+                        )
+                    )
+
+                else:
+                    if predictions.confidence is None:
+                        raise ValueError(
+                            "F1Score metric requires `confidence` on predictions."
+                        )
+                    prediction_class_ids = np.asarray(
+                        predictions.class_id, dtype=np.int32
+                    )
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)
+                    prediction_confidence = np.asarray(
+                        predictions.confidence, dtype=np.float32
+                    )
+                    if self._metric_target == MetricTarget.BOXES:
+                        # BOXES target never yields CompactMask; narrow for mypy.
+                        iou = box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    elif self._metric_target == MetricTarget.MASKS:
+                        iou = mask_iou_batch(target_contents, prediction_contents)
+                    elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+                        # OBB target never yields CompactMask; narrow for mypy.
+                        iou = oriented_box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    else:
+                        raise ValueError(
+                            "Unsupported metric target for IoU calculation"
+                        )
+
+                    # None keeps the matcher on its single-round fast path
+                    # when no size bucket is scored.
+                    target_scored_mask = (
+                        target_size_mask
+                        if size_category != ObjectSizeCategory.ANY
+                        else None
+                    )
+                    matches, matched_target_indices = (
+                        _match_detection_batch_with_target_indices(
+                            prediction_class_ids,
+                            target_class_ids,
+                            iou,
+                            iou_thresholds,
+                            target_scored_mask=target_scored_mask,
+                        )
+                    )
+                    ignored_matches = np.zeros_like(matches, dtype=bool)
+                    if size_category != ObjectSizeCategory.ANY:
+                        valid_target_match = matched_target_indices >= 0
+                        matched_scored_target = np.zeros_like(matches, dtype=bool)
+                        if np.any(valid_target_match):
+                            matched_scored_target[valid_target_match] = (
+                                target_size_mask[
+                                    matched_target_indices[valid_target_match]
+                                ]
+                            )
+                        prediction_scored = (
+                            prediction_size_mask[:, None] | matched_scored_target
+                        )
+                        ignored_matches = ~prediction_scored | (
+                            valid_target_match & ~matched_scored_target
+                        )
+                        prediction_keep = np.any(~ignored_matches, axis=1)
+                        matches = (
+                            matches[prediction_keep]
+                            & matched_scored_target[prediction_keep]
+                        )
+                        ignored_matches = ignored_matches[prediction_keep]
+                        prediction_confidence = prediction_confidence[prediction_keep]
+                        prediction_class_ids = prediction_class_ids[prediction_keep]
+                        target_class_ids = target_class_ids[target_size_mask]
+                        if (
+                            len(prediction_class_ids) == 0
+                            and len(target_class_ids) == 0
+                        ):
+                            continue
+                    stats.append(
+                        (
+                            matches,
+                            ignored_matches,
+                            prediction_confidence,
+                            prediction_class_ids,
+                            target_class_ids,
+                        )
+                    )
+
+        if not stats:
+            return F1ScoreResult(
+                metric_target=self._metric_target,
+                averaging_method=self.averaging_method,
+                f1_scores=np.zeros(iou_thresholds.shape[0]),
+                f1_per_class=np.zeros((0, iou_thresholds.shape[0])),
+                iou_thresholds=iou_thresholds,
+                matched_classes=np.array([], dtype=int),
+                small_objects=None,
+                medium_objects=None,
+                large_objects=None,
+            )
+
+        concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)]
+        f1_scores, f1_per_class, unique_classes = self._compute_f1_for_classes(
+            *concatenated_stats
+        )
+
+        return F1ScoreResult(
+            metric_target=self._metric_target,
+            averaging_method=self.averaging_method,
+            f1_scores=f1_scores,
+            f1_per_class=f1_per_class,
+            iou_thresholds=iou_thresholds,
+            matched_classes=unique_classes,
+            small_objects=None,
+            medium_objects=None,
+            large_objects=None,
+        )
+
+    def _compute_f1_for_classes(
+        self,
+        matches: npt.NDArray[np.bool_],
+        ignored_matches: npt.NDArray[np.bool_],
+        prediction_confidence: npt.NDArray[np.float32],
+        prediction_class_ids: npt.NDArray[np.int32],
+        true_class_ids: npt.NDArray[np.int32],
+    ) -> tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+    ]:
+        """Compute F1 scores from concatenated stats across all images.
+
+        ``unique_classes`` is the union of GT and predicted classes so that
+        predictions of classes absent from GT still count as false positives.
+        """
+        sorted_indices = np.argsort(-prediction_confidence)
+        matches = matches[sorted_indices]
+        ignored_matches = ignored_matches[sorted_indices]
+        prediction_class_ids = prediction_class_ids[sorted_indices]
+        # Predictions whose class never appears in the ground truth are still
+        # false positives, so include those classes in the confusion matrix
+        # (their true-instance count is zero).
+        unique_classes = np.unique(
+            np.concatenate((true_class_ids, prediction_class_ids))
+        )
+        true_classes, true_counts = np.unique(true_class_ids, return_counts=True)
+        class_counts = np.zeros(unique_classes.shape[0], dtype=int)
+        class_counts[np.searchsorted(unique_classes, true_classes)] = true_counts
+
+        # Shape: PxTh,P,C,C -> CxThx3
+        confusion_matrix = self._compute_confusion_matrix(
+            matches, ignored_matches, prediction_class_ids, unique_classes, class_counts
+        )
+
+        # Shape: CxThx3 -> CxTh
+        f1_per_class = self._compute_f1(confusion_matrix)
+
+        # Shape: CxTh -> Th
+        if self.averaging_method == AveragingMethod.MACRO:
+            f1_scores = np.mean(f1_per_class, axis=0)
+        elif self.averaging_method == AveragingMethod.MICRO:
+            confusion_matrix_merged = confusion_matrix.sum(0)
+            f1_scores = self._compute_f1(confusion_matrix_merged)
+        elif self.averaging_method == AveragingMethod.WEIGHTED:
+            class_counts = class_counts.astype(np.float32)
+            if class_counts.sum() == 0:
+                # No ground-truth support (e.g. only false-positive classes, or a
+                # size bucket with predictions but no targets): weighting is
+                # undefined, so report 0 as the empty case did before.
+                f1_scores = np.zeros(f1_per_class.shape[1])
+            else:
+                f1_scores = np.average(f1_per_class, axis=0, weights=class_counts)
+
+        return f1_scores, f1_per_class, unique_classes
+
+    @staticmethod
+    def _match_detection_batch(
+        predictions_classes: npt.NDArray[np.int32],
+        target_classes: npt.NDArray[np.int32],
+        iou: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        result_correct, _ = _match_detection_batch_with_target_indices(
+            predictions_classes, target_classes, iou, iou_thresholds
+        )
+        return result_correct
+
+    @staticmethod
+    def _compute_confusion_matrix(
+        sorted_matches: npt.NDArray[np.bool_],
+        sorted_ignored_matches: npt.NDArray[np.bool_],
+        sorted_prediction_class_ids: npt.NDArray[np.int32],
+        unique_classes: npt.NDArray[np.int32],
+        class_counts: npt.NDArray[np.int32],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Compute the confusion matrix for each class and IoU threshold.
+
+        Assumes the matches and prediction_class_ids are sorted by confidence
+        in descending order.
+
+        Args:
+            sorted_matches: shape (P, Th), that is True
+                if the prediction is a true positive at the given IoU threshold.
+            sorted_ignored_matches: shape (P, Th), that is True
+                if the prediction should not affect the given IoU threshold.
+            sorted_prediction_class_ids: shape (P,), containing
+                the class id for each prediction.
+            unique_classes: shape (C,), containing the unique
+                class ids.
+            class_counts: shape (C,), containing the number
+                of true instances for each class.
+
+        Returns:
+            shape (C, Th, 3), containing the true positives, false
+                positives, and false negatives for each class and IoU threshold.
+        """
+
+        num_thresholds = sorted_matches.shape[1]
+        num_classes = unique_classes.shape[0]
+
+        confusion_matrix: npt.NDArray[np.float64] = np.zeros(
+            (num_classes, num_thresholds, 3), dtype=np.float64
+        )
+        for class_idx, class_id in enumerate(unique_classes):
+            is_class = sorted_prediction_class_ids == class_id
+            num_true = class_counts[class_idx]
+            num_predictions = is_class.sum()
+
+            if num_predictions == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = np.zeros(num_thresholds)
+                false_negatives = np.full(num_thresholds, num_true)
+            elif num_true == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = (~sorted_ignored_matches[is_class]).sum(0)
+                false_negatives = np.zeros(num_thresholds)
+            else:
+                true_positives = sorted_matches[is_class].sum(0)
+                false_positives = (
+                    ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class]
+                ).sum(0)
+                false_negatives = num_true - true_positives
+            confusion_matrix[class_idx] = np.stack(
+                [true_positives, false_positives, false_negatives], axis=1
+            )
+
+        result_confusion_matrix: npt.NDArray[np.float64] = confusion_matrix
+        return result_confusion_matrix
+
+    @staticmethod
+    def _compute_f1(
+        confusion_matrix: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Broadcastable function, computing the F1 score from the confusion matrix.
+
+        Args:
+            confusion_matrix: shape (N, ..., 3), where the last dimension
+                contains the true positives, false positives, and false negatives.
+
+        Returns:
+            shape (N, ...), containing the F1 score for each element.
+        """
+        if not confusion_matrix.shape[-1] == 3:
+            raise ValueError(
+                f"Confusion matrix must have shape (..., 3), got "
+                f"{confusion_matrix.shape}"
+            )
+        true_positives = confusion_matrix[..., 0]
+        false_positives = confusion_matrix[..., 1]
+        false_negatives = confusion_matrix[..., 2]
+
+        # Alternate formula, avoids multiple zero division checks
+        denominator = 2 * true_positives + false_positives + false_negatives
+        f1_score = np.divide(
+            2 * true_positives,
+            denominator,
+            out=np.zeros_like(denominator, dtype=np.float64),
+            where=denominator != 0,
+        )
+
+        result_f1_score: npt.NDArray[np.float64] = f1_score
+        return result_f1_score
+
+    def _detections_content(
+        self, detections: Detections
+    ) -> npt.NDArray[Any] | CompactMask:
+        """Return boxes, masks or oriented bounding boxes from detections.
+
+        For the mask target this may return a
+        :class:`~supervision.detection.compact_mask.CompactMask` rather than a
+        dense boolean array when the detections carry compact masks.
+        """
+        if self._metric_target == MetricTarget.BOXES:
+            return cast(npt.NDArray[Any], detections.xyxy)
+        if self._metric_target == MetricTarget.MASKS:
+            if detections.mask is not None:
+                # detections.mask is NDArray[bool] | CompactMask; return as-is.
+                return detections.mask
+            if len(detections) > 0:
+                raise ValueError(
+                    "F1Score with `MetricTarget.MASKS` requires detections to "
+                    "include masks."
+                )
+            return self._make_empty_content()
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+            if obb is not None and len(obb) > 0:
+                result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32)
+                return result_obb
+            return self._make_empty_content()
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _make_empty_content(self) -> npt.NDArray[Any]:
+        if self._metric_target == MetricTarget.BOXES:
+            empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32)
+            return empty_boxes
+        if self._metric_target == MetricTarget.MASKS:
+            empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool)
+            return empty_masks
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32)
+            return empty_obb
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _filter_detections_by_size(
+        self, detections: Detections, size_category: ObjectSizeCategory
+    ) -> Detections:
+        """Return a copy of detections with contents filtered by object size."""
+        new_detections = deepcopy(detections)
+        if detections.is_empty() or size_category == ObjectSizeCategory.ANY:
+            return new_detections
+
+        sizes = get_detection_size_category(new_detections, self._metric_target)
+        size_mask = sizes == size_category.value
+
+        new_detections.xyxy = new_detections.xyxy[size_mask]
+        if new_detections.mask is not None:
+            new_detections.mask = new_detections.mask[size_mask]
+        if new_detections.class_id is not None:
+            new_detections.class_id = new_detections.class_id[size_mask]
+        if new_detections.confidence is not None:
+            new_detections.confidence = new_detections.confidence[size_mask]
+        if new_detections.tracker_id is not None:
+            new_detections.tracker_id = new_detections.tracker_id[size_mask]
+        if new_detections.data is not None:
+            for key, value in new_detections.data.items():
+                new_detections.data[key] = np.array(value)[size_mask]
+
+        return new_detections
+
+    def _filter_predictions_and_targets_by_size(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory,
+    ) -> tuple[list[Detections], list[Detections]]:
+        """
+        Filter predictions and targets by object size category.
+        """
+        new_predictions_list = []
+        new_targets_list = []
+        for predictions, targets in zip(predictions_list, targets_list):
+            new_predictions_list.append(
+                self._filter_detections_by_size(predictions, size_category)
+            )
+            new_targets_list.append(
+                self._filter_detections_by_size(targets, size_category)
+            )
+        return new_predictions_list, new_targets_list
+
+
+@dataclass
+class F1ScoreResult:
+    """
+    The results of the F1 score metric calculation.
+
+    Defaults to `0` if no detections or targets were provided.
+
+    Attributes:
+        metric_target: the type of data used for the metric -
+            boxes, masks or oriented bounding boxes.
+        averaging_method: the averaging method used to compute the
+            F1 scores. Determines how the F1 scores are aggregated across classes.
+        f1_50: the F1 score at IoU threshold of `0.5`.
+        f1_75: the F1 score at IoU threshold of `0.75`.
+        f1_scores: the F1 scores at each IoU threshold.
+            Shape: `(num_iou_thresholds,)`
+        f1_per_class: the F1 scores per class and IoU threshold.
+            Shape: `(num_classes, num_iou_thresholds)`
+        iou_thresholds: the IoU thresholds used in the calculations.
+        matched_classes: the class IDs present in either predictions or ground
+            truth. Corresponds to the rows of `f1_per_class`. Classes that
+            appear only in predictions (no ground-truth instances) are
+            included; their per-threshold F1 values will be `0.0`.
+        small_objects: the F1 metric results
+            for small objects (area < 32²).
+        medium_objects: the F1 metric results
+            for medium objects (32² ≤ area < 96²).
+        large_objects: the F1 metric results
+            for large objects (area ≥ 96²).
+    """
+
+    metric_target: MetricTarget
+    averaging_method: AveragingMethod
+
+    @property
+    def f1_50(self) -> float:
+        return float(self.f1_scores[0])
+
+    @property
+    def f1_75(self) -> float:
+        return float(self.f1_scores[5])
+
+    f1_scores: npt.NDArray[np.float64]
+    f1_per_class: npt.NDArray[np.float64]
+    iou_thresholds: npt.NDArray[np.float32]
+    matched_classes: npt.NDArray[np.int32]
+
+    small_objects: F1ScoreResult | None
+    medium_objects: F1ScoreResult | None
+    large_objects: F1ScoreResult | None
+
+    def __str__(self) -> str:
+        """
+        Format as a pretty string.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from supervision.metrics import F1Score
+            >>> predictions = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0]),
+            ...     confidence=np.array([0.9])
+            ... )
+            >>> targets = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> f1_metric = F1Score()
+            >>> f1_result = f1_metric.update(predictions, targets).compute()
+            >>> print(f1_result)  # doctest: +ELLIPSIS
+            F1ScoreResult:
+            Metric target: MetricTarget.BOXES
+            Averaging method: AveragingMethod.WEIGHTED
+            F1 @ 50:     1.0000
+            F1 @ 75:     1.0000
+            F1 @ thresh: [1. ... 1.]
+            IoU thresh:  [0.5  0.55 ... 0.95]
+            F1 per class:
+              0: [1. ... 1.]
+            ...
+            Medium objects:
+              F1ScoreResult:
+              Metric target: MetricTarget.BOXES
+              Averaging method: AveragingMethod.WEIGHTED
+              F1 @ 50:     0.0000
+              ...
+
+            ```
+        """
+        out_str = (
+            f"{self.__class__.__name__}:\n"
+            f"Metric target: {self.metric_target}\n"
+            f"Averaging method: {self.averaging_method}\n"
+            f"F1 @ 50:     {self.f1_50:.4f}\n"
+            f"F1 @ 75:     {self.f1_75:.4f}\n"
+            f"F1 @ thresh: {self.f1_scores}\n"
+            f"IoU thresh:  {self.iou_thresholds}\n"
+            f"F1 per class:\n"
+        )
+        if self.f1_per_class.size == 0:
+            out_str += "  No results\n"
+        for class_id, f1_of_class in zip(self.matched_classes, self.f1_per_class):
+            out_str += f"  {class_id}: {f1_of_class}\n"
+
+        indent = "  "
+        if self.small_objects is not None:
+            indented = indent + str(self.small_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nSmall objects:\n{indented}"
+        if self.medium_objects is not None:
+            indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nMedium objects:\n{indented}"
+        if self.large_objects is not None:
+            indented = indent + str(self.large_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nLarge objects:\n{indented}"
+
+        return out_str
+
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the result to a pandas DataFrame.
+
+        Returns:
+            The result as a DataFrame.
+        """
+        ensure_pandas_installed()
+        import pandas as pd
+
+        pandas_data: dict[str, Any] = {
+            "F1@50": self.f1_50,
+            "F1@75": self.f1_75,
+        }
+
+        if self.small_objects is not None:
+            small_objects_df = self.small_objects.to_pandas()
+            for key, value in small_objects_df.items():
+                pandas_data[f"small_objects_{key}"] = value
+        if self.medium_objects is not None:
+            medium_objects_df = self.medium_objects.to_pandas()
+            for key, value in medium_objects_df.items():
+                pandas_data[f"medium_objects_{key}"] = value
+        if self.large_objects is not None:
+            large_objects_df = self.large_objects.to_pandas()
+            for key, value in large_objects_df.items():
+                pandas_data[f"large_objects_{key}"] = value
+
+        return pd.DataFrame(pandas_data, index=[0])
+
+    def plot(self) -> None:
+        """
+        Plot the F1 results.
+
+        ![example_plot](
+            https://media.roboflow.com/supervision-docs/metrics/f1_plot_example.png
+        ){ align=center width="800" }
+        """
+        from matplotlib import pyplot as plt
+
+        labels = ["F1@50", "F1@75"]
+        values = [self.f1_50, self.f1_75]
+        colors = [LEGACY_COLOR_PALETTE[0]] * 2
+
+        if self.small_objects is not None:
+            small_objects = self.small_objects
+            labels += ["Small: F1@50", "Small: F1@75"]
+            values += [small_objects.f1_50, small_objects.f1_75]
+            colors += [LEGACY_COLOR_PALETTE[3]] * 2
+
+        if self.medium_objects is not None:
+            medium_objects = self.medium_objects
+            labels += ["Medium: F1@50", "Medium: F1@75"]
+            values += [medium_objects.f1_50, medium_objects.f1_75]
+            colors += [LEGACY_COLOR_PALETTE[2]] * 2
+
+        if self.large_objects is not None:
+            large_objects = self.large_objects
+            labels += ["Large: F1@50", "Large: F1@75"]
+            values += [large_objects.f1_50, large_objects.f1_75]
+            colors += [LEGACY_COLOR_PALETTE[4]] * 2
+
+        plt.rcParams["font.family"] = "monospace"
+
+        _, ax = plt.subplots(figsize=(10, 6))
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Value", fontweight="bold")
+        title = (
+            f"F1 Score, by Object Size"
+            f"\n(target: {self.metric_target.value},"
+            f" averaging: {self.averaging_method.value})"
+        )
+        ax.set_title(title, fontweight="bold")
+
+        x_positions = range(len(labels))
+        bars = ax.bar(x_positions, values, color=colors, align="center")
+
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right")
+
+        for bar in bars:
+            y_value = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                y_value + 0.02,
+                f"{y_value:.2f}",
+                ha="center",
+                va="bottom",
+            )
+
+        plt.rcParams["font.family"] = "sans-serif"
+
+        plt.tight_layout()
+        plt.show()
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_precision.py b/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cd04fa6cc4e6a5c331cb945626f1a8dfdb4913a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_precision.py
@@ -0,0 +1,1726 @@
+from __future__ import annotations
+
+import copy
+import datetime
+import itertools
+from collections import defaultdict
+from copy import deepcopy
+from dataclasses import dataclass
+from enum import Enum
+from typing import TYPE_CHECKING, Any, TypeAlias, TypedDict
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import AREA_DATA_FIELD, ORIENTED_BOX_COORDINATES
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch_with_jaccard,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.draw.color import LEGACY_COLOR_PALETTE
+from supervision.metrics.core import Metric, MetricTarget
+from supervision.metrics.utils.utils import ensure_pandas_installed
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class _TypeCocoDict(TypedDict, total=False):
+    id: int
+    image_id: int
+    category_id: int
+    bbox: list[float]
+    area: float
+    iscrowd: int
+    ignore: int
+    _ignore: int
+    score: float
+    segmentation: list[list[float]]
+    name: str
+    supercategory: str
+    caption: str
+    keypoints: list[float]
+    # Metric-target-specific content: a boolean mask of shape (H, W) for
+    # `MetricTarget.MASKS` or an oriented box of shape (4, 2) for
+    # `MetricTarget.ORIENTED_BOUNDING_BOXES`. Absent for `MetricTarget.BOXES`.
+    # Invariant: shape/dtype match `metric_target` of the owning COCOEvaluator.
+    content: npt.NDArray[Any]
+
+
+_TypeCocoDataset: TypeAlias = dict[str, list[_TypeCocoDict]]
+
+
+class _TypeEvaluationImageResult(TypedDict):
+    image_id: int
+    category_id: int
+    area_range: list[float] | tuple[float, float]
+    max_det: int
+    dt_ids: list[int]
+    gt_ids: list[int]
+    dtMatches: npt.NDArray[np.int64]
+    gtMatches: npt.NDArray[np.int64]
+    dtScores: list[float]
+    gtIgnore: npt.NDArray[np.int64]
+    dtIgnore: npt.NDArray[np.bool_]
+
+
+@dataclass
+class MeanAveragePrecisionResult:
+    """
+    The result of the Mean Average Precision calculation.
+
+    Returns `-1` sentinel scores when no detections or targets are present.
+
+    Attributes:
+        metric_target: the type of data used for the metric -
+            boxes, masks or oriented bounding boxes.
+        is_class_agnostic: When computing class-agnostic results, class ID
+            is set to `-1`.
+        mAP_scores: the mAP scores at each IoU threshold.
+            Shape: `(num_iou_thresholds,)`
+        ap_per_class: the average precision scores per
+            class and IoU threshold. Shape: `(num_target_classes, num_iou_thresholds)`
+        iou_thresholds: the IoU thresholds used in the calculations.
+        matched_classes: the class IDs of all matched classes.
+            Corresponds to the rows of `ap_per_class`.
+        small_objects: the mAP results
+            for small objects (area < 32²).
+        medium_objects: the mAP results
+            for medium objects (32² ≤ area < 96²).
+        large_objects: the mAP results
+            for large objects (area ≥ 96²).
+    """
+
+    metric_target: MetricTarget
+    is_class_agnostic: bool
+
+    @property
+    def map50_95(self) -> float:
+        """the mAP score at IoU thresholds from `0.5` to `0.95`."""
+        valid_scores = self.mAP_scores[self.mAP_scores > -1]
+        if len(valid_scores) > 0:
+            return float(valid_scores.mean())
+        else:
+            return -1
+
+    @property
+    def map50(self) -> float:
+        """the mAP score at IoU threshold of `0.5`."""
+        return float(self.mAP_scores[0])
+
+    @property
+    def map75(self) -> float:
+        """the mAP score at IoU threshold of `0.75`."""
+        return float(self.mAP_scores[5])
+
+    mAP_scores: npt.NDArray[np.float64]
+    ap_per_class: npt.NDArray[np.float64]
+    iou_thresholds: npt.NDArray[np.float64]
+    matched_classes: npt.NDArray[np.int32]
+    small_objects: MeanAveragePrecisionResult | None = None
+    medium_objects: MeanAveragePrecisionResult | None = None
+    large_objects: MeanAveragePrecisionResult | None = None
+
+    def __str__(self) -> str:
+        """
+        Formats the evaluation output metrics to match the structure used by pycocotools
+
+        Example:
+           ```pycon
+           >>> import numpy as np
+           >>> import supervision as sv
+           >>> from supervision.metrics import MeanAveragePrecision
+           >>> predictions = sv.Detections(
+           ...     xyxy=np.array([[0, 0, 10, 10]]),
+           ...     class_id=np.array([0]),
+           ...     confidence=np.array([0.9])
+           ... )
+           >>> targets = sv.Detections(
+           ...     xyxy=np.array([[0, 0, 10, 10]]),
+           ...     class_id=np.array([0])
+           ... )
+           >>> map_metric = MeanAveragePrecision()
+           >>> map_result = map_metric.update(predictions, targets).compute()
+           >>> print(map_result)  # doctest: +ELLIPSIS
+           Average Precision (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = ...
+           Average Precision (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = ...
+           Average Precision (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = ...
+           Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = ...
+           Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = ...
+           Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = ...
+
+           ```
+        """
+        if (
+            self.small_objects is None
+            or self.medium_objects is None
+            or self.large_objects is None
+        ):
+            return (
+                f"Average Precision (AP) @[ IoU=0.50:0.95 | area=   all | "
+                f"maxDets=100 ] = {self.map50_95:.3f}\n"
+                f"Average Precision (AP) @[ IoU=0.50      | area=   all | "
+                f"maxDets=100 ] = {self.map50:.3f}\n"
+                f"Average Precision (AP) @[ IoU=0.75      | area=   all | "
+                f"maxDets=100 ] = {self.map75:.3f}"
+            )
+
+        return (
+            f"Average Precision (AP) @[ IoU=0.50:0.95 | area=   all | "
+            f"maxDets=100 ] = {self.map50_95:.3f}\n"
+            f"Average Precision (AP) @[ IoU=0.50      | area=   all | "
+            f"maxDets=100 ] = {self.map50:.3f}\n"
+            f"Average Precision (AP) @[ IoU=0.75      | area=   all | "
+            f"maxDets=100 ] = {self.map75:.3f}\n"
+            f"Average Precision (AP) @[ IoU=0.50:0.95 | area= small | "
+            f"maxDets=100 ] = {self.small_objects.map50_95:.3f}\n"
+            f"Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | "
+            f"maxDets=100 ] = {self.medium_objects.map50_95:.3f}\n"
+            f"Average Precision (AP) @[ IoU=0.50:0.95 | area= large | "
+            f"maxDets=100 ] = {self.large_objects.map50_95:.3f}"
+        )
+
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the result to a pandas DataFrame.
+
+        Returns:
+            The result as a DataFrame.
+        """
+        ensure_pandas_installed()
+        import pandas as pd
+
+        pandas_data: dict[str, object] = {
+            "mAP@50:95": self.map50_95,
+            "mAP@50": self.map50,
+            "mAP@75": self.map75,
+        }
+
+        if self.small_objects is not None:
+            small_objects_df = self.small_objects.to_pandas()
+            for key, value in small_objects_df.items():
+                pandas_data[f"small_objects_{key}"] = value
+        if self.medium_objects is not None:
+            medium_objects_df = self.medium_objects.to_pandas()
+            for key, value in medium_objects_df.items():
+                pandas_data[f"medium_objects_{key}"] = value
+        if self.large_objects is not None:
+            large_objects_df = self.large_objects.to_pandas()
+            for key, value in large_objects_df.items():
+                pandas_data[f"large_objects_{key}"] = value
+
+        # Average precisions are currently not included in the DataFrame.
+        return pd.DataFrame(
+            pandas_data,
+            index=[0],
+        )
+
+    def plot(self) -> None:
+        """
+        Plot the mAP results.
+
+        ![example_plot](
+            https://media.roboflow.com/supervision-docs/metrics/mAP_plot_example.png
+        ){ align=center width="800" }
+        """
+        from matplotlib import pyplot as plt
+
+        labels = ["mAP@50:95", "mAP@50", "mAP@75"]
+        values = [self.map50_95, self.map50, self.map75]
+        colors = [LEGACY_COLOR_PALETTE[0]] * 3
+
+        if self.small_objects is not None:
+            labels += ["Small: mAP@50:95", "Small: mAP@50", "Small: mAP@75"]
+            values += [
+                self.small_objects.map50_95,
+                self.small_objects.map50,
+                self.small_objects.map75,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[3]] * 3
+
+        if self.medium_objects is not None:
+            labels += ["Medium: mAP@50:95", "Medium: mAP@50", "Medium: mAP@75"]
+            values += [
+                self.medium_objects.map50_95,
+                self.medium_objects.map50,
+                self.medium_objects.map75,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[2]] * 3
+
+        if self.large_objects is not None:
+            labels += ["Large: mAP@50:95", "Large: mAP@50", "Large: mAP@75"]
+            values += [
+                self.large_objects.map50_95,
+                self.large_objects.map50,
+                self.large_objects.map75,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[4]] * 3
+
+        plt.rcParams["font.family"] = "monospace"
+
+        _, ax = plt.subplots(figsize=(10, 6))
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Value", fontweight="bold")
+        ax.set_title("Mean Average Precision", fontweight="bold")
+
+        x_positions = range(len(labels))
+        bars = ax.bar(x_positions, values, color=colors, align="center")
+
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right")
+
+        for bar in bars:
+            y_value = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                y_value + 0.02,
+                f"{y_value:.2f}",
+                ha="center",
+                va="bottom",
+            )
+
+        plt.rcParams["font.family"] = "sans-serif"
+
+        plt.tight_layout()
+        plt.show()
+
+
+class EvaluationDataset:
+    """
+    Class used representing a dataset in the right format needed by the
+    `COCOEvaluator` class.
+    """
+
+    def __init__(self, targets: _TypeCocoDataset | None = None) -> None:
+        """
+        Constructor of EvaluationDataset object used to evaluate models with
+        Mean Average Precision.
+
+        Args:
+            targets: The targets (ground truth) of the dataset in a the
+                COCO format.
+        """
+        # Initialize members
+        # Initialize members
+        self.dataset: _TypeCocoDataset = {}
+        self.anns: dict[int, _TypeCocoDict] = {}
+        self.cats: dict[int, _TypeCocoDict] = {}
+        self.imgs: dict[int, _TypeCocoDict] = {}
+        self.img_to_anns: dict[int, list[_TypeCocoDict]] = defaultdict(list)
+        self.cat_to_imgs: dict[int, list[int]] = defaultdict(list)
+
+        if targets is None:
+            return
+
+        # Load dataset
+        self.dataset = targets
+        self.create_class_members()
+
+    @classmethod
+    def empty(cls) -> EvaluationDataset:
+        return cls(targets=None)
+
+    def create_class_members(self) -> None:
+        """
+        Create index elements for the dataset.
+        """
+        anns: dict[int, _TypeCocoDict] = {}
+        cats: dict[int, _TypeCocoDict] = {}
+        imgs: dict[int, _TypeCocoDict] = {}
+        img_to_anns: dict[int, list[_TypeCocoDict]] = defaultdict(list)
+        cat_to_imgs: dict[int, list[int]] = defaultdict(list)
+        if "annotations" in self.dataset:
+            for ann in self.dataset["annotations"]:
+                img_to_anns[ann["image_id"]].append(ann)
+                anns[ann["id"]] = ann
+
+        if "images" in self.dataset:
+            for img in self.dataset["images"]:
+                imgs[img["id"]] = img
+
+        if "categories" in self.dataset:
+            for cat in self.dataset["categories"]:
+                cats[cat["id"]] = cat
+
+        if "annotations" in self.dataset and "categories" in self.dataset:
+            for ann in self.dataset["annotations"]:
+                cat_to_imgs[ann["category_id"]].append(ann["image_id"])
+
+        # Populate class members
+        self.anns = anns
+        self.img_to_anns = img_to_anns
+        self.cat_to_imgs = cat_to_imgs
+        self.imgs = imgs
+        self.cats = cats
+
+    def get_annotation_ids(
+        self,
+        img_ids: list[int] | None = None,
+        cat_ids: list[int] | None = None,
+        area_range: tuple[float, float] | None = None,
+        iscrowd: bool = False,
+    ) -> list[int]:
+        """
+        Get annotation ids that satisfy given filter conditions.
+
+        Args:
+            img_ids: ids of the images that we want to retrieve.
+            cat_ids: ids of the categories that we want to retrieve.
+            area_range: area range of the annotations that we want to retrieve
+                in the format [min_area, max_area].
+            iscrowd: if annotations to retrieve are `iscrowded=1`.
+        """
+        # If there are no filters, we use all annotations
+        if not img_ids and not cat_ids and not area_range:
+            anns = self.dataset["annotations"]
+        else:
+            if img_ids:
+                lists = [
+                    self.img_to_anns[img_id]
+                    for img_id in img_ids
+                    if img_id in self.img_to_anns
+                ]
+                anns = list(itertools.chain.from_iterable(lists))
+            else:
+                anns = self.dataset["annotations"]
+
+            # Filter by category
+            anns = (
+                anns
+                if not cat_ids
+                else [ann for ann in anns if ann["category_id"] in cat_ids]
+            )
+
+            # Filter by area
+            anns = (
+                anns
+                if not area_range
+                else [
+                    ann for ann in anns if area_range[0] < ann["area"] < area_range[1]
+                ]
+            )
+
+        # Filter by iscrowd
+        if iscrowd is True:
+            ids = [ann["id"] for ann in anns if ann["iscrowd"] == 1]
+        else:
+            ids = [ann["id"] for ann in anns]
+        return ids
+
+    def get_category_ids(
+        self,
+        cat_names: list[str] | None = None,
+        supercategory_names: list[str] | None = None,
+        cat_ids: list[int] | None = None,
+    ) -> list[int]:
+        """
+        Get category ids that satisfy given filter conditions.
+
+        Args:
+            cat_names: names of the categories to retrieve.
+            supercategory_names: names of the supercategories to retrieve.
+            cat_ids: ids of the categories to retrieve.
+
+        Returns:
+            ids: integer array of category ids.
+        """
+        # If there are no filters, we use all categories
+        if not cat_names and not supercategory_names and not cat_ids:
+            cats = self.dataset["categories"]
+        else:
+            cats = self.dataset["categories"]
+
+            # Filter by name
+            cats = (
+                cats
+                if not cat_names
+                else [cat for cat in cats if cat["name"] in cat_names]
+            )
+
+            # Filter by supercategory
+            cats = (
+                cats
+                if not supercategory_names
+                else [
+                    cat for cat in cats if cat["supercategory"] in supercategory_names
+                ]
+            )
+
+            # Filter by id
+            cats = (
+                cats if not cat_ids else [cat for cat in cats if cat["id"] in cat_ids]
+            )
+        ids = [cat["id"] for cat in cats]
+        return ids
+
+    def get_image_ids(
+        self,
+        img_ids: list[int] | None = None,
+        cat_ids: list[int] | None = None,
+    ) -> list[int]:
+        """
+        Get image ids that satisfy given filter conditions.
+
+        Args:
+            img_ids: ids of the images to retrieve.
+            cat_ids: ids of the categories to retrieve.
+
+        Returns:
+            ids: integer array of image ids.
+        """
+        # If there are no filters, we use all images
+        if not img_ids and not cat_ids:
+            ids = self.imgs.keys()
+            return list(ids)
+
+        ids_set = set(img_ids) if img_ids else set()
+
+        if cat_ids:
+            for i, cat_id in enumerate(cat_ids):
+                if i == 0 and not ids_set:
+                    ids_set = set(self.cat_to_imgs[cat_id])
+                else:
+                    ids_set &= set(self.cat_to_imgs[cat_id])
+
+        return list(ids_set)
+
+    def get_annotations(self, ids: list[int] | None = None) -> list[_TypeCocoDict]:
+        """
+        Get annotations with the specified ids.
+
+        Args:
+            ids: integer ids specifying annotations.
+
+        Returns:
+            anns: loaded annotations.
+        """
+        if ids is None:
+            return []
+        return [self.anns[idx] for idx in ids]
+
+    def load_predictions(self, predictions: list[_TypeCocoDict]) -> EvaluationDataset:
+        """
+        Load prediction result into an EvaluationDataset object.
+
+        Args:
+            predictions: prediction result.
+
+        Returns:
+            EvaluationDataset object representing the predictions.
+        """
+        # Create an empty EvaluationDataset object for the predictions
+        predictions_dataset = EvaluationDataset.empty()
+        predictions_dataset.dataset["images"] = list(self.dataset["images"])
+
+        if not isinstance(predictions, list):
+            raise ValueError("results must be a list")
+
+        # Handle empty predictions
+        if len(predictions) == 0:
+            predictions_dataset.dataset["annotations"] = []
+            return predictions_dataset
+
+        ids = [pred["image_id"] for pred in predictions]
+
+        # Make sure the image ids from predictions exist in the current dataset.
+        # A plain ``assert`` would be stripped under ``python -O``, so validate
+        # this public-input contract with an explicit exception instead.
+        if not set(ids) <= set(self.get_image_ids()):
+            raise ValueError("Results do not correspond to current coco set")
+
+        # Check if the predictions contain any unsupported keys
+        if "caption" in predictions[0]:
+            raise NotImplementedError(
+                "Evaluating predictions with caption is not supported."
+            )
+        elif "segmentation" in predictions[0]:
+            raise NotImplementedError(
+                "Evaluating predictions with segmentation is not supported."
+            )
+        elif "keypoints" in predictions[0]:
+            raise NotImplementedError(
+                "Evaluating predictions with keypoints is not supported."
+            )
+
+        elif "bbox" in predictions[0] and not predictions[0]["bbox"] == []:
+            predictions_dataset.dataset["categories"] = copy.deepcopy(
+                self.dataset["categories"]
+            )
+
+            # Prepare fields for every prediction of the given image
+            for idx, pred in enumerate(predictions):
+                x, y, w, h = pred["bbox"]
+                x1, x2, y1, y2 = [x, x + w, y, y + h]
+
+                # Make segmentation from bounding box coordinates
+                if "segmentation" not in pred:
+                    pred["segmentation"] = [[x1, y1, x1, y2, x2, y2, x2, y1]]
+                # Use provided area if available
+                if "area" not in pred:
+                    pred["area"] = w * h
+                pred["id"] = idx + 1
+                # For predictions we set iscrowd to 0
+                pred["iscrowd"] = 0
+        predictions_dataset.dataset["annotations"] = predictions
+        predictions_dataset.create_class_members()
+        return predictions_dataset
+
+
+# Area ranges for object size in pixels
+SMALL_OBJECT_AREA = 32**2
+MEDIUM_OBJECT_AREA = 96**2
+MAX_ALL_OBJECT_AREA = 1e5**2
+
+# Smallest number to avoid division by zero
+EPS = np.finfo(np.float32).eps
+
+
+def _mask_iou_with_jaccard(
+    masks_true: list[npt.NDArray[np.bool_]],
+    masks_detection: list[npt.NDArray[np.bool_]],
+    is_crowd: list[bool],
+) -> npt.NDArray[np.float64]:
+    """
+    Calculate the IoU between detection masks (dt) and ground-truth masks (gt),
+    following the COCO convention: a detection may match any subregion of a
+    crowd ground truth, so for crowd rows the union collapses to the detection
+    area (mask counterpart of `box_iou_batch_with_jaccard`).
+
+    Args:
+        masks_true: List of ground-truth masks of shape `(H, W)`.
+        masks_detection: List of detection masks of shape `(H, W)`.
+        is_crowd: List indicating if each ground-truth mask is a crowd region.
+
+    Returns:
+        Array of IoU values of shape `(len(masks_detection), len(masks_true))`.
+    """
+    if len(masks_detection) == 0 or len(masks_true) == 0:
+        return np.empty((len(masks_detection), len(masks_true)), dtype=np.float64)
+
+    gt_masks = np.stack(masks_true).astype(bool)
+    dt_masks = np.stack(masks_detection).astype(bool)
+    crowd = np.asarray(is_crowd, dtype=bool)
+
+    # Compute base IoU via the optimised path (float32 + memory-chunked).
+    # mask_iou_batch returns (gt, dt); the evaluator expects (dt, gt).
+    iou: npt.NDArray[np.float64] = mask_iou_batch(gt_masks, dt_masks).T.astype(
+        np.float64
+    )
+
+    if not np.any(crowd):
+        return iou
+
+    # Override crowd columns: COCO convention collapses the union to the
+    # detection area, so a small detection inside a large crowd region scores
+    # IoU ≈ 1.  Recompute only the crowd columns to avoid a full float64 matmul.
+    eps = np.spacing(1)
+    crowd_idx = np.where(crowd)[0]
+    gt_flat = gt_masks[crowd_idx].reshape(len(crowd_idx), -1).astype(np.float32)
+    dt_flat = dt_masks.reshape(dt_masks.shape[0], -1).astype(np.float32)
+    area_inter = (dt_flat @ gt_flat.T).astype(np.float64)  # (dt, N_crowd)
+    area_dt = dt_flat.sum(axis=1).astype(np.float64)  # (dt,)
+    iou[:, crowd_idx] = area_inter / (area_dt[:, None] + eps)
+    return iou
+
+
+class ObjectSize(Enum):
+    """
+    Enum for object size.
+    """
+
+    ALL = "all"
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+
+
+class COCOEvaluatorParameters:
+    """
+    Parameters for COCOEvaluator
+    """
+
+    def __init__(self) -> None:
+        """Initialize all parameters for evaluation"""
+
+        self.img_ids: list[int] = []
+        self.cat_ids: list[int] = []
+
+        # IoU thresholds [0.5, 0.55, 0.6, 0.65, ..., 0.95]
+        self.iou_thrs = np.linspace(
+            0.5,
+            0.95,
+            int(np.round((0.95 - 0.5) / 0.05)) + 1,
+            endpoint=True,
+            dtype=np.float32,
+        )
+        # 101 recall thresholds [0.0, 0.01, 0.02, ..., 1.00]
+        self.rec_thrs = np.linspace(
+            0.0,
+            1.00,
+            int(np.round((1.00 - 0.0) / 0.01)) + 1,
+            endpoint=True,
+            dtype=np.float32,
+        )
+        # 3 maximum detection thresholds [1, 10, 100]
+        self.max_dets = [1, 10, 100]
+        # Area ranges [0, 1e5], [0, 32], [32, 96], [96, 1e5]
+        self.area_range: list[list[float]] = [
+            [0, MAX_ALL_OBJECT_AREA],
+            [0, SMALL_OBJECT_AREA],
+            [SMALL_OBJECT_AREA, MEDIUM_OBJECT_AREA],
+            [MEDIUM_OBJECT_AREA, MAX_ALL_OBJECT_AREA],
+        ]
+
+
+class COCOEvaluator:
+    """
+    Evaluator class to compute COCO metrics.
+    """
+
+    def __init__(
+        self,
+        coco_targets: EvaluationDataset,
+        coco_predictions: EvaluationDataset,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+    ) -> None:
+        """
+        Constructor of COCOEvaluator object.
+
+        Args:
+            coco_targets: The dataset with the ground truths.
+            coco_predictions: The dataset with the predictions.
+            metric_target: The type of detection data used to compute the IoU -
+                boxes, masks or oriented bounding boxes.
+        """
+        if coco_targets is None:
+            raise ValueError("coco_targets must be provided")
+        if coco_predictions is None:
+            raise ValueError("coco_predictions must be provided")
+
+        self.coco_targets = coco_targets
+        self.coco_predictions = coco_predictions
+        self.metric_target = metric_target
+        # List of dictionaries containing the evaluation results
+        # len(eval_imgs) = (categories) * (area_ranges) * (images)
+        # For COCO 2017: len(eval_images) = 80 * 4 * 5000 = 1600000
+        self.eval_imgs: list[_TypeEvaluationImageResult | None] = []
+        # Dictionary of accumulated results
+        self.results: dict[str, object] = {}
+        # Dictionary of targets for evaluation
+        self._targets: defaultdict[tuple[int, int], list[_TypeCocoDict]] = defaultdict(
+            list
+        )
+        self._predictions: defaultdict[tuple[int, int], list[_TypeCocoDict]] = (
+            defaultdict(list)
+        )
+        # Parameters for evaluation
+        self.params = COCOEvaluatorParameters()
+        # List of results summarization
+        self.stats: list[object] = []
+        # Dictionary of IOUs between all targets and predictions
+        self.ious: dict[tuple[int, int], npt.NDArray[np.float32]] = {}
+        # Set image and category ids
+        self.params.img_ids = sorted(self.coco_targets.get_image_ids())
+        self.params.cat_ids = sorted(self.coco_targets.get_category_ids())
+
+    def _prepare_targets_and_predictions(self) -> None:
+        """
+        Prepare targets and predictions for evaluation.
+        """
+        # Get the target samples for the evaluation
+        annotation_ids = self.coco_targets.get_annotation_ids(
+            img_ids=self.params.img_ids, cat_ids=self.params.cat_ids
+        )
+        targets = self.coco_targets.get_annotations(annotation_ids)
+        # Get the prediction samples for the evaluation
+        prediction_ids = self.coco_predictions.get_annotation_ids(
+            img_ids=self.params.img_ids, cat_ids=self.params.cat_ids
+        )
+        predictions = self.coco_predictions.get_annotations(prediction_ids)
+
+        # Set ignore flag
+        for gt in targets:
+            ignore = int(gt.get("ignore", 0))
+            iscrowd = int(gt.get("iscrowd", 0))
+            gt["ignore"] = int(bool(ignore or iscrowd))
+
+        # Select targets
+        self._targets = defaultdict(list)
+        for gt in targets:
+            self._targets[gt["image_id"], gt["category_id"]].append(gt)
+
+        # Select predictions
+        self._predictions = defaultdict(list)
+        for dt in predictions:
+            self._predictions[dt["image_id"], dt["category_id"]].append(dt)
+
+        # Initialize evaluation results
+        self.eval_imgs = []
+        self.results = {}
+
+    def _compute_iou(self, img_id: int, cat_id: int) -> npt.NDArray[np.float32]:
+        """
+        Compute the IoU between the targets and predictions for a given image and
+        category, using boxes, masks or oriented bounding boxes depending on the
+        configured metric target.
+
+        Args:
+            img_id: The image id.
+            cat_id: The category id.
+
+        Returns:
+            The IoU between the targets and predictions.
+        """
+
+        gt = self._targets[img_id, cat_id]
+        dt = self._predictions[img_id, cat_id]
+
+        # If there is nothing to evaluate
+        if len(gt) == 0 and len(dt) == 0:
+            empty_result: npt.NDArray[np.float32] = np.array([], dtype=np.float32)
+            return empty_result
+
+        # Sort predictions by highest score first
+        inds = np.argsort([-d["score"] for d in dt], kind="stable")
+        dt = [dt[i] for i in inds]
+
+        # Truncate the predictions if there are more predictions than the max detections
+        # to evaluate
+        if len(dt) > self.params.max_dets[-1]:
+            dt = dt[0 : self.params.max_dets[-1]]
+
+        # Get the iscrowd flag for each gt
+        is_crowd = [bool(o["iscrowd"]) for o in gt]
+
+        # Compute iou between each prediction and gt region
+        if self.metric_target == MetricTarget.MASKS:
+            iou = _mask_iou_with_jaccard(
+                [g["content"] for g in gt], [d["content"] for d in dt], is_crowd
+            )
+        elif self.metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            # Crowd regions are not supported for oriented boxes; the standard
+            # IoU is used for every ground truth.
+            if len(gt) == 0 or len(dt) == 0:
+                iou = np.empty((len(dt), len(gt)), dtype=np.float64)
+            else:
+                gt_obb = np.stack([g["content"] for g in gt])
+                dt_obb = np.stack([d["content"] for d in dt])
+                # oriented_box_iou_batch returns (gt, dt);
+                # the evaluator expects (dt, gt).
+                iou = oriented_box_iou_batch(gt_obb, dt_obb).T.astype(np.float64)
+        else:
+            gt_boxes = [g["bbox"] for g in gt]
+            dt_boxes = [d["bbox"] for d in dt]
+            iou = box_iou_batch_with_jaccard(gt_boxes, dt_boxes, is_crowd)
+        return iou.astype(np.float32)
+
+    def _evaluate_image(
+        self,
+        img_id: int,
+        cat_id: int,
+        area_range: list[float] | tuple[float, float],
+        max_det: int,
+    ) -> _TypeEvaluationImageResult | None:
+        """
+        Perform evaluation for single category and image.
+        Args:
+            img_id: The image id.
+            cat_id: The category id.
+            area_range: The area range.
+            max_det: The maximum number of detections.
+
+        Returns:
+            The evaluation results.
+        """
+        # Get targets (gt) and predictions (dt) for the given image and category
+        gt: list[_TypeCocoDict] = self._targets[img_id, cat_id]
+        dt: list[_TypeCocoDict] = self._predictions[img_id, cat_id]
+
+        # If there is nothing to evaluate
+        if len(gt) == 0 and len(dt) == 0:
+            return None
+
+        min_area, max_area = area_range
+
+        # Create an `_ignore` flag for targets if they are set as ignore or their area
+        # is not in the range [min_area, max_area]
+        for g in gt:
+            if g["ignore"] or not (min_area <= g["area"] <= max_area):
+                g["_ignore"] = 1
+            else:
+                g["_ignore"] = 0
+
+        # Sort ground-truths by ignore flag (0: non ignored, 1: ignored)
+        gt_sorted = np.argsort([g["_ignore"] for g in gt], kind="stable")
+        gt = [gt[i] for i in gt_sorted]
+
+        # Sort predictions by scores in descending order
+        dt_sorted = np.argsort([-d["score"] for d in dt], kind="stable")
+        dt = [dt[i] for i in dt_sorted[0:max_det]]
+
+        # Load computed ious for the given image and category
+        ious = (
+            self.ious[img_id, cat_id][:, gt_sorted]
+            if len(self.ious[img_id, cat_id]) > 0
+            else self.ious[img_id, cat_id]
+        )
+
+        # Get the number of thresholds, ground truths and detections
+        num_thresholds = len(self.params.iou_thrs)
+        num_ground_truths = len(gt)
+        num_detections = len(dt)
+
+        # Initialize matches: 0 means no match
+        gt_matches = np.zeros((num_thresholds, num_ground_truths), dtype=np.int64)
+        dt_matches = np.zeros((num_thresholds, num_detections), dtype=np.int64)
+        # Initialize ignore flags: 0 means no ignore
+        gt_ignore = np.array([g["_ignore"] for g in gt], dtype=np.int64)
+        dt_ignore = np.zeros((num_thresholds, num_detections), dtype=np.bool_)
+        if len(ious) != 0:
+            # Go through the iou thresholds
+            for tresh_idx, thresh in enumerate(self.params.iou_thrs):
+                # Go through the detections
+                for det_idx, det in enumerate(dt):
+                    # Start the iou of the best match
+                    iou_best_match = min([thresh, 1 - 1e-10])
+                    # Set the best match index to -1 (unmatched)
+                    best_match_idx = -1
+                    # Go through the ground truths
+                    for g_idx, g in enumerate(gt):
+                        # If current gt is already matched, and not a crowd, continue
+                        # if gt_matches[tresh_idx, g_idx] > 0 and not iscrowd[g_idx]:
+                        iscrowd = int(g.get("iscrowd", 0))
+                        if gt_matches[tresh_idx, g_idx] > 0 and not iscrowd:
+                            continue
+                        # Stop searching the ground truths
+                        if (
+                            best_match_idx > -1  # detection is matched to a gt
+                            and gt_ignore[best_match_idx]
+                            == 0  # matched gt is not ignored
+                            and gt_ignore[g_idx] == 1  # current gt is ignored
+                        ):
+                            break
+
+                        # A new best match was found
+                        if ious[det_idx, g_idx] >= iou_best_match:
+                            iou_best_match = ious[det_idx, g_idx]
+                            best_match_idx = g_idx
+
+                    # A best match was found
+                    if best_match_idx != -1:
+                        dt_ignore[tresh_idx, det_idx] = gt_ignore[best_match_idx]
+                        dt_matches[tresh_idx, det_idx] = gt[best_match_idx]["id"]
+                        gt_matches[tresh_idx, best_match_idx] = det["id"]
+
+        # Set unmatched detections outside of area range to ignore
+        area_range_mask = np.array(
+            [d["area"] < min_area or d["area"] > max_area for d in dt]
+        ).reshape((1, len(dt)))
+
+        # Update the ignore flags for detections
+        dt_ignore = np.logical_or(
+            dt_ignore,
+            np.logical_and(
+                dt_matches == 0, np.repeat(area_range_mask, num_thresholds, 0)
+            ),
+        )
+
+        return {
+            "image_id": img_id,
+            "category_id": cat_id,
+            "area_range": area_range,
+            "max_det": max_det,
+            "dt_ids": [d["id"] for d in dt],
+            "gt_ids": [g["id"] for g in gt],
+            "dtMatches": dt_matches,
+            "gtMatches": gt_matches,
+            "dtScores": [d["score"] for d in dt],
+            "gtIgnore": gt_ignore,
+            "dtIgnore": dt_ignore,
+        }
+
+    def _accumulate(self) -> None:
+        """
+        Accumulate per image evaluation results and store the result in self.results
+        """
+        # Get the number of thresholds, categories, area ranges, and max detections
+        num_iou_thresholds = len(self.params.iou_thrs)
+        num_recall_thresholds = len(self.params.rec_thrs)
+        num_categories = len(self.params.cat_ids)
+        num_area_ranges = len(self.params.area_range)
+        num_max_detections = len(self.params.max_dets)
+        num_imgs = len(self.params.img_ids)
+
+        # Initialize precision, recall, and scores arrays
+        # -1 means absent categories
+        precision = -np.ones(
+            (
+                num_iou_thresholds,
+                num_recall_thresholds,
+                num_categories,
+                num_area_ranges,
+                num_max_detections,
+            ),
+            dtype=np.float32,
+        )
+        recall = -np.ones(
+            (num_iou_thresholds, num_categories, num_area_ranges, num_max_detections),
+            dtype=np.float32,
+        )
+        scores = -np.ones(
+            (
+                num_iou_thresholds,
+                num_recall_thresholds,
+                num_categories,
+                num_area_ranges,
+                num_max_detections,
+            ),
+            dtype=np.float32,
+        )
+
+        # Create sets for indexing
+        set_categories = set(self.params.cat_ids)
+        set_area_ranges: set[tuple[float, ...]] = {
+            tuple(a) for a in self.params.area_range
+        }
+        set_max_detections = set(self.params.max_dets)
+        set_image_ids = set(self.params.img_ids)
+
+        # Select category indexes to evaluate
+        selected_category_ids = [
+            n for n, k in enumerate(self.params.cat_ids) if k in set_categories
+        ]
+        # Select max detections to evaluate
+        selected_max_detections = [
+            m for m in self.params.max_dets if m in set_max_detections
+        ]
+        # Select area ranges to evaluate
+        selected_area_ranges_ids = [
+            idx
+            for idx, area in enumerate(self.params.area_range)
+            if tuple(area) in set_area_ranges
+        ]
+        # Select image indexes to evaluate
+        image_inds = [
+            n for n, i in enumerate(self.params.img_ids) if i in set_image_ids
+        ]
+
+        # Evaluating at all categories, area ranges, max number of detections, and
+        # IoU thresholds
+
+        # Loop through categories
+        for cat_idx, cat_eval_idx in enumerate(selected_category_ids):
+            cat_offset = cat_eval_idx * num_area_ranges * num_imgs
+
+            # Loop through area ranges
+            for area_idx, area_eval_idx in enumerate(selected_area_ranges_ids):
+                area_offset = area_eval_idx * num_imgs
+
+                # Loop through max detections
+                for max_det_idx, max_det in enumerate(selected_max_detections):
+                    eval_img_data_raw = [
+                        self.eval_imgs[cat_offset + area_offset + i] for i in image_inds
+                    ]
+                    eval_img_data: list[_TypeEvaluationImageResult] = [
+                        e for e in eval_img_data_raw if e is not None
+                    ]
+
+                    # No image to evaluate
+                    if len(eval_img_data) == 0:
+                        continue
+
+                    # Sort detected scores in descending order
+                    dt_scores = np.concatenate(
+                        [e["dtScores"][0:max_det] for e in eval_img_data]
+                    )
+                    inds = np.argsort(-dt_scores, kind="stable")
+                    dt_scores_sorted = dt_scores[inds]
+
+                    # Get matches and ignored matches
+                    dt_matches = np.concatenate(
+                        [e["dtMatches"][:, 0:max_det] for e in eval_img_data], axis=1
+                    )[:, inds]
+                    dt_ignored = np.concatenate(
+                        [e["dtIgnore"][:, 0:max_det] for e in eval_img_data], axis=1
+                    )[:, inds]
+
+                    # Get ignored ground truth objects
+                    gt_ignored = np.concatenate([e["gtIgnore"] for e in eval_img_data])
+                    num_non_ignored_gt = np.count_nonzero(gt_ignored == 0)
+
+                    # No ground truth objects to evaluate
+                    if num_non_ignored_gt == 0:
+                        continue
+
+                    # Compute true positives and false positives
+                    true_positives = np.logical_and(
+                        dt_matches, np.logical_not(dt_ignored)
+                    )
+                    false_positives = np.logical_and(
+                        np.logical_not(dt_matches), np.logical_not(dt_ignored)
+                    )
+
+                    tp_sum = np.cumsum(true_positives, axis=1).astype(dtype=np.float32)
+                    fp_sum = np.cumsum(false_positives, axis=1).astype(dtype=np.float32)
+
+                    # Loop through thresholds
+                    for iou_thresh_idx, (tp, fp) in enumerate(zip(tp_sum, fp_sum)):
+                        tp = np.array(tp)
+                        fp = np.array(fp)
+                        num_tps = len(tp)
+                        # Recall: TP / Total number of ground truth objects
+                        rc = tp / np.float32(num_non_ignored_gt)
+                        # Precision: TP / (FP + TP)
+                        pr = (tp / (fp + tp + EPS)).tolist()
+                        # List to compute the precision at each recall threshold
+                        precision_at_recall = [0.0] * num_recall_thresholds
+                        # List to compute the score at each recall threshold
+                        score_at_recall = [0.0] * num_recall_thresholds
+
+                        # Set recall to either the final recall value or 0 (when there
+                        # is no TP)
+                        recall[iou_thresh_idx, cat_idx, area_idx, max_det_idx] = (
+                            rc[-1] if num_tps else 0
+                        )
+
+                        # Loop through precision values
+                        for i in range(num_tps - 1, 0, -1):
+                            if pr[i] > pr[i - 1]:
+                                pr[i - 1] = pr[i]
+
+                        recall_inds: npt.NDArray[np.int_] = np.searchsorted(
+                            rc, self.params.rec_thrs, side="left"
+                        )
+                        recall_inds_list: list[int] = recall_inds.tolist()
+                        for ri, pos_idx_value in enumerate(recall_inds_list):
+                            # Ensure pi is within the range of both arrays
+                            pos_idx_int: int = int(pos_idx_value)
+                            if 0 <= pos_idx_int < len(pr) and 0 <= pos_idx_int < len(
+                                dt_scores_sorted
+                            ):
+                                precision_at_recall[ri] = pr[pos_idx_int]
+                                score_at_recall[ri] = dt_scores_sorted[pos_idx_int]
+
+                        # Convert precision to numpy array
+                        precision[iou_thresh_idx, :, cat_idx, area_idx, max_det_idx] = (
+                            np.array(precision_at_recall, dtype=np.float32)
+                        )
+                        # Convert scores to numpy array
+                        scores[iou_thresh_idx, :, cat_idx, area_idx, max_det_idx] = (
+                            np.array(score_at_recall, dtype=np.float32)
+                        )
+
+        self.results = {
+            "params": self.params,
+            "counts": [
+                num_iou_thresholds,
+                num_recall_thresholds,
+                num_categories,
+                num_area_ranges,
+                num_max_detections,
+            ],
+            "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "precision": precision,
+            "recall": recall,
+            "scores": scores,
+        }
+
+        # Helper function to compute average precision while handling -1 sentinel values
+        def compute_average_precision(
+            precision_slice: npt.NDArray[np.float32],
+        ) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+            """Compute average precision while handling -1 sentinel values."""
+            valid_mask = precision_slice != -1
+            valid_precision = np.where(valid_mask, precision_slice, np.float32(0.0))
+
+            def mean_with_mask(
+                axis: int | tuple[int, ...],
+            ) -> npt.NDArray[np.float64]:
+                sums = valid_precision.sum(axis=axis, dtype=np.float64)
+                counts = valid_mask.sum(axis=axis)
+                means: npt.NDArray[np.float64] = np.divide(
+                    sums,
+                    counts,
+                    out=np.full(sums.shape, -1.0, dtype=np.float64),
+                    where=counts > 0,
+                )
+                return means
+
+            mAP_scores = mean_with_mask((1, 2))
+            ap_per_class = mean_with_mask(1).transpose(1, 0)
+            return mAP_scores, ap_per_class
+
+        # Average precision over all sizes, 100 max detections
+        area_range_idx = list(ObjectSize).index(ObjectSize.ALL)
+        max_100_dets_idx = self.params.max_dets.index(100)
+        # Average precision  [threshold, recall, classes]
+        average_precision_all_sizes = precision[
+            :, :, :, area_range_idx, max_100_dets_idx
+        ]
+        # mAP over thresholds (dimension=num_thresholds)
+        # Exclude -1 sentinel values when computing mean
+        mAP_scores_all_sizes, ap_per_class_all_sizes = compute_average_precision(
+            average_precision_all_sizes
+        )
+
+        # Average precision for SMALL objects and 100 max detections
+        small_area_range_idx = list(ObjectSize).index(ObjectSize.SMALL)
+        average_precision_small = precision[
+            :, :, :, small_area_range_idx, max_100_dets_idx
+        ]
+        mAP_scores_small, ap_per_class_small = compute_average_precision(
+            average_precision_small
+        )
+
+        # Average precision for MEDIUM objects and 100 max detections
+        medium_area_range_idx = list(ObjectSize).index(ObjectSize.MEDIUM)
+        average_precision_medium = precision[
+            :, :, :, medium_area_range_idx, max_100_dets_idx
+        ]
+        mAP_scores_medium, ap_per_class_medium = compute_average_precision(
+            average_precision_medium
+        )
+
+        # Average precision for LARGE objects and 100 max detections
+        large_area_range_idx = list(ObjectSize).index(ObjectSize.LARGE)
+        average_precision_large = precision[
+            :, :, :, large_area_range_idx, max_100_dets_idx
+        ]
+        mAP_scores_large, ap_per_class_large = compute_average_precision(
+            average_precision_large
+        )
+
+        self.results = {
+            "params": self.params,
+            "counts": [
+                num_iou_thresholds,
+                num_recall_thresholds,
+                num_categories,
+                num_area_ranges,
+                num_max_detections,
+            ],
+            "date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "precision": precision,
+            "recall": recall,
+            "scores": scores,
+            "mAP_scores_all_sizes": mAP_scores_all_sizes,
+            "ap_per_class_all_sizes": ap_per_class_all_sizes,
+            "mAP_scores_small": mAP_scores_small,
+            "ap_per_class_small": ap_per_class_small,
+            "mAP_scores_medium": mAP_scores_medium,
+            "ap_per_class_medium": ap_per_class_medium,
+            "mAP_scores_large": mAP_scores_large,
+            "ap_per_class_large": ap_per_class_large,
+        }
+
+    def _pycocotools_summarize(self) -> None:
+        """
+        Compute and display summary metrics for evaluation results.
+        """
+
+        def _summarize(
+            use_ap: bool = True,
+            iou_thr: float | None = None,
+            area_range: ObjectSize = ObjectSize.ALL,
+            max_dets: int = 100,
+        ) -> float:
+            iStr = " {:<18} {} @[ IoU={:<9} | area={:>6s} | maxDets={:>3d} ] = {:0.10f}"
+            titleStr = "Average Precision" if use_ap else "Average Recall"
+            typeStr = "(AP)" if use_ap else "(AR)"
+            iou_str = (
+                f"{self.params.iou_thrs[0]:0.2f}:{self.params.iou_thrs[-1]:0.2f}"
+                if iou_thr is None
+                else f"{iou_thr:0.2f}"
+            )
+            all_object_sizes = list(ObjectSize)
+            area_range_idx = all_object_sizes.index(area_range)
+            max_detections_idx = self.params.max_dets.index(max_dets)
+            if use_ap:
+                # Dimension of precision:
+                # threshold x recall x classes x areas x max detections
+                s: npt.NDArray[np.float32] = np.asarray(
+                    self.results["precision"], dtype=np.float32
+                )
+                # IOU
+                if iou_thr is not None:
+                    t = np.where(iou_thr == self.params.iou_thrs)[0]
+                    s = s[t]
+                s = s[:, :, :, area_range_idx, max_detections_idx]
+            else:
+                # Dimension of recall:
+                # threshold x classes x areas x max detections
+                s = np.asarray(self.results["recall"], dtype=np.float32)
+                if iou_thr is not None:
+                    t = np.where(iou_thr == self.params.iou_thrs)[0]
+                    s = s[t]
+                s = s[:, :, area_range_idx, max_detections_idx]
+            if len(s[s > -1]) == 0:
+                mean_s = -1.0
+            else:
+                mean_s = float(np.mean(s[s > -1]))
+            logger.info(
+                iStr.format(titleStr, typeStr, iou_str, area_range, max_dets, mean_s)
+            )
+            return mean_s
+
+        def _summarize_predictions() -> npt.NDArray[np.float32]:
+            stats: npt.NDArray[np.float32] = np.zeros((12,), dtype=np.float32)
+            stats[0] = _summarize(use_ap=True)
+            stats[1] = _summarize(
+                use_ap=True, iou_thr=0.5, max_dets=self.params.max_dets[2]
+            )
+            stats[2] = _summarize(
+                use_ap=True, iou_thr=0.75, max_dets=self.params.max_dets[2]
+            )
+            stats[3] = _summarize(
+                use_ap=True,
+                area_range=ObjectSize.SMALL,
+                max_dets=self.params.max_dets[2],
+            )
+            stats[4] = _summarize(
+                use_ap=True,
+                area_range=ObjectSize.MEDIUM,
+                max_dets=self.params.max_dets[2],
+            )
+            stats[5] = _summarize(
+                use_ap=True,
+                area_range=ObjectSize.LARGE,
+                max_dets=self.params.max_dets[2],
+            )
+            stats[6] = _summarize(use_ap=False, max_dets=self.params.max_dets[0])
+            stats[7] = _summarize(use_ap=False, max_dets=self.params.max_dets[1])
+            stats[8] = _summarize(use_ap=False, max_dets=self.params.max_dets[2])
+            stats[9] = _summarize(
+                use_ap=False,
+                area_range=ObjectSize.SMALL,
+                max_dets=self.params.max_dets[2],
+            )
+            stats[10] = _summarize(
+                use_ap=False,
+                area_range=ObjectSize.MEDIUM,
+                max_dets=self.params.max_dets[2],
+            )
+            stats[11] = _summarize(
+                use_ap=False,
+                area_range=ObjectSize.LARGE,
+                max_dets=self.params.max_dets[2],
+            )
+            return stats
+
+        if len(self.results) != 0:
+            self.stats = _summarize_predictions().tolist()
+
+    def evaluate(self) -> None:
+        """
+        Start the per image evaluation on all images and keeep results in
+        self.eval_imgs (a list of dictionaries).
+        """
+        # Select all parameters to evaluate
+        self.params.img_ids = list(np.unique(self.params.img_ids))
+        self.params.cat_ids = list(np.unique(self.params.cat_ids))
+        self.params.max_dets = sorted(self.params.max_dets)
+
+        self._prepare_targets_and_predictions()
+
+        # Compute IOUs between all targets and predictions for all images and categories
+        self.ious = {
+            (img_id, cat_id): self._compute_iou(img_id, cat_id)
+            for img_id in self.params.img_ids
+            for cat_id in self.params.cat_ids
+        }
+
+        # Select the largest max area (the last element containing 100 dets
+        max_det = self.params.max_dets[-1]
+
+        # Evaluate each image with all categories, area range and max detections
+        self.eval_imgs = [
+            self._evaluate_image(img_id, cat_id, area_range, max_det)
+            for cat_id in self.params.cat_ids
+            for area_range in self.params.area_range
+            for img_id in self.params.img_ids
+        ]
+
+        # Accumulate results
+        self._accumulate()
+
+
+class MeanAveragePrecision(Metric[MeanAveragePrecisionResult]):
+    """
+    Mean Average Precision (mAP) is a metric used to evaluate object detection models.
+    It is the average of the precision-recall curves at different IoU thresholds.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics import MeanAveragePrecision
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> map_metric = MeanAveragePrecision()
+        >>> map_result = map_metric.update(predictions, targets).compute()
+        >>> round(float(map_result.map50), 2)
+        1.0
+        >>> print(map_result)
+        Average Precision (AP) @[ IoU=0.50:0.95 | area=   all | maxDets=100 ] = 1.000
+        Average Precision (AP) @[ IoU=0.50      | area=   all | maxDets=100 ] = 1.000
+        Average Precision (AP) @[ IoU=0.75      | area=   all | maxDets=100 ] = 1.000
+        Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 1.000
+        Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.000
+        Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.000
+
+        ```
+
+    ![example_plot](
+        https://media.roboflow.com/supervision-docs/metrics/mAP_plot_example.png
+    ){ align=center width="800" }
+    """
+
+    def __init__(
+        self,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+        class_agnostic: bool = False,
+        class_mapping: dict[int, int] | None = None,
+        image_indices: list[int] | None = None,
+    ) -> None:
+        """
+        Initialize the Mean Average Precision metric.
+
+        Args:
+            metric_target: The type of detection data to use.
+            class_agnostic: Whether to treat all data as a single class.
+            class_mapping: A dictionary to map class IDs to new IDs.
+            image_indices: The indices of the images to use.
+        """
+        self._metric_target = metric_target
+        self._class_agnostic = class_agnostic
+
+        self._predictions_list: list[Detections] = []
+        self._targets_list: list[Detections] = []
+        self._class_mapping = class_mapping
+        self._image_indices = image_indices
+
+    def reset(self) -> None:
+        """
+        Reset the metric to its initial state, clearing all stored data.
+        """
+        self._predictions_list = []
+        self._targets_list = []
+
+    def update(
+        self,
+        predictions: Detections | list[Detections],
+        targets: Detections | list[Detections],
+    ) -> MeanAveragePrecision:
+        """
+        Add new predictions and targets to the metric, but do not compute the result.
+
+        Args:
+            predictions: The predicted detections.
+            targets: The ground-truth detections.
+
+        Returns:
+            The updated metric instance.
+        """
+        if not isinstance(predictions, list):
+            predictions = [predictions]
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        if len(predictions) != len(targets):
+            raise ValueError(
+                f"The number of predictions ({len(predictions)}) and"
+                f" targets ({len(targets)}) during the update must be the same."
+            )
+
+        if self._class_agnostic:
+            predictions = deepcopy(predictions)
+            targets = deepcopy(targets)
+
+            for prediction in predictions:
+                if prediction.class_id is not None:
+                    prediction.class_id[:] = -1
+            for target in targets:
+                if target.class_id is not None:
+                    target.class_id[:] = -1
+
+        self._predictions_list.extend(predictions)
+        self._targets_list.extend(targets)
+
+        return self
+
+    def _detections_content(self, detections: Detections) -> npt.NDArray[Any] | None:
+        """Return per-detection masks or oriented boxes for the metric target,
+        or `None` for the box target and for empty detections."""
+        if self._metric_target == MetricTarget.BOXES or len(detections) == 0:
+            return None
+        if self._metric_target == MetricTarget.MASKS:
+            if detections.mask is None:
+                raise ValueError(
+                    "MeanAveragePrecision with `MetricTarget.MASKS` requires"
+                    " masks on both predictions and targets."
+                )
+            return np.asarray(detections.mask).astype(bool)
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+            if obb is None:
+                raise ValueError(
+                    "MeanAveragePrecision with"
+                    " `MetricTarget.ORIENTED_BOUNDING_BOXES` requires"
+                    f" `{ORIENTED_BOX_COORDINATES}` in `data` on both"
+                    " predictions and targets."
+                )
+            return np.asarray(obb, dtype=np.float32).reshape(-1, 4, 2)
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _content_area(
+        self, xywh: list[float], content: npt.NDArray[Any] | None, idx: int
+    ) -> float:
+        """Compute the default annotation area for the metric target: bbox area
+        for boxes, pixel count for masks, polygon area for oriented boxes."""
+        if content is None:
+            return float(xywh[2] * xywh[3])
+        if self._metric_target == MetricTarget.MASKS:
+            return float(np.count_nonzero(content[idx]))
+        x, y = content[idx, :, 0], content[idx, :, 1]
+        # Shoelace formula
+        return float(0.5 * abs(np.sum(x * np.roll(y, -1) - np.roll(x, -1) * y)))
+
+    def _prepare_targets(
+        self, targets: list[Detections]
+    ) -> dict[str, list[_TypeCocoDict]]:
+        """Transform targets into a dictionary that can be used by the COCO evaluator"""
+        images: list[_TypeCocoDict] = [{"id": img_id} for img_id in range(len(targets))]
+        if self._image_indices is not None:
+            images = [{"id": self._image_indices[img["id"]]} for img in images]
+        # Annotations list
+        annotations: list[_TypeCocoDict] = []
+        for image_id, image_targets in enumerate(targets):
+            if self._image_indices is not None:
+                image_id = self._image_indices[image_id]
+
+            # Ensure xyxy is not None
+            if image_targets.xyxy is None:
+                continue
+
+            content = self._detections_content(image_targets)
+            for target_idx, xyxy in enumerate(image_targets.xyxy):
+                xywh = [xyxy[0], xyxy[1], xyxy[2] - xyxy[0], xyxy[3] - xyxy[1]]
+
+                # Default values
+                category_id = 0
+
+                if image_targets.class_id is not None:
+                    cls_id = image_targets.class_id[target_idx]
+                    if self._class_mapping is not None:
+                        category_id = self._class_mapping[int(cls_id)]
+                    else:
+                        category_id = int(cls_id)
+
+                # Use area from data if available, otherwise calculate from the
+                # metric target content (bbox, mask or oriented box)
+                area = None
+                if (
+                    image_targets.data is not None
+                    and AREA_DATA_FIELD in image_targets.data
+                ):
+                    area_data: npt.NDArray[np.float32] = np.asarray(
+                        image_targets.data[AREA_DATA_FIELD], dtype=np.float32
+                    )
+                    area = float(area_data[target_idx])
+
+                if area is None:
+                    area = self._content_area(xywh, content, target_idx)
+
+                iscrowd = 0
+                if image_targets.data is not None and "iscrowd" in image_targets.data:
+                    iscrowd_data: npt.NDArray[np.int64] = np.asarray(
+                        image_targets.data["iscrowd"], dtype=np.int64
+                    )
+                    iscrowd = int(iscrowd_data[target_idx])
+
+                ignore = 0
+                if image_targets.data is not None and "ignore" in image_targets.data:
+                    ignore_data: npt.NDArray[np.int64] = np.asarray(
+                        image_targets.data["ignore"], dtype=np.int64
+                    )
+                    ignore = int(ignore_data[target_idx])
+
+                dict_annotation: _TypeCocoDict = {
+                    "area": area,
+                    "iscrowd": iscrowd,
+                    "image_id": image_id,
+                    "bbox": xywh,
+                    "category_id": category_id,
+                    "id": len(annotations) + 1,  # Start IDs from 1 (0 means no match)
+                    "ignore": ignore,
+                }
+                if content is not None:
+                    dict_annotation["content"] = content[target_idx]
+                annotations.append(dict_annotation)
+        # Category list
+        all_cat_ids = {annotation["category_id"] for annotation in annotations}
+        categories: list[_TypeCocoDict] = [{"id": cat_id} for cat_id in all_cat_ids]
+        # Create coco dictionary
+        return {
+            "images": images,
+            "annotations": annotations,
+            "categories": categories,
+        }
+
+    def _prepare_predictions(
+        self, predictions: list[Detections]
+    ) -> list[_TypeCocoDict]:
+        """Transform predictions into a list of predictions that can be used by the COCO
+        evaluator."""
+        coco_predictions: list[_TypeCocoDict] = []
+        for image_id, image_predictions in enumerate(predictions):
+            if self._image_indices is not None:
+                image_id = self._image_indices[image_id]
+
+            if image_predictions.xyxy is None:
+                continue
+
+            content = self._detections_content(image_predictions)
+            for pred_idx, xyxy in enumerate(image_predictions.xyxy):
+                xywh = [xyxy[0], xyxy[1], xyxy[2] - xyxy[0], xyxy[3] - xyxy[1]]
+
+                category_id = 0
+                score = 0.0
+
+                if image_predictions.class_id is not None:
+                    cls_id = image_predictions.class_id[pred_idx]
+                    if self._class_mapping is not None:
+                        category_id = self._class_mapping[int(cls_id)]
+                    else:
+                        category_id = int(cls_id)
+
+                if image_predictions.confidence is not None:
+                    score = float(image_predictions.confidence[pred_idx])
+
+                # Use area from data if available, otherwise calculate from the
+                # metric target content (bbox, mask or oriented box)
+                area = None
+                if (
+                    image_predictions.data is not None
+                    and AREA_DATA_FIELD in image_predictions.data
+                ):
+                    area_data: npt.NDArray[np.float32] = np.asarray(
+                        image_predictions.data[AREA_DATA_FIELD], dtype=np.float32
+                    )
+                    area = float(area_data[pred_idx])
+
+                if area is None:
+                    area = self._content_area(xywh, content, pred_idx)
+
+                dict_prediction: _TypeCocoDict = {
+                    "image_id": image_id,
+                    "bbox": xywh,
+                    "score": score,
+                    "category_id": category_id,
+                    "area": area,
+                    "id": len(coco_predictions) + 1,
+                }
+                if content is not None:
+                    dict_prediction["content"] = content[pred_idx]
+                coco_predictions.append(dict_prediction)
+        return coco_predictions
+
+    def compute(self) -> MeanAveragePrecisionResult:
+        """
+        Calculate Mean Average Precision based on predicted and ground-truth
+        detections at different thresholds using the COCO evaluation metrics.
+        Source: https://github.com/rafaelpadilla/review_object_detection_metrics
+
+        Returns:
+            The Mean Average Precision result.
+        """
+        total_images_predictions = len(self._predictions_list)
+        total_images_targets = len(self._targets_list)
+
+        if total_images_predictions != total_images_targets:
+            raise ValueError(
+                f"The number of predictions ({total_images_predictions}) and"
+                f" targets ({total_images_targets}) during the evaluation must be"
+                " the same."
+            )
+        dict_targets = self._prepare_targets(self._targets_list)
+        lst_predictions = self._prepare_predictions(self._predictions_list)
+        # Create a coco object with the targets
+        coco_gt = EvaluationDataset(targets=dict_targets)
+        # Include the predictions to coco object
+        coco_det = coco_gt.load_predictions(lst_predictions)
+        # Create a coco evaluator with the predictions
+        cocoEval = COCOEvaluator(coco_gt, coco_det, metric_target=self._metric_target)
+
+        # Evaluate on all images
+        cocoEval.evaluate()
+
+        # Create MeanAveragePrecisionResult object for small objects
+        mAP_small = MeanAveragePrecisionResult(
+            metric_target=self._metric_target,
+            is_class_agnostic=self._class_agnostic,
+            mAP_scores=np.asarray(
+                cocoEval.results["mAP_scores_small"], dtype=np.float64
+            ),
+            ap_per_class=np.asarray(
+                cocoEval.results["ap_per_class_small"], dtype=np.float64
+            ),
+            iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64),
+            matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32),
+        )
+        # Create MeanAveragePrecisionResult object for medium objects
+        mAP_medium = MeanAveragePrecisionResult(
+            metric_target=self._metric_target,
+            is_class_agnostic=self._class_agnostic,
+            mAP_scores=np.asarray(
+                cocoEval.results["mAP_scores_medium"], dtype=np.float64
+            ),
+            ap_per_class=np.asarray(
+                cocoEval.results["ap_per_class_medium"], dtype=np.float64
+            ),
+            iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64),
+            matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32),
+        )
+        # Create MeanAveragePrecisionResult object for large objects
+        mAP_large = MeanAveragePrecisionResult(
+            metric_target=self._metric_target,
+            is_class_agnostic=self._class_agnostic,
+            mAP_scores=np.asarray(
+                cocoEval.results["mAP_scores_large"], dtype=np.float64
+            ),
+            ap_per_class=np.asarray(
+                cocoEval.results["ap_per_class_large"], dtype=np.float64
+            ),
+            iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64),
+            matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32),
+        )
+
+        # Create the final MeanAveragePrecisionResult object
+        mAP_result = MeanAveragePrecisionResult(
+            metric_target=self._metric_target,
+            is_class_agnostic=self._class_agnostic,
+            mAP_scores=np.asarray(
+                cocoEval.results["mAP_scores_all_sizes"], dtype=np.float64
+            ),
+            ap_per_class=np.asarray(
+                cocoEval.results["ap_per_class_all_sizes"], dtype=np.float64
+            ),
+            iou_thresholds=np.asarray(cocoEval.params.iou_thrs, dtype=np.float64),
+            matched_classes=np.asarray(cocoEval.params.cat_ids, dtype=np.int32),
+            small_objects=mAP_small,
+            medium_objects=mAP_medium,
+            large_objects=mAP_large,
+        )
+        return mAP_result
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_recall.py b/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_recall.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d2a1820656ef97a89d49f169c744c2c93d34918
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/mean_average_recall.py
@@ -0,0 +1,792 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.draw.color import LEGACY_COLOR_PALETTE
+from supervision.metrics.core import Metric, MetricTarget
+from supervision.metrics.utils.matching import (
+    _match_detection_batch_with_target_indices,
+)
+from supervision.metrics.utils.object_size import (
+    ObjectSizeCategory,
+    get_detection_size_category,
+)
+from supervision.metrics.utils.utils import ensure_pandas_installed
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+@dataclass
+class MeanAverageRecallResult:
+    """
+    The results of the Mean Average Recall metric calculation.
+
+    Defaults to `0` if no detections or targets were provided.
+
+    Attributes:
+        metric_target: the type of data used for the metric -
+            boxes, masks or oriented bounding boxes.
+        mAR_at_1: the Mean Average Recall, when considering only the top
+            highest confidence detection for each image.
+        mAR_at_10: the Mean Average Recall, when considering top 10
+            highest confidence detections for each image.
+        mAR_at_100: the Mean Average Recall, when considering top 100
+            highest confidence detections for each image.
+        recall_per_class: the recall scores per max detection count, class and
+            IoU threshold. Shape:
+            `(num_max_detections, num_target_classes, num_iou_thresholds)`.
+        max_detections: the array with maximum number of detections
+            considered.
+        iou_thresholds: the IoU thresholds used in the calculations.
+        matched_classes: the class IDs of all matched classes.
+            Corresponds to the class axis of `recall_per_class`.
+        small_objects: the Mean Average Recall
+            metric results for small objects (area < 32²).
+        medium_objects: the Mean Average Recall
+            metric results for medium objects (32² ≤ area < 96²).
+        large_objects: the Mean Average Recall
+            metric results for large objects (area ≥ 96²).
+    """
+
+    metric_target: MetricTarget
+
+    @property
+    def mAR_at_1(self) -> float:
+        return float(self.recall_scores[0])
+
+    @property
+    def mAR_at_10(self) -> float:
+        return float(self.recall_scores[1])
+
+    @property
+    def mAR_at_100(self) -> float:
+        return float(self.recall_scores[2])
+
+    recall_scores: npt.NDArray[np.float64]
+    recall_per_class: npt.NDArray[np.float64]
+    max_detections: npt.NDArray[np.int32]
+    iou_thresholds: npt.NDArray[np.float32]
+    matched_classes: npt.NDArray[np.int32]
+
+    small_objects: MeanAverageRecallResult | None
+    medium_objects: MeanAverageRecallResult | None
+    large_objects: MeanAverageRecallResult | None
+
+    def __str__(self) -> str:
+        """
+        Format as a pretty string.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from supervision.metrics import MeanAverageRecall
+            >>> predictions = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0]),
+            ...     confidence=np.array([0.9])
+            ... )
+            >>> targets = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> mar_metric = MeanAverageRecall()
+            >>> mar_result = mar_metric.update(predictions, targets).compute()
+            >>> print(mar_result)  # doctest: +ELLIPSIS
+            MeanAverageRecallResult:
+            Metric target:  MetricTarget.BOXES
+            mAR @ 1:    1.0000
+            mAR @ 10:   1.0000
+            mAR @ 100:  1.0000
+            max detections: [  1  10 100]
+            IoU thresh:     [0.5  0.55 ... 0.95]
+            mAR per class:
+              @1:
+                0: [1. ... 1.]
+              @10:
+                0: [1. ... 1.]
+              @100:
+                0: [1. ... 1.]
+            ...
+            Medium objects:
+              MeanAverageRecallResult:
+              Metric target:  MetricTarget.BOXES
+              mAR @ 1:    0.0000
+              ...
+
+            ```
+        """
+        out_str = (
+            f"{self.__class__.__name__}:\n"
+            f"Metric target:  {self.metric_target}\n"
+            f"mAR @ 1:    {self.mAR_at_1:.4f}\n"
+            f"mAR @ 10:   {self.mAR_at_10:.4f}\n"
+            f"mAR @ 100:  {self.mAR_at_100:.4f}\n"
+            f"max detections: {self.max_detections}\n"
+            f"IoU thresh:     {self.iou_thresholds}\n"
+            f"mAR per class:\n"
+        )
+        if self.recall_per_class.size == 0:
+            out_str += "  No results\n"
+        for max_detections, recalls_at_k in zip(
+            self.max_detections, self.recall_per_class
+        ):
+            out_str += f"  @{max_detections}:\n"
+            for class_id, recall_of_class in zip(self.matched_classes, recalls_at_k):
+                out_str += f"    {class_id}: {recall_of_class}\n"
+
+        indent = "  "
+        if self.small_objects is not None:
+            indented = indent + str(self.small_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nSmall objects:\n{indented}"
+        if self.medium_objects is not None:
+            indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nMedium objects:\n{indented}"
+        if self.large_objects is not None:
+            indented = indent + str(self.large_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nLarge objects:\n{indented}"
+
+        return out_str
+
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the result to a pandas DataFrame.
+
+        Returns:
+            The result as a DataFrame.
+        """
+        ensure_pandas_installed()
+        import pandas as pd
+
+        pandas_data: dict[str, Any] = {
+            "mAR @ 1": self.mAR_at_1,
+            "mAR @ 10": self.mAR_at_10,
+            "mAR @ 100": self.mAR_at_100,
+        }
+
+        if self.small_objects is not None:
+            small_objects_df = self.small_objects.to_pandas()
+            for key, value in small_objects_df.items():
+                pandas_data[f"small_objects_{key}"] = value
+        if self.medium_objects is not None:
+            medium_objects_df = self.medium_objects.to_pandas()
+            for key, value in medium_objects_df.items():
+                pandas_data[f"medium_objects_{key}"] = value
+        if self.large_objects is not None:
+            large_objects_df = self.large_objects.to_pandas()
+            for key, value in large_objects_df.items():
+                pandas_data[f"large_objects_{key}"] = value
+
+        return pd.DataFrame(pandas_data, index=[0])
+
+    def plot(self) -> None:
+        """
+        Plot the Mean Average Recall results.
+
+        ![example_plot](\
+            https://media.roboflow.com/supervision-docs/metrics/mAR_plot_example.png\
+            ){ align=center width="800" }
+        """
+        from matplotlib import pyplot as plt
+
+        labels = ["mAR @ 1", "mAR @ 10", "mAR @ 100"]
+        values = [self.mAR_at_1, self.mAR_at_10, self.mAR_at_100]
+        colors = [LEGACY_COLOR_PALETTE[0]] * 3
+
+        if self.small_objects is not None:
+            small_objects = self.small_objects
+            labels += ["Small: mAR @ 1", "Small: mAR @ 10", "Small: mAR @ 100"]
+            values += [
+                small_objects.mAR_at_1,
+                small_objects.mAR_at_10,
+                small_objects.mAR_at_100,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[3]] * 3
+
+        if self.medium_objects is not None:
+            medium_objects = self.medium_objects
+            labels += ["Medium: mAR @ 1", "Medium: mAR @ 10", "Medium: mAR @ 100"]
+            values += [
+                medium_objects.mAR_at_1,
+                medium_objects.mAR_at_10,
+                medium_objects.mAR_at_100,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[2]] * 3
+
+        if self.large_objects is not None:
+            large_objects = self.large_objects
+            labels += ["Large: mAR @ 1", "Large: mAR @ 10", "Large: mAR @ 100"]
+            values += [
+                large_objects.mAR_at_1,
+                large_objects.mAR_at_10,
+                large_objects.mAR_at_100,
+            ]
+            colors += [LEGACY_COLOR_PALETTE[4]] * 3
+
+        plt.rcParams["font.family"] = "monospace"
+
+        _, ax = plt.subplots(figsize=(10, 6))
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Value", fontweight="bold")
+        title = (
+            f"Mean Average Recall, by Object Size\n(target: {self.metric_target.value})"
+        )
+        ax.set_title(title, fontweight="bold")
+
+        x_positions = range(len(labels))
+        bars = ax.bar(x_positions, values, color=colors, align="center")
+
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right")
+
+        for bar in bars:
+            y_value = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                y_value + 0.02,
+                f"{y_value:.2f}",
+                ha="center",
+                va="bottom",
+            )
+
+        plt.rcParams["font.family"] = "sans-serif"
+
+        plt.tight_layout()
+        plt.show()
+
+
+class MeanAverageRecall(Metric["MeanAverageRecallResult"]):
+    """
+    Mean Average Recall (mAR) measures how well the model detects
+    and retrieves relevant objects by averaging recall over multiple
+    IoU thresholds, classes and detection limits.
+
+    Intuitively, while Recall measures the ability to find all relevant
+    objects, mAR narrows down how many detections are considered for each
+    image. For example, mAR @ 100 considers the top 100 highest confidence
+    detections for each image. mAR @ 1 considers only the highest
+    confidence detection for each image.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics import MeanAverageRecall
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> mar_metric = MeanAverageRecall()
+        >>> mar_result = mar_metric.update(predictions, targets).compute()
+        >>> round(float(mar_result.mAR_at_100), 2)
+        1.0
+
+        ```
+
+    ![example_plot](
+        https://media.roboflow.com/supervision-docs/metrics/mAR_plot_example.png
+    ){ align=center width="800" }
+    """
+
+    def __init__(
+        self,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+    ):
+        """
+        Initialize the Mean Average Recall metric.
+
+        Args:
+            metric_target: The type of detection data to use.
+        """
+        self._metric_target = metric_target
+
+        self._predictions_list: list[Detections] = []
+        self._targets_list: list[Detections] = []
+
+        self.max_detections = np.array([1, 10, 100])
+
+    def reset(self) -> None:
+        """
+        Reset the metric to its initial state, clearing all stored data.
+        """
+        self._predictions_list = []
+        self._targets_list = []
+
+    def update(
+        self,
+        predictions: Detections | list[Detections],
+        targets: Detections | list[Detections],
+    ) -> MeanAverageRecall:
+        """
+        Add new predictions and targets to the metric, but do not compute the result.
+
+        Args:
+            predictions: The predicted detections.
+            targets: The target detections.
+
+        Returns:
+            The updated metric instance.
+        """
+        if not isinstance(predictions, list):
+            predictions = [predictions]
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        if len(predictions) != len(targets):
+            raise ValueError(
+                f"The number of predictions ({len(predictions)}) and"
+                f" targets ({len(targets)}) during the update must be the same."
+            )
+
+        self._predictions_list.extend(predictions)
+        self._targets_list.extend(targets)
+
+        return self
+
+    def compute(self) -> MeanAverageRecallResult:
+        """
+        Calculate the Mean Average Recall metric based on the stored predictions
+        and ground-truth, at different IoU thresholds and maximum detection counts.
+
+        Returns:
+            The Mean Average Recall metric result.
+        """
+        result = self._compute(self._predictions_list, self._targets_list)
+        result.small_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL
+        )
+        result.medium_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM
+        )
+        result.large_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE
+        )
+
+        return result
+
+    def _compute(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory = ObjectSizeCategory.ANY,
+    ) -> MeanAverageRecallResult:
+        if size_category != ObjectSizeCategory.ANY:
+            # Recall is unaffected by false-positive bookkeeping, and out-of-bucket
+            # predictions must still consume top-K rank slots, so bucket-filtering
+            # the targets is all the size handling mAR needs.
+            targets_list = [
+                self._filter_detections_by_size(targets, size_category)
+                for targets in targets_list
+            ]
+
+        iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32)
+        stats: list[Any] = []
+
+        for predictions, targets in zip(predictions_list, targets_list):
+            prediction_contents = self._detections_content(predictions)
+            target_contents = self._detections_content(targets)
+            if len(targets) > 0:
+                if predictions.class_id is None or targets.class_id is None:
+                    raise ValueError(
+                        "MeanAverageRecall metric requires `class_id` on both "
+                        "predictions and targets."
+                    )
+                if len(predictions) == 0:
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)
+                    if len(target_class_ids) == 0:
+                        continue
+                    stats.append(
+                        (
+                            np.zeros(
+                                (0, iou_thresholds.size, self.max_detections.size),
+                                dtype=bool,
+                            ),
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0,), dtype=int),
+                            np.zeros((0,), dtype=int),
+                            target_class_ids,
+                        )
+                    )
+
+                else:
+                    if predictions.confidence is None:
+                        raise ValueError(
+                            "MeanAverageRecall metric requires `confidence` on "
+                            "predictions."
+                        )
+                    prediction_class_ids = np.asarray(
+                        predictions.class_id, dtype=np.int32
+                    )
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)
+                    prediction_confidence = np.asarray(
+                        predictions.confidence, dtype=np.float32
+                    )
+                    if self._metric_target == MetricTarget.BOXES:
+                        # BOXES target never yields CompactMask; narrow for mypy.
+                        iou = box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    elif self._metric_target == MetricTarget.MASKS:
+                        iou = mask_iou_batch(target_contents, prediction_contents)
+                    elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+                        # OBB target never yields CompactMask; narrow for mypy.
+                        iou = oriented_box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    else:
+                        raise ValueError(
+                            "Unsupported metric target for IoU calculation"
+                        )
+
+                    sorted_indices = np.argsort(-prediction_confidence)
+                    matches = self._match_top_predictions(
+                        prediction_class_ids[sorted_indices],
+                        target_class_ids,
+                        iou[:, sorted_indices],
+                        iou_thresholds,
+                    )
+                    ignored_matches = np.zeros(
+                        (len(sorted_indices), iou_thresholds.size), dtype=bool
+                    )
+
+                    stats.append(
+                        (
+                            matches,
+                            ignored_matches,
+                            np.arange(len(prediction_confidence)),
+                            prediction_class_ids[sorted_indices],
+                            target_class_ids,
+                        )
+                    )
+
+        if not stats:
+            max_detection_count = self.max_detections.shape[0]
+            return MeanAverageRecallResult(
+                metric_target=self._metric_target,
+                recall_scores=np.zeros(max_detection_count),
+                recall_per_class=np.zeros(
+                    (max_detection_count, 0, iou_thresholds.shape[0])
+                ),
+                max_detections=self.max_detections,
+                iou_thresholds=iou_thresholds,
+                matched_classes=np.array([], dtype=int),
+                small_objects=None,
+                medium_objects=None,
+                large_objects=None,
+            )
+
+        concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)]
+        recall_scores_per_k, recall_per_class_at_k, unique_classes = (
+            self._compute_average_recall_for_classes(*concatenated_stats)
+        )
+
+        return MeanAverageRecallResult(
+            metric_target=self._metric_target,
+            recall_scores=recall_scores_per_k,
+            recall_per_class=recall_per_class_at_k,
+            max_detections=self.max_detections,
+            iou_thresholds=iou_thresholds,
+            matched_classes=unique_classes,
+            small_objects=None,
+            medium_objects=None,
+            large_objects=None,
+        )
+
+    def _match_top_predictions(
+        self,
+        sorted_prediction_class_ids: npt.NDArray[np.int32],
+        target_class_ids: npt.NDArray[np.int32],
+        sorted_iou: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        """Match one image's predictions separately for each detection limit.
+
+        The matcher pairs by highest IoU rather than by confidence, so matching every
+        prediction and then keeping the top K would let a prediction ranked below K
+        take a target from one ranked within it. Each limit therefore matches only its
+        own top K predictions.
+
+        Args:
+            sorted_prediction_class_ids: shape (P,), prediction class ids sorted by
+                descending confidence.
+            target_class_ids: shape (T,), target class ids.
+            sorted_iou: shape (T, P), IoU with prediction columns in the same order.
+            iou_thresholds: shape (Th,), IoU thresholds.
+
+        Returns:
+            shape (P, Th, K), whether each prediction is a true positive when only
+                the top `max_detections[k]` predictions are matched; predictions
+                ranked below that limit are `False`.
+        """
+        prediction_count = sorted_prediction_class_ids.shape[0]
+        matches = np.zeros(
+            (prediction_count, iou_thresholds.size, self.max_detections.size),
+            dtype=bool,
+        )
+        for limit_index, max_detections in enumerate(self.max_detections):
+            top_count = min(int(max_detections), prediction_count)
+            limit_matches, _ = _match_detection_batch_with_target_indices(
+                sorted_prediction_class_ids[:top_count],
+                target_class_ids,
+                sorted_iou[:, :top_count],
+                iou_thresholds,
+            )
+            matches[:top_count, :, limit_index] = limit_matches
+        return matches
+
+    def _compute_average_recall_for_classes(
+        self,
+        matches: npt.NDArray[np.bool_],
+        ignored_matches: npt.NDArray[np.bool_],
+        prediction_indices: npt.NDArray[np.int32],
+        prediction_class_ids: npt.NDArray[np.int32],
+        true_class_ids: npt.NDArray[np.int32],
+    ) -> tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+    ]:
+        """Compute recall per detection limit and class from all images' matches.
+
+        `matches` has shape (P, Th, K) and holds, for each detection limit, the
+        matches of that limit's own top predictions; the other arrays have one row
+        or entry per prediction, or per target for `true_class_ids`.
+        """
+        unique_classes, class_counts = np.unique(true_class_ids, return_counts=True)
+
+        if unique_classes.size == 0:
+            max_detection_count = self.max_detections.shape[0]
+            num_thresholds = matches.shape[1]
+            return (
+                np.zeros(max_detection_count, dtype=np.float64),
+                np.zeros((max_detection_count, 0, num_thresholds), dtype=np.float64),
+                unique_classes,
+            )
+
+        recalls_at_k: list[npt.NDArray[np.float64]] = []
+        for limit_index, max_detections in enumerate(self.max_detections):
+            # Shape: PxThxK,P,C,C -> CxThx3
+            is_within_limit = prediction_indices < max_detections
+            confusion_matrix = self._compute_confusion_matrix(
+                matches[is_within_limit, :, limit_index],
+                ignored_matches[is_within_limit],
+                prediction_class_ids[is_within_limit],
+                unique_classes,
+                class_counts,
+            )
+
+            # Shape: CxThx3 -> CxTh
+            recall_per_class = self._compute_recall(confusion_matrix)
+            recalls_at_k.append(recall_per_class)
+
+        # Shape: KxCxTh -> KxC
+        recall_per_class_at_k = np.array(recalls_at_k)
+        average_recall_per_class = np.mean(recall_per_class_at_k, axis=2)
+
+        # Shape: KxC -> K
+        recall_scores = np.mean(average_recall_per_class, axis=1)
+
+        return recall_scores, recall_per_class_at_k, unique_classes
+
+    @staticmethod
+    def _match_detection_batch(
+        predictions_classes: npt.NDArray[np.int32],
+        target_classes: npt.NDArray[np.int32],
+        iou: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        result_correct, _ = _match_detection_batch_with_target_indices(
+            predictions_classes, target_classes, iou, iou_thresholds
+        )
+        return result_correct
+
+    @staticmethod
+    def _compute_confusion_matrix(
+        sorted_matches: npt.NDArray[np.bool_],
+        sorted_ignored_matches: npt.NDArray[np.bool_],
+        sorted_prediction_class_ids: npt.NDArray[np.int32],
+        unique_classes: npt.NDArray[np.integer],
+        class_counts: npt.NDArray[np.integer],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Compute the confusion matrix for each class and IoU threshold.
+
+        Assumes the matches and prediction_class_ids are sorted by confidence
+        in descending order.
+
+        Args:
+            sorted_matches: shape (P, Th), that is True
+                if the prediction is a true positive at the given IoU threshold.
+            sorted_ignored_matches: shape (P, Th), that is True
+                if the prediction should not affect the given IoU threshold.
+            sorted_prediction_class_ids: shape (P,), containing
+                the class id for each prediction.
+            unique_classes: shape (C,), containing the unique
+                class ids.
+            class_counts: shape (C,), containing the number
+                of true instances for each class.
+            max_detections: The maximum number of detections to
+                consider for each class. Extra detections are considered false
+                positives. By default, all detections are considered.
+
+        Returns:
+            shape (C, Th, 3), containing the true positives, false
+                positives, and false negatives for each class and IoU threshold.
+        """
+        num_thresholds = sorted_matches.shape[1]
+        num_classes = unique_classes.shape[0]
+
+        confusion_matrix: npt.NDArray[np.float64] = np.zeros(
+            (num_classes, num_thresholds, 3), dtype=np.float64
+        )
+        for class_idx, class_id in enumerate(unique_classes):
+            is_class = sorted_prediction_class_ids == class_id
+            num_true = class_counts[class_idx]
+            num_predictions = is_class.sum()
+
+            if num_predictions == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = np.zeros(num_thresholds)
+                false_negatives = np.full(num_thresholds, num_true)
+            elif num_true == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = (~sorted_ignored_matches[is_class]).sum(0)
+                false_negatives = np.zeros(num_thresholds)
+            else:
+                limited_matches = sorted_matches[is_class]
+                limited_ignored_matches = sorted_ignored_matches[is_class]
+                true_positives = limited_matches.sum(0)
+
+                false_positives = (~limited_matches & ~limited_ignored_matches).sum(0)
+                false_negatives = num_true - true_positives
+
+            confusion_matrix[class_idx] = np.stack(
+                [true_positives, false_positives, false_negatives], axis=1
+            )
+
+        result_confusion_matrix: npt.NDArray[np.float64] = confusion_matrix
+        return result_confusion_matrix
+
+    @staticmethod
+    def _compute_recall(
+        confusion_matrix: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Broadcastable function, computing the recall from the confusion matrix.
+
+        Args:
+            confusion_matrix: shape (N, ..., 3), where the last dimension
+                contains the true positives, false positives, and false negatives.
+
+        Returns:
+            shape (N, ...), containing the recall for each element.
+        """
+        if not confusion_matrix.shape[-1] == 3:
+            raise ValueError(
+                f"Confusion matrix must have shape (..., 3), got "
+                f"{confusion_matrix.shape}"
+            )
+        true_positives = confusion_matrix[..., 0]
+        false_negatives = confusion_matrix[..., 2]
+
+        denominator = true_positives + false_negatives
+        recall = np.divide(
+            true_positives,
+            denominator,
+            out=np.zeros_like(denominator, dtype=np.float64),
+            where=denominator != 0,
+        )
+
+        result_recall: npt.NDArray[np.float64] = recall
+        return result_recall
+
+    def _detections_content(
+        self, detections: Detections
+    ) -> npt.NDArray[Any] | CompactMask:
+        """Return boxes, masks or oriented bounding boxes from detections.
+
+        For the mask target this may return a
+        :class:`~supervision.detection.compact_mask.CompactMask` rather than a
+        dense boolean array when the detections carry compact masks.
+        """
+        if self._metric_target == MetricTarget.BOXES:
+            return cast(npt.NDArray[Any], detections.xyxy)
+        if self._metric_target == MetricTarget.MASKS:
+            if detections.mask is not None:
+                # detections.mask is NDArray[bool] | CompactMask; return as-is.
+                return detections.mask
+            if len(detections) > 0:
+                raise ValueError(
+                    "MeanAverageRecall with `MetricTarget.MASKS` requires "
+                    "detections to include masks."
+                )
+            return self._make_empty_content()
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+            if obb is not None and len(obb) > 0:
+                result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32)
+                return result_obb
+            return self._make_empty_content()
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _make_empty_content(self) -> npt.NDArray[Any]:
+        if self._metric_target == MetricTarget.BOXES:
+            empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32)
+            return empty_boxes
+
+        if self._metric_target == MetricTarget.MASKS:
+            empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool)
+            return empty_masks
+
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32)
+            return empty_obb
+
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _filter_detections_by_size(
+        self, detections: Detections, size_category: ObjectSizeCategory
+    ) -> Detections:
+        """Return a copy of detections with contents filtered by object size."""
+        new_detections = deepcopy(detections)
+        if detections.is_empty() or size_category == ObjectSizeCategory.ANY:
+            return new_detections
+
+        sizes = get_detection_size_category(new_detections, self._metric_target)
+        size_mask = sizes == size_category.value
+
+        new_detections.xyxy = new_detections.xyxy[size_mask]
+        if new_detections.mask is not None:
+            new_detections.mask = new_detections.mask[size_mask]
+        if new_detections.class_id is not None:
+            new_detections.class_id = new_detections.class_id[size_mask]
+        if new_detections.confidence is not None:
+            new_detections.confidence = new_detections.confidence[size_mask]
+        if new_detections.tracker_id is not None:
+            new_detections.tracker_id = new_detections.tracker_id[size_mask]
+        if new_detections.data is not None:
+            for key, value in new_detections.data.items():
+                new_detections.data[key] = np.array(value)[size_mask]
+
+        return new_detections
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/precision.py b/.venv/lib/python3.12/site-packages/supervision/metrics/precision.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8bcf34b2dde6efc4bf302523fc0abf4ca175459
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/precision.py
@@ -0,0 +1,814 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.draw.color import LEGACY_COLOR_PALETTE
+from supervision.metrics.core import AveragingMethod, Metric, MetricTarget
+from supervision.metrics.utils.matching import (
+    _match_detection_batch_with_target_indices,
+)
+from supervision.metrics.utils.object_size import (
+    ObjectSizeCategory,
+    get_detection_size_category,
+)
+from supervision.metrics.utils.utils import ensure_pandas_installed
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class Precision(Metric["PrecisionResult"]):
+    """
+    Precision is a metric used to evaluate object detection models. It is the ratio of
+    true positive detections to the total number of predicted detections. We calculate
+    it at different IoU thresholds.
+
+    In simple terms, Precision is a measure of a model's accuracy, calculated as:
+
+    `Precision = TP / (TP + FP)`
+
+    Here, `TP` is the number of true positives (correct detections), and `FP` is the
+    number of false positive detections (detected, but incorrectly).
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics import Precision
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> precision_metric = Precision()
+        >>> precision_result = precision_metric.update(predictions, targets).compute()
+        >>> round(float(precision_result.precision_at_50), 2)
+        1.0
+
+        ```
+
+    ![example_plot](
+        https://media.roboflow.com/supervision-docs/metrics/precision_plot_example.png
+    ){ align=center width="800" }
+    """
+
+    def __init__(
+        self,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+        averaging_method: AveragingMethod = AveragingMethod.WEIGHTED,
+    ):
+        """
+        Initialize the Precision metric.
+
+        Args:
+            metric_target: The type of detection data to use.
+            averaging_method: The averaging method used to compute the
+                precision. Determines how the precision is aggregated across classes.
+        """
+        self._metric_target = metric_target
+        self.averaging_method = averaging_method
+
+        self._predictions_list: list[Detections] = []
+        self._targets_list: list[Detections] = []
+
+    def reset(self) -> None:
+        """
+        Reset the metric to its initial state, clearing all stored data.
+        """
+        self._predictions_list = []
+        self._targets_list = []
+
+    def update(
+        self,
+        predictions: Detections | list[Detections],
+        targets: Detections | list[Detections],
+    ) -> Precision:
+        """
+        Add new predictions and targets to the metric, but do not compute the result.
+
+        Args:
+            predictions: The predicted detections.
+            targets: The target detections.
+
+        Returns:
+            The updated metric instance.
+        """
+        if not isinstance(predictions, list):
+            predictions = [predictions]
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        if len(predictions) != len(targets):
+            raise ValueError(
+                f"The number of predictions ({len(predictions)}) and"
+                f" targets ({len(targets)}) during the update must be the same."
+            )
+
+        self._predictions_list.extend(predictions)
+        self._targets_list.extend(targets)
+
+        return self
+
+    def compute(self) -> PrecisionResult:
+        """
+        Calculate the precision metric based on the stored predictions and ground-truth
+        data, at different IoU thresholds.
+
+        Returns:
+            The precision metric result.
+        """
+        result = self._compute(self._predictions_list, self._targets_list)
+        result.small_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL
+        )
+        result.medium_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM
+        )
+        result.large_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE
+        )
+
+        return result
+
+    def _compute(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory = ObjectSizeCategory.ANY,
+    ) -> PrecisionResult:
+        """Build per-image stats tuples and delegate to class-level computation.
+
+        Each stats tuple is
+        ``(matches, ignored_matches, confidence, class_ids, true_class_ids)``:
+        - Both empty: skip (no information).
+        - Targets empty, predictions present: all predictions are FPs; true_class_ids
+          is ``zeros((0,))``.
+        - Targets present: IoU matching produces ``matches`` array.
+        """
+        iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32)
+        stats: list[Any] = []
+
+        for predictions, targets in zip(predictions_list, targets_list):
+            prediction_contents = self._detections_content(predictions)
+            target_contents = self._detections_content(targets)
+            prediction_size_mask = np.ones(len(predictions), dtype=bool)
+            target_size_mask = np.ones(len(targets), dtype=bool)
+            if size_category != ObjectSizeCategory.ANY:
+                if len(predictions) > 0:
+                    prediction_size_mask = (
+                        get_detection_size_category(predictions, self._metric_target)
+                        == size_category.value
+                    )
+                if len(targets) > 0:
+                    target_size_mask = (
+                        get_detection_size_category(targets, self._metric_target)
+                        == size_category.value
+                    )
+
+            if len(targets) == 0 and len(predictions) > 0:
+                # Only predictions are present (e.g. a background image); every
+                # prediction is a false positive.
+                if predictions.class_id is None or predictions.confidence is None:
+                    raise ValueError(
+                        "Precision metric requires `class_id` and `confidence` "
+                        "on predictions."
+                    )
+                prediction_class_ids = np.asarray(predictions.class_id, dtype=np.int32)[
+                    prediction_size_mask
+                ]
+                prediction_confidence = np.asarray(
+                    predictions.confidence, dtype=np.float32
+                )[prediction_size_mask]
+                if len(prediction_class_ids) == 0:
+                    continue
+                stats.append(
+                    (
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        prediction_confidence,
+                        prediction_class_ids,
+                        np.zeros((0,), dtype=np.int32),
+                    )
+                )
+            elif len(targets) > 0:
+                if predictions.class_id is None or targets.class_id is None:
+                    raise ValueError(
+                        "Precision metric requires `class_id` on both predictions "
+                        "and targets."
+                    )
+                if len(predictions) == 0:
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[
+                        target_size_mask
+                    ]
+                    if len(target_class_ids) == 0:
+                        continue
+                    stats.append(
+                        (
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0,), dtype=np.float32),
+                            np.zeros((0,), dtype=int),
+                            target_class_ids,
+                        )
+                    )
+
+                else:
+                    if predictions.confidence is None:
+                        raise ValueError(
+                            "Precision metric requires `confidence` on predictions."
+                        )
+                    prediction_class_ids = np.asarray(
+                        predictions.class_id, dtype=np.int32
+                    )
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)
+                    prediction_confidence = np.asarray(
+                        predictions.confidence, dtype=np.float32
+                    )
+                    if self._metric_target == MetricTarget.BOXES:
+                        iou = box_iou_batch(target_contents, prediction_contents)
+                    elif self._metric_target == MetricTarget.MASKS:
+                        iou = mask_iou_batch(target_contents, prediction_contents)
+                    elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+                        iou = oriented_box_iou_batch(
+                            target_contents, prediction_contents
+                        )
+                    else:
+                        raise ValueError(
+                            "Unsupported metric target for IoU calculation"
+                        )
+
+                    # None keeps the matcher on its single-round fast path
+                    # when no size bucket is scored.
+                    target_scored_mask = (
+                        target_size_mask
+                        if size_category != ObjectSizeCategory.ANY
+                        else None
+                    )
+                    matches, matched_target_indices = (
+                        _match_detection_batch_with_target_indices(
+                            prediction_class_ids,
+                            target_class_ids,
+                            iou,
+                            iou_thresholds,
+                            target_scored_mask=target_scored_mask,
+                        )
+                    )
+                    ignored_matches = np.zeros_like(matches, dtype=bool)
+                    if size_category != ObjectSizeCategory.ANY:
+                        valid_target_match = matched_target_indices >= 0
+                        matched_scored_target = np.zeros_like(matches, dtype=bool)
+                        if np.any(valid_target_match):
+                            matched_scored_target[valid_target_match] = (
+                                target_size_mask[
+                                    matched_target_indices[valid_target_match]
+                                ]
+                            )
+                        prediction_scored = (
+                            prediction_size_mask[:, None] | matched_scored_target
+                        )
+                        ignored_matches = ~prediction_scored | (
+                            valid_target_match & ~matched_scored_target
+                        )
+                        prediction_keep = np.any(~ignored_matches, axis=1)
+                        matches = (
+                            matches[prediction_keep]
+                            & matched_scored_target[prediction_keep]
+                        )
+                        ignored_matches = ignored_matches[prediction_keep]
+                        prediction_confidence = prediction_confidence[prediction_keep]
+                        prediction_class_ids = prediction_class_ids[prediction_keep]
+                        target_class_ids = target_class_ids[target_size_mask]
+                        if (
+                            len(prediction_class_ids) == 0
+                            and len(target_class_ids) == 0
+                        ):
+                            continue
+                    stats.append(
+                        (
+                            matches,
+                            ignored_matches,
+                            prediction_confidence,
+                            prediction_class_ids,
+                            target_class_ids,
+                        )
+                    )
+
+        if not stats:
+            return PrecisionResult(
+                metric_target=self._metric_target,
+                averaging_method=self.averaging_method,
+                precision_scores=np.zeros(iou_thresholds.shape[0]),
+                precision_per_class=np.zeros((0, iou_thresholds.shape[0])),
+                iou_thresholds=iou_thresholds,
+                matched_classes=np.array([], dtype=int),
+                small_objects=None,
+                medium_objects=None,
+                large_objects=None,
+            )
+
+        concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)]
+        precision_scores, precision_per_class, unique_classes = (
+            self._compute_precision_for_classes(*concatenated_stats)
+        )
+
+        return PrecisionResult(
+            metric_target=self._metric_target,
+            averaging_method=self.averaging_method,
+            precision_scores=precision_scores,
+            precision_per_class=precision_per_class,
+            iou_thresholds=iou_thresholds,
+            matched_classes=unique_classes,
+            small_objects=None,
+            medium_objects=None,
+            large_objects=None,
+        )
+
+    def _compute_precision_for_classes(
+        self,
+        matches: npt.NDArray[np.bool_],
+        ignored_matches: npt.NDArray[np.bool_],
+        prediction_confidence: npt.NDArray[np.float32],
+        prediction_class_ids: npt.NDArray[np.int32],
+        true_class_ids: npt.NDArray[np.int32],
+    ) -> tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+    ]:
+        """Compute precision scores from concatenated stats across all images.
+
+        ``unique_classes`` is the union of GT and predicted classes so that
+        predictions of classes absent from GT still count as false positives.
+        """
+        sorted_indices = np.argsort(-prediction_confidence)
+        matches = matches[sorted_indices]
+        ignored_matches = ignored_matches[sorted_indices]
+        prediction_class_ids = prediction_class_ids[sorted_indices]
+        # Predictions whose class never appears in the ground truth are still
+        # false positives, so include those classes in the confusion matrix
+        # (their true-instance count is zero).
+        unique_classes = np.unique(
+            np.concatenate((true_class_ids, prediction_class_ids))
+        )
+        true_classes, true_counts = np.unique(true_class_ids, return_counts=True)
+        class_counts = np.zeros(unique_classes.shape[0], dtype=int)
+        class_counts[np.searchsorted(unique_classes, true_classes)] = true_counts
+
+        # Shape: PxTh,P,C,C -> CxThx3
+        confusion_matrix = self._compute_confusion_matrix(
+            matches, ignored_matches, prediction_class_ids, unique_classes, class_counts
+        )
+
+        # Shape: CxThx3 -> CxTh
+        precision_per_class = self._compute_precision(confusion_matrix)
+
+        # Shape: CxTh -> Th
+        if self.averaging_method == AveragingMethod.MACRO:
+            precision_scores = np.mean(precision_per_class, axis=0)
+        elif self.averaging_method == AveragingMethod.MICRO:
+            confusion_matrix_merged = confusion_matrix.sum(0)
+            precision_scores = self._compute_precision(confusion_matrix_merged)
+        elif self.averaging_method == AveragingMethod.WEIGHTED:
+            class_counts = class_counts.astype(np.float32)
+            if class_counts.sum() == 0:
+                # No ground-truth support (e.g. only false-positive classes, or a
+                # size bucket with predictions but no targets): weighting is
+                # undefined, so report 0 as the empty case did before.
+                precision_scores = np.zeros(precision_per_class.shape[1])
+            else:
+                precision_scores = np.average(
+                    precision_per_class, axis=0, weights=class_counts
+                )
+
+        return precision_scores, precision_per_class, unique_classes
+
+    @staticmethod
+    def _match_detection_batch(
+        predictions_classes: npt.NDArray[np.int32],
+        target_classes: npt.NDArray[np.int32],
+        iou: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        result_correct, _ = _match_detection_batch_with_target_indices(
+            predictions_classes, target_classes, iou, iou_thresholds
+        )
+        return result_correct
+
+    @staticmethod
+    def _compute_confusion_matrix(
+        sorted_matches: npt.NDArray[np.bool_],
+        sorted_ignored_matches: npt.NDArray[np.bool_],
+        sorted_prediction_class_ids: npt.NDArray[np.int32],
+        unique_classes: npt.NDArray[np.int32],
+        class_counts: npt.NDArray[np.int32],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Compute the confusion matrix for each class and IoU threshold.
+
+        Assumes the matches and prediction_class_ids are sorted by confidence
+        in descending order.
+
+        Args:
+            sorted_matches: shape (P, Th), that is True
+                if the prediction is a true positive at the given IoU threshold.
+            sorted_ignored_matches: shape (P, Th), that is True
+                if the prediction should not affect the given IoU threshold.
+            sorted_prediction_class_ids: shape (P,), containing
+                the class id for each prediction.
+            unique_classes: shape (C,), containing the unique
+                class ids.
+            class_counts: shape (C,), containing the number
+                of true instances for each class.
+
+        Returns:
+            shape (C, Th, 3), containing the true positives, false
+                positives, and false negatives for each class and IoU threshold.
+        """
+
+        num_thresholds = sorted_matches.shape[1]
+        num_classes = unique_classes.shape[0]
+
+        confusion_matrix: npt.NDArray[np.float64] = np.zeros(
+            (num_classes, num_thresholds, 3), dtype=np.float64
+        )
+        for class_idx, class_id in enumerate(unique_classes):
+            is_class = sorted_prediction_class_ids == class_id
+            num_true = class_counts[class_idx]
+            num_predictions = is_class.sum()
+
+            if num_predictions == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = np.zeros(num_thresholds)
+                false_negatives = np.full(num_thresholds, num_true)
+            elif num_true == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = (~sorted_ignored_matches[is_class]).sum(0)
+                false_negatives = np.zeros(num_thresholds)
+            else:
+                true_positives = sorted_matches[is_class].sum(0)
+                false_positives = (
+                    ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class]
+                ).sum(0)
+                false_negatives = num_true - true_positives
+            confusion_matrix[class_idx] = np.stack(
+                [true_positives, false_positives, false_negatives], axis=1
+            )
+        result_matrix: npt.NDArray[np.float64] = confusion_matrix
+        return result_matrix
+
+    @staticmethod
+    def _compute_precision(
+        confusion_matrix: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Broadcastable function, computing the precision from the confusion matrix.
+
+        Args:
+            confusion_matrix: shape (N, ..., 3), where the last dimension
+                contains the true positives, false positives, and false negatives.
+
+        Returns:
+            shape (N, ...), containing the precision for each element.
+        """
+        if not confusion_matrix.shape[-1] == 3:
+            raise ValueError(
+                f"Confusion matrix must have shape (..., 3), got "
+                f"{confusion_matrix.shape}"
+            )
+        true_positives = confusion_matrix[..., 0]
+        false_positives = confusion_matrix[..., 1]
+
+        denominator = true_positives + false_positives
+        precision = np.divide(
+            true_positives,
+            denominator,
+            out=np.zeros_like(true_positives),
+            where=denominator != 0,
+        )
+
+        result_precision: npt.NDArray[np.float64] = precision
+        return result_precision
+
+    def _detections_content(self, detections: Detections) -> npt.NDArray[Any]:
+        """Return boxes, masks or oriented bounding boxes from detections."""
+        if self._metric_target == MetricTarget.BOXES:
+            return cast(npt.NDArray[Any], detections.xyxy)
+        if self._metric_target == MetricTarget.MASKS:
+            if detections.mask is not None:
+                return cast(npt.NDArray[Any], detections.mask)
+            if len(detections) > 0:
+                raise ValueError(
+                    "Precision with `MetricTarget.MASKS` requires detections to "
+                    "include masks."
+                )
+            return self._make_empty_content()
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+            if obb is not None and len(obb) > 0:
+                result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32)
+                return result_obb
+            return self._make_empty_content()
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _make_empty_content(self) -> npt.NDArray[Any]:
+        if self._metric_target == MetricTarget.BOXES:
+            empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32)
+            return empty_boxes
+
+        if self._metric_target == MetricTarget.MASKS:
+            empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool)
+            return empty_masks
+
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32)
+            return empty_obb
+
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _filter_detections_by_size(
+        self, detections: Detections, size_category: ObjectSizeCategory
+    ) -> Detections:
+        """Return a copy of detections with contents filtered by object size."""
+        new_detections = deepcopy(detections)
+        if detections.is_empty() or size_category == ObjectSizeCategory.ANY:
+            return new_detections
+
+        sizes = get_detection_size_category(new_detections, self._metric_target)
+        size_mask = sizes == size_category.value
+
+        new_detections.xyxy = new_detections.xyxy[size_mask]
+        if new_detections.mask is not None:
+            new_detections.mask = new_detections.mask[size_mask]
+        if new_detections.class_id is not None:
+            new_detections.class_id = new_detections.class_id[size_mask]
+        if new_detections.confidence is not None:
+            new_detections.confidence = new_detections.confidence[size_mask]
+        if new_detections.tracker_id is not None:
+            new_detections.tracker_id = new_detections.tracker_id[size_mask]
+        if new_detections.data is not None:
+            for key, value in new_detections.data.items():
+                new_detections.data[key] = np.array(value)[size_mask]
+
+        return new_detections
+
+    def _filter_predictions_and_targets_by_size(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory,
+    ) -> tuple[list[Detections], list[Detections]]:
+        """
+        Filter predictions and targets by object size category.
+        """
+        new_predictions_list = []
+        new_targets_list = []
+        for predictions, targets in zip(predictions_list, targets_list):
+            new_predictions_list.append(
+                self._filter_detections_by_size(predictions, size_category)
+            )
+            new_targets_list.append(
+                self._filter_detections_by_size(targets, size_category)
+            )
+        return new_predictions_list, new_targets_list
+
+
+@dataclass
+class PrecisionResult:
+    """
+    The results of the precision metric calculation.
+
+    Defaults to `0` if no detections or targets were provided.
+
+    Attributes:
+        metric_target: the type of data used for the metric -
+            boxes, masks or oriented bounding boxes.
+        averaging_method: the averaging method used to compute the
+            precision. Determines how the precision is aggregated across classes.
+        precision_at_50: the precision at IoU threshold of `0.5`.
+        precision_at_75: the precision at IoU threshold of `0.75`.
+        precision_scores: the precision scores at each IoU threshold.
+            Shape: `(num_iou_thresholds,)`
+        precision_per_class: the precision scores per class and
+            IoU threshold. Shape: `(num_classes, num_iou_thresholds)`
+        iou_thresholds: the IoU thresholds used in the calculations.
+        matched_classes: the class IDs present in either predictions or ground
+            truth. Corresponds to the rows of `precision_per_class`. Classes
+            that appear only in predictions (no ground-truth instances) are
+            included; their per-threshold precision values will be `0.0`.
+        small_objects: the Precision metric results
+            for small objects (area < 32²).
+        medium_objects: the Precision metric results
+            for medium objects (32² ≤ area < 96²).
+        large_objects: the Precision metric results
+            for large objects (area ≥ 96²).
+    """
+
+    metric_target: MetricTarget
+    averaging_method: AveragingMethod
+
+    @property
+    def precision_at_50(self) -> float:
+        return float(self.precision_scores[0])
+
+    @property
+    def precision_at_75(self) -> float:
+        return float(self.precision_scores[5])
+
+    precision_scores: npt.NDArray[np.float64]
+    precision_per_class: npt.NDArray[np.float64]
+    iou_thresholds: npt.NDArray[np.float32]
+    matched_classes: npt.NDArray[np.int32]
+
+    small_objects: PrecisionResult | None
+    medium_objects: PrecisionResult | None
+    large_objects: PrecisionResult | None
+
+    def __str__(self) -> str:
+        """
+        Format as a pretty string.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from supervision.metrics import Precision
+            >>> predictions = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0]),
+            ...     confidence=np.array([0.9])
+            ... )
+            >>> targets = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> precision_metric = Precision()
+            >>> precision_result = precision_metric.update(
+            ...     predictions, targets
+            ... ).compute()
+            >>> print(precision_result)  # doctest: +ELLIPSIS
+            PrecisionResult:
+            Metric target:    MetricTarget.BOXES
+            Averaging method: AveragingMethod.WEIGHTED
+            P @ 50:     1.0000
+            P @ 75:     1.0000
+            P @ thresh: [1. ... 1.]
+            IoU thresh: [0.5  0.55 ... 0.95]
+            Precision per class:
+              0: [1. ... 1.]
+            ...
+            Medium objects:
+              PrecisionResult:
+              Metric target:    MetricTarget.BOXES
+              Averaging method: AveragingMethod.WEIGHTED
+              P @ 50:     0.0000
+              ...
+
+            ```
+        """
+        out_str = (
+            f"{self.__class__.__name__}:\n"
+            f"Metric target:    {self.metric_target}\n"
+            f"Averaging method: {self.averaging_method}\n"
+            f"P @ 50:     {self.precision_at_50:.4f}\n"
+            f"P @ 75:     {self.precision_at_75:.4f}\n"
+            f"P @ thresh: {self.precision_scores}\n"
+            f"IoU thresh: {self.iou_thresholds}\n"
+            f"Precision per class:\n"
+        )
+        if self.precision_per_class.size == 0:
+            out_str += "  No results\n"
+        for class_id, precision_of_class in zip(
+            self.matched_classes, self.precision_per_class
+        ):
+            out_str += f"  {class_id}: {precision_of_class}\n"
+
+        indent = "  "
+        if self.small_objects is not None:
+            indented = indent + str(self.small_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nSmall objects:\n{indented}"
+        if self.medium_objects is not None:
+            indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nMedium objects:\n{indented}"
+        if self.large_objects is not None:
+            indented = indent + str(self.large_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nLarge objects:\n{indented}"
+
+        return out_str
+
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the result to a pandas DataFrame.
+
+        Returns:
+            The result as a DataFrame.
+        """
+        ensure_pandas_installed()
+        import pandas as pd
+
+        pandas_data = {
+            "P@50": self.precision_at_50,
+            "P@75": self.precision_at_75,
+        }
+
+        if self.small_objects is not None:
+            small_objects_df = self.small_objects.to_pandas()
+            for key, value in small_objects_df.items():
+                pandas_data[f"small_objects_{key}"] = value
+        if self.medium_objects is not None:
+            medium_objects_df = self.medium_objects.to_pandas()
+            for key, value in medium_objects_df.items():
+                pandas_data[f"medium_objects_{key}"] = value
+        if self.large_objects is not None:
+            large_objects_df = self.large_objects.to_pandas()
+            for key, value in large_objects_df.items():
+                pandas_data[f"large_objects_{key}"] = value
+
+        return pd.DataFrame(pandas_data, index=[0])
+
+    def plot(self) -> None:
+        """
+        Plot the precision results.
+
+        ![example_plot](
+            https://media.roboflow.com/supervision-docs/metrics/precision_plot_example.png
+        ){ align=center width="800" }
+        """
+
+        from matplotlib import pyplot as plt
+
+        labels = ["Precision@50", "Precision@75"]
+        values = [self.precision_at_50, self.precision_at_75]
+        colors = [LEGACY_COLOR_PALETTE[0]] * 2
+
+        if self.small_objects is not None:
+            small_objects = self.small_objects
+            labels += ["Small: P@50", "Small: P@75"]
+            values += [small_objects.precision_at_50, small_objects.precision_at_75]
+            colors += [LEGACY_COLOR_PALETTE[3]] * 2
+
+        if self.medium_objects is not None:
+            medium_objects = self.medium_objects
+            labels += ["Medium: P@50", "Medium: P@75"]
+            values += [medium_objects.precision_at_50, medium_objects.precision_at_75]
+            colors += [LEGACY_COLOR_PALETTE[2]] * 2
+
+        if self.large_objects is not None:
+            large_objects = self.large_objects
+            labels += ["Large: P@50", "Large: P@75"]
+            values += [large_objects.precision_at_50, large_objects.precision_at_75]
+            colors += [LEGACY_COLOR_PALETTE[4]] * 2
+
+        plt.rcParams["font.family"] = "monospace"
+
+        _, ax = plt.subplots(figsize=(10, 6))
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Value", fontweight="bold")
+        title = (
+            f"Precision, by Object Size"
+            f"\n(target: {self.metric_target.value},"
+            f" averaging: {self.averaging_method.value})"
+        )
+        ax.set_title(title, fontweight="bold")
+
+        x_positions = range(len(labels))
+        bars = ax.bar(x_positions, values, color=colors, align="center")
+
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right")
+
+        for bar in bars:
+            y_value = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                y_value + 0.02,
+                f"{y_value:.2f}",
+                ha="center",
+                va="bottom",
+            )
+
+        plt.rcParams["font.family"] = "sans-serif"
+
+        plt.tight_layout()
+        plt.show()
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/recall.py b/.venv/lib/python3.12/site-packages/supervision/metrics/recall.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5be7bb566a971781d8bb708f836553306cea864
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/recall.py
@@ -0,0 +1,845 @@
+from __future__ import annotations
+
+from copy import deepcopy
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import (
+    box_iou_batch,
+    mask_iou_batch,
+    oriented_box_iou_batch,
+)
+from supervision.draw.color import LEGACY_COLOR_PALETTE
+from supervision.metrics.core import AveragingMethod, Metric, MetricTarget
+from supervision.metrics.utils.matching import (
+    _match_detection_batch_with_target_indices,
+)
+from supervision.metrics.utils.object_size import (
+    ObjectSizeCategory,
+    get_detection_size_category,
+)
+from supervision.metrics.utils.utils import ensure_pandas_installed
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+class Recall(Metric["RecallResult"]):
+    """
+    Recall is a metric used to evaluate object detection models. It is the ratio of
+    true positive detections to the total number of ground truth instances. We calculate
+    it at different IoU thresholds.
+
+    In simple terms, Recall is a measure of a model's completeness, calculated as:
+
+    `Recall = TP / (TP + FN)`
+
+    Here, `TP` is the number of true positives (correct detections), and `FN` is the
+    number of false negatives (missed detections).
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> from supervision.metrics import Recall
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0]),
+        ...     confidence=np.array([0.9])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> recall_metric = Recall()
+        >>> recall_result = recall_metric.update(predictions, targets).compute()
+        >>> round(float(recall_result.recall_at_50), 2)
+        1.0
+
+        ```
+
+        A class that only ever appears in the predictions (for example a detection
+        on a background image with no ground truth) has no instances to recall, so
+        it is tracked with a recall of `0.0` rather than dropped. This keeps the
+        tracked class set aligned with Precision and F1Score for the same input:
+
+        ```pycon
+        >>> predictions = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10], [100, 0, 110, 10]]),
+        ...     class_id=np.array([0, 1]),  # class 1 has no ground-truth instance
+        ...     confidence=np.array([0.9, 0.8])
+        ... )
+        >>> targets = sv.Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]]),
+        ...     class_id=np.array([0])
+        ... )
+        >>> recall_result = Recall().update(predictions, targets).compute()
+        >>> recall_result.matched_classes.tolist()
+        [0, 1]
+        >>> round(float(recall_result.recall_per_class[0][0]), 2)  # matched class 0
+        1.0
+        >>> round(float(recall_result.recall_per_class[1][0]), 2)  # prediction-only
+        0.0
+
+        ```
+
+    ![example_plot](
+        https://media.roboflow.com/supervision-docs/metrics/recall_plot_example.png
+    ){ align=center width="800" }
+    """
+
+    def __init__(
+        self,
+        metric_target: MetricTarget = MetricTarget.BOXES,
+        averaging_method: AveragingMethod = AveragingMethod.WEIGHTED,
+    ):
+        """
+        Initialize the Recall metric.
+
+        Args:
+            metric_target: The type of detection data to use.
+            averaging_method: The averaging method used to compute the
+                recall. Determines how the recall is aggregated across classes.
+        """
+        self._metric_target = metric_target
+        self.averaging_method = averaging_method
+
+        self._predictions_list: list[Detections] = []
+        self._targets_list: list[Detections] = []
+
+    def reset(self) -> None:
+        """
+        Reset the metric to its initial state, clearing all stored data.
+        """
+        self._predictions_list = []
+        self._targets_list = []
+
+    def update(
+        self,
+        predictions: Detections | list[Detections],
+        targets: Detections | list[Detections],
+    ) -> Recall:
+        """
+        Add new predictions and targets to the metric, but do not compute the result.
+
+        Args:
+            predictions: The predicted detections.
+            targets: The target detections.
+
+        Returns:
+            The updated metric instance.
+        """
+        if not isinstance(predictions, list):
+            predictions = [predictions]
+        if not isinstance(targets, list):
+            targets = [targets]
+
+        if len(predictions) != len(targets):
+            raise ValueError(
+                f"The number of predictions ({len(predictions)}) and"
+                f" targets ({len(targets)}) during the update must be the same."
+            )
+
+        self._predictions_list.extend(predictions)
+        self._targets_list.extend(targets)
+
+        return self
+
+    def compute(self) -> RecallResult:
+        """
+        Calculate the recall metric based on the stored predictions and ground-truth
+        data, at different IoU thresholds.
+
+        Returns:
+            The recall metric result.
+        """
+        result = self._compute(self._predictions_list, self._targets_list)
+        result.small_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.SMALL
+        )
+        result.medium_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.MEDIUM
+        )
+        result.large_objects = self._compute(
+            self._predictions_list, self._targets_list, ObjectSizeCategory.LARGE
+        )
+
+        return result
+
+    def _compute(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory = ObjectSizeCategory.ANY,
+    ) -> RecallResult:
+        iou_thresholds = np.linspace(0.5, 0.95, 10, dtype=np.float32)
+        stats: list[Any] = []
+
+        for predictions, targets in zip(predictions_list, targets_list):
+            prediction_contents = self._detections_content(predictions)
+            target_contents = self._detections_content(targets)
+            prediction_size_mask = np.ones(len(predictions), dtype=bool)
+            target_size_mask = np.ones(len(targets), dtype=bool)
+            if size_category != ObjectSizeCategory.ANY:
+                if len(predictions) > 0:
+                    prediction_size_mask = (
+                        get_detection_size_category(predictions, self._metric_target)
+                        == size_category.value
+                    )
+                if len(targets) > 0:
+                    target_size_mask = (
+                        get_detection_size_category(targets, self._metric_target)
+                        == size_category.value
+                    )
+
+            if len(targets) == 0 and len(predictions) > 0:
+                # Only predictions are present (e.g. a background image). They produce
+                # no false negatives, so no recall value changes, but the classes still
+                # have to be tracked or `matched_classes` silently disagrees with
+                # Precision and F1Score for the same input.
+                if predictions.class_id is None or predictions.confidence is None:
+                    raise ValueError(
+                        "Recall metric requires `class_id` and `confidence` "
+                        "on predictions."
+                    )
+                prediction_class_ids = np.asarray(predictions.class_id, dtype=np.int32)[
+                    prediction_size_mask
+                ]
+                prediction_confidence = np.asarray(
+                    predictions.confidence, dtype=np.float32
+                )[prediction_size_mask]
+                if len(prediction_class_ids) == 0:
+                    continue
+                stats.append(
+                    (
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        np.zeros(
+                            (len(prediction_class_ids), iou_thresholds.size),
+                            dtype=np.bool_,
+                        ),
+                        prediction_confidence,
+                        prediction_class_ids,
+                        np.zeros((0,), dtype=np.int32),
+                    )
+                )
+            elif len(targets) > 0:
+                if predictions.class_id is None or targets.class_id is None:
+                    raise ValueError(
+                        "Recall metric requires `class_id` on both predictions "
+                        "and targets."
+                    )
+                if len(predictions) == 0:
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)[
+                        target_size_mask
+                    ]
+                    if len(target_class_ids) == 0:
+                        continue
+                    stats.append(
+                        (
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0, iou_thresholds.size), dtype=bool),
+                            np.zeros((0,), dtype=np.float32),
+                            np.zeros((0,), dtype=int),
+                            target_class_ids,
+                        )
+                    )
+
+                else:
+                    if predictions.confidence is None:
+                        raise ValueError(
+                            "Recall metric requires `confidence` on predictions."
+                        )
+                    prediction_class_ids = np.asarray(
+                        predictions.class_id, dtype=np.int32
+                    )
+                    target_class_ids = np.asarray(targets.class_id, dtype=np.int32)
+                    prediction_confidence = np.asarray(
+                        predictions.confidence, dtype=np.float32
+                    )
+                    if self._metric_target == MetricTarget.BOXES:
+                        # BOXES target never yields CompactMask; narrow for mypy.
+                        iou = box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    elif self._metric_target == MetricTarget.MASKS:
+                        iou = mask_iou_batch(target_contents, prediction_contents)
+                    elif self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+                        # OBB target never yields CompactMask; narrow for mypy.
+                        iou = oriented_box_iou_batch(
+                            cast(npt.NDArray[np.number], target_contents),
+                            cast(npt.NDArray[np.number], prediction_contents),
+                        )
+                    else:
+                        raise ValueError(
+                            "Unsupported metric target for IoU calculation"
+                        )
+
+                    # None keeps the matcher on its single-round fast path
+                    # when no size bucket is scored.
+                    target_scored_mask = (
+                        target_size_mask
+                        if size_category != ObjectSizeCategory.ANY
+                        else None
+                    )
+                    matches, matched_target_indices = (
+                        _match_detection_batch_with_target_indices(
+                            prediction_class_ids,
+                            target_class_ids,
+                            iou,
+                            iou_thresholds,
+                            target_scored_mask=target_scored_mask,
+                        )
+                    )
+                    ignored_matches = np.zeros_like(matches, dtype=bool)
+                    if size_category != ObjectSizeCategory.ANY:
+                        valid_target_match = matched_target_indices >= 0
+                        matched_scored_target = np.zeros_like(matches, dtype=bool)
+                        if np.any(valid_target_match):
+                            matched_scored_target[valid_target_match] = (
+                                target_size_mask[
+                                    matched_target_indices[valid_target_match]
+                                ]
+                            )
+                        prediction_scored = (
+                            prediction_size_mask[:, None] | matched_scored_target
+                        )
+                        ignored_matches = ~prediction_scored | (
+                            valid_target_match & ~matched_scored_target
+                        )
+                        prediction_keep = np.any(~ignored_matches, axis=1)
+                        matches = (
+                            matches[prediction_keep]
+                            & matched_scored_target[prediction_keep]
+                        )
+                        ignored_matches = ignored_matches[prediction_keep]
+                        prediction_confidence = prediction_confidence[prediction_keep]
+                        prediction_class_ids = prediction_class_ids[prediction_keep]
+                        target_class_ids = target_class_ids[target_size_mask]
+                        if (
+                            len(prediction_class_ids) == 0
+                            and len(target_class_ids) == 0
+                        ):
+                            continue
+                    stats.append(
+                        (
+                            matches,
+                            ignored_matches,
+                            prediction_confidence,
+                            prediction_class_ids,
+                            target_class_ids,
+                        )
+                    )
+
+        if not stats:
+            return RecallResult(
+                metric_target=self._metric_target,
+                averaging_method=self.averaging_method,
+                recall_scores=np.zeros(iou_thresholds.shape[0]),
+                recall_per_class=np.zeros((0, iou_thresholds.shape[0])),
+                iou_thresholds=iou_thresholds,
+                matched_classes=np.array([], dtype=int),
+                small_objects=None,
+                medium_objects=None,
+                large_objects=None,
+            )
+
+        concatenated_stats = [np.concatenate(items, 0) for items in zip(*stats)]
+        recall_scores, recall_per_class, unique_classes = (
+            self._compute_recall_for_classes(*concatenated_stats)
+        )
+
+        return RecallResult(
+            metric_target=self._metric_target,
+            averaging_method=self.averaging_method,
+            recall_scores=recall_scores,
+            recall_per_class=recall_per_class,
+            iou_thresholds=iou_thresholds,
+            matched_classes=unique_classes,
+            small_objects=None,
+            medium_objects=None,
+            large_objects=None,
+        )
+
+    def _compute_recall_for_classes(
+        self,
+        matches: npt.NDArray[np.bool_],
+        ignored_matches: npt.NDArray[np.bool_],
+        prediction_confidence: npt.NDArray[np.float32],
+        prediction_class_ids: npt.NDArray[np.int32],
+        true_class_ids: npt.NDArray[np.int32],
+    ) -> tuple[
+        npt.NDArray[np.float64],
+        npt.NDArray[np.float64],
+        npt.NDArray[np.int32],
+    ]:
+        sorted_indices = np.argsort(-prediction_confidence)
+        matches = matches[sorted_indices]
+        ignored_matches = ignored_matches[sorted_indices]
+        prediction_class_ids = prediction_class_ids[sorted_indices]
+        # Classes that appear only in predictions have no ground-truth instances, so
+        # their recall is 0.0 rather than undefined. Including them keeps the tracked
+        # class set identical to Precision and F1Score and matches sklearn, which infers
+        # labels from the union of y_true and y_pred.
+        true_classes, true_counts = np.unique(true_class_ids, return_counts=True)
+        pred_classes = np.unique(prediction_class_ids)
+        # Dedupe each side first, then union1d the already-unique arrays: this skips
+        # union1d's internal re-sort/re-unique of the full concatenation and measured
+        # ~1.4x faster than np.unique(np.concatenate(...)). Deduping after the union
+        # (or union1d on the raw arrays) yields no speedup.
+        unique_classes = np.union1d(true_classes, pred_classes)
+        class_counts = np.zeros(unique_classes.shape[0], dtype=int)
+        class_counts[np.searchsorted(unique_classes, true_classes)] = true_counts
+
+        # Shape: PxTh,P,C,C -> CxThx3
+        confusion_matrix = self._compute_confusion_matrix(
+            matches, ignored_matches, prediction_class_ids, unique_classes, class_counts
+        )
+
+        # Shape: CxThx3 -> CxTh
+        recall_per_class = self._compute_recall(confusion_matrix)
+
+        # Shape: CxTh -> Th
+        if self.averaging_method == AveragingMethod.MACRO:
+            recall_scores = np.mean(recall_per_class, axis=0)
+        elif self.averaging_method == AveragingMethod.MICRO:
+            confusion_matrix_merged = confusion_matrix.sum(0)
+            recall_scores = self._compute_recall(confusion_matrix_merged)
+        elif self.averaging_method == AveragingMethod.WEIGHTED:
+            class_counts = class_counts.astype(np.float32)
+            if class_counts.sum() == 0:
+                # No ground-truth support (e.g. only false-positive classes, or a
+                # size bucket with predictions but no targets): weighting is
+                # undefined, so report 0 as the empty case did before.
+                recall_scores = np.zeros(recall_per_class.shape[1])
+            else:
+                recall_scores = np.average(
+                    recall_per_class, axis=0, weights=class_counts
+                )
+
+        return recall_scores, recall_per_class, unique_classes
+
+    @staticmethod
+    def _match_detection_batch(
+        predictions_classes: npt.NDArray[np.int32],
+        target_classes: npt.NDArray[np.int32],
+        iou: npt.NDArray[np.float32],
+        iou_thresholds: npt.NDArray[np.float32],
+    ) -> npt.NDArray[np.bool_]:
+        result_correct, _ = _match_detection_batch_with_target_indices(
+            predictions_classes, target_classes, iou, iou_thresholds
+        )
+        return result_correct
+
+    @staticmethod
+    def _compute_confusion_matrix(
+        sorted_matches: npt.NDArray[np.bool_],
+        sorted_ignored_matches: npt.NDArray[np.bool_],
+        sorted_prediction_class_ids: npt.NDArray[np.int32],
+        unique_classes: npt.NDArray[np.integer],
+        class_counts: npt.NDArray[np.integer],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Compute the confusion matrix for each class and IoU threshold.
+
+        Assumes the matches and prediction_class_ids are sorted by confidence
+        in descending order.
+
+        Args:
+            sorted_matches: shape (P, Th), that is True
+                if the prediction is a true positive at the given IoU threshold.
+            sorted_ignored_matches: shape (P, Th), that is True
+                if the prediction should not affect the given IoU threshold.
+            sorted_prediction_class_ids: shape (P,), containing
+                the class id for each prediction.
+            unique_classes: shape (C,), containing the unique
+                class ids.
+            class_counts: shape (C,), containing the number
+                of true instances for each class.
+
+        Returns:
+            shape (C, Th, 3), containing the true positives, false
+                positives, and false negatives for each class and IoU threshold.
+        """
+
+        num_thresholds = sorted_matches.shape[1]
+        num_classes = unique_classes.shape[0]
+
+        confusion_matrix: npt.NDArray[np.float64] = np.zeros(
+            (num_classes, num_thresholds, 3), dtype=np.float64
+        )
+        for class_idx, class_id in enumerate(unique_classes):
+            is_class = sorted_prediction_class_ids == class_id
+            num_true = class_counts[class_idx]
+            num_predictions = is_class.sum()
+
+            if num_predictions == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = np.zeros(num_thresholds)
+                false_negatives = np.full(num_thresholds, num_true)
+            elif num_true == 0:
+                true_positives = np.zeros(num_thresholds)
+                false_positives = (~sorted_ignored_matches[is_class]).sum(0)
+                false_negatives = np.zeros(num_thresholds)
+            else:
+                true_positives = sorted_matches[is_class].sum(0)
+                false_positives = (
+                    ~sorted_matches[is_class] & ~sorted_ignored_matches[is_class]
+                ).sum(0)
+                false_negatives = num_true - true_positives
+            confusion_matrix[class_idx] = np.stack(
+                [true_positives, false_positives, false_negatives], axis=1
+            )
+        result: npt.NDArray[np.float64] = confusion_matrix
+        return result
+
+    @staticmethod
+    def _compute_recall(
+        confusion_matrix: npt.NDArray[np.float64],
+    ) -> npt.NDArray[np.float64]:
+        """
+        Broadcastable function, computing the recall from the confusion matrix.
+
+        Args:
+            confusion_matrix: shape (N, ..., 3), where the last dimension
+                contains the true positives, false positives, and false negatives.
+
+        Returns:
+            shape (N, ...), containing the recall for each element.
+        """
+        if not confusion_matrix.shape[-1] == 3:
+            raise ValueError(
+                f"Confusion matrix must have shape (..., 3), got "
+                f"{confusion_matrix.shape}"
+            )
+        true_positives = confusion_matrix[..., 0]
+        false_negatives = confusion_matrix[..., 2]
+
+        denominator = true_positives + false_negatives
+        recall = np.divide(
+            true_positives,
+            denominator,
+            out=np.zeros_like(true_positives),
+            where=denominator != 0,
+        )
+
+        result_recall: npt.NDArray[np.float64] = recall
+        return result_recall
+
+    def _detections_content(
+        self, detections: Detections
+    ) -> npt.NDArray[Any] | CompactMask:
+        """Return boxes, masks or oriented bounding boxes from detections.
+
+        For the mask target this may return a
+        :class:`~supervision.detection.compact_mask.CompactMask` rather than a
+        dense boolean array when the detections carry compact masks.
+        """
+        if self._metric_target == MetricTarget.BOXES:
+            return cast(npt.NDArray[Any], detections.xyxy)
+        if self._metric_target == MetricTarget.MASKS:
+            if detections.mask is not None:
+                # detections.mask is NDArray[bool] | CompactMask; return as-is.
+                return detections.mask
+            if len(detections) > 0:
+                raise ValueError(
+                    "Recall with `MetricTarget.MASKS` requires detections to "
+                    "include masks."
+                )
+            return self._make_empty_content()
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            obb = detections.data.get(ORIENTED_BOX_COORDINATES)
+            if obb is not None and len(obb) > 0:
+                result_obb: npt.NDArray[np.float32] = np.array(obb, dtype=np.float32)
+                return result_obb
+            return self._make_empty_content()
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _make_empty_content(self) -> npt.NDArray[Any]:
+        if self._metric_target == MetricTarget.BOXES:
+            empty_boxes: npt.NDArray[np.float32] = np.empty((0, 4), dtype=np.float32)
+            return empty_boxes
+
+        if self._metric_target == MetricTarget.MASKS:
+            empty_masks: npt.NDArray[np.bool_] = np.empty((0, 0, 0), dtype=bool)
+            return empty_masks
+
+        if self._metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+            empty_obb: npt.NDArray[np.float32] = np.empty((0, 4, 2), dtype=np.float32)
+            return empty_obb
+
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+        raise ValueError(f"Invalid metric target: {self._metric_target}")
+
+    def _filter_detections_by_size(
+        self, detections: Detections, size_category: ObjectSizeCategory
+    ) -> Detections:
+        """Return a copy of detections with contents filtered by object size."""
+        new_detections = deepcopy(detections)
+        if detections.is_empty() or size_category == ObjectSizeCategory.ANY:
+            return new_detections
+
+        sizes = get_detection_size_category(new_detections, self._metric_target)
+        size_mask = sizes == size_category.value
+
+        new_detections.xyxy = new_detections.xyxy[size_mask]
+        if new_detections.mask is not None:
+            new_detections.mask = new_detections.mask[size_mask]
+        if new_detections.class_id is not None:
+            new_detections.class_id = new_detections.class_id[size_mask]
+        if new_detections.confidence is not None:
+            new_detections.confidence = new_detections.confidence[size_mask]
+        if new_detections.tracker_id is not None:
+            new_detections.tracker_id = new_detections.tracker_id[size_mask]
+        if new_detections.data is not None:
+            for key, value in new_detections.data.items():
+                new_detections.data[key] = np.array(value)[size_mask]
+
+        return new_detections
+
+    def _filter_predictions_and_targets_by_size(
+        self,
+        predictions_list: list[Detections],
+        targets_list: list[Detections],
+        size_category: ObjectSizeCategory,
+    ) -> tuple[list[Detections], list[Detections]]:
+        """
+        Filter predictions and targets by object size category.
+        """
+        new_predictions_list = []
+        new_targets_list = []
+        for predictions, targets in zip(predictions_list, targets_list):
+            new_predictions_list.append(
+                self._filter_detections_by_size(predictions, size_category)
+            )
+            new_targets_list.append(
+                self._filter_detections_by_size(targets, size_category)
+            )
+        return new_predictions_list, new_targets_list
+
+
+@dataclass
+class RecallResult:
+    """
+    The results of the recall metric calculation.
+
+    Defaults to `0` if no detections or targets were provided.
+
+    Attributes:
+        metric_target: the type of data used for the metric -
+            boxes, masks or oriented bounding boxes.
+        averaging_method: the averaging method used to compute the
+            recall. Determines how the recall is aggregated across classes.
+        recall_at_50: the recall at IoU threshold of `0.5`.
+        recall_at_75: the recall at IoU threshold of `0.75`.
+        recall_scores: the recall scores at each IoU threshold.
+            Shape: `(num_iou_thresholds,)`
+        recall_per_class: the recall scores per class and IoU threshold.
+            Shape: `(num_classes, num_iou_thresholds)`
+        iou_thresholds: the IoU thresholds used in the calculations.
+        matched_classes: the class IDs present in either predictions or ground
+            truth. Corresponds to the rows of `recall_per_class`. Classes that
+            appear only in predictions (no ground-truth instances) are included;
+            their per-threshold recall values will be `0.0`.
+        small_objects: the Recall metric results
+            for small objects (area < 32²).
+        medium_objects: the Recall metric results
+            for medium objects (32² ≤ area < 96²).
+        large_objects: the Recall metric results
+            for large objects (area ≥ 96²).
+    """
+
+    metric_target: MetricTarget
+    averaging_method: AveragingMethod
+
+    @property
+    def recall_at_50(self) -> float:
+        return float(self.recall_scores[0])
+
+    @property
+    def recall_at_75(self) -> float:
+        return float(self.recall_scores[5])
+
+    recall_scores: npt.NDArray[np.float64]
+    recall_per_class: npt.NDArray[np.float64]
+    iou_thresholds: npt.NDArray[np.float32]
+    matched_classes: npt.NDArray[np.int32]
+
+    small_objects: RecallResult | None
+    medium_objects: RecallResult | None
+    large_objects: RecallResult | None
+
+    def __str__(self) -> str:
+        """
+        Format as a pretty string.
+
+        Example:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> from supervision.metrics import Recall
+            >>> predictions = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0]),
+            ...     confidence=np.array([0.9])
+            ... )
+            >>> targets = sv.Detections(
+            ...     xyxy=np.array([[0, 0, 10, 10]]),
+            ...     class_id=np.array([0])
+            ... )
+            >>> recall_metric = Recall()
+            >>> recall_result = recall_metric.update(predictions, targets).compute()
+            >>> print(recall_result)  # doctest: +ELLIPSIS
+            RecallResult:
+            Metric target:    MetricTarget.BOXES
+            Averaging method: AveragingMethod.WEIGHTED
+            R @ 50:     1.0000
+            R @ 75:     1.0000
+            R @ thresh: [1. ... 1.]
+            IoU thresh: [0.5  0.55 ... 0.95]
+            Recall per class:
+              0: [1. ... 1.]
+            ...
+            Medium objects:
+              RecallResult:
+              Metric target:    MetricTarget.BOXES
+              Averaging method: AveragingMethod.WEIGHTED
+              R @ 50:     0.0000
+              ...
+
+            ```
+        """
+        out_str = (
+            f"{self.__class__.__name__}:\n"
+            f"Metric target:    {self.metric_target}\n"
+            f"Averaging method: {self.averaging_method}\n"
+            f"R @ 50:     {self.recall_at_50:.4f}\n"
+            f"R @ 75:     {self.recall_at_75:.4f}\n"
+            f"R @ thresh: {self.recall_scores}\n"
+            f"IoU thresh: {self.iou_thresholds}\n"
+            f"Recall per class:\n"
+        )
+        if self.recall_per_class.size == 0:
+            out_str += "  No results\n"
+        for class_id, recall_of_class in zip(
+            self.matched_classes, self.recall_per_class
+        ):
+            out_str += f"  {class_id}: {recall_of_class}\n"
+
+        indent = "  "
+        if self.small_objects is not None:
+            indented = indent + str(self.small_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nSmall objects:\n{indented}"
+        if self.medium_objects is not None:
+            indented = indent + str(self.medium_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nMedium objects:\n{indented}"
+        if self.large_objects is not None:
+            indented = indent + str(self.large_objects).replace("\n", f"\n{indent}")
+            out_str += f"\nLarge objects:\n{indented}"
+
+        return out_str
+
+    def to_pandas(self) -> pd.DataFrame:
+        """
+        Convert the result to a pandas DataFrame.
+
+        Returns:
+            The result as a DataFrame.
+        """
+        ensure_pandas_installed()
+        import pandas as pd
+
+        pandas_data: dict[str, Any] = {
+            "R@50": self.recall_at_50,
+            "R@75": self.recall_at_75,
+        }
+
+        if self.small_objects is not None:
+            small_objects_df = self.small_objects.to_pandas()
+            for key, value in small_objects_df.items():
+                pandas_data[f"small_objects_{key}"] = value
+        if self.medium_objects is not None:
+            medium_objects_df = self.medium_objects.to_pandas()
+            for key, value in medium_objects_df.items():
+                pandas_data[f"medium_objects_{key}"] = value
+        if self.large_objects is not None:
+            large_objects_df = self.large_objects.to_pandas()
+            for key, value in large_objects_df.items():
+                pandas_data[f"large_objects_{key}"] = value
+
+        return pd.DataFrame(pandas_data, index=[0])
+
+    def plot(self) -> None:
+        """
+        Plot the recall results.
+
+        ![example_plot](
+            https://media.roboflow.com/supervision-docs/metrics/recall_plot_example.png
+        ){ align=center width="800" }
+        """
+        from matplotlib import pyplot as plt
+
+        labels = ["Recall@50", "Recall@75"]
+        values = [self.recall_at_50, self.recall_at_75]
+        colors = [LEGACY_COLOR_PALETTE[0]] * 2
+
+        if self.small_objects is not None:
+            small_objects = self.small_objects
+            labels += ["Small: R@50", "Small: R@75"]
+            values += [small_objects.recall_at_50, small_objects.recall_at_75]
+            colors += [LEGACY_COLOR_PALETTE[3]] * 2
+
+        if self.medium_objects is not None:
+            medium_objects = self.medium_objects
+            labels += ["Medium: R@50", "Medium: R@75"]
+            values += [medium_objects.recall_at_50, medium_objects.recall_at_75]
+            colors += [LEGACY_COLOR_PALETTE[2]] * 2
+
+        if self.large_objects is not None:
+            large_objects = self.large_objects
+            labels += ["Large: R@50", "Large: R@75"]
+            values += [large_objects.recall_at_50, large_objects.recall_at_75]
+            colors += [LEGACY_COLOR_PALETTE[4]] * 2
+
+        plt.rcParams["font.family"] = "monospace"
+
+        _, ax = plt.subplots(figsize=(10, 6))
+        ax.set_ylim(0, 1)
+        ax.set_ylabel("Value", fontweight="bold")
+        title = (
+            f"Recall, by Object Size"
+            f"\n(target: {self.metric_target.value},"
+            f" averaging: {self.averaging_method.value})"
+        )
+        ax.set_title(title, fontweight="bold")
+
+        x_positions = range(len(labels))
+        bars = ax.bar(x_positions, values, color=colors, align="center")
+
+        ax.set_xticks(x_positions)
+        ax.set_xticklabels(labels, rotation=45, ha="right")
+
+        for bar in bars:
+            y_value = bar.get_height()
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                y_value + 0.02,
+                f"{y_value:.2f}",
+                ha="center",
+                va="bottom",
+            )
+
+        plt.rcParams["font.family"] = "sans-serif"
+
+        plt.tight_layout()
+        plt.show()
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__init__.py b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f7f9c9ae8c96836e9c0581a9e406866d7c15108
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/matching.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/matching.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..891874ce58189a31ae1a2e6a394c4f267c52a617
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/matching.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/object_size.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/object_size.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..37573b9d6252eb4fd6fb7c9f16c21157deeff1ef
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/object_size.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..231e722c319dfd0b7109a426b8e829895c615c66
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/matching.py b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..394cb1e3b923752a0f0f16d14200f0078ce4e94f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/matching.py
@@ -0,0 +1,96 @@
+from collections.abc import Iterator
+
+import numpy as np
+import numpy.typing as npt
+
+
+def _greedy_match(
+    iou: npt.NDArray[np.float32],
+    matched_indices: tuple[npt.NDArray[np.intp], ...],
+) -> Iterator[tuple[int, int]]:
+    """Yield (target_idx, pred_idx) pairs in greedy highest-IoU-first one-to-one order.
+
+    Candidate pairs are sorted by descending IoU and assigned one-to-one: a pair
+    is accepted only when neither the target nor the prediction has been matched.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> iou = np.array([[1.0, 0.667], [0.333, 0.538]], dtype=np.float32)
+        >>> matched_indices = np.where(iou >= 0.5)
+        >>> list(_greedy_match(iou, matched_indices))
+        [(0, 0), (1, 1)]
+
+        ```
+    """
+    target_idx = matched_indices[0]
+    pred_idx = matched_indices[1]
+    iou_values = iou[matched_indices]
+    order = np.argsort(-iou_values, kind="stable")
+    matched_targets: set[int] = set()
+    matched_preds: set[int] = set()
+    for t, p in zip(target_idx[order].tolist(), pred_idx[order].tolist()):
+        if t not in matched_targets and p not in matched_preds:
+            matched_targets.add(t)
+            matched_preds.add(p)
+            yield t, p
+
+
+def _match_detection_batch_with_target_indices(
+    predictions_classes: npt.NDArray[np.int32],
+    target_classes: npt.NDArray[np.int32],
+    iou: npt.NDArray[np.float32],
+    iou_thresholds: npt.NDArray[np.float32],
+    target_scored_mask: npt.NDArray[np.bool_] | None = None,
+) -> tuple[npt.NDArray[np.bool_], npt.NDArray[np.int32]]:
+    """Match predictions to targets and retain target indices per IoU threshold.
+
+    When ``target_scored_mask`` is provided, scored targets are matched first and
+    only predictions left unmatched may then match unscored (ignored) targets.
+    This mirrors COCO evaluation, where detections prefer non-ignored ground
+    truth, so an out-of-bucket target can never steal a prediction from an
+    in-bucket one.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> predictions_classes = np.array([0], dtype=np.int32)
+        >>> target_classes = np.array([0], dtype=np.int32)
+        >>> iou = np.array([[1.0]], dtype=np.float32)
+        >>> thresholds = np.array([0.5], dtype=np.float32)
+        >>> correct, matched = _match_detection_batch_with_target_indices(
+        ...     predictions_classes,
+        ...     target_classes,
+        ...     iou,
+        ...     thresholds,
+        ... )
+        >>> correct.tolist(), matched.tolist()
+        ([[True]], [[0]])
+
+        ```
+    """
+    num_predictions = predictions_classes.shape[0]
+    num_iou_levels = iou_thresholds.shape[0]
+    correct = np.zeros((num_predictions, num_iou_levels), dtype=bool)
+    matched_targets = np.full((num_predictions, num_iou_levels), -1, dtype=np.int32)
+    correct_class = target_classes[:, None] == predictions_classes
+
+    for i, iou_level in enumerate(iou_thresholds):
+        candidate_pairs = (iou >= iou_level) & correct_class
+        if target_scored_mask is None:
+            match_rounds = [candidate_pairs]
+        else:
+            match_rounds = [
+                candidate_pairs & target_scored_mask[:, None],
+                candidate_pairs & ~target_scored_mask[:, None],
+            ]
+
+        for round_pairs in match_rounds:
+            unmatched_predictions = matched_targets[:, i] < 0
+            matched_indices = np.where(round_pairs & unmatched_predictions)
+
+            for target_idx, prediction_idx in _greedy_match(iou, matched_indices):
+                correct[prediction_idx, i] = True
+                matched_targets[prediction_idx, i] = target_idx
+
+    return correct, matched_targets
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/object_size.py b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/object_size.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9b7bb2a9f981f172da6cb9b7d2e683dd01ba362
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/object_size.py
@@ -0,0 +1,322 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import TYPE_CHECKING, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.config import AREA_DATA_FIELD, ORIENTED_BOX_COORDINATES
+from supervision.detection.compact_mask import CompactMask
+from supervision.detection.utils.masks import count_mask_pixels
+from supervision.metrics.core import MetricTarget
+
+if TYPE_CHECKING:
+    from supervision.detection.core import Detections
+
+SIZE_THRESHOLDS = (32**2, 96**2)
+
+
+class ObjectSizeCategory(Enum):
+    """
+    Enum for object size categories based on area in pixels.
+
+    Small: area < 32^2
+    Medium: 32^2 <= area < 96^2
+    Large: area >= 96^2
+
+    Example:
+        ```pycon
+        >>> from supervision.metrics.utils.object_size import ObjectSizeCategory
+        >>> ObjectSizeCategory.SMALL.value
+        1
+        >>> ObjectSizeCategory.MEDIUM.value
+        2
+        >>> ObjectSizeCategory.LARGE.value
+        3
+
+        ```
+    """
+
+    ANY = -1
+    SMALL = 1
+    MEDIUM = 2
+    LARGE = 3
+
+
+def get_object_size_category(
+    data: npt.NDArray[np.number] | npt.NDArray[np.bool_],
+    metric_target: MetricTarget,
+) -> npt.NDArray[np.int_]:
+    """
+    Get the size category of an object. Distinguish based on the metric target.
+
+    Args:
+        data: The object data, shaped (N, ...).
+        metric_target: Determines whether boxes, masks or
+            oriented bounding boxes are used.
+
+    Returns:
+        The size category of each object, matching
+        the enum values of ObjectSizeCategory. Shaped (N,).
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.metrics.core import MetricTarget
+        >>> from supervision.metrics.utils.object_size import get_object_size_category
+        >>> xyxy = np.array([
+        ...     [0, 0, 10, 10],    # 100 (Small)
+        ...     [0, 0, 50, 50],    # 2500 (Medium)
+        ...     [0, 0, 100, 100]   # 10000 (Large)
+        ... ])
+        >>> get_object_size_category(xyxy, MetricTarget.BOXES)
+        array([1, 2, 3])
+
+        ```
+    """
+    if metric_target == MetricTarget.BOXES:
+        bbox_data = cast(npt.NDArray[np.number], data)
+        return get_bbox_size_category(bbox_data)
+    if metric_target == MetricTarget.MASKS:
+        mask_data = cast(npt.NDArray[np.bool_], data)
+        return get_mask_size_category(mask_data)
+    if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+        obb_data = cast(npt.NDArray[np.number], data)
+        return get_obb_size_category(obb_data)
+    raise ValueError("Invalid metric type")
+
+
+def get_bbox_size_category(xyxy: npt.NDArray[np.number]) -> npt.NDArray[np.int_]:
+    """
+    Get the size category of a bounding boxes array.
+
+    Args:
+        xyxy: The bounding boxes array shaped (N, 4).
+
+    Returns:
+        The size category of each bounding box, matching
+        the enum values of ObjectSizeCategory. Shaped (N,).
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.metrics.utils.object_size import get_bbox_size_category
+        >>> xyxy = np.array([
+        ...     [0, 0, 31, 31],    # 961 (Small)
+        ...     [0, 0, 32, 32],    # 1024 (Medium)
+        ...     [0, 0, 95, 95],    # 9025 (Medium)
+        ...     [0, 0, 96, 96]     # 9216 (Large)
+        ... ])
+        >>> get_bbox_size_category(xyxy)
+        array([1, 2, 2, 3])
+
+        ```
+    """
+    if len(xyxy.shape) != 2 or xyxy.shape[1] != 4:
+        raise ValueError("Bounding boxes must be shaped (N, 4)")
+
+    width = xyxy[:, 2] - xyxy[:, 0]
+    height = xyxy[:, 3] - xyxy[:, 1]
+    areas = width * height
+
+    result = np.full(areas.shape, ObjectSizeCategory.ANY.value)
+    SM, LG = SIZE_THRESHOLDS
+    result[areas < SM] = ObjectSizeCategory.SMALL.value
+    result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value
+    result[areas >= LG] = ObjectSizeCategory.LARGE.value
+    return result
+
+
+def get_area_size_category(
+    areas: npt.NDArray[np.number],
+) -> npt.NDArray[np.int_]:
+    """Get object size categories from per-detection pixel areas.
+
+    Args:
+        areas: One-dimensional pixel areas shaped (N,).
+
+    Returns:
+        The size category of each area, matching the enum values of
+        `ObjectSizeCategory`. Shaped (N,).
+
+    Raises:
+        ValueError: If `areas` is not one-dimensional.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.metrics.utils.object_size import get_area_size_category
+        >>> get_area_size_category(np.array([100, 2500, 10000]))
+        array([1, 2, 3])
+
+        ```
+    """
+    if len(areas.shape) != 1:
+        raise ValueError("Areas must be shaped (N,)")
+
+    result = np.full(areas.shape, ObjectSizeCategory.ANY.value)
+    sm, lg = SIZE_THRESHOLDS
+    result[areas < sm] = ObjectSizeCategory.SMALL.value
+    result[(areas >= sm) & (areas < lg)] = ObjectSizeCategory.MEDIUM.value
+    result[areas >= lg] = ObjectSizeCategory.LARGE.value
+    return result
+
+
+def get_mask_size_category(
+    mask: npt.NDArray[np.bool_] | CompactMask,
+) -> npt.NDArray[np.int_]:
+    """
+    Get the size category of detection masks.
+
+    Args:
+        mask: The mask array shaped (N, H, W), or a
+            :class:`~supervision.detection.compact_mask.CompactMask`.
+
+    Returns:
+        The size category of each mask, matching
+        the enum values of ObjectSizeCategory. Shaped (N,).
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.metrics.utils.object_size import get_mask_size_category
+        >>> mask = np.zeros((3, 100, 100), dtype=bool)
+        >>> mask[0, 0:10, 0:10] = True   # 100 (Small)
+        >>> mask[1, 0:50, 0:50] = True   # 2500 (Medium)
+        >>> mask[2, 0:100, 0:100] = True # 10000 (Large)
+        >>> get_mask_size_category(mask)
+        array([1, 2, 3])
+
+        ```
+    """
+    if isinstance(mask, CompactMask):
+        areas = mask.area
+    else:
+        if len(mask.shape) != 3:
+            raise ValueError("Masks must be shaped (N, H, W)")
+        # count_mask_pixels uses np.count_nonzero (no axis), which dispatches
+        # to SIMD popcount over the bool buffer and is ~6x faster than the
+        # vectorized np.sum(mask, axis=(1, 2)). Do not "simplify" back to
+        # np.sum(axis=(1,2)); benchmark before reverting. dtype=np.int64 keeps
+        # areas consistent across platforms (Windows NumPy defaults to int32).
+        areas = count_mask_pixels(mask)
+
+    result = np.full(areas.shape, ObjectSizeCategory.ANY.value)
+    SM, LG = SIZE_THRESHOLDS
+    result[areas < SM] = ObjectSizeCategory.SMALL.value
+    result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value
+    result[areas >= LG] = ObjectSizeCategory.LARGE.value
+    return result
+
+
+def get_obb_size_category(xyxyxyxy: npt.NDArray[np.number]) -> npt.NDArray[np.int_]:
+    """
+    Get the size category of a oriented bounding boxes array.
+
+    Args:
+        xyxyxyxy: The bounding boxes array shaped (N, 4, 2).
+
+    Returns:
+        The size category of each bounding box, matching
+        the enum values of ObjectSizeCategory. Shaped (N,).
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.metrics.utils.object_size import get_obb_size_category
+        >>> obb = np.array([
+        ...     [[0, 0], [10, 0], [10, 10], [0, 10]],   # 100 (Small)
+        ...     [[0, 0], [50, 0], [50, 50], [0, 50]],   # 2500 (Medium)
+        ...     [[0, 0], [100, 0], [100, 100], [0, 100]] # 10000 (Large)
+        ... ])
+        >>> get_obb_size_category(obb)
+        array([1, 2, 3])
+
+        ```
+    """
+    if len(xyxyxyxy.shape) != 3 or xyxyxyxy.shape[1] != 4 or xyxyxyxy.shape[2] != 2:
+        raise ValueError("Oriented bounding boxes must be shaped (N, 4, 2)")
+
+    # Shoelace formula
+    x = xyxyxyxy[:, :, 0]
+    y = xyxyxyxy[:, :, 1]
+    x1, x2, x3, x4 = x.T
+    y1, y2, y3, y4 = y.T
+    areas = 0.5 * np.abs(
+        (x1 * y2 + x2 * y3 + x3 * y4 + x4 * y1)
+        - (x2 * y1 + x3 * y2 + x4 * y3 + x1 * y4)
+    )
+
+    result = np.full(areas.shape, ObjectSizeCategory.ANY.value)
+    SM, LG = SIZE_THRESHOLDS
+    result[areas < SM] = ObjectSizeCategory.SMALL.value
+    result[(areas >= SM) & (areas < LG)] = ObjectSizeCategory.MEDIUM.value
+    result[areas >= LG] = ObjectSizeCategory.LARGE.value
+    return result
+
+
+def get_detection_size_category(
+    detections: Detections, metric_target: MetricTarget = MetricTarget.BOXES
+) -> npt.NDArray[np.int_]:
+    """Get the size category of each detection.
+
+    Explicit area metadata takes precedence for every metric target, matching
+    COCO-style evaluation. Geometry, mask, or oriented-box content remains the
+    fallback when area metadata is absent.
+
+    Args:
+        detections: The detections object.
+        metric_target: Determines whether boxes, masks or
+            oriented bounding boxes are used.
+
+    Returns:
+        The size category of each bounding box, matching
+        the enum values of ObjectSizeCategory. Shaped (N,).
+
+    Raises:
+        ValueError: If area metadata is not one-dimensional or is not aligned
+            with the detections.
+
+    Example:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.config import AREA_DATA_FIELD
+        >>> from supervision.detection.core import Detections
+        >>> detections = Detections(
+        ...     xyxy=np.array([[0, 0, 10, 10]], dtype=np.float32),
+        ...     data={AREA_DATA_FIELD: np.array([2500.0])},
+        ... )
+        >>> get_detection_size_category(detections)
+        array([2])
+
+        ```
+    """
+    area_data = detections.data.get(AREA_DATA_FIELD)
+    if area_data is not None:
+        areas = np.asarray(area_data, dtype=np.float64)
+        if len(areas.shape) != 1 or len(areas) != len(detections):
+            raise ValueError(
+                "Detection area metadata must be shaped (N,) and aligned "
+                "with detections"
+            )
+        return get_area_size_category(areas)
+
+    if metric_target == MetricTarget.BOXES:
+        return get_bbox_size_category(detections.xyxy)
+    if metric_target == MetricTarget.MASKS:
+        mask = detections.mask
+        if mask is None:
+            raise ValueError("Detections mask is not available")
+        return get_mask_size_category(mask)
+    if metric_target == MetricTarget.ORIENTED_BOUNDING_BOXES:
+        oriented_box_coordinates = detections.data.get(ORIENTED_BOX_COORDINATES)
+        if oriented_box_coordinates is None:
+            raise ValueError("Detections oriented bounding boxes are not available")
+        return get_obb_size_category(
+            cast(
+                npt.NDArray[np.number],
+                np.asarray(oriented_box_coordinates, dtype=np.float32),
+            )
+        )
+    raise ValueError("Invalid metric type")
diff --git a/.venv/lib/python3.12/site-packages/supervision/metrics/utils/utils.py b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..a108279ead8a20e10b40bf576f713e48e294e3cf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/metrics/utils/utils.py
@@ -0,0 +1,9 @@
+def ensure_pandas_installed() -> None:
+    try:
+        import pandas  # noqa
+    except ImportError:
+        raise ImportError(
+            "`metrics` extra is required to run the function."
+            " Run `uv pip install 'supervision[metrics]'` or"
+            " `uv add supervision --extra metrics`."
+        )
diff --git a/.venv/lib/python3.12/site-packages/supervision/py.typed b/.venv/lib/python3.12/site-packages/supervision/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/__init__.py b/.venv/lib/python3.12/site-packages/supervision/tracker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3aa57aa32e8ccc30a39d198bdffa577ba7915634
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/__init__.py
@@ -0,0 +1,5 @@
+"""Deprecated tracker compatibility exports."""
+
+from supervision.tracker.byte_tracker.core import ByteTrack
+
+__all__ = ["ByteTrack"]
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ff8de49c7ee769cb7e13a8aad07c408c9766538
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__init__.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc8f645c60d46bc045876addf39d408aa3fcc395
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cab9a57d984f7db25d80ec1ea04d864250dc8911
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/kalman_filter.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/kalman_filter.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8242869324e055f65588932f5474b9c23e4e0374
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/kalman_filter.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/matching.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/matching.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0c2c621fc2d54539862d9943703be6347427fbc0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/matching.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/single_object_track.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/single_object_track.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19957d3ed595534745e18a4b27a218b4b6104a93
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/single_object_track.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/utils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/utils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..510becffc502c1cc52167e6bd2bf5917f90efc56
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/__pycache__/utils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/core.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..35363e5f55edeaa0fd491841a7ce79819ee51e2b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/core.py
@@ -0,0 +1,417 @@
+import numpy as np
+import numpy.typing as npt
+from deprecate import (  # type: ignore[import-untyped,unused-ignore]
+    TargetMode,
+    deprecated_class,
+)
+
+from supervision.detection.core import Detections
+from supervision.detection.utils.iou_and_nms import box_iou_batch
+from supervision.tracker.byte_tracker import matching
+from supervision.tracker.byte_tracker.kalman_filter import KalmanFilter
+from supervision.tracker.byte_tracker.single_object_track import STrack, TrackState
+from supervision.tracker.byte_tracker.utils import IdCounter
+
+
+def _valid_tracking_tensors(
+    tensors: npt.NDArray[np.float32],
+) -> npt.NDArray[np.bool_]:
+    """Identify finite tensors with positive-width and positive-height boxes."""
+    bboxes = tensors[:, :4]
+    widths = bboxes[:, 2] - bboxes[:, 0]
+    heights = bboxes[:, 3] - bboxes[:, 1]
+    return np.isfinite(tensors).all(axis=1) & (widths > 0) & (heights > 0)
+
+
+@deprecated_class(
+    target=TargetMode.NOTIFY,
+    deprecated_in="0.28.0",
+    remove_in="0.31.0",
+)
+class ByteTrack:
+    """
+    Initialize the ByteTrack object.
+
+    !!! deprecated "Deprecated"
+
+        `ByteTrack` is deprecated since `supervision-0.28.0` and will be removed in
+        `supervision-0.31.0`. Use `ByteTrackTracker` from the `trackers` package
+        instead (`pip install trackers`). Note: the update method is renamed from
+        `update_with_detections()` to `update()`.
+
+    
+
+    Args:
+        track_activation_threshold: Detection confidence threshold
+            for track activation. Increasing track_activation_threshold improves accuracy
+            and stability but might miss true detections. Decreasing it increases
+            completeness but risks introducing noise and instability.
+        lost_track_buffer: Number of frames to buffer when a track is lost.
+            Increasing lost_track_buffer enhances occlusion handling, significantly
+            reducing the likelihood of track fragmentation or disappearance caused
+            by brief detection gaps.
+        minimum_matching_threshold: Threshold for matching tracks with detections.
+            Decreasing minimum_matching_threshold improves accuracy but risks fragmentation.
+            Increasing it improves completeness but risks false positives and drift.
+        frame_rate: The frame rate of the video. Accepts float values (e.g. 23.976,
+            29.97) for accurate lost-track-buffer calculation.
+        minimum_consecutive_frames: Number of consecutive frames that an object must
+            be tracked before it is considered a 'valid' track.
+            Increasing minimum_consecutive_frames prevents the creation of accidental tracks from
+            false detection or double detection, but risks missing shorter tracks.
+    """  # noqa: E501 // docs
+
+    def __init__(
+        self,
+        track_activation_threshold: float = 0.25,
+        lost_track_buffer: int = 30,
+        minimum_matching_threshold: float = 0.8,
+        frame_rate: float = 30,
+        minimum_consecutive_frames: int = 1,
+    ) -> None:
+        self.track_activation_threshold = track_activation_threshold
+        self.minimum_matching_threshold = minimum_matching_threshold
+
+        self.frame_id = 0
+        self.det_thresh = self.track_activation_threshold + 0.1
+        if self.det_thresh > 1.0:
+            self.det_thresh = self.track_activation_threshold
+        self.max_time_lost = int(frame_rate / 30.0 * lost_track_buffer)
+        self.minimum_consecutive_frames = minimum_consecutive_frames
+        self.kalman_filter = KalmanFilter()
+        self.shared_kalman = KalmanFilter()
+
+        self.tracked_tracks: list[STrack] = []
+        self.lost_tracks: list[STrack] = []
+        self.removed_tracks: list[STrack] = []
+
+        # Warning, possible bug: If you also set internal_id to start at 1,
+        # all traces will be connected across objects.
+        self.internal_id_counter = IdCounter()
+        self.external_id_counter = IdCounter(start_id=1)
+
+    def update_with_detections(self, detections: Detections) -> Detections:
+        """
+        Updates the tracker with the provided detections and returns the updated
+        detection results.
+
+        Args:
+            detections: The detections to pass through the tracker.
+
+        Example:
+            ```python
+            import supervision as sv
+            from rfdetr import RFDETRMedium
+
+            model = RFDETRMedium()
+            tracker = sv.ByteTrack()
+
+            box_annotator = sv.BoxAnnotator()
+            label_annotator = sv.LabelAnnotator()
+
+            def callback(frame: np.ndarray, index: int) -> np.ndarray:
+                detections = model.predict(frame[:, :, ::-1])
+                detections = tracker.update_with_detections(detections)
+
+                labels = [f"#{tracker_id}" for tracker_id in detections.tracker_id]
+
+                annotated_frame = box_annotator.annotate(
+                    scene=frame.copy(), detections=detections)
+                annotated_frame = label_annotator.annotate(
+                    scene=annotated_frame, detections=detections, labels=labels)
+                return annotated_frame
+
+            sv.process_video(
+                source_path="",
+                target_path="",
+                callback=callback
+            )
+            ```
+        """
+        if detections.confidence is None:
+            raise ValueError("Detections confidence must be provided for tracking.")
+
+        tensors = np.hstack(
+            (
+                detections.xyxy,
+                detections.confidence[:, np.newaxis],
+            )
+        )
+        tracks = self.update_with_tensors(tensors=tensors)
+
+        if len(tracks) > 0:
+            detection_bounding_boxes = np.asarray([det[:4] for det in tensors])
+            track_bounding_boxes = np.asarray([track.tlbr for track in tracks])
+
+            ious = box_iou_batch(detection_bounding_boxes, track_bounding_boxes)
+
+            iou_costs: npt.NDArray[np.float32] = 1 - ious
+
+            matches, _, _ = matching.linear_assignment(iou_costs, 0.5)
+            tracked_detections = detections.select(slice(None))
+            tracked_detections.tracker_id = np.full(len(detections), -1, dtype=int)
+            for i_detection, i_track in matches:
+                tracked_detections.tracker_id[i_detection] = int(
+                    tracks[i_track].external_track_id
+                )
+
+            return tracked_detections.select(tracked_detections.tracker_id != -1)
+
+        else:
+            detections = Detections.empty()
+            detections.tracker_id = np.array([], dtype=int)
+
+            return detections
+
+    def reset(self) -> None:
+        """
+        Resets the internal state of the ByteTrack tracker.
+
+        This method clears the tracking data, including tracked, lost,
+        and removed tracks, as well as resetting the frame counter. It's
+        particularly useful when processing multiple videos sequentially,
+        ensuring the tracker starts with a clean state for each new video.
+        """
+        self.frame_id = 0
+        self.internal_id_counter.reset()
+        self.external_id_counter.reset()
+        self.tracked_tracks = []
+        self.lost_tracks = []
+        self.removed_tracks = []
+
+    def update_with_tensors(self, tensors: npt.NDArray[np.float32]) -> list[STrack]:
+        """
+        Updates the tracker with the provided tensors and returns the updated tracks.
+
+        Args:
+            tensors: The new tensors to update with.
+
+        Returns:
+            Updated tracks.
+        """
+        self.frame_id += 1
+        activated_starcks = []
+        refind_stracks = []
+        lost_stracks = []
+        removed_stracks = []
+
+        tensors = tensors[_valid_tracking_tensors(tensors)]
+        scores = tensors[:, 4]
+        bboxes = tensors[:, :4]
+
+        remain_inds = scores >= self.track_activation_threshold
+        inds_low = scores > 0.1
+        inds_high = scores < self.track_activation_threshold
+
+        inds_second = np.logical_and(inds_low, inds_high)
+        dets_second = bboxes[inds_second]
+        dets = bboxes[remain_inds]
+        scores_keep = scores[remain_inds]
+        scores_second = scores[inds_second]
+
+        if len(dets) > 0:
+            """Detections"""
+            detections = [
+                STrack(
+                    STrack.tlbr_to_tlwh(tlbr),
+                    score_keep,
+                    self.minimum_consecutive_frames,
+                    self.shared_kalman,
+                    self.internal_id_counter,
+                    self.external_id_counter,
+                )
+                for (tlbr, score_keep) in zip(dets, scores_keep)
+            ]
+        else:
+            detections = []
+
+        """ Add newly detected tracklets to tracked_stracks"""
+        unconfirmed = []
+        tracked_stracks: list[STrack] = []
+
+        for track in self.tracked_tracks:
+            if not track.is_activated:
+                unconfirmed.append(track)
+            else:
+                tracked_stracks.append(track)
+
+        """ Step 2: First association, with high score detection boxes"""
+        strack_pool = joint_tracks(tracked_stracks, self.lost_tracks)
+        # Predict the current location with KF
+        STrack.multi_predict(strack_pool, self.shared_kalman)
+        dists = matching.iou_distance(strack_pool, detections)
+
+        dists = matching.fuse_score(dists, detections)
+        matches, u_track, u_detection = matching.linear_assignment(
+            dists, thresh=self.minimum_matching_threshold
+        )
+
+        for itracked, idet in matches:
+            track = strack_pool[itracked]
+            det = detections[idet]
+            if track.state == TrackState.Tracked:
+                track.update(detections[idet], self.frame_id)
+                activated_starcks.append(track)
+            else:
+                track.re_activate(det, self.frame_id)
+                refind_stracks.append(track)
+
+        """ Step 3: Second association, with low score detection boxes"""
+        # association the untrack to the low score detections
+        if len(dets_second) > 0:
+            """Detections"""
+            detections_second = [
+                STrack(
+                    STrack.tlbr_to_tlwh(tlbr),
+                    score_second,
+                    self.minimum_consecutive_frames,
+                    self.shared_kalman,
+                    self.internal_id_counter,
+                    self.external_id_counter,
+                )
+                for (tlbr, score_second) in zip(dets_second, scores_second)
+            ]
+        else:
+            detections_second = []
+        r_tracked_stracks = [
+            strack_pool[i]
+            for i in u_track
+            if strack_pool[i].state == TrackState.Tracked
+        ]
+        dists = matching.iou_distance(r_tracked_stracks, detections_second)
+        matches, u_track, _u_detection_second = matching.linear_assignment(
+            dists, thresh=0.5
+        )
+        for itracked, idet in matches:
+            track = r_tracked_stracks[itracked]
+            det = detections_second[idet]
+            if track.state == TrackState.Tracked:
+                track.update(det, self.frame_id)
+                activated_starcks.append(track)
+            else:
+                track.re_activate(det, self.frame_id)
+                refind_stracks.append(track)
+
+        for it in u_track:
+            track = r_tracked_stracks[it]
+            if not track.state == TrackState.Lost:
+                track.state = TrackState.Lost
+                lost_stracks.append(track)
+
+        """Deal with unconfirmed tracks, usually tracks with only one beginning frame"""
+        detections = [detections[i] for i in u_detection]
+        dists = matching.iou_distance(unconfirmed, detections)
+
+        dists = matching.fuse_score(dists, detections)
+        matches, u_unconfirmed, u_detection = matching.linear_assignment(
+            dists, thresh=0.7
+        )
+        for itracked, idet in matches:
+            unconfirmed[itracked].update(detections[idet], self.frame_id)
+            activated_starcks.append(unconfirmed[itracked])
+        for it in u_unconfirmed:
+            track = unconfirmed[it]
+            track.state = TrackState.Removed
+            removed_stracks.append(track)
+
+        """ Step 4: Init new stracks"""
+        for inew in u_detection:
+            track = detections[inew]
+            if track.score < self.det_thresh:
+                continue
+            track.activate(self.kalman_filter, self.frame_id)
+            activated_starcks.append(track)
+        """ Step 5: Update state"""
+        for track in self.lost_tracks:
+            if self.frame_id - track.frame_id > self.max_time_lost:
+                track.state = TrackState.Removed
+                removed_stracks.append(track)
+
+        self.tracked_tracks = [
+            t for t in self.tracked_tracks if t.state == TrackState.Tracked
+        ]
+        self.tracked_tracks = joint_tracks(self.tracked_tracks, activated_starcks)
+        self.tracked_tracks = joint_tracks(self.tracked_tracks, refind_stracks)
+        self.lost_tracks = sub_tracks(self.lost_tracks, self.tracked_tracks)
+        self.lost_tracks.extend(lost_stracks)
+        self.lost_tracks = sub_tracks(self.lost_tracks, self.removed_tracks)
+        self.removed_tracks = removed_stracks
+        self.tracked_tracks, self.lost_tracks = remove_duplicate_tracks(
+            self.tracked_tracks, self.lost_tracks
+        )
+        output_stracks = [track for track in self.tracked_tracks if track.is_activated]
+
+        return output_stracks
+
+
+def joint_tracks(
+    track_list_a: list[STrack], track_list_b: list[STrack]
+) -> list[STrack]:
+    """
+    Joins two lists of tracks, ensuring that the resulting list does not
+    contain tracks with duplicate internal_track_id values.
+
+    Args:
+        track_list_a: First list of tracks.
+        track_list_b: Second list of tracks.
+
+    Returns:
+        Combined list of tracks from track_list_a and track_list_b
+            without duplicate internal_track_id values.
+    """
+    seen_track_ids = set()
+    result = []
+
+    for track in track_list_a + track_list_b:
+        if track.internal_track_id not in seen_track_ids:
+            seen_track_ids.add(track.internal_track_id)
+            result.append(track)
+
+    return result
+
+
+def sub_tracks(track_list_a: list[STrack], track_list_b: list[STrack]) -> list[STrack]:
+    """
+    Returns a list of tracks from track_list_a after removing any tracks
+    that share the same internal_track_id with tracks in track_list_b.
+
+    Args:
+        track_list_a: List of tracks.
+        track_list_b: List of tracks to be subtracted from track_list_a.
+    Returns:
+        List of remaining tracks from track_list_a after subtraction.
+    """
+    tracks = {track.internal_track_id: track for track in track_list_a}
+    track_ids_b = {track.internal_track_id for track in track_list_b}
+
+    for track_id in track_ids_b:
+        tracks.pop(track_id, None)
+
+    return list(tracks.values())
+
+
+def remove_duplicate_tracks(
+    tracks_a: list[STrack], tracks_b: list[STrack]
+) -> tuple[list[STrack], list[STrack]]:
+    pairwise_distance = matching.iou_distance(tracks_a, tracks_b)
+    matching_pairs = np.where(pairwise_distance < 0.05)
+
+    duplicates_a, duplicates_b = set(), set()
+    for track_index_a, track_index_b in zip(*matching_pairs):
+        time_a = tracks_a[track_index_a].frame_id - tracks_a[track_index_a].start_frame
+        time_b = tracks_b[track_index_b].frame_id - tracks_b[track_index_b].start_frame
+        if time_a > time_b:
+            duplicates_b.add(track_index_b)
+        else:
+            duplicates_a.add(track_index_a)
+
+    result_a = [
+        track for index, track in enumerate(tracks_a) if index not in duplicates_a
+    ]
+    result_b = [
+        track for index, track in enumerate(tracks_b) if index not in duplicates_b
+    ]
+
+    return result_a, result_b
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/kalman_filter.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/kalman_filter.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d5cbeb936d4daabb76b2734505e398bd817120f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/kalman_filter.py
@@ -0,0 +1,191 @@
+import numpy as np
+import numpy.typing as npt
+import scipy.linalg
+
+
+class KalmanFilter:
+    """
+    A simple Kalman filter for tracking bounding boxes in image space.
+
+    The 8-dimensional state space is (x, y, a, h, vx, vy, va, vh), where
+    (x, y) is the bounding box center, a is the aspect ratio (w/h), h is
+    the height, and their respective velocities.
+
+    Object motion follows a constant velocity model. The bounding box location
+    (x, y, a, h) is taken as direct observation of the state space (linear
+    observation model).
+    """
+
+    def __init__(self) -> None:
+        ndim, dt = 4, 1.0
+
+        self._motion_mat: npt.NDArray[np.float64] = np.eye(2 * ndim, 2 * ndim)
+        for i in range(ndim):
+            self._motion_mat[i, ndim + i] = dt
+        self._update_mat: npt.NDArray[np.float64] = np.eye(ndim, 2 * ndim)
+
+        self._std_weight_position: float = 1.0 / 20
+        self._std_weight_velocity: float = 1.0 / 160
+
+    def initiate(
+        self, measurement: npt.NDArray[np.float32]
+    ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]:
+        """
+        Create track from unassociated measurement.
+
+        Args:
+            measurement: The initial measurement vector.
+
+        Returns:
+            The mean vector and covariance matrix of the new track.
+        """
+        mean_pos = measurement
+        mean_vel = np.zeros_like(mean_pos)
+        mean = np.r_[mean_pos, mean_vel]
+
+        std = [
+            2 * self._std_weight_position * measurement[3],
+            2 * self._std_weight_position * measurement[3],
+            1e-2,
+            2 * self._std_weight_position * measurement[3],
+            10 * self._std_weight_velocity * measurement[3],
+            10 * self._std_weight_velocity * measurement[3],
+            1e-5,
+            10 * self._std_weight_velocity * measurement[3],
+        ]
+        covariance = np.diag(np.square(std))
+        return mean, covariance
+
+    def predict(
+        self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32]
+    ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]:
+        """
+        Run Kalman filter prediction step.
+
+        Args:
+            mean: The object state mean at the previous time step.
+            covariance: The object state covariance at the previous time step.
+
+        Returns:
+            The mean vector and covariance matrix of the predicted state.
+        """
+        std_pos = [
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3],
+            1e-2,
+            self._std_weight_position * mean[3],
+        ]
+        std_vel = [
+            self._std_weight_velocity * mean[3],
+            self._std_weight_velocity * mean[3],
+            1e-5,
+            self._std_weight_velocity * mean[3],
+        ]
+        motion_cov = np.diag(np.square(np.r_[std_pos, std_vel]))
+
+        mean = np.dot(mean, self._motion_mat.T)
+        covariance = (
+            np.linalg.multi_dot((self._motion_mat, covariance, self._motion_mat.T))
+            + motion_cov
+        )
+
+        return mean, covariance
+
+    def project(
+        self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32]
+    ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]:
+        """
+        Project state distribution to measurement space.
+
+        Args:
+            mean: The state's mean vector.
+            covariance: The state's covariance matrix.
+
+        Returns:
+            The projected mean and covariance matrix of the given state estimate.
+        """
+        std = [
+            self._std_weight_position * mean[3],
+            self._std_weight_position * mean[3],
+            1e-1,
+            self._std_weight_position * mean[3],
+        ]
+        innovation_cov = np.diag(np.square(std))
+
+        mean = np.dot(self._update_mat, mean)
+        covariance = np.linalg.multi_dot(
+            (self._update_mat, covariance, self._update_mat.T)
+        )
+        return mean, covariance + innovation_cov
+
+    def multi_predict(
+        self, mean: npt.NDArray[np.float32], covariance: npt.NDArray[np.float32]
+    ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]:
+        """
+        Run Kalman filter prediction step (Vectorized version).
+        Args:
+            mean: The object state means at the previous time step.
+            covariance: The object state covariances at the previous time step.
+
+        Returns:
+            The mean vector and covariance matrix of the predicted state.
+        """
+        std_pos = [
+            self._std_weight_position * mean[:, 3],
+            self._std_weight_position * mean[:, 3],
+            1e-2 * np.ones_like(mean[:, 3]),
+            self._std_weight_position * mean[:, 3],
+        ]
+        std_vel = [
+            self._std_weight_velocity * mean[:, 3],
+            self._std_weight_velocity * mean[:, 3],
+            1e-5 * np.ones_like(mean[:, 3]),
+            self._std_weight_velocity * mean[:, 3],
+        ]
+        sqr = np.square(np.r_[std_pos, std_vel]).T
+
+        motion_cov_list: list[npt.NDArray[np.float32]] = []
+        for i in range(len(mean)):
+            motion_cov_list.append(np.diag(sqr[i]))
+        motion_cov = np.asarray(motion_cov_list)
+
+        mean = np.dot(mean, self._motion_mat.T)
+        left = np.dot(self._motion_mat, covariance).transpose((1, 0, 2))
+        covariance = np.dot(left, self._motion_mat.T) + motion_cov
+
+        return mean, covariance
+
+    def update(
+        self,
+        mean: npt.NDArray[np.float32],
+        covariance: npt.NDArray[np.float32],
+        measurement: npt.NDArray[np.float32],
+    ) -> tuple[npt.NDArray[np.float32], npt.NDArray[np.float32]]:
+        """
+        Run Kalman filter correction step.
+
+        Args:
+            mean: The predicted state's mean vector.
+            covariance: The state's covariance matrix.
+            measurement: The measurement vector.
+
+        Returns:
+            The measurement-corrected state distribution.
+        """
+        projected_mean, projected_cov = self.project(mean, covariance)
+
+        chol_factor, lower = scipy.linalg.cho_factor(
+            projected_cov, lower=True, check_finite=False
+        )
+        kalman_gain = scipy.linalg.cho_solve(
+            (chol_factor, lower),
+            np.dot(covariance, self._update_mat.T).T,
+            check_finite=False,
+        ).T
+        innovation = measurement - projected_mean
+
+        new_mean = mean + np.dot(innovation, kalman_gain.T)
+        new_covariance = covariance - np.linalg.multi_dot(
+            (kalman_gain, projected_cov, kalman_gain.T)
+        )
+        return new_mean, new_covariance
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/matching.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/matching.py
new file mode 100644
index 0000000000000000000000000000000000000000..b32871b7725a68bbae862acb5ae2407d2d848326
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/matching.py
@@ -0,0 +1,79 @@
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+from scipy.optimize import linear_sum_assignment
+
+from supervision.detection.utils.iou_and_nms import box_iou_batch
+from supervision.tracker.byte_tracker.single_object_track import STrack
+
+
+def indices_to_matches(
+    cost_matrix: npt.NDArray[np.float32], indices: npt.NDArray[np.int_], thresh: float
+) -> tuple[npt.NDArray[np.int_], tuple[int, ...], tuple[int, ...]]:
+    matched_cost = cost_matrix[tuple(zip(*indices))]
+    matched_mask = matched_cost <= thresh
+
+    matches = indices[matched_mask]
+    unmatched_a = tuple(set(range(cost_matrix.shape[0])) - set(matches[:, 0]))
+    unmatched_b = tuple(set(range(cost_matrix.shape[1])) - set(matches[:, 1]))
+    return matches, unmatched_a, unmatched_b
+
+
+def linear_assignment(
+    cost_matrix: npt.NDArray[np.float32], thresh: float
+) -> tuple[npt.NDArray[np.int_], tuple[int, ...], tuple[int, ...]]:
+    """Match rows and columns without mutating the caller-owned cost matrix."""
+    if cost_matrix.size == 0:
+        return (
+            np.empty((0, 2), dtype=int),
+            tuple(range(cost_matrix.shape[0])),
+            tuple(range(cost_matrix.shape[1])),
+        )
+
+    assignment_cost_matrix = cost_matrix.copy()
+    assignment_cost_matrix[assignment_cost_matrix > thresh] = thresh + 1e-4
+    row_ind, col_ind = linear_sum_assignment(assignment_cost_matrix)
+    indices = np.column_stack((row_ind, col_ind))
+
+    return indices_to_matches(cost_matrix, indices, thresh)
+
+
+def iou_distance(
+    atracks: list[STrack] | list[npt.NDArray[np.float32]],
+    btracks: list[STrack] | list[npt.NDArray[np.float32]],
+) -> npt.NDArray[np.float32]:
+    if (len(atracks) > 0 and isinstance(atracks[0], np.ndarray)) or (
+        len(btracks) > 0 and isinstance(btracks[0], np.ndarray)
+    ):
+        atlbrs = cast(list[npt.NDArray[np.float32]], atracks)
+        btlbrs = cast(list[npt.NDArray[np.float32]], btracks)
+    else:
+        atlbrs = [track.tlbr for track in cast(list[STrack], atracks)]
+        btlbrs = [track.tlbr for track in cast(list[STrack], btracks)]
+
+    if len(atlbrs) == 0 or len(btlbrs) == 0:
+        return cast(
+            npt.NDArray[np.float32],
+            np.empty((len(atlbrs), len(btlbrs)), dtype=np.float32),
+        )
+
+    ious = box_iou_batch(
+        np.asarray(atlbrs, dtype=np.float32),
+        np.asarray(btlbrs, dtype=np.float32),
+    )
+    cost_matrix = np.asarray(1 - ious, dtype=np.float32)
+    return cost_matrix
+
+
+def fuse_score(
+    cost_matrix: npt.NDArray[np.float32], stracks: list[STrack]
+) -> npt.NDArray[np.float32]:
+    if cost_matrix.size == 0:
+        return cost_matrix
+    iou_sim = 1 - cost_matrix
+    det_scores = np.array([strack.score for strack in stracks], dtype=np.float32)
+    det_scores = np.expand_dims(det_scores, axis=0).repeat(cost_matrix.shape[0], axis=0)
+    fuse_sim = iou_sim * det_scores
+    fuse_cost = np.asarray(1 - fuse_sim, dtype=np.float32)
+    return fuse_cost
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/single_object_track.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/single_object_track.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d540db1b50f8b615e44015f8e68b6e4b74ef990
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/single_object_track.py
@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+
+from supervision.tracker.byte_tracker.kalman_filter import KalmanFilter
+from supervision.tracker.byte_tracker.utils import IdCounter
+
+
+class TrackState(Enum):
+    New = 0
+    Tracked = 1
+    Lost = 2
+    Removed = 3
+
+
+class STrack:
+    def __init__(
+        self,
+        tlwh: npt.NDArray[np.float32],
+        score: float,
+        minimum_consecutive_frames: int,
+        shared_kalman: KalmanFilter,
+        internal_id_counter: IdCounter,
+        external_id_counter: IdCounter,
+    ):
+        self.state = TrackState.New
+        self.is_activated = False
+        self.start_frame = 0
+        self.frame_id = 0
+
+        self._tlwh = np.asarray(tlwh, dtype=np.float32)
+        self.kalman_filter: KalmanFilter | None = None
+        self.shared_kalman = shared_kalman
+        self.mean: npt.NDArray[np.float32] | None = None
+        self.covariance: npt.NDArray[np.float32] | None = None
+        self.is_activated = False
+
+        self.score: float = score
+        self.tracklet_len = 0
+
+        self.minimum_consecutive_frames = minimum_consecutive_frames
+
+        self.internal_id_counter = internal_id_counter
+        self.external_id_counter = external_id_counter
+        self.internal_track_id = self.internal_id_counter.NO_ID
+        self.external_track_id = self.external_id_counter.NO_ID
+
+    def predict(self) -> None:
+        assert self.mean is not None
+        assert self.covariance is not None
+        assert self.kalman_filter is not None
+        mean_state = self.mean.copy()
+        if self.state != TrackState.Tracked:
+            mean_state[7] = 0
+        self.mean, self.covariance = self.kalman_filter.predict(
+            mean_state, self.covariance
+        )
+
+    @staticmethod
+    def multi_predict(stracks: list[STrack], shared_kalman: KalmanFilter) -> None:
+        if len(stracks) > 0:
+            multi_mean_states = []
+            multi_covariance = []
+            for i, st in enumerate(stracks):
+                assert st.mean is not None
+                assert st.covariance is not None
+                multi_mean_states.append(st.mean.copy())
+                multi_covariance.append(st.covariance)
+                if st.state != TrackState.Tracked:
+                    multi_mean_states[i][7] = 0
+
+            predicted_mean, predicted_covariance = shared_kalman.multi_predict(
+                np.asarray(multi_mean_states), np.asarray(multi_covariance)
+            )
+            for i, (mean, cov) in enumerate(zip(predicted_mean, predicted_covariance)):
+                stracks[i].mean = mean
+                stracks[i].covariance = cov
+
+    def activate(self, kalman_filter: KalmanFilter, frame_id: int) -> None:
+        """Start a new tracklet after its first detection."""
+        self.kalman_filter = kalman_filter
+        self.internal_track_id = self.internal_id_counter.new_id()
+        self.mean, self.covariance = self.kalman_filter.initiate(
+            self.tlwh_to_xyah(self._tlwh)
+        )
+
+        self.tracklet_len = 1
+        self.state = TrackState.Tracked
+        if frame_id == 1 and self.tracklet_len >= self.minimum_consecutive_frames:
+            self.is_activated = True
+            self.external_track_id = self.external_id_counter.new_id()
+
+        self.frame_id = frame_id
+        self.start_frame = frame_id
+
+    def re_activate(self, new_track: STrack, frame_id: int) -> None:
+        assert self.kalman_filter is not None
+        assert self.mean is not None
+        assert self.covariance is not None
+        self.mean, self.covariance = self.kalman_filter.update(
+            self.mean, self.covariance, self.tlwh_to_xyah(new_track.tlwh)
+        )
+        self.tracklet_len = 0
+        self.state = TrackState.Tracked
+
+        self.frame_id = frame_id
+        self.score = new_track.score
+
+    def update(self, new_track: STrack, frame_id: int) -> None:
+        """
+        Update a matched track.
+
+        Args:
+            new_track: The new track data.
+            frame_id: The current frame ID.
+        """
+        assert self.kalman_filter is not None
+        assert self.mean is not None
+        assert self.covariance is not None
+        self.frame_id = frame_id
+        self.tracklet_len += 1
+
+        new_tlwh = new_track.tlwh
+        self.mean, self.covariance = self.kalman_filter.update(
+            self.mean, self.covariance, self.tlwh_to_xyah(new_tlwh)
+        )
+        self.state = TrackState.Tracked
+        if self.tracklet_len >= self.minimum_consecutive_frames:
+            self.is_activated = True
+            if self.external_track_id == self.external_id_counter.NO_ID:
+                self.external_track_id = self.external_id_counter.new_id()
+
+        self.score = new_track.score
+
+    @property
+    def tlwh(self) -> npt.NDArray[np.float32]:
+        """Get current position in bounding box format `(top left x, top left y,
+        width, height)`.
+        """
+        if self.mean is None:
+            return cast(npt.NDArray[np.float32], self._tlwh.copy())
+        ret = self.mean[:4].copy()
+        ret[2] *= ret[3]
+        ret[:2] -= ret[2:] / 2
+        return cast(npt.NDArray[np.float32], ret)
+
+    @property
+    def tlbr(self) -> npt.NDArray[np.float32]:
+        """Convert bounding box to format `(min x, min y, max x, max y)`, i.e.,
+        `(top left, bottom right)`.
+        """
+        ret = self.tlwh.copy()
+        ret[2:] += ret[:2]
+        return cast(npt.NDArray[np.float32], ret)
+
+    @staticmethod
+    def tlwh_to_xyah(tlwh: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+        """Convert bounding box to format `(center x, center y, aspect ratio,
+        height)`, where the aspect ratio is `width / height`.
+        """
+        ret = np.asarray(tlwh).copy()
+        ret[:2] += ret[2:] / 2
+        ret[2] /= ret[3]
+        return cast(npt.NDArray[np.float32], ret)
+
+    def to_xyah(self) -> npt.NDArray[np.float32]:
+        return self.tlwh_to_xyah(self.tlwh)
+
+    @staticmethod
+    def tlbr_to_tlwh(tlbr: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+        ret = np.asarray(tlbr).copy()
+        ret[2:] -= ret[:2]
+        return cast(npt.NDArray[np.float32], ret)
+
+    @staticmethod
+    def tlwh_to_tlbr(tlwh: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
+        ret = np.asarray(tlwh).copy()
+        ret[2:] += ret[:2]
+        return cast(npt.NDArray[np.float32], ret)
+
+    def __repr__(self) -> str:
+        return f"OT_{self.internal_track_id}_({self.start_frame}-{self.frame_id})"
diff --git a/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/utils.py b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4e1c1c297af00dd3ce7db499e4f7a76107bd0fc1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/tracker/byte_tracker/utils.py
@@ -0,0 +1,34 @@
+class IdCounter:
+    def __init__(self, start_id: int = 0) -> None:
+        """
+        Initialize the ID counter.
+
+        Args:
+            start_id: The starting integer for the counter.
+
+        Raises:
+            ValueError: If start_id is less than or equal to -1.
+        """
+        self.start_id = start_id
+        if self.start_id <= self.NO_ID:
+            raise ValueError(f"start_id must be greater than {self.NO_ID}")
+        self.reset()
+
+    def reset(self) -> None:
+        """Reset the counter to the initial start_id."""
+        self._id = self.start_id
+
+    def new_id(self) -> int:
+        """
+        Get the current ID and increment the counter.
+
+        Returns:
+            The newly assigned ID.
+        """
+        returned_id = self._id
+        self._id += 1
+        return returned_id
+
+    @property
+    def NO_ID(self) -> int:
+        return -1
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__init__.py b/.venv/lib/python3.12/site-packages/supervision/utils/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..07638b180f4d960d287b3fed87458c74317ac8ce
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/conversion.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/conversion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..05c9d8cee2d4ff0067bd7dae1a8193723a4a00f9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/conversion.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/file.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/file.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b701edbca1d6a566d939ac6bba0197af4c772f6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/file.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf28db44e018aa3783ce7de41ff17b2253c2de7c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image_window.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image_window.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00002dc9a752cf0e22af21508aac495f3a4b71d5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/image_window.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/internal.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/internal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..089f8d247f876a097c0b43464ffbbcde59edba5a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/internal.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/iterables.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/iterables.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b642e9f12022b39bf476dfe608e380065ac4a74
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/iterables.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/logger.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/logger.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6171be06eec73acec334a7e619f4e3e6fcc1535
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/logger.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/notebook.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/notebook.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5b55d8ef07f00e39da49929b0d0043cee30a5e4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/notebook.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/video.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/video.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51420bc26c359660480839da4ca0f7225deafb1f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/utils/__pycache__/video.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/conversion.py b/.venv/lib/python3.12/site-packages/supervision/utils/conversion.py
new file mode 100644
index 0000000000000000000000000000000000000000..30b51999569d68d66afa9eccbd46966118647b0d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/conversion.py
@@ -0,0 +1,236 @@
+import functools
+from collections.abc import Callable
+from typing import Any, TypeVar, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import deprecated, void  # type: ignore[import-untyped,unused-ignore]
+from PIL import Image
+
+from supervision import _cv2 as cv2
+from supervision.draw.base import ImageType
+
+F = TypeVar("F", bound=Callable[..., Any])
+
+
+def ensure_cv2_image_for_class_method(
+    annotate_func: F,
+) -> F:
+    """
+    Decorates `BaseAnnotator.annotate` implementations, converts scene to
+    an image type used internally by the annotators, converts back when annotation
+    is complete.
+
+    Assumes the annotators modify the scene in-place.
+
+    Raises:
+        TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+    """
+
+    @functools.wraps(annotate_func)
+    def wrapper(self: Any, scene: ImageType, *args: Any, **kwargs: Any) -> Any:
+        if isinstance(scene, np.ndarray):
+            return annotate_func(self, scene, *args, **kwargs)
+
+        if isinstance(scene, Image.Image):
+            scene_np = pillow_to_cv2(scene)
+            annotated_np = annotate_func(self, scene_np, *args, **kwargs)
+            scene.paste(cv2_to_pillow(annotated_np))
+            return scene
+
+        raise TypeError(f"Unsupported image type: {type(scene)}")
+
+    return cast(F, wrapper)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=ensure_cv2_image_for_class_method,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def ensure_cv2_image_for_annotation(
+    annotate_func: F,
+) -> F:
+    return cast(F, void(annotate_func))
+
+
+def ensure_cv2_image_for_standalone_function(
+    image_processing_fun: F,
+) -> F:
+    """
+    Decorates image processing functions that accept np.ndarray, converting `image` to
+    np.ndarray, converts back when processing is complete.
+
+    Assumes the annotators do NOT modify the scene in-place.
+
+    Raises:
+        TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`.
+    """
+
+    @functools.wraps(image_processing_fun)
+    def wrapper(image: ImageType, *args: Any, **kwargs: Any) -> Any:
+        if isinstance(image, np.ndarray):
+            return image_processing_fun(image, *args, **kwargs)
+
+        if isinstance(image, Image.Image):
+            scene = pillow_to_cv2(image)
+            annotated = image_processing_fun(scene, *args, **kwargs)
+            return cv2_to_pillow(annotated)
+
+        raise TypeError(f"Unsupported image type: {type(image)}")
+
+    return cast(F, wrapper)
+
+
+def ensure_pil_image_for_class_method(
+    annotate_func: F,
+) -> F:
+    """
+    Decorates image processing functions that accept np.ndarray, converting `image` to
+    PIL image, converts back when processing is complete.
+
+    Assumes the annotators modify the scene in-place.
+
+    Raises:
+        TypeError: If `scene` is not a `numpy.ndarray` or `PIL.Image.Image`.
+    """
+
+    @functools.wraps(annotate_func)
+    def wrapper(self: Any, scene: ImageType, *args: Any, **kwargs: Any) -> Any:
+        if isinstance(scene, np.ndarray):
+            scene_pil = cv2_to_pillow(scene)
+            annotated_pil = annotate_func(self, scene_pil, *args, **kwargs)
+            np.copyto(scene, pillow_to_cv2(annotated_pil))
+            return scene
+
+        if isinstance(scene, Image.Image):
+            return cast(ImageType, annotate_func(self, scene, *args, **kwargs))
+
+        raise TypeError(f"Unsupported image type: {type(scene)}")
+
+    return cast(F, wrapper)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=ensure_pil_image_for_class_method,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def ensure_pil_image_for_annotation(
+    annotate_func: F,
+) -> F:
+    return cast(F, void(annotate_func))
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=ensure_cv2_image_for_standalone_function,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def ensure_cv2_image_for_processing(
+    image_processing_fun: F,
+) -> F:
+    return cast(F, void(image_processing_fun))
+
+
+def images_to_cv2(
+    images: list[npt.NDArray[np.uint8] | Image.Image],
+) -> list[npt.NDArray[np.uint8]]:
+    """
+    Converts images provided either as Pillow images or OpenCV
+    images into OpenCV format.
+
+    Args:
+        images: Images to be converted
+
+    Returns:
+        List of input images in OpenCV format
+            (with order preserved).
+
+    """
+    result: list[npt.NDArray[np.uint8]] = []
+    for image in images:
+        if isinstance(image, Image.Image):
+            result.append(pillow_to_cv2(image))
+        else:
+            result.append(image)
+    return result
+
+
+def pillow_to_cv2(image: Image.Image) -> npt.NDArray[np.uint8]:
+    """
+    Converts Pillow image into OpenCV image, handling RGB -> BGR
+    conversion. Palette images are first expanded to RGB so palette indices are
+    resolved to their actual colors. RGBA images are converted to BGR, matching
+    OpenCV by dropping the alpha channel.
+
+    Args:
+        image: Pillow image in RGB, RGBA, grayscale, or palette mode.
+
+    Returns:
+        Input image converted to OpenCV format.
+
+    Examples:
+        ```pycon
+        >>> from PIL import Image
+        >>> from supervision.utils.conversion import pillow_to_cv2
+        >>> image = Image.new("RGB", (10, 10), color=(255, 0, 0))
+        >>> scene = pillow_to_cv2(image)
+        >>> scene.shape
+        (10, 10, 3)
+        >>> scene[0, 0].tolist()
+        [0, 0, 255]
+
+        ```
+    """
+    if image.mode == "P":
+        image = image.convert("RGB")
+
+    scene = np.array(image)
+    if scene.ndim == 2:
+        return cast(npt.NDArray[np.uint8], scene.astype(np.uint8, copy=False))
+    scene = cv2.cvtColor(scene, cv2.COLOR_RGB2BGR)
+    # cvtColor already returns uint8 here, so astype is a no-op other than the
+    # full-image copy it forces; copy=False keeps the dtype guard without it.
+    return cast(npt.NDArray[np.uint8], scene.astype(np.uint8, copy=False))
+
+
+def cv2_to_pillow(image: npt.NDArray[np.uint8]) -> Image.Image:
+    """
+    Converts an OpenCV image into a Pillow image, reordering channels from
+    OpenCV's BGR(A) convention to Pillow's RGB(A).
+
+    Args:
+        image: OpenCV image. Accepted shapes:
+            - `(H, W)` — grayscale, passed through unchanged.
+            - `(H, W, 3)` — BGR, converted to RGB.
+            - `(H, W, 4)` — BGRA, converted to RGBA.
+
+    Returns:
+        Input image converted to Pillow format.
+
+    Raises:
+        ValueError: If `image` is not 2-D or 3-D with 3 or 4 channels.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> from supervision.utils.conversion import cv2_to_pillow
+        >>> scene = np.zeros((10, 10, 3), dtype=np.uint8)
+        >>> scene[:, :, 2] = 255
+        >>> image = cv2_to_pillow(scene)
+        >>> image.size
+        (10, 10)
+        >>> image.getpixel((0, 0))
+        (255, 0, 0)
+
+        ```
+    """
+    if image.ndim == 2:
+        return Image.fromarray(np.ascontiguousarray(image))
+    if image.ndim == 3 and image.shape[2] == 3:
+        rgb_image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        return Image.fromarray(rgb_image)
+    if image.ndim == 3 and image.shape[2] == 4:
+        return Image.fromarray(np.ascontiguousarray(image[..., [2, 1, 0, 3]]))
+    raise ValueError(f"Expected shape (H,W), (H,W,3), or (H,W,4), got {image.shape}.")
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/file.py b/.venv/lib/python3.12/site-packages/supervision/utils/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..311d9186f786805d6b492f01bd6fb26e906c569d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/file.py
@@ -0,0 +1,308 @@
+import json
+import os
+import tempfile
+import urllib.parse
+from pathlib import Path
+from shutil import copyfileobj
+from typing import Any
+
+import numpy as np
+import requests
+import yaml
+
+SUPERVISION_CACHE_DIR = Path(tempfile.gettempdir()) / "supervision"
+
+
+def _normalize_http_url(url: str) -> str:
+    """
+    Validate and normalize an HTTP(S) URL.
+
+    Args:
+        url: URL to validate.
+
+    Returns:
+        Normalized URL string.
+
+    Raises:
+        ValueError: If the URL is invalid or uses an unsupported scheme.
+    """
+    try:
+        original_parsed_url = urllib.parse.urlparse(url)
+        if "\\" in original_parsed_url.netloc:
+            raise ValueError("URL authority contains a backslash")
+
+        prepared_request = requests.Request(method="GET", url=url).prepare()
+        prepared_url = prepared_request.url
+        if prepared_url is None:
+            raise ValueError("prepared URL is empty")
+
+        parsed_url = urllib.parse.urlparse(prepared_url)
+    except (requests.RequestException, ValueError) as error:
+        raise ValueError(f"Invalid URL {url!r}: {error}") from error
+
+    if parsed_url.scheme not in {"http", "https"}:
+        raise ValueError(
+            f"Unsupported URL scheme {parsed_url.scheme!r} in {url!r}. "
+            "Only HTTP and HTTPS URLs are supported."
+        )
+    if parsed_url.hostname is None:
+        raise ValueError(f"Invalid URL {url!r}: no host supplied.")
+
+    return prepared_url
+
+
+def _download_to_file(
+    url: str, target: Path, *, timeout: float = 30.0, stream: bool = False
+) -> None:
+    """
+    Download `url` to `target` atomically using a temporary file and `os.replace`.
+
+    Args:
+        url: HTTP(S) URL to download.
+        target: Destination file path. Parent directories are created as needed.
+        timeout: Request timeout in seconds. Defaults to `30.0`.
+        stream: If `True`, stream the response to disk in chunks and display a
+            progress bar. If `False`, buffer the response in memory before
+            writing. Defaults to `False`.
+
+    Raises:
+        requests.RequestException: If the request fails or returns an error status.
+    """
+    response = requests.get(url, stream=stream, allow_redirects=True, timeout=timeout)
+    try:
+        response.raise_for_status()
+        target.parent.mkdir(parents=True, exist_ok=True)
+        with tempfile.NamedTemporaryFile(
+            delete=False, dir=target.parent, suffix=target.suffix
+        ) as file:
+            temp_path = Path(file.name)
+            try:
+                if stream:
+                    from tqdm.auto import tqdm
+
+                    file_size = int(response.headers.get("Content-Length", 0))
+                    with tqdm.wrapattr(
+                        response.raw, "read", total=file_size, desc="", colour="#a351fb"
+                    ) as raw_response:
+                        copyfileobj(raw_response, file)
+                else:
+                    file.write(response.content)
+            except BaseException:
+                file.close()
+                temp_path.unlink(missing_ok=True)
+                raise
+    finally:
+        response.close()
+
+    try:
+        os.replace(temp_path, target)
+    finally:
+        temp_path.unlink(missing_ok=True)
+
+
+class NumpyJsonEncoder(json.JSONEncoder):
+    def default(self, obj: Any) -> Any:
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super().default(obj)
+
+
+def list_files_with_extensions(
+    directory: str | Path, extensions: list[str] | None = None
+) -> list[Path]:
+    """
+    List files in a directory with specified extensions or
+        all files if no extensions are provided.
+
+    Args:
+        directory: The directory path as a string or Path object.
+        extensions: A list of file extensions to filter. Extensions may be
+            supplied with or without a leading dot (e.g. ``'jpg'`` and
+            ``'.jpg'`` are equivalent). Matching is case-insensitive.
+            Multi-part extensions are supported (e.g. ``'tar.gz'``). Pass
+            ``None`` (default) to list all files; pass an empty list to
+            return no files.
+
+    Returns:
+        A list of Path objects for the matching files.
+
+    Examples:
+        ```pycon
+        >>> import supervision as sv
+        >>> from pathlib import Path
+        >>> import tempfile
+        >>> # Keep a reference to the directory object
+        >>> tmp_dir_obj = tempfile.TemporaryDirectory()
+        >>> tmpdir = tmp_dir_obj.name
+        >>> # Create test files
+        >>> (Path(tmpdir) / "test1.txt").touch()
+        >>> (Path(tmpdir) / "test2.md").touch()
+        >>> (Path(tmpdir) / "test3.py").touch()
+        >>> # List all files in the directory
+        >>> files = sv.list_files_with_extensions(directory=tmpdir)
+        >>> len(files)
+        3
+        >>> # Leading dot accepted; matching is case-insensitive
+        >>> files = sv.list_files_with_extensions(
+        ...     directory=tmpdir, extensions=['.txt', 'md'])
+        >>> len(files)
+        2
+
+        ```
+    """
+
+    directory = Path(directory)
+    files_with_extensions: list[Path] = []
+
+    if extensions is not None:
+        candidates = [p for p in directory.glob("*") if p.is_file()]
+        path_index: dict[Path, set[str]] = {}
+        for path in candidates:
+            suffixes = [suffix.lower().lstrip(".") for suffix in path.suffixes]
+            path_index[path] = {
+                ".".join(suffixes[index:]) for index in range(len(suffixes))
+            }
+        seen_paths: set[Path] = set()
+        for ext in extensions:
+            normalized_extension = ext.lower().lstrip(".")
+            if not normalized_extension:
+                continue
+            for path, path_extensions in path_index.items():
+                if path not in seen_paths and normalized_extension in path_extensions:
+                    files_with_extensions.append(path)
+                    seen_paths.add(path)
+    else:
+        files_with_extensions.extend(p for p in directory.glob("*") if p.is_file())
+
+    return files_with_extensions
+
+
+def read_txt_file(file_path: str | Path, skip_empty: bool = False) -> list[str]:
+    """
+    Read a text file and return a list of strings without newline characters.
+    Optionally skip empty lines.
+
+    Args:
+        file_path: The file path as a string or Path object.
+        skip_empty: If True, skip lines that are empty or contain only
+            whitespace. Default is False.
+
+    Returns:
+        A list of strings representing the lines in the text file.
+
+    Examples:
+        ```pycon
+        >>> import tempfile
+        >>> from pathlib import Path
+        >>> from supervision.utils.file import read_txt_file, save_text_file
+        >>> with tempfile.TemporaryDirectory() as tmpdir:
+        ...     file_path = Path(tmpdir) / "test.txt"
+        ...     save_text_file(["line1", " ", "line3"], file_path)
+        ...     print(read_txt_file(file_path))
+        ...     print(read_txt_file(file_path, skip_empty=True))
+        ['line1', ' ', 'line3']
+        ['line1', 'line3']
+
+        ```
+    """
+    with open(str(file_path)) as file:
+        if skip_empty:
+            lines = [line.rstrip("\n") for line in file if line.strip()]
+        else:
+            lines = [line.rstrip("\n") for line in file]
+
+    return lines
+
+
+def save_text_file(lines: list[str], file_path: str | Path) -> None:
+    """
+    Write a list of strings to a text file, each string on a new line.
+
+    Args:
+        lines: The list of strings to be written to the file.
+        file_path: The file path as a string or Path object.
+    """
+    with open(str(file_path), "w") as file:
+        for line in lines:
+            file.write(line + "\n")
+
+
+def read_json_file(file_path: str | Path) -> dict[str, Any]:
+    """
+    Read a json file and return a dict.
+
+    The file is decoded as UTF-8, the encoding JSON files are written in, whatever
+    the platform's default encoding is.
+
+    Args:
+        file_path: The file path as a string or Path object.
+
+    Returns:
+        A dict of annotations information
+
+    Examples:
+        ```pycon
+        >>> import tempfile
+        >>> from pathlib import Path
+        >>> from supervision.utils.file import read_json_file, save_json_file
+        >>> data = {"key": "value", "list": [1, 2, 3]}
+        >>> with tempfile.TemporaryDirectory() as tmpdir:
+        ...     file_path = Path(tmpdir) / "test.json"
+        ...     save_json_file(data, file_path)
+        ...     print(read_json_file(file_path))
+        {'key': 'value', 'list': [1, 2, 3]}
+
+        ```
+    """
+    with open(str(file_path), encoding="utf-8") as file:
+        data = json.load(file)
+    return data  # type: ignore
+
+
+def save_json_file(
+    data: dict[str, Any], file_path: str | Path, indent: int = 3
+) -> None:
+    """
+    Write a dict to a json file.
+
+    Args:
+        data: dict with unique keys and value as pair.
+        file_path: The file path as a string or Path object.
+        indent:
+    """
+    with open(str(file_path), "w") as fp:
+        json.dump(data, fp, cls=NumpyJsonEncoder, indent=indent)
+
+
+def read_yaml_file(file_path: str | Path) -> dict[str, Any]:
+    """
+    Read a yaml file and return a dict.
+
+    The file is decoded as UTF-8, whatever the platform's default encoding is.
+
+    Args:
+        file_path: The file path as a string or Path object.
+
+    Returns:
+        A dict of content information
+    """
+    with open(str(file_path), encoding="utf-8") as file:
+        data = yaml.safe_load(file)
+    return data  # type: ignore
+
+
+def save_yaml_file(data: dict[str, Any], file_path: str | Path) -> None:
+    """
+    Save a dict to a yaml file.
+
+    Args:
+        data: dict with unique keys and value as pair.
+        file_path: The file path as a string or Path object.
+    """
+
+    with open(str(file_path), "w") as outfile:
+        yaml.dump(data, outfile, sort_keys=False, default_flow_style=None)
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/image.py b/.venv/lib/python3.12/site-packages/supervision/utils/image.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bc0ef1d759c036bf6af92e8f280b428ded6ae0f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/image.py
@@ -0,0 +1,1129 @@
+from __future__ import annotations
+
+import itertools
+import math
+import os
+import shutil
+import tempfile
+import urllib.parse
+from collections.abc import Callable
+from functools import partial
+from hashlib import md5
+from pathlib import Path
+from types import TracebackType
+from typing import Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+from deprecate import (  # type: ignore[import-untyped,unused-ignore]
+    TargetMode,
+    deprecated,
+)
+from PIL import Image
+
+from supervision import _cv2 as cv2
+from supervision.draw.base import ImageType
+from supervision.draw.color import Color, unify_to_bgr
+from supervision.draw.utils import calculate_optimal_text_scale, draw_text
+from supervision.geometry.core import Point
+from supervision.utils.conversion import (
+    cv2_to_pillow,
+    ensure_cv2_image_for_standalone_function,
+    images_to_cv2,
+)
+from supervision.utils.file import (
+    SUPERVISION_CACHE_DIR,
+    _download_to_file,
+    _normalize_http_url,
+)
+from supervision.utils.iterables import create_batches, fill
+
+RelativePosition = Literal["top", "bottom"]
+
+MAX_COLUMNS_FOR_SINGLE_ROW_GRID = 3
+
+DEFAULT_IMAGE_URL_CACHE_DIR = SUPERVISION_CACHE_DIR / "image-url"
+
+
+def _get_image_url_cache_path(value: str, cache_dir: str | Path | None) -> Path:
+    """
+    Build the cache file path for a URL: `/`.
+    """
+    cache_root = (
+        DEFAULT_IMAGE_URL_CACHE_DIR
+        if cache_dir is None
+        else Path(cache_dir).expanduser().resolve()
+    )
+    url_path = urllib.parse.urlparse(value).path
+    suffix = Path(url_path).suffix or ".image"
+    url_hash = md5(value.encode("utf-8"), usedforsecurity=False).hexdigest()
+    return cache_root / f"{url_hash}{suffix}"
+
+
+def _decode_image_from_bytes(
+    value: bytes,
+    cv_imread_flags: int,
+) -> npt.NDArray[np.uint8]:
+    """
+    Decode raw image bytes into an OpenCV image, raising on undecodable data.
+    """
+    image = cv2.imdecode(
+        np.frombuffer(value, dtype=np.uint8),
+        cv_imread_flags,
+    )
+    if image is None:
+        raise ValueError("Data pointed by URL could not be decoded into image.")
+
+    return cast(npt.NDArray[np.uint8], image)
+
+
+def load_image_from_url(
+    value: str,
+    cv_imread_flags: int = cv2.IMREAD_COLOR,
+    timeout: float = 30.0,
+    use_cache: bool = True,
+    cache_dir: str | Path | None = None,
+    force_reload: bool = False,
+) -> npt.NDArray[np.uint8]:
+    """
+    Load an image from a URL as an OpenCV image.
+
+    Args:
+        value: HTTP(S) URL of the image.
+        cv_imread_flags: OpenCV image read flag passed to `cv2.imdecode`.
+            Defaults to `cv2.IMREAD_COLOR`.
+        timeout: Request timeout in seconds. Defaults to `30.0`.
+        use_cache: If `True`, cache downloaded image bytes locally and reuse them
+            on repeated calls. Defaults to `True`.
+        cache_dir: Directory where downloaded image bytes are cached. If `None`,
+            uses the system temporary directory. Defaults to `None`.
+        force_reload: If `True`, re-download the image and refresh the cache.
+            Defaults to `False`.
+
+    Returns:
+        Image as a NumPy array in the format selected by `cv_imread_flags`.
+
+    Raises:
+        ValueError: If the URL is invalid or the downloaded bytes cannot be decoded.
+        requests.RequestException: If the request fails or returns an error status.
+
+    Examples:
+        ```python
+        import supervision as sv
+
+        image = sv.load_image_from_url(
+            "https://media.roboflow.com/quickstart/dog.jpeg"
+        )
+        image.shape
+
+        ```
+    """
+    prepared_url = _normalize_http_url(url=value)
+    if not use_cache:
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_target = Path(temp_dir) / "image"
+            _download_to_file(prepared_url, temp_target, timeout=timeout)
+            return _decode_image_from_bytes(
+                value=temp_target.read_bytes(),
+                cv_imread_flags=cv_imread_flags,
+            )
+
+    cache_path = _get_image_url_cache_path(
+        value=prepared_url,
+        cache_dir=cache_dir,
+    )
+    if cache_path.exists() and not force_reload:
+        try:
+            return _decode_image_from_bytes(
+                value=cache_path.read_bytes(),
+                cv_imread_flags=cv_imread_flags,
+            )
+        except ValueError:
+            cache_path.unlink(missing_ok=True)
+
+    _download_to_file(prepared_url, cache_path, timeout=timeout)
+    try:
+        return _decode_image_from_bytes(
+            value=cache_path.read_bytes(),
+            cv_imread_flags=cv_imread_flags,
+        )
+    except ValueError:
+        cache_path.unlink(missing_ok=True)
+        raise
+
+
+@ensure_cv2_image_for_standalone_function
+def crop_image(
+    image: ImageType,
+    xyxy: npt.NDArray[np.number] | list[int] | tuple[int, int, int, int],
+) -> ImageType:
+    """
+    Crop image based on bounding box coordinates.
+
+    Args:
+        image: The image to crop.
+        xyxy:
+            Bounding box coordinates in `(x_min, y_min, x_max, y_max)` format.
+
+    Returns:
+        Cropped image matching input
+            type.
+
+    Note:
+        Coordinates are rounded to integers and clipped to the image bounds
+        before slicing. This keeps NumPy and Pillow inputs aligned and avoids
+        negative-index wrap-around on NumPy arrays.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8)
+        >>> image.shape
+        (1080, 1920, 3)
+        >>> xyxy = (400, 400, 800, 800)
+        >>> cropped_image = sv.crop_image(image=image, xyxy=xyxy)
+        >>> cropped_image.shape
+        (400, 400, 3)
+
+        ```
+
+        ```pycon
+        >>> image = np.zeros((1920, 1080), dtype=np.uint8)
+        >>> image.shape
+        (1920, 1080)
+        >>> xyxy = (400, 400, 800, 800)
+        >>> cropped_image = sv.crop_image(image=image, xyxy=xyxy)
+        >>> cropped_image.shape
+        (400, 400)
+
+        ```
+
+    ![crop-image](https://media.roboflow.com/supervision-docs/supervision-docs-crop-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    xyxy_arr = np.asarray(xyxy, dtype=np.float64).round().astype(np.int32)
+    x_min, y_min, x_max, y_max = xyxy_arr.flatten()
+
+    if isinstance(image, np.ndarray):
+        height, width = image.shape[:2]
+        x_min = int(np.clip(x_min, 0, width))
+        y_min = int(np.clip(y_min, 0, height))
+        x_max = int(np.clip(x_max, 0, width))
+        y_max = int(np.clip(y_max, 0, height))
+        return image[y_min:y_max, x_min:x_max]
+
+    if isinstance(image, Image.Image):
+        width, height = image.size
+        x_min = int(np.clip(x_min, 0, width))
+        y_min = int(np.clip(y_min, 0, height))
+        x_max = int(np.clip(x_max, 0, width))
+        y_max = int(np.clip(y_max, 0, height))
+        return image.crop((float(x_min), float(y_min), float(x_max), float(y_max)))
+
+    raise TypeError(
+        f"`image` must be a numpy.ndarray or PIL.Image.Image. Received {type(image)}"
+    )
+
+
+@ensure_cv2_image_for_standalone_function
+def scale_image(image: ImageType, scale_factor: float) -> ImageType:
+    """
+    Scale image by given factor. Scale factor > 1.0 zooms in, < 1.0 zooms out.
+
+    Args:
+        image: The image to scale.
+        scale_factor: Factor by which to scale the image.
+
+    Returns:
+        Scaled image matching input
+            type.
+
+    Raises:
+        TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`.
+        ValueError: If scale factor is non-positive.
+
+    Note:
+        Each axis keeps at least one pixel, so a factor small enough to round an
+        axis of a small image down to zero returns a one-pixel-wide or
+        one-pixel-tall image rather than raising.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8)
+        >>> image.shape
+        (1080, 1920, 3)
+        >>> scaled_image = sv.scale_image(image=image, scale_factor=0.5)
+        >>> scaled_image.shape
+        (540, 960, 3)
+
+        ```
+
+        ```pycon
+        >>> image = np.zeros((1920, 1080), dtype=np.uint8)
+        >>> image.shape
+        (1920, 1080)
+        >>> scaled_image = sv.scale_image(image=image, scale_factor=0.5)
+        >>> scaled_image.shape
+        (960, 540)
+
+        ```
+
+    ![scale-image](https://media.roboflow.com/supervision-docs/supervision-docs-scale-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    if scale_factor <= 0:
+        raise ValueError("Scale factor must be positive.")
+
+    width_old, height_old = image.shape[1], image.shape[0]
+    # A small factor on a small image truncates an axis to zero, and `cv2.resize`
+    # answers a zero-sized target with a bare assertion. One pixel is the smallest
+    # image that still exists, so clamp there instead.
+    width_new = max(1, int(width_old * scale_factor))
+    height_new = max(1, int(height_old * scale_factor))
+    return cast(
+        npt.NDArray[np.uint8],
+        cv2.resize(image, (width_new, height_new), interpolation=cv2.INTER_LINEAR),
+    )
+
+
+@ensure_cv2_image_for_standalone_function
+def resize_image(
+    image: ImageType,
+    resolution_wh: tuple[int, int],
+    keep_aspect_ratio: bool = False,
+) -> ImageType:
+    """
+    Resize image to specified resolution. Can optionally maintain aspect ratio.
+
+    Args:
+        image: The image to resize.
+        resolution_wh: Target resolution as `(width, height)`.
+        keep_aspect_ratio: Flag to maintain original aspect ratio.
+            Defaults to `False`.
+
+    Returns:
+        Resized image matching input
+            type.
+
+    Raises:
+        TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+    Note:
+        With `keep_aspect_ratio=True` the fitted axis keeps at least one pixel, so
+        an aspect ratio too extreme to fit the target box returns a one-pixel-wide
+        or one-pixel-tall image rather than raising.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8)
+        >>> image.shape
+        (1080, 1920, 3)
+        >>> resized_image = sv.resize_image(
+        ...     image=image, resolution_wh=(1000, 1000), keep_aspect_ratio=True
+        ... )
+        >>> resized_image.shape
+        (562, 1000, 3)
+
+        ```
+
+        ```pycon
+        >>> image = np.zeros((1920, 1080), dtype=np.uint8)
+        >>> image.shape
+        (1920, 1080)
+        >>> resized_image = sv.resize_image(
+        ...     image=image, resolution_wh=(1000, 1000), keep_aspect_ratio=True
+        ... )
+        >>> resized_image.shape
+        (1000, 562)
+
+        ```
+
+    ![resize-image](https://media.roboflow.com/supervision-docs/supervision-docs-resize-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    if keep_aspect_ratio:
+        image_ratio = image.shape[1] / image.shape[0]
+        target_ratio = resolution_wh[0] / resolution_wh[1]
+        # The fitted axis truncates to zero once the aspect ratio outgrows the target
+        # box, and `cv2.resize` answers a zero-sized target with a bare assertion.
+        # One pixel is the smallest image that still exists, so clamp there instead.
+        if image_ratio >= target_ratio:
+            width_new = resolution_wh[0]
+            height_new = max(1, int(resolution_wh[0] / image_ratio))
+        else:
+            height_new = resolution_wh[1]
+            width_new = max(1, int(resolution_wh[1] * image_ratio))
+    else:
+        width_new, height_new = resolution_wh
+
+    return cast(
+        npt.NDArray[np.uint8],
+        cv2.resize(image, (width_new, height_new), interpolation=cv2.INTER_LINEAR),
+    )
+
+
+@ensure_cv2_image_for_standalone_function
+def letterbox_image(
+    image: ImageType,
+    resolution_wh: tuple[int, int],
+    color: tuple[int, int, int] | Color = Color.BLACK,
+) -> ImageType:
+    """
+    Resize image and pad with color to achieve desired resolution while
+    maintaining aspect ratio.
+
+    Args:
+        image: The image to resize and pad. Accepts BGR arrays of shape
+            ``(H, W, 3)``, BGRA arrays of shape ``(H, W, 4)``, grayscale
+            arrays of shape ``(H, W)``, or a PIL ``Image``.
+        resolution_wh: Target resolution as `(width, height)`.
+        color: Padding color. If tuple, should be in BGR format.
+            Defaults to `Color.BLACK`.
+
+    Returns:
+        Letterboxed image matching input type.
+
+    Raises:
+        TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`.
+
+    Note:
+        For BGRA inputs, the alpha channel in the padding region is set to
+        0 (fully transparent). Grayscale inputs receive scalar padding
+        from ``color[0]``.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8)
+        >>> image.shape
+        (1080, 1920, 3)
+        >>> letterboxed_image = sv.letterbox_image(
+        ...     image=image, resolution_wh=(1000, 1000)
+        ... )
+        >>> letterboxed_image.shape
+        (1000, 1000, 3)
+        >>> gray = np.zeros((4, 6), dtype=np.uint8)
+        >>> sv.letterbox_image(image=gray, resolution_wh=(10, 10)).shape
+        (10, 10)
+
+        ```
+
+    ![letterbox-image](https://media.roboflow.com/supervision-docs/supervision-docs-letterbox-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    color = unify_to_bgr(color=color)
+    resized_image = resize_image(
+        image=image, resolution_wh=resolution_wh, keep_aspect_ratio=True
+    )
+    height_new, width_new = resized_image.shape[:2]
+    padding_top = (resolution_wh[1] - height_new) // 2
+    padding_bottom = resolution_wh[1] - height_new - padding_top
+    padding_left = (resolution_wh[0] - width_new) // 2
+    padding_right = resolution_wh[0] - width_new - padding_left
+    image_with_borders = cast(
+        npt.NDArray[np.uint8],
+        cv2.copyMakeBorder(
+            resized_image,
+            padding_top,
+            padding_bottom,
+            padding_left,
+            padding_right,
+            cv2.BORDER_CONSTANT,
+            value=color,
+        ),
+    )
+
+    return image_with_borders
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=TargetMode.NOTIFY,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def overlay_image(
+    image: npt.NDArray[np.uint8],
+    overlay: npt.NDArray[np.uint8],
+    anchor: tuple[int, int],
+) -> npt.NDArray[np.uint8]:
+    """
+    Deprecated since 0.27.0; removal in 0.31.0. Use `_overlay_image` for
+    internal callers, or avoid calling `overlay_image` directly in external code.
+
+    Overlay image onto scene at specified anchor point. Handles cases where
+    overlay position is partially or completely outside scene bounds.
+
+    Args:
+        image: Background scene with shape `(height, width, 3)`.
+        overlay: Image to overlay with shape
+            `(height, width, 3)` or `(height, width, 4)`.
+        anchor: Coordinates `(x, y)` where top-left corner
+            of overlay will be placed.
+
+    Returns:
+        Scene with overlay applied, shape `(height, width, 3)`.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1000, 1000, 3), dtype=np.uint8)
+        >>> overlay = np.zeros((400, 400, 3), dtype=np.uint8)
+        >>> overlay[:] = (0, 255, 0)  # Green overlay
+        >>> result_image = sv.overlay_image(
+        ...     image=image, overlay=overlay, anchor=(200, 400)
+        ... )
+        >>> result_image.shape
+        (1000, 1000, 3)
+
+        ```
+    """
+    return _overlay_image(image=image, overlay=overlay, anchor=anchor)
+
+
+def _overlay_image(
+    image: npt.NDArray[np.uint8],
+    overlay: npt.NDArray[np.uint8],
+    anchor: tuple[int, int],
+) -> npt.NDArray[np.uint8]:
+    """Overlay `overlay` onto `image` at `anchor`, clipping to scene bounds.
+
+    Non-deprecated internal implementation backing the public `overlay_image`.
+    Kept separate so library-internal callers do not emit a deprecation warning.
+
+    Args:
+        image: Background BGR array of shape ``(H, W, 3)``. Modified in place
+            and returned.
+        overlay: Overlay array of shape ``(H, W, 3)`` or ``(H, W, 4)``; channel
+            4, when present, is treated as alpha.
+        anchor: ``(x, y)`` pixel position of the overlay top-left corner. May
+            be negative (partial off-screen placement is clipped).
+
+    Returns:
+        The ``image`` array with the overlay applied.
+    """
+    scene_height, scene_width = image.shape[:2]
+    image_height, image_width = overlay.shape[:2]
+    anchor_x, anchor_y = anchor
+
+    is_out_horizontally = anchor_x + image_width <= 0 or anchor_x >= scene_width
+    is_out_vertically = anchor_y + image_height <= 0 or anchor_y >= scene_height
+
+    if is_out_horizontally or is_out_vertically:
+        return image
+
+    x_min = max(anchor_x, 0)
+    y_min = max(anchor_y, 0)
+    x_max = min(scene_width, anchor_x + image_width)
+    y_max = min(scene_height, anchor_y + image_height)
+
+    crop_x_min = max(-anchor_x, 0)
+    crop_y_min = max(-anchor_y, 0)
+    crop_x_max = image_width - max((anchor_x + image_width) - scene_width, 0)
+    crop_y_max = image_height - max((anchor_y + image_height) - scene_height, 0)
+
+    if overlay.shape[2] == 4:
+        b, g, r, alpha = cv2.split(
+            overlay[crop_y_min:crop_y_max, crop_x_min:crop_x_max]
+        )
+        alpha_f32 = alpha[:, :, None].astype(np.float32) / 255.0
+        overlay_color = cv2.merge((b, g, r)).astype(np.float32)
+
+        roi = image[y_min:y_max, x_min:x_max].astype(np.float32)
+        blended = roi * (1 - alpha_f32) + overlay_color * alpha_f32
+        image[y_min:y_max, x_min:x_max] = np.clip(blended, 0, 255).astype(np.uint8)
+    else:
+        image[y_min:y_max, x_min:x_max] = overlay[
+            crop_y_min:crop_y_max, crop_x_min:crop_x_max
+        ]
+
+    return image
+
+
+@ensure_cv2_image_for_standalone_function
+def tint_image(
+    image: ImageType,
+    color: Color = Color.BLACK,
+    opacity: float = 0.5,
+) -> ImageType:
+    """
+    Tint image with solid color overlay at specified opacity.
+
+    Args:
+        image: The image to tint.
+        color: Overlay tint color. Defaults to `Color.BLACK`.
+        opacity: Blend ratio between overlay and image (0.0-1.0).
+            Defaults to `0.5`.
+
+    Returns:
+        Tinted image matching input
+            type. The input image is left unchanged.
+
+    Raises:
+        TypeError: If `image` is not a `numpy.ndarray` or `PIL.Image.Image`.
+        ValueError: If opacity is outside range [0.0, 1.0].
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> tinted_image = sv.tint_image(
+        ...     image=image, color=sv.Color.ROBOFLOW, opacity=0.5
+        ... )
+        >>> tinted_image.shape
+        (100, 100, 3)
+        >>> int(image.max())
+        0
+
+        ```
+
+    ![tint-image](https://media.roboflow.com/supervision-docs/supervision-docs-tint-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    if not 0.0 <= opacity <= 1.0:
+        raise ValueError("opacity must be between 0.0 and 1.0")
+
+    overlay = np.full_like(image, fill_value=color.as_bgr(), dtype=image.dtype)
+    # No `dst`: let the blend allocate its own buffer. Passing `image` there wrote
+    # the tint back into the caller's array for a NumPy input, while a Pillow input
+    # was shielded by the ndarray conversion the decorator makes.
+    return cast(
+        npt.NDArray[np.uint8],
+        cv2.addWeighted(
+            src1=overlay, alpha=opacity, src2=image, beta=1 - opacity, gamma=0
+        ),
+    )
+
+
+@ensure_cv2_image_for_standalone_function
+def grayscale_image(image: ImageType) -> ImageType:
+    """
+    Convert image to 3-channel grayscale. Luminance channel is broadcast to
+    all three channels for compatibility with color-based drawing helpers.
+
+    Args:
+        image: The image to convert to
+            grayscale.
+
+    Returns:
+        3-channel grayscale image
+            matching input type.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.ones((100, 100, 3), dtype=np.uint8) * 128
+        >>> grayscale_image = sv.grayscale_image(image=image)
+        >>> grayscale_image.shape
+        (100, 100, 3)
+
+        ```
+
+    ![grayscale-image](https://media.roboflow.com/supervision-docs/supervision-docs-grayscale-image-2.png){ align=center width="1000" }
+    """  # noqa E501 // docs
+    assert isinstance(image, np.ndarray)
+    grayscaled = cast(npt.NDArray[np.uint8], cv2.cvtColor(image, cv2.COLOR_BGR2GRAY))
+    return cast(npt.NDArray[np.uint8], cv2.cvtColor(grayscaled, cv2.COLOR_GRAY2BGR))
+
+
+def get_image_resolution_wh(image: ImageType) -> tuple[int, int]:
+    """
+    Get image width and height as a tuple `(width, height)` for various image formats.
+
+    Supports both `numpy.ndarray` images (with shape `(H, W, ...)`) and
+    `PIL.Image.Image` inputs.
+
+    Args:
+        image: Input image.
+
+    Returns:
+        Image resolution as `(width, height)`.
+
+    Raises:
+        ValueError: If a `numpy.ndarray` image has fewer than 2 dimensions.
+        TypeError: If `image` is not a supported type (`numpy.ndarray` or
+            `PIL.Image.Image`).
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import supervision as sv
+        >>> image = np.zeros((1080, 1920, 3), dtype=np.uint8)
+        >>> sv.get_image_resolution_wh(image)
+        (1920, 1080)
+
+        ```
+    """
+    if isinstance(image, np.ndarray):
+        if image.ndim < 2:
+            raise ValueError(
+                "NumPy image must have at least 2 dimensions (H, W, ...). "
+                f"Received shape: {image.shape}"
+            )
+        height, width = image.shape[:2]
+        return int(width), int(height)
+
+    if isinstance(image, Image.Image):
+        width, height = image.size
+        return int(width), int(height)
+
+    raise TypeError(
+        "`image` must be a numpy.ndarray or PIL.Image.Image. "
+        f"Received type: {type(image)}"
+    )
+
+
+class ImageSink:
+    """
+    Save sequential images into a directory through a context manager.
+
+    `ImageSink` creates the target directory on entry and writes each image
+    using `save_image`, incrementing the image name pattern after every save.
+    """
+
+    def __init__(
+        self,
+        target_dir_path: str,
+        overwrite: bool = False,
+        image_name_pattern: str = "image_{:05d}.png",
+    ) -> None:
+        """
+        Initialize context manager for saving images to directory.
+
+        Args:
+            target_dir_path: Target directory path where images will be
+                saved.
+            overwrite: Whether to overwrite existing directory.
+                Defaults to `False`.
+            image_name_pattern: File name pattern for saved images.
+                Defaults to `"image_{:05d}.png"`.
+
+        Examples:
+            ```pycon
+            >>> import numpy as np
+            >>> import supervision as sv
+            >>> import tempfile
+            >>> import os
+            >>> with tempfile.TemporaryDirectory() as tmpdir:
+            ...     image = np.zeros((100, 100, 3), dtype=np.uint8)
+            ...     with sv.ImageSink(target_dir_path=tmpdir, overwrite=True) as sink:
+            ...         sink.save_image(image=image)
+            ...         sink.save_image(image=image)
+            ...     files = sorted(os.listdir(tmpdir))
+            ...     len(files)
+            2
+
+            ```
+        """
+        self.target_dir_path = target_dir_path
+        self.overwrite = overwrite
+        self.image_name_pattern = image_name_pattern
+        self.image_count = 0
+
+    def __enter__(self) -> ImageSink:
+        if os.path.exists(self.target_dir_path):
+            if self.overwrite:
+                shutil.rmtree(self.target_dir_path)
+                os.makedirs(self.target_dir_path)
+        else:
+            os.makedirs(self.target_dir_path)
+
+        return self
+
+    def save_image(
+        self, image: npt.NDArray[np.uint8], image_name: str | None = None
+    ) -> None:
+        """
+        Save image to target directory with optional custom filename.
+
+        Args:
+            image: Image to save with shape `(height, width, 3)`
+                in BGR format.
+            image_name: Custom filename for saved image. If
+                `None`, generates name using `image_name_pattern`. Defaults to
+                `None`.
+
+        Raises:
+            OSError: If `cv2.imwrite` cannot write the image to disk.
+        """
+        if image_name is None:
+            image_name = self.image_name_pattern.format(self.image_count)
+
+        image_path = os.path.join(self.target_dir_path, image_name)
+        if not cv2.imwrite(image_path, image):
+            raise OSError(f"Failed to save image to path: {image_path}")
+        self.image_count += 1
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        pass
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=TargetMode.NOTIFY,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def create_tiles(
+    images: list[ImageType],
+    grid_size: tuple[int | None, int | None] | None = None,
+    single_tile_size: tuple[int, int] | None = None,
+    tile_scaling: Literal["min", "max", "avg"] = "avg",
+    tile_padding_color: tuple[int, int, int] | Color = Color.from_hex("#D9D9D9"),
+    tile_margin: int = 10,
+    tile_margin_color: tuple[int, int, int] | Color = Color.from_hex("#BFBEBD"),
+    return_type: Literal["auto", "cv2", "pillow"] = "auto",
+    titles: list[str | None] | None = None,
+    titles_anchors: Point | list[Point | None] | None = None,
+    titles_color: tuple[int, int, int] | Color = Color.from_hex("#262523"),
+    titles_scale: float | None = None,
+    titles_thickness: int = 1,
+    titles_padding: int = 10,
+    titles_text_font: int = cv2.FONT_HERSHEY_SIMPLEX,
+    titles_background_color: tuple[int, int, int] | Color = Color.from_hex("#D9D9D9"),
+    default_title_placement: RelativePosition = "top",
+) -> ImageType:
+    """
+    Creates tiles mosaic from input images, automating grid placement and
+    converting images to common resolution maintaining aspect ratio. It is
+    also possible to render text titles on tiles, using optional set of
+    parameters specifying text drawing (see parameters description).
+
+    Automated grid placement will try to maintain square shape of grid
+    (with size being the nearest integer square root of #images), up to two exceptions:
+    * if there are up to 3 images - images will be displayed in single row
+    * if square-grid placement causes last row to be empty - number of rows is trimmed
+        until last row has at least one image
+
+    Args:
+        images: Images to create tiles. Elements can be either np.ndarray or
+            PIL.Image, and a common representation will be agreed by the
+            function.
+        grid_size: Expected grid size in format (n_rows, n_cols). If not
+            given, automated grid placement will be applied. One may also
+            provide only one out of two elements of the tuple - then grid
+            will be created with either n_rows or n_cols fixed, leaving the
+            other dimension to be adjusted by the number of images.
+        single_tile_size: Size of a single tile element provided in
+            (width, height) format. If not given, size of tile will be
+            automatically calculated based on `tile_scaling`.
+        tile_scaling: Strategy used to calculate tile size when
+            `single_tile_size` is not given, using the min / max / avg size
+            of images provided in `images`.
+        tile_padding_color: Color to be used in the image letterbox procedure
+            while standardizing tile sizes. If a tuple is provided, it should
+            be in BGR order.
+        tile_margin: Size of margin between tiles, in pixels.
+        tile_margin_color: Color of the tile margin. If a tuple is provided,
+            it should be in BGR order.
+        return_type: Format of the returned image. One may choose a specific
+            format ("cv2" or "pillow") to enforce conversion. "auto" mode
+            takes a majority vote between types of elements in `images`,
+            resolving draws in favour of OpenCV format. "auto" can be safely
+            used when all input images are of the same type.
+        titles: Optional titles to be added to tiles. Elements of that list
+            may be empty - then a specific tile, in the order presented in
+            `images`, will not be filled with a title. It is possible to
+            provide a list of titles shorter than `images` - then remaining
+            titles will be assumed empty.
+        titles_anchors: Anchor points for titles. It is possible to specify
+            an anchor either globally or for specific tiles, following the
+            order of `images`. If not given, either globally or for a
+            specific element of the list, it will be calculated
+            automatically based on `default_title_placement`.
+        titles_color: Color of the title text. If a tuple is provided, it
+            should be in BGR order.
+        titles_scale: Scale of titles. If not provided, the value will be
+            calculated using `calculate_optimal_text_scale(...)`.
+        titles_thickness: Thickness of title text.
+        titles_padding: Size of title padding.
+        titles_text_font: Font used to render titles. Must be an integer
+            constant representing an OpenCV font.
+            (See docs: https://docs.opencv.org/4.x/d6/d6e/group__imgproc__draw.html)
+        titles_background_color: Color of the title text padding.
+        default_title_placement: Title anchor placement used when an explicit
+            anchor is not provided.
+
+    Returns:
+        ImageType: Image with all input images located in tiles grid. The output type is
+            determined by `return_type` parameter.
+
+    Raises:
+        ValueError: In case when input images list is empty, provided `grid_size` is too
+            small to fit all images, `tile_scaling` mode is invalid.
+    """
+    if len(images) == 0:
+        raise ValueError("Could not create image tiles from empty list of images.")
+    if return_type == "auto":
+        return_type = _negotiate_tiles_format(images=images)
+    tile_padding_color = unify_to_bgr(color=tile_padding_color)
+    tile_margin_color = unify_to_bgr(color=tile_margin_color)
+    images_cv2 = images_to_cv2(images=images)
+    if single_tile_size is None:
+        single_tile_size = _aggregate_images_shape(images=images_cv2, mode=tile_scaling)
+    resized_images = [
+        letterbox_image(
+            image=i, resolution_wh=single_tile_size, color=tile_padding_color
+        )
+        for i in images_cv2
+    ]
+    grid_size = _establish_grid_size(images=images_cv2, grid_size=grid_size)
+    if len(images_cv2) > grid_size[0] * grid_size[1]:
+        raise ValueError(
+            f"Could not place {len(images_cv2)} in grid with size: {grid_size}."
+        )
+    if titles is not None:
+        titles = fill(sequence=titles, desired_size=len(images_cv2), content=None)
+    if isinstance(titles_anchors, list):
+        titles_anchors_sequence = titles_anchors
+    else:
+        titles_anchors_sequence = [titles_anchors]
+    titles_anchors = fill(
+        sequence=titles_anchors_sequence, desired_size=len(images_cv2), content=None
+    )
+    titles_color = unify_to_bgr(color=titles_color)
+    titles_background_color = unify_to_bgr(color=titles_background_color)
+    tiles_image = _generate_tiles(
+        images=resized_images,
+        grid_size=grid_size,
+        single_tile_size=single_tile_size,
+        tile_padding_color=tile_padding_color,
+        tile_margin=tile_margin,
+        tile_margin_color=tile_margin_color,
+        titles=titles,
+        titles_anchors=titles_anchors,
+        titles_color=titles_color,
+        titles_scale=titles_scale,
+        titles_thickness=titles_thickness,
+        titles_padding=titles_padding,
+        titles_text_font=titles_text_font,
+        titles_background_color=titles_background_color,
+        default_title_placement=default_title_placement,
+    )
+    if return_type == "pillow":
+        tiles_image_pillow: object = cv2_to_pillow(image=tiles_image)
+        return cast(ImageType, tiles_image_pillow)
+    tiles_image_cv2: object = tiles_image
+    return cast(ImageType, tiles_image_cv2)
+
+
+def _negotiate_tiles_format(images: list[ImageType]) -> Literal["cv2", "pillow"]:
+    number_of_np_arrays = sum(issubclass(type(i), np.ndarray) for i in images)
+    if number_of_np_arrays * 2 >= len(images):
+        return "cv2"
+    return "pillow"
+
+
+def _calculate_aggregated_images_shape(
+    images: list[npt.NDArray[np.uint8]], aggregator: Callable[[list[int]], float]
+) -> tuple[int, int]:
+    height = round(aggregator([i.shape[0] for i in images]))
+    width = round(aggregator([i.shape[1] for i in images]))
+    return width, height
+
+
+SHAPE_AGGREGATION_FUN = {
+    "min": partial(_calculate_aggregated_images_shape, aggregator=np.min),
+    "max": partial(_calculate_aggregated_images_shape, aggregator=np.max),
+    "avg": partial(_calculate_aggregated_images_shape, aggregator=np.average),
+}
+
+
+def _aggregate_images_shape(
+    images: list[npt.NDArray[np.uint8]], mode: Literal["min", "max", "avg"]
+) -> tuple[int, int]:
+    if mode not in SHAPE_AGGREGATION_FUN:
+        raise ValueError(
+            f"Could not aggregate images shape - provided unknown mode: {mode}. "
+            f"Supported modes: {list(SHAPE_AGGREGATION_FUN.keys())}."
+        )
+    return SHAPE_AGGREGATION_FUN[mode](images)
+
+
+def _establish_grid_size(
+    images: list[npt.NDArray[np.uint8]],
+    grid_size: tuple[int | None, int | None] | None,
+) -> tuple[int, int]:
+    if grid_size is None or all(e is None for e in grid_size):
+        return _negotiate_grid_size(images=images)
+    if grid_size[0] is None:
+        columns = grid_size[1]
+        assert columns is not None
+        return math.ceil(len(images) / columns), columns
+    if grid_size[1] is None:
+        rows = grid_size[0]
+        assert rows is not None
+        return rows, math.ceil(len(images) / rows)
+    return cast(tuple[int, int], grid_size)
+
+
+def _negotiate_grid_size(images: list[npt.NDArray[np.uint8]]) -> tuple[int, int]:
+    if len(images) <= MAX_COLUMNS_FOR_SINGLE_ROW_GRID:
+        return 1, len(images)
+    nearest_sqrt = math.ceil(np.sqrt(len(images)))
+    proposed_columns = nearest_sqrt
+    proposed_rows = nearest_sqrt
+    while proposed_columns * (proposed_rows - 1) >= len(images):
+        proposed_rows -= 1
+    return proposed_rows, proposed_columns
+
+
+def _generate_tiles(
+    images: list[npt.NDArray[np.uint8]],
+    grid_size: tuple[int, int],
+    single_tile_size: tuple[int, int],
+    tile_padding_color: tuple[int, int, int],
+    tile_margin: int,
+    tile_margin_color: tuple[int, int, int],
+    titles: list[str | None] | None,
+    titles_anchors: list[Point | None],
+    titles_color: tuple[int, int, int],
+    titles_scale: float | None,
+    titles_thickness: int,
+    titles_padding: int,
+    titles_text_font: int,
+    titles_background_color: tuple[int, int, int],
+    default_title_placement: RelativePosition,
+) -> npt.NDArray[np.uint8]:
+    images = _draw_texts(
+        images=images,
+        titles=titles,
+        titles_anchors=titles_anchors,
+        titles_color=titles_color,
+        titles_scale=titles_scale,
+        titles_thickness=titles_thickness,
+        titles_padding=titles_padding,
+        titles_text_font=titles_text_font,
+        titles_background_color=titles_background_color,
+        default_title_placement=default_title_placement,
+    )
+    rows, columns = grid_size
+    tiles_elements = list(create_batches(sequence=images, batch_size=columns))
+    while len(tiles_elements[-1]) < columns:
+        tiles_elements[-1].append(
+            _generate_color_image(shape=single_tile_size, color=tile_padding_color)
+        )
+    while len(tiles_elements) < rows:
+        tiles_elements.append(
+            [_generate_color_image(shape=single_tile_size, color=tile_padding_color)]
+            * columns
+        )
+    return _merge_tiles_elements(
+        tiles_elements=tiles_elements,
+        grid_size=grid_size,
+        single_tile_size=single_tile_size,
+        tile_margin=tile_margin,
+        tile_margin_color=tile_margin_color,
+    )
+
+
+def _draw_texts(
+    images: list[npt.NDArray[np.uint8]],
+    titles: list[str | None] | None,
+    titles_anchors: list[Point | None],
+    titles_color: tuple[int, int, int],
+    titles_scale: float | None,
+    titles_thickness: int,
+    titles_padding: int,
+    titles_text_font: int,
+    titles_background_color: tuple[int, int, int],
+    default_title_placement: RelativePosition,
+) -> list[npt.NDArray[np.uint8]]:
+    if titles is None:
+        return images
+    prepared_titles_anchors = _prepare_default_titles_anchors(
+        images=images,
+        titles_anchors=titles_anchors,
+        default_title_placement=default_title_placement,
+    )
+    if titles_scale is None:
+        image_height, image_width = images[0].shape[:2]
+        titles_scale = calculate_optimal_text_scale(
+            resolution_wh=(image_width, image_height)
+        )
+    result = []
+    for image, text, anchor in zip(images, titles, prepared_titles_anchors):
+        if text is None:
+            result.append(image)
+            continue
+        processed_image = draw_text(
+            scene=image,
+            text=text,
+            text_anchor=anchor,
+            text_color=Color.from_bgr_tuple(titles_color),
+            text_scale=titles_scale,
+            text_thickness=titles_thickness,
+            text_padding=titles_padding,
+            text_font=titles_text_font,
+            background_color=Color.from_bgr_tuple(titles_background_color),
+        )
+        result.append(processed_image)
+    return result
+
+
+def _prepare_default_titles_anchors(
+    images: list[npt.NDArray[np.uint8]],
+    titles_anchors: list[Point | None],
+    default_title_placement: RelativePosition,
+) -> list[Point]:
+    result = []
+    for image, anchor in zip(images, titles_anchors):
+        if anchor is not None:
+            result.append(anchor)
+            continue
+        image_height, image_width = image.shape[:2]
+        if default_title_placement == "top":
+            default_anchor = Point(x=image_width / 2, y=image_height * 0.1)
+        else:
+            default_anchor = Point(x=image_width / 2, y=image_height * 0.9)
+        result.append(default_anchor)
+    return result
+
+
+def _merge_tiles_elements(
+    tiles_elements: list[list[npt.NDArray[np.uint8]]],
+    grid_size: tuple[int, int],
+    single_tile_size: tuple[int, int],
+    tile_margin: int,
+    tile_margin_color: tuple[int, int, int],
+) -> npt.NDArray[np.uint8]:
+    vertical_padding: npt.NDArray[np.uint8] = np.full(
+        (single_tile_size[1], tile_margin, 3),
+        tile_margin_color,
+        dtype=np.uint8,
+    )
+    merged_rows = [
+        np.concatenate(
+            list(
+                itertools.chain.from_iterable(
+                    zip(row, [vertical_padding] * grid_size[1])
+                )
+            )[:-1],
+            axis=1,
+        )
+        for row in tiles_elements
+    ]
+    row_width = merged_rows[0].shape[1]
+    horizontal_padding: npt.NDArray[np.uint8] = np.full(
+        (tile_margin, row_width, 3),
+        tile_margin_color,
+        dtype=np.uint8,
+    )
+    rows_with_paddings: list[npt.NDArray[np.uint8]] = []
+    for row in merged_rows:
+        rows_with_paddings.append(row)
+        rows_with_paddings.append(horizontal_padding)
+    return np.concatenate(rows_with_paddings[:-1], axis=0).astype(np.uint8, copy=False)
+
+
+def _generate_color_image(
+    shape: tuple[int, int], color: tuple[int, int, int]
+) -> npt.NDArray[np.uint8]:
+    return np.full((*shape[::-1], 3), color, dtype=np.uint8)
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/image_window.py b/.venv/lib/python3.12/site-packages/supervision/utils/image_window.py
new file mode 100644
index 0000000000000000000000000000000000000000..796b018fcf178582b2a410b8a199bebea6ebef1a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/image_window.py
@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from contextlib import suppress
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+from supervision.utils.conversion import cv2_to_pillow
+
+MouseCallback = Callable[[int, int, str], None]
+
+
+class ImageWindow:
+    """Desktop image window backed by stdlib tkinter + pillow.
+
+    Functional replacement for `cv2.imshow` / `cv2.waitKey` that works under
+    `opencv-python-headless`. Requires tkinter (stdlib) and pillow (already a
+    supervision dependency). Instantiation always succeeds; `show()` raises
+    `ModuleNotFoundError` (No module named '_tkinter') on environments where
+    `python3-tk` is absent — install with ``sudo apt-get install python3-tk``
+    (Debian/Ubuntu) or ``brew install tcl-tk`` (macOS with Homebrew/pyenv)
+    — and raises `tkinter.TclError` on headless servers where a display is
+    unavailable.
+
+    Differences from cv2:
+        - `wait_key()` returns a tkinter keysym `str` (e.g. ``"q"``,
+          ``"Return"``, ``"Escape"``) or ``None``, not an ``int``. Code
+          relying on ``key == ord("q")`` or ``key & 0xFF == 27`` must be
+          updated to ``key == "q"`` or ``key == "Escape"``.
+        - Mouse callback signature is ``(x: int, y: int, event_type: str)``
+          where ``event_type`` is ``"down"``, ``"up"``, or ``"move"``. This
+          differs from cv2's ``(event: int, x, y, flags, param)`` — existing
+          cv2 mouse callbacks are not compatible without modification.
+        - Only left-button events are captured. Right-button clicks, scroll
+          events, and modifier-key flags (Ctrl, Shift) have no equivalent.
+
+    Args:
+        title: Window title bar text.
+        keep_aspect_ratio: If ``True`` (default), frames are scaled to fit
+            inside the window while preserving aspect ratio (letterboxed). If
+            ``False``, frames are stretched to fill the window exactly.
+
+    Examples:
+        ```python
+        import supervision as sv
+
+        window = sv.ImageWindow("preview")
+        for frame in sv.get_video_frames_generator(source_path="video.mp4"):
+            annotated = ...  # annotate frame
+            window.show(annotated)
+            if window.wait_key(delay_ms=1) == "q":
+                break
+        window.close()
+        ```
+
+        Context-manager form closes automatically:
+
+        ```python
+        import supervision as sv
+
+        with sv.ImageWindow("preview") as window:
+            for frame in sv.get_video_frames_generator(source_path="video.mp4"):
+                window.show(frame)
+                if window.wait_key(delay_ms=1) == "q":
+                    break
+        ```
+    """
+
+    def __init__(
+        self, title: str = "supervision", keep_aspect_ratio: bool = True
+    ) -> None:
+        self.title = title
+        self.keep_aspect_ratio = keep_aspect_ratio
+        self._mouse_callback: MouseCallback | None = None
+        self._root: Any = None
+        self._label: Any = None
+        self._photo: Any = None
+        self._key_event: Any = None
+        self._key_queue: list[str] = []
+        self._pil_image: Image.Image | None = None
+        self._win_w: int = 0
+        self._win_h: int = 0
+        self._display_scale_x: float = 1.0
+        self._display_scale_y: float = 1.0
+        self._display_offset_x: float = 0.0
+        self._display_offset_y: float = 0.0
+
+    def show(self, image: npt.NDArray[np.uint8]) -> None:
+        """Display a BGR, grayscale, or BGRA frame in the window.
+
+        The image is scaled to fit the current window dimensions. Aspect ratio is
+        preserved unless `keep_aspect_ratio=False`. Resizing the window rescales live.
+        Args:
+            image: uint8 numpy array. Accepted shapes:
+                - ``(H, W)`` — grayscale
+                - ``(H, W, 3)`` — BGR (OpenCV convention; channels are swapped
+                  to RGB before display)
+                - ``(H, W, 4)`` — BGRA (channels reordered to RGBA)
+
+        Raises:
+            TypeError: If `image.dtype` is not `uint8`.
+            ValueError: If `image` is not 2-D or 3-D with 3 or 4 channels.
+        """
+        if image.dtype != np.uint8:
+            raise TypeError(
+                f"image must be uint8, got {image.dtype}. "
+                "Convert with image.astype(np.uint8) before calling show()."
+            )
+        self._pil_image = _bgr_to_pil(image)
+        self._ensure_window()
+        self._update_display()
+        self._root.update_idletasks()
+        self._root.update()
+
+    def wait_key(self, delay_ms: int = 0) -> str | None:
+        """Wait for a keypress and return its name.
+
+        Args:
+            delay_ms: How long to wait in milliseconds. ``0`` blocks until a
+                key is pressed. Positive values poll for up to `delay_ms` ms
+                and return ``None`` if no key arrives in time.
+
+        Returns:
+            The tkinter keysym string (e.g. ``"q"``, ``"Return"``, ``"Escape"``)
+            or ``None`` if the timeout elapsed without a key event.
+        """
+        if self._root is None and not self._key_queue:
+            return None
+        self._ensure_window()
+        if self._key_queue:
+            return self._key_queue.pop(0)
+        root = self._root
+        if delay_ms <= 0:
+            self._wait_for_key_or_close()
+        else:
+            timeout_id = root.after(delay_ms, self._signal_wait)
+            self._wait_for_key_or_close()
+            if self._root is not None:
+                with suppress(Exception):
+                    root.after_cancel(timeout_id)
+        return self._key_queue.pop(0) if self._key_queue else None
+
+    def set_mouse_callback(self, callback: MouseCallback | None) -> None:
+        """Register a callback for mouse events on the image.
+
+        Args:
+            callback: Callable receiving ``(x, y, event_type)`` where
+                ``event_type`` is one of ``"down"``, ``"up"``, or ``"move"``.
+                Pass ``None`` to remove the callback.
+        """
+        self._mouse_callback = callback
+
+    @property
+    def is_open(self) -> bool:
+        """Return whether the underlying Tk window currently exists."""
+        return self._window_exists()
+
+    def close(self) -> None:
+        """Destroy the window and release its resources."""
+        if self._root is not None:
+            root = self._root
+            self._signal_wait()
+            with suppress(Exception):
+                root.destroy()
+            self._reset_window_refs()
+
+    def __enter__(self) -> ImageWindow:
+        return self
+
+    def __exit__(self, *_: object) -> None:
+        self.close()
+
+    def _ensure_window(self) -> None:
+        if self._window_exists():
+            return
+        self._reset_window_refs()
+        import tkinter as tk
+
+        self._root = tk.Tk()
+        self._root.title(self.title)
+        self._label = tk.Label(self._root)
+        self._label.pack(expand=True, fill="both")
+        self._key_event = tk.IntVar(master=self._root, value=0)
+        self._root.bind("", self._on_key)
+        self._root.bind("", self._on_configure)
+        self._root.protocol("WM_DELETE_WINDOW", self.close)
+        self._label.bind("", lambda e: self._on_mouse(e, "down"))
+        self._label.bind("", lambda e: self._on_mouse(e, "up"))
+        self._label.bind("", lambda e: self._on_mouse(e, "move"))
+
+    def _on_configure(self, event: Any) -> None:
+        if event.widget is not self._root:
+            return
+        w, h = event.width, event.height
+        if w > 1 and h > 1 and (w, h) != (self._win_w, self._win_h):
+            self._win_w, self._win_h = w, h
+            if self._pil_image is not None:
+                self._update_display()
+
+    def _update_display(self) -> None:
+        if self._pil_image is None or self._label is None:
+            return
+        from PIL import ImageTk
+
+        img = self._pil_image
+        if self._win_w > 1 and self._win_h > 1:
+            img = _fit_image(img, self._win_w, self._win_h, self.keep_aspect_ratio)
+        self._update_display_transform(img)
+        self._photo = ImageTk.PhotoImage(img)
+        self._label.configure(image=self._photo)
+
+    def _update_display_transform(self, fitted: Image.Image) -> None:
+        """Record the scale and letterbox offset from the last display pass.
+
+        The fitted image is drawn centered inside the label, so mouse events on
+        the label carry display-space coordinates. Storing the per-axis scale
+        and centering offset lets `_on_mouse` invert the transform back to
+        original image-pixel coordinates. Falls back to an identity transform
+        while the window geometry is still unknown.
+        """
+        if self._pil_image is None:
+            return
+        orig_w, orig_h = self._pil_image.size
+        fit_w, fit_h = fitted.size
+        win_w = self._win_w if self._win_w > 1 else fit_w
+        win_h = self._win_h if self._win_h > 1 else fit_h
+        self._display_scale_x = fit_w / orig_w if orig_w else 1.0
+        self._display_scale_y = fit_h / orig_h if orig_h else 1.0
+        self._display_offset_x = max(0.0, (win_w - fit_w) / 2)
+        self._display_offset_y = max(0.0, (win_h - fit_h) / 2)
+
+    def _on_key(self, event: Any) -> None:
+        self._key_queue.append(event.keysym)
+        self._signal_wait()
+
+    def _on_mouse(self, event: Any, event_type: str) -> None:
+        if self._mouse_callback is None:
+            return
+        x, y = self._to_image_coords(event.x, event.y)
+        self._mouse_callback(x, y, event_type)
+
+    def _to_image_coords(self, event_x: int, event_y: int) -> tuple[int, int]:
+        """Map label-space event coordinates to original image pixels.
+
+        Inverts the scale and letterbox offset recorded by `_update_display`
+        so callbacks receive coordinates in the source image's pixel space,
+        regardless of how the window has been resized. Results are rounded to
+        the nearest pixel and clamped inside the image bounds. When no image
+        has been shown, the raw event coordinates are returned unchanged.
+        """
+        if self._pil_image is None:
+            return event_x, event_y
+        orig_w, orig_h = self._pil_image.size
+        image_x = round((event_x - self._display_offset_x) / self._display_scale_x)
+        image_y = round((event_y - self._display_offset_y) / self._display_scale_y)
+        clamped_x = min(max(image_x, 0), orig_w - 1)
+        clamped_y = min(max(image_y, 0), orig_h - 1)
+        return clamped_x, clamped_y
+
+    def _signal_wait(self) -> None:
+        if self._key_event is None:
+            return
+        with suppress(Exception):
+            self._key_event.set(self._key_event.get() + 1)
+
+    def _wait_for_key_or_close(self) -> None:
+        if self._root is None or self._key_event is None:
+            return
+        if self._key_queue:
+            return
+        try:
+            self._root.wait_variable(self._key_event)
+        except Exception:
+            self._reset_window_refs()
+
+    def _window_exists(self) -> bool:
+        if self._root is None:
+            return False
+        try:
+            return bool(self._root.winfo_exists())
+        except Exception:
+            return False
+
+    def _reset_window_refs(self) -> None:
+        self._root = None
+        self._label = None
+        self._photo = None
+        self._key_event = None
+        self._key_queue.clear()
+        self._win_w = 0
+        self._win_h = 0
+        self._display_scale_x = 1.0
+        self._display_scale_y = 1.0
+        self._display_offset_x = 0.0
+        self._display_offset_y = 0.0
+        self._pil_image = None
+
+
+def _fit_image(
+    image: Image.Image, width: int, height: int, keep_aspect_ratio: bool = True
+) -> Image.Image:
+    iw, ih = image.size
+    if keep_aspect_ratio:
+        scale = min(width / iw, height / ih)
+        new_w, new_h = max(1, round(iw * scale)), max(1, round(ih * scale))
+    else:
+        new_w, new_h = width, height
+    if (new_w, new_h) == (iw, ih):
+        return image
+    return image.resize((new_w, new_h), Image.Resampling.LANCZOS)
+
+
+def _bgr_to_pil(image: npt.NDArray[np.uint8]) -> Image.Image:
+    """Convert a BGR, grayscale, or BGRA OpenCV array to a Pillow image.
+
+    Thin wrapper delegating to `sv.cv2_to_pillow`, which reorders channels
+    from OpenCV's BGR(A) convention to Pillow's RGB(A) and passes grayscale
+    arrays through unchanged.
+    """
+    return cv2_to_pillow(image)
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/internal.py b/.venv/lib/python3.12/site-packages/supervision/utils/internal.py
new file mode 100644
index 0000000000000000000000000000000000000000..2376324ac0b8d3535b1ec91a0552582ce5b20060
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/internal.py
@@ -0,0 +1,209 @@
+import functools
+import inspect
+import os
+import warnings
+from collections.abc import Callable
+from typing import Any, Generic, TypeVar
+
+
+class SupervisionWarnings(Warning):
+    """Supervision warning category.
+    Set the deprecation warnings visibility for Supervision library.
+    You can set the environment variable SUPERVISION_DEPRECATION_WARNING to '0'
+    to disable the deprecation warnings. The legacy misspelled
+    SUPERVISON_DEPRECATION_WARNING variable is still accepted.
+    """
+
+    pass
+
+
+def format_warning(
+    message: Warning | str,
+    category: type[Warning],
+    filename: str,
+    lineno: int,
+    line: str | None = None,
+) -> str:
+    """
+    Format a warning the same way as the default formatter, but also include the
+    category name in the output.
+    """
+    return f"{category.__name__}: {message}\n"
+
+
+deprecation_warning_env = os.getenv(
+    "SUPERVISION_DEPRECATION_WARNING",
+    os.getenv("SUPERVISON_DEPRECATION_WARNING"),
+)
+if deprecation_warning_env == "0":
+    warnings.simplefilter("ignore", SupervisionWarnings)
+else:
+    warnings.simplefilter("always", SupervisionWarnings)
+
+
+def warn_deprecated(message: str) -> None:
+    """
+    Issue a warning that a function is deprecated.
+
+    Args:
+        message: The message to display when the function is called.
+    """
+    warnings.warn(message, category=SupervisionWarnings, stacklevel=2)
+
+
+def deprecated_parameter(
+    old_parameter: str,
+    new_parameter: str,
+    map_function: Callable[[Any], Any] = lambda x: x,
+    warning_message: str = "Warning: '{old_parameter}' in '{function_name}' is "
+    "deprecated: use '{new_parameter}' instead.",
+    **message_kwargs: Any,
+) -> Callable[[Any], Any]:
+    """
+    A decorator to mark a function's parameter as deprecated and issue a warning when
+    used.
+
+    Args:
+        old_parameter: The name of the deprecated parameter.
+        new_parameter: The name of the parameter that should be used instead.
+        map_function: A function used to map the value of the old
+            parameter to the new parameter. Defaults to the identity function.
+        warning_message: The warning message to be displayed when the
+            deprecated parameter is used. Defaults to a generic warning message with
+            placeholders for the old parameter, new parameter, and function name.
+        **message_kwargs: Additional keyword arguments that can be used to customize
+            the warning message.
+
+    Returns:
+        A decorator function that can be applied to mark a function's
+            parameter as deprecated.
+
+    Examples:
+        ```pycon
+        >>> from supervision.utils.internal import deprecated_parameter
+        >>> import warnings
+        >>> @deprecated_parameter(
+        ...     old_parameter='old_name',
+        ...     new_parameter='new_name'
+        ... )
+        ... def example_function(new_name=None):
+        ...     return new_name
+        >>> # Calling with new parameter works normally
+        >>> example_function(new_name='value')
+        'value'
+        >>> # Calling with old parameter triggers warning but still works
+        >>> with warnings.catch_warnings(record=True):
+        ...     result = example_function(old_name='deprecated_value')
+        ...     print(result)
+        deprecated_value
+
+        ```
+    """
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        @functools.wraps(func)
+        def wrapper(*args: Any, **kwargs: Any) -> Any:
+            if old_parameter in kwargs:
+                if args and hasattr(args[0], "__class__"):
+                    class_name = args[0].__class__.__name__
+                    function_name = f"{class_name}.{func.__name__}"
+                else:
+                    function_name = func.__name__
+
+                warn_deprecated(
+                    message=warning_message.format(
+                        function_name=function_name,
+                        old_parameter=old_parameter,
+                        new_parameter=new_parameter,
+                        **message_kwargs,
+                    )
+                )
+
+                kwargs[new_parameter] = map_function(kwargs.pop(old_parameter))
+
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+T = TypeVar("T")
+
+
+class classproperty(Generic[T]):
+    """
+    A decorator that combines @classmethod and @property.
+    It allows a method to be accessed as a property of the class,
+    rather than an instance, similar to a classmethod.
+
+    Usage:
+        @classproperty
+        def my_method(cls):
+            ...
+    """
+
+    def __init__(self, fget: Callable[..., T]) -> None:
+        """
+        Args:
+            The function that is called when the property is accessed.
+        """
+        self.fget = fget
+
+    def __get__(self, owner_self: Any, owner_cls: type | None = None) -> T:
+        """
+        Override the __get__ method to return the result of the function call.
+
+        Args:
+            owner_self: The instance through which the attribute was accessed, or None.
+                Irrelevant for class properties.
+            owner_cls: The class through which the attribute was accessed.
+
+        Returns:
+            The result of calling the function stored in 'fget' with 'owner_cls'.
+        """
+        if self.fget is None:
+            raise AttributeError("unreadable attribute")
+        return self.fget(owner_cls)
+
+
+def get_instance_variables(instance: Any, include_properties: bool = False) -> set[str]:
+    """
+    Get the public variables of a class instance.
+
+    Args:
+        instance: The instance of a class
+        include_properties: Whether to include properties in the result
+
+    Usage:
+        ```pycon
+        >>> from supervision.utils.internal import get_instance_variables
+        >>> import numpy as np
+        >>> from supervision import Detections
+        >>> detections = Detections(xyxy=np.array([[1, 2, 3, 4]]))
+        >>> variables = get_instance_variables(detections)
+        >>> 'xyxy' in variables
+        True
+        >>> 'data' in variables
+        True
+
+        ```
+    """
+    if isinstance(instance, type):
+        raise ValueError("Only class instances are supported, not classes.")
+
+    fields = {
+        name
+        for name, val in inspect.getmembers(instance)
+        if not callable(val) and not name.startswith("_")
+    }
+
+    if not include_properties:
+        properties = {
+            name
+            for name, val in inspect.getmembers(instance.__class__)
+            if isinstance(val, property)
+        }
+        fields -= properties
+
+    return fields
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/iterables.py b/.venv/lib/python3.12/site-packages/supervision/utils/iterables.py
new file mode 100644
index 0000000000000000000000000000000000000000..9b30e6bb3bab07f1f51c626c2ac5f31632980fa5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/iterables.py
@@ -0,0 +1,103 @@
+from collections.abc import Generator, Iterable
+from typing import TypeVar
+
+V = TypeVar("V")
+
+
+def create_batches(
+    sequence: Iterable[V], batch_size: int
+) -> Generator[list[V], None, None]:
+    """
+    Provides a generator that yields chunks of the input sequence
+    of the size specified by the `batch_size` parameter. The last
+    chunk may be a smaller batch.
+
+    Args:
+        sequence: The sequence to be split into batches.
+        batch_size: The expected size of a batch.
+
+    Returns:
+        A generator that yields chunks
+            of `sequence` of size `batch_size`, up to the length of
+            the input `sequence`.
+
+    Examples:
+        ```pycon
+        >>> from supervision.utils.iterables import create_batches
+        >>> list(create_batches([1, 2, 3, 4, 5], 2))
+        [[1, 2], [3, 4], [5]]
+        >>> list(create_batches("abcde", 3))
+        [['a', 'b', 'c'], ['d', 'e']]
+
+        ```
+    """
+    batch_size = max(batch_size, 1)
+    current_batch: list[V] = []
+    for element in sequence:
+        if len(current_batch) == batch_size:
+            yield current_batch
+            current_batch = []
+        current_batch.append(element)
+    if current_batch:
+        yield current_batch
+
+
+def fill(sequence: list[V], desired_size: int, content: V) -> list[V]:
+    """
+    Fill the sequence with padding elements until the sequence reaches
+    the desired size.
+
+    Args:
+        sequence: The input sequence.
+        desired_size: The expected size of the output list. The
+            difference between this value and the actual length of `sequence`
+            (if positive) dictates how many elements will be added as padding.
+        content: The element to be placed at the end of the input
+            `sequence` as padding.
+
+    Returns:
+        A padded version of the input `sequence` (if needed).
+
+    Examples:
+        ```pycon
+        >>> from supervision.utils.iterables import fill
+        >>> fill([1, 2], 4, 0)
+        [1, 2, 0, 0]
+        >>> fill(['a', 'b'], 3, 'c')
+        ['a', 'b', 'c']
+
+        ```
+    """
+    missing_size = max(0, desired_size - len(sequence))
+    sequence.extend([content] * missing_size)
+    return sequence
+
+
+def find_duplicates(sequence: list[V]) -> list[V]:
+    """
+    Find all duplicate elements in the input sequence.
+
+    Args:
+        sequence: The input sequence.
+
+    Returns:
+        A list of duplicate elements found in the sequence.
+
+    Examples:
+        ```pycon
+        >>> from supervision.utils.iterables import find_duplicates
+        >>> sorted(find_duplicates([1, 2, 3, 2, 4, 5, 1]))
+        [1, 2]
+        >>> find_duplicates(['a', 'b', 'c'])
+        []
+
+        ```
+    """
+    seen = set()
+    duplicates = set()
+    for element in sequence:
+        if element in seen:
+            duplicates.add(element)
+        else:
+            seen.add(element)
+    return list(duplicates)
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/logger.py b/.venv/lib/python3.12/site-packages/supervision/utils/logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ed8c452d8ba852c40192787f9ee513c2b26a4f5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/logger.py
@@ -0,0 +1,61 @@
+import logging
+import os
+import sys
+
+
+def _get_logger(name: str = "supervision", level: int | None = None) -> logging.Logger:
+    """Creates and configures a logger with stdout and stderr handlers.
+
+    This function creates a logger that sends INFO and DEBUG level logs to stdout,
+    and WARNING, ERROR, and CRITICAL level logs to stderr. If the logger already
+    has handlers, it returns the existing logger without adding new handlers.
+
+    The log level can be specified directly or through the `LOG_LEVEL` environment
+    variable.
+
+    Args:
+        name: The name of the logger. Defaults to `"supervision"`.
+        level: The logging level to set. If `None`, uses the `LOG_LEVEL` environment
+            variable, defaulting to `INFO` if not set.
+
+    Returns:
+        A configured `logging.Logger` instance.
+
+    Example:
+        ```pycon
+        >>> from supervision.utils.logger import _get_logger
+        >>> import logging
+        >>> logger = _get_logger("test_logger", level=logging.INFO)
+        >>> logger.name
+        'test_logger'
+        >>> logger.level == logging.INFO
+        True
+
+        ```
+    """
+    if level is None:
+        level = getattr(logging, os.getenv("LOG_LEVEL", "INFO").upper(), logging.INFO)
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    if not logger.handlers:
+        formatter = logging.Formatter(
+            "[%(asctime)s] [%(levelname)s] %(name)s - %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S",
+        )
+
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setLevel(logging.DEBUG)
+        stdout_handler.addFilter(lambda r: r.levelno <= logging.INFO)
+        stdout_handler.setFormatter(formatter)
+
+        stderr_handler = logging.StreamHandler(sys.stderr)
+        stderr_handler.setLevel(logging.WARNING)
+        stderr_handler.setFormatter(formatter)
+
+        logger.addHandler(stdout_handler)
+        logger.addHandler(stderr_handler)
+        logger.propagate = False
+
+    return logger
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/notebook.py b/.venv/lib/python3.12/site-packages/supervision/utils/notebook.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9965d43949d1b7dc8598070ea04ce64fd2b797b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/notebook.py
@@ -0,0 +1,123 @@
+import numpy as np
+import numpy.typing as npt
+from PIL import Image
+
+from supervision import _cv2 as cv2
+from supervision.draw.base import ImageType
+from supervision.utils.conversion import pillow_to_cv2
+
+
+def plot_image(
+    image: ImageType, size: tuple[int, int] = (12, 12), cmap: str | None = "gray"
+) -> None:
+    """
+    Plots image using matplotlib.
+
+    Args:
+        image: The frame to be displayed ImageType
+             is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`.
+        size: The size of the plot in inches.
+        cmap: the colormap to use for single channel images.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import matplotlib
+        >>> matplotlib.use('Agg')  # Prevents the GUI window from popping up
+        >>> import supervision as sv
+        >>> image = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> sv.plot_image(image=image, size=(16, 16))
+        ...
+
+        ```
+    """
+    if isinstance(image, Image.Image):
+        image_np = pillow_to_cv2(image)
+    else:
+        image_np = image
+
+    # Keep pyplot lazy so importing notebook helpers does not import matplotlib.
+    import matplotlib.pyplot as plt
+
+    plt.figure(figsize=size)
+
+    if image_np.ndim == 2:
+        plt.imshow(image_np, cmap=cmap)
+    else:
+        plt.imshow(cv2.cvtColor(image_np, cv2.COLOR_BGR2RGB))
+
+    plt.axis("off")
+    plt.show()
+
+
+def plot_images_grid(
+    images: list[ImageType],
+    grid_size: tuple[int, int],
+    titles: list[str] | None = None,
+    size: tuple[int, int] = (12, 12),
+    cmap: str | None = "gray",
+) -> None:
+    """
+    Plots images in a grid using matplotlib.
+
+    Args:
+       images: A list of images as ImageType
+             is a flexible type, accepting either `numpy.ndarray` or `PIL.Image.Image`.
+       grid_size: A tuple specifying the number
+            of rows and columns for the grid.
+       titles: A list of titles for each image.
+            Defaults to None.
+       size: A tuple specifying the width and
+            height of the entire plot in inches.
+       cmap: the colormap to use for single channel images.
+
+    Raises:
+       ValueError: If the number of images exceeds the grid size.
+
+    Examples:
+        ```pycon
+        >>> import numpy as np
+        >>> import matplotlib
+        >>> matplotlib.use('Agg')  # Prevents the GUI window from popping up
+        >>> import supervision as sv
+        >>> from PIL import Image
+        >>> image1 = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> image2 = Image.new('RGB', (100, 100))
+        >>> image3 = np.zeros((100, 100, 3), dtype=np.uint8)
+        >>> images = [image1, image2, image3]
+        >>> titles = ["Image 1", "Image 2", "Image 3"]
+        >>> sv.plot_images_grid(images, grid_size=(2, 2), titles=titles, size=(16, 16))
+        ...
+
+        ```
+    """
+    nrows, ncols = grid_size
+
+    images_np: list[npt.NDArray[np.uint8]] = [
+        pillow_to_cv2(img) if isinstance(img, Image.Image) else img for img in images
+    ]
+
+    if len(images_np) > nrows * ncols:
+        raise ValueError(
+            "The number of images exceeds the grid size. Please increase the grid size"
+            " or reduce the number of images."
+        )
+
+    # Keep pyplot lazy so importing notebook helpers does not import matplotlib.
+    import matplotlib.pyplot as plt
+
+    # Without `squeeze=False`, a 1x1 grid returns a lone `Axes` that has no `.flat`.
+    _fig, axes = plt.subplots(nrows=nrows, ncols=ncols, figsize=size, squeeze=False)
+
+    for idx, ax in enumerate(axes.flat):
+        if idx < len(images_np):
+            if images_np[idx].ndim == 2:
+                ax.imshow(images_np[idx], cmap=cmap)
+            else:
+                ax.imshow(cv2.cvtColor(images_np[idx], cv2.COLOR_BGR2RGB))
+
+            if titles is not None and idx < len(titles):
+                ax.set_title(titles[idx])
+
+        ax.axis("off")
+    plt.show()
diff --git a/.venv/lib/python3.12/site-packages/supervision/utils/video.py b/.venv/lib/python3.12/site-packages/supervision/utils/video.py
new file mode 100644
index 0000000000000000000000000000000000000000..732b9bf6c50ecc0a01659b778896f6d91a31818e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/utils/video.py
@@ -0,0 +1,634 @@
+from __future__ import annotations
+
+import threading
+import time
+from collections import deque
+from collections.abc import Callable, Generator
+from dataclasses import dataclass
+from queue import Empty, Full, Queue
+from types import TracebackType
+from typing import cast
+
+import numpy as np
+import numpy.typing as npt
+from tqdm.auto import tqdm
+
+from supervision import _cv2 as cv2
+from supervision._cv2._video import _mux_audio
+from supervision.utils.logger import _get_logger
+
+logger = _get_logger(__name__)
+
+
+@dataclass
+class VideoInfo:
+    """
+    A class to store video information, including width, height, fps and
+        total number of frames.
+
+    Attributes:
+        width: width of the video in pixels
+        height: height of the video in pixels
+        fps: frames per second of the video as a float. Common values include
+            23.976, 24.0, 25.0, 29.97, 30.0, 59.94, and 60.0.
+        total_frames: total number of frames in the video,
+            default is None
+
+    Examples:
+        ```python
+        import supervision as sv
+
+        video_info = sv.VideoInfo.from_video_path(video_path="")
+
+        video_info
+        # VideoInfo(width=3840, height=2160, fps=25.0, total_frames=538)
+
+        video_info.resolution_wh
+        # (3840, 2160)
+        ```
+    """
+
+    width: int
+    height: int
+    fps: float
+    total_frames: int | None = None
+
+    @classmethod
+    def from_video_path(cls, video_path: str) -> VideoInfo:
+        """Read video metadata from a file path.
+
+        Args:
+            video_path: Path to the video file.
+
+        Returns:
+            A `VideoInfo` instance with width, height, fps, and total_frames.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            video_info = sv.VideoInfo.from_video_path(video_path="")
+            # VideoInfo(width=3840, height=2160, fps=25.0, total_frames=538)
+            ```
+        """
+        video = cv2.VideoCapture(video_path)
+        if not video.isOpened():
+            raise Exception(f"Could not open video at {video_path}")
+
+        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        fps = float(video.get(cv2.CAP_PROP_FPS))
+        total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+        video.release()
+        return VideoInfo(width, height, fps, total_frames)
+
+    @property
+    def resolution_wh(self) -> tuple[int, int]:
+        return self.width, self.height
+
+
+class VideoSink:
+    """
+    Context manager that saves video frames to a file using OpenCV.
+
+    Attributes:
+        target_path: The path to the output file where the video will be saved.
+        video_info: Information about the video resolution, fps,
+            and total frame count.
+        codec: FOURCC code for video format
+
+    Example:
+        ```python
+        import supervision as sv
+
+        video_info = sv.VideoInfo.from_video_path("")
+        frames_generator = sv.get_video_frames_generator("")
+
+        with sv.VideoSink(target_path="", video_info=video_info) as sink:
+            for frame in frames_generator:
+                sink.write_frame(frame=frame)
+        ```
+    """  # noqa: E501 // docs
+
+    def __init__(
+        self, target_path: str, video_info: VideoInfo, codec: str = "mp4v"
+    ) -> None:
+        self.target_path = target_path
+        self.video_info = video_info
+        self.__codec = codec
+        self.__fourcc: int = 0
+        self.__writer: cv2.VideoWriter | None = None
+
+    def __enter__(self) -> VideoSink:
+        """Open the underlying video writer for context-managed frame output."""
+        fourcc_fn = cast(
+            Callable[[str, str, str, str], int], getattr(cv2, "VideoWriter_fourcc")
+        )
+        try:
+            self.__fourcc = int(fourcc_fn(*self.__codec))
+        except TypeError as e:
+            logger.warning("%s. Defaulting to mp4v...", str(e))
+            self.__fourcc = int(fourcc_fn(*"mp4v"))
+        self.__writer = cv2.VideoWriter(
+            self.target_path,
+            self.__fourcc,
+            self.video_info.fps,
+            self.video_info.resolution_wh,
+        )
+        # OpenCV can construct a writer object that is not usable for the target path.
+        if not self.__writer.isOpened():
+            self.__writer.release()
+            self.__writer = None
+            raise RuntimeError(f"Could not open video writer for {self.target_path}")
+        return self
+
+    def write_frame(self, frame: npt.NDArray[np.uint8]) -> None:
+        """
+        Writes a single video frame to the target video file.
+
+        Args:
+            frame: The video frame to be written to the file. The frame
+                must be in BGR color format.
+        """
+        # Preserve the context-manager invariant instead of silently dropping frames.
+        if self.__writer is None:
+            raise RuntimeError("write_frame requires an open VideoSink context.")
+        self.__writer.write(frame)
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        exc_traceback: TracebackType | None,
+    ) -> None:
+        """Release the underlying video writer when leaving the context."""
+        if self.__writer is not None:
+            self.__writer.release()
+            self.__writer = None
+
+
+def _validate_and_setup_video(
+    source_path: str, start: int, end: int | None, iterative_seek: bool = False
+) -> tuple[cv2.VideoCapture, int, int]:
+    """Open a video, position it at `start`, and return it with the clamped range."""
+    video = cv2.VideoCapture(source_path)
+    if not video.isOpened():
+        raise Exception(f"Could not open video at {source_path}")
+    total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
+    if end is not None and end > total_frames:
+        raise Exception("Requested frames are outbound")
+    start = max(start, 0)
+    end = min(end, total_frames) if end is not None else total_frames
+
+    if iterative_seek:
+        # Count grabs separately: `start` is returned as the position of the first
+        # frame read, and the caller measures `end` from it.
+        for _ in range(start):
+            success = video.grab()
+            if not success:
+                break
+    elif start > 0:
+        video.set(cv2.CAP_PROP_POS_FRAMES, start)
+
+    return video, start, end
+
+
+def get_video_frames_generator(
+    source_path: str,
+    stride: int = 1,
+    start: int = 0,
+    end: int | None = None,
+    iterative_seek: bool = False,
+    prefetch: int = 0,
+) -> Generator[npt.NDArray[np.uint8], None, None]:
+    """
+    Get a generator that yields the frames of the video.
+
+    Args:
+        source_path: The path of the video file.
+        stride: Indicates the interval at which frames are returned,
+            skipping stride - 1 frames between each.
+        start: Indicates the starting position from which
+            video should generate frames
+        end: Indicates the ending position at which video
+            should stop generating frames. If None, video will be read to the end.
+        iterative_seek: If True, the generator will seek to the
+            `start` frame by grabbing each frame, which is much slower. This is a
+            workaround for videos that don't open at all when you set the `start` value.
+        prefetch: If > 0, decode frames in a background thread and buffer up to
+            this many frames in a bounded queue. Useful when the consumer (e.g.
+            CPU inference) is the bottleneck and can overlap with decode I/O.
+            This works best when the consumer releases the GIL during frame
+            processing (common for numpy/PyTorch/ONNX C-extension calls). Pure
+            Python per-frame consumers that hold the GIL (for example, heavy
+            Python loops, PIL usage, or pandas `apply`) usually see little
+            speedup.
+            Default 0 keeps the original synchronous behaviour unchanged. Note:
+            each buffered frame occupies width x height x 3 bytes of uncompressed
+            memory; use `sv.VideoInfo.from_video_path()` to size appropriately.
+
+    Returns:
+        A generator that yields the frames of the video.
+
+    Raises:
+        ValueError: If `prefetch` is negative.
+        RuntimeError: If `prefetch` is greater than 0 and the background reader
+            thread encounters a decode/open error, raised as
+            `RuntimeError(f"Reader thread raised: {item!r}") from item`. Errors are
+            drained after buffered frames, so when `prefetch` > 0 the consumer may
+            yield up to `prefetch` additional good frames before the exception is
+            raised.
+
+    Note:
+        For live camera streams, use `cv2.VideoCapture` with an integer device
+        index directly. `get_video_frames_generator` is designed for file-based
+        sources; `cv2.VideoCapture` must be released by the caller when done.
+        This requires OpenCV to be installed — the PyAV-based fallback used
+        when OpenCV is unavailable only supports file paths, not webcam device
+        indexes; passing an integer source to it always leaves the capture
+        closed (`isOpened()` returns `False`):
+
+        ```python
+        from supervision import _cv2 as cv2
+
+        cap = cv2.VideoCapture(0)  # 0 = default webcam
+        try:
+            while cap.isOpened():
+                success, frame = cap.read()
+                if not success:
+                    break
+                ...  # process frame
+        finally:
+            cap.release()
+        ```
+
+    Examples:
+        ```python
+        import supervision as sv
+
+        for frame in sv.get_video_frames_generator(source_path=""):
+            ...
+
+        # Prefetch frames in a background thread to overlap I/O with CPU inference:
+        for frame in sv.get_video_frames_generator(
+            source_path="", prefetch=8
+        ):
+            ...
+        ```
+    """
+    if prefetch < 0:
+        raise ValueError(f"prefetch must be >= 0, got {prefetch!r}")
+    if prefetch > 0:
+        yield from _prefetched_frames_generator(
+            source_path=source_path,
+            stride=stride,
+            start=start,
+            end=end,
+            iterative_seek=iterative_seek,
+            prefetch=prefetch,
+        )
+        return
+
+    video, start, end = _validate_and_setup_video(
+        source_path, start, end, iterative_seek
+    )
+    frame_position = start
+    try:
+        while True:
+            success, frame = video.read()
+            if not success or frame_position >= end:
+                break
+            if frame is not None:
+                yield cast(npt.NDArray[np.uint8], frame)
+            for _ in range(stride - 1):
+                success = video.grab()
+                if not success:
+                    break
+            frame_position += stride
+    finally:
+        video.release()
+
+
+def _prefetched_frames_generator(
+    source_path: str,
+    stride: int,
+    start: int,
+    end: int | None,
+    iterative_seek: bool,
+    prefetch: int,
+) -> Generator[npt.NDArray[np.uint8], None, None]:
+    """Read frames into a bounded queue on a daemon thread.
+
+    Sentinel protocol: None = normal EOF, Exception instance = reader error.
+    """
+    frame_queue: Queue[npt.NDArray[np.uint8] | BaseException | None] = Queue(
+        maxsize=prefetch
+    )
+    stop_event = threading.Event()
+
+    def reader() -> None:
+        sentinel: BaseException | None = None
+        try:
+            for frame in get_video_frames_generator(
+                source_path=source_path,
+                stride=stride,
+                start=start,
+                end=end,
+                iterative_seek=iterative_seek,
+                prefetch=0,
+            ):
+                if stop_event.is_set():
+                    return
+                while True:
+                    try:
+                        frame_queue.put(frame, timeout=0.1)
+                        break
+                    except Full:
+                        if stop_event.is_set():
+                            return
+        except Exception as exc:
+            sentinel = exc
+        finally:
+            while not stop_event.is_set():
+                try:
+                    frame_queue.put(sentinel, timeout=0.1)
+                    return
+                except Full:
+                    pass
+
+    thread = threading.Thread(target=reader, daemon=True)
+    thread.start()
+    try:
+        while True:
+            try:
+                item = frame_queue.get(timeout=0.5)
+            except Empty:
+                if not thread.is_alive():
+                    break
+                continue
+            if isinstance(item, BaseException):
+                raise RuntimeError(f"Reader thread raised: {item!r}") from item
+            if item is None:
+                break
+            yield item
+    finally:
+        stop_event.set()
+        thread.join(timeout=2.0)
+
+
+def process_video(
+    source_path: str,
+    target_path: str,
+    callback: Callable[[npt.NDArray[np.uint8], int], npt.NDArray[np.uint8]],
+    *,
+    max_frames: int | None = None,
+    prefetch: int = 32,
+    writer_buffer: int = 32,
+    show_progress: bool = False,
+    progress_message: str = "Processing video",
+    preserve_audio: bool = False,
+) -> None:
+    """
+    Process video frames asynchronously using a threaded pipeline.
+
+    This function orchestrates a three-stage pipeline to optimize video processing
+    throughput:
+
+    1. Reader thread: Continuously reads frames from the source video file and
+       enqueues them into a bounded queue (`frame_read_queue`). The queue size is
+       limited by the `prefetch` parameter to control memory usage.
+    2. Main thread (Processor): Dequeues frames from `frame_read_queue`, applies the
+       user-defined `callback` function to process each frame, then enqueues the
+       processed frames into another bounded queue (`frame_write_queue`) for writing.
+       The processing happens in the main thread, simplifying use of stateful objects
+       without synchronization.
+    3. Writer thread: Dequeues processed frames from `frame_write_queue` and writes
+       them sequentially to the output video file.
+
+    Args:
+        source_path: Path to the input video file.
+        target_path: Path where the processed video will be saved.
+        callback: Function called for
+            each frame, accepting the frame as a numpy array and its zero-based index,
+            returning the processed frame.
+        max_frames: Optional maximum number of frames to process.
+            If None, the entire video is processed (default). A value larger
+            than the number of frames in the video processes the whole video.
+        prefetch: Maximum number of frames buffered by the reader thread.
+            Controls memory use; default is 32.
+        writer_buffer: Maximum number of frames buffered before writing.
+            Controls output buffer size; default is 32.
+        show_progress: Whether to display a tqdm progress bar during processing.
+            Default is False.
+        progress_message: Description shown in the progress bar.
+        preserve_audio: If True, copy the audio stream from `source_path` into
+            `target_path` after frame processing. Remuxing is done with PyAV;
+            no external `ffmpeg` executable is required. If the mux step
+            fails, a warning is logged and the output video is saved without
+            audio — no exception is raised. Audio is truncated to match the
+            processed video duration. Default is False.
+
+    Returns:
+        None
+
+    Raises:
+        RuntimeError: If the reader thread fails to open or decode the source
+            video, raised as `RuntimeError(f"Reader thread raised: {exc!r}")`
+            from the original exception. Exceptions raised by `callback` are
+            re-raised unchanged.
+
+    Example:
+        ```python
+        import supervision as sv
+        from rfdetr import RFDETRMedium
+
+        model = RFDETRMedium()
+
+        def callback(frame, frame_index):
+            return model.predict(frame)
+
+        sv.process_video(
+            source_path="source.mp4",
+            target_path="target.mp4",
+            callback=callback,
+            preserve_audio=True,
+        )
+        ```
+    """
+    video_info = VideoInfo.from_video_path(video_path=source_path)
+    video_total_frames = video_info.total_frames or 0
+    total_frames = video_total_frames
+    if max_frames is not None:
+        total_frames = min(video_total_frames, max_frames)
+
+    # `max_frames` is a cap, not an exact count: a value larger than the video
+    # must process the whole video. `get_video_frames_generator` raises when
+    # `end` exceeds the frame count, so clamp it whenever the count is known.
+    frames_end: int | None = max_frames
+    if max_frames is not None and video_total_frames > 0:
+        frames_end = total_frames
+
+    frame_read_queue: Queue[tuple[int, npt.NDArray[np.uint8]] | None] = Queue(
+        maxsize=prefetch
+    )
+    frame_write_queue: Queue[npt.NDArray[np.uint8] | None] = Queue(
+        maxsize=writer_buffer
+    )
+
+    reader_exception: Exception | None = None
+
+    def reader_thread() -> None:
+        """Feed frames into the read queue, always ending with the sentinel."""
+        nonlocal reader_exception
+        try:
+            frame_generator = get_video_frames_generator(
+                source_path=source_path,
+                end=frames_end,
+            )
+            for frame_index, frame in enumerate(frame_generator):
+                frame_read_queue.put((frame_index, frame))
+        except Exception as exc:
+            # The main loop blocks on `frame_read_queue.get()` with no timeout,
+            # so a reader failure must still enqueue the sentinel or the call
+            # never returns. Surface the error once the pipeline has shut down.
+            reader_exception = exc
+        finally:
+            frame_read_queue.put(None)
+
+    def writer_thread(video_sink: VideoSink) -> None:
+        while True:
+            frame = frame_write_queue.get()
+            if frame is None:
+                break
+            video_sink.write_frame(frame=frame)
+
+    reader_worker = threading.Thread(target=reader_thread, daemon=True)
+    with VideoSink(target_path=target_path, video_info=video_info) as video_sink:
+        writer_worker = threading.Thread(
+            target=writer_thread,
+            args=(video_sink,),
+            daemon=True,
+        )
+
+        reader_worker.start()
+        writer_worker.start()
+
+        progress_bar = tqdm(
+            total=total_frames,
+            disable=not show_progress,
+            desc=progress_message,
+        )
+
+        exception_in_worker: Exception | None = None
+        read_finished = False
+
+        try:
+            while True:
+                read_item = frame_read_queue.get()
+                if read_item is None:
+                    read_finished = True
+                    break
+
+                frame_index, frame = read_item
+                try:
+                    processed_frame = callback(frame, frame_index)
+                    frame_write_queue.put(processed_frame)
+                    progress_bar.update(1)
+                except Exception as exc:
+                    exception_in_worker = exc
+                    break
+        finally:
+            try:
+                frame_write_queue.put(None, timeout=1)
+            except Full:
+                # Best effort: if the writer is stuck and the queue never drains,
+                # do not block shutdown forever trying to enqueue the sentinel.
+                pass
+            if not read_finished:
+                while True:
+                    # Use timeout to prevent indefinite blocking if reader thread fails
+                    try:
+                        read_item = frame_read_queue.get(timeout=1)
+                        if read_item is None:
+                            break
+                    # If we timeout waiting for a frame, only assume failure if reader
+                    # thread is no longer alive. Otherwise, keep waiting as the reader
+                    # may simply be slow (for example, due to a slow source).
+                    except Empty:
+                        if not reader_worker.is_alive():
+                            break
+                        # Reader is still alive; continue waiting for frames.
+                        continue
+            reader_worker.join(timeout=10)
+            writer_worker.join(timeout=10)
+            progress_bar.close()
+            if exception_in_worker is not None:
+                raise exception_in_worker
+            if reader_exception is not None:
+                raise RuntimeError(
+                    f"Reader thread raised: {reader_exception!r}"
+                ) from reader_exception
+
+    if preserve_audio:
+        if writer_worker.is_alive():
+            logger.warning(
+                "Writer thread did not finish in time; skipping audio mux "
+                "to avoid reading an incomplete output file."
+            )
+        else:
+            _mux_audio(source_path=source_path, video_path=target_path)
+
+
+class FPSMonitor:
+    """
+    A class for monitoring frames per second (FPS) to benchmark latency.
+    """
+
+    def __init__(self, sample_size: int = 30) -> None:
+        """
+        Args:
+            sample_size: The maximum number of observations for latency
+                benchmarking.
+
+        Examples:
+            ```python
+            import supervision as sv
+
+            frames_generator = sv.get_video_frames_generator(
+                source_path="")
+            fps_monitor = sv.FPSMonitor()
+
+            for frame in frames_generator:
+                # your processing code here
+                fps_monitor.tick()
+                fps = fps_monitor.fps
+            ```
+        """
+        self.all_timestamps: deque[float] = deque(maxlen=sample_size)
+
+    @property
+    def fps(self) -> float:
+        """
+        Computes and returns the average FPS based on the stored time stamps.
+
+        Returns:
+            The average FPS across the recorded intervals. Returns 0.0 if fewer
+            than two time stamps are stored.
+        """
+        if len(self.all_timestamps) < 2:
+            return 0.0
+        taken_time = self.all_timestamps[-1] - self.all_timestamps[0]
+        frame_intervals = len(self.all_timestamps) - 1
+        return frame_intervals / taken_time if taken_time != 0 else 0.0
+
+    def tick(self) -> None:
+        """
+        Adds a new time stamp to the deque for FPS calculation.
+        """
+        self.all_timestamps.append(time.monotonic())
+
+    def reset(self) -> None:
+        """
+        Clears all the time stamps from the deque.
+        """
+        self.all_timestamps.clear()
diff --git a/.venv/lib/python3.12/site-packages/supervision/validators/__init__.py b/.venv/lib/python3.12/site-packages/supervision/validators/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8cd58d399598d281365d77886a545ddbc13976f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/supervision/validators/__init__.py
@@ -0,0 +1,363 @@
+from typing import Any
+
+import numpy as np
+from deprecate import deprecated, void  # type: ignore[import-untyped,unused-ignore]
+
+from supervision.detection.compact_mask import CompactMask
+from supervision.utils.internal import warn_deprecated
+
+
+def _validate_xyxy(xyxy: Any) -> None:
+    """Validate that xyxy is a 2D np.ndarray with shape (N, 4).
+
+    ```pycon
+    >>> _validate_xyxy(np.array([[0, 0, 1, 1], [1, 1, 2, 2]]))
+
+    ```
+    """
+    expected_shape = "(_, 4)"
+    actual_shape = str(getattr(xyxy, "shape", None))
+    is_valid = isinstance(xyxy, np.ndarray) and xyxy.ndim == 2 and xyxy.shape[1] == 4
+    if not is_valid:
+        raise ValueError(
+            f"xyxy must be a 2D np.ndarray with shape {expected_shape}, but got shape "
+            f"{actual_shape}"
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_xyxy,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_xyxy(xyxy: Any) -> None:
+    void(xyxy)
+
+
+def _validate_mask(mask: Any, n: int) -> None:
+    if mask is None:
+        return
+
+    # Fast path: CompactMask only needs a length check.
+
+    if isinstance(mask, CompactMask):
+        if len(mask) != n:
+            raise ValueError(f"mask must contain {n} masks, but got {len(mask)}")
+        return
+
+    expected_shape = f"({n}, H, W)"
+    actual_shape = str(getattr(mask, "shape", None))
+    actual_dtype = getattr(mask, "dtype", None)
+
+    is_valid_shape = (
+        isinstance(mask, np.ndarray) and len(mask.shape) == 3 and mask.shape[0] == n
+    )
+    if not is_valid_shape:
+        raise ValueError(
+            "mask must be a 3D np.ndarray with shape "
+            + f"{expected_shape}, but got shape {actual_shape}"
+        )
+    if not np.issubdtype(actual_dtype, bool):
+        warn_deprecated(
+            f"A `Detections` object was created with a mask of type {actual_dtype}."
+            " Masks of type other than `bool` are deprecated and may produce unexpected"
+            " behavior. Starting from `supervision-0.28.0`, passing a mask with"
+            " `dtype` different from `bool` to `Detections` will raise a `ValueError`"
+            " during validation instead of being accepted with a warning. To migrate,"
+            " please ensure your masks are boolean, for example by using"
+            " `mask = np.array(..., dtype=bool)` or by converting existing masks with"
+            " `mask = mask.astype(bool)` before creating the `Detections` object. If"
+            " you did not create the mask manually, please report the issue to the"
+            " `supervision` team."
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_mask,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_mask(mask: Any, n: int) -> None:
+    void(mask, n)
+
+
+def _validate_class_id(class_id: Any, n: int) -> None:
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(class_id, "shape", None))
+    is_valid = class_id is None or (
+        isinstance(class_id, np.ndarray) and class_id.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"class_id must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_class_id,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_class_id(class_id: Any, n: int) -> None:
+    void(class_id, n)
+
+
+def _validate_confidence(confidence: Any, n: int) -> None:
+    """Validate detection-level confidence: 1D ``np.ndarray`` with shape ``(n,)``."""
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(confidence, "shape", None))
+    is_valid = confidence is None or (
+        isinstance(confidence, np.ndarray) and confidence.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"confidence must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_confidence,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_confidence(confidence: Any, n: int) -> None:
+    void(confidence, n)
+
+
+def _validate_keypoint_confidence(confidence: Any, n: int, m: int) -> None:
+    """Validate per-keypoint confidence: 2D ``np.ndarray`` with shape ``(n, m)``."""
+    actual_shape = str(getattr(confidence, "shape", None))
+
+    if confidence is not None:
+        if not isinstance(confidence, np.ndarray) or confidence.ndim != 2:
+            raise ValueError(
+                f"keypoint_confidence must be a 2D np.ndarray with shape (n, m), but "
+                f"got shape {actual_shape}"
+            )
+        if confidence.shape[0] != n:
+            raise ValueError(
+                f"keypoint_confidence first dimension must be {n}, "
+                f"but got shape {actual_shape}"
+            )
+        if n > 0 and confidence.shape[1] != m:
+            raise ValueError(
+                f"keypoint_confidence second dimension must be {m}, but "
+                f"got shape {actual_shape}"
+            )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_keypoint_confidence,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_key_point_confidence(confidence: Any, n: int, m: int) -> None:
+    void(confidence, n, m)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_keypoint_confidence,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def validate_keypoint_confidence(confidence: Any, n: int, m: int) -> None:
+    void(confidence, n, m)
+
+
+def _validate_tracker_id(tracker_id: Any, n: int) -> None:
+    expected_shape = f"({n},)"
+    actual_shape = str(getattr(tracker_id, "shape", None))
+    is_valid = tracker_id is None or (
+        isinstance(tracker_id, np.ndarray) and tracker_id.shape == (n,)
+    )
+    if not is_valid:
+        raise ValueError(
+            f"tracker_id must be a 1D np.ndarray with shape {expected_shape}, but got "
+            f"shape {actual_shape}"
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_tracker_id,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_tracker_id(tracker_id: Any, n: int) -> None:
+    void(tracker_id, n)
+
+
+def _validate_data(data: dict[str, Any], n: int) -> None:
+    for key, value in data.items():
+        if isinstance(value, list):
+            if len(value) != n:
+                raise ValueError(f"Length of list for key '{key}' must be {n}")
+        elif isinstance(value, np.ndarray):
+            if value.ndim == 1 and value.shape[0] != n:
+                raise ValueError(f"Shape of np.ndarray for key '{key}' must be ({n},)")
+            elif value.ndim > 1 and value.shape[0] != n:
+                raise ValueError(
+                    f"First dimension of np.ndarray for key '{key}' must have size {n}"
+                )
+        else:
+            raise ValueError(f"Value for key '{key}' must be a list or np.ndarray")
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_data,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_data(data: dict[str, Any], n: int) -> None:
+    void(data, n)
+
+
+def _validate_xy(xy: Any, n: int, m: int) -> None:
+    expected_shape = f"({n}, {m}, 2) or ({n}, {m}, 3)"
+    actual_shape = str(getattr(xy, "shape", None))
+
+    if not isinstance(xy, np.ndarray) or xy.ndim != 3 or xy.shape[2] not in (2, 3):
+        raise ValueError(
+            f"xy must be a 3D np.ndarray with shape {expected_shape}, but got shape "
+            f"{actual_shape}"
+        )
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_xy,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_xy(xy: Any, n: int, m: int) -> None:
+    void(xy, n, m)
+
+
+def _validate_visible(visible: Any, n: int, m: int) -> None:
+    """Validate per-keypoint visibility mask.
+
+    Expects a 2D bool ``np.ndarray`` with shape ``(n, m)``.
+    """
+    if visible is None:
+        return
+    actual_shape = str(getattr(visible, "shape", None))
+    if not isinstance(visible, np.ndarray) or visible.ndim != 2:
+        raise ValueError(
+            "visible must be a 2D np.ndarray with shape (n, m), but "
+            f"got shape {actual_shape}"
+        )
+    if visible.shape[0] != n:
+        raise ValueError(
+            f"visible first dimension must be {n}, but got shape {actual_shape}"
+        )
+    if n > 0 and visible.shape[1] != m:
+        raise ValueError(
+            f"visible second dimension must be {m}, but got shape {actual_shape}"
+        )
+
+
+def _validate_detections_fields(
+    xyxy: Any,
+    mask: Any,
+    class_id: Any,
+    confidence: Any,
+    tracker_id: Any,
+    data: dict[str, Any],
+) -> None:
+    _validate_xyxy(xyxy)
+    n = len(xyxy)
+    _validate_mask(mask, n)
+    _validate_class_id(class_id, n)
+    _validate_confidence(confidence, n)
+    _validate_tracker_id(tracker_id, n)
+    _validate_data(data, n)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_detections_fields,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_detections_fields(
+    xyxy: Any,
+    mask: Any,
+    class_id: Any,
+    confidence: Any,
+    tracker_id: Any,
+    data: dict[str, Any],
+) -> None:
+    void(xyxy, mask, class_id, confidence, tracker_id, data)
+
+
+def _validate_keypoints_fields(
+    xy: Any,
+    class_id: Any,
+    confidence: Any,
+    detection_confidence: Any = None,
+    visible: Any = None,
+    data: dict[str, Any] | None = None,
+) -> None:
+    n = len(xy)
+    m = len(xy[0]) if len(xy) > 0 else 0
+    _validate_xy(xy, n, m)
+    _validate_class_id(class_id, n)
+    _validate_keypoint_confidence(confidence, n, m)
+    if detection_confidence is not None:
+        _validate_confidence(detection_confidence, n)
+    _validate_visible(visible, n, m)
+    if data is not None:
+        _validate_data(data, n)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_keypoints_fields,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_key_points_fields(
+    xy: Any, class_id: Any, confidence: Any, data: dict[str, Any]
+) -> None:
+    void(xy, class_id, confidence, data)
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_keypoints_fields,
+    deprecated_in="0.27.0",
+    remove_in="0.31.0",
+)
+def validate_keypoints_fields(
+    xy: Any, class_id: Any, confidence: Any, data: dict[str, Any]
+) -> None:
+    void(xy, class_id, confidence, data)
+
+
+def _validate_resolution(resolution: Any) -> tuple[int, int]:
+    if not (isinstance(resolution, tuple) and len(resolution) == 2):
+        raise ValueError(
+            f"""
+            resolution must be a tuple of two integers, got
+            {type(resolution)} with value {resolution}
+            """
+        )
+    w, h = resolution
+    if not (isinstance(w, int) and isinstance(h, int)):
+        raise ValueError(
+            f"""
+            Both elements in resolution must be integers.
+            Got types ({type(w)}, {type(h)})
+            """
+        )
+    if w <= 0 or h <= 0:
+        raise ValueError(
+            f"Both dimensions in resolution must be positive. Got ({w}, {h})."
+        )
+    return w, h
+
+
+@deprecated(  # type: ignore[untyped-decorator]
+    target=_validate_resolution,
+    deprecated_in="0.29.0",
+    remove_in="0.32.0",
+)
+def validate_resolution(resolution: Any) -> tuple[int, int]:
+    return void(resolution)  # type: ignore[no-any-return]
diff --git a/.venv/lib/python3.12/site-packages/supervision/validators/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/supervision/validators/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49ee53337a40a83b39178cba2e2245c5c9803b35
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/supervision/validators/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__init__.py b/.venv/lib/python3.12/site-packages/sympy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..c67ba49409169c49ac5d34f2be365def3c30369b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/__init__.py
@@ -0,0 +1,545 @@
+"""
+SymPy is a Python library for symbolic mathematics. It aims to become a
+full-featured computer algebra system (CAS) while keeping the code as simple
+as possible in order to be comprehensible and easily extensible.  SymPy is
+written entirely in Python. It depends on mpmath, and other external libraries
+may be optionally for things like plotting support.
+
+See the webpage for more information and documentation:
+
+    https://sympy.org
+
+"""
+
+
+# Keep this in sync with setup.py/pyproject.toml
+import sys
+if sys.version_info < (3, 9):
+    raise ImportError("Python version 3.9 or above is required for SymPy.")
+del sys
+
+
+try:
+    import mpmath
+except ImportError:
+    raise ImportError("SymPy now depends on mpmath as an external library. "
+    "See https://docs.sympy.org/latest/install.html#mpmath for more information.")
+
+del mpmath
+
+from sympy.release import __version__
+from sympy.core.cache import lazy_function
+
+if 'dev' in __version__:
+    def enable_warnings():
+        import warnings
+        warnings.filterwarnings('default',   '.*',   DeprecationWarning, module='sympy.*')
+        del warnings
+    enable_warnings()
+    del enable_warnings
+
+
+def __sympy_debug():
+    # helper function so we don't import os globally
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+# Fails py2 test if using type hinting
+SYMPY_DEBUG = __sympy_debug()  # type: bool
+
+
+from .core import (sympify, SympifyError, cacheit, Basic, Atom,
+        preorder_traversal, S, Expr, AtomicExpr, UnevaluatedExpr, Symbol,
+        Wild, Dummy, symbols, var, Number, Float, Rational, Integer,
+        NumberSymbol, RealNumber, igcd, ilcm, seterr, E, I, nan, oo, pi, zoo,
+        AlgebraicNumber, comp, mod_inverse, Pow, integer_nthroot, integer_log,
+        trailing, Mul, prod, Add, Mod, Rel, Eq, Ne, Lt, Le, Gt, Ge, Equality,
+        GreaterThan, LessThan, Unequality, StrictGreaterThan, StrictLessThan,
+        vectorize, Lambda, WildFunction, Derivative, diff, FunctionClass,
+        Function, Subs, expand, PoleError, count_ops, expand_mul, expand_log,
+        expand_func, expand_trig, expand_complex, expand_multinomial, nfloat,
+        expand_power_base, expand_power_exp, arity, PrecisionExhausted, N,
+        evalf, Tuple, Dict, gcd_terms, factor_terms, factor_nc, evaluate,
+        Catalan, EulerGamma, GoldenRatio, TribonacciConstant, bottom_up, use,
+        postorder_traversal, default_sort_key, ordered, num_digits)
+
+from .logic import (to_cnf, to_dnf, to_nnf, And, Or, Not, Xor, Nand, Nor,
+        Implies, Equivalent, ITE, POSform, SOPform, simplify_logic, bool_map,
+        true, false, satisfiable)
+
+from .assumptions import (AppliedPredicate, Predicate, AssumptionsContext,
+        assuming, Q, ask, register_handler, remove_handler, refine)
+
+from .polys import (Poly, PurePoly, poly_from_expr, parallel_poly_from_expr,
+        degree, total_degree, degree_list, LC, LM, LT, pdiv, prem, pquo,
+        pexquo, div, rem, quo, exquo, half_gcdex, gcdex, invert,
+        subresultants, resultant, discriminant, cofactors, gcd_list, gcd,
+        lcm_list, lcm, terms_gcd, trunc, monic, content, primitive, compose,
+        decompose, sturm, gff_list, gff, sqf_norm, sqf_part, sqf_list, sqf,
+        factor_list, factor, intervals, refine_root, count_roots, all_roots,
+        real_roots, nroots, ground_roots, nth_power_roots_poly, cancel,
+        reduced, groebner, is_zero_dimensional, GroebnerBasis, poly,
+        symmetrize, horner, interpolate, rational_interpolate, viete, together,
+        BasePolynomialError, ExactQuotientFailed, PolynomialDivisionFailed,
+        OperationNotSupported, HeuristicGCDFailed, HomomorphismFailed,
+        IsomorphismFailed, ExtraneousFactors, EvaluationFailed,
+        RefinementFailed, CoercionFailed, NotInvertible, NotReversible,
+        NotAlgebraic, DomainError, PolynomialError, UnificationFailed,
+        GeneratorsError, GeneratorsNeeded, ComputationFailed,
+        UnivariatePolynomialError, MultivariatePolynomialError,
+        PolificationFailed, OptionError, FlagError, minpoly,
+        minimal_polynomial, primitive_element, field_isomorphism,
+        to_number_field, isolate, round_two, prime_decomp, prime_valuation,
+        galois_group, itermonomials, Monomial, lex, grlex,
+        grevlex, ilex, igrlex, igrevlex, CRootOf, rootof, RootOf,
+        ComplexRootOf, RootSum, roots, Domain, FiniteField, IntegerRing,
+        RationalField, RealField, ComplexField, PythonFiniteField,
+        GMPYFiniteField, PythonIntegerRing, GMPYIntegerRing, PythonRational,
+        GMPYRationalField, AlgebraicField, PolynomialRing, FractionField,
+        ExpressionDomain, FF_python, FF_gmpy, ZZ_python, ZZ_gmpy, QQ_python,
+        QQ_gmpy, GF, FF, ZZ, QQ, ZZ_I, QQ_I, RR, CC, EX, EXRAW,
+        construct_domain, swinnerton_dyer_poly, cyclotomic_poly,
+        symmetric_poly, random_poly, interpolating_poly, jacobi_poly,
+        chebyshevt_poly, chebyshevu_poly, hermite_poly, hermite_prob_poly,
+        legendre_poly, laguerre_poly, apart, apart_list, assemble_partfrac_list,
+        Options, ring, xring, vring, sring, field, xfield, vfield, sfield)
+
+from .series import (Order, O, limit, Limit, gruntz, series, approximants,
+        residue, EmptySequence, SeqPer, SeqFormula, sequence, SeqAdd, SeqMul,
+        fourier_series, fps, difference_delta, limit_seq)
+
+from .functions import (factorial, factorial2, rf, ff, binomial,
+        RisingFactorial, FallingFactorial, subfactorial, carmichael,
+        fibonacci, lucas, motzkin, tribonacci, harmonic, bernoulli, bell, euler,
+        catalan, genocchi, andre, partition, divisor_sigma, legendre_symbol,
+        jacobi_symbol, kronecker_symbol, mobius, primenu, primeomega,
+        totient, reduced_totient, primepi, sqrt, root, Min, Max, Id,
+        real_root, Rem, cbrt, re, im, sign, Abs, conjugate, arg, polar_lift,
+        periodic_argument, unbranched_argument, principal_branch, transpose,
+        adjoint, polarify, unpolarify, sin, cos, tan, sec, csc, cot, sinc,
+        asin, acos, atan, asec, acsc, acot, atan2, exp_polar, exp, ln, log,
+        LambertW, sinh, cosh, tanh, coth, sech, csch, asinh, acosh, atanh,
+        acoth, asech, acsch, floor, ceiling, frac, Piecewise, piecewise_fold,
+        piecewise_exclusive, erf, erfc, erfi, erf2, erfinv, erfcinv, erf2inv,
+        Ei, expint, E1, li, Li, Si, Ci, Shi, Chi, fresnels, fresnelc, gamma,
+        lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma,
+        multigamma, dirichlet_eta, zeta, lerchphi, polylog, stieltjes, Eijk,
+        LeviCivita, KroneckerDelta, SingularityFunction, DiracDelta, Heaviside,
+        bspline_basis, bspline_basis_set, interpolating_spline, besselj,
+        bessely, besseli, besselk, hankel1, hankel2, jn, yn, jn_zeros, hn1,
+        hn2, airyai, airybi, airyaiprime, airybiprime, marcumq, hyper,
+        meijerg, appellf1, legendre, assoc_legendre, hermite, hermite_prob,
+        chebyshevt, chebyshevu, chebyshevu_root, chebyshevt_root, laguerre,
+        assoc_laguerre, gegenbauer, jacobi, jacobi_normalized, Ynm, Ynm_c,
+        Znm, elliptic_k, elliptic_f, elliptic_e, elliptic_pi, beta, mathieus,
+        mathieuc, mathieusprime, mathieucprime, riemann_xi, betainc, betainc_regularized)
+
+from .ntheory import (nextprime, prevprime, prime, primerange,
+        randprime, Sieve, sieve, primorial, cycle_length, composite,
+        compositepi, isprime, divisors, proper_divisors, factorint,
+        multiplicity, perfect_power, factor_cache, pollard_pm1, pollard_rho, primefactors,
+        divisor_count, proper_divisor_count,
+        factorrat,
+        mersenne_prime_exponent, is_perfect, is_mersenne_prime, is_abundant,
+        is_deficient, is_amicable, is_carmichael, abundance, npartitions, is_primitive_root,
+        is_quad_residue, n_order, sqrt_mod,
+        quadratic_residues, primitive_root, nthroot_mod, is_nthpow_residue,
+        sqrt_mod_iter, discrete_log, quadratic_congruence,
+        binomial_coefficients, binomial_coefficients_list,
+        multinomial_coefficients, continued_fraction_periodic,
+        continued_fraction_iterator, continued_fraction_reduce,
+        continued_fraction_convergents, continued_fraction, egyptian_fraction)
+
+from .concrete import product, Product, summation, Sum
+
+from .discrete import (fft, ifft, ntt, intt, fwht, ifwht, mobius_transform,
+        inverse_mobius_transform, convolution, covering_product,
+        intersecting_product)
+
+from .simplify import (simplify, hypersimp, hypersimilar, logcombine,
+        separatevars, posify, besselsimp, kroneckersimp, signsimp,
+        nsimplify, FU, fu, sqrtdenest, cse, epath, EPath, hyperexpand,
+        collect, rcollect, radsimp, collect_const, fraction, numer, denom,
+        trigsimp, exptrigsimp, powsimp, powdenest, combsimp, gammasimp,
+        ratsimp, ratsimpmodprime)
+
+from .sets import (Set, Interval, Union, EmptySet, FiniteSet, ProductSet,
+        Intersection, DisjointUnion, imageset, Complement, SymmetricDifference, ImageSet,
+        Range, ComplexRegion, Complexes, Reals, Contains, ConditionSet, Ordinal,
+        OmegaPower, ord0, PowerSet, Naturals, Naturals0, UniversalSet,
+        Integers, Rationals)
+
+from .solvers import (solve, solve_linear_system, solve_linear_system_LU,
+        solve_undetermined_coeffs, nsolve, solve_linear, checksol, det_quick,
+        inv_quick, check_assumptions, failing_assumptions, diophantine,
+        rsolve, rsolve_poly, rsolve_ratio, rsolve_hyper, checkodesol,
+        classify_ode, dsolve, homogeneous_order, solve_poly_system, factor_system,
+        solve_triangulated, pde_separate, pde_separate_add, pde_separate_mul,
+        pdsolve, classify_pde, checkpdesol, ode_order, reduce_inequalities,
+        reduce_abs_inequality, reduce_abs_inequalities, solve_poly_inequality,
+        solve_rational_inequalities, solve_univariate_inequality, decompogen,
+        solveset, linsolve, linear_eq_to_matrix, nonlinsolve, substitution)
+
+from .matrices import (ShapeError, NonSquareMatrixError, GramSchmidt,
+        casoratian, diag, eye, hessian, jordan_cell, list2numpy, matrix2numpy,
+        matrix_multiply_elementwise, ones, randMatrix, rot_axis1, rot_axis2,
+        rot_axis3, symarray, wronskian, zeros, MutableDenseMatrix,
+        DeferredVector, MatrixBase, Matrix, MutableMatrix,
+        MutableSparseMatrix, banded, ImmutableDenseMatrix,
+        ImmutableSparseMatrix, ImmutableMatrix, SparseMatrix, MatrixSlice,
+        BlockDiagMatrix, BlockMatrix, FunctionMatrix, Identity, Inverse,
+        MatAdd, MatMul, MatPow, MatrixExpr, MatrixSymbol, Trace, Transpose,
+        ZeroMatrix, OneMatrix, blockcut, block_collapse, matrix_symbols,
+        Adjoint, hadamard_product, HadamardProduct, HadamardPower,
+        Determinant, det, diagonalize_vector, DiagMatrix, DiagonalMatrix,
+        DiagonalOf, trace, DotProduct, kronecker_product, KroneckerProduct,
+        PermutationMatrix, MatrixPermute, Permanent, per, rot_ccw_axis1,
+        rot_ccw_axis2, rot_ccw_axis3, rot_givens)
+
+from .geometry import (Point, Point2D, Point3D, Line, Ray, Segment, Line2D,
+        Segment2D, Ray2D, Line3D, Segment3D, Ray3D, Plane, Ellipse, Circle,
+        Polygon, RegularPolygon, Triangle, rad, deg, are_similar, centroid,
+        convex_hull, idiff, intersection, closest_points, farthest_points,
+        GeometryError, Curve, Parabola)
+
+from .utilities import (flatten, group, take, subsets, variations,
+        numbered_symbols, cartes, capture, dict_merge, prefixes, postfixes,
+        sift, topological_sort, unflatten, has_dups, has_variety, reshape,
+        rotations, filldedent, lambdify,
+        threaded, xthreaded, public, memoize_property, timed)
+
+from .integrals import (integrate, Integral, line_integrate, mellin_transform,
+        inverse_mellin_transform, MellinTransform, InverseMellinTransform,
+        laplace_transform, laplace_correspondence, laplace_initial_conds,
+        inverse_laplace_transform, LaplaceTransform,
+        InverseLaplaceTransform, fourier_transform, inverse_fourier_transform,
+        FourierTransform, InverseFourierTransform, sine_transform,
+        inverse_sine_transform, SineTransform, InverseSineTransform,
+        cosine_transform, inverse_cosine_transform, CosineTransform,
+        InverseCosineTransform, hankel_transform, inverse_hankel_transform,
+        HankelTransform, InverseHankelTransform, singularityintegrate)
+
+from .tensor import (IndexedBase, Idx, Indexed, get_contraction_structure,
+        get_indices, shape, MutableDenseNDimArray, ImmutableDenseNDimArray,
+        MutableSparseNDimArray, ImmutableSparseNDimArray, NDimArray,
+        tensorproduct, tensorcontraction, tensordiagonal, derive_by_array,
+        permutedims, Array, DenseNDimArray, SparseNDimArray)
+
+from .parsing import parse_expr
+
+from .calculus import (euler_equations, singularities, is_increasing,
+        is_strictly_increasing, is_decreasing, is_strictly_decreasing,
+        is_monotonic, finite_diff_weights, apply_finite_diff,
+        differentiate_finite, periodicity, not_empty_in, AccumBounds,
+        is_convex, stationary_points, minimum, maximum)
+
+from .algebras import Quaternion
+
+from .printing import (pager_print, pretty, pretty_print, pprint,
+        pprint_use_unicode, pprint_try_use_unicode, latex, print_latex,
+        multiline_latex, mathml, print_mathml, python, print_python, pycode,
+        ccode, print_ccode, smtlib_code, glsl_code, print_glsl, cxxcode, fcode,
+        print_fcode, rcode, print_rcode, jscode, print_jscode, julia_code,
+        mathematica_code, octave_code, rust_code, print_gtk, preview, srepr,
+        print_tree, StrPrinter, sstr, sstrrepr, TableForm, dotprint,
+        maple_code, print_maple_code)
+
+test = lazy_function('sympy.testing.runtests_pytest', 'test')
+doctest = lazy_function('sympy.testing.runtests', 'doctest')
+
+# This module causes conflicts with other modules:
+# from .stats import *
+# Adds about .04-.05 seconds of import time
+# from combinatorics import *
+# This module is slow to import:
+#from physics import units
+from .plotting import plot, textplot, plot_backends, plot_implicit, plot_parametric
+from .interactive import init_session, init_printing, interactive_traversal
+
+evalf._create_evalf_table()
+
+__all__ = [
+    '__version__',
+
+    # sympy.core
+    'sympify', 'SympifyError', 'cacheit', 'Basic', 'Atom',
+    'preorder_traversal', 'S', 'Expr', 'AtomicExpr', 'UnevaluatedExpr',
+    'Symbol', 'Wild', 'Dummy', 'symbols', 'var', 'Number', 'Float',
+    'Rational', 'Integer', 'NumberSymbol', 'RealNumber', 'igcd', 'ilcm',
+    'seterr', 'E', 'I', 'nan', 'oo', 'pi', 'zoo', 'AlgebraicNumber', 'comp',
+    'mod_inverse', 'Pow', 'integer_nthroot', 'integer_log', 'trailing', 'Mul', 'prod',
+    'Add', 'Mod', 'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge', 'Equality',
+    'GreaterThan', 'LessThan', 'Unequality', 'StrictGreaterThan',
+    'StrictLessThan', 'vectorize', 'Lambda', 'WildFunction', 'Derivative',
+    'diff', 'FunctionClass', 'Function', 'Subs', 'expand', 'PoleError',
+    'count_ops', 'expand_mul', 'expand_log', 'expand_func', 'expand_trig',
+    'expand_complex', 'expand_multinomial', 'nfloat', 'expand_power_base',
+    'expand_power_exp', 'arity', 'PrecisionExhausted', 'N', 'evalf', 'Tuple',
+    'Dict', 'gcd_terms', 'factor_terms', 'factor_nc', 'evaluate', 'Catalan',
+    'EulerGamma', 'GoldenRatio', 'TribonacciConstant', 'bottom_up', 'use',
+    'postorder_traversal', 'default_sort_key', 'ordered', 'num_digits',
+
+    # sympy.logic
+    'to_cnf', 'to_dnf', 'to_nnf', 'And', 'Or', 'Not', 'Xor', 'Nand', 'Nor',
+    'Implies', 'Equivalent', 'ITE', 'POSform', 'SOPform', 'simplify_logic',
+    'bool_map', 'true', 'false', 'satisfiable',
+
+    # sympy.assumptions
+    'AppliedPredicate', 'Predicate', 'AssumptionsContext', 'assuming', 'Q',
+    'ask', 'register_handler', 'remove_handler', 'refine',
+
+    # sympy.polys
+    'Poly', 'PurePoly', 'poly_from_expr', 'parallel_poly_from_expr', 'degree',
+    'total_degree', 'degree_list', 'LC', 'LM', 'LT', 'pdiv', 'prem', 'pquo',
+    'pexquo', 'div', 'rem', 'quo', 'exquo', 'half_gcdex', 'gcdex', 'invert',
+    'subresultants', 'resultant', 'discriminant', 'cofactors', 'gcd_list',
+    'gcd', 'lcm_list', 'lcm', 'terms_gcd', 'trunc', 'monic', 'content',
+    'primitive', 'compose', 'decompose', 'sturm', 'gff_list', 'gff',
+    'sqf_norm', 'sqf_part', 'sqf_list', 'sqf', 'factor_list', 'factor',
+    'intervals', 'refine_root', 'count_roots', 'all_roots', 'real_roots',
+    'nroots', 'ground_roots', 'nth_power_roots_poly', 'cancel', 'reduced',
+    'groebner', 'is_zero_dimensional', 'GroebnerBasis', 'poly', 'symmetrize',
+    'horner', 'interpolate', 'rational_interpolate', 'viete', 'together',
+    'BasePolynomialError', 'ExactQuotientFailed', 'PolynomialDivisionFailed',
+    'OperationNotSupported', 'HeuristicGCDFailed', 'HomomorphismFailed',
+    'IsomorphismFailed', 'ExtraneousFactors', 'EvaluationFailed',
+    'RefinementFailed', 'CoercionFailed', 'NotInvertible', 'NotReversible',
+    'NotAlgebraic', 'DomainError', 'PolynomialError', 'UnificationFailed',
+    'GeneratorsError', 'GeneratorsNeeded', 'ComputationFailed',
+    'UnivariatePolynomialError', 'MultivariatePolynomialError',
+    'PolificationFailed', 'OptionError', 'FlagError', 'minpoly',
+    'minimal_polynomial', 'primitive_element', 'field_isomorphism',
+    'to_number_field', 'isolate', 'round_two', 'prime_decomp',
+    'prime_valuation', 'galois_group', 'itermonomials', 'Monomial', 'lex', 'grlex',
+    'grevlex', 'ilex', 'igrlex', 'igrevlex', 'CRootOf', 'rootof', 'RootOf',
+    'ComplexRootOf', 'RootSum', 'roots', 'Domain', 'FiniteField',
+    'IntegerRing', 'RationalField', 'RealField', 'ComplexField',
+    'PythonFiniteField', 'GMPYFiniteField', 'PythonIntegerRing',
+    'GMPYIntegerRing', 'PythonRational', 'GMPYRationalField',
+    'AlgebraicField', 'PolynomialRing', 'FractionField', 'ExpressionDomain',
+    'FF_python', 'FF_gmpy', 'ZZ_python', 'ZZ_gmpy', 'QQ_python', 'QQ_gmpy',
+    'GF', 'FF', 'ZZ', 'QQ', 'ZZ_I', 'QQ_I', 'RR', 'CC', 'EX', 'EXRAW',
+    'construct_domain', 'swinnerton_dyer_poly', 'cyclotomic_poly',
+    'symmetric_poly', 'random_poly', 'interpolating_poly', 'jacobi_poly',
+    'chebyshevt_poly', 'chebyshevu_poly', 'hermite_poly', 'hermite_prob_poly',
+    'legendre_poly', 'laguerre_poly', 'apart', 'apart_list', 'assemble_partfrac_list',
+    'Options', 'ring', 'xring', 'vring', 'sring', 'field', 'xfield', 'vfield',
+    'sfield',
+
+    # sympy.series
+    'Order', 'O', 'limit', 'Limit', 'gruntz', 'series', 'approximants',
+    'residue', 'EmptySequence', 'SeqPer', 'SeqFormula', 'sequence', 'SeqAdd',
+    'SeqMul', 'fourier_series', 'fps', 'difference_delta', 'limit_seq',
+
+    # sympy.functions
+    'factorial', 'factorial2', 'rf', 'ff', 'binomial', 'RisingFactorial',
+    'FallingFactorial', 'subfactorial', 'carmichael', 'fibonacci', 'lucas',
+    'motzkin', 'tribonacci', 'harmonic', 'bernoulli', 'bell', 'euler', 'catalan',
+    'genocchi', 'andre', 'partition',  'divisor_sigma', 'legendre_symbol', 'jacobi_symbol',
+    'kronecker_symbol', 'mobius', 'primenu', 'primeomega', 'totient', 'primepi',
+    'reduced_totient', 'sqrt', 'root', 'Min', 'Max', 'Id', 'real_root',
+    'Rem', 'cbrt', 're', 'im', 'sign', 'Abs', 'conjugate', 'arg', 'polar_lift',
+    'periodic_argument', 'unbranched_argument', 'principal_branch',
+    'transpose', 'adjoint', 'polarify', 'unpolarify', 'sin', 'cos', 'tan',
+    'sec', 'csc', 'cot', 'sinc', 'asin', 'acos', 'atan', 'asec', 'acsc',
+    'acot', 'atan2', 'exp_polar', 'exp', 'ln', 'log', 'LambertW', 'sinh',
+    'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh',
+    'acoth', 'asech', 'acsch', 'floor', 'ceiling', 'frac', 'Piecewise',
+    'piecewise_fold', 'piecewise_exclusive', 'erf', 'erfc', 'erfi', 'erf2',
+    'erfinv', 'erfcinv', 'erf2inv', 'Ei', 'expint', 'E1', 'li', 'Li', 'Si',
+    'Ci', 'Shi', 'Chi', 'fresnels', 'fresnelc', 'gamma', 'lowergamma',
+    'uppergamma', 'polygamma', 'loggamma', 'digamma', 'trigamma', 'multigamma',
+    'dirichlet_eta', 'zeta', 'lerchphi', 'polylog', 'stieltjes', 'Eijk', 'LeviCivita',
+    'KroneckerDelta', 'SingularityFunction', 'DiracDelta', 'Heaviside',
+    'bspline_basis', 'bspline_basis_set', 'interpolating_spline', 'besselj',
+    'bessely', 'besseli', 'besselk', 'hankel1', 'hankel2', 'jn', 'yn',
+    'jn_zeros', 'hn1', 'hn2', 'airyai', 'airybi', 'airyaiprime',
+    'airybiprime', 'marcumq', 'hyper', 'meijerg', 'appellf1', 'legendre',
+    'assoc_legendre', 'hermite', 'hermite_prob', 'chebyshevt', 'chebyshevu',
+    'chebyshevu_root', 'chebyshevt_root', 'laguerre', 'assoc_laguerre',
+    'gegenbauer', 'jacobi', 'jacobi_normalized', 'Ynm', 'Ynm_c', 'Znm',
+    'elliptic_k', 'elliptic_f', 'elliptic_e', 'elliptic_pi', 'beta',
+    'mathieus', 'mathieuc', 'mathieusprime', 'mathieucprime', 'riemann_xi','betainc',
+    'betainc_regularized',
+
+    # sympy.ntheory
+    'nextprime', 'prevprime', 'prime', 'primerange', 'randprime',
+    'Sieve', 'sieve', 'primorial', 'cycle_length', 'composite', 'compositepi',
+    'isprime', 'divisors', 'proper_divisors', 'factorint', 'multiplicity',
+    'perfect_power', 'pollard_pm1', 'factor_cache', 'pollard_rho', 'primefactors',
+    'divisor_count', 'proper_divisor_count',
+    'factorrat',
+    'mersenne_prime_exponent', 'is_perfect', 'is_mersenne_prime',
+    'is_abundant', 'is_deficient', 'is_amicable', 'is_carmichael', 'abundance',
+    'npartitions',
+    'is_primitive_root', 'is_quad_residue',
+    'n_order', 'sqrt_mod', 'quadratic_residues',
+    'primitive_root', 'nthroot_mod', 'is_nthpow_residue', 'sqrt_mod_iter',
+    'discrete_log', 'quadratic_congruence', 'binomial_coefficients',
+    'binomial_coefficients_list', 'multinomial_coefficients',
+    'continued_fraction_periodic', 'continued_fraction_iterator',
+    'continued_fraction_reduce', 'continued_fraction_convergents',
+    'continued_fraction', 'egyptian_fraction',
+
+    # sympy.concrete
+    'product', 'Product', 'summation', 'Sum',
+
+    # sympy.discrete
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform', 'convolution', 'covering_product',
+    'intersecting_product',
+
+    # sympy.simplify
+    'simplify', 'hypersimp', 'hypersimilar', 'logcombine', 'separatevars',
+    'posify', 'besselsimp', 'kroneckersimp', 'signsimp',
+    'nsimplify', 'FU', 'fu', 'sqrtdenest', 'cse', 'epath', 'EPath',
+    'hyperexpand', 'collect', 'rcollect', 'radsimp', 'collect_const',
+    'fraction', 'numer', 'denom', 'trigsimp', 'exptrigsimp', 'powsimp',
+    'powdenest', 'combsimp', 'gammasimp', 'ratsimp', 'ratsimpmodprime',
+
+    # sympy.sets
+    'Set', 'Interval', 'Union', 'EmptySet', 'FiniteSet', 'ProductSet',
+    'Intersection', 'imageset', 'DisjointUnion', 'Complement', 'SymmetricDifference',
+    'ImageSet', 'Range', 'ComplexRegion', 'Reals', 'Contains', 'ConditionSet',
+    'Ordinal', 'OmegaPower', 'ord0', 'PowerSet', 'Naturals',
+    'Naturals0', 'UniversalSet', 'Integers', 'Rationals', 'Complexes',
+
+    # sympy.solvers
+    'solve', 'solve_linear_system', 'solve_linear_system_LU',
+    'solve_undetermined_coeffs', 'nsolve', 'solve_linear', 'checksol',
+    'det_quick', 'inv_quick', 'check_assumptions', 'failing_assumptions',
+    'diophantine', 'rsolve', 'rsolve_poly', 'rsolve_ratio', 'rsolve_hyper',
+    'checkodesol', 'classify_ode', 'dsolve', 'homogeneous_order',
+    'solve_poly_system', 'factor_system', 'solve_triangulated', 'pde_separate',
+    'pde_separate_add', 'pde_separate_mul', 'pdsolve', 'classify_pde',
+    'checkpdesol', 'ode_order', 'reduce_inequalities',
+    'reduce_abs_inequality', 'reduce_abs_inequalities',
+    'solve_poly_inequality', 'solve_rational_inequalities',
+    'solve_univariate_inequality', 'decompogen', 'solveset', 'linsolve',
+    'linear_eq_to_matrix', 'nonlinsolve', 'substitution',
+
+    # sympy.matrices
+    'ShapeError', 'NonSquareMatrixError', 'GramSchmidt', 'casoratian', 'diag',
+    'eye', 'hessian', 'jordan_cell', 'list2numpy', 'matrix2numpy',
+    'matrix_multiply_elementwise', 'ones', 'randMatrix', 'rot_axis1',
+    'rot_axis2', 'rot_axis3', 'symarray', 'wronskian', 'zeros',
+    'MutableDenseMatrix', 'DeferredVector', 'MatrixBase', 'Matrix',
+    'MutableMatrix', 'MutableSparseMatrix', 'banded', 'ImmutableDenseMatrix',
+    'ImmutableSparseMatrix', 'ImmutableMatrix', 'SparseMatrix', 'MatrixSlice',
+    'BlockDiagMatrix', 'BlockMatrix', 'FunctionMatrix', 'Identity', 'Inverse',
+    'MatAdd', 'MatMul', 'MatPow', 'MatrixExpr', 'MatrixSymbol', 'Trace',
+    'Transpose', 'ZeroMatrix', 'OneMatrix', 'blockcut', 'block_collapse',
+    'matrix_symbols', 'Adjoint', 'hadamard_product', 'HadamardProduct',
+    'HadamardPower', 'Determinant', 'det', 'diagonalize_vector', 'DiagMatrix',
+    'DiagonalMatrix', 'DiagonalOf', 'trace', 'DotProduct',
+    'kronecker_product', 'KroneckerProduct', 'PermutationMatrix',
+    'MatrixPermute', 'Permanent', 'per', 'rot_ccw_axis1', 'rot_ccw_axis2',
+    'rot_ccw_axis3', 'rot_givens',
+
+    # sympy.geometry
+    'Point', 'Point2D', 'Point3D', 'Line', 'Ray', 'Segment', 'Line2D',
+    'Segment2D', 'Ray2D', 'Line3D', 'Segment3D', 'Ray3D', 'Plane', 'Ellipse',
+    'Circle', 'Polygon', 'RegularPolygon', 'Triangle', 'rad', 'deg',
+    'are_similar', 'centroid', 'convex_hull', 'idiff', 'intersection',
+    'closest_points', 'farthest_points', 'GeometryError', 'Curve', 'Parabola',
+
+    # sympy.utilities
+    'flatten', 'group', 'take', 'subsets', 'variations', 'numbered_symbols',
+    'cartes', 'capture', 'dict_merge', 'prefixes', 'postfixes', 'sift',
+    'topological_sort', 'unflatten', 'has_dups', 'has_variety', 'reshape',
+    'rotations', 'filldedent', 'lambdify', 'threaded', 'xthreaded',
+    'public', 'memoize_property', 'timed',
+
+    # sympy.integrals
+    'integrate', 'Integral', 'line_integrate', 'mellin_transform',
+    'inverse_mellin_transform', 'MellinTransform', 'InverseMellinTransform',
+    'laplace_transform', 'inverse_laplace_transform', 'LaplaceTransform',
+    'laplace_correspondence', 'laplace_initial_conds',
+    'InverseLaplaceTransform', 'fourier_transform',
+    'inverse_fourier_transform', 'FourierTransform',
+    'InverseFourierTransform', 'sine_transform', 'inverse_sine_transform',
+    'SineTransform', 'InverseSineTransform', 'cosine_transform',
+    'inverse_cosine_transform', 'CosineTransform', 'InverseCosineTransform',
+    'hankel_transform', 'inverse_hankel_transform', 'HankelTransform',
+    'InverseHankelTransform', 'singularityintegrate',
+
+    # sympy.tensor
+    'IndexedBase', 'Idx', 'Indexed', 'get_contraction_structure',
+    'get_indices', 'shape', 'MutableDenseNDimArray', 'ImmutableDenseNDimArray',
+    'MutableSparseNDimArray', 'ImmutableSparseNDimArray', 'NDimArray',
+    'tensorproduct', 'tensorcontraction', 'tensordiagonal', 'derive_by_array',
+    'permutedims', 'Array', 'DenseNDimArray', 'SparseNDimArray',
+
+    # sympy.parsing
+    'parse_expr',
+
+    # sympy.calculus
+    'euler_equations', 'singularities', 'is_increasing',
+    'is_strictly_increasing', 'is_decreasing', 'is_strictly_decreasing',
+    'is_monotonic', 'finite_diff_weights', 'apply_finite_diff',
+    'differentiate_finite', 'periodicity', 'not_empty_in',
+    'AccumBounds', 'is_convex', 'stationary_points', 'minimum', 'maximum',
+
+    # sympy.algebras
+    'Quaternion',
+
+    # sympy.printing
+    'pager_print', 'pretty', 'pretty_print', 'pprint', 'pprint_use_unicode',
+    'pprint_try_use_unicode', 'latex', 'print_latex', 'multiline_latex',
+    'mathml', 'print_mathml', 'python', 'print_python', 'pycode', 'ccode',
+    'print_ccode', 'smtlib_code', 'glsl_code', 'print_glsl', 'cxxcode', 'fcode',
+    'print_fcode', 'rcode', 'print_rcode', 'jscode', 'print_jscode',
+    'julia_code', 'mathematica_code', 'octave_code', 'rust_code', 'print_gtk',
+    'preview', 'srepr', 'print_tree', 'StrPrinter', 'sstr', 'sstrrepr',
+    'TableForm', 'dotprint', 'maple_code', 'print_maple_code',
+
+    # sympy.plotting
+    'plot', 'textplot', 'plot_backends', 'plot_implicit', 'plot_parametric',
+
+    # sympy.interactive
+    'init_session', 'init_printing', 'interactive_traversal',
+
+    # sympy.testing
+    'test', 'doctest',
+]
+
+
+#===========================================================================#
+#                                                                           #
+# XXX: The names below were importable before SymPy 1.6 using               #
+#                                                                           #
+#          from sympy import *                                              #
+#                                                                           #
+# This happened implicitly because there was no __all__ defined in this     #
+# __init__.py file. Not every package is imported. The list matches what    #
+# would have been imported before. It is possible that these packages will  #
+# not be imported by a star-import from sympy in future.                    #
+#                                                                           #
+#===========================================================================#
+
+
+__all__.extend((
+    'algebras',
+    'assumptions',
+    'calculus',
+    'concrete',
+    'discrete',
+    'external',
+    'functions',
+    'geometry',
+    'interactive',
+    'multipledispatch',
+    'ntheory',
+    'parsing',
+    'plotting',
+    'polys',
+    'printing',
+    'release',
+    'strategies',
+    'tensor',
+    'utilities',
+))
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..accc9a910868d882464e66c3d8e76709cb170e12
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/abc.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/abc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef324cb42fa638a701a9e73ba88265067034a8a9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/abc.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/conftest.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/conftest.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9251bcbcd4b55ac6bbd1290452ede7f8aee4a4e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/conftest.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/galgebra.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/galgebra.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a9cdac9046a3b615982bddba03b07d4721b28757
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/galgebra.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/release.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/release.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ab4a6e7db2b5e8676f9ded7acfe8a0adb29691c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/release.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/__pycache__/this.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/__pycache__/this.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08e4af7ddc7e3ba3870b55b35d5969396a3cd7e9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/__pycache__/this.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/abc.py b/.venv/lib/python3.12/site-packages/sympy/abc.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6f7a4056e60b0d651becc0b9909bd0ab3c1723f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/abc.py
@@ -0,0 +1,111 @@
+"""
+This module exports all latin and greek letters as Symbols, so you can
+conveniently do
+
+    >>> from sympy.abc import x, y
+
+instead of the slightly more clunky-looking
+
+    >>> from sympy import symbols
+    >>> x, y = symbols('x y')
+
+Caveats
+=======
+
+1. As of the time of writing this, the names ``O``, ``S``, ``I``, ``N``,
+``E``, and ``Q`` are colliding with names defined in SymPy. If you import them
+from both ``sympy.abc`` and ``sympy``, the second import will "win".
+This is an issue only for * imports, which should only be used for short-lived
+code such as interactive sessions and throwaway scripts that do not survive
+until the next SymPy upgrade, where ``sympy`` may contain a different set of
+names.
+
+2. This module does not define symbol names on demand, i.e.
+``from sympy.abc import foo`` will be reported as an error because
+``sympy.abc`` does not contain the name ``foo``. To get a symbol named ``foo``,
+you still need to use ``Symbol('foo')`` or ``symbols('foo')``.
+You can freely mix usage of ``sympy.abc`` and ``Symbol``/``symbols``, though
+sticking with one and only one way to get the symbols does tend to make the code
+more readable.
+
+The module also defines some special names to help detect which names clash
+with the default SymPy namespace.
+
+``_clash1`` defines all the single letter variables that clash with
+SymPy objects; ``_clash2`` defines the multi-letter clashing symbols;
+and ``_clash`` is the union of both. These can be passed for ``locals``
+during sympification if one desires Symbols rather than the non-Symbol
+objects for those names.
+
+Examples
+========
+
+>>> from sympy import S
+>>> from sympy.abc import _clash1, _clash2, _clash
+>>> S("Q & C", locals=_clash1)
+C & Q
+>>> S('pi(x)', locals=_clash2)
+pi(x)
+>>> S('pi(C, Q)', locals=_clash)
+pi(C, Q)
+
+"""
+from __future__ import annotations
+from typing import Any
+
+import string
+
+from .core import Symbol, symbols
+from .core.alphabets import greeks
+from sympy.parsing.sympy_parser import null
+
+##### Symbol definitions #####
+
+# Implementation note: The easiest way to avoid typos in the symbols()
+# parameter is to copy it from the left-hand side of the assignment.
+
+a, b, c, d, e, f, g, h, i, j = symbols('a, b, c, d, e, f, g, h, i, j')
+k, l, m, n, o, p, q, r, s, t = symbols('k, l, m, n, o, p, q, r, s, t')
+u, v, w, x, y, z = symbols('u, v, w, x, y, z')
+
+A, B, C, D, E, F, G, H, I, J = symbols('A, B, C, D, E, F, G, H, I, J')
+K, L, M, N, O, P, Q, R, S, T = symbols('K, L, M, N, O, P, Q, R, S, T')
+U, V, W, X, Y, Z = symbols('U, V, W, X, Y, Z')
+
+alpha, beta, gamma, delta = symbols('alpha, beta, gamma, delta')
+epsilon, zeta, eta, theta = symbols('epsilon, zeta, eta, theta')
+iota, kappa, lamda, mu = symbols('iota, kappa, lamda, mu')
+nu, xi, omicron, pi = symbols('nu, xi, omicron, pi')
+rho, sigma, tau, upsilon = symbols('rho, sigma, tau, upsilon')
+phi, chi, psi, omega = symbols('phi, chi, psi, omega')
+
+
+##### Clashing-symbols diagnostics #####
+
+# We want to know which names in SymPy collide with those in here.
+# This is mostly for diagnosing SymPy's namespace during SymPy development.
+
+_latin = list(string.ascii_letters)
+# QOSINE should not be imported as they clash; gamma, pi and zeta clash, too
+_greek = list(greeks) # make a copy, so we can mutate it
+# Note: We import lamda since lambda is a reserved keyword in Python
+_greek.remove("lambda")
+_greek.append("lamda")
+
+ns: dict[str, Any] = {}
+exec('from sympy import *', ns)
+_clash1: dict[str, Any] = {}
+_clash2: dict[str, Any] = {}
+while ns:
+    _k, _ = ns.popitem()
+    if _k in _greek:
+        _clash2[_k] = null
+        _greek.remove(_k)
+    elif _k in _latin:
+        _clash1[_k] = null
+        _latin.remove(_k)
+_clash = {}
+_clash.update(_clash1)
+_clash.update(_clash2)
+
+del _latin, _greek, Symbol, _k, null
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/__init__.py b/.venv/lib/python3.12/site-packages/sympy/algebras/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..58013d2e0377a016d1a21fbf21c344ee76765189
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/algebras/__init__.py
@@ -0,0 +1,3 @@
+from .quaternion import Quaternion
+
+__all__ = ["Quaternion",]
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8166e89f08f55fac0e84f274cb6313f5f88a2eb2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/quaternion.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/quaternion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4116d83d57224e586bfd80eb161ee67a62a4add4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/algebras/__pycache__/quaternion.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/quaternion.py b/.venv/lib/python3.12/site-packages/sympy/algebras/quaternion.py
new file mode 100644
index 0000000000000000000000000000000000000000..1bf4b363545128e50294e825461106ef9b41990d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/algebras/quaternion.py
@@ -0,0 +1,1666 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.relational import is_eq
+from sympy.functions.elementary.complexes import (conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log as ln)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, atan2)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import MutableDenseMatrix as Matrix
+from sympy.core.sympify import sympify, _sympify
+from sympy.core.expr import Expr
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.utilities.misc import as_int
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+def _check_norm(elements, norm):
+    """validate if input norm is consistent"""
+    if norm is not None and norm.is_number:
+        if norm.is_positive is False:
+            raise ValueError("Input norm must be positive.")
+
+        numerical = all(i.is_number and i.is_real is True for i in elements)
+        if numerical and is_eq(norm**2, sum(i**2 for i in elements)) is False:
+            raise ValueError("Incompatible value for norm.")
+
+
+def _is_extrinsic(seq):
+    """validate seq and return True if seq is lowercase and False if uppercase"""
+    if type(seq) != str:
+        raise ValueError('Expected seq to be a string.')
+    if len(seq) != 3:
+        raise ValueError("Expected 3 axes, got `{}`.".format(seq))
+
+    intrinsic = seq.isupper()
+    extrinsic = seq.islower()
+    if not (intrinsic or extrinsic):
+        raise ValueError("seq must either be fully uppercase (for extrinsic "
+                         "rotations), or fully lowercase, for intrinsic "
+                         "rotations).")
+
+    i, j, k = seq.lower()
+    if (i == j) or (j == k):
+        raise ValueError("Consecutive axes must be different")
+
+    bad = set(seq) - set('xyzXYZ')
+    if bad:
+        raise ValueError("Expected axes from `seq` to be from "
+                         "['x', 'y', 'z'] or ['X', 'Y', 'Z'], "
+                         "got {}".format(''.join(bad)))
+
+    return extrinsic
+
+
+class Quaternion(Expr):
+    """Provides basic quaternion operations.
+    Quaternion objects can be instantiated as ``Quaternion(a, b, c, d)``
+    as in $q = a + bi + cj + dk$.
+
+    Parameters
+    ==========
+
+    norm : None or number
+        Pre-defined quaternion norm. If a value is given, Quaternion.norm
+        returns this pre-defined value instead of calculating the norm
+
+    Examples
+    ========
+
+    >>> from sympy import Quaternion
+    >>> q = Quaternion(1, 2, 3, 4)
+    >>> q
+    1 + 2*i + 3*j + 4*k
+
+    Quaternions over complex fields can be defined as:
+
+    >>> from sympy import Quaternion
+    >>> from sympy import symbols, I
+    >>> x = symbols('x')
+    >>> q1 = Quaternion(x, x**3, x, x**2, real_field = False)
+    >>> q2 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    >>> q1
+    x + x**3*i + x*j + x**2*k
+    >>> q2
+    (3 + 4*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+    Defining symbolic unit quaternions:
+
+    >>> from sympy import Quaternion
+    >>> from sympy.abc import w, x, y, z
+    >>> q = Quaternion(w, x, y, z, norm=1)
+    >>> q
+    w + x*i + y*j + z*k
+    >>> q.norm()
+    1
+
+    References
+    ==========
+
+    .. [1] https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/
+    .. [2] https://en.wikipedia.org/wiki/Quaternion
+
+    """
+    _op_priority = 11.0
+
+    is_commutative = False
+
+    def __new__(cls, a=0, b=0, c=0, d=0, real_field=True, norm=None):
+        a, b, c, d = map(sympify, (a, b, c, d))
+
+        if any(i.is_commutative is False for i in [a, b, c, d]):
+            raise ValueError("arguments have to be commutative")
+        obj = super().__new__(cls, a, b, c, d)
+        obj._real_field = real_field
+        obj.set_norm(norm)
+        return obj
+
+    def set_norm(self, norm):
+        """Sets norm of an already instantiated quaternion.
+
+        Parameters
+        ==========
+
+        norm : None or number
+            Pre-defined quaternion norm. If a value is given, Quaternion.norm
+            returns this pre-defined value instead of calculating the norm
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        Setting the norm:
+
+        >>> q.set_norm(1)
+        >>> q.norm()
+        1
+
+        Removing set norm:
+
+        >>> q.set_norm(None)
+        >>> q.norm()
+        sqrt(a**2 + b**2 + c**2 + d**2)
+
+        """
+        norm = sympify(norm)
+        _check_norm(self.args, norm)
+        self._norm = norm
+
+    @property
+    def a(self):
+        return self.args[0]
+
+    @property
+    def b(self):
+        return self.args[1]
+
+    @property
+    def c(self):
+        return self.args[2]
+
+    @property
+    def d(self):
+        return self.args[3]
+
+    @property
+    def real_field(self):
+        return self._real_field
+
+    @property
+    def product_matrix_left(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        left. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  &-d  & c \\
+                                  c  & d  & a  &-b \\
+                                  d  &-c  & b  & a \end{bmatrix}
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(1, 0, 0, 1)
+        >>> q2 = Quaternion(a, b, c, d)
+        >>> q1.product_matrix_left
+        Matrix([
+        [1, 0,  0, -1],
+        [0, 1, -1,  0],
+        [0, 1,  1,  0],
+        [1, 0,  0,  1]])
+
+        >>> q1.product_matrix_left * q2.to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [a - d],
+        [b - c],
+        [b + c],
+        [a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, -self.d, self.c],
+                [self.c, self.d, self.a, -self.b],
+                [self.d, -self.c, self.b, self.a]])
+
+    @property
+    def product_matrix_right(self):
+        r"""Returns 4 x 4 Matrix equivalent to a Hamilton product from the
+        right. This can be useful when treating quaternion elements as column
+        vectors. Given a quaternion $q = a + bi + cj + dk$ where a, b, c and d
+        are real numbers, the product matrix from the left is:
+
+        .. math::
+
+            M  =  \begin{bmatrix} a  &-b  &-c  &-d \\
+                                  b  & a  & d  &-c \\
+                                  c  &-d  & a  & b \\
+                                  d  & c  &-b  & a \end{bmatrix}
+
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q1 = Quaternion(a, b, c, d)
+        >>> q2 = Quaternion(1, 0, 0, 1)
+        >>> q2.product_matrix_right
+        Matrix([
+        [1, 0, 0, -1],
+        [0, 1, 1, 0],
+        [0, -1, 1, 0],
+        [1, 0, 0, 1]])
+
+        Note the switched arguments: the matrix represents the quaternion on
+        the right, but is still considered as a matrix multiplication from the
+        left.
+
+        >>> q2.product_matrix_right * q1.to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+
+        This is equivalent to:
+
+        >>> (q1 * q2).to_Matrix()
+        Matrix([
+        [ a - d],
+        [ b + c],
+        [-b + c],
+        [ a + d]])
+        """
+        return Matrix([
+                [self.a, -self.b, -self.c, -self.d],
+                [self.b, self.a, self.d, -self.c],
+                [self.c, -self.d, self.a, self.b],
+                [self.d, self.c, -self.b, self.a]])
+
+    def to_Matrix(self, vector_only=False):
+        """Returns elements of quaternion as a column vector.
+        By default, a ``Matrix`` of length 4 is returned, with the real part as the
+        first element.
+        If ``vector_only`` is ``True``, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        vector_only : bool
+            If True, only imaginary part is returned.
+            Default value: False
+
+        Returns
+        =======
+
+        Matrix
+            A column vector constructed by the elements of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion(a, b, c, d)
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q.to_Matrix()
+        Matrix([
+        [a],
+        [b],
+        [c],
+        [d]])
+
+
+        >>> q.to_Matrix(vector_only=True)
+        Matrix([
+        [b],
+        [c],
+        [d]])
+
+        """
+        if vector_only:
+            return Matrix(self.args[1:])
+        else:
+            return Matrix(self.args)
+
+    @classmethod
+    def from_Matrix(cls, elements):
+        """Returns quaternion from elements of a column vector`.
+        If vector_only is True, returns only imaginary part as a Matrix of
+        length 3.
+
+        Parameters
+        ==========
+
+        elements : Matrix, list or tuple of length 3 or 4. If length is 3,
+            assume real part is zero.
+            Default value: False
+
+        Returns
+        =======
+
+        Quaternion
+            A quaternion created from the input elements.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> q = Quaternion.from_Matrix([a, b, c, d])
+        >>> q
+        a + b*i + c*j + d*k
+
+        >>> q = Quaternion.from_Matrix([b, c, d])
+        >>> q
+        0 + b*i + c*j + d*k
+
+        """
+        length = len(elements)
+        if length != 3 and length != 4:
+            raise ValueError("Input elements must have length 3 or 4, got {} "
+                             "elements".format(length))
+
+        if length == 3:
+            return Quaternion(0, *elements)
+        else:
+            return Quaternion(*elements)
+
+    @classmethod
+    def from_euler(cls, angles, seq):
+        """Returns quaternion equivalent to rotation represented by the Euler
+        angles, in the sequence defined by ``seq``.
+
+        Parameters
+        ==========
+
+        angles : list, tuple or Matrix of 3 numbers
+            The Euler angles (in radians).
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the Euler angles
+            in the given sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi
+        >>> q = Quaternion.from_euler([pi/2, 0, 0], 'xyz')
+        >>> q
+        sqrt(2)/2 + sqrt(2)/2*i + 0*j + 0*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'zyz')
+        >>> q
+        0 + (-sqrt(2)/2)*i + 0*j + sqrt(2)/2*k
+
+        >>> q = Quaternion.from_euler([0, pi/2, pi] , 'ZYZ')
+        >>> q
+        0 + sqrt(2)/2*i + 0*j + sqrt(2)/2*k
+
+        """
+
+        if len(angles) != 3:
+            raise ValueError("3 angles must be given.")
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get elementary basis vectors
+        ei = [1 if n == i else 0 for n in 'xyz']
+        ej = [1 if n == j else 0 for n in 'xyz']
+        ek = [1 if n == k else 0 for n in 'xyz']
+
+        # calculate distinct quaternions
+        qi = cls.from_axis_angle(ei, angles[0])
+        qj = cls.from_axis_angle(ej, angles[1])
+        qk = cls.from_axis_angle(ek, angles[2])
+
+        if extrinsic:
+            return trigsimp(qk * qj * qi)
+        else:
+            return trigsimp(qi * qj * qk)
+
+    def to_euler(self, seq, angle_addition=True, avoid_square_root=False):
+        r"""Returns Euler angles representing same rotation as the quaternion,
+        in the sequence given by ``seq``. This implements the method described
+        in [1]_.
+
+        For degenerate cases (gymbal lock cases), the third angle is
+        set to zero.
+
+        Parameters
+        ==========
+
+        seq : string of length 3
+            Represents the sequence of rotations.
+            For extrinsic rotations, seq must be all lowercase and its elements
+            must be from the set ``{'x', 'y', 'z'}``
+            For intrinsic rotations, seq must be all uppercase and its elements
+            must be from the set ``{'X', 'Y', 'Z'}``
+
+        angle_addition : bool
+            When True, first and third angles are given as an addition and
+            subtraction of two simpler ``atan2`` expressions. When False, the
+            first and third angles are each given by a single more complicated
+            ``atan2`` expression. This equivalent expression is given by:
+
+            .. math::
+
+                \operatorname{atan_2} (b,a) \pm \operatorname{atan_2} (d,c) =
+                \operatorname{atan_2} (bc\pm ad, ac\mp bd)
+
+            Default value: True
+
+        avoid_square_root : bool
+            When True, the second angle is calculated with an expression based
+            on ``acos``, which is slightly more complicated but avoids a square
+            root. When False, second angle is calculated with ``atan2``, which
+            is simpler and can be better for numerical reasons (some
+            numerical implementations of ``acos`` have problems near zero).
+            Default value: False
+
+
+        Returns
+        =======
+
+        Tuple
+            The Euler angles calculated from the quaternion
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import a, b, c, d
+        >>> euler = Quaternion(a, b, c, d).to_euler('zyz')
+        >>> euler
+        (-atan2(-b, c) + atan2(d, a),
+         2*atan2(sqrt(b**2 + c**2), sqrt(a**2 + d**2)),
+         atan2(-b, c) + atan2(d, a))
+
+
+        References
+        ==========
+
+        .. [1] https://doi.org/10.1371/journal.pone.0276302
+
+        """
+        if self.is_zero_quaternion():
+            raise ValueError('Cannot convert a quaternion with norm 0.')
+
+        angles = [0, 0, 0]
+
+        extrinsic = _is_extrinsic(seq)
+        i, j, k = seq.lower()
+
+        # get index corresponding to elementary basis vectors
+        i = 'xyz'.index(i) + 1
+        j = 'xyz'.index(j) + 1
+        k = 'xyz'.index(k) + 1
+
+        if not extrinsic:
+            i, k = k, i
+
+        # check if sequence is symmetric
+        symmetric = i == k
+        if symmetric:
+            k = 6 - i - j
+
+        # parity of the permutation
+        sign = (i - j) * (j - k) * (k - i) // 2
+
+        # permutate elements
+        elements = [self.a, self.b, self.c, self.d]
+        a = elements[0]
+        b = elements[i]
+        c = elements[j]
+        d = elements[k] * sign
+
+        if not symmetric:
+            a, b, c, d = a - c, b + d, c + a, d - b
+
+        if avoid_square_root:
+            if symmetric:
+                n2 = self.norm()**2
+                angles[1] = acos((a * a + b * b - c * c - d * d) / n2)
+            else:
+                n2 = 2 * self.norm()**2
+                angles[1] = asin((c * c + d * d - a * a - b * b) / n2)
+        else:
+            angles[1] = 2 * atan2(sqrt(c * c + d * d), sqrt(a * a + b * b))
+            if not symmetric:
+                angles[1] -= S.Pi / 2
+
+        # Check for singularities in numerical cases
+        case = 0
+        if is_eq(c, S.Zero) and is_eq(d, S.Zero):
+            case = 1
+        if is_eq(a, S.Zero) and is_eq(b, S.Zero):
+            case = 2
+
+        if case == 0:
+            if angle_addition:
+                angles[0] = atan2(b, a) + atan2(d, c)
+                angles[2] = atan2(b, a) - atan2(d, c)
+            else:
+                angles[0] = atan2(b*c + a*d, a*c - b*d)
+                angles[2] = atan2(b*c - a*d, a*c + b*d)
+
+        else:  # any degenerate case
+            angles[2 * (not extrinsic)] = S.Zero
+            if case == 1:
+                angles[2 * extrinsic] = 2 * atan2(b, a)
+            else:
+                angles[2 * extrinsic] = 2 * atan2(d, c)
+                angles[2 * extrinsic] *= (-1 if extrinsic else 1)
+
+        # for Tait-Bryan angles
+        if not symmetric:
+            angles[0] *= sign
+
+        if extrinsic:
+            return tuple(angles[::-1])
+        else:
+            return tuple(angles)
+
+    @classmethod
+    def from_axis_angle(cls, vector, angle):
+        """Returns a rotation quaternion given the axis and the angle of rotation.
+
+        Parameters
+        ==========
+
+        vector : tuple of three numbers
+            The vector representation of the given axis.
+        angle : number
+            The angle by which axis is rotated (in radians).
+
+        Returns
+        =======
+
+        Quaternion
+            The normalized rotation quaternion calculated from the given axis and the angle of rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import pi, sqrt
+        >>> q = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), 2*pi/3)
+        >>> q
+        1/2 + 1/2*i + 1/2*j + 1/2*k
+
+        """
+        (x, y, z) = vector
+        norm = sqrt(x**2 + y**2 + z**2)
+        (x, y, z) = (x / norm, y / norm, z / norm)
+        s = sin(angle * S.Half)
+        a = cos(angle * S.Half)
+        b = x * s
+        c = y * s
+        d = z * s
+
+        # note that this quaternion is already normalized by construction:
+        # c^2 + (s*x)^2 + (s*y)^2 + (s*z)^2 = c^2 + s^2*(x^2 + y^2 + z^2) = c^2 + s^2 * 1 = c^2 + s^2 = 1
+        # so, what we return is a normalized quaternion
+
+        return cls(a, b, c, d)
+
+    @classmethod
+    def from_rotation_matrix(cls, M):
+        """Returns the equivalent quaternion of a matrix. The quaternion will be normalized
+        only if the matrix is special orthogonal (orthogonal and det(M) = 1).
+
+        Parameters
+        ==========
+
+        M : Matrix
+            Input matrix to be converted to equivalent quaternion. M must be special
+            orthogonal (orthogonal and det(M) = 1) for the quaternion to be normalized.
+
+        Returns
+        =======
+
+        Quaternion
+            The quaternion equivalent to given matrix.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Matrix, symbols, cos, sin, trigsimp
+        >>> x = symbols('x')
+        >>> M = Matrix([[cos(x), -sin(x), 0], [sin(x), cos(x), 0], [0, 0, 1]])
+        >>> q = trigsimp(Quaternion.from_rotation_matrix(M))
+        >>> q
+        sqrt(2)*sqrt(cos(x) + 1)/2 + 0*i + 0*j + sqrt(2 - 2*cos(x))*sign(sin(x))/2*k
+
+        """
+
+        absQ = M.det()**Rational(1, 3)
+
+        a = sqrt(absQ + M[0, 0] + M[1, 1] + M[2, 2]) / 2
+        b = sqrt(absQ + M[0, 0] - M[1, 1] - M[2, 2]) / 2
+        c = sqrt(absQ - M[0, 0] + M[1, 1] - M[2, 2]) / 2
+        d = sqrt(absQ - M[0, 0] - M[1, 1] + M[2, 2]) / 2
+
+        b = b * sign(M[2, 1] - M[1, 2])
+        c = c * sign(M[0, 2] - M[2, 0])
+        d = d * sign(M[1, 0] - M[0, 1])
+
+        return Quaternion(a, b, c, d)
+
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.add(other*-1)
+
+    def __mul__(self, other):
+        return self._generic_mul(self, _sympify(other))
+
+    def __rmul__(self, other):
+        return self._generic_mul(_sympify(other), self)
+
+    def __pow__(self, p):
+        return self.pow(p)
+
+    def __neg__(self):
+        return Quaternion(-self.a, -self.b, -self.c, -self.d)
+
+    def __truediv__(self, other):
+        return self * sympify(other)**-1
+
+    def __rtruediv__(self, other):
+        return sympify(other) * self**-1
+
+    def _eval_Integral(self, *args):
+        return self.integrate(*args)
+
+    def diff(self, *symbols, **kwargs):
+        kwargs.setdefault('evaluate', True)
+        return self.func(*[a.diff(*symbols, **kwargs) for a  in self.args])
+
+    def add(self, other):
+        """Adds quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion
+            The quaternion to add to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after adding self to other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.add(q2)
+        6 + 8*i + 10*j + 12*k
+        >>> q1 + 5
+        6 + 2*i + 3*j + 4*k
+        >>> x = symbols('x', real = True)
+        >>> q1.add(x)
+        (x + 1) + 2*i + 3*j + 4*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.add(2 + 3*I)
+        (5 + 7*I) + (2 + 5*I)*i + 0*j + (7 + 8*I)*k
+
+        """
+        q1 = self
+        q2 = sympify(other)
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return Quaternion(re(q2) + q1.a, im(q2) + q1.b, q1.c, q1.d)
+            elif q2.is_commutative:
+                return Quaternion(q1.a + q2, q1.b, q1.c, q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be added with a Quaternion.")
+
+        return Quaternion(q1.a + q2.a, q1.b + q2.b, q1.c + q2.c, q1.d
+                          + q2.d)
+
+    def mul(self, other):
+        """Multiplies quaternions.
+
+        Parameters
+        ==========
+
+        other : Quaternion or symbol
+            The quaternion to multiply to current (self) quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying self with other
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> q1.mul(q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> q1.mul(2)
+        2 + 4*i + 6*j + 8*k
+        >>> x = symbols('x', real = True)
+        >>> q1.mul(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import Quaternion
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> q3.mul(2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        return self._generic_mul(self, _sympify(other))
+
+    @staticmethod
+    def _generic_mul(q1, q2):
+        """Generic multiplication.
+
+        Parameters
+        ==========
+
+        q1 : Quaternion or symbol
+        q2 : Quaternion or symbol
+
+        It is important to note that if neither q1 nor q2 is a Quaternion,
+        this function simply returns q1 * q2.
+
+        Returns
+        =======
+
+        Quaternion
+            The resultant quaternion after multiplying q1 and q2
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import Symbol, S
+        >>> q1 = Quaternion(1, 2, 3, 4)
+        >>> q2 = Quaternion(5, 6, 7, 8)
+        >>> Quaternion._generic_mul(q1, q2)
+        (-60) + 12*i + 30*j + 24*k
+        >>> Quaternion._generic_mul(q1, S(2))
+        2 + 4*i + 6*j + 8*k
+        >>> x = Symbol('x', real = True)
+        >>> Quaternion._generic_mul(q1, x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Quaternions over complex fields :
+
+        >>> from sympy import I
+        >>> q3 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+        >>> Quaternion._generic_mul(q3, 2 + 3*I)
+        (2 + 3*I)*(3 + 4*I) + (2 + 3*I)*(2 + 5*I)*i + 0*j + (2 + 3*I)*(7 + 8*I)*k
+
+        """
+        # None is a Quaternion:
+        if not isinstance(q1, Quaternion) and not isinstance(q2, Quaternion):
+            return q1 * q2
+
+        # If q1 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q1, Quaternion):
+            if q2.real_field and q1.is_complex:
+                return Quaternion(re(q1), im(q1), 0, 0) * q2
+            elif q1.is_commutative:
+                return Quaternion(q1 * q2.a, q1 * q2.b, q1 * q2.c, q1 * q2.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If q2 is a number or a SymPy expression instead of a quaternion
+        if not isinstance(q2, Quaternion):
+            if q1.real_field and q2.is_complex:
+                return q1 * Quaternion(re(q2), im(q2), 0, 0)
+            elif q2.is_commutative:
+                return Quaternion(q2 * q1.a, q2 * q1.b, q2 * q1.c, q2 * q1.d)
+            else:
+                raise ValueError("Only commutative expressions can be multiplied with a Quaternion.")
+
+        # If any of the quaternions has a fixed norm, pre-compute norm
+        if q1._norm is None and q2._norm is None:
+            norm = None
+        else:
+            norm = q1.norm() * q2.norm()
+
+        return Quaternion(-q1.b*q2.b - q1.c*q2.c - q1.d*q2.d + q1.a*q2.a,
+                          q1.b*q2.a + q1.c*q2.d - q1.d*q2.c + q1.a*q2.b,
+                          -q1.b*q2.d + q1.c*q2.a + q1.d*q2.b + q1.a*q2.c,
+                          q1.b*q2.c - q1.c*q2.b + q1.d*q2.a + q1.a * q2.d,
+                          norm=norm)
+
+    def _eval_conjugate(self):
+        """Returns the conjugate of the quaternion."""
+        q = self
+        return Quaternion(q.a, -q.b, -q.c, -q.d, norm=q._norm)
+
+    def norm(self):
+        """Returns the norm of the quaternion."""
+        if self._norm is None:  # check if norm is pre-defined
+            q = self
+            # trigsimp is used to simplify sin(x)^2 + cos(x)^2 (these terms
+            # arise when from_axis_angle is used).
+            return sqrt(trigsimp(q.a**2 + q.b**2 + q.c**2 + q.d**2))
+
+        return self._norm
+
+    def normalize(self):
+        """Returns the normalized form of the quaternion."""
+        q = self
+        return q * (1/q.norm())
+
+    def inverse(self):
+        """Returns the inverse of the quaternion."""
+        q = self
+        if not q.norm():
+            raise ValueError("Cannot compute inverse for a quaternion with zero norm")
+        return conjugate(q) * (1/q.norm()**2)
+
+    def pow(self, p):
+        """Finds the pth power of the quaternion.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Returns the p-th power of the current quaternion.
+            Returns the inverse if p = -1.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow(4)
+        668 + (-224)*i + (-336)*j + (-448)*k
+
+        """
+        try:
+            q, p = self, as_int(p)
+        except ValueError:
+            return NotImplemented
+
+        if p < 0:
+            q, p = q.inverse(), -p
+
+        if p == 1:
+            return q
+
+        res = Quaternion(1, 0, 0, 0)
+        while p > 0:
+            if p & 1:
+                res *= q
+            q *= q
+            p >>= 1
+
+        return res
+
+    def exp(self):
+        """Returns the exponential of $q$, given by $e^q$.
+
+        Returns
+        =======
+
+        Quaternion
+            The exponential of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.exp()
+        E*cos(sqrt(29))
+        + 2*sqrt(29)*E*sin(sqrt(29))/29*i
+        + 3*sqrt(29)*E*sin(sqrt(29))/29*j
+        + 4*sqrt(29)*E*sin(sqrt(29))/29*k
+
+        """
+        # exp(q) = e^a(cos||v|| + v/||v||*sin||v||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        a = exp(q.a) * cos(vector_norm)
+        b = exp(q.a) * sin(vector_norm) * q.b / vector_norm
+        c = exp(q.a) * sin(vector_norm) * q.c / vector_norm
+        d = exp(q.a) * sin(vector_norm) * q.d / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def log(self):
+        r"""Returns the logarithm of the quaternion, given by $\log q$.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.log()
+        log(sqrt(30))
+        + 2*sqrt(29)*acos(sqrt(30)/30)/29*i
+        + 3*sqrt(29)*acos(sqrt(30)/30)/29*j
+        + 4*sqrt(29)*acos(sqrt(30)/30)/29*k
+
+        """
+        # log(q) = log||q|| + v/||v||*arccos(a/||q||)
+        q = self
+        vector_norm = sqrt(q.b**2 + q.c**2 + q.d**2)
+        q_norm = q.norm()
+        a = ln(q_norm)
+        b = q.b * acos(q.a / q_norm) / vector_norm
+        c = q.c * acos(q.a / q_norm) / vector_norm
+        d = q.d * acos(q.a / q_norm) / vector_norm
+
+        return Quaternion(a, b, c, d)
+
+    def _eval_subs(self, *args):
+        elements = [i.subs(*args) for i in self.args]
+        norm = self._norm
+        if norm is not None:
+            norm = norm.subs(*args)
+        _check_norm(elements, norm)
+        return Quaternion(*elements, norm=norm)
+
+    def _eval_evalf(self, prec):
+        """Returns the floating point approximations (decimal numbers) of the quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Floating point approximations of quaternion(self)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import sqrt
+        >>> q = Quaternion(1/sqrt(1), 1/sqrt(2), 1/sqrt(3), 1/sqrt(4))
+        >>> q.evalf()
+        1.00000000000000
+        + 0.707106781186547*i
+        + 0.577350269189626*j
+        + 0.500000000000000*k
+
+        """
+        nprec = prec_to_dps(prec)
+        return Quaternion(*[arg.evalf(n=nprec) for arg in self.args])
+
+    def pow_cos_sin(self, p):
+        """Computes the pth power in the cos-sin form.
+
+        Parameters
+        ==========
+
+        p : int
+            Power to be applied on quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            The p-th power in the cos-sin form.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.pow_cos_sin(4)
+        900*cos(4*acos(sqrt(30)/30))
+        + 1800*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*i
+        + 2700*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*j
+        + 3600*sqrt(29)*sin(4*acos(sqrt(30)/30))/29*k
+
+        """
+        # q = ||q||*(cos(a) + u*sin(a))
+        # q^p = ||q||^p * (cos(p*a) + u*sin(p*a))
+
+        q = self
+        (v, angle) = q.to_axis_angle()
+        q2 = Quaternion.from_axis_angle(v, p * angle)
+        return q2 * (q.norm()**p)
+
+    def integrate(self, *args):
+        """Computes integration of quaternion.
+
+        Returns
+        =======
+
+        Quaternion
+            Integration of the quaternion(self) with the given variable.
+
+        Examples
+        ========
+
+        Indefinite Integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate(x)
+        x + 2*x*i + 3*x*j + 4*x*k
+
+        Definite integral of quaternion :
+
+        >>> from sympy import Quaternion
+        >>> from sympy.abc import x
+        >>> q = Quaternion(1, 2, 3, 4)
+        >>> q.integrate((x, 1, 5))
+        4 + 8*i + 12*j + 16*k
+
+        """
+        return Quaternion(integrate(self.a, *args), integrate(self.b, *args),
+                          integrate(self.c, *args), integrate(self.d, *args))
+
+    @staticmethod
+    def rotate_point(pin, r):
+        """Returns the coordinates of the point pin (a 3 tuple) after rotation.
+
+        Parameters
+        ==========
+
+        pin : tuple
+            A 3-element tuple of coordinates of a point which needs to be
+            rotated.
+        r : Quaternion or tuple
+            Axis and angle of rotation.
+
+            It's important to note that when r is a tuple, it must be of the form
+            (axis, angle)
+
+        Returns
+        =======
+
+        tuple
+            The coordinates of the point after rotation.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), q))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> trigsimp(Quaternion.rotate_point((1, 1, 1), (axis, angle)))
+        (sqrt(2)*cos(x + pi/4), sqrt(2)*sin(x + pi/4), 1)
+
+        """
+        if isinstance(r, tuple):
+            # if r is of the form (vector, angle)
+            q = Quaternion.from_axis_angle(r[0], r[1])
+        else:
+            # if r is a quaternion
+            q = r.normalize()
+        pout = q * Quaternion(0, pin[0], pin[1], pin[2]) * conjugate(q)
+        return (pout.b, pout.c, pout.d)
+
+    def to_axis_angle(self):
+        """Returns the axis and angle of rotation of a quaternion.
+
+        Returns
+        =======
+
+        tuple
+            Tuple of (axis, angle)
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> (axis, angle) = q.to_axis_angle()
+        >>> axis
+        (sqrt(3)/3, sqrt(3)/3, sqrt(3)/3)
+        >>> angle
+        2*pi/3
+
+        """
+        q = self
+        if q.a.is_negative:
+            q = q * -1
+
+        q = q.normalize()
+        angle = trigsimp(2 * acos(q.a))
+
+        # Since quaternion is normalised, q.a is less than 1.
+        s = sqrt(1 - q.a*q.a)
+
+        x = trigsimp(q.b / s)
+        y = trigsimp(q.c / s)
+        z = trigsimp(q.d / s)
+
+        v = (x, y, z)
+        t = (v, angle)
+
+        return t
+
+    def to_rotation_matrix(self, v=None, homogeneous=True):
+        """Returns the equivalent rotation transformation matrix of the quaternion
+        which represents rotation about the origin if ``v`` is not passed.
+
+        Parameters
+        ==========
+
+        v : tuple or None
+            Default value: None
+        homogeneous : bool
+            When True, gives an expression that may be more efficient for
+            symbolic calculations but less so for direct evaluation. Both
+            formulas are mathematically equivalent.
+            Default value: True
+
+        Returns
+        =======
+
+        tuple
+            Returns the equivalent rotation transformation matrix of the quaternion
+            which represents rotation about the origin if v is not passed.
+
+        Examples
+        ========
+
+        >>> from sympy import Quaternion
+        >>> from sympy import symbols, trigsimp, cos, sin
+        >>> x = symbols('x')
+        >>> q = Quaternion(cos(x/2), 0, 0, sin(x/2))
+        >>> trigsimp(q.to_rotation_matrix())
+        Matrix([
+        [cos(x), -sin(x), 0],
+        [sin(x),  cos(x), 0],
+        [     0,       0, 1]])
+
+        Generates a 4x4 transformation matrix (used for rotation about a point
+        other than the origin) if the point(v) is passed as an argument.
+        """
+
+        q = self
+        s = q.norm()**-2
+
+        # diagonal elements are different according to parameter normal
+        if homogeneous:
+            m00 = s*(q.a**2 + q.b**2 - q.c**2 - q.d**2)
+            m11 = s*(q.a**2 - q.b**2 + q.c**2 - q.d**2)
+            m22 = s*(q.a**2 - q.b**2 - q.c**2 + q.d**2)
+        else:
+            m00 = 1 - 2*s*(q.c**2 + q.d**2)
+            m11 = 1 - 2*s*(q.b**2 + q.d**2)
+            m22 = 1 - 2*s*(q.b**2 + q.c**2)
+
+        m01 = 2*s*(q.b*q.c - q.d*q.a)
+        m02 = 2*s*(q.b*q.d + q.c*q.a)
+
+        m10 = 2*s*(q.b*q.c + q.d*q.a)
+        m12 = 2*s*(q.c*q.d - q.b*q.a)
+
+        m20 = 2*s*(q.b*q.d - q.c*q.a)
+        m21 = 2*s*(q.c*q.d + q.b*q.a)
+
+        if not v:
+            return Matrix([[m00, m01, m02], [m10, m11, m12], [m20, m21, m22]])
+
+        else:
+            (x, y, z) = v
+
+            m03 = x - x*m00 - y*m01 - z*m02
+            m13 = y - x*m10 - y*m11 - z*m12
+            m23 = z - x*m20 - y*m21 - z*m22
+            m30 = m31 = m32 = 0
+            m33 = 1
+
+            return Matrix([[m00, m01, m02, m03], [m10, m11, m12, m13],
+                          [m20, m21, m22, m23], [m30, m31, m32, m33]])
+
+    def scalar_part(self):
+        r"""Returns scalar part($\mathbf{S}(q)$) of the quaternion q.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{S}(q) = a$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.scalar_part()
+        4
+
+        """
+
+        return self.a
+
+    def vector_part(self):
+        r"""
+        Returns $\mathbf{V}(q)$, the vector part of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{V}(q) = bi + cj + dk$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.vector_part()
+        0 + 1*i + 1*j + 1*k
+
+        >>> q = Quaternion(4, 8, 13, 12)
+        >>> q.vector_part()
+        0 + 8*i + 13*j + 12*k
+
+        """
+
+        return Quaternion(0, self.b, self.c, self.d)
+
+    def axis(self):
+        r"""
+        Returns $\mathbf{Ax}(q)$, the axis of the quaternion $q$.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$, returns $\mathbf{Ax}(q)$  i.e., the versor of the vector part of that quaternion
+        equal to $\mathbf{U}[\mathbf{V}(q)]$.
+        The axis is always an imaginary unit with square equal to $-1 + 0i + 0j + 0k$.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 1, 1, 1)
+        >>> q.axis()
+        0 + sqrt(3)/3*i + sqrt(3)/3*j + sqrt(3)/3*k
+
+        See Also
+        ========
+
+        vector_part
+
+        """
+        axis = self.vector_part().normalize()
+
+        return Quaternion(0, axis.b, axis.c, axis.d)
+
+    def is_pure(self):
+        """
+        Returns true if the quaternion is pure, false if the quaternion is not pure
+        or returns none if it is unknown.
+
+        Explanation
+        ===========
+
+        A pure quaternion (also a vector quaternion) is a quaternion with scalar
+        part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 8, 13, 12)
+        >>> q.is_pure()
+        True
+
+        See Also
+        ========
+        scalar_part
+
+        """
+
+        return self.a.is_zero
+
+    def is_zero_quaternion(self):
+        """
+        Returns true if the quaternion is a zero quaternion or false if it is not a zero quaternion
+        and None if the value is unknown.
+
+        Explanation
+        ===========
+
+        A zero quaternion is a quaternion with both scalar part and
+        vector part equal to 0.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        False
+
+        >>> q = Quaternion(0, 0, 0, 0)
+        >>> q.is_zero_quaternion()
+        True
+
+        See Also
+        ========
+        scalar_part
+        vector_part
+
+        """
+
+        return self.norm().is_zero
+
+    def angle(self):
+        r"""
+        Returns the angle of the quaternion measured in the real-axis plane.
+
+        Explanation
+        ===========
+
+        Given a quaternion $q = a + bi + cj + dk$ where $a$, $b$, $c$ and $d$
+        are real numbers, returns the angle of the quaternion given by
+
+        .. math::
+            \theta := 2 \operatorname{atan_2}\left(\sqrt{b^2 + c^2 + d^2}, {a}\right)
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(1, 4, 4, 4)
+        >>> q.angle()
+        2*atan(4*sqrt(3))
+
+        """
+
+        return 2 * atan2(self.vector_part().norm(), self.scalar_part())
+
+
+    def arc_coplanar(self, other):
+        """
+        Returns True if the transformation arcs represented by the input quaternions happen in the same plane.
+
+        Explanation
+        ===========
+
+        Two quaternions are said to be coplanar (in this arc sense) when their axes are parallel.
+        The plane of a quaternion is the one normal to its axis.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the planes of the two quaternions are the same, apart from its orientation/sign.
+        False : if the planes of the two quaternions are not the same, apart from its orientation/sign.
+        None : if plane of either of the quaternion is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(1, 4, 4, 4)
+        >>> q2 = Quaternion(3, 8, 8, 8)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        True
+
+        >>> q1 = Quaternion(2, 8, 13, 12)
+        >>> Quaternion.arc_coplanar(q1, q2)
+        False
+
+        See Also
+        ========
+
+        vector_coplanar
+        is_pure
+
+        """
+        if (self.is_zero_quaternion()) or (other.is_zero_quaternion()):
+            raise ValueError('Neither of the given quaternions can be 0')
+
+        return fuzzy_or([(self.axis() - other.axis()).is_zero_quaternion(), (self.axis() + other.axis()).is_zero_quaternion()])
+
+    @classmethod
+    def vector_coplanar(cls, q1, q2, q3):
+        r"""
+        Returns True if the axis of the pure quaternions seen as 3D vectors
+        ``q1``, ``q2``, and ``q3`` are coplanar.
+
+        Explanation
+        ===========
+
+        Three pure quaternions are vector coplanar if the quaternions seen as 3D vectors are coplanar.
+
+        Parameters
+        ==========
+
+        q1
+            A pure Quaternion.
+        q2
+            A pure Quaternion.
+        q3
+            A pure Quaternion.
+
+        Returns
+        =======
+
+        True : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar.
+        False : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are not coplanar.
+        None : if the axis of the pure quaternions seen as 3D vectors
+        q1, q2, and q3 are coplanar is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q1 = Quaternion(0, 4, 4, 4)
+        >>> q2 = Quaternion(0, 8, 8, 8)
+        >>> q3 = Quaternion(0, 24, 24, 24)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        True
+
+        >>> q1 = Quaternion(0, 8, 16, 8)
+        >>> q2 = Quaternion(0, 8, 3, 12)
+        >>> Quaternion.vector_coplanar(q1, q2, q3)
+        False
+
+        See Also
+        ========
+
+        axis
+        is_pure
+
+        """
+
+        if fuzzy_not(q1.is_pure()) or fuzzy_not(q2.is_pure()) or fuzzy_not(q3.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        M = Matrix([[q1.b, q1.c, q1.d], [q2.b, q2.c, q2.d], [q3.b, q3.c, q3.d]]).det()
+        return M.is_zero
+
+    def parallel(self, other):
+        """
+        Returns True if the two pure quaternions seen as 3D vectors are parallel.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called parallel when their vector product is commutative which
+        implies that the quaternions seen as 3D vectors have same direction.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are parallel.
+        False : if the two pure quaternions seen as 3D vectors are not parallel.
+        None : if the two pure quaternions seen as 3D vectors are parallel is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.parallel(q1)
+        True
+
+        >>> q1 = Quaternion(0, 8, 13, 12)
+        >>> q.parallel(q1)
+        False
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The provided quaternions must be pure')
+
+        return (self*other - other*self).is_zero_quaternion()
+
+    def orthogonal(self, other):
+        """
+        Returns the orthogonality of two quaternions.
+
+        Explanation
+        ===========
+
+        Two pure quaternions are called orthogonal when their product is anti-commutative.
+
+        Parameters
+        ==========
+
+        other : a Quaternion
+
+        Returns
+        =======
+
+        True : if the two pure quaternions seen as 3D vectors are orthogonal.
+        False : if the two pure quaternions seen as 3D vectors are not orthogonal.
+        None : if the two pure quaternions seen as 3D vectors are orthogonal is unknown.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(0, 4, 4, 4)
+        >>> q1 = Quaternion(0, 8, 8, 8)
+        >>> q.orthogonal(q1)
+        False
+
+        >>> q1 = Quaternion(0, 2, 2, 0)
+        >>> q = Quaternion(0, 2, -2, 0)
+        >>> q.orthogonal(q1)
+        True
+
+        """
+
+        if fuzzy_not(self.is_pure()) or fuzzy_not(other.is_pure()):
+            raise ValueError('The given quaternions must be pure')
+
+        return (self*other + other*self).is_zero_quaternion()
+
+    def index_vector(self):
+        r"""
+        Returns the index vector of the quaternion.
+
+        Explanation
+        ===========
+
+        The index vector is given by $\mathbf{T}(q)$, the norm (or magnitude) of
+        the quaternion $q$, multiplied by $\mathbf{Ax}(q)$, the axis of $q$.
+
+        Returns
+        =======
+
+        Quaternion: representing index vector of the provided quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.index_vector()
+        0 + 4*sqrt(10)/3*i + 2*sqrt(10)/3*j + 4*sqrt(10)/3*k
+
+        See Also
+        ========
+
+        axis
+        norm
+
+        """
+
+        return self.norm() * self.axis()
+
+    def mensor(self):
+        """
+        Returns the natural logarithm of the norm(magnitude) of the quaternion.
+
+        Examples
+        ========
+
+        >>> from sympy.algebras.quaternion import Quaternion
+        >>> q = Quaternion(2, 4, 2, 4)
+        >>> q.mensor()
+        log(2*sqrt(10))
+        >>> q.norm()
+        2*sqrt(10)
+
+        See Also
+        ========
+
+        norm
+
+        """
+
+        return ln(self.norm())
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd1e7237c724d9ba89100cee34dc50327ca64d2d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/test_quaternion.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/test_quaternion.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fd9a4a45efe4ac9cb8f0d8ecfc0114fb75f6408
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/__pycache__/test_quaternion.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/algebras/tests/test_quaternion.py b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/test_quaternion.py
new file mode 100644
index 0000000000000000000000000000000000000000..a4331cd6afa05c96e8e11d59df4b7520e4810930
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/algebras/tests/test_quaternion.py
@@ -0,0 +1,437 @@
+from sympy.testing.pytest import slow
+from sympy.core.function import diff
+from sympy.core.function import expand
+from sympy.core.numbers import (E, I, Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, cos, sin, atan2, atan)
+from sympy.integrals.integrals import integrate
+from sympy.matrices.dense import Matrix
+from sympy.simplify import simplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.algebras.quaternion import Quaternion
+from sympy.testing.pytest import raises
+import math
+from itertools import permutations, product
+
+w, x, y, z = symbols('w:z')
+phi = symbols('phi')
+
+def test_quaternion_construction():
+    q = Quaternion(w, x, y, z)
+    assert q + q == Quaternion(2*w, 2*x, 2*y, 2*z)
+
+    q2 = Quaternion.from_axis_angle((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3),
+                                    pi*Rational(2, 3))
+    assert q2 == Quaternion(S.Half, S.Half,
+                            S.Half, S.Half)
+
+    M = Matrix([[cos(phi), -sin(phi), 0], [sin(phi), cos(phi), 0], [0, 0, 1]])
+    q3 = trigsimp(Quaternion.from_rotation_matrix(M))
+    assert q3 == Quaternion(
+        sqrt(2)*sqrt(cos(phi) + 1)/2, 0, 0, sqrt(2 - 2*cos(phi))*sign(sin(phi))/2)
+
+    nc = Symbol('nc', commutative=False)
+    raises(ValueError, lambda: Quaternion(w, x, nc, z))
+
+
+def test_quaternion_construction_norm():
+    q1 = Quaternion(*symbols('a:d'))
+
+    q2 = Quaternion(w, x, y, z)
+    assert expand((q1*q2).norm()**2 - (q1.norm()**2 * q2.norm()**2)) == 0
+
+    q3 = Quaternion(w, x, y, z, norm=1)
+    assert (q1 * q3).norm() == q1.norm()
+
+
+def test_issue_25254():
+    # calculating the inverse cached the norm which caused problems
+    # when multiplying
+    p = Quaternion(1, 0, 0, 0)
+    q = Quaternion.from_axis_angle((1, 1, 1), 3 * math.pi/4)
+    qi = q.inverse()  # this operation cached the norm
+    test = q * p * qi
+    assert ((test - p).norm() < 1E-10)
+
+
+def test_to_and_from_Matrix():
+    q = Quaternion(w, x, y, z)
+    q_full = Quaternion.from_Matrix(q.to_Matrix())
+    q_vect = Quaternion.from_Matrix(q.to_Matrix(True))
+    assert (q - q_full).is_zero_quaternion()
+    assert (q.vector_part() - q_vect).is_zero_quaternion()
+
+
+def test_product_matrices():
+    q1 = Quaternion(w, x, y, z)
+    q2 = Quaternion(*(symbols("a:d")))
+    assert (q1 * q2).to_Matrix() == q1.product_matrix_left * q2.to_Matrix()
+    assert (q1 * q2).to_Matrix() == q2.product_matrix_right * q1.to_Matrix()
+
+    R1 = (q1.product_matrix_left * q1.product_matrix_right.T)[1:, 1:]
+    R2 = simplify(q1.to_rotation_matrix()*q1.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_axis_angle():
+
+    test_data = [ # axis, angle, expected_quaternion
+        ((1, 0, 0), 0, (1, 0, 0, 0)),
+        ((1, 0, 0), pi/2, (sqrt(2)/2, sqrt(2)/2, 0, 0)),
+        ((0, 1, 0), pi/2, (sqrt(2)/2, 0, sqrt(2)/2, 0)),
+        ((0, 0, 1), pi/2, (sqrt(2)/2, 0, 0, sqrt(2)/2)),
+        ((1, 0, 0), pi, (0, 1, 0, 0)),
+        ((0, 1, 0), pi, (0, 0, 1, 0)),
+        ((0, 0, 1), pi, (0, 0, 0, 1)),
+        ((1, 1, 1), pi, (0, 1/sqrt(3),1/sqrt(3),1/sqrt(3))),
+        ((sqrt(3)/3, sqrt(3)/3, sqrt(3)/3), pi*2/3, (S.Half, S.Half, S.Half, S.Half))
+    ]
+
+    for axis, angle, expected in test_data:
+        assert Quaternion.from_axis_angle(axis, angle) == Quaternion(*expected)
+
+
+def test_quaternion_axis_angle_simplification():
+    result = Quaternion.from_axis_angle((1, 2, 3), asin(4))
+    assert result.a == cos(asin(4)/2)
+    assert result.b == sqrt(14)*sin(asin(4)/2)/14
+    assert result.c == sqrt(14)*sin(asin(4)/2)/7
+    assert result.d == 3*sqrt(14)*sin(asin(4)/2)/14
+
+def test_quaternion_complex_real_addition():
+    a = symbols("a", complex=True)
+    b = symbols("b", real=True)
+    # This symbol is not complex:
+    c = symbols("c", commutative=False)
+
+    q = Quaternion(w, x, y, z)
+    assert a + q == Quaternion(w + re(a), x + im(a), y, z)
+    assert 1 + q == Quaternion(1 + w, x, y, z)
+    assert I + q == Quaternion(w, 1 + x, y, z)
+    assert b + q == Quaternion(w + b, x, y, z)
+    raises(ValueError, lambda: c + q)
+    raises(ValueError, lambda: q * c)
+    raises(ValueError, lambda: c * q)
+
+    assert -q == Quaternion(-w, -x, -y, -z)
+
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 4, 7, 8)
+
+    assert q1 + (2 + 3*I) == Quaternion(5 + 7*I, 2 + 5*I, 0, 7 + 8*I)
+    assert q2 + (2 + 3*I) == Quaternion(3, 7, 7, 8)
+    assert q1 * (2 + 3*I) == \
+    Quaternion((2 + 3*I)*(3 + 4*I), (2 + 3*I)*(2 + 5*I), 0, (2 + 3*I)*(7 + 8*I))
+    assert q2 * (2 + 3*I) == Quaternion(-10, 11, 38, -5)
+
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+    assert q1 + q0 == q1
+    assert q1 - q0 == q1
+    assert q1 - q1 == q0
+
+
+def test_quaternion_subs():
+    q = Quaternion.from_axis_angle((0, 0, 1), phi)
+    assert q.subs(phi, 0) == Quaternion(1, 0, 0, 0)
+
+
+def test_quaternion_evalf():
+    assert (Quaternion(sqrt(2), 0, 0, sqrt(3)).evalf() ==
+            Quaternion(sqrt(2).evalf(), 0, 0, sqrt(3).evalf()))
+    assert (Quaternion(1/sqrt(2), 0, 0, 1/sqrt(2)).evalf() ==
+            Quaternion((1/sqrt(2)).evalf(), 0, 0, (1/sqrt(2)).evalf()))
+
+
+def test_quaternion_functions():
+    q = Quaternion(w, x, y, z)
+    q1 = Quaternion(1, 2, 3, 4)
+    q0 = Quaternion(0, 0, 0, 0)
+
+    assert conjugate(q) == Quaternion(w, -x, -y, -z)
+    assert q.norm() == sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.normalize() == Quaternion(w, x, y, z) / sqrt(w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == Quaternion(w, -x, -y, -z) / (w**2 + x**2 + y**2 + z**2)
+    assert q.inverse() == q.pow(-1)
+    raises(ValueError, lambda: q0.inverse())
+    assert q.pow(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q**(2) == Quaternion(w**2 - x**2 - y**2 - z**2, 2*w*x, 2*w*y, 2*w*z)
+    assert q1.pow(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1**(-2) == Quaternion(
+        Rational(-7, 225), Rational(-1, 225), Rational(-1, 150), Rational(-2, 225))
+    assert q1.pow(-0.5) == NotImplemented
+    raises(TypeError, lambda: q1**(-0.5))
+
+    assert q1.exp() == \
+    Quaternion(E * cos(sqrt(29)),
+               2 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               3 * sqrt(29) * E * sin(sqrt(29)) / 29,
+               4 * sqrt(29) * E * sin(sqrt(29)) / 29)
+    assert q1.log() == \
+    Quaternion(log(sqrt(30)),
+               2 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               3 * sqrt(29) * acos(sqrt(30)/30) / 29,
+               4 * sqrt(29) * acos(sqrt(30)/30) / 29)
+
+    assert q1.pow_cos_sin(2) == \
+    Quaternion(30 * cos(2 * acos(sqrt(30)/30)),
+               60 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               90 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29,
+               120 * sqrt(29) * sin(2 * acos(sqrt(30)/30)) / 29)
+
+    assert diff(Quaternion(x, x, x, x), x) == Quaternion(1, 1, 1, 1)
+
+    assert integrate(Quaternion(x, x, x, x), x) == \
+    Quaternion(x**2 / 2, x**2 / 2, x**2 / 2, x**2 / 2)
+
+    assert Quaternion(1, x, x**2, x**3).integrate(x) == \
+    Quaternion(x, x**2/2, x**3/3, x**4/4)
+
+    assert Quaternion(sin(x), cos(x), sin(2*x), cos(2*x)).integrate(x) == \
+    Quaternion(-cos(x), sin(x), -cos(2*x)/2, sin(2*x)/2)
+
+    assert Quaternion(x**2, y**2, z**2, x*y*z).integrate(x, y) == \
+    Quaternion(x**3*y/3, x*y**3/3, x*y*z**2, x**2*y**2*z/4)
+
+    assert Quaternion.rotate_point((1, 1, 1), q1) == (S.One / 5, 1, S(7) / 5)
+    n = Symbol('n')
+    raises(TypeError, lambda: q1**n)
+    n = Symbol('n', integer=True)
+    raises(TypeError, lambda: q1**n)
+
+    assert Quaternion(22, 23, 55, 8).scalar_part() == 22
+    assert Quaternion(w, x, y, z).scalar_part() == w
+
+    assert Quaternion(22, 23, 55, 8).vector_part() == Quaternion(0, 23, 55, 8)
+    assert Quaternion(w, x, y, z).vector_part() == Quaternion(0, x, y, z)
+
+    assert q1.axis() == Quaternion(0, 2*sqrt(29)/29, 3*sqrt(29)/29, 4*sqrt(29)/29)
+    assert q1.axis().pow(2) == Quaternion(-1, 0, 0, 0)
+    assert q0.axis().scalar_part() == 0
+    assert (q.axis() == Quaternion(0,
+                                   x/sqrt(x**2 + y**2 + z**2),
+                                   y/sqrt(x**2 + y**2 + z**2),
+                                   z/sqrt(x**2 + y**2 + z**2)))
+
+    assert q0.is_pure() is True
+    assert q1.is_pure() is False
+    assert Quaternion(0, 0, 0, 3).is_pure() is True
+    assert Quaternion(0, 2, 10, 3).is_pure() is True
+    assert Quaternion(w, 2, 10, 3).is_pure() is None
+
+    assert q1.angle() == 2*atan(sqrt(29))
+    assert q.angle() == 2*atan2(sqrt(x**2 + y**2 + z**2), w)
+
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, -2, -3, -4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 8, 12, 16)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(1, 2, 3, 4)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, 4, 6, 8)) is True
+    assert Quaternion.arc_coplanar(q1, Quaternion(2, 7, 4, 1)) is False
+    assert Quaternion.arc_coplanar(q1, Quaternion(w, x, y, z)) is None
+    raises(ValueError, lambda: Quaternion.arc_coplanar(q1, q0))
+
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 12, 16),
+        Quaternion(0, 4, 6, 8),
+        Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 0, 0, 0), Quaternion(0, 4, 6, 8), Quaternion(0, 2, 3, 4)) is True
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 8, 2, 6), Quaternion(0, 1, 6, 6), Quaternion(0, 0, 3, 4)) is False
+    assert Quaternion.vector_coplanar(
+        Quaternion(0, 1, 3, 4),
+        Quaternion(0, 4, w, 6),
+        Quaternion(0, 6, 8, 1)) is None
+    raises(ValueError, lambda:
+        Quaternion.vector_coplanar(q0, Quaternion(0, 4, 6, 8), q1))
+
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 4, 6)) is True
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 1, 2, 3).parallel(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.parallel(q1))
+
+    assert Quaternion(0, 1, 2, 3).orthogonal(Quaternion(0, -2, 1, 0)) is True
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(0, 2, 2, 6)) is False
+    assert Quaternion(0, 2, 4, 7).orthogonal(Quaternion(w, x, y, 6)) is None
+    raises(ValueError, lambda: q0.orthogonal(q1))
+
+    assert q1.index_vector() == Quaternion(
+        0, 2*sqrt(870)/29,
+        3*sqrt(870)/29,
+        4*sqrt(870)/29)
+    assert Quaternion(0, 3, 9, 4).index_vector() == Quaternion(0, 3, 9, 4)
+
+    assert Quaternion(4, 3, 9, 4).mensor() == log(sqrt(122))
+    assert Quaternion(3, 3, 0, 2).mensor() == log(sqrt(22))
+
+    assert q0.is_zero_quaternion() is True
+    assert q1.is_zero_quaternion() is False
+    assert Quaternion(w, 0, 0, 0).is_zero_quaternion() is None
+
+def test_quaternion_conversions():
+    q1 = Quaternion(1, 2, 3, 4)
+
+    assert q1.to_axis_angle() == ((2 * sqrt(29)/29,
+                                   3 * sqrt(29)/29,
+                                   4 * sqrt(29)/29),
+                                   2 * acos(sqrt(30)/30))
+
+    assert (q1.to_rotation_matrix() ==
+            Matrix([[Rational(-2, 3), Rational(2, 15), Rational(11, 15)],
+                    [Rational(2, 3), Rational(-1, 3), Rational(2, 3)],
+                    [Rational(1, 3), Rational(14, 15), Rational(2, 15)]]))
+
+    assert (q1.to_rotation_matrix((1, 1, 1)) ==
+            Matrix([
+                [Rational(-2, 3), Rational(2, 15), Rational(11, 15), Rational(4, 5)],
+                [Rational(2, 3), Rational(-1, 3), Rational(2, 3), S.Zero],
+                [Rational(1, 3), Rational(14, 15), Rational(2, 15), Rational(-2, 5)],
+                [S.Zero, S.Zero, S.Zero, S.One]]))
+
+    theta = symbols("theta", real=True)
+    q2 = Quaternion(cos(theta/2), 0, 0, sin(theta/2))
+
+    assert trigsimp(q2.to_rotation_matrix()) == Matrix([
+                                               [cos(theta), -sin(theta), 0],
+                                               [sin(theta),  cos(theta), 0],
+                                               [0,           0,          1]])
+
+    assert q2.to_axis_angle() == ((0, 0, sin(theta/2)/Abs(sin(theta/2))),
+                                   2*acos(cos(theta/2)))
+
+    assert trigsimp(q2.to_rotation_matrix((1, 1, 1))) == Matrix([
+               [cos(theta), -sin(theta), 0, sin(theta) - cos(theta) + 1],
+               [sin(theta),  cos(theta), 0, -sin(theta) - cos(theta) + 1],
+               [0,           0,          1,  0],
+               [0,           0,          0,  1]])
+
+
+def test_rotation_matrix_homogeneous():
+    q = Quaternion(w, x, y, z)
+    R1 = q.to_rotation_matrix(homogeneous=True) * q.norm()**2
+    R2 = simplify(q.to_rotation_matrix(homogeneous=False) * q.norm()**2)
+    assert R1 == R2
+
+
+def test_quaternion_rotation_iss1593():
+    """
+    There was a sign mistake in the definition,
+    of the rotation matrix. This tests that particular sign mistake.
+    See issue 1593 for reference.
+    See wikipedia
+    https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Quaternion-derived_rotation_matrix
+    for the correct definition
+    """
+    q = Quaternion(cos(phi/2), sin(phi/2), 0, 0)
+    assert(trigsimp(q.to_rotation_matrix()) == Matrix([
+                [1,        0,         0],
+                [0, cos(phi), -sin(phi)],
+                [0, sin(phi),  cos(phi)]]))
+
+
+def test_quaternion_multiplication():
+    q1 = Quaternion(3 + 4*I, 2 + 5*I, 0, 7 + 8*I, real_field = False)
+    q2 = Quaternion(1, 2, 3, 5)
+    q3 = Quaternion(1, 1, 1, y)
+
+    assert Quaternion._generic_mul(S(4), S.One) == 4
+    assert (Quaternion._generic_mul(S(4), q1) ==
+            Quaternion(12 + 16*I, 8 + 20*I, 0, 28 + 32*I))
+    assert q2.mul(2) == Quaternion(2, 4, 6, 10)
+    assert q2.mul(q3) == Quaternion(-5*y - 4, 3*y - 2, 9 - 2*y, y + 4)
+    assert q2.mul(q3) == q2*q3
+
+    z = symbols('z', complex=True)
+    z_quat = Quaternion(re(z), im(z), 0, 0)
+    q = Quaternion(*symbols('q:4', real=True))
+
+    assert z * q == z_quat * q
+    assert q * z == q * z_quat
+
+
+def test_issue_16318():
+    #for rtruediv
+    q0 = Quaternion(0, 0, 0, 0)
+    raises(ValueError, lambda: 1/q0)
+    #for rotate_point
+    q = Quaternion(1, 2, 3, 4)
+    (axis, angle) = q.to_axis_angle()
+    assert Quaternion.rotate_point((1, 1, 1), (axis, angle)) == (S.One / 5, 1, S(7) / 5)
+    #test for to_axis_angle
+    q = Quaternion(-1, 1, 1, 1)
+    axis = (-sqrt(3)/3, -sqrt(3)/3, -sqrt(3)/3)
+    angle = 2*pi/3
+    assert (axis, angle) == q.to_axis_angle()
+
+
+@slow
+def test_to_euler():
+    q = Quaternion(w, x, y, z)
+    q_normalized = q.normalize()
+
+    seqs = ['zxy', 'zyx', 'zyz', 'zxz']
+    seqs += [seq.upper() for seq in seqs]
+
+    for seq in seqs:
+        euler_from_q = q.to_euler(seq)
+        q_back = simplify(Quaternion.from_euler(euler_from_q, seq))
+        assert q_back == q_normalized
+
+
+def test_to_euler_iss24504():
+    """
+    There was a mistake in the degenerate case testing
+    See issue 24504 for reference.
+    """
+    q = Quaternion.from_euler((phi, 0, 0), 'zyz')
+    assert trigsimp(q.to_euler('zyz'), inverse=True) == (phi, 0, 0)
+
+
+def test_to_euler_numerical_singilarities():
+
+    def test_one_case(angles, seq):
+        q = Quaternion.from_euler(angles, seq)
+        assert q.to_euler(seq) == angles
+
+    # symmetric
+    test_one_case((pi/2,  0, 0), 'zyz')
+    test_one_case((pi/2,  0, 0), 'ZYZ')
+    test_one_case((pi/2,  pi, 0), 'zyz')
+    test_one_case((pi/2,  pi, 0), 'ZYZ')
+
+    # asymmetric
+    test_one_case((pi/2,  pi/2, 0), 'zyx')
+    test_one_case((pi/2,  -pi/2, 0), 'zyx')
+    test_one_case((pi/2,  pi/2, 0), 'ZYX')
+    test_one_case((pi/2,  -pi/2, 0), 'ZYX')
+
+
+@slow
+def test_to_euler_options():
+    def test_one_case(q):
+        angles1 = Matrix(q.to_euler(seq, True, True))
+        angles2 = Matrix(q.to_euler(seq, False, False))
+        angle_errors = simplify(angles1-angles2).evalf()
+        for angle_error in angle_errors:
+            # forcing angles to set {-pi, pi}
+            angle_error = (angle_error + pi) % (2 * pi) - pi
+            assert angle_error < 10e-7
+
+    for xyz in ('xyz', 'XYZ'):
+        for seq_tuple in permutations(xyz):
+            for symmetric in (True, False):
+                if symmetric:
+                    seq = ''.join([seq_tuple[0], seq_tuple[1], seq_tuple[0]])
+                else:
+                    seq = ''.join(seq_tuple)
+
+                for elements in product([-1, 0, 1], repeat=4):
+                    q = Quaternion(*elements)
+                    if not q.is_zero_quaternion():
+                        test_one_case(q)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__init__.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..af862653f3ce0eeb67f7764e16c32f3466e87024
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/__init__.py
@@ -0,0 +1,18 @@
+"""
+A module to implement logical predicates and assumption system.
+"""
+
+from .assume import (
+    AppliedPredicate, Predicate, AssumptionsContext, assuming,
+    global_assumptions
+)
+from .ask import Q, ask, register_handler, remove_handler
+from .refine import refine
+from .relation import BinaryRelation, AppliedBinaryRelation
+
+__all__ = [
+    'AppliedPredicate', 'Predicate', 'AssumptionsContext', 'assuming',
+    'global_assumptions', 'Q', 'ask', 'register_handler', 'remove_handler',
+    'refine',
+    'BinaryRelation', 'AppliedBinaryRelation'
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8e4e6c4d031ca483d00d85677201f06ab861714
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..383604eca721f58b8842408444af555792ff2c5b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask_generated.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask_generated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e3961c7ba1ab3447ca1d33d642c4e284f4359f2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/ask_generated.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/assume.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/assume.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4af9056386460f822b3dab13affa284f53896cb5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/assume.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/cnf.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/cnf.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c381363113a69a54e22760da523c71a6945c0f3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/cnf.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/facts.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/facts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb2fd70cfa1d4bacaf869ae69ed5cee7c7bddb51
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/facts.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/lra_satask.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/lra_satask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..33e36c7207d967368e6d53f45f994ccf8e96bc27
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/lra_satask.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/refine.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/refine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b94931930db4ea9c8c5870398329f796f51495d6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/refine.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/satask.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/satask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df1095d667a4ae157938a9eec828e29d63d635b7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/satask.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/sathandlers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/sathandlers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbdcac163ec516070adf8d275541e185b6d932df
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/sathandlers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/wrapper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/wrapper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5188052323d8ae5649998235bbdfc15f93c4cc1c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/__pycache__/wrapper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/ask.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/ask.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec81ec8ecce245c2a798cf9e71af1e9373292bc1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/ask.py
@@ -0,0 +1,651 @@
+"""Module for querying SymPy objects about assumptions."""
+
+from sympy.assumptions.assume import (global_assumptions, Predicate,
+        AppliedPredicate)
+from sympy.assumptions.cnf import CNF, EncodedCNF, Literal
+from sympy.core import sympify
+from sympy.core.kind import BooleanKind
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.logic.inference import satisfiable
+from sympy.utilities.decorator import memoize_property
+from sympy.utilities.exceptions import (sympy_deprecation_warning,
+                                        SymPyDeprecationWarning,
+                                        ignore_warnings)
+
+
+# Memoization is necessary for the properties of AssumptionKeys to
+# ensure that only one object of Predicate objects are created.
+# This is because assumption handlers are registered on those objects.
+
+
+class AssumptionKeys:
+    """
+    This class contains all the supported keys by ``ask``.
+    It should be accessed via the instance ``sympy.Q``.
+
+    """
+
+    # DO NOT add methods or properties other than predicate keys.
+    # SAT solver checks the properties of Q and use them to compute the
+    # fact system. Non-predicate attributes will break this.
+
+    @memoize_property
+    def hermitian(self):
+        from .handlers.sets import HermitianPredicate
+        return HermitianPredicate()
+
+    @memoize_property
+    def antihermitian(self):
+        from .handlers.sets import AntihermitianPredicate
+        return AntihermitianPredicate()
+
+    @memoize_property
+    def real(self):
+        from .handlers.sets import RealPredicate
+        return RealPredicate()
+
+    @memoize_property
+    def extended_real(self):
+        from .handlers.sets import ExtendedRealPredicate
+        return ExtendedRealPredicate()
+
+    @memoize_property
+    def imaginary(self):
+        from .handlers.sets import ImaginaryPredicate
+        return ImaginaryPredicate()
+
+    @memoize_property
+    def complex(self):
+        from .handlers.sets import ComplexPredicate
+        return ComplexPredicate()
+
+    @memoize_property
+    def algebraic(self):
+        from .handlers.sets import AlgebraicPredicate
+        return AlgebraicPredicate()
+
+    @memoize_property
+    def transcendental(self):
+        from .predicates.sets import TranscendentalPredicate
+        return TranscendentalPredicate()
+
+    @memoize_property
+    def integer(self):
+        from .handlers.sets import IntegerPredicate
+        return IntegerPredicate()
+
+    @memoize_property
+    def noninteger(self):
+        from .predicates.sets import NonIntegerPredicate
+        return NonIntegerPredicate()
+
+    @memoize_property
+    def rational(self):
+        from .handlers.sets import RationalPredicate
+        return RationalPredicate()
+
+    @memoize_property
+    def irrational(self):
+        from .handlers.sets import IrrationalPredicate
+        return IrrationalPredicate()
+
+    @memoize_property
+    def finite(self):
+        from .handlers.calculus import FinitePredicate
+        return FinitePredicate()
+
+    @memoize_property
+    def infinite(self):
+        from .handlers.calculus import InfinitePredicate
+        return InfinitePredicate()
+
+    @memoize_property
+    def positive_infinite(self):
+        from .handlers.calculus import PositiveInfinitePredicate
+        return PositiveInfinitePredicate()
+
+    @memoize_property
+    def negative_infinite(self):
+        from .handlers.calculus import NegativeInfinitePredicate
+        return NegativeInfinitePredicate()
+
+    @memoize_property
+    def positive(self):
+        from .handlers.order import PositivePredicate
+        return PositivePredicate()
+
+    @memoize_property
+    def negative(self):
+        from .handlers.order import NegativePredicate
+        return NegativePredicate()
+
+    @memoize_property
+    def zero(self):
+        from .handlers.order import ZeroPredicate
+        return ZeroPredicate()
+
+    @memoize_property
+    def extended_positive(self):
+        from .handlers.order import ExtendedPositivePredicate
+        return ExtendedPositivePredicate()
+
+    @memoize_property
+    def extended_negative(self):
+        from .handlers.order import ExtendedNegativePredicate
+        return ExtendedNegativePredicate()
+
+    @memoize_property
+    def nonzero(self):
+        from .handlers.order import NonZeroPredicate
+        return NonZeroPredicate()
+
+    @memoize_property
+    def nonpositive(self):
+        from .handlers.order import NonPositivePredicate
+        return NonPositivePredicate()
+
+    @memoize_property
+    def nonnegative(self):
+        from .handlers.order import NonNegativePredicate
+        return NonNegativePredicate()
+
+    @memoize_property
+    def extended_nonzero(self):
+        from .handlers.order import ExtendedNonZeroPredicate
+        return ExtendedNonZeroPredicate()
+
+    @memoize_property
+    def extended_nonpositive(self):
+        from .handlers.order import ExtendedNonPositivePredicate
+        return ExtendedNonPositivePredicate()
+
+    @memoize_property
+    def extended_nonnegative(self):
+        from .handlers.order import ExtendedNonNegativePredicate
+        return ExtendedNonNegativePredicate()
+
+    @memoize_property
+    def even(self):
+        from .handlers.ntheory import EvenPredicate
+        return EvenPredicate()
+
+    @memoize_property
+    def odd(self):
+        from .handlers.ntheory import OddPredicate
+        return OddPredicate()
+
+    @memoize_property
+    def prime(self):
+        from .handlers.ntheory import PrimePredicate
+        return PrimePredicate()
+
+    @memoize_property
+    def composite(self):
+        from .handlers.ntheory import CompositePredicate
+        return CompositePredicate()
+
+    @memoize_property
+    def commutative(self):
+        from .handlers.common import CommutativePredicate
+        return CommutativePredicate()
+
+    @memoize_property
+    def is_true(self):
+        from .handlers.common import IsTruePredicate
+        return IsTruePredicate()
+
+    @memoize_property
+    def symmetric(self):
+        from .handlers.matrices import SymmetricPredicate
+        return SymmetricPredicate()
+
+    @memoize_property
+    def invertible(self):
+        from .handlers.matrices import InvertiblePredicate
+        return InvertiblePredicate()
+
+    @memoize_property
+    def orthogonal(self):
+        from .handlers.matrices import OrthogonalPredicate
+        return OrthogonalPredicate()
+
+    @memoize_property
+    def unitary(self):
+        from .handlers.matrices import UnitaryPredicate
+        return UnitaryPredicate()
+
+    @memoize_property
+    def positive_definite(self):
+        from .handlers.matrices import PositiveDefinitePredicate
+        return PositiveDefinitePredicate()
+
+    @memoize_property
+    def upper_triangular(self):
+        from .handlers.matrices import UpperTriangularPredicate
+        return UpperTriangularPredicate()
+
+    @memoize_property
+    def lower_triangular(self):
+        from .handlers.matrices import LowerTriangularPredicate
+        return LowerTriangularPredicate()
+
+    @memoize_property
+    def diagonal(self):
+        from .handlers.matrices import DiagonalPredicate
+        return DiagonalPredicate()
+
+    @memoize_property
+    def fullrank(self):
+        from .handlers.matrices import FullRankPredicate
+        return FullRankPredicate()
+
+    @memoize_property
+    def square(self):
+        from .handlers.matrices import SquarePredicate
+        return SquarePredicate()
+
+    @memoize_property
+    def integer_elements(self):
+        from .handlers.matrices import IntegerElementsPredicate
+        return IntegerElementsPredicate()
+
+    @memoize_property
+    def real_elements(self):
+        from .handlers.matrices import RealElementsPredicate
+        return RealElementsPredicate()
+
+    @memoize_property
+    def complex_elements(self):
+        from .handlers.matrices import ComplexElementsPredicate
+        return ComplexElementsPredicate()
+
+    @memoize_property
+    def singular(self):
+        from .predicates.matrices import SingularPredicate
+        return SingularPredicate()
+
+    @memoize_property
+    def normal(self):
+        from .predicates.matrices import NormalPredicate
+        return NormalPredicate()
+
+    @memoize_property
+    def triangular(self):
+        from .predicates.matrices import TriangularPredicate
+        return TriangularPredicate()
+
+    @memoize_property
+    def unit_triangular(self):
+        from .predicates.matrices import UnitTriangularPredicate
+        return UnitTriangularPredicate()
+
+    @memoize_property
+    def eq(self):
+        from .relation.equality import EqualityPredicate
+        return EqualityPredicate()
+
+    @memoize_property
+    def ne(self):
+        from .relation.equality import UnequalityPredicate
+        return UnequalityPredicate()
+
+    @memoize_property
+    def gt(self):
+        from .relation.equality import StrictGreaterThanPredicate
+        return StrictGreaterThanPredicate()
+
+    @memoize_property
+    def ge(self):
+        from .relation.equality import GreaterThanPredicate
+        return GreaterThanPredicate()
+
+    @memoize_property
+    def lt(self):
+        from .relation.equality import StrictLessThanPredicate
+        return StrictLessThanPredicate()
+
+    @memoize_property
+    def le(self):
+        from .relation.equality import LessThanPredicate
+        return LessThanPredicate()
+
+
+Q = AssumptionKeys()
+
+def _extract_all_facts(assump, exprs):
+    """
+    Extract all relevant assumptions from *assump* with respect to given *exprs*.
+
+    Parameters
+    ==========
+
+    assump : sympy.assumptions.cnf.CNF
+
+    exprs : tuple of expressions
+
+    Returns
+    =======
+
+    sympy.assumptions.cnf.CNF
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.ask import _extract_all_facts
+    >>> from sympy.abc import x, y
+    >>> assump = CNF.from_prop(Q.positive(x) & Q.integer(y))
+    >>> exprs = (x,)
+    >>> cnf = _extract_all_facts(assump, exprs)
+    >>> cnf.clauses
+    {frozenset({Literal(Q.positive, False)})}
+
+    """
+    facts = set()
+
+    for clause in assump.clauses:
+        args = []
+        for literal in clause:
+            if isinstance(literal.lit, AppliedPredicate) and len(literal.lit.arguments) == 1:
+                if literal.lit.arg in exprs:
+                    # Add literal if it has matching in it
+                    args.append(Literal(literal.lit.function, literal.is_Not))
+                else:
+                    # If any of the literals doesn't have matching expr don't add the whole clause.
+                    break
+            else:
+                # If any of the literals aren't unary predicate don't add the whole clause.
+                break
+
+        else:
+            if args:
+                facts.add(frozenset(args))
+    return CNF(facts)
+
+
+def ask(proposition, assumptions=True, context=global_assumptions):
+    """
+    Function to evaluate the proposition with assumptions.
+
+    Explanation
+    ===========
+
+    This function evaluates the proposition to ``True`` or ``False`` if
+    the truth value can be determined. If not, it returns ``None``.
+
+    It should be discerned from :func:`~.refine` which, when applied to a
+    proposition, simplifies the argument to symbolic ``Boolean`` instead of
+    Python built-in ``True``, ``False`` or ``None``.
+
+    **Syntax**
+
+        * ask(proposition)
+            Evaluate the *proposition* in global assumption context.
+
+        * ask(proposition, assumptions)
+            Evaluate the *proposition* with respect to *assumptions* in
+            global assumption context.
+
+    Parameters
+    ==========
+
+    proposition : Boolean
+        Proposition which will be evaluated to boolean value. If this is
+        not ``AppliedPredicate``, it will be wrapped by ``Q.is_true``.
+
+    assumptions : Boolean, optional
+        Local assumptions to evaluate the *proposition*.
+
+    context : AssumptionsContext, optional
+        Default assumptions to evaluate the *proposition*. By default,
+        this is ``sympy.assumptions.global_assumptions`` variable.
+
+    Returns
+    =======
+
+    ``True``, ``False``, or ``None``
+
+    Raises
+    ======
+
+    TypeError : *proposition* or *assumptions* is not valid logical expression.
+
+    ValueError : assumptions are inconsistent.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi
+    >>> from sympy.abc import x, y
+    >>> ask(Q.rational(pi))
+    False
+    >>> ask(Q.even(x*y), Q.even(x) & Q.integer(y))
+    True
+    >>> ask(Q.prime(4*x), Q.integer(x))
+    False
+
+    If the truth value cannot be determined, ``None`` will be returned.
+
+    >>> print(ask(Q.odd(3*x))) # cannot determine unless we know x
+    None
+
+    ``ValueError`` is raised if assumptions are inconsistent.
+
+    >>> ask(Q.integer(x), Q.even(x) & Q.odd(x))
+    Traceback (most recent call last):
+      ...
+    ValueError: inconsistent assumptions Q.even(x) & Q.odd(x)
+
+    Notes
+    =====
+
+    Relations in assumptions are not implemented (yet), so the following
+    will not give a meaningful result.
+
+    >>> ask(Q.positive(x), x > 0)
+
+    It is however a work in progress.
+
+    See Also
+    ========
+
+    sympy.assumptions.refine.refine : Simplification using assumptions.
+        Proposition is not reduced to ``None`` if the truth value cannot
+        be determined.
+    """
+    from sympy.assumptions.satask import satask
+    from sympy.assumptions.lra_satask import lra_satask
+    from sympy.logic.algorithms.lra_theory import UnhandledInput
+
+    proposition = sympify(proposition)
+    assumptions = sympify(assumptions)
+
+    if isinstance(proposition, Predicate) or proposition.kind is not BooleanKind:
+        raise TypeError("proposition must be a valid logical expression")
+
+    if isinstance(assumptions, Predicate) or assumptions.kind is not BooleanKind:
+        raise TypeError("assumptions must be a valid logical expression")
+
+    binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+    if isinstance(proposition, AppliedPredicate):
+        key, args = proposition.function, proposition.arguments
+    elif proposition.func in binrelpreds:
+        key, args = binrelpreds[type(proposition)], proposition.args
+    else:
+        key, args = Q.is_true, (proposition,)
+
+    # convert local and global assumptions to CNF
+    assump_cnf = CNF.from_prop(assumptions)
+    assump_cnf.extend(context)
+
+    # extract the relevant facts from assumptions with respect to args
+    local_facts = _extract_all_facts(assump_cnf, args)
+
+    # convert default facts and assumed facts to encoded CNF
+    known_facts_cnf = get_all_known_facts()
+    enc_cnf = EncodedCNF()
+    enc_cnf.from_cnf(CNF(known_facts_cnf))
+    enc_cnf.add_from_cnf(local_facts)
+
+    # check the satisfiability of given assumptions
+    if local_facts.clauses and satisfiable(enc_cnf) is False:
+        raise ValueError("inconsistent assumptions %s" % assumptions)
+
+    # quick computation for single fact
+    res = _ask_single_fact(key, local_facts)
+    if res is not None:
+        return res
+
+    # direct resolution method, no logic
+    res = key(*args)._eval_ask(assumptions)
+    if res is not None:
+        return bool(res)
+
+    # using satask (still costly)
+    res = satask(proposition, assumptions=assumptions, context=context)
+    if res is not None:
+        return res
+
+    try:
+        res = lra_satask(proposition, assumptions=assumptions, context=context)
+    except UnhandledInput:
+        return None
+
+    return res
+
+
+def _ask_single_fact(key, local_facts):
+    """
+    Compute the truth value of single predicate using assumptions.
+
+    Parameters
+    ==========
+
+    key : sympy.assumptions.assume.Predicate
+        Proposition predicate.
+
+    local_facts : sympy.assumptions.cnf.CNF
+        Local assumption in CNF form.
+
+    Returns
+    =======
+
+    ``True``, ``False`` or ``None``
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.ask import _ask_single_fact
+
+    If prerequisite of proposition is rejected by the assumption,
+    return ``False``.
+
+    >>> key, assump = Q.zero, ~Q.zero
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+    >>> key, assump = Q.zero, ~Q.even
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+
+    If assumption implies the proposition, return ``True``.
+
+    >>> key, assump = Q.even, Q.zero
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    True
+
+    If proposition rejects the assumption, return ``False``.
+
+    >>> key, assump = Q.even, Q.odd
+    >>> local_facts = CNF.from_prop(assump)
+    >>> _ask_single_fact(key, local_facts)
+    False
+    """
+    if local_facts.clauses:
+
+        known_facts_dict = get_known_facts_dict()
+
+        if len(local_facts.clauses) == 1:
+            cl, = local_facts.clauses
+            if len(cl) == 1:
+                f, = cl
+                prop_facts = known_facts_dict.get(key, None)
+                prop_req = prop_facts[0] if prop_facts is not None else set()
+                if f.is_Not and f.arg in prop_req:
+                    # the prerequisite of proposition is rejected
+                    return False
+
+        for clause in local_facts.clauses:
+            if len(clause) == 1:
+                f, = clause
+                prop_facts = known_facts_dict.get(f.arg, None) if not f.is_Not else None
+                if prop_facts is None:
+                    continue
+
+                prop_req, prop_rej = prop_facts
+                if key in prop_req:
+                    # assumption implies the proposition
+                    return True
+                elif key in prop_rej:
+                    # proposition rejects the assumption
+                    return False
+
+    return None
+
+
+def register_handler(key, handler):
+    """
+    Register a handler in the ask system. key must be a string and handler a
+    class inheriting from AskHandler.
+
+    .. deprecated:: 1.8.
+        Use multipledispatch handler instead. See :obj:`~.Predicate`.
+
+    """
+    sympy_deprecation_warning(
+        """
+        The AskHandler system is deprecated. The register_handler() function
+        should be replaced with the multipledispatch handler of Predicate.
+        """,
+        deprecated_since_version="1.8",
+        active_deprecations_target='deprecated-askhandler',
+    )
+    if isinstance(key, Predicate):
+        key = key.name.name
+    Qkey = getattr(Q, key, None)
+    if Qkey is not None:
+        Qkey.add_handler(handler)
+    else:
+        setattr(Q, key, Predicate(key, handlers=[handler]))
+
+
+def remove_handler(key, handler):
+    """
+    Removes a handler from the ask system.
+
+    .. deprecated:: 1.8.
+        Use multipledispatch handler instead. See :obj:`~.Predicate`.
+
+    """
+    sympy_deprecation_warning(
+        """
+        The AskHandler system is deprecated. The remove_handler() function
+        should be replaced with the multipledispatch handler of Predicate.
+        """,
+        deprecated_since_version="1.8",
+        active_deprecations_target='deprecated-askhandler',
+    )
+    if isinstance(key, Predicate):
+        key = key.name.name
+    # Don't show the same warning again recursively
+    with ignore_warnings(SymPyDeprecationWarning):
+        getattr(Q, key).remove_handler(handler)
+
+
+from sympy.assumptions.ask_generated import (get_all_known_facts,
+    get_known_facts_dict)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/ask_generated.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/ask_generated.py
new file mode 100644
index 0000000000000000000000000000000000000000..d90cdffc1e127d78e18f70cda13d8d5e0530d41b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/ask_generated.py
@@ -0,0 +1,352 @@
+"""
+Do NOT manually edit this file.
+Instead, run ./bin/ask_update.py.
+"""
+
+from sympy.assumptions.ask import Q
+from sympy.assumptions.cnf import Literal
+from sympy.core.cache import cacheit
+
+@cacheit
+def get_all_known_facts():
+    """
+    Known facts between unary predicates as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.algebraic, False), Literal(Q.imaginary, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.negative, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.positive, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.rational, True))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.transcendental, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.finite, False))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.imaginary, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.finite, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.complex_elements, False), Literal(Q.real_elements, True))),
+        frozenset((Literal(Q.composite, False), Literal(Q.even, True), Literal(Q.positive, True), Literal(Q.prime, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.even, False), Literal(Q.odd, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.positive, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.prime, True))),
+        frozenset((Literal(Q.diagonal, False), Literal(Q.lower_triangular, True), Literal(Q.upper_triangular, True))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.lower_triangular, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.normal, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.symmetric, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.even, False), Literal(Q.odd, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.odd, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.finite, False), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.finite, True), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.fullrank, False), Literal(Q.invertible, True))),
+        frozenset((Literal(Q.fullrank, True), Literal(Q.invertible, False), Literal(Q.square, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.negative, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.positive, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.negative, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.integer_elements, True), Literal(Q.real_elements, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.positive_definite, True))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.singular, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.singular, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.negative, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.positive, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.rational, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.zero, False))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.rational, True))),
+        frozenset((Literal(Q.lower_triangular, False), Literal(Q.triangular, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.lower_triangular, True), Literal(Q.triangular, False))),
+        frozenset((Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.rational, True), Literal(Q.zero, False))),
+        frozenset((Literal(Q.negative, True), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.normal, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.normal, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.odd, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.orthogonal, False), Literal(Q.real_elements, True), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.positive_definite, False))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.unitary, False))),
+        frozenset((Literal(Q.positive, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.positive_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.square, False), Literal(Q.symmetric, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.unit_triangular, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.upper_triangular, True)))
+    }
+
+@cacheit
+def get_all_known_matrix_facts():
+    """
+    Known facts between unary predicates for matrices as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.complex_elements, False), Literal(Q.real_elements, True))),
+        frozenset((Literal(Q.diagonal, False), Literal(Q.lower_triangular, True), Literal(Q.upper_triangular, True))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.lower_triangular, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.normal, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.symmetric, False))),
+        frozenset((Literal(Q.diagonal, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.fullrank, False), Literal(Q.invertible, True))),
+        frozenset((Literal(Q.fullrank, True), Literal(Q.invertible, False), Literal(Q.square, True))),
+        frozenset((Literal(Q.integer_elements, True), Literal(Q.real_elements, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.positive_definite, True))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.singular, False))),
+        frozenset((Literal(Q.invertible, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.singular, True))),
+        frozenset((Literal(Q.invertible, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.lower_triangular, False), Literal(Q.triangular, True), Literal(Q.upper_triangular, False))),
+        frozenset((Literal(Q.lower_triangular, True), Literal(Q.triangular, False))),
+        frozenset((Literal(Q.normal, False), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.normal, True), Literal(Q.square, False))),
+        frozenset((Literal(Q.orthogonal, False), Literal(Q.real_elements, True), Literal(Q.unitary, True))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.positive_definite, False))),
+        frozenset((Literal(Q.orthogonal, True), Literal(Q.unitary, False))),
+        frozenset((Literal(Q.square, False), Literal(Q.symmetric, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.unit_triangular, True))),
+        frozenset((Literal(Q.triangular, False), Literal(Q.upper_triangular, True)))
+    }
+
+@cacheit
+def get_all_known_number_facts():
+    """
+    Known facts between unary predicates for numbers as CNF clauses.
+    """
+    return {
+        frozenset((Literal(Q.algebraic, False), Literal(Q.imaginary, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.negative, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.positive, True), Literal(Q.transcendental, False))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.rational, True))),
+        frozenset((Literal(Q.algebraic, False), Literal(Q.transcendental, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.finite, False))),
+        frozenset((Literal(Q.algebraic, True), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.antihermitian, False), Literal(Q.imaginary, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.finite, True))),
+        frozenset((Literal(Q.commutative, False), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.composite, False), Literal(Q.even, True), Literal(Q.positive, True), Literal(Q.prime, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.even, False), Literal(Q.odd, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.positive, False))),
+        frozenset((Literal(Q.composite, True), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.odd, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.even, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.odd, True))),
+        frozenset((Literal(Q.even, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.finite, False), Literal(Q.transcendental, True))),
+        frozenset((Literal(Q.finite, True), Literal(Q.infinite, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.negative, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.positive, True))),
+        frozenset((Literal(Q.hermitian, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.negative, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.imaginary, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.infinite, False), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.negative, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.positive, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.irrational, False), Literal(Q.rational, False), Literal(Q.zero, True))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.zero, False))),
+        frozenset((Literal(Q.irrational, True), Literal(Q.rational, True))),
+        frozenset((Literal(Q.negative, False), Literal(Q.positive, False), Literal(Q.rational, True), Literal(Q.zero, False))),
+        frozenset((Literal(Q.negative, True), Literal(Q.negative_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.negative_infinite, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.odd, True), Literal(Q.rational, False))),
+        frozenset((Literal(Q.positive, False), Literal(Q.prime, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.positive_infinite, True))),
+        frozenset((Literal(Q.positive, True), Literal(Q.zero, True))),
+        frozenset((Literal(Q.positive_infinite, True), Literal(Q.zero, True)))
+    }
+
+@cacheit
+def get_known_facts_dict():
+    """
+    Logical relations between unary predicates as dictionary.
+
+    Each key is a predicate, and item is two groups of predicates.
+    First group contains the predicates which are implied by the key, and
+    second group contains the predicates which are rejected by the key.
+
+    """
+    return {
+        Q.algebraic: (set([Q.algebraic, Q.commutative, Q.complex, Q.finite]),
+        set([Q.infinite, Q.negative_infinite, Q.positive_infinite,
+        Q.transcendental])),
+        Q.antihermitian: (set([Q.antihermitian]), set([])),
+        Q.commutative: (set([Q.commutative]), set([])),
+        Q.complex: (set([Q.commutative, Q.complex, Q.finite]),
+        set([Q.infinite, Q.negative_infinite, Q.positive_infinite])),
+        Q.complex_elements: (set([Q.complex_elements]), set([])),
+        Q.composite: (set([Q.algebraic, Q.commutative, Q.complex, Q.composite,
+        Q.extended_nonnegative, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonnegative, Q.nonzero, Q.positive, Q.rational,
+        Q.real]), set([Q.extended_negative, Q.extended_nonpositive,
+        Q.imaginary, Q.infinite, Q.irrational, Q.negative,
+        Q.negative_infinite, Q.nonpositive, Q.positive_infinite,
+        Q.prime, Q.transcendental, Q.zero])),
+        Q.diagonal: (set([Q.diagonal, Q.lower_triangular, Q.normal, Q.square,
+        Q.symmetric, Q.triangular, Q.upper_triangular]), set([])),
+        Q.even: (set([Q.algebraic, Q.commutative, Q.complex, Q.even,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer, Q.rational,
+        Q.real]), set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.odd, Q.positive_infinite,
+        Q.transcendental])),
+        Q.extended_negative: (set([Q.commutative, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real]),
+        set([Q.composite, Q.extended_nonnegative, Q.extended_positive,
+        Q.imaginary, Q.nonnegative, Q.positive, Q.positive_infinite,
+        Q.prime, Q.zero])),
+        Q.extended_nonnegative: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_real]), set([Q.extended_negative, Q.imaginary,
+        Q.negative, Q.negative_infinite])),
+        Q.extended_nonpositive: (set([Q.commutative, Q.extended_nonpositive,
+        Q.extended_real]), set([Q.composite, Q.extended_positive,
+        Q.imaginary, Q.positive, Q.positive_infinite, Q.prime])),
+        Q.extended_nonzero: (set([Q.commutative, Q.extended_nonzero,
+        Q.extended_real]), set([Q.imaginary, Q.zero])),
+        Q.extended_positive: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real]),
+        set([Q.extended_negative, Q.extended_nonpositive, Q.imaginary,
+        Q.negative, Q.negative_infinite, Q.nonpositive, Q.zero])),
+        Q.extended_real: (set([Q.commutative, Q.extended_real]),
+        set([Q.imaginary])),
+        Q.finite: (set([Q.commutative, Q.finite]), set([Q.infinite,
+        Q.negative_infinite, Q.positive_infinite])),
+        Q.fullrank: (set([Q.fullrank]), set([])),
+        Q.hermitian: (set([Q.hermitian]), set([])),
+        Q.imaginary: (set([Q.antihermitian, Q.commutative, Q.complex,
+        Q.finite, Q.imaginary]), set([Q.composite, Q.even,
+        Q.extended_negative, Q.extended_nonnegative,
+        Q.extended_nonpositive, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.infinite, Q.integer,
+        Q.irrational, Q.negative, Q.negative_infinite, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive,
+        Q.positive_infinite, Q.prime, Q.rational, Q.real, Q.zero])),
+        Q.infinite: (set([Q.commutative, Q.infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.finite, Q.imaginary,
+        Q.integer, Q.irrational, Q.negative, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.integer: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer, Q.rational,
+        Q.real]), set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental])),
+        Q.integer_elements: (set([Q.complex_elements, Q.integer_elements,
+        Q.real_elements]), set([])),
+        Q.invertible: (set([Q.fullrank, Q.invertible, Q.square]),
+        set([Q.singular])),
+        Q.irrational: (set([Q.commutative, Q.complex, Q.extended_nonzero,
+        Q.extended_real, Q.finite, Q.hermitian, Q.irrational,
+        Q.nonzero, Q.real]), set([Q.composite, Q.even, Q.imaginary,
+        Q.infinite, Q.integer, Q.negative_infinite, Q.odd,
+        Q.positive_infinite, Q.prime, Q.rational, Q.zero])),
+        Q.is_true: (set([Q.is_true]), set([])),
+        Q.lower_triangular: (set([Q.lower_triangular, Q.triangular]), set([])),
+        Q.negative: (set([Q.commutative, Q.complex, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real,
+        Q.finite, Q.hermitian, Q.negative, Q.nonpositive, Q.nonzero,
+        Q.real]), set([Q.composite, Q.extended_nonnegative,
+        Q.extended_positive, Q.imaginary, Q.infinite,
+        Q.negative_infinite, Q.nonnegative, Q.positive,
+        Q.positive_infinite, Q.prime, Q.zero])),
+        Q.negative_infinite: (set([Q.commutative, Q.extended_negative,
+        Q.extended_nonpositive, Q.extended_nonzero, Q.extended_real,
+        Q.infinite, Q.negative_infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.extended_nonnegative,
+        Q.extended_positive, Q.finite, Q.imaginary, Q.integer,
+        Q.irrational, Q.negative, Q.nonnegative, Q.nonpositive,
+        Q.nonzero, Q.odd, Q.positive, Q.positive_infinite, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.noninteger: (set([Q.noninteger]), set([])),
+        Q.nonnegative: (set([Q.commutative, Q.complex, Q.extended_nonnegative,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonnegative,
+        Q.real]), set([Q.extended_negative, Q.imaginary, Q.infinite,
+        Q.negative, Q.negative_infinite, Q.positive_infinite])),
+        Q.nonpositive: (set([Q.commutative, Q.complex, Q.extended_nonpositive,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonpositive,
+        Q.real]), set([Q.composite, Q.extended_positive, Q.imaginary,
+        Q.infinite, Q.negative_infinite, Q.positive,
+        Q.positive_infinite, Q.prime])),
+        Q.nonzero: (set([Q.commutative, Q.complex, Q.extended_nonzero,
+        Q.extended_real, Q.finite, Q.hermitian, Q.nonzero, Q.real]),
+        set([Q.imaginary, Q.infinite, Q.negative_infinite,
+        Q.positive_infinite, Q.zero])),
+        Q.normal: (set([Q.normal, Q.square]), set([])),
+        Q.odd: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_nonzero, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonzero, Q.odd, Q.rational, Q.real]),
+        set([Q.even, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental,
+        Q.zero])),
+        Q.orthogonal: (set([Q.fullrank, Q.invertible, Q.normal, Q.orthogonal,
+        Q.positive_definite, Q.square, Q.unitary]), set([Q.singular])),
+        Q.positive: (set([Q.commutative, Q.complex, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real,
+        Q.finite, Q.hermitian, Q.nonnegative, Q.nonzero, Q.positive,
+        Q.real]), set([Q.extended_negative, Q.extended_nonpositive,
+        Q.imaginary, Q.infinite, Q.negative, Q.negative_infinite,
+        Q.nonpositive, Q.positive_infinite, Q.zero])),
+        Q.positive_definite: (set([Q.fullrank, Q.invertible,
+        Q.positive_definite, Q.square]), set([Q.singular])),
+        Q.positive_infinite: (set([Q.commutative, Q.extended_nonnegative,
+        Q.extended_nonzero, Q.extended_positive, Q.extended_real,
+        Q.infinite, Q.positive_infinite]), set([Q.algebraic,
+        Q.complex, Q.composite, Q.even, Q.extended_negative,
+        Q.extended_nonpositive, Q.finite, Q.imaginary, Q.integer,
+        Q.irrational, Q.negative, Q.negative_infinite, Q.nonnegative,
+        Q.nonpositive, Q.nonzero, Q.odd, Q.positive, Q.prime,
+        Q.rational, Q.real, Q.transcendental, Q.zero])),
+        Q.prime: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_nonnegative, Q.extended_nonzero,
+        Q.extended_positive, Q.extended_real, Q.finite, Q.hermitian,
+        Q.integer, Q.nonnegative, Q.nonzero, Q.positive, Q.prime,
+        Q.rational, Q.real]), set([Q.composite, Q.extended_negative,
+        Q.extended_nonpositive, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative, Q.negative_infinite, Q.nonpositive,
+        Q.positive_infinite, Q.transcendental, Q.zero])),
+        Q.rational: (set([Q.algebraic, Q.commutative, Q.complex,
+        Q.extended_real, Q.finite, Q.hermitian, Q.rational, Q.real]),
+        set([Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative_infinite, Q.positive_infinite, Q.transcendental])),
+        Q.real: (set([Q.commutative, Q.complex, Q.extended_real, Q.finite,
+        Q.hermitian, Q.real]), set([Q.imaginary, Q.infinite,
+        Q.negative_infinite, Q.positive_infinite])),
+        Q.real_elements: (set([Q.complex_elements, Q.real_elements]), set([])),
+        Q.singular: (set([Q.singular]), set([Q.invertible, Q.orthogonal,
+        Q.positive_definite, Q.unitary])),
+        Q.square: (set([Q.square]), set([])),
+        Q.symmetric: (set([Q.square, Q.symmetric]), set([])),
+        Q.transcendental: (set([Q.commutative, Q.complex, Q.finite,
+        Q.transcendental]), set([Q.algebraic, Q.composite, Q.even,
+        Q.infinite, Q.integer, Q.negative_infinite, Q.odd,
+        Q.positive_infinite, Q.prime, Q.rational, Q.zero])),
+        Q.triangular: (set([Q.triangular]), set([])),
+        Q.unit_triangular: (set([Q.triangular, Q.unit_triangular]), set([])),
+        Q.unitary: (set([Q.fullrank, Q.invertible, Q.normal, Q.square,
+        Q.unitary]), set([Q.singular])),
+        Q.upper_triangular: (set([Q.triangular, Q.upper_triangular]), set([])),
+        Q.zero: (set([Q.algebraic, Q.commutative, Q.complex, Q.even,
+        Q.extended_nonnegative, Q.extended_nonpositive,
+        Q.extended_real, Q.finite, Q.hermitian, Q.integer,
+        Q.nonnegative, Q.nonpositive, Q.rational, Q.real, Q.zero]),
+        set([Q.composite, Q.extended_negative, Q.extended_nonzero,
+        Q.extended_positive, Q.imaginary, Q.infinite, Q.irrational,
+        Q.negative, Q.negative_infinite, Q.nonzero, Q.odd, Q.positive,
+        Q.positive_infinite, Q.prime, Q.transcendental])),
+    }
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/assume.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/assume.py
new file mode 100644
index 0000000000000000000000000000000000000000..743195a865a1d39389d471b95728ca79834ed019
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/assume.py
@@ -0,0 +1,485 @@
+"""A module which implements predicates and assumption context."""
+
+from contextlib import contextmanager
+import inspect
+from sympy.core.symbol import Str
+from sympy.core.sympify import _sympify
+from sympy.logic.boolalg import Boolean, false, true
+from sympy.multipledispatch.dispatcher import Dispatcher, str_signature
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.source import get_class
+
+
+class AssumptionsContext(set):
+    """
+    Set containing default assumptions which are applied to the ``ask()``
+    function.
+
+    Explanation
+    ===========
+
+    This is used to represent global assumptions, but you can also use this
+    class to create your own local assumptions contexts. It is basically a thin
+    wrapper to Python's set, so see its documentation for advanced usage.
+
+    Examples
+    ========
+
+    The default assumption context is ``global_assumptions``, which is initially empty:
+
+    >>> from sympy import ask, Q
+    >>> from sympy.assumptions import global_assumptions
+    >>> global_assumptions
+    AssumptionsContext()
+
+    You can add default assumptions:
+
+    >>> from sympy.abc import x
+    >>> global_assumptions.add(Q.real(x))
+    >>> global_assumptions
+    AssumptionsContext({Q.real(x)})
+    >>> ask(Q.real(x))
+    True
+
+    And remove them:
+
+    >>> global_assumptions.remove(Q.real(x))
+    >>> print(ask(Q.real(x)))
+    None
+
+    The ``clear()`` method removes every assumption:
+
+    >>> global_assumptions.add(Q.positive(x))
+    >>> global_assumptions
+    AssumptionsContext({Q.positive(x)})
+    >>> global_assumptions.clear()
+    >>> global_assumptions
+    AssumptionsContext()
+
+    See Also
+    ========
+
+    assuming
+
+    """
+
+    def add(self, *assumptions):
+        """Add assumptions."""
+        for a in assumptions:
+            super().add(a)
+
+    def _sympystr(self, printer):
+        if not self:
+            return "%s()" % self.__class__.__name__
+        return "{}({})".format(self.__class__.__name__, printer._print_set(self))
+
+global_assumptions = AssumptionsContext()
+
+
+class AppliedPredicate(Boolean):
+    """
+    The class of expressions resulting from applying ``Predicate`` to
+    the arguments. ``AppliedPredicate`` merely wraps its argument and
+    remain unevaluated. To evaluate it, use the ``ask()`` function.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> Q.integer(1)
+    Q.integer(1)
+
+    The ``function`` attribute returns the predicate, and the ``arguments``
+    attribute returns the tuple of arguments.
+
+    >>> type(Q.integer(1))
+    
+    >>> Q.integer(1).function
+    Q.integer
+    >>> Q.integer(1).arguments
+    (1,)
+
+    Applied predicates can be evaluated to a boolean value with ``ask``:
+
+    >>> ask(Q.integer(1))
+    True
+
+    """
+    __slots__ = ()
+
+    def __new__(cls, predicate, *args):
+        if not isinstance(predicate, Predicate):
+            raise TypeError("%s is not a Predicate." % predicate)
+        args = map(_sympify, args)
+        return super().__new__(cls, predicate, *args)
+
+    @property
+    def arg(self):
+        """
+        Return the expression used by this assumption.
+
+        Examples
+        ========
+
+        >>> from sympy import Q, Symbol
+        >>> x = Symbol('x')
+        >>> a = Q.integer(x + 1)
+        >>> a.arg
+        x + 1
+
+        """
+        # Will be deprecated
+        args = self._args
+        if len(args) == 2:
+            # backwards compatibility
+            return args[1]
+        raise TypeError("'arg' property is allowed only for unary predicates.")
+
+    @property
+    def function(self):
+        """
+        Return the predicate.
+        """
+        # Will be changed to self.args[0] after args overriding is removed
+        return self._args[0]
+
+    @property
+    def arguments(self):
+        """
+        Return the arguments which are applied to the predicate.
+        """
+        # Will be changed to self.args[1:] after args overriding is removed
+        return self._args[1:]
+
+    def _eval_ask(self, assumptions):
+        return self.function.eval(self.arguments, assumptions)
+
+    @property
+    def binary_symbols(self):
+        from .ask import Q
+        if self.function == Q.is_true:
+            i = self.arguments[0]
+            if i.is_Boolean or i.is_Symbol:
+                return i.binary_symbols
+        if self.function in (Q.eq, Q.ne):
+            if true in self.arguments or false in self.arguments:
+                if self.arguments[0].is_Symbol:
+                    return {self.arguments[0]}
+                elif self.arguments[1].is_Symbol:
+                    return {self.arguments[1]}
+        return set()
+
+
+class PredicateMeta(type):
+    def __new__(cls, clsname, bases, dct):
+        # If handler is not defined, assign empty dispatcher.
+        if "handler" not in dct:
+            name = f"Ask{clsname.capitalize()}Handler"
+            handler = Dispatcher(name, doc="Handler for key %s" % name)
+            dct["handler"] = handler
+
+        dct["_orig_doc"] = dct.get("__doc__", "")
+
+        return super().__new__(cls, clsname, bases, dct)
+
+    @property
+    def __doc__(cls):
+        handler = cls.handler
+        doc = cls._orig_doc
+        if cls is not Predicate and handler is not None:
+            doc += "Handler\n"
+            doc += "    =======\n\n"
+
+            # Append the handler's doc without breaking sphinx documentation.
+            docs = ["    Multiply dispatched method: %s" % handler.name]
+            if handler.doc:
+                for line in handler.doc.splitlines():
+                    if not line:
+                        continue
+                    docs.append("    %s" % line)
+            other = []
+            for sig in handler.ordering[::-1]:
+                func = handler.funcs[sig]
+                if func.__doc__:
+                    s = '    Inputs: <%s>' % str_signature(sig)
+                    lines = []
+                    for line in func.__doc__.splitlines():
+                        lines.append("    %s" % line)
+                    s += "\n".join(lines)
+                    docs.append(s)
+                else:
+                    other.append(str_signature(sig))
+            if other:
+                othersig = "    Other signatures:"
+                for line in other:
+                    othersig += "\n        * %s" % line
+                docs.append(othersig)
+
+            doc += '\n\n'.join(docs)
+
+        return doc
+
+
+class Predicate(Boolean, metaclass=PredicateMeta):
+    """
+    Base class for mathematical predicates. It also serves as a
+    constructor for undefined predicate objects.
+
+    Explanation
+    ===========
+
+    Predicate is a function that returns a boolean value [1].
+
+    Predicate function is object, and it is instance of predicate class.
+    When a predicate is applied to arguments, ``AppliedPredicate``
+    instance is returned. This merely wraps the argument and remain
+    unevaluated. To obtain the truth value of applied predicate, use the
+    function ``ask``.
+
+    Evaluation of predicate is done by multiple dispatching. You can
+    register new handler to the predicate to support new types.
+
+    Every predicate in SymPy can be accessed via the property of ``Q``.
+    For example, ``Q.even`` returns the predicate which checks if the
+    argument is even number.
+
+    To define a predicate which can be evaluated, you must subclass this
+    class, make an instance of it, and register it to ``Q``. After then,
+    dispatch the handler by argument types.
+
+    If you directly construct predicate using this class, you will get
+    ``UndefinedPredicate`` which cannot be dispatched. This is useful
+    when you are building boolean expressions which do not need to be
+    evaluated.
+
+    Examples
+    ========
+
+    Applying and evaluating to boolean value:
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.prime(7))
+    True
+
+    You can define a new predicate by subclassing and dispatching. Here,
+    we define a predicate for sexy primes [2] as an example.
+
+    >>> from sympy import Predicate, Integer
+    >>> class SexyPrimePredicate(Predicate):
+    ...     name = "sexyprime"
+    >>> Q.sexyprime = SexyPrimePredicate()
+    >>> @Q.sexyprime.register(Integer, Integer)
+    ... def _(int1, int2, assumptions):
+    ...     args = sorted([int1, int2])
+    ...     if not all(ask(Q.prime(a), assumptions) for a in args):
+    ...         return False
+    ...     return args[1] - args[0] == 6
+    >>> ask(Q.sexyprime(5, 11))
+    True
+
+    Direct constructing returns ``UndefinedPredicate``, which can be
+    applied but cannot be dispatched.
+
+    >>> from sympy import Predicate, Integer
+    >>> Q.P = Predicate("P")
+    >>> type(Q.P)
+    
+    >>> Q.P(1)
+    Q.P(1)
+    >>> Q.P.register(Integer)(lambda expr, assump: True)
+    Traceback (most recent call last):
+      ...
+    TypeError:  cannot be dispatched.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Predicate_%28mathematical_logic%29
+    .. [2] https://en.wikipedia.org/wiki/Sexy_prime
+
+    """
+
+    is_Atom = True
+
+    def __new__(cls, *args, **kwargs):
+        if cls is Predicate:
+            return UndefinedPredicate(*args, **kwargs)
+        obj = super().__new__(cls, *args)
+        return obj
+
+    @property
+    def name(self):
+        # May be overridden
+        return type(self).__name__
+
+    @classmethod
+    def register(cls, *types, **kwargs):
+        """
+        Register the signature to the handler.
+        """
+        if cls.handler is None:
+            raise TypeError("%s cannot be dispatched." % type(cls))
+        return cls.handler.register(*types, **kwargs)
+
+    @classmethod
+    def register_many(cls, *types, **kwargs):
+        """
+        Register multiple signatures to same handler.
+        """
+        def _(func):
+            for t in types:
+                if not is_sequence(t):
+                    t = (t,)  # for convenience, allow passing `type` to mean `(type,)`
+                cls.register(*t, **kwargs)(func)
+        return _
+
+    def __call__(self, *args):
+        return AppliedPredicate(self, *args)
+
+    def eval(self, args, assumptions=True):
+        """
+        Evaluate ``self(*args)`` under the given assumptions.
+
+        This uses only direct resolution methods, not logical inference.
+        """
+        result = None
+        try:
+            result = self.handler(*args, assumptions=assumptions)
+        except NotImplementedError:
+            pass
+        return result
+
+    def _eval_refine(self, assumptions):
+        # When Predicate is no longer Boolean, delete this method
+        return self
+
+
+class UndefinedPredicate(Predicate):
+    """
+    Predicate without handler.
+
+    Explanation
+    ===========
+
+    This predicate is generated by using ``Predicate`` directly for
+    construction. It does not have a handler, and evaluating this with
+    arguments is done by SAT solver.
+
+    Examples
+    ========
+
+    >>> from sympy import Predicate, Q
+    >>> Q.P = Predicate('P')
+    >>> Q.P.func
+    
+    >>> Q.P.name
+    Str('P')
+
+    """
+
+    handler = None
+
+    def __new__(cls, name, handlers=None):
+        # "handlers" parameter supports old design
+        if not isinstance(name, Str):
+            name = Str(name)
+        obj = super(Boolean, cls).__new__(cls, name)
+        obj.handlers = handlers or []
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    def _hashable_content(self):
+        return (self.name,)
+
+    def __getnewargs__(self):
+        return (self.name,)
+
+    def __call__(self, expr):
+        return AppliedPredicate(self, expr)
+
+    def add_handler(self, handler):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Predicate.add_handler()
+            should be replaced with the multipledispatch handler of Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        self.handlers.append(handler)
+
+    def remove_handler(self, handler):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Predicate.remove_handler()
+            should be replaced with the multipledispatch handler of Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        self.handlers.remove(handler)
+
+    def eval(self, args, assumptions=True):
+        # Support for deprecated design
+        # When old design is removed, this will always return None
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. Evaluating UndefinedPredicate
+            objects should be replaced with the multipledispatch handler of
+            Predicate.
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+            stacklevel=5,
+        )
+        expr, = args
+        res, _res = None, None
+        mro = inspect.getmro(type(expr))
+        for handler in self.handlers:
+            cls = get_class(handler)
+            for subclass in mro:
+                eval_ = getattr(cls, subclass.__name__, None)
+                if eval_ is None:
+                    continue
+                res = eval_(expr, assumptions)
+                # Do not stop if value returned is None
+                # Try to check for higher classes
+                if res is None:
+                    continue
+                if _res is None:
+                    _res = res
+                else:
+                    # only check consistency if both resolutors have concluded
+                    if _res != res:
+                        raise ValueError('incompatible resolutors')
+                break
+        return res
+
+
+@contextmanager
+def assuming(*assumptions):
+    """
+    Context manager for assumptions.
+
+    Examples
+    ========
+
+    >>> from sympy import assuming, Q, ask
+    >>> from sympy.abc import x, y
+    >>> print(ask(Q.integer(x + y)))
+    None
+    >>> with assuming(Q.integer(x), Q.integer(y)):
+    ...     print(ask(Q.integer(x + y)))
+    True
+    """
+    old_global_assumptions = global_assumptions.copy()
+    global_assumptions.update(assumptions)
+    try:
+        yield
+    finally:
+        global_assumptions.clear()
+        global_assumptions.update(old_global_assumptions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/cnf.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/cnf.py
new file mode 100644
index 0000000000000000000000000000000000000000..a95d27bed6eeb64c42f4edd9d49bd8e5753069e5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/cnf.py
@@ -0,0 +1,445 @@
+"""
+The classes used here are for the internal use of assumptions system
+only and should not be used anywhere else as these do not possess the
+signatures common to SymPy objects. For general use of logic constructs
+please refer to sympy.logic classes And, Or, Not, etc.
+"""
+from itertools import combinations, product, zip_longest
+from sympy.assumptions.assume import AppliedPredicate, Predicate
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.core.singleton import S
+from sympy.logic.boolalg import Or, And, Not, Xnor
+from sympy.logic.boolalg import (Equivalent, ITE, Implies, Nand, Nor, Xor)
+
+
+class Literal:
+    """
+    The smallest element of a CNF object.
+
+    Parameters
+    ==========
+
+    lit : Boolean expression
+
+    is_Not : bool
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import Literal
+    >>> from sympy.abc import x
+    >>> Literal(Q.even(x))
+    Literal(Q.even(x), False)
+    >>> Literal(~Q.even(x))
+    Literal(Q.even(x), True)
+    """
+
+    def __new__(cls, lit, is_Not=False):
+        if isinstance(lit, Not):
+            lit = lit.args[0]
+            is_Not = True
+        elif isinstance(lit, (AND, OR, Literal)):
+            return ~lit if is_Not else lit
+        obj = super().__new__(cls)
+        obj.lit = lit
+        obj.is_Not = is_Not
+        return obj
+
+    @property
+    def arg(self):
+        return self.lit
+
+    def rcall(self, expr):
+        if callable(self.lit):
+            lit = self.lit(expr)
+        else:
+            lit = self.lit.apply(expr)
+        return type(self)(lit, self.is_Not)
+
+    def __invert__(self):
+        is_Not = not self.is_Not
+        return Literal(self.lit, is_Not)
+
+    def __str__(self):
+        return '{}({}, {})'.format(type(self).__name__, self.lit, self.is_Not)
+
+    __repr__ = __str__
+
+    def __eq__(self, other):
+        return self.arg == other.arg and self.is_Not == other.is_Not
+
+    def __hash__(self):
+        h = hash((type(self).__name__, self.arg, self.is_Not))
+        return h
+
+
+class OR:
+    """
+    A low-level implementation for Or
+    """
+    def __init__(self, *args):
+        self._args = args
+
+    @property
+    def args(self):
+        return sorted(self._args, key=str)
+
+    def rcall(self, expr):
+        return type(self)(*[arg.rcall(expr)
+                            for arg in self._args
+                            ])
+
+    def __invert__(self):
+        return AND(*[~arg for arg in self._args])
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(self, other):
+        return self.args == other.args
+
+    def __str__(self):
+        s = '(' + ' | '.join([str(arg) for arg in self.args]) + ')'
+        return s
+
+    __repr__ = __str__
+
+
+class AND:
+    """
+    A low-level implementation for And
+    """
+    def __init__(self, *args):
+        self._args = args
+
+    def __invert__(self):
+        return OR(*[~arg for arg in self._args])
+
+    @property
+    def args(self):
+        return sorted(self._args, key=str)
+
+    def rcall(self, expr):
+        return type(self)(*[arg.rcall(expr)
+                            for arg in self._args
+                            ])
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(self, other):
+        return self.args == other.args
+
+    def __str__(self):
+        s = '('+' & '.join([str(arg) for arg in self.args])+')'
+        return s
+
+    __repr__ = __str__
+
+
+def to_NNF(expr, composite_map=None):
+    """
+    Generates the Negation Normal Form of any boolean expression in terms
+    of AND, OR, and Literal objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Eq
+    >>> from sympy.assumptions.cnf import to_NNF
+    >>> from sympy.abc import x, y
+    >>> expr = Q.even(x) & ~Q.positive(x)
+    >>> to_NNF(expr)
+    (Literal(Q.even(x), False) & Literal(Q.positive(x), True))
+
+    Supported boolean objects are converted to corresponding predicates.
+
+    >>> to_NNF(Eq(x, y))
+    Literal(Q.eq(x, y), False)
+
+    If ``composite_map`` argument is given, ``to_NNF`` decomposes the
+    specified predicate into a combination of primitive predicates.
+
+    >>> cmap = {Q.nonpositive: Q.negative | Q.zero}
+    >>> to_NNF(Q.nonpositive, cmap)
+    (Literal(Q.negative, False) | Literal(Q.zero, False))
+    >>> to_NNF(Q.nonpositive(x), cmap)
+    (Literal(Q.negative(x), False) | Literal(Q.zero(x), False))
+    """
+    from sympy.assumptions.ask import Q
+
+    if composite_map is None:
+        composite_map = {}
+
+
+    binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+    if type(expr) in binrelpreds:
+        pred = binrelpreds[type(expr)]
+        expr = pred(*expr.args)
+
+    if isinstance(expr, Not):
+        arg = expr.args[0]
+        tmp = to_NNF(arg, composite_map)  # Strategy: negate the NNF of expr
+        return ~tmp
+
+    if isinstance(expr, Or):
+        return OR(*[to_NNF(x, composite_map) for x in Or.make_args(expr)])
+
+    if isinstance(expr, And):
+        return AND(*[to_NNF(x, composite_map) for x in And.make_args(expr)])
+
+    if isinstance(expr, Nand):
+        tmp = AND(*[to_NNF(x, composite_map) for x in expr.args])
+        return ~tmp
+
+    if isinstance(expr, Nor):
+        tmp = OR(*[to_NNF(x, composite_map) for x in expr.args])
+        return ~tmp
+
+    if isinstance(expr, Xor):
+        cnfs = []
+        for i in range(0, len(expr.args) + 1, 2):
+            for neg in combinations(expr.args, i):
+                clause = [~to_NNF(s, composite_map) if s in neg else to_NNF(s, composite_map)
+                          for s in expr.args]
+                cnfs.append(OR(*clause))
+        return AND(*cnfs)
+
+    if isinstance(expr, Xnor):
+        cnfs = []
+        for i in range(0, len(expr.args) + 1, 2):
+            for neg in combinations(expr.args, i):
+                clause = [~to_NNF(s, composite_map) if s in neg else to_NNF(s, composite_map)
+                          for s in expr.args]
+                cnfs.append(OR(*clause))
+        return ~AND(*cnfs)
+
+    if isinstance(expr, Implies):
+        L, R = to_NNF(expr.args[0], composite_map), to_NNF(expr.args[1], composite_map)
+        return OR(~L, R)
+
+    if isinstance(expr, Equivalent):
+        cnfs = []
+        for a, b in zip_longest(expr.args, expr.args[1:], fillvalue=expr.args[0]):
+            a = to_NNF(a, composite_map)
+            b = to_NNF(b, composite_map)
+            cnfs.append(OR(~a, b))
+        return AND(*cnfs)
+
+    if isinstance(expr, ITE):
+        L = to_NNF(expr.args[0], composite_map)
+        M = to_NNF(expr.args[1], composite_map)
+        R = to_NNF(expr.args[2], composite_map)
+        return AND(OR(~L, M), OR(L, R))
+
+    if isinstance(expr, AppliedPredicate):
+        pred, args = expr.function, expr.arguments
+        newpred = composite_map.get(pred, None)
+        if newpred is not None:
+            return to_NNF(newpred.rcall(*args), composite_map)
+
+    if isinstance(expr, Predicate):
+        newpred = composite_map.get(expr, None)
+        if newpred is not None:
+            return to_NNF(newpred, composite_map)
+
+    return Literal(expr)
+
+
+def distribute_AND_over_OR(expr):
+    """
+    Distributes AND over OR in the NNF expression.
+    Returns the result( Conjunctive Normal Form of expression)
+    as a CNF object.
+    """
+    if not isinstance(expr, (AND, OR)):
+        tmp = set()
+        tmp.add(frozenset((expr,)))
+        return CNF(tmp)
+
+    if isinstance(expr, OR):
+        return CNF.all_or(*[distribute_AND_over_OR(arg)
+                            for arg in expr._args])
+
+    if isinstance(expr, AND):
+        return CNF.all_and(*[distribute_AND_over_OR(arg)
+                             for arg in expr._args])
+
+
+class CNF:
+    """
+    Class to represent CNF of a Boolean expression.
+    Consists of set of clauses, which themselves are stored as
+    frozenset of Literal objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.abc import x
+    >>> cnf = CNF.from_prop(Q.real(x) & ~Q.zero(x))
+    >>> cnf.clauses
+    {frozenset({Literal(Q.zero(x), True)}),
+    frozenset({Literal(Q.negative(x), False),
+    Literal(Q.positive(x), False), Literal(Q.zero(x), False)})}
+    """
+    def __init__(self, clauses=None):
+        if not clauses:
+            clauses = set()
+        self.clauses = clauses
+
+    def add(self, prop):
+        clauses = CNF.to_CNF(prop).clauses
+        self.add_clauses(clauses)
+
+    def __str__(self):
+        s = ' & '.join(
+            ['(' + ' | '.join([str(lit) for lit in clause]) +')'
+            for clause in self.clauses]
+        )
+        return s
+
+    def extend(self, props):
+        for p in props:
+            self.add(p)
+        return self
+
+    def copy(self):
+        return CNF(set(self.clauses))
+
+    def add_clauses(self, clauses):
+        self.clauses |= clauses
+
+    @classmethod
+    def from_prop(cls, prop):
+        res = cls()
+        res.add(prop)
+        return res
+
+    def __iand__(self, other):
+        self.add_clauses(other.clauses)
+        return self
+
+    def all_predicates(self):
+        predicates = set()
+        for c in self.clauses:
+            predicates |= {arg.lit for arg in c}
+        return predicates
+
+    def _or(self, cnf):
+        clauses = set()
+        for a, b in product(self.clauses, cnf.clauses):
+            tmp = set(a)
+            tmp.update(b)
+            clauses.add(frozenset(tmp))
+        return CNF(clauses)
+
+    def _and(self, cnf):
+        clauses = self.clauses.union(cnf.clauses)
+        return CNF(clauses)
+
+    def _not(self):
+        clss = list(self.clauses)
+        ll = {frozenset((~x,)) for x in clss[-1]}
+        ll = CNF(ll)
+
+        for rest in clss[:-1]:
+            p = {frozenset((~x,)) for x in rest}
+            ll = ll._or(CNF(p))
+        return ll
+
+    def rcall(self, expr):
+        clause_list = []
+        for clause in self.clauses:
+            lits = [arg.rcall(expr) for arg in clause]
+            clause_list.append(OR(*lits))
+        expr = AND(*clause_list)
+        return distribute_AND_over_OR(expr)
+
+    @classmethod
+    def all_or(cls, *cnfs):
+        b = cnfs[0].copy()
+        for rest in cnfs[1:]:
+            b = b._or(rest)
+        return b
+
+    @classmethod
+    def all_and(cls, *cnfs):
+        b = cnfs[0].copy()
+        for rest in cnfs[1:]:
+            b = b._and(rest)
+        return b
+
+    @classmethod
+    def to_CNF(cls, expr):
+        from sympy.assumptions.facts import get_composite_predicates
+        expr = to_NNF(expr, get_composite_predicates())
+        expr = distribute_AND_over_OR(expr)
+        return expr
+
+    @classmethod
+    def CNF_to_cnf(cls, cnf):
+        """
+        Converts CNF object to SymPy's boolean expression
+        retaining the form of expression.
+        """
+        def remove_literal(arg):
+            return Not(arg.lit) if arg.is_Not else arg.lit
+
+        return And(*(Or(*(remove_literal(arg) for arg in clause)) for clause in cnf.clauses))
+
+
+class EncodedCNF:
+    """
+    Class for encoding the CNF expression.
+    """
+    def __init__(self, data=None, encoding=None):
+        if not data and not encoding:
+            data = []
+            encoding = {}
+        self.data = data
+        self.encoding = encoding
+        self._symbols = list(encoding.keys())
+
+    def from_cnf(self, cnf):
+        self._symbols = list(cnf.all_predicates())
+        n = len(self._symbols)
+        self.encoding = dict(zip(self._symbols, range(1, n + 1)))
+        self.data = [self.encode(clause) for clause in cnf.clauses]
+
+    @property
+    def symbols(self):
+        return self._symbols
+
+    @property
+    def variables(self):
+        return range(1, len(self._symbols) + 1)
+
+    def copy(self):
+        new_data = [set(clause) for clause in self.data]
+        return EncodedCNF(new_data, dict(self.encoding))
+
+    def add_prop(self, prop):
+        cnf = CNF.from_prop(prop)
+        self.add_from_cnf(cnf)
+
+    def add_from_cnf(self, cnf):
+        clauses = [self.encode(clause) for clause in cnf.clauses]
+        self.data += clauses
+
+    def encode_arg(self, arg):
+        literal = arg.lit
+        value = self.encoding.get(literal, None)
+        if value is None:
+            n = len(self._symbols)
+            self._symbols.append(literal)
+            value = self.encoding[literal] = n + 1
+        if arg.is_Not:
+            return -value
+        else:
+            return value
+
+    def encode(self, clause):
+        return {self.encode_arg(arg) if not arg.lit == S.false else 0 for arg in clause}
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/facts.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/facts.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ff268677cf74e252ac6c3bc3eecbea08b9414d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/facts.py
@@ -0,0 +1,270 @@
+"""
+Known facts in assumptions module.
+
+This module defines the facts between unary predicates in ``get_known_facts()``,
+and supports functions to generate the contents in
+``sympy.assumptions.ask_generated`` file.
+"""
+
+from sympy.assumptions.ask import Q
+from sympy.assumptions.assume import AppliedPredicate
+from sympy.core.cache import cacheit
+from sympy.core.symbol import Symbol
+from sympy.logic.boolalg import (to_cnf, And, Not, Implies, Equivalent,
+    Exclusive,)
+from sympy.logic.inference import satisfiable
+
+
+@cacheit
+def get_composite_predicates():
+    # To reduce the complexity of sat solver, these predicates are
+    # transformed into the combination of primitive predicates.
+    return {
+        Q.real : Q.negative | Q.zero | Q.positive,
+        Q.integer : Q.even | Q.odd,
+        Q.nonpositive : Q.negative | Q.zero,
+        Q.nonzero : Q.negative | Q.positive,
+        Q.nonnegative : Q.zero | Q.positive,
+        Q.extended_real : Q.negative_infinite | Q.negative | Q.zero | Q.positive | Q.positive_infinite,
+        Q.extended_positive: Q.positive | Q.positive_infinite,
+        Q.extended_negative: Q.negative | Q.negative_infinite,
+        Q.extended_nonzero: Q.negative_infinite | Q.negative | Q.positive | Q.positive_infinite,
+        Q.extended_nonpositive: Q.negative_infinite | Q.negative | Q.zero,
+        Q.extended_nonnegative: Q.zero | Q.positive | Q.positive_infinite,
+        Q.complex : Q.algebraic | Q.transcendental
+    }
+
+
+@cacheit
+def get_known_facts(x=None):
+    """
+    Facts between unary predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        get_number_facts(x),
+        get_matrix_facts(x)
+    )
+    return fact
+
+
+@cacheit
+def get_number_facts(x = None):
+    """
+    Facts between unary number predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        # primitive predicates for extended real exclude each other.
+        Exclusive(Q.negative_infinite(x), Q.negative(x), Q.zero(x),
+            Q.positive(x), Q.positive_infinite(x)),
+
+        # build complex plane
+        Exclusive(Q.real(x), Q.imaginary(x)),
+        Implies(Q.real(x) | Q.imaginary(x), Q.complex(x)),
+
+        # other subsets of complex
+        Exclusive(Q.transcendental(x), Q.algebraic(x)),
+        Equivalent(Q.real(x), Q.rational(x) | Q.irrational(x)),
+        Exclusive(Q.irrational(x), Q.rational(x)),
+        Implies(Q.rational(x), Q.algebraic(x)),
+
+        # integers
+        Exclusive(Q.even(x), Q.odd(x)),
+        Implies(Q.integer(x), Q.rational(x)),
+        Implies(Q.zero(x), Q.even(x)),
+        Exclusive(Q.composite(x), Q.prime(x)),
+        Implies(Q.composite(x) | Q.prime(x), Q.integer(x) & Q.positive(x)),
+        Implies(Q.even(x) & Q.positive(x) & ~Q.prime(x), Q.composite(x)),
+
+        # hermitian and antihermitian
+        Implies(Q.real(x), Q.hermitian(x)),
+        Implies(Q.imaginary(x), Q.antihermitian(x)),
+        Implies(Q.zero(x), Q.hermitian(x) | Q.antihermitian(x)),
+
+        # define finity and infinity, and build extended real line
+        Exclusive(Q.infinite(x), Q.finite(x)),
+        Implies(Q.complex(x), Q.finite(x)),
+        Implies(Q.negative_infinite(x) | Q.positive_infinite(x), Q.infinite(x)),
+
+        # commutativity
+        Implies(Q.finite(x) | Q.infinite(x), Q.commutative(x)),
+    )
+    return fact
+
+
+@cacheit
+def get_matrix_facts(x = None):
+    """
+    Facts between unary matrix predicates.
+
+    Parameters
+    ==========
+
+    x : Symbol, optional
+        Placeholder symbol for unary facts. Default is ``Symbol('x')``.
+
+    Returns
+    =======
+
+    fact : Known facts in conjugated normal form.
+
+    """
+    if x is None:
+        x = Symbol('x')
+
+    fact = And(
+        # matrices
+        Implies(Q.orthogonal(x), Q.positive_definite(x)),
+        Implies(Q.orthogonal(x), Q.unitary(x)),
+        Implies(Q.unitary(x) & Q.real_elements(x), Q.orthogonal(x)),
+        Implies(Q.unitary(x), Q.normal(x)),
+        Implies(Q.unitary(x), Q.invertible(x)),
+        Implies(Q.normal(x), Q.square(x)),
+        Implies(Q.diagonal(x), Q.normal(x)),
+        Implies(Q.positive_definite(x), Q.invertible(x)),
+        Implies(Q.diagonal(x), Q.upper_triangular(x)),
+        Implies(Q.diagonal(x), Q.lower_triangular(x)),
+        Implies(Q.lower_triangular(x), Q.triangular(x)),
+        Implies(Q.upper_triangular(x), Q.triangular(x)),
+        Implies(Q.triangular(x), Q.upper_triangular(x) | Q.lower_triangular(x)),
+        Implies(Q.upper_triangular(x) & Q.lower_triangular(x), Q.diagonal(x)),
+        Implies(Q.diagonal(x), Q.symmetric(x)),
+        Implies(Q.unit_triangular(x), Q.triangular(x)),
+        Implies(Q.invertible(x), Q.fullrank(x)),
+        Implies(Q.invertible(x), Q.square(x)),
+        Implies(Q.symmetric(x), Q.square(x)),
+        Implies(Q.fullrank(x) & Q.square(x), Q.invertible(x)),
+        Equivalent(Q.invertible(x), ~Q.singular(x)),
+        Implies(Q.integer_elements(x), Q.real_elements(x)),
+        Implies(Q.real_elements(x), Q.complex_elements(x)),
+    )
+    return fact
+
+
+
+def generate_known_facts_dict(keys, fact):
+    """
+    Computes and returns a dictionary which contains the relations between
+    unary predicates.
+
+    Each key is a predicate, and item is two groups of predicates.
+    First group contains the predicates which are implied by the key, and
+    second group contains the predicates which are rejected by the key.
+
+    All predicates in *keys* and *fact* must be unary and have same placeholder
+    symbol.
+
+    Parameters
+    ==========
+
+    keys : list of AppliedPredicate instances.
+
+    fact : Fact between predicates in conjugated normal form.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, And, Implies
+    >>> from sympy.assumptions.facts import generate_known_facts_dict
+    >>> from sympy.abc import x
+    >>> keys = [Q.even(x), Q.odd(x), Q.zero(x)]
+    >>> fact = And(Implies(Q.even(x), ~Q.odd(x)),
+    ...     Implies(Q.zero(x), Q.even(x)))
+    >>> generate_known_facts_dict(keys, fact)
+    {Q.even: ({Q.even}, {Q.odd}),
+     Q.odd: ({Q.odd}, {Q.even, Q.zero}),
+     Q.zero: ({Q.even, Q.zero}, {Q.odd})}
+    """
+    fact_cnf = to_cnf(fact)
+    mapping = single_fact_lookup(keys, fact_cnf)
+
+    ret = {}
+    for key, value in mapping.items():
+        implied = set()
+        rejected = set()
+        for expr in value:
+            if isinstance(expr, AppliedPredicate):
+                implied.add(expr.function)
+            elif isinstance(expr, Not):
+                pred = expr.args[0]
+                rejected.add(pred.function)
+        ret[key.function] = (implied, rejected)
+    return ret
+
+
+@cacheit
+def get_known_facts_keys():
+    """
+    Return every unary predicates registered to ``Q``.
+
+    This function is used to generate the keys for
+    ``generate_known_facts_dict``.
+
+    """
+    # exclude polyadic predicates
+    exclude = {Q.eq, Q.ne, Q.gt, Q.lt, Q.ge, Q.le}
+
+    result = []
+    for attr in Q.__class__.__dict__:
+        if attr.startswith('__'):
+            continue
+        pred = getattr(Q, attr)
+        if pred in exclude:
+            continue
+        result.append(pred)
+    return result
+
+
+def single_fact_lookup(known_facts_keys, known_facts_cnf):
+    # Return the dictionary for quick lookup of single fact
+    mapping = {}
+    for key in known_facts_keys:
+        mapping[key] = {key}
+        for other_key in known_facts_keys:
+            if other_key != key:
+                if ask_full_inference(other_key, key, known_facts_cnf):
+                    mapping[key].add(other_key)
+                if ask_full_inference(~other_key, key, known_facts_cnf):
+                    mapping[key].add(~other_key)
+    return mapping
+
+
+def ask_full_inference(proposition, assumptions, known_facts_cnf):
+    """
+    Method for inferring properties about objects.
+
+    """
+    if not satisfiable(And(known_facts_cnf, assumptions, proposition)):
+        return False
+    if not satisfiable(And(known_facts_cnf, assumptions, Not(proposition))):
+        return True
+    return None
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__init__.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0fbe618eb8b43e252ac8fb0baf1eeee22bf347cc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__init__.py
@@ -0,0 +1,13 @@
+"""
+Multipledispatch handlers for ``Predicate`` are implemented here.
+Handlers in this module are not directly imported to other modules in
+order to avoid circular import problem.
+"""
+
+from .common import (AskHandler, CommonHandler,
+    test_closed_group)
+
+__all__ = [
+    'AskHandler', 'CommonHandler',
+    'test_closed_group'
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7cd154abe2ef0ba8663ad6890c37e41cf4e059c0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/calculus.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/calculus.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db8ad99aa7a416406e5e22230cf4099628ca436b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/calculus.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/common.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04ed731a8abb07ed21efc389f1dbdca1bf894334
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/common.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/matrices.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/matrices.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..357ed3a2cb6ed7f0fe44091418fc5a294d2bec0c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/matrices.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/ntheory.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/ntheory.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0b3d1fd088017e7222867f952915f7071e9abf8d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/ntheory.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/order.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/order.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55efc57d5778d403babc6d12c6779e7238577303
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/order.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/sets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/sets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8e4292e3cc05ee523de774dd2587a2899a4e5c3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/__pycache__/sets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/calculus.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2b9c43ccea216988a25aa671ea23bc81d2209ff
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/calculus.py
@@ -0,0 +1,273 @@
+"""
+This module contains query handlers responsible for calculus queries:
+infinitesimal, finite, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Expr, Add, Mul, Pow, Symbol
+from sympy.core.numbers import (NegativeInfinity, GoldenRatio,
+    Infinity, Exp1, ComplexInfinity, ImaginaryUnit, NaN, Number, Pi, E,
+    TribonacciConstant)
+from sympy.functions import cos, exp, log, sign, sin
+from sympy.logic.boolalg import conjuncts
+
+from ..predicates.calculus import (FinitePredicate, InfinitePredicate,
+    PositiveInfinitePredicate, NegativeInfinitePredicate)
+
+
+# FinitePredicate
+
+
+@FinitePredicate.register(Symbol)
+def _(expr, assumptions):
+    """
+    Handles Symbol.
+    """
+    if expr.is_finite is not None:
+        return expr.is_finite
+    if Q.finite(expr) in conjuncts(assumptions):
+        return True
+    return None
+
+@FinitePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +-------+-----+-----------+-----------+
+    |       |     |           |           |
+    |       |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |   |   |   |   |   |   |
+    |       |     |'+'|'-'|'x'|'+'|'-'|'x'|
+    |       |     |   |   |   |   |   |   |
+    +-------+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   B   |  B  |     U     |     ?     |
+    |       |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    |   |'+'|     | U | ? | ? | U | ? | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |   |   |   |   |   |   |
+    | U |'-'|     | ? | U | ? | ? | U | ? |
+    |   |   |     |   |   |   |   |   |   |
+    |   +---+-----+---+---+---+---+---+---+
+    |   |   |     |           |           |
+    |   |'x'|     |     ?     |     ?     |
+    |   |   |     |           |           |
+    +---+---+-----+---+---+---+---+---+---+
+    |       |     |           |           |
+    |   ?   |     |           |     ?     |
+    |       |     |           |           |
+    +-------+-----+-----------+---+---+---+
+
+        * 'B' = Bounded
+
+        * 'U' = Unbounded
+
+        * '?' = unknown boundedness
+
+        * '+' = positive sign
+
+        * '-' = negative sign
+
+        * 'x' = sign unknown
+
+        * All Bounded -> True
+
+        * 1 Unbounded and the rest Bounded -> False
+
+        * >1 Unbounded, all with same known sign -> False
+
+        * Any Unknown and unknown sign -> None
+
+        * Else -> None
+
+    When the signs are not the same you can have an undefined
+    result as in oo - oo, hence 'bounded' is also undefined.
+    """
+    sign = -1  # sign of unknown or infinite
+    result = True
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            continue
+        s = ask(Q.extended_positive(arg), assumptions)
+        # if there has been more than one sign or if the sign of this arg
+        # is None and Bounded is None or there was already
+        # an unknown sign, return None
+        if sign != -1 and s != sign or \
+                s is None and None in (_bounded, sign):
+            return None
+        else:
+            sign = s
+        # once False, do not change
+        if result is not False:
+            result = _bounded
+    return result
+
+@FinitePredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Return True if expr is bounded, False if not and None if unknown.
+
+    Truth Table:
+
+    +---+---+---+--------+
+    |   |   |   |        |
+    |   | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    |   |   |   | s | /s |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | B | B | U |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+    |   |   |   |   |    |
+    | U |   | U | U | ?  |
+    |   |   |   |   |    |
+    +---+---+---+---+----+
+    |   |   |   |        |
+    | ? |   |   |   ?    |
+    |   |   |   |        |
+    +---+---+---+---+----+
+
+        * B = Bounded
+
+        * U = Unbounded
+
+        * ? = unknown boundedness
+
+        * s = signed (hence nonzero)
+
+        * /s = not signed
+    """
+    result = True
+    possible_zero = False
+    for arg in expr.args:
+        _bounded = ask(Q.finite(arg), assumptions)
+        if _bounded:
+            if ask(Q.zero(arg), assumptions) is not False:
+                if result is False:
+                    return None
+                possible_zero = True
+        elif _bounded is None:
+            if result is None:
+                return None
+            if ask(Q.extended_nonzero(arg), assumptions) is None:
+                return None
+            if result is not False:
+                result = None
+        else:
+            if possible_zero:
+                return None
+            result = False
+    return result
+
+@FinitePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Unbounded ** NonZero -> Unbounded
+
+    * Bounded ** Bounded -> Bounded
+
+    * Abs()<=1 ** Positive -> Bounded
+
+    * Abs()>=1 ** Negative -> Bounded
+
+    * Otherwise unknown
+    """
+    if expr.base == E:
+        return ask(Q.finite(expr.exp), assumptions)
+
+    base_bounded = ask(Q.finite(expr.base), assumptions)
+    exp_bounded = ask(Q.finite(expr.exp), assumptions)
+    if base_bounded is None and exp_bounded is None:  # Common Case
+        return None
+    if base_bounded is False and ask(Q.extended_nonzero(expr.exp), assumptions):
+        return False
+    if base_bounded and exp_bounded:
+        is_base_zero = ask(Q.zero(expr.base),assumptions)
+        is_exp_negative = ask(Q.negative(expr.exp),assumptions)
+        if is_base_zero is True and is_exp_negative is True:
+            return False
+        if is_base_zero is not False and is_exp_negative is not False:
+            return None
+        return True
+    if (abs(expr.base) <= 1) == True and ask(Q.extended_positive(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and ask(Q.extended_negative(expr.exp), assumptions):
+        return True
+    if (abs(expr.base) >= 1) == True and exp_bounded is False:
+        return False
+    return None
+
+@FinitePredicate.register(exp)
+def _(expr, assumptions):
+    return ask(Q.finite(expr.exp), assumptions)
+
+@FinitePredicate.register(log)
+def _(expr, assumptions):
+    # After complex -> finite fact is registered to new assumption system,
+    # querying Q.infinite may be removed.
+    if ask(Q.infinite(expr.args[0]), assumptions):
+        return False
+    return ask(~Q.zero(expr.args[0]), assumptions)
+
+@FinitePredicate.register_many(cos, sin, Number, Pi, Exp1, GoldenRatio,
+    TribonacciConstant, ImaginaryUnit, sign)
+def _(expr, assumptions):
+    return True
+
+@FinitePredicate.register_many(ComplexInfinity, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@FinitePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# InfinitePredicate
+
+
+@InfinitePredicate.register(Expr)
+def _(expr, assumptions):
+    is_finite = Q.finite(expr)._eval_ask(assumptions)
+    if is_finite is None:
+        return None
+    return not is_finite
+
+
+# PositiveInfinitePredicate
+
+
+@PositiveInfinitePredicate.register(Infinity)
+def _(expr, assumptions):
+    return True
+
+
+@PositiveInfinitePredicate.register_many(NegativeInfinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False
+
+
+# NegativeInfinitePredicate
+
+
+@NegativeInfinitePredicate.register(NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+
+@NegativeInfinitePredicate.register_many(Infinity, ComplexInfinity)
+def _(expr, assumptions):
+    return False
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/common.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6e9f6f321be461c09b16c03b9cec5708404d21a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/common.py
@@ -0,0 +1,164 @@
+"""
+This module defines base class for handlers and some core handlers:
+``Q.commutative`` and ``Q.is_true``.
+"""
+
+from sympy.assumptions import Q, ask, AppliedPredicate
+from sympy.core import Basic, Symbol
+from sympy.core.logic import _fuzzy_group, fuzzy_and, fuzzy_or
+from sympy.core.numbers import NaN, Number
+from sympy.logic.boolalg import (And, BooleanTrue, BooleanFalse, conjuncts,
+    Equivalent, Implies, Not, Or)
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from ..predicates.common import CommutativePredicate, IsTruePredicate
+
+
+class AskHandler:
+    """Base class that all Ask Handlers must inherit."""
+    def __new__(cls, *args, **kwargs):
+        sympy_deprecation_warning(
+            """
+            The AskHandler system is deprecated. The AskHandler class should
+            be replaced with the multipledispatch handler of Predicate
+            """,
+            deprecated_since_version="1.8",
+            active_deprecations_target='deprecated-askhandler',
+        )
+        return super().__new__(cls, *args, **kwargs)
+
+
+class CommonHandler(AskHandler):
+    # Deprecated
+    """Defines some useful methods common to most Handlers. """
+
+    @staticmethod
+    def AlwaysTrue(expr, assumptions):
+        return True
+
+    @staticmethod
+    def AlwaysFalse(expr, assumptions):
+        return False
+
+    @staticmethod
+    def AlwaysNone(expr, assumptions):
+        return None
+
+    NaN = AlwaysFalse
+
+
+# CommutativePredicate
+
+@CommutativePredicate.register(Symbol)
+def _(expr, assumptions):
+    """Objects are expected to be commutative unless otherwise stated"""
+    assumps = conjuncts(assumptions)
+    if expr.is_commutative is not None:
+        return expr.is_commutative and not ~Q.commutative(expr) in assumps
+    if Q.commutative(expr) in assumps:
+        return True
+    elif ~Q.commutative(expr) in assumps:
+        return False
+    return True
+
+@CommutativePredicate.register(Basic)
+def _(expr, assumptions):
+    for arg in expr.args:
+        if not ask(Q.commutative(arg), assumptions):
+            return False
+    return True
+
+@CommutativePredicate.register(Number)
+def _(expr, assumptions):
+    return True
+
+@CommutativePredicate.register(NaN)
+def _(expr, assumptions):
+    return True
+
+
+# IsTruePredicate
+
+@IsTruePredicate.register(bool)
+def _(expr, assumptions):
+    return expr
+
+@IsTruePredicate.register(BooleanTrue)
+def _(expr, assumptions):
+    return True
+
+@IsTruePredicate.register(BooleanFalse)
+def _(expr, assumptions):
+    return False
+
+@IsTruePredicate.register(AppliedPredicate)
+def _(expr, assumptions):
+    return ask(expr, assumptions)
+
+@IsTruePredicate.register(Not)
+def _(expr, assumptions):
+    arg = expr.args[0]
+    if arg.is_Symbol:
+        # symbol used as abstract boolean object
+        return None
+    value = ask(arg, assumptions=assumptions)
+    if value in (True, False):
+        return not value
+    else:
+        return None
+
+@IsTruePredicate.register(Or)
+def _(expr, assumptions):
+    result = False
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is True:
+            return True
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(And)
+def _(expr, assumptions):
+    result = True
+    for arg in expr.args:
+        p = ask(arg, assumptions=assumptions)
+        if p is False:
+            return False
+        if p is None:
+            result = None
+    return result
+
+@IsTruePredicate.register(Implies)
+def _(expr, assumptions):
+    p, q = expr.args
+    return ask(~p | q, assumptions=assumptions)
+
+@IsTruePredicate.register(Equivalent)
+def _(expr, assumptions):
+    p, q = expr.args
+    pt = ask(p, assumptions=assumptions)
+    if pt is None:
+        return None
+    qt = ask(q, assumptions=assumptions)
+    if qt is None:
+        return None
+    return pt == qt
+
+
+#### Helper methods
+def test_closed_group(expr, assumptions, key):
+    """
+    Test for membership in a group with respect
+    to the current operation.
+    """
+    return _fuzzy_group(
+        (ask(key(a), assumptions) for a in expr.args), quick_exit=True)
+
+def ask_all(*queries, assumptions):
+    return fuzzy_and(
+        (ask(query, assumptions) for query in queries))
+
+def ask_any(*queries, assumptions):
+    return fuzzy_or(
+        (ask(query, assumptions) for query in queries))
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/matrices.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..3b20385360136629ea037eb7238c45b70ba57fd2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/matrices.py
@@ -0,0 +1,716 @@
+"""
+This module contains query handlers responsible for Matrices queries:
+Square, Symmetric, Invertible etc.
+"""
+
+from sympy.logic.boolalg import conjuncts
+from sympy.assumptions import Q, ask
+from sympy.assumptions.handlers import test_closed_group
+from sympy.matrices import MatrixBase
+from sympy.matrices.expressions import (BlockMatrix, BlockDiagMatrix, Determinant,
+    DiagMatrix, DiagonalMatrix, HadamardProduct, Identity, Inverse, MatAdd, MatMul,
+    MatPow, MatrixExpr, MatrixSlice, MatrixSymbol, OneMatrix, Trace, Transpose,
+    ZeroMatrix)
+from sympy.matrices.expressions.blockmatrix import reblock_2x2
+from sympy.matrices.expressions.factorizations import Factorization
+from sympy.matrices.expressions.fourier import DFT
+from sympy.core.logic import fuzzy_and
+from sympy.utilities.iterables import sift
+from sympy.core import Basic
+
+from ..predicates.matrices import (SquarePredicate, SymmetricPredicate,
+    InvertiblePredicate, OrthogonalPredicate, UnitaryPredicate,
+    FullRankPredicate, PositiveDefinitePredicate, UpperTriangularPredicate,
+    LowerTriangularPredicate, DiagonalPredicate, IntegerElementsPredicate,
+    RealElementsPredicate, ComplexElementsPredicate)
+
+
+def _Factorization(predicate, expr, assumptions):
+    if predicate in expr.predicates:
+        return True
+
+
+# SquarePredicate
+
+@SquarePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    return expr.shape[0] == expr.shape[1]
+
+
+# SymmetricPredicate
+
+@SymmetricPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.symmetric(arg), assumptions) for arg in mmul.args):
+        return True
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if len(mmul.args) >= 2 and mmul.args[0] == mmul.args[-1].T:
+        if len(mmul.args) == 2:
+            return True
+        return ask(Q.symmetric(MatMul(*mmul.args[1:-1])), assumptions)
+
+@SymmetricPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.symmetric(base), assumptions)
+    return None
+
+@SymmetricPredicate.register(MatAdd)
+def _(expr, assumptions):
+    return all(ask(Q.symmetric(arg), assumptions) for arg in expr.args)
+
+@SymmetricPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if Q.symmetric(expr) in conjuncts(assumptions):
+        return True
+
+@SymmetricPredicate.register_many(OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return ask(Q.square(expr), assumptions)
+
+@SymmetricPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.symmetric(expr.arg), assumptions)
+
+@SymmetricPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    # TODO: implement sathandlers system for the matrices.
+    # Now it duplicates the general fact: Implies(Q.diagonal, Q.symmetric).
+    if ask(Q.diagonal(expr), assumptions):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.symmetric(expr.parent), assumptions)
+
+@SymmetricPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+
+# InvertiblePredicate
+
+@InvertiblePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if all(ask(Q.invertible(arg), assumptions) for arg in mmul.args):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@InvertiblePredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.invertible(base), assumptions)
+    return None
+
+@InvertiblePredicate.register(MatAdd)
+def _(expr, assumptions):
+    return None
+
+@InvertiblePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.invertible(expr) in conjuncts(assumptions):
+        return True
+
+@InvertiblePredicate.register_many(Identity, Inverse)
+def _(expr, assumptions):
+    return True
+
+@InvertiblePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@InvertiblePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@InvertiblePredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.invertible(expr.arg), assumptions)
+
+@InvertiblePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.invertible(expr.parent), assumptions)
+
+@InvertiblePredicate.register(MatrixBase)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return expr.rank() == expr.rows
+
+@InvertiblePredicate.register(MatrixExpr)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    return None
+
+@InvertiblePredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if expr.blockshape == (1, 1):
+        return ask(Q.invertible(expr.blocks[0, 0]), assumptions)
+    expr = reblock_2x2(expr)
+    if expr.blockshape == (2, 2):
+        [[A, B], [C, D]] = expr.blocks.tolist()
+        if ask(Q.invertible(A), assumptions) == True:
+            invertible = ask(Q.invertible(D - C * A.I * B), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(B), assumptions) == True:
+            invertible = ask(Q.invertible(C - D * B.I * A), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(C), assumptions) == True:
+            invertible = ask(Q.invertible(B - A * C.I * D), assumptions)
+            if invertible is not None:
+                return invertible
+        if ask(Q.invertible(D), assumptions) == True:
+            invertible = ask(Q.invertible(A - B * D.I * C), assumptions)
+            if invertible is not None:
+                return invertible
+    return None
+
+@InvertiblePredicate.register(BlockDiagMatrix)
+def _(expr, assumptions):
+    if expr.rowblocksizes != expr.colblocksizes:
+        return None
+    return fuzzy_and([ask(Q.invertible(a), assumptions) for a in expr.diag])
+
+
+# OrthogonalPredicate
+
+@OrthogonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.orthogonal(arg), assumptions) for arg in mmul.args) and
+            factor == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@OrthogonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.orthogonal(base), assumptions)
+    return None
+
+@OrthogonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if (len(expr.args) == 1 and
+            ask(Q.orthogonal(expr.args[0]), assumptions)):
+        return True
+
+@OrthogonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.orthogonal(expr) in conjuncts(assumptions):
+        return True
+
+@OrthogonalPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@OrthogonalPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@OrthogonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.orthogonal(expr.arg), assumptions)
+
+@OrthogonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.orthogonal(expr.parent), assumptions)
+
+@OrthogonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.orthogonal, expr, assumptions)
+
+
+# UnitaryPredicate
+
+@UnitaryPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.unitary(arg), assumptions) for arg in mmul.args) and
+            abs(factor) == 1):
+        return True
+    if any(ask(Q.invertible(arg), assumptions) is False
+            for arg in mmul.args):
+        return False
+
+@UnitaryPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp:
+        return ask(Q.unitary(base), assumptions)
+    return None
+
+@UnitaryPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if (not expr.is_square or
+                    ask(Q.invertible(expr), assumptions) is False):
+        return False
+    if Q.unitary(expr) in conjuncts(assumptions):
+        return True
+
+@UnitaryPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.unitary(expr.arg), assumptions)
+
+@UnitaryPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.unitary(expr.parent), assumptions)
+
+@UnitaryPredicate.register_many(DFT, Identity)
+def _(expr, assumptions):
+    return True
+
+@UnitaryPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@UnitaryPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.unitary, expr, assumptions)
+
+
+# FullRankPredicate
+
+@FullRankPredicate.register(MatMul)
+def _(expr, assumptions):
+    if all(ask(Q.fullrank(arg), assumptions) for arg in expr.args):
+        return True
+
+@FullRankPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if int_exp and ask(~Q.negative(exp), assumptions):
+        return ask(Q.fullrank(base), assumptions)
+    return None
+
+@FullRankPredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@FullRankPredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@FullRankPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@FullRankPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.fullrank(expr.arg), assumptions)
+
+@FullRankPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if ask(Q.orthogonal(expr.parent), assumptions):
+        return True
+
+
+# PositiveDefinitePredicate
+
+@PositiveDefinitePredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, mmul = expr.as_coeff_mmul()
+    if (all(ask(Q.positive_definite(arg), assumptions)
+            for arg in mmul.args) and factor > 0):
+        return True
+    if (len(mmul.args) >= 2
+            and mmul.args[0] == mmul.args[-1].T
+            and ask(Q.fullrank(mmul.args[0]), assumptions)):
+        return ask(Q.positive_definite(
+            MatMul(*mmul.args[1:-1])), assumptions)
+
+@PositiveDefinitePredicate.register(MatPow)
+def _(expr, assumptions):
+    # a power of a positive definite matrix is positive definite
+    if ask(Q.positive_definite(expr.args[0]), assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.positive_definite(arg), assumptions)
+            for arg in expr.args):
+        return True
+
+@PositiveDefinitePredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if not expr.is_square:
+        return False
+    if Q.positive_definite(expr) in conjuncts(assumptions):
+        return True
+
+@PositiveDefinitePredicate.register(Identity)
+def _(expr, assumptions):
+    return True
+
+@PositiveDefinitePredicate.register(ZeroMatrix)
+def _(expr, assumptions):
+    return False
+
+@PositiveDefinitePredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@PositiveDefinitePredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.positive_definite(expr.arg), assumptions)
+
+@PositiveDefinitePredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.positive_definite(expr.parent), assumptions)
+
+
+# UpperTriangularPredicate
+
+@UpperTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.upper_triangular(m), assumptions) for m in matrices):
+        return True
+
+@UpperTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.upper_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@UpperTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.upper_triangular(base), assumptions)
+    return None
+
+@UpperTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.upper_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@UpperTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@UpperTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@UpperTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@UpperTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.upper_triangular(expr.parent), assumptions)
+
+@UpperTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.upper_triangular, expr, assumptions)
+
+# LowerTriangularPredicate
+
+@LowerTriangularPredicate.register(MatMul)
+def _(expr, assumptions):
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.lower_triangular(m), assumptions) for m in matrices):
+        return True
+
+@LowerTriangularPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.lower_triangular(arg), assumptions) for arg in expr.args):
+        return True
+
+@LowerTriangularPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.lower_triangular(base), assumptions)
+    return None
+
+@LowerTriangularPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if Q.lower_triangular(expr) in conjuncts(assumptions):
+        return True
+
+@LowerTriangularPredicate.register_many(Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@LowerTriangularPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@LowerTriangularPredicate.register(Transpose)
+def _(expr, assumptions):
+    return ask(Q.upper_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(Inverse)
+def _(expr, assumptions):
+    return ask(Q.lower_triangular(expr.arg), assumptions)
+
+@LowerTriangularPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.lower_triangular(expr.parent), assumptions)
+
+@LowerTriangularPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.lower_triangular, expr, assumptions)
+
+
+# DiagonalPredicate
+
+def _is_empty_or_1x1(expr):
+    return expr.shape in ((0, 0), (1, 1))
+
+@DiagonalPredicate.register(MatMul)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    factor, matrices = expr.as_coeff_matrices()
+    if all(ask(Q.diagonal(m), assumptions) for m in matrices):
+        return True
+
+@DiagonalPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.diagonal(base), assumptions)
+    return None
+
+@DiagonalPredicate.register(MatAdd)
+def _(expr, assumptions):
+    if all(ask(Q.diagonal(arg), assumptions) for arg in expr.args):
+        return True
+
+@DiagonalPredicate.register(MatrixSymbol)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if Q.diagonal(expr) in conjuncts(assumptions):
+        return True
+
+@DiagonalPredicate.register(OneMatrix)
+def _(expr, assumptions):
+    return expr.shape[0] == 1 and expr.shape[1] == 1
+
+@DiagonalPredicate.register_many(Inverse, Transpose)
+def _(expr, assumptions):
+    return ask(Q.diagonal(expr.arg), assumptions)
+
+@DiagonalPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    if _is_empty_or_1x1(expr):
+        return True
+    if not expr.on_diag:
+        return None
+    else:
+        return ask(Q.diagonal(expr.parent), assumptions)
+
+@DiagonalPredicate.register_many(DiagonalMatrix, DiagMatrix, Identity, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@DiagonalPredicate.register(Factorization)
+def _(expr, assumptions):
+    return _Factorization(Q.diagonal, expr, assumptions)
+
+
+# IntegerElementsPredicate
+
+def BM_elements(predicate, expr, assumptions):
+    """ Block Matrix elements. """
+    return all(ask(predicate(b), assumptions) for b in expr.blocks)
+
+def MS_elements(predicate, expr, assumptions):
+    """ Matrix Slice elements. """
+    return ask(predicate(expr.parent), assumptions)
+
+def MatMul_elements(matrix_predicate, scalar_predicate, expr, assumptions):
+    d = sift(expr.args, lambda x: isinstance(x, MatrixExpr))
+    factors, matrices = d[False], d[True]
+    return fuzzy_and([
+        test_closed_group(Basic(*factors), assumptions, scalar_predicate),
+        test_closed_group(Basic(*matrices), assumptions, matrix_predicate)])
+
+
+@IntegerElementsPredicate.register_many(Determinant, HadamardProduct, MatAdd,
+    Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.integer_elements)
+
+@IntegerElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    if exp.is_negative == False:
+        return ask(Q.integer_elements(base), assumptions)
+    return None
+
+@IntegerElementsPredicate.register_many(Identity, OneMatrix, ZeroMatrix)
+def _(expr, assumptions):
+    return True
+
+@IntegerElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.integer_elements, Q.integer, expr, assumptions)
+
+@IntegerElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.integer_elements, expr, assumptions)
+
+@IntegerElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.integer_elements, expr, assumptions)
+
+
+# RealElementsPredicate
+
+@RealElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.real_elements)
+
+@RealElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.real_elements(base), assumptions)
+    return None
+
+@RealElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.real_elements, Q.real, expr, assumptions)
+
+@RealElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.real_elements, expr, assumptions)
+
+@RealElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.real_elements, expr, assumptions)
+
+
+# ComplexElementsPredicate
+
+@ComplexElementsPredicate.register_many(Determinant, Factorization, HadamardProduct,
+    Inverse, MatAdd, Trace, Transpose)
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex_elements)
+
+@ComplexElementsPredicate.register(MatPow)
+def _(expr, assumptions):
+    # only for integer powers
+    base, exp = expr.args
+    int_exp = ask(Q.integer(exp), assumptions)
+    if not int_exp:
+        return None
+    non_negative = ask(~Q.negative(exp), assumptions)
+    if (non_negative or non_negative == False
+                        and ask(Q.invertible(base), assumptions)):
+        return ask(Q.complex_elements(base), assumptions)
+    return None
+
+@ComplexElementsPredicate.register(MatMul)
+def _(expr, assumptions):
+    return MatMul_elements(Q.complex_elements, Q.complex, expr, assumptions)
+
+@ComplexElementsPredicate.register(MatrixSlice)
+def _(expr, assumptions):
+    return MS_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(BlockMatrix)
+def _(expr, assumptions):
+    return BM_elements(Q.complex_elements, expr, assumptions)
+
+@ComplexElementsPredicate.register(DFT)
+def _(expr, assumptions):
+    return True
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/ntheory.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfe63ba6467ea6863c6112c5e35bb3a78191a23e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/ntheory.py
@@ -0,0 +1,279 @@
+"""
+Handlers for keys related to number theory: prime, even, odd, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Float, Mul, Pow, S
+from sympy.core.numbers import (ImaginaryUnit, Infinity, Integer, NaN,
+    NegativeInfinity, NumberSymbol, Rational, int_valued)
+from sympy.functions import Abs, im, re
+from sympy.ntheory import isprime
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.ntheory import (PrimePredicate, CompositePredicate,
+    EvenPredicate, OddPredicate)
+
+
+# PrimePredicate
+
+def _PrimePredicate_number(expr, assumptions):
+    # helper method
+    exact = not expr.atoms(Float)
+    try:
+        i = int(expr.round())
+        if (expr - i).equals(0) is False:
+            raise TypeError
+    except TypeError:
+        return False
+    if exact:
+        return isprime(i)
+    # when not exact, we won't give a True or False
+    # since the number represents an approximate value
+
+@PrimePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_prime
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PrimePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            return None
+    for arg in expr.args:
+        if arg.is_number and arg.is_composite:
+            return False
+
+@PrimePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Integer**Integer     -> !Prime
+    """
+    if expr.is_number:
+        return _PrimePredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions) and \
+            ask(Q.integer(expr.base), assumptions):
+        prime_base = ask(Q.prime(expr.base), assumptions)
+        if prime_base is False:
+            return False
+        is_exp_one = ask(Q.eq(expr.exp, 1), assumptions)
+        if is_exp_one is False:
+            return False
+        if prime_base is True and is_exp_one is True:
+            return True
+
+@PrimePredicate.register(Integer)
+def _(expr, assumptions):
+    return isprime(expr)
+
+@PrimePredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PrimePredicate.register(Float)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _PrimePredicate_number(expr, assumptions)
+
+@PrimePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# CompositePredicate
+
+@CompositePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_composite
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@CompositePredicate.register(Basic)
+def _(expr, assumptions):
+    _positive = ask(Q.positive(expr), assumptions)
+    if _positive:
+        _integer = ask(Q.integer(expr), assumptions)
+        if _integer:
+            _prime = ask(Q.prime(expr), assumptions)
+            if _prime is None:
+                return
+            # Positive integer which is not prime is not
+            # necessarily composite
+            _is_one = ask(Q.eq(expr, 1), assumptions)
+            if _is_one:
+                return False
+            if _is_one is None:
+                return None
+            return not _prime
+        else:
+            return _integer
+    else:
+        return _positive
+
+
+# EvenPredicate
+
+def _EvenPredicate_number(expr, assumptions):
+    # helper method
+    if isinstance(expr, (float, Float)):
+        if int_valued(expr):
+            return None
+        return False
+    try:
+        i = int(expr.round())
+    except TypeError:
+        return False
+    if not (expr - i).equals(0):
+        return False
+    return i % 2 == 0
+
+@EvenPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_even
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@EvenPredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    Even * Integer    -> Even
+    Even * Odd        -> Even
+    Integer * Odd     -> ?
+    Odd * Odd         -> Odd
+    Even * Even       -> Even
+    Integer * Integer -> Even if Integer + Integer = Odd
+    otherwise         -> ?
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    even, odd, irrational, acc = False, 0, False, 1
+    for arg in expr.args:
+        # check for all integers and at least one even
+        if ask(Q.integer(arg), assumptions):
+            if ask(Q.even(arg), assumptions):
+                even = True
+            elif ask(Q.odd(arg), assumptions):
+                odd += 1
+            elif not even and acc != 1:
+                if ask(Q.odd(acc + arg), assumptions):
+                    even = True
+        elif ask(Q.irrational(arg), assumptions):
+            # one irrational makes the result False
+            # two makes it undefined
+            if irrational:
+                break
+            irrational = True
+        else:
+            break
+        acc = arg
+    else:
+        if irrational:
+            return False
+        if even:
+            return True
+        if odd == len(expr.args):
+            return False
+
+@EvenPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Even + Odd  -> Odd
+    Even + Even -> Even
+    Odd  + Odd  -> Even
+
+    """
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    _result = True
+    for arg in expr.args:
+        if ask(Q.even(arg), assumptions):
+            pass
+        elif ask(Q.odd(arg), assumptions):
+            _result = not _result
+        else:
+            break
+    else:
+        return _result
+
+@EvenPredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _EvenPredicate_number(expr, assumptions)
+    if ask(Q.integer(expr.exp), assumptions):
+        if ask(Q.positive(expr.exp), assumptions):
+            return ask(Q.even(expr.base), assumptions)
+        elif ask(~Q.negative(expr.exp) & Q.odd(expr.base), assumptions):
+            return False
+        elif expr.base is S.NegativeOne:
+            return False
+
+@EvenPredicate.register(Integer)
+def _(expr, assumptions):
+    return not bool(expr.p & 1)
+
+@EvenPredicate.register_many(Rational, Infinity, NegativeInfinity, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@EvenPredicate.register(NumberSymbol)
+def _(expr, assumptions):
+    return _EvenPredicate_number(expr, assumptions)
+
+@EvenPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(re)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return ask(Q.even(expr.args[0]), assumptions)
+
+@EvenPredicate.register(im)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        return True
+
+@EvenPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# OddPredicate
+
+@OddPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_odd
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@OddPredicate.register(Basic)
+def _(expr, assumptions):
+    _integer = ask(Q.integer(expr), assumptions)
+    if _integer:
+        _even = ask(Q.even(expr), assumptions)
+        if _even is None:
+            return None
+        return not _even
+    return _integer
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/order.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/order.py
new file mode 100644
index 0000000000000000000000000000000000000000..24a8bae7f30777f62a1bec0579d58b9875143679
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/order.py
@@ -0,0 +1,440 @@
+"""
+Handlers related to order relations: positive, negative, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.logic import fuzzy_not, fuzzy_and, fuzzy_or
+from sympy.core.numbers import E, ImaginaryUnit, NaN, I, pi
+from sympy.functions import Abs, acos, acot, asin, atan, exp, factorial, log
+from sympy.matrices import Determinant, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from ..predicates.order import (NegativePredicate, NonNegativePredicate,
+    NonZeroPredicate, ZeroPredicate, NonPositivePredicate, PositivePredicate,
+    ExtendedNegativePredicate, ExtendedNonNegativePredicate,
+    ExtendedNonPositivePredicate, ExtendedNonZeroPredicate,
+    ExtendedPositivePredicate,)
+
+
+# NegativePredicate
+
+def _NegativePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+
+    if r == S.NaN or i == S.NaN:
+        return None
+
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r < 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r < 0
+
+@NegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+@NegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_negative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NegativePredicate.register(Add)
+def _(expr, assumptions):
+    """
+    Positive + Positive -> Positive,
+    Negative + Negative -> Negative
+    """
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonpos = 0
+    for arg in expr.args:
+        if ask(Q.negative(arg), assumptions) is not True:
+            if ask(Q.positive(arg), assumptions) is False:
+                nonpos += 1
+            else:
+                break
+    else:
+        if nonpos < len(expr.args):
+            return True
+
+@NegativePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    result = None
+    for arg in expr.args:
+        if result is None:
+            result = False
+        if ask(Q.negative(arg), assumptions):
+            result = not result
+        elif ask(Q.positive(arg), assumptions):
+            pass
+        else:
+            return
+    return result
+
+@NegativePredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    Real ** Even -> NonNegative
+    Real ** Odd  -> same_as_base
+    NonNegative ** Positive -> NonNegative
+    """
+    if expr.base == E:
+        # Exponential is always positive:
+        if ask(Q.real(expr.exp), assumptions):
+            return False
+        return
+
+    if expr.is_number:
+        return _NegativePredicate_number(expr, assumptions)
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            if ask(Q.real(expr.exp), assumptions):
+                return False
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        if ask(Q.odd(expr.exp), assumptions):
+            return ask(Q.negative(expr.base), assumptions)
+
+@NegativePredicate.register_many(Abs, ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@NegativePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return False
+    raise MDNotImplementedError
+
+
+# NonNegativePredicate
+
+@NonNegativePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notnegative = fuzzy_not(_NegativePredicate_number(expr, assumptions))
+        if notnegative:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notnegative
+
+@NonNegativePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonnegative
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+
+# NonZeroPredicate
+
+@NonZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonzero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    if ask(Q.real(expr)) is False:
+        return False
+    if expr.is_number:
+        # if there are no symbols just evalf
+        i = expr.evalf(2)
+        def nonz(i):
+            if i._prec != 1:
+                return i != 0
+        return fuzzy_or(nonz(i) for i in i.as_real_imag())
+
+@NonZeroPredicate.register(Add)
+def _(expr, assumptions):
+    if all(ask(Q.positive(x), assumptions) for x in expr.args) \
+            or all(ask(Q.negative(x), assumptions) for x in expr.args):
+        return True
+
+@NonZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    for arg in expr.args:
+        result = ask(Q.nonzero(arg), assumptions)
+        if result:
+            continue
+        return result
+    return True
+
+@NonZeroPredicate.register(Pow)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.base), assumptions)
+
+@NonZeroPredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr.args[0]), assumptions)
+
+@NonZeroPredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ZeroPredicate
+
+@ZeroPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_zero
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ZeroPredicate.register(Basic)
+def _(expr, assumptions):
+    return fuzzy_and([fuzzy_not(ask(Q.nonzero(expr), assumptions)),
+        ask(Q.real(expr), assumptions)])
+
+@ZeroPredicate.register(Mul)
+def _(expr, assumptions):
+    # TODO: This should be deducible from the nonzero handler
+    return fuzzy_or(ask(Q.zero(arg), assumptions) for arg in expr.args)
+
+
+# NonPositivePredicate
+
+@NonPositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_nonpositive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@NonPositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        notpositive = fuzzy_not(_PositivePredicate_number(expr, assumptions))
+        if notpositive:
+            return ask(Q.real(expr), assumptions)
+        else:
+            return notpositive
+
+
+# PositivePredicate
+
+def _PositivePredicate_number(expr, assumptions):
+    r, i = expr.as_real_imag()
+    # If the imaginary part can symbolically be shown to be zero then
+    # we just evaluate the real part; otherwise we evaluate the imaginary
+    # part to see if it actually evaluates to zero and if it does then
+    # we make the comparison between the real part and zero.
+    if not i:
+        r = r.evalf(2)
+        if r._prec != 1:
+            return r > 0
+    else:
+        i = i.evalf(2)
+        if i._prec != 1:
+            if i != 0:
+                return False
+            r = r.evalf(2)
+            if r._prec != 1:
+                return r > 0
+
+@PositivePredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_positive
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@PositivePredicate.register(Basic)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+@PositivePredicate.register(Mul)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions):
+            continue
+        elif ask(Q.negative(arg), assumptions):
+            result = result ^ True
+        else:
+            return
+    return result
+
+@PositivePredicate.register(Add)
+def _(expr, assumptions):
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+
+    r = ask(Q.real(expr), assumptions)
+    if r is not True:
+        return r
+
+    nonneg = 0
+    for arg in expr.args:
+        if ask(Q.positive(arg), assumptions) is not True:
+            if ask(Q.negative(arg), assumptions) is False:
+                nonneg += 1
+            else:
+                break
+    else:
+        if nonneg < len(expr.args):
+            return True
+
+@PositivePredicate.register(Pow)
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+        if ask(Q.imaginary(expr.exp), assumptions):
+            return ask(Q.even(expr.exp/(I*pi)), assumptions)
+        return
+
+    if expr.is_number:
+        return _PositivePredicate_number(expr, assumptions)
+    if ask(Q.positive(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            return True
+    if ask(Q.negative(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return True
+        if ask(Q.odd(expr.exp), assumptions):
+            return False
+
+@PositivePredicate.register(exp)
+def _(expr, assumptions):
+    if ask(Q.real(expr.exp), assumptions):
+        return True
+    if ask(Q.imaginary(expr.exp), assumptions):
+        return ask(Q.even(expr.exp/(I*pi)), assumptions)
+
+@PositivePredicate.register(log)
+def _(expr, assumptions):
+    r = ask(Q.real(expr.args[0]), assumptions)
+    if r is not True:
+        return r
+    if ask(Q.positive(expr.args[0] - 1), assumptions):
+        return True
+    if ask(Q.negative(expr.args[0] - 1), assumptions):
+        return False
+
+@PositivePredicate.register(factorial)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.integer(x) & Q.positive(x), assumptions):
+            return True
+
+@PositivePredicate.register(ImaginaryUnit)
+def _(expr, assumptions):
+    return False
+
+@PositivePredicate.register(Abs)
+def _(expr, assumptions):
+    return ask(Q.nonzero(expr), assumptions)
+
+@PositivePredicate.register(Trace)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(Determinant)
+def _(expr, assumptions):
+    if ask(Q.positive_definite(expr.arg), assumptions):
+        return True
+
+@PositivePredicate.register(MatrixElement)
+def _(expr, assumptions):
+    if (expr.i == expr.j
+            and ask(Q.positive_definite(expr.parent), assumptions)):
+        return True
+
+@PositivePredicate.register(atan)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@PositivePredicate.register(asin)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.positive(x) & Q.nonpositive(x - 1), assumptions):
+        return True
+    if ask(Q.negative(x) & Q.nonnegative(x + 1), assumptions):
+        return False
+
+@PositivePredicate.register(acos)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.nonpositive(x - 1) & Q.nonnegative(x + 1), assumptions):
+        return True
+
+@PositivePredicate.register(acot)
+def _(expr, assumptions):
+    return ask(Q.real(expr.args[0]), assumptions)
+
+@PositivePredicate.register(NaN)
+def _(expr, assumptions):
+    return None
+
+
+# ExtendedNegativePredicate
+
+@ExtendedNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative(expr) | Q.negative_infinite(expr), assumptions)
+
+
+# ExtendedPositivePredicate
+
+@ExtendedPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.positive(expr) | Q.positive_infinite(expr), assumptions)
+
+
+# ExtendedNonZeroPredicate
+
+@ExtendedNonZeroPredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)
+
+
+# ExtendedNonPositivePredicate
+
+@ExtendedNonPositivePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.negative_infinite(expr) | Q.negative(expr) | Q.zero(expr),
+        assumptions)
+
+
+# ExtendedNonNegativePredicate
+
+@ExtendedNonNegativePredicate.register(object)
+def _(expr, assumptions):
+    return ask(
+        Q.zero(expr) | Q.positive(expr) | Q.positive_infinite(expr),
+        assumptions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/sets.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/sets.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a13ed9bf99c5b0ffc4f32fd55cb60c2c15ab836
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/handlers/sets.py
@@ -0,0 +1,816 @@
+"""
+Handlers for predicates related to set membership: integer, rational, etc.
+"""
+
+from sympy.assumptions import Q, ask
+from sympy.core import Add, Basic, Expr, Mul, Pow, S
+from sympy.core.numbers import (AlgebraicNumber, ComplexInfinity, Exp1, Float,
+    GoldenRatio, ImaginaryUnit, Infinity, Integer, NaN, NegativeInfinity,
+    Number, NumberSymbol, Pi, pi, Rational, TribonacciConstant, E)
+from sympy.core.logic import fuzzy_bool
+from sympy.functions import (Abs, acos, acot, asin, atan, cos, cot, exp, im,
+    log, re, sin, tan)
+from sympy.core.numbers import I
+from sympy.core.relational import Eq
+from sympy.functions.elementary.complexes import conjugate
+from sympy.matrices import Determinant, MatrixBase, Trace
+from sympy.matrices.expressions.matexpr import MatrixElement
+
+from sympy.multipledispatch import MDNotImplementedError
+
+from .common import test_closed_group, ask_all, ask_any
+from ..predicates.sets import (IntegerPredicate, RationalPredicate,
+    IrrationalPredicate, RealPredicate, ExtendedRealPredicate,
+    HermitianPredicate, ComplexPredicate, ImaginaryPredicate,
+    AntihermitianPredicate, AlgebraicPredicate)
+
+
+# IntegerPredicate
+
+def _IntegerPredicate_number(expr, assumptions):
+    # helper function
+        try:
+            i = int(expr.round())
+            if not (expr - i).equals(0):
+                raise TypeError
+            return True
+        except TypeError:
+            return False
+
+@IntegerPredicate.register_many(int, Integer) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@IntegerPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+        NegativeInfinity, Pi, Rational, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@IntegerPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_integer
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IntegerPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Integer + Integer       -> Integer
+    * Integer + !Integer      -> !Integer
+    * !Integer + !Integer -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.integer)
+
+@IntegerPredicate.register(Pow)
+def _(expr,assumptions):
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    if ask_all(~Q.zero(expr.base), Q.finite(expr.base), Q.zero(expr.exp), assumptions=assumptions):
+        return True
+    if ask_all(Q.integer(expr.base), Q.integer(expr.exp), assumptions=assumptions):
+        if ask_any(Q.positive(expr.exp), Q.nonnegative(expr.exp) & ~Q.zero(expr.base), Q.zero(expr.base-1), Q.zero(expr.base+1), assumptions=assumptions):
+            return True
+
+@IntegerPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Integer*Integer      -> Integer
+    * Integer*Irrational   -> !Integer
+    * Odd/Even             -> !Integer
+    * Integer*Rational     -> ?
+    """
+    if expr.is_number:
+        return _IntegerPredicate_number(expr, assumptions)
+    _output = True
+    for arg in expr.args:
+        if not ask(Q.integer(arg), assumptions):
+            if arg.is_Rational:
+                if arg.q == 2:
+                    return ask(Q.even(2*expr), assumptions)
+                if ~(arg.q & 1):
+                    return None
+            elif ask(Q.irrational(arg), assumptions):
+                if _output:
+                    _output = False
+                else:
+                    return
+            else:
+                return
+
+    return _output
+
+@IntegerPredicate.register(Abs)
+def _(expr, assumptions):
+    if ask(Q.integer(expr.args[0]), assumptions):
+        return True
+
+@IntegerPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.integer_elements(expr.args[0]), assumptions)
+
+
+# RationalPredicate
+
+@RationalPredicate.register(Rational)
+def _(expr, assumptions):
+    return True
+
+@RationalPredicate.register(Float)
+def _(expr, assumptions):
+    return None
+
+@RationalPredicate.register_many(Exp1, GoldenRatio, ImaginaryUnit, Infinity,
+    NegativeInfinity, Pi, TribonacciConstant)
+def _(expr, assumptions):
+    return False
+
+@RationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_rational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RationalPredicate.register_many(Add, Mul)
+def _(expr, assumptions):
+    """
+    * Rational + Rational     -> Rational
+    * Rational + !Rational    -> !Rational
+    * !Rational + !Rational   -> ?
+    """
+    if expr.is_number:
+        if expr.as_real_imag()[1]:
+            return False
+    return test_closed_group(expr, assumptions, Q.rational)
+
+@RationalPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Rational ** Integer      -> Rational
+    * Irrational ** Rational   -> Irrational
+    * Rational ** Irrational   -> ?
+    """
+    if expr.base == E:
+        x = expr.exp
+        if ask(Q.rational(x), assumptions):
+            return ask(Q.zero(x), assumptions)
+        return
+
+    is_exp_integer = ask(Q.integer(expr.exp), assumptions)
+    if is_exp_integer:
+        is_base_rational = ask(Q.rational(expr.base),assumptions)
+        if is_base_rational:
+            is_base_zero = ask(Q.zero(expr.base),assumptions)
+            if is_base_zero is False:
+                return True
+            if is_base_zero and ask(Q.positive(expr.exp)):
+                return True
+        if ask(Q.algebraic(expr.base),assumptions) is False:
+            return ask(Q.zero(expr.exp), assumptions)
+        if ask(Q.irrational(expr.base),assumptions) and ask(Q.eq(expr.exp,-1)):
+            return False
+        return
+    elif ask(Q.rational(expr.exp), assumptions):
+        if ask(Q.prime(expr.base), assumptions) and is_exp_integer is False:
+            return False
+        if ask(Q.zero(expr.base)) and ask(Q.positive(expr.exp)):
+            return True
+        if ask(Q.eq(expr.base,1)):
+            return True
+
+@RationalPredicate.register_many(asin, atan, cos, sin, tan)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register(exp)
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@RationalPredicate.register_many(acot, cot)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return False
+
+@RationalPredicate.register_many(acos, log)
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.rational(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)
+
+
+# IrrationalPredicate
+
+@IrrationalPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_irrational
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@IrrationalPredicate.register(Basic)
+def _(expr, assumptions):
+    _real = ask(Q.real(expr), assumptions)
+    if _real:
+        _rational = ask(Q.rational(expr), assumptions)
+        if _rational is None:
+            return None
+        return not _rational
+    else:
+        return _real
+
+
+# RealPredicate
+
+def _RealPredicate_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    i = expr.as_real_imag()[1].evalf(2)
+    if i._prec != 1:
+        return not i
+    # allow None to be returned if we couldn't show for sure
+    # that i was 0
+
+@RealPredicate.register_many(Abs, Exp1, Float, GoldenRatio, im, Pi, Rational,
+    re, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@RealPredicate.register_many(ImaginaryUnit, Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return False
+
+@RealPredicate.register(Expr)
+def _(expr, assumptions):
+    ret = expr.is_real
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@RealPredicate.register(Add)
+def _(expr, assumptions):
+    """
+    * Real + Real              -> Real
+    * Real + (Complex & !Real) -> !Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    return test_closed_group(expr, assumptions, Q.real)
+
+@RealPredicate.register(Mul)
+def _(expr, assumptions):
+    """
+    * Real*Real               -> Real
+    * Real*Imaginary          -> !Real
+    * Imaginary*Imaginary     -> Real
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+    result = True
+    for arg in expr.args:
+        if ask(Q.real(arg), assumptions):
+            pass
+        elif ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        else:
+            break
+    else:
+        return result
+
+@RealPredicate.register(Pow)
+def _(expr, assumptions):
+    """
+    * Real**Integer              -> Real
+    * Positive**Real             -> Real
+    * Negative**Real             -> ?
+    * Real**(Integer/Even)       -> Real if base is nonnegative
+    * Real**(Integer/Odd)        -> Real
+    * Imaginary**(Integer/Even)  -> Real
+    * Imaginary**(Integer/Odd)   -> not Real
+    * Imaginary**Real            -> ? since Real could be 0 (giving real)
+                                    or 1 (giving imaginary)
+    * b**Imaginary               -> Real if log(b) is imaginary and b != 0
+                                    and exponent != integer multiple of
+                                    I*pi/log(b)
+    * Real**Real                 -> ? e.g. sqrt(-1) is imaginary and
+                                    sqrt(2) is not
+    """
+    if expr.is_number:
+        return _RealPredicate_number(expr, assumptions)
+
+    if expr.base == E:
+        return ask(
+            Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+        )
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return True
+        # If the i = (exp's arg)/(I*pi) is an integer or half-integer
+        # multiple of I*pi then 2*i will be an integer. In addition,
+        # exp(i*I*pi) = (-1)**i so the overall realness of the expr
+        # can be determined by replacing exp(i*I*pi) with (-1)**i.
+        i = expr.base.exp/I/pi
+        if ask(Q.integer(2*i), assumptions):
+            return ask(Q.real((S.NegativeOne**i)**expr.exp), assumptions)
+        return
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return not odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real, log(I) is imag;
+            # (2*I)**i -> complex, log(2*I) is not imag
+            return imlog
+
+    if ask(Q.real(expr.base), assumptions):
+        if ask(Q.real(expr.exp), assumptions):
+            if ask(Q.zero(expr.base), assumptions) is not False:
+                if ask(Q.positive(expr.exp), assumptions):
+                    return True
+                return
+            if expr.exp.is_Rational and \
+                    ask(Q.even(expr.exp.q), assumptions):
+                return ask(Q.positive(expr.base), assumptions)
+            elif ask(Q.integer(expr.exp), assumptions):
+                return True
+            elif ask(Q.positive(expr.base), assumptions):
+                return True
+
+@RealPredicate.register_many(cos, sin)
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+            return True
+
+@RealPredicate.register(exp)
+def _(expr, assumptions):
+    return ask(
+        Q.integer(expr.exp/I/pi) | Q.real(expr.exp), assumptions
+    )
+
+@RealPredicate.register(log)
+def _(expr, assumptions):
+    return ask(Q.positive(expr.args[0]), assumptions)
+
+@RealPredicate.register_many(Determinant, MatrixElement, Trace)
+def _(expr, assumptions):
+    return ask(Q.real_elements(expr.args[0]), assumptions)
+
+
+# ExtendedRealPredicate
+
+@ExtendedRealPredicate.register(object)
+def _(expr, assumptions):
+    return ask(Q.negative_infinite(expr)
+               | Q.negative(expr)
+               | Q.zero(expr)
+               | Q.positive(expr)
+               | Q.positive_infinite(expr),
+            assumptions)
+
+@ExtendedRealPredicate.register_many(Infinity, NegativeInfinity)
+def _(expr, assumptions):
+    return True
+
+@ExtendedRealPredicate.register_many(Add, Mul, Pow) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.extended_real)
+
+
+# HermitianPredicate
+
+@HermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    return ask(Q.real(expr), assumptions)
+
+@HermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian + Hermitian  -> Hermitian
+    * Hermitian + !Hermitian -> !Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.hermitian)
+
+@HermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> Hermitian
+    * Hermitian*Antihermitian     -> !Hermitian
+    * Antihermitian*Antihermitian -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = True
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@HermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer -> Hermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if expr.base == E:
+        if ask(Q.hermitian(expr.exp), assumptions):
+            return True
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register_many(cos, sin) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.args[0]), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.hermitian(expr.exp), assumptions):
+        return True
+    raise MDNotImplementedError
+
+@HermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# ComplexPredicate
+
+@ComplexPredicate.register_many(Abs, cos, exp, im, ImaginaryUnit, log, Number, # type:ignore
+    NumberSymbol, re, sin)
+def _(expr, assumptions):
+    return True
+
+@ComplexPredicate.register_many(Infinity, NegativeInfinity) # type:ignore
+def _(expr, assumptions):
+    return False
+
+@ComplexPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_complex
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ComplexPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        return True
+    return test_closed_group(expr, assumptions, Q.complex)
+
+@ComplexPredicate.register_many(Determinant, MatrixElement, Trace) # type:ignore
+def _(expr, assumptions):
+    return ask(Q.complex_elements(expr.args[0]), assumptions)
+
+@ComplexPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# ImaginaryPredicate
+
+def _Imaginary_number(expr, assumptions):
+    # let as_real_imag() work first since the expression may
+    # be simpler to evaluate
+    r = expr.as_real_imag()[0].evalf(2)
+    if r._prec != 1:
+        return not r
+    # allow None to be returned if we couldn't show for sure
+    # that r was 0
+
+@ImaginaryPredicate.register(ImaginaryUnit) # type:ignore
+def _(expr, assumptions):
+    return True
+
+@ImaginaryPredicate.register(Expr) # type:ignore
+def _(expr, assumptions):
+    ret = expr.is_imaginary
+    if ret is None:
+        raise MDNotImplementedError
+    return ret
+
+@ImaginaryPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary + Imaginary -> Imaginary
+    * Imaginary + Complex   -> ?
+    * Imaginary + Real      -> !Imaginary
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            pass
+        elif ask(Q.real(arg), assumptions):
+            reals += 1
+        else:
+            break
+    else:
+        if reals == 0:
+            return True
+        if reals in (1, len(expr.args)):
+            # two reals could sum 0 thus giving an imaginary
+            return False
+
+@ImaginaryPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    * Real*Imaginary      -> Imaginary
+    * Imaginary*Imaginary -> Real
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+    result = False
+    reals = 0
+    for arg in expr.args:
+        if ask(Q.imaginary(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.real(arg), assumptions):
+            break
+    else:
+        if reals == len(expr.args):
+            return False
+        return result
+
+@ImaginaryPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Imaginary**Odd        -> Imaginary
+    * Imaginary**Even       -> Real
+    * b**Imaginary          -> !Imaginary if exponent is an integer
+                               multiple of I*pi/log(b)
+    * Imaginary**Real       -> ?
+    * Positive**Real        -> Real
+    * Negative**Integer     -> Real
+    * Negative**(Integer/2) -> Imaginary
+    * Negative**Real        -> not Imaginary if exponent is not Rational
+    """
+    if expr.is_number:
+        return _Imaginary_number(expr, assumptions)
+
+    if expr.base == E:
+        a = expr.exp/I/pi
+        return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+    if expr.base.func == exp or (expr.base.is_Pow and expr.base.base == E):
+        if ask(Q.imaginary(expr.base.exp), assumptions):
+            if ask(Q.imaginary(expr.exp), assumptions):
+                return False
+            i = expr.base.exp/I/pi
+            if ask(Q.integer(2*i), assumptions):
+                return ask(Q.imaginary((S.NegativeOne**i)**expr.exp), assumptions)
+
+    if ask(Q.imaginary(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            odd = ask(Q.odd(expr.exp), assumptions)
+            if odd is not None:
+                return odd
+            return
+
+    if ask(Q.imaginary(expr.exp), assumptions):
+        imlog = ask(Q.imaginary(log(expr.base)), assumptions)
+        if imlog is not None:
+            # I**i -> real; (2*I)**i -> complex ==> not imaginary
+            return False
+
+    if ask(Q.real(expr.base) & Q.real(expr.exp), assumptions):
+        if ask(Q.positive(expr.base), assumptions):
+            return False
+        else:
+            rat = ask(Q.rational(expr.exp), assumptions)
+            if not rat:
+                return rat
+            if ask(Q.integer(expr.exp), assumptions):
+                return False
+            else:
+                half = ask(Q.integer(2*expr.exp), assumptions)
+                if half:
+                    return ask(Q.negative(expr.base), assumptions)
+                return half
+
+@ImaginaryPredicate.register(log) # type:ignore
+def _(expr, assumptions):
+    if ask(Q.real(expr.args[0]), assumptions):
+        if ask(Q.positive(expr.args[0]), assumptions):
+            return False
+        return
+    # XXX it should be enough to do
+    # return ask(Q.nonpositive(expr.args[0]), assumptions)
+    # but ask(Q.nonpositive(exp(x)), Q.imaginary(x)) -> None;
+    # it should return True since exp(x) will be either 0 or complex
+    if expr.args[0].func == exp or (expr.args[0].is_Pow and expr.args[0].base == E):
+        if expr.args[0].exp in [I, -I]:
+            return True
+    im = ask(Q.imaginary(expr.args[0]), assumptions)
+    if im is False:
+        return False
+
+@ImaginaryPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    a = expr.exp/I/pi
+    return ask(Q.integer(2*a) & ~Q.integer(a), assumptions)
+
+@ImaginaryPredicate.register_many(Number, NumberSymbol) # type:ignore
+def _(expr, assumptions):
+    return not (expr.as_real_imag()[1] == 0)
+
+@ImaginaryPredicate.register(NaN) # type:ignore
+def _(expr, assumptions):
+    return None
+
+
+# AntihermitianPredicate
+
+@AntihermitianPredicate.register(object) # type:ignore
+def _(expr, assumptions):
+    if isinstance(expr, MatrixBase):
+        return None
+    if ask(Q.zero(expr), assumptions):
+        return True
+    return ask(Q.imaginary(expr), assumptions)
+
+@AntihermitianPredicate.register(Add) # type:ignore
+def _(expr, assumptions):
+    """
+    * Antihermitian + Antihermitian  -> Antihermitian
+    * Antihermitian + !Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    return test_closed_group(expr, assumptions, Q.antihermitian)
+
+@AntihermitianPredicate.register(Mul) # type:ignore
+def _(expr, assumptions):
+    """
+    As long as there is at most only one noncommutative term:
+
+    * Hermitian*Hermitian         -> !Antihermitian
+    * Hermitian*Antihermitian     -> Antihermitian
+    * Antihermitian*Antihermitian -> !Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    nccount = 0
+    result = False
+    for arg in expr.args:
+        if ask(Q.antihermitian(arg), assumptions):
+            result = result ^ True
+        elif not ask(Q.hermitian(arg), assumptions):
+            break
+        if ask(~Q.commutative(arg), assumptions):
+            nccount += 1
+            if nccount > 1:
+                break
+    else:
+        return result
+
+@AntihermitianPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    """
+    * Hermitian**Integer  -> !Antihermitian
+    * Antihermitian**Even -> !Antihermitian
+    * Antihermitian**Odd  -> Antihermitian
+    """
+    if expr.is_number:
+        raise MDNotImplementedError
+    if ask(Q.hermitian(expr.base), assumptions):
+        if ask(Q.integer(expr.exp), assumptions):
+            return False
+    elif ask(Q.antihermitian(expr.base), assumptions):
+        if ask(Q.even(expr.exp), assumptions):
+            return False
+        elif ask(Q.odd(expr.exp), assumptions):
+            return True
+    raise MDNotImplementedError
+
+@AntihermitianPredicate.register(MatrixBase) # type:ignore
+def _(mat, assumptions):
+    rows, cols = mat.shape
+    ret_val = True
+    for i in range(rows):
+        for j in range(i, cols):
+            cond = fuzzy_bool(Eq(mat[i, j], -conjugate(mat[j, i])))
+            if cond is None:
+                ret_val = None
+            if cond == False:
+                return False
+    if ret_val is None:
+        raise MDNotImplementedError
+    return ret_val
+
+
+# AlgebraicPredicate
+
+@AlgebraicPredicate.register_many(AlgebraicNumber, Float, GoldenRatio, # type:ignore
+    ImaginaryUnit, TribonacciConstant)
+def _(expr, assumptions):
+    return True
+
+@AlgebraicPredicate.register_many(ComplexInfinity, Exp1, Infinity, # type:ignore
+    NegativeInfinity, Pi)
+def _(expr, assumptions):
+    return False
+
+@AlgebraicPredicate.register_many(Add, Mul) # type:ignore
+def _(expr, assumptions):
+    return test_closed_group(expr, assumptions, Q.algebraic)
+
+@AlgebraicPredicate.register(Pow) # type:ignore
+def _(expr, assumptions):
+    if expr.base == E:
+        if ask(Q.algebraic(expr.exp), assumptions):
+            return ask(~Q.nonzero(expr.exp), assumptions)
+        return
+    if expr.base == pi:
+        if ask(Q.integer(expr.exp), assumptions) and ask(Q.positive(expr.exp), assumptions):
+            return False
+        return
+    exp_rational = ask(Q.rational(expr.exp), assumptions)
+    base_algebraic = ask(Q.algebraic(expr.base), assumptions)
+    exp_algebraic = ask(Q.algebraic(expr.exp),assumptions)
+    if base_algebraic and exp_algebraic:
+        if exp_rational:
+            return True
+        # Check based on the Gelfond-Schneider theorem:
+        # If the base is algebraic and not equal to 0 or 1, and the exponent
+        # is irrational,then the result is transcendental.
+        if ask(Q.ne(expr.base,0) & Q.ne(expr.base,1)) and exp_rational is False:
+            return False
+
+@AlgebraicPredicate.register(Rational) # type:ignore
+def _(expr, assumptions):
+    return expr.q != 0
+
+@AlgebraicPredicate.register_many(asin, atan, cos, sin, tan) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register(exp) # type:ignore
+def _(expr, assumptions):
+    x = expr.exp
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x), assumptions)
+
+@AlgebraicPredicate.register_many(acot, cot) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return False
+
+@AlgebraicPredicate.register_many(acos, log) # type:ignore
+def _(expr, assumptions):
+    x = expr.args[0]
+    if ask(Q.algebraic(x), assumptions):
+        return ask(~Q.nonzero(x - 1), assumptions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/lra_satask.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/lra_satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..53afe3e5abe99109ec01a47f19f1a8a4c99c5628
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/lra_satask.py
@@ -0,0 +1,286 @@
+from sympy.assumptions.assume import global_assumptions
+from sympy.assumptions.cnf import CNF, EncodedCNF
+from sympy.assumptions.ask import Q
+from sympy.logic.inference import satisfiable
+from sympy.logic.algorithms.lra_theory import UnhandledInput, ALLOWED_PRED
+from sympy.matrices.kind import MatrixKind
+from sympy.core.kind import NumberKind
+from sympy.assumptions.assume import AppliedPredicate
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+
+
+def lra_satask(proposition, assumptions=True, context=global_assumptions):
+    """
+    Function to evaluate the proposition with assumptions using SAT algorithm
+    in conjunction with an Linear Real Arithmetic theory solver.
+
+    Used to handle inequalities. Should eventually be depreciated and combined
+    into satask, but infinity handling and other things need to be implemented
+    before that can happen.
+    """
+    props = CNF.from_prop(proposition)
+    _props = CNF.from_prop(~proposition)
+
+    cnf = CNF.from_prop(assumptions)
+    assumptions = EncodedCNF()
+    assumptions.from_cnf(cnf)
+
+    context_cnf = CNF()
+    if context:
+        context_cnf = context_cnf.extend(context)
+
+    assumptions.add_from_cnf(context_cnf)
+
+    return check_satisfiability(props, _props, assumptions)
+
+# Some predicates such as Q.prime can't be handled by lra_satask.
+# For example, (x > 0) & (x < 1) & Q.prime(x) is unsat but lra_satask would think it was sat.
+# WHITE_LIST is a list of predicates that can always be handled.
+WHITE_LIST = ALLOWED_PRED | {Q.positive, Q.negative, Q.zero, Q.nonzero, Q.nonpositive, Q.nonnegative,
+                                            Q.extended_positive, Q.extended_negative, Q.extended_nonpositive,
+                                            Q.extended_negative, Q.extended_nonzero, Q.negative_infinite,
+                                            Q.positive_infinite}
+
+
+def check_satisfiability(prop, _prop, factbase):
+    sat_true = factbase.copy()
+    sat_false = factbase.copy()
+    sat_true.add_from_cnf(prop)
+    sat_false.add_from_cnf(_prop)
+
+    all_pred, all_exprs = get_all_pred_and_expr_from_enc_cnf(sat_true)
+
+    for pred in all_pred:
+        if pred.function not in WHITE_LIST and pred.function != Q.ne:
+            raise UnhandledInput(f"LRASolver: {pred} is an unhandled predicate")
+    for expr in all_exprs:
+        if expr.kind == MatrixKind(NumberKind):
+            raise UnhandledInput(f"LRASolver: {expr} is of MatrixKind")
+        if expr == S.NaN:
+            raise UnhandledInput("LRASolver: nan")
+
+    # convert old assumptions into predicates and add them to sat_true and sat_false
+    # also check for unhandled predicates
+    for assm in extract_pred_from_old_assum(all_exprs):
+        n = len(sat_true.encoding)
+        if assm not in sat_true.encoding:
+            sat_true.encoding[assm] = n+1
+        sat_true.data.append([sat_true.encoding[assm]])
+
+        n = len(sat_false.encoding)
+        if assm not in sat_false.encoding:
+            sat_false.encoding[assm] = n+1
+        sat_false.data.append([sat_false.encoding[assm]])
+
+
+    sat_true = _preprocess(sat_true)
+    sat_false = _preprocess(sat_false)
+
+    can_be_true = satisfiable(sat_true, use_lra_theory=True) is not False
+    can_be_false = satisfiable(sat_false, use_lra_theory=True) is not False
+
+    if can_be_true and can_be_false:
+        return None
+
+    if can_be_true and not can_be_false:
+        return True
+
+    if not can_be_true and can_be_false:
+        return False
+
+    if not can_be_true and not can_be_false:
+        raise ValueError("Inconsistent assumptions")
+
+
+def _preprocess(enc_cnf):
+    """
+    Returns an encoded cnf with only Q.eq, Q.gt, Q.lt,
+    Q.ge, and Q.le predicate.
+
+    Converts every unequality into a disjunction of strict
+    inequalities. For example, x != 3 would become
+    x < 3 OR x > 3.
+
+    Also converts all negated Q.ne predicates into
+    equalities.
+    """
+
+    # loops through each literal in each clause
+    # to construct a new, preprocessed encodedCNF
+
+    enc_cnf = enc_cnf.copy()
+    cur_enc = 1
+    rev_encoding = {value: key for key, value in enc_cnf.encoding.items()}
+
+    new_encoding = {}
+    new_data = []
+    for clause in enc_cnf.data:
+        new_clause = []
+        for lit in clause:
+            if lit == 0:
+                new_clause.append(lit)
+                new_encoding[lit] = False
+                continue
+            prop = rev_encoding[abs(lit)]
+            negated = lit < 0
+            sign = (lit > 0) - (lit < 0)
+
+            prop = _pred_to_binrel(prop)
+
+            if not isinstance(prop, AppliedPredicate):
+                if prop not in new_encoding:
+                    new_encoding[prop] = cur_enc
+                    cur_enc += 1
+                lit = new_encoding[prop]
+                new_clause.append(sign*lit)
+                continue
+
+
+            if negated and prop.function == Q.eq:
+                negated = False
+                prop = Q.ne(*prop.arguments)
+
+            if prop.function == Q.ne:
+                arg1, arg2 = prop.arguments
+                if negated:
+                    new_prop = Q.eq(arg1, arg2)
+                    if new_prop not in new_encoding:
+                        new_encoding[new_prop] = cur_enc
+                        cur_enc += 1
+
+                    new_enc = new_encoding[new_prop]
+                    new_clause.append(new_enc)
+                    continue
+                else:
+                    new_props = (Q.gt(arg1, arg2), Q.lt(arg1, arg2))
+                    for new_prop in new_props:
+                        if new_prop not in new_encoding:
+                            new_encoding[new_prop] = cur_enc
+                            cur_enc += 1
+
+                        new_enc = new_encoding[new_prop]
+                        new_clause.append(new_enc)
+                    continue
+
+            if prop.function == Q.eq and negated:
+                assert False
+
+            if prop not in new_encoding:
+                new_encoding[prop] = cur_enc
+                cur_enc += 1
+            new_clause.append(new_encoding[prop]*sign)
+        new_data.append(new_clause)
+
+    assert len(new_encoding) >= cur_enc - 1
+
+    enc_cnf = EncodedCNF(new_data, new_encoding)
+    return enc_cnf
+
+
+def _pred_to_binrel(pred):
+    if not isinstance(pred, AppliedPredicate):
+        return pred
+
+    if pred.function in pred_to_pos_neg_zero:
+        f = pred_to_pos_neg_zero[pred.function]
+        if f is False:
+            return False
+        pred = f(pred.arguments[0])
+
+    if pred.function == Q.positive:
+        pred = Q.gt(pred.arguments[0], 0)
+    elif pred.function == Q.negative:
+        pred = Q.lt(pred.arguments[0], 0)
+    elif pred.function == Q.zero:
+        pred = Q.eq(pred.arguments[0], 0)
+    elif pred.function == Q.nonpositive:
+        pred = Q.le(pred.arguments[0], 0)
+    elif pred.function == Q.nonnegative:
+        pred = Q.ge(pred.arguments[0], 0)
+    elif pred.function == Q.nonzero:
+        pred = Q.ne(pred.arguments[0], 0)
+
+    return pred
+
+pred_to_pos_neg_zero = {
+    Q.extended_positive: Q.positive,
+    Q.extended_negative: Q.negative,
+    Q.extended_nonpositive: Q.nonpositive,
+    Q.extended_negative: Q.negative,
+    Q.extended_nonzero: Q.nonzero,
+    Q.negative_infinite: False,
+    Q.positive_infinite: False
+}
+
+def get_all_pred_and_expr_from_enc_cnf(enc_cnf):
+    all_exprs = set()
+    all_pred = set()
+    for pred in enc_cnf.encoding.keys():
+        if isinstance(pred, AppliedPredicate):
+            all_pred.add(pred)
+            all_exprs.update(pred.arguments)
+
+    return all_pred, all_exprs
+
+def extract_pred_from_old_assum(all_exprs):
+    """
+    Returns a list of relevant new assumption predicate
+    based on any old assumptions.
+
+    Raises an UnhandledInput exception if any of the assumptions are
+    unhandled.
+
+    Ignored predicate:
+    - commutative
+    - complex
+    - algebraic
+    - transcendental
+    - extended_real
+    - real
+    - all matrix predicate
+    - rational
+    - irrational
+
+    Example
+    =======
+    >>> from sympy.assumptions.lra_satask import extract_pred_from_old_assum
+    >>> from sympy import symbols
+    >>> x, y = symbols("x y", positive=True)
+    >>> extract_pred_from_old_assum([x, y, 2])
+    [Q.positive(x), Q.positive(y)]
+    """
+    ret = []
+    for expr in all_exprs:
+        if not hasattr(expr, "free_symbols"):
+            continue
+        if len(expr.free_symbols) == 0:
+            continue
+
+        if expr.is_real is not True:
+            raise UnhandledInput(f"LRASolver: {expr} must be real")
+        # test for I times imaginary variable; such expressions are considered real
+        if isinstance(expr, Mul) and any(arg.is_real is not True for arg in expr.args):
+            raise UnhandledInput(f"LRASolver: {expr} must be real")
+
+        if expr.is_integer == True and expr.is_zero != True:
+            raise UnhandledInput(f"LRASolver: {expr} is an integer")
+        if expr.is_integer == False:
+            raise UnhandledInput(f"LRASolver: {expr} can't be an integer")
+        if expr.is_rational == False:
+            raise UnhandledInput(f"LRASolver: {expr} is irational")
+
+        if expr.is_zero:
+            ret.append(Q.zero(expr))
+        elif expr.is_positive:
+            ret.append(Q.positive(expr))
+        elif expr.is_negative:
+            ret.append(Q.negative(expr))
+        elif expr.is_nonzero:
+            ret.append(Q.nonzero(expr))
+        elif expr.is_nonpositive:
+            ret.append(Q.nonpositive(expr))
+        elif expr.is_nonnegative:
+            ret.append(Q.nonnegative(expr))
+
+    return ret
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__init__.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e294544bfdce13633ecff762ff42861aa12719f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__init__.py
@@ -0,0 +1,5 @@
+"""
+Module to implement predicate classes.
+
+Class of every predicate registered to ``Q`` is defined here.
+"""
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2204f440303b49b474eeb1793f2fc5ddbc58e786
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/calculus.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/calculus.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90100f0484a3aa21bc14bcd830c5c4eac655b1b2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/calculus.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/common.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/common.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..536652ee088870ac898fe94f541a71545aa5940c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/common.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/matrices.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/matrices.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fe2fe59e2e76e8e8a9bd0d75e472f32c0d0e083
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/matrices.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/ntheory.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/ntheory.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a8c5cfb5efb0c6e9742e8d7caa03df36b9a9a46
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/ntheory.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/order.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/order.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3852902ee2124438b2cef738f24fdc4fb29071b1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/order.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/sets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/sets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0a70fa03d1c172890419f4342c51cd4fbb32cb84
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/__pycache__/sets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/calculus.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/calculus.py
new file mode 100644
index 0000000000000000000000000000000000000000..f300703788683c07649ee3a0afd6e9d4eabd4567
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/calculus.py
@@ -0,0 +1,82 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class FinitePredicate(Predicate):
+    """
+    Finite number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.finite(x)`` is true if ``x`` is a number but neither an infinity
+    nor a ``NaN``. In other words, ``ask(Q.finite(x))`` is true for all
+    numerical ``x`` having a bounded absolute value.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S, oo, I, zoo
+    >>> from sympy.abc import x
+    >>> ask(Q.finite(oo))
+    False
+    >>> ask(Q.finite(-oo))
+    False
+    >>> ask(Q.finite(zoo))
+    False
+    >>> ask(Q.finite(1))
+    True
+    >>> ask(Q.finite(2 + 3*I))
+    True
+    >>> ask(Q.finite(x), Q.positive(x))
+    True
+    >>> print(ask(Q.finite(S.NaN)))
+    None
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Finite
+
+    """
+    name = 'finite'
+    handler = Dispatcher(
+        "FiniteHandler",
+        doc=("Handler for Q.finite. Test that an expression is bounded respect"
+        " to all its variables.")
+    )
+
+
+class InfinitePredicate(Predicate):
+    """
+    Infinite number predicate.
+
+    ``Q.infinite(x)`` is true iff the absolute value of ``x`` is
+    infinity.
+
+    """
+    # TODO: Add examples
+    name = 'infinite'
+    handler = Dispatcher(
+        "InfiniteHandler",
+        doc="""Handler for Q.infinite key."""
+    )
+
+
+class PositiveInfinitePredicate(Predicate):
+    """
+    Positive infinity predicate.
+
+    ``Q.positive_infinite(x)`` is true iff ``x`` is positive infinity ``oo``.
+    """
+    name = 'positive_infinite'
+    handler = Dispatcher("PositiveInfiniteHandler")
+
+
+class NegativeInfinitePredicate(Predicate):
+    """
+    Negative infinity predicate.
+
+    ``Q.negative_infinite(x)`` is true iff ``x`` is negative infinity ``-oo``.
+    """
+    name = 'negative_infinite'
+    handler = Dispatcher("NegativeInfiniteHandler")
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/common.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..a53892747131b03636abeb8f563c4f76cf3e281e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/common.py
@@ -0,0 +1,81 @@
+from sympy.assumptions import Predicate, AppliedPredicate, Q
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.multipledispatch import Dispatcher
+
+
+class CommutativePredicate(Predicate):
+    """
+    Commutative predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.commutative(x))`` is true iff ``x`` commutes with any other
+    object with respect to multiplication operation.
+
+    """
+    # TODO: Add examples
+    name = 'commutative'
+    handler = Dispatcher("CommutativeHandler", doc="Handler for key 'commutative'.")
+
+
+binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+
+class IsTruePredicate(Predicate):
+    """
+    Generic predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.is_true(x))`` is true iff ``x`` is true. This only makes
+    sense if ``x`` is a boolean object.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> from sympy.abc import x, y
+    >>> ask(Q.is_true(True))
+    True
+
+    Wrapping another applied predicate just returns the applied predicate.
+
+    >>> Q.is_true(Q.even(x))
+    Q.even(x)
+
+    Wrapping binary relation classes in SymPy core returns applied binary
+    relational predicates.
+
+    >>> from sympy import Eq, Gt
+    >>> Q.is_true(Eq(x, y))
+    Q.eq(x, y)
+    >>> Q.is_true(Gt(x, y))
+    Q.gt(x, y)
+
+    Notes
+    =====
+
+    This class is designed to wrap the boolean objects so that they can
+    behave as if they are applied predicates. Consequently, wrapping another
+    applied predicate is unnecessary and thus it just returns the argument.
+    Also, binary relation classes in SymPy core have binary predicates to
+    represent themselves and thus wrapping them with ``Q.is_true`` converts them
+    to these applied predicates.
+
+    """
+    name = 'is_true'
+    handler = Dispatcher(
+        "IsTrueHandler",
+        doc="Wrapper allowing to query the truth value of a boolean expression."
+    )
+
+    def __call__(self, arg):
+        # No need to wrap another predicate
+        if isinstance(arg, AppliedPredicate):
+            return arg
+        # Convert relational predicates instead of wrapping them
+        if getattr(arg, "is_Relational", False):
+            pred = binrelpreds[type(arg)]
+            return pred(*arg.args)
+        return super().__call__(arg)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/matrices.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..151e78c4ff345800e1d2f17973fb0591b8d379d2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/matrices.py
@@ -0,0 +1,511 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+class SquarePredicate(Predicate):
+    """
+    Square matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.square(x)`` is true iff ``x`` is a square matrix. A square matrix
+    is a matrix with the same number of rows and columns.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('X', 2, 3)
+    >>> ask(Q.square(X))
+    True
+    >>> ask(Q.square(Y))
+    False
+    >>> ask(Q.square(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.square(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_matrix
+
+    """
+    name = 'square'
+    handler = Dispatcher("SquareHandler", doc="Handler for Q.square.")
+
+
+class SymmetricPredicate(Predicate):
+    """
+    Symmetric matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.symmetric(x)`` is true iff ``x`` is a square matrix and is equal to
+    its transpose. Every square diagonal matrix is a symmetric matrix.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z))
+    True
+    >>> ask(Q.symmetric(Y))
+    False
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_matrix
+
+    """
+    # TODO: Add handlers to make these keys work with
+    # actual matrices and add more examples in the docstring.
+    name = 'symmetric'
+    handler = Dispatcher("SymmetricHandler", doc="Handler for Q.symmetric.")
+
+
+class InvertiblePredicate(Predicate):
+    """
+    Invertible matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.invertible(x)`` is true iff ``x`` is an invertible matrix.
+    A square matrix is called invertible only if its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.invertible(X*Y), Q.invertible(X))
+    False
+    >>> ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z))
+    True
+    >>> ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Invertible_matrix
+
+    """
+    name = 'invertible'
+    handler = Dispatcher("InvertibleHandler", doc="Handler for Q.invertible.")
+
+
+class OrthogonalPredicate(Predicate):
+    """
+    Orthogonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.orthogonal(x)`` is true iff ``x`` is an orthogonal matrix.
+    A square matrix ``M`` is an orthogonal matrix if it satisfies
+    ``M^TM = MM^T = I`` where ``M^T`` is the transpose matrix of
+    ``M`` and ``I`` is an identity matrix. Note that an orthogonal
+    matrix is necessarily invertible.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.orthogonal(Y))
+    False
+    >>> ask(Q.orthogonal(X*Z*X), Q.orthogonal(X) & Q.orthogonal(Z))
+    True
+    >>> ask(Q.orthogonal(Identity(3)))
+    True
+    >>> ask(Q.invertible(X), Q.orthogonal(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Orthogonal_matrix
+
+    """
+    name = 'orthogonal'
+    handler = Dispatcher("OrthogonalHandler", doc="Handler for key 'orthogonal'.")
+
+
+class UnitaryPredicate(Predicate):
+    """
+    Unitary matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.unitary(x)`` is true iff ``x`` is a unitary matrix.
+    Unitary matrix is an analogue to orthogonal matrix. A square
+    matrix ``M`` with complex elements is unitary if :math:``M^TM = MM^T= I``
+    where :math:``M^T`` is the conjugate transpose matrix of ``M``.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.unitary(Y))
+    False
+    >>> ask(Q.unitary(X*Z*X), Q.unitary(X) & Q.unitary(Z))
+    True
+    >>> ask(Q.unitary(Identity(3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Unitary_matrix
+
+    """
+    name = 'unitary'
+    handler = Dispatcher("UnitaryHandler", doc="Handler for key 'unitary'.")
+
+
+class FullRankPredicate(Predicate):
+    """
+    Fullrank matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.fullrank(x)`` is true iff ``x`` is a full rank matrix.
+    A matrix is full rank if all rows and columns of the matrix
+    are linearly independent. A square matrix is full rank iff
+    its determinant is nonzero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.fullrank(X.T), Q.fullrank(X))
+    True
+    >>> ask(Q.fullrank(ZeroMatrix(3, 3)))
+    False
+    >>> ask(Q.fullrank(Identity(3)))
+    True
+
+    """
+    name = 'fullrank'
+    handler = Dispatcher("FullRankHandler", doc="Handler for key 'fullrank'.")
+
+
+class PositiveDefinitePredicate(Predicate):
+    r"""
+    Positive definite matrix predicate.
+
+    Explanation
+    ===========
+
+    If $M$ is a :math:`n \times n` symmetric real matrix, it is said
+    to be positive definite if :math:`Z^TMZ` is positive for
+    every non-zero column vector $Z$ of $n$ real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, Identity
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> Y = MatrixSymbol('Y', 2, 3)
+    >>> Z = MatrixSymbol('Z', 2, 2)
+    >>> ask(Q.positive_definite(Y))
+    False
+    >>> ask(Q.positive_definite(Identity(3)))
+    True
+    >>> ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+    ...     Q.positive_definite(Z))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Positive-definite_matrix
+
+    """
+    name = "positive_definite"
+    handler = Dispatcher("PositiveDefiniteHandler", doc="Handler for key 'positive_definite'.")
+
+
+class UpperTriangularPredicate(Predicate):
+    """
+    Upper triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called upper triangular matrix if :math:`M_{ij}=0`
+    for :math:`i>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.upper_triangular(Identity(3)))
+    True
+    >>> ask(Q.upper_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/UpperTriangularMatrix.html
+
+    """
+    name = "upper_triangular"
+    handler = Dispatcher("UpperTriangularHandler", doc="Handler for key 'upper_triangular'.")
+
+
+class LowerTriangularPredicate(Predicate):
+    """
+    Lower triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A matrix $M$ is called lower triangular matrix if :math:`M_{ij}=0`
+    for :math:`i>j`.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, ZeroMatrix, Identity
+    >>> ask(Q.lower_triangular(Identity(3)))
+    True
+    >>> ask(Q.lower_triangular(ZeroMatrix(3, 3)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/LowerTriangularMatrix.html
+
+    """
+    name = "lower_triangular"
+    handler = Dispatcher("LowerTriangularHandler", doc="Handler for key 'lower_triangular'.")
+
+
+class DiagonalPredicate(Predicate):
+    """
+    Diagonal matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.diagonal(x)`` is true iff ``x`` is a diagonal matrix. A diagonal
+    matrix is a matrix in which the entries outside the main diagonal
+    are all zero.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol, ZeroMatrix
+    >>> X = MatrixSymbol('X', 2, 2)
+    >>> ask(Q.diagonal(ZeroMatrix(3, 3)))
+    True
+    >>> ask(Q.diagonal(X), Q.lower_triangular(X) &
+    ...     Q.upper_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Diagonal_matrix
+
+    """
+    name = "diagonal"
+    handler = Dispatcher("DiagonalHandler", doc="Handler for key 'diagonal'.")
+
+
+class IntegerElementsPredicate(Predicate):
+    """
+    Integer elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer_elements(x)`` is true iff all the elements of ``x``
+    are integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    True
+
+    """
+    name = "integer_elements"
+    handler = Dispatcher("IntegerElementsHandler", doc="Handler for key 'integer_elements'.")
+
+
+class RealElementsPredicate(Predicate):
+    """
+    Real elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real_elements(x)`` is true iff all the elements of ``x``
+    are real numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.real(X[1, 2]), Q.real_elements(X))
+    True
+
+    """
+    name = "real_elements"
+    handler = Dispatcher("RealElementsHandler", doc="Handler for key 'real_elements'.")
+
+
+class ComplexElementsPredicate(Predicate):
+    """
+    Complex elements matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex_elements(x)`` is true iff all the elements of ``x``
+    are complex numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    True
+    >>> ask(Q.complex_elements(X), Q.integer_elements(X))
+    True
+
+    """
+    name = "complex_elements"
+    handler = Dispatcher("ComplexElementsHandler", doc="Handler for key 'complex_elements'.")
+
+
+class SingularPredicate(Predicate):
+    """
+    Singular matrix predicate.
+
+    A matrix is singular iff the value of its determinant is 0.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.singular(X), Q.invertible(X))
+    False
+    >>> ask(Q.singular(X), ~Q.invertible(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/SingularMatrix.html
+
+    """
+    name = "singular"
+    handler = Dispatcher("SingularHandler", doc="Predicate fore key 'singular'.")
+
+
+class NormalPredicate(Predicate):
+    """
+    Normal matrix predicate.
+
+    A matrix is normal if it commutes with its conjugate transpose.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.normal(X), Q.unitary(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Normal_matrix
+
+    """
+    name = "normal"
+    handler = Dispatcher("NormalHandler", doc="Predicate fore key 'normal'.")
+
+
+class TriangularPredicate(Predicate):
+    """
+    Triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    ``Q.triangular(X)`` is true if ``X`` is one that is either lower
+    triangular or upper triangular.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.upper_triangular(X))
+    True
+    >>> ask(Q.triangular(X), Q.lower_triangular(X))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Triangular_matrix
+
+    """
+    name = "triangular"
+    handler = Dispatcher("TriangularHandler", doc="Predicate fore key 'triangular'.")
+
+
+class UnitTriangularPredicate(Predicate):
+    """
+    Unit triangular matrix predicate.
+
+    Explanation
+    ===========
+
+    A unit triangular matrix is a triangular matrix with 1s
+    on the diagonal.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, MatrixSymbol
+    >>> X = MatrixSymbol('X', 4, 4)
+    >>> ask(Q.triangular(X), Q.unit_triangular(X))
+    True
+
+    """
+    name = "unit_triangular"
+    handler = Dispatcher("UnitTriangularHandler", doc="Predicate fore key 'unit_triangular'.")
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/ntheory.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..6c598e0ed1bd4a1170aa28044f9ae6de2fa1a1e0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/ntheory.py
@@ -0,0 +1,126 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class PrimePredicate(Predicate):
+    """
+    Prime number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.prime(x))`` is true iff ``x`` is a natural number greater
+    than 1 that has no positive divisors other than ``1`` and the
+    number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.prime(0))
+    False
+    >>> ask(Q.prime(1))
+    False
+    >>> ask(Q.prime(2))
+    True
+    >>> ask(Q.prime(20))
+    False
+    >>> ask(Q.prime(-3))
+    False
+
+    """
+    name = 'prime'
+    handler = Dispatcher(
+        "PrimeHandler",
+        doc=("Handler for key 'prime'. Test that an expression represents a prime"
+        " number. When the expression is an exact number, the result (when True)"
+        " is subject to the limitations of isprime() which is used to return the "
+        "result.")
+    )
+
+
+class CompositePredicate(Predicate):
+    """
+    Composite number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.composite(x))`` is true iff ``x`` is a positive integer and has
+    at least one positive divisor other than ``1`` and the number itself.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask
+    >>> ask(Q.composite(0))
+    False
+    >>> ask(Q.composite(1))
+    False
+    >>> ask(Q.composite(2))
+    False
+    >>> ask(Q.composite(20))
+    True
+
+    """
+    name = 'composite'
+    handler = Dispatcher("CompositeHandler", doc="Handler for key 'composite'.")
+
+
+class EvenPredicate(Predicate):
+    """
+    Even number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.even(x))`` is true iff ``x`` belongs to the set of even
+    integers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.even(0))
+    True
+    >>> ask(Q.even(2))
+    True
+    >>> ask(Q.even(3))
+    False
+    >>> ask(Q.even(pi))
+    False
+
+    """
+    name = 'even'
+    handler = Dispatcher("EvenHandler", doc="Handler for key 'even'.")
+
+
+class OddPredicate(Predicate):
+    """
+    Odd number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.odd(x))`` is true iff ``x`` belongs to the set of odd numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, pi
+    >>> ask(Q.odd(0))
+    False
+    >>> ask(Q.odd(2))
+    False
+    >>> ask(Q.odd(3))
+    True
+    >>> ask(Q.odd(pi))
+    False
+
+    """
+    name = 'odd'
+    handler = Dispatcher(
+        "OddHandler",
+        doc=("Handler for key 'odd'. Test that an expression represents an odd"
+        " number.")
+    )
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/order.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/order.py
new file mode 100644
index 0000000000000000000000000000000000000000..86bfb2ae49789efd5b0df99e2cfc63984e956dd0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/order.py
@@ -0,0 +1,390 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class NegativePredicate(Predicate):
+    r"""
+    Negative number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.negative(x)`` is true iff ``x`` is a real number and :math:`x < 0`, that is,
+    it is in the interval :math:`(-\infty, 0)`.  Note in particular that negative
+    infinity is not negative.
+
+    A few important facts about negative numbers:
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.negative(x), Q.real(x) & ~Q.positive(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.negative(-1))
+    True
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(~Q.negative(I))
+    True
+
+    """
+    name = 'negative'
+    handler = Dispatcher(
+        "NegativeHandler",
+        doc=("Handler for Q.negative. Test that an expression is strictly less"
+        " than zero.")
+    )
+
+
+class NonNegativePredicate(Predicate):
+    """
+    Nonnegative real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonnegative(x))`` is true iff ``x`` belongs to the set of
+    positive numbers including zero.
+
+    - Note that ``Q.nonnegative`` and ``~Q.negative`` are *not* the same
+        thing. ``~Q.negative(x)`` simply means that ``x`` is not negative,
+        whereas ``Q.nonnegative(x)`` means that ``x`` is real and not
+        negative, i.e., ``Q.nonnegative(x)`` is logically equivalent to
+        ``Q.zero(x) | Q.positive(x)``.  So for example, ``~Q.negative(I)`` is
+        true, whereas ``Q.nonnegative(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.nonnegative(1))
+    True
+    >>> ask(Q.nonnegative(0))
+    True
+    >>> ask(Q.nonnegative(-1))
+    False
+    >>> ask(Q.nonnegative(I))
+    False
+    >>> ask(Q.nonnegative(-I))
+    False
+
+    """
+    name = 'nonnegative'
+    handler = Dispatcher(
+        "NonNegativeHandler",
+        doc=("Handler for Q.nonnegative.")
+    )
+
+
+class NonZeroPredicate(Predicate):
+    """
+    Nonzero real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonzero(x))`` is true iff ``x`` is real and ``x`` is not zero.  Note in
+    particular that ``Q.nonzero(x)`` is false if ``x`` is not real.  Use
+    ``~Q.zero(x)`` if you want the negation of being zero without any real
+    assumptions.
+
+    A few important facts about nonzero numbers:
+
+    - ``Q.nonzero`` is logically equivalent to ``Q.positive | Q.negative``.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I, oo
+    >>> x = symbols('x')
+    >>> print(ask(Q.nonzero(x), ~Q.zero(x)))
+    None
+    >>> ask(Q.nonzero(x), Q.positive(x))
+    True
+    >>> ask(Q.nonzero(x), Q.zero(x))
+    False
+    >>> ask(Q.nonzero(0))
+    False
+    >>> ask(Q.nonzero(I))
+    False
+    >>> ask(~Q.zero(I))
+    True
+    >>> ask(Q.nonzero(oo))
+    False
+
+    """
+    name = 'nonzero'
+    handler = Dispatcher(
+        "NonZeroHandler",
+        doc=("Handler for key 'nonzero'. Test that an expression is not identically"
+        " zero.")
+    )
+
+
+class ZeroPredicate(Predicate):
+    """
+    Zero number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.zero(x))`` is true iff the value of ``x`` is zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, symbols
+    >>> x, y = symbols('x, y')
+    >>> ask(Q.zero(0))
+    True
+    >>> ask(Q.zero(1/oo))
+    True
+    >>> print(ask(Q.zero(0*oo)))
+    None
+    >>> ask(Q.zero(1))
+    False
+    >>> ask(Q.zero(x*y), Q.zero(x) | Q.zero(y))
+    True
+
+    """
+    name = 'zero'
+    handler = Dispatcher(
+        "ZeroHandler",
+        doc="Handler for key 'zero'."
+    )
+
+
+class NonPositivePredicate(Predicate):
+    """
+    Nonpositive real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.nonpositive(x))`` is true iff ``x`` belongs to the set of
+    negative numbers including zero.
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+
+    >>> ask(Q.nonpositive(-1))
+    True
+    >>> ask(Q.nonpositive(0))
+    True
+    >>> ask(Q.nonpositive(1))
+    False
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(Q.nonpositive(-I))
+    False
+
+    """
+    name = 'nonpositive'
+    handler = Dispatcher(
+        "NonPositiveHandler",
+        doc="Handler for key 'nonpositive'."
+    )
+
+
+class PositivePredicate(Predicate):
+    r"""
+    Positive real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.positive(x)`` is true iff ``x`` is real and `x > 0`, that is if ``x``
+    is in the interval `(0, \infty)`.  In particular, infinity is not
+    positive.
+
+    A few important facts about positive numbers:
+
+    - Note that ``Q.nonpositive`` and ``~Q.positive`` are *not* the same
+        thing. ``~Q.positive(x)`` simply means that ``x`` is not positive,
+        whereas ``Q.nonpositive(x)`` means that ``x`` is real and not
+        positive, i.e., ``Q.nonpositive(x)`` is logically equivalent to
+        `Q.negative(x) | Q.zero(x)``.  So for example, ``~Q.positive(I)`` is
+        true, whereas ``Q.nonpositive(I)`` is false.
+
+    - See the documentation of ``Q.real`` for more information about
+        related facts.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols, I
+    >>> x = symbols('x')
+    >>> ask(Q.positive(x), Q.real(x) & ~Q.negative(x) & ~Q.zero(x))
+    True
+    >>> ask(Q.positive(1))
+    True
+    >>> ask(Q.nonpositive(I))
+    False
+    >>> ask(~Q.positive(I))
+    True
+
+    """
+    name = 'positive'
+    handler = Dispatcher(
+        "PositiveHandler",
+        doc=("Handler for key 'positive'. Test that an expression is strictly"
+        " greater than zero.")
+    )
+
+
+class ExtendedPositivePredicate(Predicate):
+    r"""
+    Positive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_positive(x)`` is true iff ``x`` is extended real and
+    `x > 0`, that is if ``x`` is in the interval `(0, \infty]`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_positive(1))
+    True
+    >>> ask(Q.extended_positive(oo))
+    True
+    >>> ask(Q.extended_positive(I))
+    False
+
+    """
+    name = 'extended_positive'
+    handler = Dispatcher("ExtendedPositiveHandler")
+
+
+class ExtendedNegativePredicate(Predicate):
+    r"""
+    Negative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_negative(x)`` is true iff ``x`` is extended real and
+    `x < 0`, that is if ``x`` is in the interval `[-\infty, 0)`.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_negative(-1))
+    True
+    >>> ask(Q.extended_negative(-oo))
+    True
+    >>> ask(Q.extended_negative(-I))
+    False
+
+    """
+    name = 'extended_negative'
+    handler = Dispatcher("ExtendedNegativeHandler")
+
+
+class ExtendedNonZeroPredicate(Predicate):
+    """
+    Nonzero extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonzero(x))`` is true iff ``x`` is extended real and
+    ``x`` is not zero.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonzero(-1))
+    True
+    >>> ask(Q.extended_nonzero(oo))
+    True
+    >>> ask(Q.extended_nonzero(I))
+    False
+
+    """
+    name = 'extended_nonzero'
+    handler = Dispatcher("ExtendedNonZeroHandler")
+
+
+class ExtendedNonPositivePredicate(Predicate):
+    """
+    Nonpositive extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonpositive(x))`` is true iff ``x`` is extended real and
+    ``x`` is not positive.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonpositive(-1))
+    True
+    >>> ask(Q.extended_nonpositive(oo))
+    False
+    >>> ask(Q.extended_nonpositive(0))
+    True
+    >>> ask(Q.extended_nonpositive(I))
+    False
+
+    """
+    name = 'extended_nonpositive'
+    handler = Dispatcher("ExtendedNonPositiveHandler")
+
+
+class ExtendedNonNegativePredicate(Predicate):
+    """
+    Nonnegative extended real number predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.extended_nonnegative(x))`` is true iff ``x`` is extended real and
+    ``x`` is not negative.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, I, oo, Q
+    >>> ask(Q.extended_nonnegative(-1))
+    False
+    >>> ask(Q.extended_nonnegative(oo))
+    True
+    >>> ask(Q.extended_nonnegative(0))
+    True
+    >>> ask(Q.extended_nonnegative(I))
+    False
+
+    """
+    name = 'extended_nonnegative'
+    handler = Dispatcher("ExtendedNonNegativeHandler")
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/sets.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/sets.py
new file mode 100644
index 0000000000000000000000000000000000000000..18261cee2d9de65df14a31a56b2cd22328328ed0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/predicates/sets.py
@@ -0,0 +1,399 @@
+from sympy.assumptions import Predicate
+from sympy.multipledispatch import Dispatcher
+
+
+class IntegerPredicate(Predicate):
+    """
+    Integer predicate.
+
+    Explanation
+    ===========
+
+    ``Q.integer(x)`` is true iff ``x`` belongs to the set of integer
+    numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, S
+    >>> ask(Q.integer(5))
+    True
+    >>> ask(Q.integer(S(1)/2))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Integer
+
+    """
+    name = 'integer'
+    handler = Dispatcher(
+        "IntegerHandler",
+        doc=("Handler for Q.integer.\n\n"
+        "Test that an expression belongs to the field of integer numbers.")
+    )
+
+
+class NonIntegerPredicate(Predicate):
+    """
+    Non-integer extended real predicate.
+    """
+    name = 'noninteger'
+    handler = Dispatcher(
+        "NonIntegerHandler",
+        doc=("Handler for Q.noninteger.\n\n"
+        "Test that an expression is a non-integer extended real number.")
+    )
+
+
+class RationalPredicate(Predicate):
+    """
+    Rational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.rational(x)`` is true iff ``x`` belongs to the set of
+    rational numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S
+    >>> ask(Q.rational(0))
+    True
+    >>> ask(Q.rational(S(1)/2))
+    True
+    >>> ask(Q.rational(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Rational_number
+
+    """
+    name = 'rational'
+    handler = Dispatcher(
+        "RationalHandler",
+        doc=("Handler for Q.rational.\n\n"
+        "Test that an expression belongs to the field of rational numbers.")
+    )
+
+
+class IrrationalPredicate(Predicate):
+    """
+    Irrational number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.irrational(x)`` is true iff ``x``  is any real number that
+    cannot be expressed as a ratio of integers.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, pi, S, I
+    >>> ask(Q.irrational(0))
+    False
+    >>> ask(Q.irrational(S(1)/2))
+    False
+    >>> ask(Q.irrational(pi))
+    True
+    >>> ask(Q.irrational(I))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Irrational_number
+
+    """
+    name = 'irrational'
+    handler = Dispatcher(
+        "IrrationalHandler",
+        doc=("Handler for Q.irrational.\n\n"
+        "Test that an expression is irrational numbers.")
+    )
+
+
+class RealPredicate(Predicate):
+    r"""
+    Real number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.real(x)`` is true iff ``x`` is a real number, i.e., it is in the
+    interval `(-\infty, \infty)`.  Note that, in particular the
+    infinities are not real. Use ``Q.extended_real`` if you want to
+    consider those as well.
+
+    A few important facts about reals:
+
+    - Every real number is positive, negative, or zero.  Furthermore,
+        because these sets are pairwise disjoint, each real number is
+        exactly one of those three.
+
+    - Every real number is also complex.
+
+    - Every real number is finite.
+
+    - Every real number is either rational or irrational.
+
+    - Every real number is either algebraic or transcendental.
+
+    - The facts ``Q.negative``, ``Q.zero``, ``Q.positive``,
+        ``Q.nonnegative``, ``Q.nonpositive``, ``Q.nonzero``,
+        ``Q.integer``, ``Q.rational``, and ``Q.irrational`` all imply
+        ``Q.real``, as do all facts that imply those facts.
+
+    - The facts ``Q.algebraic``, and ``Q.transcendental`` do not imply
+        ``Q.real``; they imply ``Q.complex``. An algebraic or
+        transcendental number may or may not be real.
+
+    - The "non" facts (i.e., ``Q.nonnegative``, ``Q.nonzero``,
+        ``Q.nonpositive`` and ``Q.noninteger``) are not equivalent to
+        not the fact, but rather, not the fact *and* ``Q.real``.
+        For example, ``Q.nonnegative`` means ``~Q.negative & Q.real``.
+        So for example, ``I`` is not nonnegative, nonzero, or
+        nonpositive.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, symbols
+    >>> x = symbols('x')
+    >>> ask(Q.real(x), Q.positive(x))
+    True
+    >>> ask(Q.real(0))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Real_number
+
+    """
+    name = 'real'
+    handler = Dispatcher(
+        "RealHandler",
+        doc=("Handler for Q.real.\n\n"
+        "Test that an expression belongs to the field of real numbers.")
+    )
+
+
+class ExtendedRealPredicate(Predicate):
+    r"""
+    Extended real predicate.
+
+    Explanation
+    ===========
+
+    ``Q.extended_real(x)`` is true iff ``x`` is a real number or
+    `\{-\infty, \infty\}`.
+
+    See documentation of ``Q.real`` for more information about related
+    facts.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, oo, I
+    >>> ask(Q.extended_real(1))
+    True
+    >>> ask(Q.extended_real(I))
+    False
+    >>> ask(Q.extended_real(oo))
+    True
+
+    """
+    name = 'extended_real'
+    handler = Dispatcher(
+        "ExtendedRealHandler",
+        doc=("Handler for Q.extended_real.\n\n"
+        "Test that an expression belongs to the field of extended real\n"
+        "numbers, that is real numbers union {Infinity, -Infinity}.")
+    )
+
+
+class HermitianPredicate(Predicate):
+    """
+    Hermitian predicate.
+
+    Explanation
+    ===========
+
+    ``ask(Q.hermitian(x))`` is true iff ``x`` belongs to the set of
+    Hermitian operators.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'hermitian'
+    handler = Dispatcher(
+        "HermitianHandler",
+        doc=("Handler for Q.hermitian.\n\n"
+        "Test that an expression belongs to the field of Hermitian operators.")
+    )
+
+
+class ComplexPredicate(Predicate):
+    """
+    Complex number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.complex(x)`` is true iff ``x`` belongs to the set of complex
+    numbers. Note that every complex number is finite.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Symbol, ask, I, oo
+    >>> x = Symbol('x')
+    >>> ask(Q.complex(0))
+    True
+    >>> ask(Q.complex(2 + 3*I))
+    True
+    >>> ask(Q.complex(oo))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_number
+
+    """
+    name = 'complex'
+    handler = Dispatcher(
+        "ComplexHandler",
+        doc=("Handler for Q.complex.\n\n"
+        "Test that an expression belongs to the field of complex numbers.")
+    )
+
+
+class ImaginaryPredicate(Predicate):
+    """
+    Imaginary number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.imaginary(x)`` is true iff ``x`` can be written as a real
+    number multiplied by the imaginary unit ``I``. Please note that ``0``
+    is not considered to be an imaginary number.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, ask, I
+    >>> ask(Q.imaginary(3*I))
+    True
+    >>> ask(Q.imaginary(2 + 3*I))
+    False
+    >>> ask(Q.imaginary(0))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Imaginary_number
+
+    """
+    name = 'imaginary'
+    handler = Dispatcher(
+        "ImaginaryHandler",
+        doc=("Handler for Q.imaginary.\n\n"
+        "Test that an expression belongs to the field of imaginary numbers,\n"
+        "that is, numbers in the form x*I, where x is real.")
+    )
+
+
+class AntihermitianPredicate(Predicate):
+    """
+    Antihermitian predicate.
+
+    Explanation
+    ===========
+
+    ``Q.antihermitian(x)`` is true iff ``x`` belongs to the field of
+    antihermitian operators, i.e., operators in the form ``x*I``, where
+    ``x`` is Hermitian.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HermitianOperator.html
+
+    """
+    # TODO: Add examples
+    name = 'antihermitian'
+    handler = Dispatcher(
+        "AntiHermitianHandler",
+        doc=("Handler for Q.antihermitian.\n\n"
+        "Test that an expression belongs to the field of anti-Hermitian\n"
+        "operators, that is, operators in the form x*I, where x is Hermitian.")
+    )
+
+
+class AlgebraicPredicate(Predicate):
+    r"""
+    Algebraic number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.algebraic(x)`` is true iff ``x`` belongs to the set of
+    algebraic numbers. ``x`` is algebraic if there is some polynomial
+    in ``p(x)\in \mathbb\{Q\}[x]`` such that ``p(x) = 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q, sqrt, I, pi
+    >>> ask(Q.algebraic(sqrt(2)))
+    True
+    >>> ask(Q.algebraic(I))
+    True
+    >>> ask(Q.algebraic(pi))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Algebraic_number
+
+    """
+    name = 'algebraic'
+    AlgebraicHandler = Dispatcher(
+        "AlgebraicHandler",
+        doc="""Handler for Q.algebraic key."""
+    )
+
+
+class TranscendentalPredicate(Predicate):
+    """
+    Transcedental number predicate.
+
+    Explanation
+    ===========
+
+    ``Q.transcendental(x)`` is true iff ``x`` belongs to the set of
+    transcendental numbers. A transcendental number is a real
+    or complex number that is not algebraic.
+
+    """
+    # TODO: Add examples
+    name = 'transcendental'
+    handler = Dispatcher(
+        "Transcendental",
+        doc="""Handler for Q.transcendental key."""
+    )
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/refine.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/refine.py
new file mode 100644
index 0000000000000000000000000000000000000000..c36a4e1cdb40f1b59a96f60a3b36182b587920fa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/refine.py
@@ -0,0 +1,405 @@
+from __future__ import annotations
+from typing import Callable
+
+from sympy.core import S, Add, Expr, Basic, Mul, Pow, Rational
+from sympy.core.logic import fuzzy_not
+from sympy.logic.boolalg import Boolean
+
+from sympy.assumptions import ask, Q  # type: ignore
+
+
+def refine(expr, assumptions=True):
+    """
+    Simplify an expression using assumptions.
+
+    Explanation
+    ===========
+
+    Unlike :func:`~.simplify` which performs structural simplification
+    without any assumption, this function transforms the expression into
+    the form which is only valid under certain assumptions. Note that
+    ``simplify()`` is generally not done in refining process.
+
+    Refining boolean expression involves reducing it to ``S.true`` or
+    ``S.false``. Unlike :func:`~.ask`, the expression will not be reduced
+    if the truth value cannot be determined.
+
+    Examples
+    ========
+
+    >>> from sympy import refine, sqrt, Q
+    >>> from sympy.abc import x
+    >>> refine(sqrt(x**2), Q.real(x))
+    Abs(x)
+    >>> refine(sqrt(x**2), Q.positive(x))
+    x
+
+    >>> refine(Q.real(x), Q.positive(x))
+    True
+    >>> refine(Q.positive(x), Q.real(x))
+    Q.positive(x)
+
+    See Also
+    ========
+
+    sympy.simplify.simplify.simplify : Structural simplification without assumptions.
+    sympy.assumptions.ask.ask : Query for boolean expressions using assumptions.
+    """
+    if not isinstance(expr, Basic):
+        return expr
+
+    if not expr.is_Atom:
+        args = [refine(arg, assumptions) for arg in expr.args]
+        # TODO: this will probably not work with Integral or Polynomial
+        expr = expr.func(*args)
+    if hasattr(expr, '_eval_refine'):
+        ref_expr = expr._eval_refine(assumptions)
+        if ref_expr is not None:
+            return ref_expr
+    name = expr.__class__.__name__
+    handler = handlers_dict.get(name, None)
+    if handler is None:
+        return expr
+    new_expr = handler(expr, assumptions)
+    if (new_expr is None) or (expr == new_expr):
+        return expr
+    if not isinstance(new_expr, Expr):
+        return new_expr
+    return refine(new_expr, assumptions)
+
+
+def refine_abs(expr, assumptions):
+    """
+    Handler for the absolute value.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Abs
+    >>> from sympy.assumptions.refine import refine_abs
+    >>> from sympy.abc import x
+    >>> refine_abs(Abs(x), Q.real(x))
+    >>> refine_abs(Abs(x), Q.positive(x))
+    x
+    >>> refine_abs(Abs(x), Q.negative(x))
+    -x
+
+    """
+    from sympy.functions.elementary.complexes import Abs
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions) and \
+            fuzzy_not(ask(Q.negative(arg), assumptions)):
+        # if it's nonnegative
+        return arg
+    if ask(Q.negative(arg), assumptions):
+        return -arg
+    # arg is Mul
+    if isinstance(arg, Mul):
+        r = [refine(abs(a), assumptions) for a in arg.args]
+        non_abs = []
+        in_abs = []
+        for i in r:
+            if isinstance(i, Abs):
+                in_abs.append(i.args[0])
+            else:
+                non_abs.append(i)
+        return Mul(*non_abs) * Abs(Mul(*in_abs))
+
+
+def refine_Pow(expr, assumptions):
+    """
+    Handler for instances of Pow.
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.refine import refine_Pow
+    >>> from sympy.abc import x,y,z
+    >>> refine_Pow((-1)**x, Q.real(x))
+    >>> refine_Pow((-1)**x, Q.even(x))
+    1
+    >>> refine_Pow((-1)**x, Q.odd(x))
+    -1
+
+    For powers of -1, even parts of the exponent can be simplified:
+
+    >>> refine_Pow((-1)**(x+y), Q.even(x))
+    (-1)**y
+    >>> refine_Pow((-1)**(x+y+z), Q.odd(x) & Q.odd(z))
+    (-1)**y
+    >>> refine_Pow((-1)**(x+y+2), Q.odd(x))
+    (-1)**(y + 1)
+    >>> refine_Pow((-1)**(x+3), True)
+    (-1)**(x + 1)
+
+    """
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.functions import sign
+    if isinstance(expr.base, Abs):
+        if ask(Q.real(expr.base.args[0]), assumptions) and \
+                ask(Q.even(expr.exp), assumptions):
+            return expr.base.args[0] ** expr.exp
+    if ask(Q.real(expr.base), assumptions):
+        if expr.base.is_number:
+            if ask(Q.even(expr.exp), assumptions):
+                return abs(expr.base) ** expr.exp
+            if ask(Q.odd(expr.exp), assumptions):
+                return sign(expr.base) * abs(expr.base) ** expr.exp
+        if isinstance(expr.exp, Rational):
+            if isinstance(expr.base, Pow):
+                return abs(expr.base.base) ** (expr.base.exp * expr.exp)
+
+        if expr.base is S.NegativeOne:
+            if expr.exp.is_Add:
+
+                old = expr
+
+                # For powers of (-1) we can remove
+                #  - even terms
+                #  - pairs of odd terms
+                #  - a single odd term + 1
+                #  - A numerical constant N can be replaced with mod(N,2)
+
+                coeff, terms = expr.exp.as_coeff_add()
+                terms = set(terms)
+                even_terms = set()
+                odd_terms = set()
+                initial_number_of_terms = len(terms)
+
+                for t in terms:
+                    if ask(Q.even(t), assumptions):
+                        even_terms.add(t)
+                    elif ask(Q.odd(t), assumptions):
+                        odd_terms.add(t)
+
+                terms -= even_terms
+                if len(odd_terms) % 2:
+                    terms -= odd_terms
+                    new_coeff = (coeff + S.One) % 2
+                else:
+                    terms -= odd_terms
+                    new_coeff = coeff % 2
+
+                if new_coeff != coeff or len(terms) < initial_number_of_terms:
+                    terms.add(new_coeff)
+                    expr = expr.base**(Add(*terms))
+
+                # Handle (-1)**((-1)**n/2 + m/2)
+                e2 = 2*expr.exp
+                if ask(Q.even(e2), assumptions):
+                    if e2.could_extract_minus_sign():
+                        e2 *= expr.base
+                if e2.is_Add:
+                    i, p = e2.as_two_terms()
+                    if p.is_Pow and p.base is S.NegativeOne:
+                        if ask(Q.integer(p.exp), assumptions):
+                            i = (i + 1)/2
+                            if ask(Q.even(i), assumptions):
+                                return expr.base**p.exp
+                            elif ask(Q.odd(i), assumptions):
+                                return expr.base**(p.exp + 1)
+                            else:
+                                return expr.base**(p.exp + i)
+
+                if old != expr:
+                    return expr
+
+
+def refine_atan2(expr, assumptions):
+    """
+    Handler for the atan2 function.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, atan2
+    >>> from sympy.assumptions.refine import refine_atan2
+    >>> from sympy.abc import x, y
+    >>> refine_atan2(atan2(y,x), Q.real(y) & Q.positive(x))
+    atan(y/x)
+    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.negative(x))
+    atan(y/x) - pi
+    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.negative(x))
+    atan(y/x) + pi
+    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.negative(x))
+    pi
+    >>> refine_atan2(atan2(y,x), Q.positive(y) & Q.zero(x))
+    pi/2
+    >>> refine_atan2(atan2(y,x), Q.negative(y) & Q.zero(x))
+    -pi/2
+    >>> refine_atan2(atan2(y,x), Q.zero(y) & Q.zero(x))
+    nan
+    """
+    from sympy.functions.elementary.trigonometric import atan
+    y, x = expr.args
+    if ask(Q.real(y) & Q.positive(x), assumptions):
+        return atan(y / x)
+    elif ask(Q.negative(y) & Q.negative(x), assumptions):
+        return atan(y / x) - S.Pi
+    elif ask(Q.positive(y) & Q.negative(x), assumptions):
+        return atan(y / x) + S.Pi
+    elif ask(Q.zero(y) & Q.negative(x), assumptions):
+        return S.Pi
+    elif ask(Q.positive(y) & Q.zero(x), assumptions):
+        return S.Pi/2
+    elif ask(Q.negative(y) & Q.zero(x), assumptions):
+        return -S.Pi/2
+    elif ask(Q.zero(y) & Q.zero(x), assumptions):
+        return S.NaN
+    else:
+        return expr
+
+
+def refine_re(expr, assumptions):
+    """
+    Handler for real part.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_re
+    >>> from sympy import Q, re
+    >>> from sympy.abc import x
+    >>> refine_re(re(x), Q.real(x))
+    x
+    >>> refine_re(re(x), Q.imaginary(x))
+    0
+    """
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions):
+        return arg
+    if ask(Q.imaginary(arg), assumptions):
+        return S.Zero
+    return _refine_reim(expr, assumptions)
+
+
+def refine_im(expr, assumptions):
+    """
+    Handler for imaginary part.
+
+    Explanation
+    ===========
+
+    >>> from sympy.assumptions.refine import refine_im
+    >>> from sympy import Q, im
+    >>> from sympy.abc import x
+    >>> refine_im(im(x), Q.real(x))
+    0
+    >>> refine_im(im(x), Q.imaginary(x))
+    -I*x
+    """
+    arg = expr.args[0]
+    if ask(Q.real(arg), assumptions):
+        return S.Zero
+    if ask(Q.imaginary(arg), assumptions):
+        return - S.ImaginaryUnit * arg
+    return _refine_reim(expr, assumptions)
+
+def refine_arg(expr, assumptions):
+    """
+    Handler for complex argument
+
+    Explanation
+    ===========
+
+    >>> from sympy.assumptions.refine import refine_arg
+    >>> from sympy import Q, arg
+    >>> from sympy.abc import x
+    >>> refine_arg(arg(x), Q.positive(x))
+    0
+    >>> refine_arg(arg(x), Q.negative(x))
+    pi
+    """
+    rg = expr.args[0]
+    if ask(Q.positive(rg), assumptions):
+        return S.Zero
+    if ask(Q.negative(rg), assumptions):
+        return S.Pi
+    return None
+
+
+def _refine_reim(expr, assumptions):
+    # Helper function for refine_re & refine_im
+    expanded = expr.expand(complex = True)
+    if expanded != expr:
+        refined = refine(expanded, assumptions)
+        if refined != expanded:
+            return refined
+    # Best to leave the expression as is
+    return None
+
+
+def refine_sign(expr, assumptions):
+    """
+    Handler for sign.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_sign
+    >>> from sympy import Symbol, Q, sign, im
+    >>> x = Symbol('x', real = True)
+    >>> expr = sign(x)
+    >>> refine_sign(expr, Q.positive(x) & Q.nonzero(x))
+    1
+    >>> refine_sign(expr, Q.negative(x) & Q.nonzero(x))
+    -1
+    >>> refine_sign(expr, Q.zero(x))
+    0
+    >>> y = Symbol('y', imaginary = True)
+    >>> expr = sign(y)
+    >>> refine_sign(expr, Q.positive(im(y)))
+    I
+    >>> refine_sign(expr, Q.negative(im(y)))
+    -I
+    """
+    arg = expr.args[0]
+    if ask(Q.zero(arg), assumptions):
+        return S.Zero
+    if ask(Q.real(arg)):
+        if ask(Q.positive(arg), assumptions):
+            return S.One
+        if ask(Q.negative(arg), assumptions):
+            return S.NegativeOne
+    if ask(Q.imaginary(arg)):
+        arg_re, arg_im = arg.as_real_imag()
+        if ask(Q.positive(arg_im), assumptions):
+            return S.ImaginaryUnit
+        if ask(Q.negative(arg_im), assumptions):
+            return -S.ImaginaryUnit
+    return expr
+
+
+def refine_matrixelement(expr, assumptions):
+    """
+    Handler for symmetric part.
+
+    Examples
+    ========
+
+    >>> from sympy.assumptions.refine import refine_matrixelement
+    >>> from sympy import MatrixSymbol, Q
+    >>> X = MatrixSymbol('X', 3, 3)
+    >>> refine_matrixelement(X[0, 1], Q.symmetric(X))
+    X[0, 1]
+    >>> refine_matrixelement(X[1, 0], Q.symmetric(X))
+    X[0, 1]
+    """
+    from sympy.matrices.expressions.matexpr import MatrixElement
+    matrix, i, j = expr.args
+    if ask(Q.symmetric(matrix), assumptions):
+        if (i - j).could_extract_minus_sign():
+            return expr
+        return MatrixElement(matrix, j, i)
+
+handlers_dict: dict[str, Callable[[Expr, Boolean], Expr]] = {
+    'Abs': refine_abs,
+    'Pow': refine_Pow,
+    'atan2': refine_atan2,
+    're': refine_re,
+    'im': refine_im,
+    'arg': refine_arg,
+    'sign': refine_sign,
+    'MatrixElement': refine_matrixelement
+}
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__init__.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..04f5ed37893766feec941614691a9177f14e4027
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__init__.py
@@ -0,0 +1,13 @@
+"""
+A module to implement finitary relations [1] as predicate.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Finitary_relation
+
+"""
+
+__all__ = ['BinaryRelation', 'AppliedBinaryRelation']
+
+from .binrel import BinaryRelation, AppliedBinaryRelation
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc07b82155e87bc24ba2610e3b5c9284a3dfaedc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/binrel.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/binrel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d07ce70563875991913bfb046d8749dca3cf3a0e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/binrel.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/equality.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/equality.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c83bdffd8f1172cfde8fb18e962d06ba36aed667
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/__pycache__/equality.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/binrel.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/binrel.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b4eba05bcce40f1a05483a30136b6ccd891c42f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/binrel.py
@@ -0,0 +1,212 @@
+"""
+General binary relations.
+"""
+from typing import Optional
+
+from sympy.core.singleton import S
+from sympy.assumptions import AppliedPredicate, ask, Predicate, Q  # type: ignore
+from sympy.core.kind import BooleanKind
+from sympy.core.relational import Eq, Ne, Gt, Lt, Ge, Le
+from sympy.logic.boolalg import conjuncts, Not
+
+__all__ = ["BinaryRelation", "AppliedBinaryRelation"]
+
+
+class BinaryRelation(Predicate):
+    """
+    Base class for all binary relational predicates.
+
+    Explanation
+    ===========
+
+    Binary relation takes two arguments and returns ``AppliedBinaryRelation``
+    instance. To evaluate it to boolean value, use :obj:`~.ask()` or
+    :obj:`~.refine()` function.
+
+    You can add support for new types by registering the handler to dispatcher.
+    See :obj:`~.Predicate()` for more information about predicate dispatching.
+
+    Examples
+    ========
+
+    Applying and evaluating to boolean value:
+
+    >>> from sympy import Q, ask, sin, cos
+    >>> from sympy.abc import x
+    >>> Q.eq(sin(x)**2+cos(x)**2, 1)
+    Q.eq(sin(x)**2 + cos(x)**2, 1)
+    >>> ask(_)
+    True
+
+    You can define a new binary relation by subclassing and dispatching.
+    Here, we define a relation $R$ such that $x R y$ returns true if
+    $x = y + 1$.
+
+    >>> from sympy import ask, Number, Q
+    >>> from sympy.assumptions import BinaryRelation
+    >>> class MyRel(BinaryRelation):
+    ...     name = "R"
+    ...     is_reflexive = False
+    >>> Q.R = MyRel()
+    >>> @Q.R.register(Number, Number)
+    ... def _(n1, n2, assumptions):
+    ...     return ask(Q.zero(n1 - n2 - 1), assumptions)
+    >>> Q.R(2, 1)
+    Q.R(2, 1)
+
+    Now, we can use ``ask()`` to evaluate it to boolean value.
+
+    >>> ask(Q.R(2, 1))
+    True
+    >>> ask(Q.R(1, 2))
+    False
+
+    ``Q.R`` returns ``False`` with minimum cost if two arguments have same
+    structure because it is antireflexive relation [1] by
+    ``is_reflexive = False``.
+
+    >>> ask(Q.R(x, x))
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Reflexive_relation
+    """
+
+    is_reflexive: Optional[bool] = None
+    is_symmetric: Optional[bool] = None
+
+    def __call__(self, *args):
+        if not len(args) == 2:
+            raise ValueError("Binary relation takes two arguments, but got %s." % len(args))
+        return AppliedBinaryRelation(self, *args)
+
+    @property
+    def reversed(self):
+        if self.is_symmetric:
+            return self
+        return None
+
+    @property
+    def negated(self):
+        return None
+
+    def _compare_reflexive(self, lhs, rhs):
+        # quick exit for structurally same arguments
+        # do not check != here because it cannot catch the
+        # equivalent arguments with different structures.
+
+        # reflexivity does not hold to NaN
+        if lhs is S.NaN or rhs is S.NaN:
+            return None
+
+        reflexive = self.is_reflexive
+        if reflexive is None:
+            pass
+        elif reflexive and (lhs == rhs):
+            return True
+        elif not reflexive and (lhs == rhs):
+            return False
+        return None
+
+    def eval(self, args, assumptions=True):
+        # quick exit for structurally same arguments
+        ret = self._compare_reflexive(*args)
+        if ret is not None:
+            return ret
+
+        # don't perform simplify on args here. (done by AppliedBinaryRelation._eval_ask)
+        # evaluate by multipledispatch
+        lhs, rhs = args
+        ret = self.handler(lhs, rhs, assumptions=assumptions)
+        if ret is not None:
+            return ret
+
+        # check reversed order if the relation is reflexive
+        if self.is_reflexive:
+            types = (type(lhs), type(rhs))
+            if self.handler.dispatch(*types) is not self.handler.dispatch(*reversed(types)):
+                ret = self.handler(rhs, lhs, assumptions=assumptions)
+
+        return ret
+
+
+class AppliedBinaryRelation(AppliedPredicate):
+    """
+    The class of expressions resulting from applying ``BinaryRelation``
+    to the arguments.
+
+    """
+
+    @property
+    def lhs(self):
+        """The left-hand side of the relation."""
+        return self.arguments[0]
+
+    @property
+    def rhs(self):
+        """The right-hand side of the relation."""
+        return self.arguments[1]
+
+    @property
+    def reversed(self):
+        """
+        Try to return the relationship with sides reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        return revfunc(self.rhs, self.lhs)
+
+    @property
+    def reversedsign(self):
+        """
+        Try to return the relationship with signs reversed.
+        """
+        revfunc = self.function.reversed
+        if revfunc is None:
+            return self
+        if not any(side.kind is BooleanKind for side in self.arguments):
+            return revfunc(-self.lhs, -self.rhs)
+        return self
+
+    @property
+    def negated(self):
+        neg_rel = self.function.negated
+        if neg_rel is None:
+            return Not(self, evaluate=False)
+        return neg_rel(*self.arguments)
+
+    def _eval_ask(self, assumptions):
+        conj_assumps = set()
+        binrelpreds = {Eq: Q.eq, Ne: Q.ne, Gt: Q.gt, Lt: Q.lt, Ge: Q.ge, Le: Q.le}
+        for a in conjuncts(assumptions):
+            if a.func in binrelpreds:
+                conj_assumps.add(binrelpreds[type(a)](*a.args))
+            else:
+                conj_assumps.add(a)
+
+        # After CNF in assumptions module is modified to take polyadic
+        # predicate, this will be removed
+        if any(rel in conj_assumps for rel in (self, self.reversed)):
+            return True
+        neg_rels = (self.negated, self.reversed.negated, Not(self, evaluate=False),
+            Not(self.reversed, evaluate=False))
+        if any(rel in conj_assumps for rel in neg_rels):
+            return False
+
+        # evaluation using multipledispatching
+        ret = self.function.eval(self.arguments, assumptions)
+        if ret is not None:
+            return ret
+
+        # simplify the args and try again
+        args = tuple(a.simplify() for a in self.arguments)
+        return self.function.eval(args, assumptions)
+
+    def __bool__(self):
+        ret = ask(self)
+        if ret is None:
+            raise TypeError("Cannot determine truth value of %s" % self)
+        return ret
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/equality.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/equality.py
new file mode 100644
index 0000000000000000000000000000000000000000..d467cea2da706de2cbbc9875f93c7f8e324a9088
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/relation/equality.py
@@ -0,0 +1,302 @@
+"""
+Module for mathematical equality [1] and inequalities [2].
+
+The purpose of this module is to provide the instances which represent the
+binary predicates in order to combine the relationals into logical inference
+system. Objects such as ``Q.eq``, ``Q.lt`` should remain internal to
+assumptions module, and user must use the classes such as :obj:`~.Eq()`,
+:obj:`~.Lt()` instead to construct the relational expressions.
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Equality_(mathematics)
+.. [2] https://en.wikipedia.org/wiki/Inequality_(mathematics)
+"""
+from sympy.assumptions import Q
+from sympy.core.relational import is_eq, is_neq, is_gt, is_ge, is_lt, is_le
+
+from .binrel import BinaryRelation
+
+__all__ = ['EqualityPredicate', 'UnequalityPredicate', 'StrictGreaterThanPredicate',
+    'GreaterThanPredicate', 'StrictLessThanPredicate', 'LessThanPredicate']
+
+
+class EqualityPredicate(BinaryRelation):
+    """
+    Binary predicate for $=$.
+
+    The purpose of this class is to provide the instance which represent
+    the equality predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Eq()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_eq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.eq(0, 0)
+    Q.eq(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Eq
+
+    """
+    is_reflexive = True
+    is_symmetric = True
+
+    name = 'eq'
+    handler = None  # Do not allow dispatching by this predicate
+
+    @property
+    def negated(self):
+        return Q.ne
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_eq is None
+            assumptions = None
+        return is_eq(*args, assumptions)
+
+
+class UnequalityPredicate(BinaryRelation):
+    r"""
+    Binary predicate for $\neq$.
+
+    The purpose of this class is to provide the instance which represent
+    the inequation predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ne()` instead to construct the inequation expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_neq`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ne(0, 0)
+    Q.ne(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Ne
+
+    """
+    is_reflexive = False
+    is_symmetric = True
+
+    name = 'ne'
+    handler = None
+
+    @property
+    def negated(self):
+        return Q.eq
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_neq is None
+            assumptions = None
+        return is_neq(*args, assumptions)
+
+
+class StrictGreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Gt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_gt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.gt(0, 0)
+    Q.gt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Gt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'gt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.lt
+
+    @property
+    def negated(self):
+        return Q.le
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_gt is None
+            assumptions = None
+        return is_gt(*args, assumptions)
+
+
+class GreaterThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $>=$.
+
+    The purpose of this class is to provide the instance which represent
+    the ">=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Ge()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_ge`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.ge(0, 0)
+    Q.ge(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Ge
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'ge'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.le
+
+    @property
+    def negated(self):
+        return Q.lt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_ge is None
+            assumptions = None
+        return is_ge(*args, assumptions)
+
+
+class StrictLessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Lt()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_lt`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.lt(0, 0)
+    Q.lt(0, 0)
+    >>> ask(_)
+    False
+
+    See Also
+    ========
+
+    sympy.core.relational.Lt
+
+    """
+    is_reflexive = False
+    is_symmetric = False
+
+    name = 'lt'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.gt
+
+    @property
+    def negated(self):
+        return Q.ge
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_lt is None
+            assumptions = None
+        return is_lt(*args, assumptions)
+
+
+class LessThanPredicate(BinaryRelation):
+    """
+    Binary predicate for $<=$.
+
+    The purpose of this class is to provide the instance which represent
+    the "<=" predicate in order to allow the logical inference.
+    This class must remain internal to assumptions module and user must
+    use :obj:`~.Le()` instead to construct the equality expression.
+
+    Evaluating this predicate to ``True`` or ``False`` is done by
+    :func:`~.core.relational.is_le`
+
+    Examples
+    ========
+
+    >>> from sympy import ask, Q
+    >>> Q.le(0, 0)
+    Q.le(0, 0)
+    >>> ask(_)
+    True
+
+    See Also
+    ========
+
+    sympy.core.relational.Le
+
+    """
+    is_reflexive = True
+    is_symmetric = False
+
+    name = 'le'
+    handler = None
+
+    @property
+    def reversed(self):
+        return Q.ge
+
+    @property
+    def negated(self):
+        return Q.gt
+
+    def eval(self, args, assumptions=True):
+        if assumptions == True:
+            # default assumptions for is_le is None
+            assumptions = None
+        return is_le(*args, assumptions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/satask.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffc13f6d3bc3fb7f573c8d5d0564b780440c1a8c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/satask.py
@@ -0,0 +1,369 @@
+"""
+Module to evaluate the proposition with assumptions using SAT algorithm.
+"""
+
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.kind import NumberKind, UndefinedKind
+from sympy.assumptions.ask_generated import get_all_known_matrix_facts, get_all_known_number_facts
+from sympy.assumptions.assume import global_assumptions, AppliedPredicate
+from sympy.assumptions.sathandlers import class_fact_registry
+from sympy.core import oo
+from sympy.logic.inference import satisfiable
+from sympy.assumptions.cnf import CNF, EncodedCNF
+from sympy.matrices.kind import MatrixKind
+
+
+def satask(proposition, assumptions=True, context=global_assumptions,
+        use_known_facts=True, iterations=oo):
+    """
+    Function to evaluate the proposition with assumptions using SAT algorithm.
+
+    This function extracts every fact relevant to the expressions composing
+    proposition and assumptions. For example, if a predicate containing
+    ``Abs(x)`` is proposed, then ``Q.zero(Abs(x)) | Q.positive(Abs(x))``
+    will be found and passed to SAT solver because ``Q.nonnegative`` is
+    registered as a fact for ``Abs``.
+
+    Proposition is evaluated to ``True`` or ``False`` if the truth value can be
+    determined. If not, ``None`` is returned.
+
+    Parameters
+    ==========
+
+    proposition : Any boolean expression.
+        Proposition which will be evaluated to boolean value.
+
+    assumptions : Any boolean expression, optional.
+        Local assumptions to evaluate the *proposition*.
+
+    context : AssumptionsContext, optional.
+        Default assumptions to evaluate the *proposition*. By default,
+        this is ``sympy.assumptions.global_assumptions`` variable.
+
+    use_known_facts : bool, optional.
+        If ``True``, facts from ``sympy.assumptions.ask_generated``
+        module are passed to SAT solver as well.
+
+    iterations : int, optional.
+        Number of times that relevant facts are recursively extracted.
+        Default is infinite times until no new fact is found.
+
+    Returns
+    =======
+
+    ``True``, ``False``, or ``None``
+
+    Examples
+    ========
+
+    >>> from sympy import Abs, Q
+    >>> from sympy.assumptions.satask import satask
+    >>> from sympy.abc import x
+    >>> satask(Q.zero(Abs(x)), Q.zero(x))
+    True
+
+    """
+    props = CNF.from_prop(proposition)
+    _props = CNF.from_prop(~proposition)
+
+    assumptions = CNF.from_prop(assumptions)
+
+    context_cnf = CNF()
+    if context:
+        context_cnf = context_cnf.extend(context)
+
+    sat = get_all_relevant_facts(props, assumptions, context_cnf,
+        use_known_facts=use_known_facts, iterations=iterations)
+    sat.add_from_cnf(assumptions)
+    if context:
+        sat.add_from_cnf(context_cnf)
+
+    return check_satisfiability(props, _props, sat)
+
+
+def check_satisfiability(prop, _prop, factbase):
+    sat_true = factbase.copy()
+    sat_false = factbase.copy()
+    sat_true.add_from_cnf(prop)
+    sat_false.add_from_cnf(_prop)
+    can_be_true = satisfiable(sat_true)
+    can_be_false = satisfiable(sat_false)
+
+    if can_be_true and can_be_false:
+        return None
+
+    if can_be_true and not can_be_false:
+        return True
+
+    if not can_be_true and can_be_false:
+        return False
+
+    if not can_be_true and not can_be_false:
+        # TODO: Run additional checks to see which combination of the
+        # assumptions, global_assumptions, and relevant_facts are
+        # inconsistent.
+        raise ValueError("Inconsistent assumptions")
+
+
+def extract_predargs(proposition, assumptions=None, context=None):
+    """
+    Extract every expression in the argument of predicates from *proposition*,
+    *assumptions* and *context*.
+
+    Parameters
+    ==========
+
+    proposition : sympy.assumptions.cnf.CNF
+
+    assumptions : sympy.assumptions.cnf.CNF, optional.
+
+    context : sympy.assumptions.cnf.CNF, optional.
+        CNF generated from assumptions context.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Abs
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.satask import extract_predargs
+    >>> from sympy.abc import x, y
+    >>> props = CNF.from_prop(Q.zero(Abs(x*y)))
+    >>> assump = CNF.from_prop(Q.zero(x) & Q.zero(y))
+    >>> extract_predargs(props, assump)
+    {x, y, Abs(x*y)}
+
+    """
+    req_keys = find_symbols(proposition)
+    keys = proposition.all_predicates()
+    # XXX: We need this since True/False are not Basic
+    lkeys = set()
+    if assumptions:
+        lkeys |= assumptions.all_predicates()
+    if context:
+        lkeys |= context.all_predicates()
+
+    lkeys = lkeys - {S.true, S.false}
+    tmp_keys = None
+    while tmp_keys != set():
+        tmp = set()
+        for l in lkeys:
+            syms = find_symbols(l)
+            if (syms & req_keys) != set():
+                tmp |= syms
+        tmp_keys = tmp - req_keys
+        req_keys |= tmp_keys
+    keys |= {l for l in lkeys if find_symbols(l) & req_keys != set()}
+
+    exprs = set()
+    for key in keys:
+        if isinstance(key, AppliedPredicate):
+            exprs |= set(key.arguments)
+        else:
+            exprs.add(key)
+    return exprs
+
+def find_symbols(pred):
+    """
+    Find every :obj:`~.Symbol` in *pred*.
+
+    Parameters
+    ==========
+
+    pred : sympy.assumptions.cnf.CNF, or any Expr.
+
+    """
+    if isinstance(pred, CNF):
+        symbols = set()
+        for a in pred.all_predicates():
+            symbols |= find_symbols(a)
+        return symbols
+    return pred.atoms(Symbol)
+
+
+def get_relevant_clsfacts(exprs, relevant_facts=None):
+    """
+    Extract relevant facts from the items in *exprs*. Facts are defined in
+    ``assumptions.sathandlers`` module.
+
+    This function is recursively called by ``get_all_relevant_facts()``.
+
+    Parameters
+    ==========
+
+    exprs : set
+        Expressions whose relevant facts are searched.
+
+    relevant_facts : sympy.assumptions.cnf.CNF, optional.
+        Pre-discovered relevant facts.
+
+    Returns
+    =======
+
+    exprs : set
+        Candidates for next relevant fact searching.
+
+    relevant_facts : sympy.assumptions.cnf.CNF
+        Updated relevant facts.
+
+    Examples
+    ========
+
+    Here, we will see how facts relevant to ``Abs(x*y)`` are recursively
+    extracted. On the first run, set containing the expression is passed
+    without pre-discovered relevant facts. The result is a set containing
+    candidates for next run, and ``CNF()`` instance containing facts
+    which are relevant to ``Abs`` and its argument.
+
+    >>> from sympy import Abs
+    >>> from sympy.assumptions.satask import get_relevant_clsfacts
+    >>> from sympy.abc import x, y
+    >>> exprs = {Abs(x*y)}
+    >>> exprs, facts = get_relevant_clsfacts(exprs)
+    >>> exprs
+    {x*y}
+    >>> facts.clauses #doctest: +SKIP
+    {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
+    frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
+    frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False),
+                Literal(Q.odd(Abs(x*y)), False),
+                Literal(Q.odd(x*y), True)}),
+    frozenset({Literal(Q.even(Abs(x*y)), False),
+                Literal(Q.even(x*y), True),
+                Literal(Q.odd(Abs(x*y)), False)}),
+    frozenset({Literal(Q.positive(Abs(x*y)), False),
+                Literal(Q.zero(Abs(x*y)), False)})}
+
+    We pass the first run's results to the second run, and get the expressions
+    for next run and updated facts.
+
+    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
+    >>> exprs
+    {x, y}
+
+    On final run, no more candidate is returned thus we know that all
+    relevant facts are successfully retrieved.
+
+    >>> exprs, facts = get_relevant_clsfacts(exprs, relevant_facts=facts)
+    >>> exprs
+    set()
+
+    """
+    if not relevant_facts:
+        relevant_facts = CNF()
+
+    newexprs = set()
+    for expr in exprs:
+        for fact in class_fact_registry(expr):
+            newfact = CNF.to_CNF(fact)
+            relevant_facts = relevant_facts._and(newfact)
+            for key in newfact.all_predicates():
+                if isinstance(key, AppliedPredicate):
+                    newexprs |= set(key.arguments)
+
+    return newexprs - exprs, relevant_facts
+
+
+def get_all_relevant_facts(proposition, assumptions, context,
+        use_known_facts=True, iterations=oo):
+    """
+    Extract all relevant facts from *proposition* and *assumptions*.
+
+    This function extracts the facts by recursively calling
+    ``get_relevant_clsfacts()``. Extracted facts are converted to
+    ``EncodedCNF`` and returned.
+
+    Parameters
+    ==========
+
+    proposition : sympy.assumptions.cnf.CNF
+        CNF generated from proposition expression.
+
+    assumptions : sympy.assumptions.cnf.CNF
+        CNF generated from assumption expression.
+
+    context : sympy.assumptions.cnf.CNF
+        CNF generated from assumptions context.
+
+    use_known_facts : bool, optional.
+        If ``True``, facts from ``sympy.assumptions.ask_generated``
+        module are encoded as well.
+
+    iterations : int, optional.
+        Number of times that relevant facts are recursively extracted.
+        Default is infinite times until no new fact is found.
+
+    Returns
+    =======
+
+    sympy.assumptions.cnf.EncodedCNF
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.cnf import CNF
+    >>> from sympy.assumptions.satask import get_all_relevant_facts
+    >>> from sympy.abc import x, y
+    >>> props = CNF.from_prop(Q.nonzero(x*y))
+    >>> assump = CNF.from_prop(Q.nonzero(x))
+    >>> context = CNF.from_prop(Q.nonzero(y))
+    >>> get_all_relevant_facts(props, assump, context) #doctest: +SKIP
+    
+
+    """
+    # The relevant facts might introduce new keys, e.g., Q.zero(x*y) will
+    # introduce the keys Q.zero(x) and Q.zero(y), so we need to run it until
+    # we stop getting new things. Hopefully this strategy won't lead to an
+    # infinite loop in the future.
+    i = 0
+    relevant_facts = CNF()
+    all_exprs = set()
+    while True:
+        if i == 0:
+            exprs = extract_predargs(proposition, assumptions, context)
+        all_exprs |= exprs
+        exprs, relevant_facts = get_relevant_clsfacts(exprs, relevant_facts)
+        i += 1
+        if i >= iterations:
+            break
+        if not exprs:
+            break
+
+    if use_known_facts:
+        known_facts_CNF = CNF()
+
+        if any(expr.kind == MatrixKind(NumberKind) for expr in all_exprs):
+            known_facts_CNF.add_clauses(get_all_known_matrix_facts())
+        # check for undefinedKind since kind system isn't fully implemented
+        if any(((expr.kind == NumberKind) or (expr.kind == UndefinedKind)) for expr in all_exprs):
+            known_facts_CNF.add_clauses(get_all_known_number_facts())
+
+        kf_encoded = EncodedCNF()
+        kf_encoded.from_cnf(known_facts_CNF)
+
+        def translate_literal(lit, delta):
+            if lit > 0:
+                return lit + delta
+            else:
+                return lit - delta
+
+        def translate_data(data, delta):
+            return [{translate_literal(i, delta) for i in clause} for clause in data]
+        data = []
+        symbols = []
+        n_lit = len(kf_encoded.symbols)
+        for i, expr in enumerate(all_exprs):
+            symbols += [pred(expr) for pred in kf_encoded.symbols]
+            data += translate_data(kf_encoded.data, i * n_lit)
+
+        encoding = dict(list(zip(symbols, range(1, len(symbols)+1))))
+        ctx = EncodedCNF(data, encoding)
+    else:
+        ctx = EncodedCNF()
+
+    ctx.add_from_cnf(relevant_facts)
+
+    return ctx
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/sathandlers.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/sathandlers.py
new file mode 100644
index 0000000000000000000000000000000000000000..a11199eb0e547187ab280c18196c0259c178e004
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/sathandlers.py
@@ -0,0 +1,322 @@
+from collections import defaultdict
+
+from sympy.assumptions.ask import Q
+from sympy.core import (Add, Mul, Pow, Number, NumberSymbol, Symbol)
+from sympy.core.numbers import ImaginaryUnit
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic.boolalg import (Equivalent, And, Or, Implies)
+from sympy.matrices.expressions import MatMul
+
+# APIs here may be subject to change
+
+
+### Helper functions ###
+
+def allargs(symbol, fact, expr):
+    """
+    Apply all arguments of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import allargs
+    >>> from sympy.abc import x, y
+    >>> allargs(x, Q.negative(x) | Q.positive(x), x*y)
+    (Q.negative(x) | Q.positive(x)) & (Q.negative(y) | Q.positive(y))
+
+    """
+    return And(*[fact.subs(symbol, arg) for arg in expr.args])
+
+
+def anyarg(symbol, fact, expr):
+    """
+    Apply any argument of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import anyarg
+    >>> from sympy.abc import x, y
+    >>> anyarg(x, Q.negative(x) & Q.positive(x), x*y)
+    (Q.negative(x) & Q.positive(x)) | (Q.negative(y) & Q.positive(y))
+
+    """
+    return Or(*[fact.subs(symbol, arg) for arg in expr.args])
+
+
+def exactlyonearg(symbol, fact, expr):
+    """
+    Apply exactly one argument of the expression to the fact structure.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+        A placeholder symbol.
+
+    fact : Boolean
+        Resulting ``Boolean`` expression.
+
+    expr : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Q
+    >>> from sympy.assumptions.sathandlers import exactlyonearg
+    >>> from sympy.abc import x, y
+    >>> exactlyonearg(x, Q.positive(x), x*y)
+    (Q.positive(x) & ~Q.positive(y)) | (Q.positive(y) & ~Q.positive(x))
+
+    """
+    pred_args = [fact.subs(symbol, arg) for arg in expr.args]
+    res = Or(*[And(pred_args[i], *[~lit for lit in pred_args[:i] +
+        pred_args[i+1:]]) for i in range(len(pred_args))])
+    return res
+
+
+### Fact registry ###
+
+class ClassFactRegistry:
+    """
+    Register handlers against classes.
+
+    Explanation
+    ===========
+
+    ``register`` method registers the handler function for a class. Here,
+    handler function should return a single fact. ``multiregister`` method
+    registers the handler function for multiple classes. Here, handler function
+    should return a container of multiple facts.
+
+    ``registry(expr)`` returns a set of facts for *expr*.
+
+    Examples
+    ========
+
+    Here, we register the facts for ``Abs``.
+
+    >>> from sympy import Abs, Equivalent, Q
+    >>> from sympy.assumptions.sathandlers import ClassFactRegistry
+    >>> reg = ClassFactRegistry()
+    >>> @reg.register(Abs)
+    ... def f1(expr):
+    ...     return Q.nonnegative(expr)
+    >>> @reg.register(Abs)
+    ... def f2(expr):
+    ...     arg = expr.args[0]
+    ...     return Equivalent(~Q.zero(arg), ~Q.zero(expr))
+
+    Calling the registry with expression returns the defined facts for the
+    expression.
+
+    >>> from sympy.abc import x
+    >>> reg(Abs(x))
+    {Q.nonnegative(Abs(x)), Equivalent(~Q.zero(x), ~Q.zero(Abs(x)))}
+
+    Multiple facts can be registered at once by ``multiregister`` method.
+
+    >>> reg2 = ClassFactRegistry()
+    >>> @reg2.multiregister(Abs)
+    ... def _(expr):
+    ...     arg = expr.args[0]
+    ...     return [Q.even(arg) >> Q.even(expr), Q.odd(arg) >> Q.odd(expr)]
+    >>> reg2(Abs(x))
+    {Implies(Q.even(x), Q.even(Abs(x))), Implies(Q.odd(x), Q.odd(Abs(x)))}
+
+    """
+    def __init__(self):
+        self.singlefacts = defaultdict(frozenset)
+        self.multifacts = defaultdict(frozenset)
+
+    def register(self, cls):
+        def _(func):
+            self.singlefacts[cls] |= {func}
+            return func
+        return _
+
+    def multiregister(self, *classes):
+        def _(func):
+            for cls in classes:
+                self.multifacts[cls] |= {func}
+            return func
+        return _
+
+    def __getitem__(self, key):
+        ret1 = self.singlefacts[key]
+        for k in self.singlefacts:
+            if issubclass(key, k):
+                ret1 |= self.singlefacts[k]
+
+        ret2 = self.multifacts[key]
+        for k in self.multifacts:
+            if issubclass(key, k):
+                ret2 |= self.multifacts[k]
+
+        return ret1, ret2
+
+    def __call__(self, expr):
+        ret = set()
+
+        handlers1, handlers2 = self[type(expr)]
+
+        ret.update(h(expr) for h in handlers1)
+        for h in handlers2:
+            ret.update(h(expr))
+        return ret
+
+class_fact_registry = ClassFactRegistry()
+
+
+
+### Class fact registration ###
+
+x = Symbol('x')
+
+## Abs ##
+
+@class_fact_registry.multiregister(Abs)
+def _(expr):
+    arg = expr.args[0]
+    return [Q.nonnegative(expr),
+            Equivalent(~Q.zero(arg), ~Q.zero(expr)),
+            Q.even(arg) >> Q.even(expr),
+            Q.odd(arg) >> Q.odd(expr),
+            Q.integer(arg) >> Q.integer(expr),
+            ]
+
+
+### Add ##
+
+@class_fact_registry.multiregister(Add)
+def _(expr):
+    return [allargs(x, Q.positive(x), expr) >> Q.positive(expr),
+            allargs(x, Q.negative(x), expr) >> Q.negative(expr),
+            allargs(x, Q.real(x), expr) >> Q.real(expr),
+            allargs(x, Q.rational(x), expr) >> Q.rational(expr),
+            allargs(x, Q.integer(x), expr) >> Q.integer(expr),
+            exactlyonearg(x, ~Q.integer(x), expr) >> ~Q.integer(expr),
+            ]
+
+@class_fact_registry.register(Add)
+def _(expr):
+    allargs_real = allargs(x, Q.real(x), expr)
+    onearg_irrational = exactlyonearg(x, Q.irrational(x), expr)
+    return Implies(allargs_real, Implies(onearg_irrational, Q.irrational(expr)))
+
+
+### Mul ###
+
+@class_fact_registry.multiregister(Mul)
+def _(expr):
+    return [Equivalent(Q.zero(expr), anyarg(x, Q.zero(x), expr)),
+            allargs(x, Q.positive(x), expr) >> Q.positive(expr),
+            allargs(x, Q.real(x), expr) >> Q.real(expr),
+            allargs(x, Q.rational(x), expr) >> Q.rational(expr),
+            allargs(x, Q.integer(x), expr) >> Q.integer(expr),
+            exactlyonearg(x, ~Q.rational(x), expr) >> ~Q.integer(expr),
+            allargs(x, Q.commutative(x), expr) >> Q.commutative(expr),
+            ]
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # Implicitly assumes Mul has more than one arg
+    # Would be allargs(x, Q.prime(x) | Q.composite(x)) except 1 is composite
+    # More advanced prime assumptions will require inequalities, as 1 provides
+    # a corner case.
+    allargs_prime = allargs(x, Q.prime(x), expr)
+    return Implies(allargs_prime, ~Q.prime(expr))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # General Case: Odd number of imaginary args implies mul is imaginary(To be implemented)
+    allargs_imag_or_real = allargs(x, Q.imaginary(x) | Q.real(x), expr)
+    onearg_imaginary = exactlyonearg(x, Q.imaginary(x), expr)
+    return Implies(allargs_imag_or_real, Implies(onearg_imaginary, Q.imaginary(expr)))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    allargs_real = allargs(x, Q.real(x), expr)
+    onearg_irrational = exactlyonearg(x, Q.irrational(x), expr)
+    return Implies(allargs_real, Implies(onearg_irrational, Q.irrational(expr)))
+
+@class_fact_registry.register(Mul)
+def _(expr):
+    # Including the integer qualification means we don't need to add any facts
+    # for odd, since the assumptions already know that every integer is
+    # exactly one of even or odd.
+    allargs_integer = allargs(x, Q.integer(x), expr)
+    anyarg_even = anyarg(x, Q.even(x), expr)
+    return Implies(allargs_integer, Equivalent(anyarg_even, Q.even(expr)))
+
+
+### MatMul ###
+
+@class_fact_registry.register(MatMul)
+def _(expr):
+    allargs_square = allargs(x, Q.square(x), expr)
+    allargs_invertible = allargs(x, Q.invertible(x), expr)
+    return Implies(allargs_square, Equivalent(Q.invertible(expr), allargs_invertible))
+
+
+### Pow ###
+
+@class_fact_registry.multiregister(Pow)
+def _(expr):
+    base, exp = expr.base, expr.exp
+    return [
+        (Q.real(base) & Q.even(exp) & Q.nonnegative(exp)) >> Q.nonnegative(expr),
+        (Q.nonnegative(base) & Q.odd(exp) & Q.nonnegative(exp)) >> Q.nonnegative(expr),
+        (Q.nonpositive(base) & Q.odd(exp) & Q.nonnegative(exp)) >> Q.nonpositive(expr),
+        Equivalent(Q.zero(expr), Q.zero(base) & Q.positive(exp))
+    ]
+
+
+### Numbers ###
+
+_old_assump_getters = {
+    Q.positive: lambda o: o.is_positive,
+    Q.zero: lambda o: o.is_zero,
+    Q.negative: lambda o: o.is_negative,
+    Q.rational: lambda o: o.is_rational,
+    Q.irrational: lambda o: o.is_irrational,
+    Q.even: lambda o: o.is_even,
+    Q.odd: lambda o: o.is_odd,
+    Q.imaginary: lambda o: o.is_imaginary,
+    Q.prime: lambda o: o.is_prime,
+    Q.composite: lambda o: o.is_composite,
+}
+
+@class_fact_registry.multiregister(Number, NumberSymbol, ImaginaryUnit)
+def _(expr):
+    ret = []
+    for p, getter in _old_assump_getters.items():
+        pred = p(expr)
+        prop = getter(expr)
+        if prop is not None:
+            ret.append(Equivalent(pred, prop))
+    return ret
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f8bbd6aa0fb9a91dc62af8265b8888751657b67
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_assumptions_2.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_assumptions_2.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..619e70792f13f2c134084c166fb0e2a3410ea245
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_assumptions_2.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_context.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_context.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be9a9361e9609a96fcd9623afd02717f774c9fb7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_context.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_matrices.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_matrices.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adcd32939c60e73aab295cf109f5f4fb7b069ef5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_matrices.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_query.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_query.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcf3d522240d1f4cbc6094c781685c40db9fa4c4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_query.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:414791f6d2132332a7bfbb12d67403aebdff572535bbbea5253aa7bb74bb07aa
+size 298892
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_refine.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_refine.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ce2146a634390d9a8216f706b55a420e64fc034
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_refine.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_rel_queries.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_rel_queries.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cfed981987c989224103d48065c09418a20bd9e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_rel_queries.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_satask.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_satask.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8731bc7ddde4596b71eb92d459cec507cfbae508
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_satask.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_sathandlers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_sathandlers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3fc4afa8b492dc3f57a14bb7333ec0298abbfe0e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_sathandlers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_wrapper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_wrapper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3041291134dc25de89f1cae47bd536a03daa71bf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/__pycache__/test_wrapper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_assumptions_2.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_assumptions_2.py
new file mode 100644
index 0000000000000000000000000000000000000000..493fe4a7ed70301754ad2cfe181c5acf30433768
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_assumptions_2.py
@@ -0,0 +1,35 @@
+"""
+rename this to test_assumptions.py when the old assumptions system is deleted
+"""
+from sympy.abc import x, y
+from sympy.assumptions.assume import global_assumptions
+from sympy.assumptions.ask import Q
+from sympy.printing import pretty
+
+
+def test_equal():
+    """Test for equality"""
+    assert Q.positive(x) == Q.positive(x)
+    assert Q.positive(x) != ~Q.positive(x)
+    assert ~Q.positive(x) == ~Q.positive(x)
+
+
+def test_pretty():
+    assert pretty(Q.positive(x)) == "Q.positive(x)"
+    assert pretty(
+        {Q.positive, Q.integer}) == "{Q.integer, Q.positive}"
+
+
+def test_global():
+    """Test for global assumptions"""
+    global_assumptions.add(x > 0)
+    assert (x > 0) in global_assumptions
+    global_assumptions.remove(x > 0)
+    assert not (x > 0) in global_assumptions
+    # same with multiple of assumptions
+    global_assumptions.add(x > 0, y > 0)
+    assert (x > 0) in global_assumptions
+    assert (y > 0) in global_assumptions
+    global_assumptions.clear()
+    assert not (x > 0) in global_assumptions
+    assert not (y > 0) in global_assumptions
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_context.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_context.py
new file mode 100644
index 0000000000000000000000000000000000000000..be162f1c69492218ff90ea69492925d7779567a4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_context.py
@@ -0,0 +1,39 @@
+from sympy.assumptions import ask, Q
+from sympy.assumptions.assume import assuming, global_assumptions
+from sympy.abc import x, y
+
+def test_assuming():
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+    assert not ask(Q.integer(x))
+
+def test_assuming_nested():
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+    with assuming(Q.integer(x)):
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+        with assuming(Q.integer(y)):
+            assert ask(Q.integer(x))
+            assert ask(Q.integer(y))
+        assert ask(Q.integer(x))
+        assert not ask(Q.integer(y))
+    assert not ask(Q.integer(x))
+    assert not ask(Q.integer(y))
+
+def test_finally():
+    try:
+        with assuming(Q.integer(x)):
+            1/0
+    except ZeroDivisionError:
+        pass
+    assert not ask(Q.integer(x))
+
+def test_remove_safe():
+    global_assumptions.add(Q.integer(x))
+    with assuming():
+        assert ask(Q.integer(x))
+        global_assumptions.remove(Q.integer(x))
+        assert not ask(Q.integer(x))
+    assert ask(Q.integer(x))
+    global_assumptions.clear() # for the benefit of other tests
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_matrices.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_matrices.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bfa990f080eebe4d6dd5bfdd733ce1a19adf329
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_matrices.py
@@ -0,0 +1,283 @@
+from sympy.assumptions.ask import (Q, ask)
+from sympy.core.symbol import Symbol
+from sympy.matrices.expressions.diagonal import (DiagMatrix, DiagonalMatrix)
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions import (MatrixSymbol, Identity, ZeroMatrix,
+        OneMatrix, Trace, MatrixSlice, Determinant, BlockMatrix, BlockDiagMatrix)
+from sympy.matrices.expressions.factorizations import LofLU
+from sympy.testing.pytest import XFAIL
+
+X = MatrixSymbol('X', 2, 2)
+Y = MatrixSymbol('Y', 2, 3)
+Z = MatrixSymbol('Z', 2, 2)
+A1x1 = MatrixSymbol('A1x1', 1, 1)
+B1x1 = MatrixSymbol('B1x1', 1, 1)
+C0x0 = MatrixSymbol('C0x0', 0, 0)
+V1 = MatrixSymbol('V1', 2, 1)
+V2 = MatrixSymbol('V2', 2, 1)
+
+def test_square():
+    assert ask(Q.square(X))
+    assert not ask(Q.square(Y))
+    assert ask(Q.square(Y*Y.T))
+
+def test_invertible():
+    assert ask(Q.invertible(X), Q.invertible(X))
+    assert ask(Q.invertible(Y)) is False
+    assert ask(Q.invertible(X*Y), Q.invertible(X)) is False
+    assert ask(Q.invertible(X*Z), Q.invertible(X)) is None
+    assert ask(Q.invertible(X*Z), Q.invertible(X) & Q.invertible(Z)) is True
+    assert ask(Q.invertible(X.T)) is None
+    assert ask(Q.invertible(X.T), Q.invertible(X)) is True
+    assert ask(Q.invertible(X.I)) is True
+    assert ask(Q.invertible(Identity(3))) is True
+    assert ask(Q.invertible(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(OneMatrix(1, 1))) is True
+    assert ask(Q.invertible(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), Q.fullrank(X) & Q.square(X))
+
+def test_singular():
+    assert ask(Q.singular(X)) is None
+    assert ask(Q.singular(X), Q.invertible(X)) is False
+    assert ask(Q.singular(X), ~Q.invertible(X)) is True
+
+@XFAIL
+def test_invertible_fullrank():
+    assert ask(Q.invertible(X), Q.fullrank(X)) is True
+
+
+def test_invertible_BlockMatrix():
+    assert ask(Q.invertible(BlockMatrix([Identity(3)]))) == True
+    assert ask(Q.invertible(BlockMatrix([ZeroMatrix(3, 3)]))) == False
+
+    X = Matrix([[1, 2, 3], [3, 5, 4]])
+    Y = Matrix([[4, 2, 7], [2, 3, 5]])
+    # non-invertible A block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.ones(3, 3), Y.T],
+        [X, Matrix.eye(2)],
+    ]))) == True
+    # non-invertible B block
+    assert ask(Q.invertible(BlockMatrix([
+        [Y.T, Matrix.ones(3, 3)],
+        [Matrix.eye(2), X],
+    ]))) == True
+    # non-invertible C block
+    assert ask(Q.invertible(BlockMatrix([
+        [X, Matrix.eye(2)],
+        [Matrix.ones(3, 3), Y.T],
+    ]))) == True
+    # non-invertible D block
+    assert ask(Q.invertible(BlockMatrix([
+        [Matrix.eye(2), X],
+        [Y.T, Matrix.ones(3, 3)],
+    ]))) == True
+
+
+def test_invertible_BlockDiagMatrix():
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), Identity(5)))) == True
+    assert ask(Q.invertible(BlockDiagMatrix(ZeroMatrix(3, 3), Identity(5)))) == False
+    assert ask(Q.invertible(BlockDiagMatrix(Identity(3), OneMatrix(5, 5)))) == False
+
+
+def test_symmetric():
+    assert ask(Q.symmetric(X), Q.symmetric(X))
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X)) is None
+    assert ask(Q.symmetric(X*Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(X + Z), Q.symmetric(X) & Q.symmetric(Z)) is True
+    assert ask(Q.symmetric(Y)) is False
+    assert ask(Q.symmetric(Y*Y.T)) is True
+    assert ask(Q.symmetric(Y.T*X*Y)) is None
+    assert ask(Q.symmetric(Y.T*X*Y), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(X**10), Q.symmetric(X)) is True
+    assert ask(Q.symmetric(A1x1)) is True
+    assert ask(Q.symmetric(A1x1 + B1x1)) is True
+    assert ask(Q.symmetric(A1x1 * B1x1)) is True
+    assert ask(Q.symmetric(V1.T*V1)) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2))) is True
+    assert ask(Q.symmetric(V1.T*(V1 + V2) + A1x1)) is True
+    assert ask(Q.symmetric(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.symmetric(Identity(3))) is True
+    assert ask(Q.symmetric(ZeroMatrix(3, 3))) is True
+    assert ask(Q.symmetric(OneMatrix(3, 3))) is True
+
+def _test_orthogonal_unitary(predicate):
+    assert ask(predicate(X), predicate(X))
+    assert ask(predicate(X.T), predicate(X)) is True
+    assert ask(predicate(X.I), predicate(X)) is True
+    assert ask(predicate(X**2), predicate(X))
+    assert ask(predicate(Y)) is False
+    assert ask(predicate(X)) is None
+    assert ask(predicate(X), ~Q.invertible(X)) is False
+    assert ask(predicate(X*Z*X), predicate(X) & predicate(Z)) is True
+    assert ask(predicate(Identity(3))) is True
+    assert ask(predicate(ZeroMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), predicate(X))
+    assert not ask(predicate(X + Z), predicate(X) & predicate(Z))
+
+def test_orthogonal():
+    _test_orthogonal_unitary(Q.orthogonal)
+
+def test_unitary():
+    _test_orthogonal_unitary(Q.unitary)
+    assert ask(Q.unitary(X), Q.orthogonal(X))
+
+def test_fullrank():
+    assert ask(Q.fullrank(X), Q.fullrank(X))
+    assert ask(Q.fullrank(X**2), Q.fullrank(X))
+    assert ask(Q.fullrank(X.T), Q.fullrank(X)) is True
+    assert ask(Q.fullrank(X)) is None
+    assert ask(Q.fullrank(Y)) is None
+    assert ask(Q.fullrank(X*Z), Q.fullrank(X) & Q.fullrank(Z)) is True
+    assert ask(Q.fullrank(Identity(3))) is True
+    assert ask(Q.fullrank(ZeroMatrix(3, 3))) is False
+    assert ask(Q.fullrank(OneMatrix(1, 1))) is True
+    assert ask(Q.fullrank(OneMatrix(3, 3))) is False
+    assert ask(Q.invertible(X), ~Q.fullrank(X)) == False
+
+
+def test_positive_definite():
+    assert ask(Q.positive_definite(X), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X.T), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(X.I), Q.positive_definite(X)) is True
+    assert ask(Q.positive_definite(Y)) is False
+    assert ask(Q.positive_definite(X)) is None
+    assert ask(Q.positive_definite(X**3), Q.positive_definite(X))
+    assert ask(Q.positive_definite(X*Z*X),
+            Q.positive_definite(X) & Q.positive_definite(Z)) is True
+    assert ask(Q.positive_definite(X), Q.orthogonal(X))
+    assert ask(Q.positive_definite(Y.T*X*Y),
+            Q.positive_definite(X) & Q.fullrank(Y)) is True
+    assert not ask(Q.positive_definite(Y.T*X*Y), Q.positive_definite(X))
+    assert ask(Q.positive_definite(Identity(3))) is True
+    assert ask(Q.positive_definite(ZeroMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(OneMatrix(1, 1))) is True
+    assert ask(Q.positive_definite(OneMatrix(3, 3))) is False
+    assert ask(Q.positive_definite(X + Z), Q.positive_definite(X) &
+            Q.positive_definite(Z)) is True
+    assert not ask(Q.positive_definite(-X), Q.positive_definite(X))
+    assert ask(Q.positive(X[1, 1]), Q.positive_definite(X))
+
+def test_triangular():
+    assert ask(Q.upper_triangular(X + Z.T + Identity(2)), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.upper_triangular(X*Z.T), Q.upper_triangular(X) &
+            Q.lower_triangular(Z)) is True
+    assert ask(Q.lower_triangular(Identity(3))) is True
+    assert ask(Q.lower_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.upper_triangular(ZeroMatrix(3, 3))) is True
+    assert ask(Q.lower_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.upper_triangular(OneMatrix(1, 1))) is True
+    assert ask(Q.lower_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.upper_triangular(OneMatrix(3, 3))) is False
+    assert ask(Q.triangular(X), Q.unit_triangular(X))
+    assert ask(Q.upper_triangular(X**3), Q.upper_triangular(X))
+    assert ask(Q.lower_triangular(X**3), Q.lower_triangular(X))
+
+
+def test_diagonal():
+    assert ask(Q.diagonal(X + Z.T + Identity(2)), Q.diagonal(X) &
+               Q.diagonal(Z)) is True
+    assert ask(Q.diagonal(ZeroMatrix(3, 3)))
+    assert ask(Q.diagonal(OneMatrix(1, 1))) is True
+    assert ask(Q.diagonal(OneMatrix(3, 3))) is False
+    assert ask(Q.lower_triangular(X) & Q.upper_triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(X), Q.lower_triangular(X) & Q.upper_triangular(X))
+    assert ask(Q.symmetric(X), Q.diagonal(X))
+    assert ask(Q.triangular(X), Q.diagonal(X))
+    assert ask(Q.diagonal(C0x0))
+    assert ask(Q.diagonal(A1x1))
+    assert ask(Q.diagonal(A1x1 + B1x1))
+    assert ask(Q.diagonal(A1x1*B1x1))
+    assert ask(Q.diagonal(V1.T*V2))
+    assert ask(Q.diagonal(V1.T*(X + Z)*V1))
+    assert ask(Q.diagonal(MatrixSlice(Y, (0, 1), (1, 2)))) is True
+    assert ask(Q.diagonal(V1.T*(V1 + V2))) is True
+    assert ask(Q.diagonal(X**3), Q.diagonal(X))
+    assert ask(Q.diagonal(Identity(3)))
+    assert ask(Q.diagonal(DiagMatrix(V1)))
+    assert ask(Q.diagonal(DiagonalMatrix(X)))
+
+
+def test_non_atoms():
+    assert ask(Q.real(Trace(X)), Q.positive(Trace(X)))
+
+@XFAIL
+def test_non_trivial_implies():
+    X = MatrixSymbol('X', 3, 3)
+    Y = MatrixSymbol('Y', 3, 3)
+    assert ask(Q.lower_triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+    assert ask(Q.triangular(X), Q.lower_triangular(X)) is True
+    assert ask(Q.triangular(X+Y), Q.lower_triangular(X) &
+               Q.lower_triangular(Y)) is True
+
+def test_MatrixSlice():
+    X = MatrixSymbol('X', 4, 4)
+    B = MatrixSlice(X, (1, 3), (1, 3))
+    C = MatrixSlice(X, (0, 3), (1, 3))
+    assert ask(Q.symmetric(B), Q.symmetric(X))
+    assert ask(Q.invertible(B), Q.invertible(X))
+    assert ask(Q.diagonal(B), Q.diagonal(X))
+    assert ask(Q.orthogonal(B), Q.orthogonal(X))
+    assert ask(Q.upper_triangular(B), Q.upper_triangular(X))
+
+    assert not ask(Q.symmetric(C), Q.symmetric(X))
+    assert not ask(Q.invertible(C), Q.invertible(X))
+    assert not ask(Q.diagonal(C), Q.diagonal(X))
+    assert not ask(Q.orthogonal(C), Q.orthogonal(X))
+    assert not ask(Q.upper_triangular(C), Q.upper_triangular(X))
+
+def test_det_trace_positive():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.positive(Trace(X)), Q.positive_definite(X))
+    assert ask(Q.positive(Determinant(X)), Q.positive_definite(X))
+
+def test_field_assumptions():
+    X = MatrixSymbol('X', 4, 4)
+    Y = MatrixSymbol('Y', 4, 4)
+    assert ask(Q.real_elements(X), Q.real_elements(X))
+    assert not ask(Q.integer_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X), Q.real_elements(X))
+    assert ask(Q.complex_elements(X**2), Q.real_elements(X))
+    assert ask(Q.real_elements(X**2), Q.integer_elements(X))
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X)) is None
+    assert ask(Q.real_elements(X+Y), Q.real_elements(X) & Q.real_elements(Y))
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    assert ask(Q.real_elements(HadamardProduct(X, Y)),
+                    Q.real_elements(X) & Q.real_elements(Y))
+    assert ask(Q.complex_elements(X+Y), Q.real_elements(X) & Q.complex_elements(Y))
+
+    assert ask(Q.real_elements(X.T), Q.real_elements(X))
+    assert ask(Q.real_elements(X.I), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(Trace(X)), Q.real_elements(X))
+    assert ask(Q.integer_elements(Determinant(X)), Q.integer_elements(X))
+    assert not ask(Q.integer_elements(X.I), Q.integer_elements(X))
+    alpha = Symbol('alpha')
+    assert ask(Q.real_elements(alpha*X), Q.real_elements(X) & Q.real(alpha))
+    assert ask(Q.real_elements(LofLU(X)), Q.real_elements(X))
+    e = Symbol('e', integer=True, negative=True)
+    assert ask(Q.real_elements(X**e), Q.real_elements(X) & Q.invertible(X))
+    assert ask(Q.real_elements(X**e), Q.real_elements(X)) is None
+
+def test_matrix_element_sets():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.real(X[1, 2]), Q.real_elements(X))
+    assert ask(Q.integer(X[1, 2]), Q.integer_elements(X))
+    assert ask(Q.complex(X[1, 2]), Q.complex_elements(X))
+    assert ask(Q.integer_elements(Identity(3)))
+    assert ask(Q.integer_elements(ZeroMatrix(3, 3)))
+    assert ask(Q.integer_elements(OneMatrix(3, 3)))
+    from sympy.matrices.expressions.fourier import DFT
+    assert ask(Q.complex_elements(DFT(3)))
+
+
+def test_matrix_element_sets_slices_blocks():
+    X = MatrixSymbol('X', 4, 4)
+    assert ask(Q.integer_elements(X[:, 3]), Q.integer_elements(X))
+    assert ask(Q.integer_elements(BlockMatrix([[X], [X]])),
+                        Q.integer_elements(X))
+
+def test_matrix_element_sets_determinant_trace():
+    assert ask(Q.integer(Determinant(X)), Q.integer_elements(X))
+    assert ask(Q.integer(Trace(X)), Q.integer_elements(X))
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_query.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_query.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1ae1f1e482e5c9d19e3dcce3f37ad46b6821817
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_query.py
@@ -0,0 +1,2541 @@
+from sympy.abc import t, w, x, y, z, n, k, m, p, i
+from sympy.assumptions import (ask, AssumptionsContext, Q, register_handler,
+        remove_handler)
+from sympy.assumptions.assume import assuming, global_assumptions, Predicate
+from sympy.assumptions.cnf import CNF, Literal
+from sympy.assumptions.facts import (single_fact_lookup,
+    get_known_facts, generate_known_facts_dict, get_known_facts_keys)
+from sympy.assumptions.handlers import AskHandler
+from sympy.assumptions.ask_generated import (get_all_known_facts,
+    get_known_facts_dict)
+from sympy.core.add import Add
+from sympy.core.numbers import (I, Integer, Rational, oo, zoo, pi)
+from sympy.core.singleton import S
+from sympy.core.power import Pow
+from sympy.core.symbol import Str, symbols, Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (Abs, im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (
+    acos, acot, asin, atan, cos, cot, sin, tan)
+from sympy.logic.boolalg import Equivalent, Implies, Xor, And, to_cnf
+from sympy.matrices import Matrix, SparseMatrix
+from sympy.testing.pytest import (XFAIL, slow, raises, warns_deprecated_sympy,
+    _both_exp_pow)
+import math
+
+
+def test_int_1():
+    z = 1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_int_11():
+    z = 11
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is True
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_int_12():
+    z = 12
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is True
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is True
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_float_1():
+    z = 1.0
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is None
+    assert ask(Q.rational(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is None
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is None
+    assert ask(Q.odd(z)) is None
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is None
+    assert ask(Q.composite(z)) is None
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = 7.2123
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is None
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    # test for issue #12168
+    assert ask(Q.rational(math.pi)) is None
+
+
+def test_zero_0():
+    z = Integer(0)
+    assert ask(Q.nonzero(z)) is False
+    assert ask(Q.zero(z)) is True
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is True
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is True
+
+
+def test_negativeone():
+    z = Integer(-1)
+    assert ask(Q.nonzero(z)) is True
+    assert ask(Q.zero(z)) is False
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is True
+    assert ask(Q.rational(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is True
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is True
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_infinity():
+    assert ask(Q.commutative(oo)) is True
+    assert ask(Q.integer(oo)) is False
+    assert ask(Q.rational(oo)) is False
+    assert ask(Q.algebraic(oo)) is False
+    assert ask(Q.real(oo)) is False
+    assert ask(Q.extended_real(oo)) is True
+    assert ask(Q.complex(oo)) is False
+    assert ask(Q.irrational(oo)) is False
+    assert ask(Q.imaginary(oo)) is False
+    assert ask(Q.positive(oo)) is False
+    assert ask(Q.extended_positive(oo)) is True
+    assert ask(Q.negative(oo)) is False
+    assert ask(Q.even(oo)) is False
+    assert ask(Q.odd(oo)) is False
+    assert ask(Q.finite(oo)) is False
+    assert ask(Q.infinite(oo)) is True
+    assert ask(Q.prime(oo)) is False
+    assert ask(Q.composite(oo)) is False
+    assert ask(Q.hermitian(oo)) is False
+    assert ask(Q.antihermitian(oo)) is False
+    assert ask(Q.positive_infinite(oo)) is True
+    assert ask(Q.negative_infinite(oo)) is False
+
+
+def test_neg_infinity():
+    mm = S.NegativeInfinity
+    assert ask(Q.commutative(mm)) is True
+    assert ask(Q.integer(mm)) is False
+    assert ask(Q.rational(mm)) is False
+    assert ask(Q.algebraic(mm)) is False
+    assert ask(Q.real(mm)) is False
+    assert ask(Q.extended_real(mm)) is True
+    assert ask(Q.complex(mm)) is False
+    assert ask(Q.irrational(mm)) is False
+    assert ask(Q.imaginary(mm)) is False
+    assert ask(Q.positive(mm)) is False
+    assert ask(Q.negative(mm)) is False
+    assert ask(Q.extended_negative(mm)) is True
+    assert ask(Q.even(mm)) is False
+    assert ask(Q.odd(mm)) is False
+    assert ask(Q.finite(mm)) is False
+    assert ask(Q.infinite(oo)) is True
+    assert ask(Q.prime(mm)) is False
+    assert ask(Q.composite(mm)) is False
+    assert ask(Q.hermitian(mm)) is False
+    assert ask(Q.antihermitian(mm)) is False
+    assert ask(Q.positive_infinite(-oo)) is False
+    assert ask(Q.negative_infinite(-oo)) is True
+
+
+def test_complex_infinity():
+    assert ask(Q.commutative(zoo)) is True
+    assert ask(Q.integer(zoo)) is False
+    assert ask(Q.rational(zoo)) is False
+    assert ask(Q.algebraic(zoo)) is False
+    assert ask(Q.real(zoo)) is False
+    assert ask(Q.extended_real(zoo)) is False
+    assert ask(Q.complex(zoo)) is False
+    assert ask(Q.irrational(zoo)) is False
+    assert ask(Q.imaginary(zoo)) is False
+    assert ask(Q.positive(zoo)) is False
+    assert ask(Q.negative(zoo)) is False
+    assert ask(Q.zero(zoo)) is False
+    assert ask(Q.nonzero(zoo)) is False
+    assert ask(Q.even(zoo)) is False
+    assert ask(Q.odd(zoo)) is False
+    assert ask(Q.finite(zoo)) is False
+    assert ask(Q.infinite(zoo)) is True
+    assert ask(Q.prime(zoo)) is False
+    assert ask(Q.composite(zoo)) is False
+    assert ask(Q.hermitian(zoo)) is False
+    assert ask(Q.antihermitian(zoo)) is False
+    assert ask(Q.positive_infinite(zoo)) is False
+    assert ask(Q.negative_infinite(zoo)) is False
+
+
+def test_nan():
+    nan = S.NaN
+    assert ask(Q.commutative(nan)) is True
+    assert ask(Q.integer(nan)) is None
+    assert ask(Q.rational(nan)) is None
+    assert ask(Q.algebraic(nan)) is None
+    assert ask(Q.real(nan)) is None
+    assert ask(Q.extended_real(nan)) is None
+    assert ask(Q.complex(nan)) is None
+    assert ask(Q.irrational(nan)) is None
+    assert ask(Q.imaginary(nan)) is None
+    assert ask(Q.positive(nan)) is None
+    assert ask(Q.nonzero(nan)) is None
+    assert ask(Q.zero(nan)) is None
+    assert ask(Q.even(nan)) is None
+    assert ask(Q.odd(nan)) is None
+    assert ask(Q.finite(nan)) is None
+    assert ask(Q.infinite(nan)) is None
+    assert ask(Q.prime(nan)) is None
+    assert ask(Q.composite(nan)) is None
+    assert ask(Q.hermitian(nan)) is None
+    assert ask(Q.antihermitian(nan)) is None
+
+
+def test_Rational_number():
+    r = Rational(3, 4)
+    assert ask(Q.commutative(r)) is True
+    assert ask(Q.integer(r)) is False
+    assert ask(Q.rational(r)) is True
+    assert ask(Q.real(r)) is True
+    assert ask(Q.complex(r)) is True
+    assert ask(Q.irrational(r)) is False
+    assert ask(Q.imaginary(r)) is False
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+    assert ask(Q.even(r)) is False
+    assert ask(Q.odd(r)) is False
+    assert ask(Q.finite(r)) is True
+    assert ask(Q.prime(r)) is False
+    assert ask(Q.composite(r)) is False
+    assert ask(Q.hermitian(r)) is True
+    assert ask(Q.antihermitian(r)) is False
+
+    r = Rational(1, 4)
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+
+    r = Rational(5, 4)
+    assert ask(Q.negative(r)) is False
+    assert ask(Q.positive(r)) is True
+
+    r = Rational(5, 3)
+    assert ask(Q.positive(r)) is True
+    assert ask(Q.negative(r)) is False
+
+    r = Rational(-3, 4)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+    r = Rational(-1, 4)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+    r = Rational(-5, 4)
+    assert ask(Q.negative(r)) is True
+    assert ask(Q.positive(r)) is False
+
+    r = Rational(-5, 3)
+    assert ask(Q.positive(r)) is False
+    assert ask(Q.negative(r)) is True
+
+
+def test_sqrt_2():
+    z = sqrt(2)
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_pi():
+    z = S.Pi
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = S.Pi + 1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = 2*S.Pi
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = S.Pi ** 2
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+    z = (1 + S.Pi) ** 2
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is None
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_E():
+    z = S.Exp1
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is False
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_GoldenRatio():
+    z = S.GoldenRatio
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_TribonacciConstant():
+    z = S.TribonacciConstant
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is True
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is True
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is True
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is True
+    assert ask(Q.antihermitian(z)) is False
+
+
+def test_I():
+    z = I
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is True
+
+    z = 1 + I
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is False
+
+    z = I*(1 + I)
+    assert ask(Q.commutative(z)) is True
+    assert ask(Q.integer(z)) is False
+    assert ask(Q.rational(z)) is False
+    assert ask(Q.algebraic(z)) is True
+    assert ask(Q.real(z)) is False
+    assert ask(Q.complex(z)) is True
+    assert ask(Q.irrational(z)) is False
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.positive(z)) is False
+    assert ask(Q.negative(z)) is False
+    assert ask(Q.even(z)) is False
+    assert ask(Q.odd(z)) is False
+    assert ask(Q.finite(z)) is True
+    assert ask(Q.prime(z)) is False
+    assert ask(Q.composite(z)) is False
+    assert ask(Q.hermitian(z)) is False
+    assert ask(Q.antihermitian(z)) is False
+
+    z = I**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (-I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (3*I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (1)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (-1)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (1+I)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(I+3)
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(I+2)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (I)**(2)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+    z = (I)**(3)
+    assert ask(Q.imaginary(z)) is True
+    assert ask(Q.real(z)) is False
+
+    z = (3)**(I)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is False
+
+    z = (I)**(0)
+    assert ask(Q.imaginary(z)) is False
+    assert ask(Q.real(z)) is True
+
+def test_bounded():
+    x, y, z = symbols('x,y,z')
+    a = x + y
+    x, y = a.args
+    assert ask(Q.finite(a), Q.positive_infinite(y)) is None
+    assert ask(Q.finite(x)) is None
+    assert ask(Q.finite(x), Q.finite(x)) is True
+    assert ask(Q.finite(x), Q.finite(y)) is None
+    assert ask(Q.finite(x), Q.complex(x)) is True
+    assert ask(Q.finite(x), Q.extended_real(x)) is None
+
+    assert ask(Q.finite(x + 1)) is None
+    assert ask(Q.finite(x + 1), Q.finite(x)) is True
+    a = x + y
+    x, y = a.args
+    # B + B
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.finite(y)
+        & ~Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.positive(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y) & ~Q.positive(x)
+        & ~Q.positive(y)) is True
+    # B + U
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & ~Q.positive(y)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x) & ~Q.finite(y)
+        & ~Q.positive(y)) is False
+    # B + ?
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.positive(x)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.positive(x)
+        & ~Q.positive(y)) is None
+    # U + U
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x) & ~Q.finite(y)
+        & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.extended_positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.extended_positive(x) & ~Q.extended_positive(y)) is False
+    # U + ?
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.positive_infinite(y)) is False
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.finite(y) & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x) & ~Q.finite(y)
+        & ~Q.extended_positive(y)) is False
+    # ? + ?
+    assert ask(Q.finite(a)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)) is None
+    assert ask(Q.finite(a), Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & ~Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & Q.extended_positive(y)) is None
+    assert ask(Q.finite(a), ~Q.extended_positive(x)
+        & ~Q.extended_positive(y)) is None
+
+    x, y, z = symbols('x,y,z')
+    a = x + y + z
+    x, y, z = a.args
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.negative(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_positive(y)
+        & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.negative_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) &
+         Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x)) is None
+    assert ask(Q.finite(a), Q.negative(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.positive(z)) is True
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.negative_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x)) is None
+    assert ask(Q.finite(a), Q.positive(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.negative_infinite(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y)& Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.negative_infinite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & ~Q.finite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is False
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.negative_infinite(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(z)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.positive_infinite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.positive_infinite(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_negative(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.positive_infinite(z)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.positive_infinite(y) & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.positive_infinite(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is False
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y) & Q.extended_negative(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_negative(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_negative(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a)) is None
+    assert ask(Q.finite(a), Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_positive(y)
+        & Q.extended_positive(z)) is None
+    assert ask(Q.finite(a), Q.extended_positive(x)
+        & Q.extended_positive(y) & Q.extended_positive(z)) is None
+
+    assert ask(Q.finite(2*x)) is None
+    assert ask(Q.finite(2*x), Q.finite(x)) is True
+
+    x, y, z = symbols('x,y,z')
+    a = x*y
+    x, y = a.args
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y) &~Q.zero(y)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is False
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a)) is None
+    a = x*y*z
+    x, y, z = a.args
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is True
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & Q.finite(y)
+        & ~Q.zero(y) & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.zero(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y) & ~Q.zero(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.zero(x) & Q.finite(y)
+        & ~Q.zero(y) & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z) & ~Q.zero(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is False
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)) is None
+    assert ask(Q.finite(a), Q.finite(y) & Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(y) & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(y) & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(y)) is None
+    assert ask(Q.finite(a), Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(z) & Q.extended_nonzero(x)
+        & Q.extended_nonzero(y) & Q.extended_nonzero(z)) is None
+    assert ask(Q.finite(a), Q.extended_nonzero(x) & ~Q.finite(y)
+        & Q.extended_nonzero(y) & ~Q.finite(z)
+        & Q.extended_nonzero(z)) is False
+
+    x, y, z = symbols('x,y,z')
+    assert ask(Q.finite(x**2)) is None
+    assert ask(Q.finite(2**x)) is None
+    assert ask(Q.finite(2**x), Q.finite(x)) is True
+    assert ask(Q.finite(x**x)) is None
+    assert ask(Q.finite(S.Half ** x)) is None
+    assert ask(Q.finite(S.Half ** x), Q.extended_positive(x)) is True
+    assert ask(Q.finite(S.Half ** x), Q.extended_negative(x)) is None
+    assert ask(Q.finite(2**x), Q.extended_negative(x)) is True
+    assert ask(Q.finite(sqrt(x))) is None
+    assert ask(Q.finite(2**x), ~Q.finite(x)) is False
+    assert ask(Q.finite(x**2), ~Q.finite(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27707
+    assert ask(Q.finite(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.finite(x**y), Q.real(x) & Q.negative(y)) is None
+    assert ask(Q.finite(x**y), Q.zero(x) & Q.negative(y)) is False
+    assert ask(Q.finite(x**y), Q.real(x) & Q.positive(y)) is True
+    assert ask(Q.finite(x**y), Q.nonzero(x) & Q.real(y)) is True
+    assert ask(Q.finite(x**y), Q.nonzero(x) & Q.negative(y)) is True
+    assert ask(Q.finite(x**y), Q.zero(x) & Q.positive(y)) is True
+
+    # sign function
+    assert ask(Q.finite(sign(x))) is True
+    assert ask(Q.finite(sign(x)), ~Q.finite(x)) is True
+
+    # exponential functions
+    assert ask(Q.finite(log(x))) is None
+    assert ask(Q.finite(log(x)), Q.finite(x)) is None
+    assert ask(Q.finite(log(x)), ~Q.zero(x)) is True
+    assert ask(Q.finite(log(x)), Q.infinite(x)) is False
+    assert ask(Q.finite(log(x)), Q.zero(x)) is False
+    assert ask(Q.finite(exp(x))) is None
+    assert ask(Q.finite(exp(x)), Q.finite(x)) is True
+    assert ask(Q.finite(exp(2))) is True
+
+    # trigonometric functions
+    assert ask(Q.finite(sin(x))) is True
+    assert ask(Q.finite(sin(x)), ~Q.finite(x)) is True
+    assert ask(Q.finite(cos(x))) is True
+    assert ask(Q.finite(cos(x)), ~Q.finite(x)) is True
+    assert ask(Q.finite(2*sin(x))) is True
+    assert ask(Q.finite(sin(x)**2)) is True
+    assert ask(Q.finite(cos(x)**2)) is True
+    assert ask(Q.finite(cos(x) + sin(x))) is True
+
+
+def test_unbounded():
+    assert ask(Q.infinite(I * oo)) is True
+    assert ask(Q.infinite(1 + I*oo)) is True
+    assert ask(Q.infinite(3 * (I * oo))) is True
+    assert ask(Q.infinite(-I * oo)) is True
+    assert ask(Q.infinite(1 + zoo)) is True
+    assert ask(Q.infinite(I * zoo)) is True
+    assert ask(Q.infinite(x / y), Q.infinite(x) & Q.finite(y) & ~Q.zero(y)) is True
+    assert ask(Q.infinite(I * oo - I * oo)) is None
+    assert ask(Q.infinite(x * I * oo)) is None
+    assert ask(Q.infinite(1 / x), Q.finite(x) & ~Q.zero(x)) is False
+    assert ask(Q.infinite(1 / (I * oo))) is False
+
+
+def test_issue_27441():
+    # https://github.com/sympy/sympy/issues/27441
+    assert ask(Q.composite(y), Q.integer(y) & Q.positive(y) & ~Q.prime(y)) is None
+
+
+def test_issue_27447():
+    x,y,z = symbols('x y z')
+    a = x*y
+    assert ask(Q.finite(a), Q.finite(x)  & ~Q.finite(y)) is None
+    assert ask(Q.finite(a), ~Q.finite(x)  & Q.finite(y)) is None
+
+    a = x*y*z
+    assert ask(Q.finite(a), Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z) ) is None
+    assert ask(Q.finite(a), Q.finite(x) & ~Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)
+        & Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & Q.finite(y)
+        & ~Q.finite(z)) is None
+    assert ask(Q.finite(a), ~Q.finite(x) & ~Q.finite(y)
+        & Q.finite(z)) is None
+
+
+@XFAIL
+def test_issue_27662_xfail():
+    assert ask(Q.finite(x*y), ~Q.finite(x)
+        & Q.zero(y)) is None
+
+
+@XFAIL
+def test_bounded_xfail():
+    """We need to support relations in ask for this to work"""
+    assert ask(Q.finite(sin(x)**x)) is True
+    assert ask(Q.finite(cos(x)**x)) is True
+
+
+def test_commutative():
+    """By default objects are Q.commutative that is why it returns True
+    for both key=True and key=False"""
+    assert ask(Q.commutative(x)) is True
+    assert ask(Q.commutative(x), ~Q.commutative(x)) is False
+    assert ask(Q.commutative(x), Q.complex(x)) is True
+    assert ask(Q.commutative(x), Q.imaginary(x)) is True
+    assert ask(Q.commutative(x), Q.real(x)) is True
+    assert ask(Q.commutative(x), Q.positive(x)) is True
+    assert ask(Q.commutative(x), ~Q.commutative(y)) is True
+
+    assert ask(Q.commutative(2*x)) is True
+    assert ask(Q.commutative(2*x), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(x + 1)) is True
+    assert ask(Q.commutative(x + 1), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(x**2)) is True
+    assert ask(Q.commutative(x**2), ~Q.commutative(x)) is False
+
+    assert ask(Q.commutative(log(x))) is True
+
+
+@_both_exp_pow
+def test_complex():
+    assert ask(Q.complex(x)) is None
+    assert ask(Q.complex(x), Q.complex(x)) is True
+    assert ask(Q.complex(x), Q.complex(y)) is None
+    assert ask(Q.complex(x), ~Q.complex(x)) is False
+    assert ask(Q.complex(x), Q.real(x)) is True
+    assert ask(Q.complex(x), ~Q.real(x)) is None
+    assert ask(Q.complex(x), Q.rational(x)) is True
+    assert ask(Q.complex(x), Q.irrational(x)) is True
+    assert ask(Q.complex(x), Q.positive(x)) is True
+    assert ask(Q.complex(x), Q.imaginary(x)) is True
+    assert ask(Q.complex(x), Q.algebraic(x)) is True
+
+    # a+b
+    assert ask(Q.complex(x + 1), Q.complex(x)) is True
+    assert ask(Q.complex(x + 1), Q.real(x)) is True
+    assert ask(Q.complex(x + 1), Q.rational(x)) is True
+    assert ask(Q.complex(x + 1), Q.irrational(x)) is True
+    assert ask(Q.complex(x + 1), Q.imaginary(x)) is True
+    assert ask(Q.complex(x + 1), Q.integer(x)) is True
+    assert ask(Q.complex(x + 1), Q.even(x)) is True
+    assert ask(Q.complex(x + 1), Q.odd(x)) is True
+    assert ask(Q.complex(x + y), Q.complex(x) & Q.complex(y)) is True
+    assert ask(Q.complex(x + y), Q.real(x) & Q.imaginary(y)) is True
+
+    # a*x +b
+    assert ask(Q.complex(2*x + 1), Q.complex(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.real(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.positive(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.rational(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.irrational(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.imaginary(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.integer(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.even(x)) is True
+    assert ask(Q.complex(2*x + 1), Q.odd(x)) is True
+
+    # x**2
+    assert ask(Q.complex(x**2), Q.complex(x)) is True
+    assert ask(Q.complex(x**2), Q.real(x)) is True
+    assert ask(Q.complex(x**2), Q.positive(x)) is True
+    assert ask(Q.complex(x**2), Q.rational(x)) is True
+    assert ask(Q.complex(x**2), Q.irrational(x)) is True
+    assert ask(Q.complex(x**2), Q.imaginary(x)) is True
+    assert ask(Q.complex(x**2), Q.integer(x)) is True
+    assert ask(Q.complex(x**2), Q.even(x)) is True
+    assert ask(Q.complex(x**2), Q.odd(x)) is True
+
+    # 2**x
+    assert ask(Q.complex(2**x), Q.complex(x)) is True
+    assert ask(Q.complex(2**x), Q.real(x)) is True
+    assert ask(Q.complex(2**x), Q.positive(x)) is True
+    assert ask(Q.complex(2**x), Q.rational(x)) is True
+    assert ask(Q.complex(2**x), Q.irrational(x)) is True
+    assert ask(Q.complex(2**x), Q.imaginary(x)) is True
+    assert ask(Q.complex(2**x), Q.integer(x)) is True
+    assert ask(Q.complex(2**x), Q.even(x)) is True
+    assert ask(Q.complex(2**x), Q.odd(x)) is True
+    assert ask(Q.complex(x**y), Q.complex(x) & Q.complex(y)) is True
+
+    # trigonometric expressions
+    assert ask(Q.complex(sin(x))) is True
+    assert ask(Q.complex(sin(2*x + 1))) is True
+    assert ask(Q.complex(cos(x))) is True
+    assert ask(Q.complex(cos(2*x + 1))) is True
+
+    # exponential
+    assert ask(Q.complex(exp(x))) is True
+    assert ask(Q.complex(exp(x))) is True
+
+    # Q.complexes
+    assert ask(Q.complex(Abs(x))) is True
+    assert ask(Q.complex(re(x))) is True
+    assert ask(Q.complex(im(x))) is True
+
+
+def test_even_query():
+    assert ask(Q.even(x)) is None
+    assert ask(Q.even(x), Q.integer(x)) is None
+    assert ask(Q.even(x), ~Q.integer(x)) is False
+    assert ask(Q.even(x), Q.rational(x)) is None
+    assert ask(Q.even(x), Q.positive(x)) is None
+
+    assert ask(Q.even(2*x)) is None
+    assert ask(Q.even(2*x), Q.integer(x)) is True
+    assert ask(Q.even(2*x), Q.even(x)) is True
+    assert ask(Q.even(2*x), Q.irrational(x)) is False
+    assert ask(Q.even(2*x), Q.odd(x)) is True
+    assert ask(Q.even(2*x), ~Q.integer(x)) is None
+    assert ask(Q.even(3*x), Q.integer(x)) is None
+    assert ask(Q.even(3*x), Q.even(x)) is True
+    assert ask(Q.even(3*x), Q.odd(x)) is False
+
+    assert ask(Q.even(x + 1), Q.odd(x)) is True
+    assert ask(Q.even(x + 1), Q.even(x)) is False
+    assert ask(Q.even(x + 2), Q.odd(x)) is False
+    assert ask(Q.even(x + 2), Q.even(x)) is True
+    assert ask(Q.even(7 - x), Q.odd(x)) is True
+    assert ask(Q.even(7 + x), Q.odd(x)) is True
+    assert ask(Q.even(x + y), Q.odd(x) & Q.odd(y)) is True
+    assert ask(Q.even(x + y), Q.odd(x) & Q.even(y)) is False
+    assert ask(Q.even(x + y), Q.even(x) & Q.even(y)) is True
+
+    assert ask(Q.even(2*x + 1), Q.integer(x)) is False
+    assert ask(Q.even(2*x*y), Q.rational(x) & Q.rational(x)) is None
+    assert ask(Q.even(2*x*y), Q.irrational(x) & Q.irrational(x)) is None
+
+    assert ask(Q.even(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) is True
+    assert ask(Q.even(x + y + z + t),
+        Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) is None
+
+    assert ask(Q.even(Abs(x)), Q.even(x)) is True
+    assert ask(Q.even(Abs(x)), ~Q.even(x)) is None
+    assert ask(Q.even(re(x)), Q.even(x)) is True
+    assert ask(Q.even(re(x)), ~Q.even(x)) is None
+    assert ask(Q.even(im(x)), Q.even(x)) is True
+    assert ask(Q.even(im(x)), Q.real(x)) is True
+
+    assert ask(Q.even((-1)**n), Q.integer(n)) is False
+
+    assert ask(Q.even(k**2), Q.even(k)) is True
+    assert ask(Q.even(n**2), Q.odd(n)) is False
+    assert ask(Q.even(2**k), Q.even(k)) is None
+    assert ask(Q.even(x**2)) is None
+
+    assert ask(Q.even(k**m), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(n**m), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is False
+
+    assert ask(Q.even(k**p), Q.even(k) & Q.integer(p) & Q.positive(p)) is True
+    assert ask(Q.even(n**p), Q.odd(n) & Q.integer(p) & Q.positive(p)) is False
+
+    assert ask(Q.even(m**k), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(p**k), Q.even(k) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.even(m**n), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.even(p**n), Q.odd(n) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.even(k**x), Q.even(k)) is None
+    assert ask(Q.even(n**x), Q.odd(n)) is None
+
+    assert ask(Q.even(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.even(x*x), Q.integer(x)) is None
+    assert ask(Q.even(x*(x + y)), Q.integer(x) & Q.odd(y)) is True
+    assert ask(Q.even(x*(x + y)), Q.integer(x) & Q.even(y)) is None
+
+
+@XFAIL
+def test_evenness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    assert ask(Q.even(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is True
+    assert ask(Q.even(y*x*(x + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is True
+
+
+def test_evenness_in_ternary_integer_product_with_even():
+    assert ask(Q.even(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.even(z)) is None
+
+
+def test_extended_real():
+    assert ask(Q.extended_real(x), Q.positive_infinite(x)) is True
+    assert ask(Q.extended_real(x), Q.positive(x)) is True
+    assert ask(Q.extended_real(x), Q.zero(x)) is True
+    assert ask(Q.extended_real(x), Q.negative(x)) is True
+    assert ask(Q.extended_real(x), Q.negative_infinite(x)) is True
+
+    assert ask(Q.extended_real(-x), Q.positive(x)) is True
+    assert ask(Q.extended_real(-x), Q.negative(x)) is True
+
+    assert ask(Q.extended_real(x + S.Infinity), Q.real(x)) is True
+
+    assert ask(Q.extended_real(x), Q.infinite(x)) is None
+
+
+@_both_exp_pow
+def test_rational():
+    assert ask(Q.rational(x), Q.integer(x)) is True
+    assert ask(Q.rational(x), Q.irrational(x)) is False
+    assert ask(Q.rational(x), Q.real(x)) is None
+    assert ask(Q.rational(x), Q.positive(x)) is None
+    assert ask(Q.rational(x), Q.negative(x)) is None
+    assert ask(Q.rational(x), Q.nonzero(x)) is None
+    assert ask(Q.rational(x), ~Q.algebraic(x)) is False
+
+    assert ask(Q.rational(2*x), Q.rational(x)) is True
+    assert ask(Q.rational(2*x), Q.integer(x)) is True
+    assert ask(Q.rational(2*x), Q.even(x)) is True
+    assert ask(Q.rational(2*x), Q.odd(x)) is True
+    assert ask(Q.rational(2*x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(x/2), Q.rational(x)) is True
+    assert ask(Q.rational(x/2), Q.integer(x)) is True
+    assert ask(Q.rational(x/2), Q.even(x)) is True
+    assert ask(Q.rational(x/2), Q.odd(x)) is True
+    assert ask(Q.rational(x/2), Q.irrational(x)) is False
+
+    assert ask(Q.rational(1/x), Q.rational(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.integer(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.even(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(1/x), Q.odd(x)) is True
+    assert ask(Q.rational(1/x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(2/x), Q.rational(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.integer(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.even(x) & Q.nonzero(x)) is True
+    assert ask(Q.rational(2/x), Q.odd(x)) is True
+    assert ask(Q.rational(2/x), Q.irrational(x)) is False
+
+    assert ask(Q.rational(x), ~Q.algebraic(x)) is False
+
+    # with multiple symbols
+    assert ask(Q.rational(x*y), Q.irrational(x) & Q.irrational(y)) is None
+    assert ask(Q.rational(y/x), Q.rational(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.integer(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.even(x) & Q.rational(y) & Q.nonzero(x)) is True
+    assert ask(Q.rational(y/x), Q.odd(x) & Q.rational(y)) is True
+    assert ask(Q.rational(y/x), Q.irrational(x) & Q.rational(y) & Q.nonzero(y)) is False
+
+    for f in [exp, sin, tan, asin, atan, cos]:
+        assert ask(Q.rational(f(7))) is False
+        assert ask(Q.rational(f(7, evaluate=False))) is False
+        assert ask(Q.rational(f(0, evaluate=False))) is True
+        assert ask(Q.rational(f(x)), Q.rational(x)) is None
+        assert ask(Q.rational(f(x)), Q.rational(x) & Q.nonzero(x)) is False
+
+    for g in [log, acos]:
+        assert ask(Q.rational(g(7))) is False
+        assert ask(Q.rational(g(7, evaluate=False))) is False
+        assert ask(Q.rational(g(1, evaluate=False))) is True
+        assert ask(Q.rational(g(x)), Q.rational(x)) is None
+        assert ask(Q.rational(g(x)), Q.rational(x) & Q.nonzero(x - 1)) is False
+
+    for h in [cot, acot]:
+        assert ask(Q.rational(h(7))) is False
+        assert ask(Q.rational(h(7, evaluate=False))) is False
+        assert ask(Q.rational(h(x)), Q.rational(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27442
+    assert ask(Q.rational(x**y),Q.irrational(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.prime(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.rational(x**y),Q.integer(x) & Q.eq(x,0) & Q.integer(y)) is None
+    assert ask(Q.rational(x**y),Q.eq(x,1) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y),Q.eq(x,-1) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y), Q.prime(x) & Q.rational(y)) is None
+    assert ask(Q.rational(x**y), ~Q.rational(x) & Q.integer(y) ) is None
+    assert ask(Q.rational(Pow(-1, x, evaluate=False), Q.rational(x))) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q. algebraic(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q. algebraic(x) & ~Q.zero(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q.algebraic(x) & Q.complex(x) & ~Q.real(x)) is None
+    assert ask(Q.rational(x**y), Q.integer(y) & ~Q.algebraic(x) & Q.complex(x)) is None
+
+
+def test_hermitian():
+    assert ask(Q.hermitian(x)) is None
+    assert ask(Q.hermitian(x), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x), Q.imaginary(x)) is False
+    assert ask(Q.hermitian(x), Q.prime(x)) is True
+    assert ask(Q.hermitian(x), Q.real(x)) is True
+    assert ask(Q.hermitian(x), Q.zero(x)) is True
+
+    assert ask(Q.hermitian(x + 1), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x + 1), Q.complex(x)) is None
+    assert ask(Q.hermitian(x + 1), Q.hermitian(x)) is True
+    assert ask(Q.hermitian(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.hermitian(x + 1), Q.real(x)) is True
+    assert ask(Q.hermitian(x + I), Q.antihermitian(x)) is None
+    assert ask(Q.hermitian(x + I), Q.complex(x)) is None
+    assert ask(Q.hermitian(x + I), Q.hermitian(x)) is False
+    assert ask(Q.hermitian(x + I), Q.imaginary(x)) is None
+    assert ask(Q.hermitian(x + I), Q.real(x)) is False
+    assert ask(
+        Q.hermitian(x + y), Q.antihermitian(x) & Q.antihermitian(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.complex(y)) is None
+    assert ask(
+        Q.hermitian(x + y), Q.antihermitian(x) & Q.hermitian(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.imaginary(y)) is None
+    assert ask(Q.hermitian(x + y), Q.antihermitian(x) & Q.real(y)) is None
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.hermitian(y)) is True
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.imaginary(y)) is False
+    assert ask(Q.hermitian(x + y), Q.hermitian(x) & Q.real(y)) is True
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.imaginary(y)) is None
+    assert ask(Q.hermitian(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.hermitian(x + y), Q.real(x) & Q.complex(y)) is None
+    assert ask(Q.hermitian(x + y), Q.real(x) & Q.real(y)) is True
+
+    assert ask(Q.hermitian(I*x), Q.antihermitian(x)) is True
+    assert ask(Q.hermitian(I*x), Q.complex(x)) is None
+    assert ask(Q.hermitian(I*x), Q.hermitian(x)) is False
+    assert ask(Q.hermitian(I*x), Q.imaginary(x)) is True
+    assert ask(Q.hermitian(I*x), Q.real(x)) is False
+    assert ask(Q.hermitian(x*y), Q.hermitian(x) & Q.real(y)) is True
+
+    assert ask(
+        Q.hermitian(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert ask(Q.hermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is False
+    assert ask(Q.hermitian(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is None
+    assert ask(Q.hermitian(x + y + z),
+        Q.imaginary(x) & Q.imaginary(y) & Q.imaginary(z)) is None
+
+    assert ask(Q.antihermitian(x)) is None
+    assert ask(Q.antihermitian(x), Q.real(x)) is False
+    assert ask(Q.antihermitian(x), Q.prime(x)) is False
+
+    assert ask(Q.antihermitian(x + 1), Q.antihermitian(x)) is False
+    assert ask(Q.antihermitian(x + 1), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x + 1), Q.hermitian(x)) is None
+    assert ask(Q.antihermitian(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.antihermitian(x + 1), Q.real(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.antihermitian(x)) is True
+    assert ask(Q.antihermitian(x + I), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.hermitian(x)) is None
+    assert ask(Q.antihermitian(x + I), Q.imaginary(x)) is True
+    assert ask(Q.antihermitian(x + I), Q.real(x)) is False
+    assert ask(Q.antihermitian(x), Q.zero(x)) is True
+
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.antihermitian(y)
+    ) is True
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.complex(y)) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.hermitian(y)) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.antihermitian(x) & Q.imaginary(y)) is True
+    assert ask(Q.antihermitian(x + y), Q.antihermitian(x) & Q.real(y)
+        ) is False
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.hermitian(y)
+        ) is None
+    assert ask(
+        Q.antihermitian(x + y), Q.hermitian(x) & Q.imaginary(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.hermitian(x) & Q.real(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.imaginary(y)) is True
+    assert ask(Q.antihermitian(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.antihermitian(x + y), Q.real(x) & Q.complex(y)) is None
+    assert ask(Q.antihermitian(x + y), Q.real(x) & Q.real(y)) is None
+
+    assert ask(Q.antihermitian(I*x), Q.real(x)) is True
+    assert ask(Q.antihermitian(I*x), Q.antihermitian(x)) is False
+    assert ask(Q.antihermitian(I*x), Q.complex(x)) is None
+    assert ask(Q.antihermitian(x*y), Q.antihermitian(x) & Q.real(y)) is True
+
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.real(z)) is None
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is None
+    assert ask(Q.antihermitian(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is False
+    assert ask(Q.antihermitian(x + y + z),
+        Q.imaginary(x) & Q.imaginary(y) & Q.imaginary(z)) is True
+
+
+@_both_exp_pow
+def test_imaginary():
+    assert ask(Q.imaginary(x)) is None
+    assert ask(Q.imaginary(x), Q.real(x)) is False
+    assert ask(Q.imaginary(x), Q.prime(x)) is False
+
+    assert ask(Q.imaginary(x + 1), Q.real(x)) is False
+    assert ask(Q.imaginary(x + 1), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x + I), Q.real(x)) is False
+    assert ask(Q.imaginary(x + I), Q.imaginary(x)) is True
+    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.imaginary(y)) is True
+    assert ask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x + y), Q.imaginary(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x + y), Q.complex(x) & Q.real(y)) is None
+    assert ask(
+        Q.imaginary(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is False
+    assert ask(Q.imaginary(x + y + z),
+        Q.real(x) & Q.real(y) & Q.imaginary(z)) is None
+    assert ask(Q.imaginary(x + y + z),
+        Q.real(x) & Q.imaginary(y) & Q.imaginary(z)) is False
+
+    assert ask(Q.imaginary(I*x), Q.real(x)) is True
+    assert ask(Q.imaginary(I*x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(I*x), Q.complex(x)) is None
+    assert ask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) is True
+    assert ask(Q.imaginary(x*y), Q.real(x) & Q.real(y)) is False
+
+    assert ask(Q.imaginary(I**x), Q.negative(x)) is None
+    assert ask(Q.imaginary(I**x), Q.positive(x)) is None
+    assert ask(Q.imaginary(I**x), Q.even(x)) is False
+    assert ask(Q.imaginary(I**x), Q.odd(x)) is True
+    assert ask(Q.imaginary(I**x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary((2*I)**x), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x**0), Q.imaginary(x)) is False
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.integer(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(y) & Q.integer(x)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.odd(y)) is True
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.rational(y)) is None
+    assert ask(Q.imaginary(x**y), Q.imaginary(x) & Q.even(y)) is False
+
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.integer(y)) is False
+    assert ask(Q.imaginary(x**y), Q.positive(x) & Q.real(y)) is False
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.real(y)) is None
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.real(y) & ~Q.rational(y)) is False
+    assert ask(Q.imaginary(x**y), Q.integer(x) & Q.imaginary(y)) is None
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y) & Q.integer(2*y)) is True
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y) & ~Q.integer(2*y)) is False
+    assert ask(Q.imaginary(x**y), Q.negative(x) & Q.rational(y)) is None
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.rational(y) & ~Q.integer(2*y)) is False
+    assert ask(Q.imaginary(x**y), Q.real(x) & Q.rational(y) & Q.integer(2*y)) is None
+
+    # logarithm
+    assert ask(Q.imaginary(log(I))) is True
+    assert ask(Q.imaginary(log(2*I))) is False
+    assert ask(Q.imaginary(log(I + 1))) is False
+    assert ask(Q.imaginary(log(x)), Q.complex(x)) is None
+    assert ask(Q.imaginary(log(x)), Q.imaginary(x)) is None
+    assert ask(Q.imaginary(log(x)), Q.positive(x)) is False
+    assert ask(Q.imaginary(log(exp(x))), Q.complex(x)) is None
+    assert ask(Q.imaginary(log(exp(x))), Q.imaginary(x)) is None  # zoo/I/a+I*b
+    assert ask(Q.imaginary(log(exp(I)))) is True
+
+    # exponential
+    assert ask(Q.imaginary(exp(x)**x), Q.imaginary(x)) is False
+    eq = Pow(exp(pi*I*x, evaluate=False), x, evaluate=False)
+    assert ask(Q.imaginary(eq), Q.even(x)) is False
+    eq = Pow(exp(pi*I*x/2, evaluate=False), x, evaluate=False)
+    assert ask(Q.imaginary(eq), Q.odd(x)) is True
+    assert ask(Q.imaginary(exp(3*I*pi*x)**x), Q.integer(x)) is False
+    assert ask(Q.imaginary(exp(2*pi*I, evaluate=False))) is False
+    assert ask(Q.imaginary(exp(pi*I/2, evaluate=False))) is True
+
+    # issue 7886
+    assert ask(Q.imaginary(Pow(x, Rational(1, 4))), Q.real(x) & Q.negative(x)) is False
+
+
+def test_integer():
+    assert ask(Q.integer(x)) is None
+    assert ask(Q.integer(x), Q.integer(x)) is True
+    assert ask(Q.integer(x), ~Q.integer(x)) is False
+    assert ask(Q.integer(x), ~Q.real(x)) is False
+    assert ask(Q.integer(x), ~Q.positive(x)) is None
+    assert ask(Q.integer(x), Q.even(x) | Q.odd(x)) is True
+
+    assert ask(Q.integer(2*x), Q.integer(x)) is True
+    assert ask(Q.integer(2*x), Q.even(x)) is True
+    assert ask(Q.integer(2*x), Q.prime(x)) is True
+    assert ask(Q.integer(2*x), Q.rational(x)) is None
+    assert ask(Q.integer(2*x), Q.real(x)) is None
+    assert ask(Q.integer(sqrt(2)*x), Q.integer(x)) is False
+    assert ask(Q.integer(sqrt(2)*x), Q.irrational(x)) is None
+
+    assert ask(Q.integer(x/2), Q.odd(x)) is False
+    assert ask(Q.integer(x/2), Q.even(x)) is True
+    assert ask(Q.integer(x/3), Q.odd(x)) is None
+    assert ask(Q.integer(x/3), Q.even(x)) is None
+
+    # https://github.com/sympy/sympy/issues/7286
+    assert ask(Q.integer(Abs(x)),Q.integer(x)) is True
+    assert ask(Q.integer(Abs(-x)),Q.integer(x)) is True
+    assert ask(Q.integer(Abs(x)), ~Q.integer(x)) is None
+    assert ask(Q.integer(Abs(x)),Q.complex(x)) is None
+    assert ask(Q.integer(Abs(x+I*y)),Q.real(x) & Q.real(y)) is None
+
+    # https://github.com/sympy/sympy/issues/27739
+    assert ask(Q.integer(x/y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.integer(1/x), Q.integer(x)) is None
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.integer(sqrt(5))) is False
+    assert ask(Q.integer(x**y), Q.nonzero(x) & Q.zero(y)) is True
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(-1**x), Q.integer(x)) is True
+    assert ask(Q.integer(x**y), Q.integer(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(x**y), Q.zero(x) & Q.integer(y) & Q.positive(y)) is True
+    assert ask(Q.integer(pi**x), Q.zero(x)) is True
+    assert ask(Q.integer(x**y), Q.imaginary(x) & Q.zero(y)) is True
+
+
+def test_negative():
+    assert ask(Q.negative(x), Q.negative(x)) is True
+    assert ask(Q.negative(x), Q.positive(x)) is False
+    assert ask(Q.negative(x), ~Q.real(x)) is False
+    assert ask(Q.negative(x), Q.prime(x)) is False
+    assert ask(Q.negative(x), ~Q.prime(x)) is None
+
+    assert ask(Q.negative(-x), Q.positive(x)) is True
+    assert ask(Q.negative(-x), ~Q.positive(x)) is None
+    assert ask(Q.negative(-x), Q.negative(x)) is False
+    assert ask(Q.negative(-x), Q.positive(x)) is True
+
+    assert ask(Q.negative(x - 1), Q.negative(x)) is True
+    assert ask(Q.negative(x + y)) is None
+    assert ask(Q.negative(x + y), Q.negative(x)) is None
+    assert ask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) is True
+    assert ask(Q.negative(x + y), Q.negative(x) & Q.nonpositive(y)) is True
+    assert ask(Q.negative(2 + I)) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.negative(cos(I)**2 + sin(I)**2 - 1)) is None
+    assert ask(Q.negative(-I + I*(cos(2)**2 + sin(2)**2))) is None
+
+    assert ask(Q.negative(x**2)) is None
+    assert ask(Q.negative(x**2), Q.real(x)) is False
+    assert ask(Q.negative(x**1.4), Q.real(x)) is None
+
+    assert ask(Q.negative(x**I), Q.positive(x)) is None
+
+    assert ask(Q.negative(x*y)) is None
+    assert ask(Q.negative(x*y), Q.positive(x) & Q.positive(y)) is False
+    assert ask(Q.negative(x*y), Q.positive(x) & Q.negative(y)) is True
+    assert ask(Q.negative(x*y), Q.complex(x) & Q.complex(y)) is None
+
+    assert ask(Q.negative(x**y)) is None
+    assert ask(Q.negative(x**y), Q.negative(x) & Q.even(y)) is False
+    assert ask(Q.negative(x**y), Q.negative(x) & Q.odd(y)) is True
+    assert ask(Q.negative(x**y), Q.positive(x) & Q.integer(y)) is False
+
+    assert ask(Q.negative(Abs(x))) is False
+
+
+def test_nonzero():
+    assert ask(Q.nonzero(x)) is None
+    assert ask(Q.nonzero(x), Q.real(x)) is None
+    assert ask(Q.nonzero(x), Q.positive(x)) is True
+    assert ask(Q.nonzero(x), Q.negative(x)) is True
+    assert ask(Q.nonzero(x), Q.negative(x) | Q.positive(x)) is True
+
+    assert ask(Q.nonzero(x + y)) is None
+    assert ask(Q.nonzero(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.nonzero(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.nonzero(x + y), Q.negative(x) & Q.negative(y)) is True
+
+    assert ask(Q.nonzero(2*x)) is None
+    assert ask(Q.nonzero(2*x), Q.positive(x)) is True
+    assert ask(Q.nonzero(2*x), Q.negative(x)) is True
+    assert ask(Q.nonzero(x*y), Q.nonzero(x)) is None
+    assert ask(Q.nonzero(x*y), Q.nonzero(x) & Q.nonzero(y)) is True
+
+    assert ask(Q.nonzero(x**y), Q.nonzero(x)) is True
+
+    assert ask(Q.nonzero(Abs(x))) is None
+    assert ask(Q.nonzero(Abs(x)), Q.nonzero(x)) is True
+
+    assert ask(Q.nonzero(log(exp(2*I)))) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.nonzero(cos(1)**2 + sin(1)**2 - 1)) is None
+
+
+def test_zero():
+    assert ask(Q.zero(x)) is None
+    assert ask(Q.zero(x), Q.real(x)) is None
+    assert ask(Q.zero(x), Q.positive(x)) is False
+    assert ask(Q.zero(x), Q.negative(x)) is False
+    assert ask(Q.zero(x), Q.negative(x) | Q.positive(x)) is False
+
+    assert ask(Q.zero(x), Q.nonnegative(x) & Q.nonpositive(x)) is True
+
+    assert ask(Q.zero(x + y)) is None
+    assert ask(Q.zero(x + y), Q.positive(x) & Q.positive(y)) is False
+    assert ask(Q.zero(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.zero(x + y), Q.negative(x) & Q.negative(y)) is False
+
+    assert ask(Q.zero(2*x)) is None
+    assert ask(Q.zero(2*x), Q.positive(x)) is False
+    assert ask(Q.zero(2*x), Q.negative(x)) is False
+    assert ask(Q.zero(x*y), Q.nonzero(x)) is None
+
+    assert ask(Q.zero(Abs(x))) is None
+    assert ask(Q.zero(Abs(x)), Q.zero(x)) is True
+
+    assert ask(Q.integer(x), Q.zero(x)) is True
+    assert ask(Q.even(x), Q.zero(x)) is True
+    assert ask(Q.odd(x), Q.zero(x)) is False
+    assert ask(Q.zero(x), Q.even(x)) is None
+    assert ask(Q.zero(x), Q.odd(x)) is False
+    assert ask(Q.zero(x) | Q.zero(y), Q.zero(x*y)) is True
+
+
+def test_odd_query():
+    assert ask(Q.odd(x)) is None
+    assert ask(Q.odd(x), Q.odd(x)) is True
+    assert ask(Q.odd(x), Q.integer(x)) is None
+    assert ask(Q.odd(x), ~Q.integer(x)) is False
+    assert ask(Q.odd(x), Q.rational(x)) is None
+    assert ask(Q.odd(x), Q.positive(x)) is None
+
+    assert ask(Q.odd(-x), Q.odd(x)) is True
+
+    assert ask(Q.odd(2*x)) is None
+    assert ask(Q.odd(2*x), Q.integer(x)) is False
+    assert ask(Q.odd(2*x), Q.odd(x)) is False
+    assert ask(Q.odd(2*x), Q.irrational(x)) is False
+    assert ask(Q.odd(2*x), ~Q.integer(x)) is None
+    assert ask(Q.odd(3*x), Q.integer(x)) is None
+
+    assert ask(Q.odd(x/3), Q.odd(x)) is None
+    assert ask(Q.odd(x/3), Q.even(x)) is None
+
+    assert ask(Q.odd(x + 1), Q.even(x)) is True
+    assert ask(Q.odd(x + 2), Q.even(x)) is False
+    assert ask(Q.odd(x + 2), Q.odd(x)) is True
+    assert ask(Q.odd(3 - x), Q.odd(x)) is False
+    assert ask(Q.odd(3 - x), Q.even(x)) is True
+    assert ask(Q.odd(3 + x), Q.odd(x)) is False
+    assert ask(Q.odd(3 + x), Q.even(x)) is True
+    assert ask(Q.odd(x + y), Q.odd(x) & Q.odd(y)) is False
+    assert ask(Q.odd(x + y), Q.odd(x) & Q.even(y)) is True
+    assert ask(Q.odd(x - y), Q.even(x) & Q.odd(y)) is True
+    assert ask(Q.odd(x - y), Q.odd(x) & Q.odd(y)) is False
+
+    assert ask(Q.odd(x + y + z), Q.odd(x) & Q.odd(y) & Q.even(z)) is False
+    assert ask(Q.odd(x + y + z + t),
+        Q.odd(x) & Q.odd(y) & Q.even(z) & Q.integer(t)) is None
+
+    assert ask(Q.odd(2*x + 1), Q.integer(x)) is True
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.odd(y)) is True
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.even(y)) is False
+    assert ask(Q.odd(2*x + y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.odd(x*y), Q.odd(x) & Q.even(y)) is False
+    assert ask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+    assert ask(Q.odd(2*x*y), Q.rational(x) & Q.rational(x)) is None
+    assert ask(Q.odd(2*x*y), Q.irrational(x) & Q.irrational(x)) is None
+
+    assert ask(Q.odd(Abs(x)), Q.odd(x)) is True
+
+    assert ask(Q.odd((-1)**n), Q.integer(n)) is True
+
+    assert ask(Q.odd(k**2), Q.even(k)) is False
+    assert ask(Q.odd(n**2), Q.odd(n)) is True
+    assert ask(Q.odd(3**k), Q.even(k)) is None
+
+    assert ask(Q.odd(k**m), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(n**m), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is True
+
+    assert ask(Q.odd(k**p), Q.even(k) & Q.integer(p) & Q.positive(p)) is False
+    assert ask(Q.odd(n**p), Q.odd(n) & Q.integer(p) & Q.positive(p)) is True
+
+    assert ask(Q.odd(m**k), Q.even(k) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(p**k), Q.even(k) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.odd(m**n), Q.odd(n) & Q.integer(m) & ~Q.negative(m)) is None
+    assert ask(Q.odd(p**n), Q.odd(n) & Q.integer(p) & Q.positive(p)) is None
+
+    assert ask(Q.odd(k**x), Q.even(k)) is None
+    assert ask(Q.odd(n**x), Q.odd(n)) is None
+
+    assert ask(Q.odd(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.odd(x*x), Q.integer(x)) is None
+    assert ask(Q.odd(x*(x + y)), Q.integer(x) & Q.odd(y)) is False
+    assert ask(Q.odd(x*(x + y)), Q.integer(x) & Q.even(y)) is None
+
+
+@XFAIL
+def test_oddness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    assert ask(Q.odd(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is False
+    assert ask(Q.odd(y*x*(x + z)), Q.integer(x) & Q.integer(y) & Q.odd(z)) is False
+
+
+def test_oddness_in_ternary_integer_product_with_even():
+    assert ask(Q.odd(x*y*(y + z)), Q.integer(x) & Q.integer(y) & Q.even(z)) is None
+
+
+def test_prime():
+    assert ask(Q.prime(x), Q.prime(x)) is True
+    assert ask(Q.prime(x), ~Q.prime(x)) is False
+    assert ask(Q.prime(x), Q.integer(x)) is None
+    assert ask(Q.prime(x), ~Q.integer(x)) is False
+
+    assert ask(Q.prime(2*x), Q.integer(x)) is None
+    assert ask(Q.prime(x*y)) is None
+    assert ask(Q.prime(x*y), Q.prime(x)) is None
+    assert ask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.prime(4*x), Q.integer(x)) is False
+    assert ask(Q.prime(4*x)) is None
+
+    assert ask(Q.prime(x**2), Q.integer(x)) is False
+    assert ask(Q.prime(x**2), Q.prime(x)) is False
+
+    # https://github.com/sympy/sympy/issues/27446
+    assert ask(Q.prime(4**x), Q.integer(x)) is False
+    assert ask(Q.prime(p**x), Q.prime(p) & Q.integer(x) & Q.ne(x, 1)) is False
+    assert ask(Q.prime(n**x), Q.integer(x) & Q.composite(n)) is False
+    assert ask(Q.prime(x**y), Q.integer(x) & Q.integer(y)) is None
+    assert ask(Q.prime(2**x), Q.integer(x)) is None
+    assert ask(Q.prime(p**x), Q.prime(p) & Q.integer(x)) is None
+
+    # Ideally, these should return True since the base is prime and the exponent is one,
+    # but currently, they return None.
+    assert ask(Q.prime(x**y), Q.prime(x) & Q.eq(y,1)) is None
+    assert ask(Q.prime(x**y), Q.prime(x) & Q.integer(y) & Q.gt(y,0) & Q.lt(y,2)) is None
+
+    assert ask(Q.prime(Pow(x,1, evaluate=False)), Q.prime(x)) is True
+
+
+@_both_exp_pow
+def test_positive():
+    assert ask(Q.positive(cos(I) ** 2 + sin(I) ** 2 - 1)) is None
+    assert ask(Q.positive(x), Q.positive(x)) is True
+    assert ask(Q.positive(x), Q.negative(x)) is False
+    assert ask(Q.positive(x), Q.nonzero(x)) is None
+
+    assert ask(Q.positive(-x), Q.positive(x)) is False
+    assert ask(Q.positive(-x), Q.negative(x)) is True
+
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.nonnegative(y)) is True
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.negative(y)) is None
+    assert ask(Q.positive(x + y), Q.positive(x) & Q.imaginary(y)) is False
+
+    assert ask(Q.positive(2*x), Q.positive(x)) is True
+    assumptions = Q.positive(x) & Q.negative(y) & Q.negative(z) & Q.positive(w)
+    assert ask(Q.positive(x*y*z)) is None
+    assert ask(Q.positive(x*y*z), assumptions) is True
+    assert ask(Q.positive(-x*y*z), assumptions) is False
+
+    assert ask(Q.positive(x**I), Q.positive(x)) is None
+
+    assert ask(Q.positive(x**2), Q.positive(x)) is True
+    assert ask(Q.positive(x**2), Q.negative(x)) is True
+    assert ask(Q.positive(x**3), Q.negative(x)) is False
+    assert ask(Q.positive(1/(1 + x**2)), Q.real(x)) is True
+    assert ask(Q.positive(2**I)) is False
+    assert ask(Q.positive(2 + I)) is False
+    # although this could be False, it is representative of expressions
+    # that don't evaluate to a zero with precision
+    assert ask(Q.positive(cos(I)**2 + sin(I)**2 - 1)) is None
+    assert ask(Q.positive(-I + I*(cos(2)**2 + sin(2)**2))) is None
+
+    #exponential
+    assert ask(Q.positive(exp(x)), Q.real(x)) is True
+    assert ask(~Q.negative(exp(x)), Q.real(x)) is True
+    assert ask(Q.positive(x + exp(x)), Q.real(x)) is None
+    assert ask(Q.positive(exp(x)), Q.imaginary(x)) is None
+    assert ask(Q.positive(exp(2*pi*I, evaluate=False)), Q.imaginary(x)) is True
+    assert ask(Q.negative(exp(pi*I, evaluate=False)), Q.imaginary(x)) is True
+    assert ask(Q.positive(exp(x*pi*I)), Q.even(x)) is True
+    assert ask(Q.positive(exp(x*pi*I)), Q.odd(x)) is False
+    assert ask(Q.positive(exp(x*pi*I)), Q.real(x)) is None
+
+    # logarithm
+    assert ask(Q.positive(log(x)), Q.imaginary(x)) is False
+    assert ask(Q.positive(log(x)), Q.negative(x)) is False
+    assert ask(Q.positive(log(x)), Q.positive(x)) is None
+    assert ask(Q.positive(log(x + 2)), Q.positive(x)) is True
+
+    # factorial
+    assert ask(Q.positive(factorial(x)), Q.integer(x) & Q.positive(x))
+    assert ask(Q.positive(factorial(x)), Q.integer(x)) is None
+
+    #absolute value
+    assert ask(Q.positive(Abs(x))) is None  # Abs(0) = 0
+    assert ask(Q.positive(Abs(x)), Q.positive(x)) is True
+
+
+def test_nonpositive():
+    assert ask(Q.nonpositive(-1))
+    assert ask(Q.nonpositive(0))
+    assert ask(Q.nonpositive(1)) is False
+    assert ask(~Q.positive(x), Q.nonpositive(x))
+    assert ask(Q.nonpositive(x), Q.positive(x)) is False
+    assert ask(Q.nonpositive(sqrt(-1))) is False
+    assert ask(Q.nonpositive(x), Q.imaginary(x)) is False
+
+
+def test_nonnegative():
+    assert ask(Q.nonnegative(-1)) is False
+    assert ask(Q.nonnegative(0))
+    assert ask(Q.nonnegative(1))
+    assert ask(~Q.negative(x), Q.nonnegative(x))
+    assert ask(Q.nonnegative(x), Q.negative(x)) is False
+    assert ask(Q.nonnegative(sqrt(-1))) is False
+    assert ask(Q.nonnegative(x), Q.imaginary(x)) is False
+
+def test_real_basic():
+    assert ask(Q.real(x)) is None
+    assert ask(Q.real(x), Q.real(x)) is True
+    assert ask(Q.real(x), Q.nonzero(x)) is True
+    assert ask(Q.real(x), Q.positive(x)) is True
+    assert ask(Q.real(x), Q.negative(x)) is True
+    assert ask(Q.real(x), Q.integer(x)) is True
+    assert ask(Q.real(x), Q.even(x)) is True
+    assert ask(Q.real(x), Q.prime(x)) is True
+
+    assert ask(Q.real(x/sqrt(2)), Q.real(x)) is True
+    assert ask(Q.real(x/sqrt(-2)), Q.real(x)) is False
+
+    assert ask(Q.real(x + 1), Q.real(x)) is True
+    assert ask(Q.real(x + I), Q.real(x)) is False
+    assert ask(Q.real(x + I), Q.complex(x)) is None
+
+    assert ask(Q.real(2*x), Q.real(x)) is True
+    assert ask(Q.real(I*x), Q.real(x)) is False
+    assert ask(Q.real(I*x), Q.imaginary(x)) is True
+    assert ask(Q.real(I*x), Q.complex(x)) is None
+
+
+def test_real_pow():
+    assert ask(Q.real(x**2), Q.real(x)) is True
+    assert ask(Q.real(sqrt(x)), Q.negative(x)) is False
+    assert ask(Q.real(x**y), Q.real(x) & Q.integer(y)) is None
+    assert ask(Q.real(x**y), Q.real(x) & Q.real(y)) is None
+    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) is True
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.imaginary(y)) is None  # I**I or (2*I)**I
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.real(y)) is None  # I**1 or I**0
+    assert ask(Q.real(x**y), Q.real(x) & Q.imaginary(y)) is None  # could be exp(2*pi*I) or 2**I
+    assert ask(Q.real(x**0), Q.imaginary(x)) is True
+    assert ask(Q.real(x**y), Q.positive(x) & Q.real(y)) is True
+    assert ask(Q.real(x**y), Q.real(x) & Q.rational(y)) is None
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.integer(y)) is None
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.odd(y)) is False
+    assert ask(Q.real(x**y), Q.imaginary(x) & Q.even(y)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.rational(y/z) & Q.even(z) & Q.positive(x)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.rational(y/z) & Q.even(z) & Q.negative(x)) is None
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.integer(y/z)) is None
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.positive(x)) is True
+    assert ask(Q.real(x**(y/z)), Q.real(x) & Q.real(y/z) & Q.negative(x)) is None
+    assert ask(Q.real((-I)**i), Q.imaginary(i)) is True
+    assert ask(Q.real(I**i), Q.imaginary(i)) is True
+    assert ask(Q.real(i**i), Q.imaginary(i)) is None  # i might be 2*I
+    assert ask(Q.real(x**i), Q.imaginary(i)) is None  # x could be 0
+    assert ask(Q.real(x**(I*pi/log(x))), Q.real(x)) is True
+
+    # https://github.com/sympy/sympy/issues/27485
+    assert ask(Q.real(n**p), Q.negative(n) & Q.positive(p)) is None
+
+    # https://github.com/sympy/sympy/issues/16530
+    assert ask(Q.real(1/Abs(x))) is None
+    assert ask(Q.real(x**y), Q.zero(x) & Q.real(y)) is None
+    assert ask(Q.real(x**y), Q.zero(x) & Q.positive(y)) is True
+
+
+@_both_exp_pow
+def test_real_functions():
+    # trigonometric functions
+    assert ask(Q.real(sin(x))) is None
+    assert ask(Q.real(cos(x))) is None
+    assert ask(Q.real(sin(x)), Q.real(x)) is True
+    assert ask(Q.real(cos(x)), Q.real(x)) is True
+
+    # exponential function
+    assert ask(Q.real(exp(x))) is None
+    assert ask(Q.real(exp(x)), Q.real(x)) is True
+    assert ask(Q.real(x + exp(x)), Q.real(x)) is True
+    assert ask(Q.real(exp(2*pi*I, evaluate=False))) is True
+    assert ask(Q.real(exp(pi*I, evaluate=False))) is True
+    assert ask(Q.real(exp(pi*I/2, evaluate=False))) is False
+
+    # logarithm
+    assert ask(Q.real(log(I))) is False
+    assert ask(Q.real(log(2*I))) is False
+    assert ask(Q.real(log(I + 1))) is False
+    assert ask(Q.real(log(x)), Q.complex(x)) is None
+    assert ask(Q.real(log(x)), Q.imaginary(x)) is False
+    assert ask(Q.real(log(exp(x))), Q.imaginary(x)) is None  # exp(2*pi*I) is 1, log(exp(pi*I)) is pi*I (disregarding periodicity)
+    assert ask(Q.real(log(exp(x))), Q.complex(x)) is None
+    eq = Pow(exp(2*pi*I*x, evaluate=False), x, evaluate=False)
+    assert ask(Q.real(eq), Q.integer(x)) is True
+    assert ask(Q.real(exp(x)**x), Q.imaginary(x)) is True
+    assert ask(Q.real(exp(x)**x), Q.complex(x)) is None
+
+    # Q.complexes
+    assert ask(Q.real(re(x))) is True
+    assert ask(Q.real(im(x))) is True
+
+
+def test_matrix():
+
+    # hermitian
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, 4], [2 - I, 3, I], [4, -I, 1]]))) == True
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, 4], [2 + I, 3, I], [4, -I, 1]]))) == False
+    z = symbols('z', complex=True)
+    assert ask(Q.hermitian(Matrix([[2, 2 + I, z], [2 - I, 3, I], [4, -I, 1]]))) == None
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11))))) == True
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, I, 0), (-5, 0, 11))))) == False
+    assert ask(Q.hermitian(SparseMatrix(((25, 15, -5), (15, z, 0), (-5, 0, 11))))) == None
+
+    # antihermitian
+    A = Matrix([[0, -2 - I, 0], [2 - I, 0, -I], [0, -I, 0]])
+    B = Matrix([[-I, 2 + I, 0], [-2 + I, 0, 2 + I], [0, -2 + I, -I]])
+    assert ask(Q.antihermitian(A)) is True
+    assert ask(Q.antihermitian(B)) is True
+    assert ask(Q.antihermitian(A**2)) is False
+    C = (B**3)
+    C.simplify()
+    assert ask(Q.antihermitian(C)) is True
+    _A = Matrix([[0, -2 - I, 0], [z, 0, -I], [0, -I, 0]])
+    assert ask(Q.antihermitian(_A)) is None
+
+
+@_both_exp_pow
+def test_algebraic():
+    assert ask(Q.algebraic(x)) is None
+
+    assert ask(Q.algebraic(I)) is True
+    assert ask(Q.algebraic(2*I)) is True
+    assert ask(Q.algebraic(I/3)) is True
+
+    assert ask(Q.algebraic(sqrt(7))) is True
+    assert ask(Q.algebraic(2*sqrt(7))) is True
+    assert ask(Q.algebraic(sqrt(7)/3)) is True
+
+    assert ask(Q.algebraic(I*sqrt(3))) is True
+    assert ask(Q.algebraic(sqrt(1 + I*sqrt(3)))) is True
+
+    assert ask(Q.algebraic(1 + I*sqrt(3)**Rational(17, 31))) is True
+    assert ask(Q.algebraic(1 + I*sqrt(3)**(17/pi))) is None
+
+    for f in [exp, sin, tan, asin, atan, cos]:
+        assert ask(Q.algebraic(f(7))) is False
+        assert ask(Q.algebraic(f(7, evaluate=False))) is False
+        assert ask(Q.algebraic(f(0, evaluate=False))) is True
+        assert ask(Q.algebraic(f(x)), Q.algebraic(x)) is None
+        assert ask(Q.algebraic(f(x)), Q.algebraic(x) & Q.nonzero(x)) is False
+
+    for g in [log, acos]:
+        assert ask(Q.algebraic(g(7))) is False
+        assert ask(Q.algebraic(g(7, evaluate=False))) is False
+        assert ask(Q.algebraic(g(1, evaluate=False))) is True
+        assert ask(Q.algebraic(g(x)), Q.algebraic(x)) is None
+        assert ask(Q.algebraic(g(x)), Q.algebraic(x) & Q.nonzero(x - 1)) is False
+
+    for h in [cot, acot]:
+        assert ask(Q.algebraic(h(7))) is False
+        assert ask(Q.algebraic(h(7, evaluate=False))) is False
+        assert ask(Q.algebraic(h(x)), Q.algebraic(x)) is False
+
+    assert ask(Q.algebraic(sqrt(sin(7)))) is None
+    assert ask(Q.algebraic(sqrt(y + I*sqrt(7)))) is None
+
+    assert ask(Q.algebraic(2.47)) is True
+
+    assert ask(Q.algebraic(x), Q.transcendental(x)) is False
+    assert ask(Q.transcendental(x), Q.algebraic(x)) is False
+
+    #https://github.com/sympy/sympy/issues/27445
+    assert ask(Q.algebraic(Pow(1, x, evaluate=False)), Q.algebraic(x)) is None
+    assert ask(Q.algebraic(Pow(x, y))) is None
+    assert ask(Q.algebraic(Pow(1, x, evaluate=False))) is None
+    assert ask(Q.algebraic(x**(pi*I))) is None
+    assert ask(Q.algebraic(pi**n),Q.integer(n) & Q.positive(n)) is False
+    assert ask(Q.algebraic(x**y),Q.algebraic(x) & Q.rational(y)) is True
+
+
+def test_global():
+    """Test ask with global assumptions"""
+    assert ask(Q.integer(x)) is None
+    global_assumptions.add(Q.integer(x))
+    assert ask(Q.integer(x)) is True
+    global_assumptions.clear()
+    assert ask(Q.integer(x)) is None
+
+
+def test_custom_context():
+    """Test ask with custom assumptions context"""
+    assert ask(Q.integer(x)) is None
+    local_context = AssumptionsContext()
+    local_context.add(Q.integer(x))
+    assert ask(Q.integer(x), context=local_context) is True
+    assert ask(Q.integer(x)) is None
+
+
+def test_functions_in_assumptions():
+    assert ask(Q.negative(x), Q.real(x) >> Q.positive(x)) is False
+    assert ask(Q.negative(x), Equivalent(Q.real(x), Q.positive(x))) is False
+    assert ask(Q.negative(x), Xor(Q.real(x), Q.negative(x))) is False
+
+
+def test_composite_ask():
+    assert ask(Q.negative(x) & Q.integer(x),
+        assumptions=Q.real(x) >> Q.positive(x)) is False
+
+
+def test_composite_proposition():
+    assert ask(True) is True
+    assert ask(False) is False
+    assert ask(~Q.negative(x), Q.positive(x)) is True
+    assert ask(~Q.real(x), Q.commutative(x)) is None
+    assert ask(Q.negative(x) & Q.integer(x), Q.positive(x)) is False
+    assert ask(Q.negative(x) & Q.integer(x)) is None
+    assert ask(Q.real(x) | Q.integer(x), Q.positive(x)) is True
+    assert ask(Q.real(x) | Q.integer(x)) is None
+    assert ask(Q.real(x) >> Q.positive(x), Q.negative(x)) is False
+    assert ask(Implies(
+        Q.real(x), Q.positive(x), evaluate=False), Q.negative(x)) is False
+    assert ask(Implies(Q.real(x), Q.positive(x), evaluate=False)) is None
+    assert ask(Equivalent(Q.integer(x), Q.even(x)), Q.even(x)) is True
+    assert ask(Equivalent(Q.integer(x), Q.even(x))) is None
+    assert ask(Equivalent(Q.positive(x), Q.integer(x)), Q.integer(x)) is None
+    assert ask(Q.real(x) | Q.integer(x), Q.real(x) | Q.integer(x)) is True
+
+def test_tautology():
+    assert ask(Q.real(x) | ~Q.real(x)) is True
+    assert ask(Q.real(x) & ~Q.real(x)) is False
+
+def test_composite_assumptions():
+    assert ask(Q.real(x), Q.real(x) & Q.real(y)) is True
+    assert ask(Q.positive(x), Q.positive(x) | Q.positive(y)) is None
+    assert ask(Q.positive(x), Q.real(x) >> Q.positive(y)) is None
+    assert ask(Q.real(x), ~(Q.real(x) >> Q.real(y))) is True
+
+def test_key_extensibility():
+    """test that you can add keys to the ask system at runtime"""
+    # make sure the key is not defined
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+    # Old handler system
+    class MyAskHandler(AskHandler):
+        @staticmethod
+        def Symbol(expr, assumptions):
+            return True
+    try:
+        with warns_deprecated_sympy():
+            register_handler('my_key', MyAskHandler)
+        with warns_deprecated_sympy():
+            assert ask(Q.my_key(x)) is True
+        with warns_deprecated_sympy():
+            assert ask(Q.my_key(x + 1)) is None
+    finally:
+        # We have to disable the stacklevel testing here because this raises
+        # the warning twice from two different places
+        with warns_deprecated_sympy():
+            remove_handler('my_key', MyAskHandler)
+        del Q.my_key
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+    # New handler system
+    class MyPredicate(Predicate):
+        pass
+    try:
+        Q.my_key = MyPredicate()
+        @Q.my_key.register(Symbol)
+        def _(expr, assumptions):
+            return True
+        assert ask(Q.my_key(x)) is True
+        assert ask(Q.my_key(x+1)) is None
+    finally:
+        del Q.my_key
+    raises(AttributeError, lambda: ask(Q.my_key(x)))
+
+
+def test_type_extensibility():
+    """test that new types can be added to the ask system at runtime
+    """
+    from sympy.core import Basic
+
+    class MyType(Basic):
+        pass
+
+    @Q.prime.register(MyType)
+    def _(expr, assumptions):
+        return True
+
+    assert ask(Q.prime(MyType())) is True
+
+
+def test_single_fact_lookup():
+    known_facts = And(Implies(Q.integer, Q.rational),
+                      Implies(Q.rational, Q.real),
+                      Implies(Q.real, Q.complex))
+    known_facts_keys = {Q.integer, Q.rational, Q.real, Q.complex}
+
+    known_facts_cnf = to_cnf(known_facts)
+    mapping = single_fact_lookup(known_facts_keys, known_facts_cnf)
+
+    assert mapping[Q.rational] == {Q.real, Q.rational, Q.complex}
+
+
+def test_generate_known_facts_dict():
+    known_facts = And(Implies(Q.integer(x), Q.rational(x)),
+                      Implies(Q.rational(x), Q.real(x)),
+                      Implies(Q.real(x), Q.complex(x)))
+    known_facts_keys = {Q.integer(x), Q.rational(x), Q.real(x), Q.complex(x)}
+
+    assert generate_known_facts_dict(known_facts_keys, known_facts) == \
+        {Q.complex: ({Q.complex}, set()),
+         Q.integer: ({Q.complex, Q.integer, Q.rational, Q.real}, set()),
+         Q.rational: ({Q.complex, Q.rational, Q.real}, set()),
+         Q.real: ({Q.complex, Q.real}, set())}
+
+
+@slow
+def test_known_facts_consistent():
+    """"Test that ask_generated.py is up-to-date"""
+    x = Symbol('x')
+    fact = get_known_facts(x)
+    # test cnf clauses of fact between unary predicates
+    cnf = CNF.to_CNF(fact)
+    clauses = set()
+    clauses.update(frozenset(Literal(lit.arg.function, lit.is_Not) for lit in sorted(cl, key=str)) for cl in cnf.clauses)
+    assert get_all_known_facts() == clauses
+    # test dictionary of fact between unary predicates
+    keys = [pred(x) for pred in get_known_facts_keys()]
+    mapping = generate_known_facts_dict(keys, fact)
+    assert get_known_facts_dict() == mapping
+
+
+def test_Add_queries():
+    assert ask(Q.prime(12345678901234567890 + (cos(1)**2 + sin(1)**2))) is True
+    assert ask(Q.even(Add(S(2), S(2), evaluate=False))) is True
+    assert ask(Q.prime(Add(S(2), S(2), evaluate=False))) is False
+    assert ask(Q.integer(Add(S(2), S(2), evaluate=False))) is True
+
+
+def test_positive_assuming():
+    with assuming(Q.positive(x + 1)):
+        assert not ask(Q.positive(x))
+
+
+def test_issue_5421():
+    raises(TypeError, lambda: ask(pi/log(x), Q.real))
+
+
+def test_issue_3906():
+    raises(TypeError, lambda: ask(Q.positive))
+
+
+def test_issue_5833():
+    assert ask(Q.positive(log(x)**2), Q.positive(x)) is None
+    assert ask(~Q.negative(log(x)**2), Q.positive(x)) is True
+
+
+def test_issue_6732():
+    raises(ValueError, lambda: ask(Q.positive(x), Q.positive(x) & Q.negative(x)))
+    raises(ValueError, lambda: ask(Q.negative(x), Q.positive(x) & Q.negative(x)))
+
+
+def test_issue_7246():
+    assert ask(Q.positive(atan(p)), Q.positive(p)) is True
+    assert ask(Q.positive(atan(p)), Q.negative(p)) is False
+    assert ask(Q.positive(atan(p)), Q.zero(p)) is False
+    assert ask(Q.positive(atan(x))) is None
+
+    assert ask(Q.positive(asin(p)), Q.positive(p)) is None
+    assert ask(Q.positive(asin(p)), Q.zero(p)) is None
+    assert ask(Q.positive(asin(Rational(1, 7)))) is True
+    assert ask(Q.positive(asin(x)), Q.positive(x) & Q.nonpositive(x - 1)) is True
+    assert ask(Q.positive(asin(x)), Q.negative(x) & Q.nonnegative(x + 1)) is False
+
+    assert ask(Q.positive(acos(p)), Q.positive(p)) is None
+    assert ask(Q.positive(acos(Rational(1, 7)))) is True
+    assert ask(Q.positive(acos(x)), Q.nonnegative(x + 1) & Q.nonpositive(x - 1)) is True
+    assert ask(Q.positive(acos(x)), Q.nonnegative(x - 1)) is None
+
+    assert ask(Q.positive(acot(x)), Q.positive(x)) is True
+    assert ask(Q.positive(acot(x)), Q.real(x)) is True
+    assert ask(Q.positive(acot(x)), Q.imaginary(x)) is False
+    assert ask(Q.positive(acot(x))) is None
+
+
+@XFAIL
+def test_issue_7246_failing():
+    #Move this test to test_issue_7246 once
+    #the new assumptions module is improved.
+    assert ask(Q.positive(acos(x)), Q.zero(x)) is True
+
+
+def test_check_old_assumption():
+    x = symbols('x', real=True)
+    assert ask(Q.real(x)) is True
+    assert ask(Q.imaginary(x)) is False
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', imaginary=True)
+    assert ask(Q.real(x)) is False
+    assert ask(Q.imaginary(x)) is True
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', complex=True)
+    assert ask(Q.real(x)) is None
+    assert ask(Q.complex(x)) is True
+
+    x = symbols('x', positive=True)
+    assert ask(Q.positive(x)) is True
+    assert ask(Q.negative(x)) is False
+    assert ask(Q.real(x)) is True
+
+    x = symbols('x', commutative=False)
+    assert ask(Q.commutative(x)) is False
+
+    x = symbols('x', negative=True)
+    assert ask(Q.positive(x)) is False
+    assert ask(Q.negative(x)) is True
+
+    x = symbols('x', nonnegative=True)
+    assert ask(Q.negative(x)) is False
+    assert ask(Q.positive(x)) is None
+    assert ask(Q.zero(x)) is None
+
+    x = symbols('x', finite=True)
+    assert ask(Q.finite(x)) is True
+
+    x = symbols('x', prime=True)
+    assert ask(Q.prime(x)) is True
+    assert ask(Q.composite(x)) is False
+
+    x = symbols('x', composite=True)
+    assert ask(Q.prime(x)) is False
+    assert ask(Q.composite(x)) is True
+
+    x = symbols('x', even=True)
+    assert ask(Q.even(x)) is True
+    assert ask(Q.odd(x)) is False
+
+    x = symbols('x', odd=True)
+    assert ask(Q.even(x)) is False
+    assert ask(Q.odd(x)) is True
+
+    x = symbols('x', nonzero=True)
+    assert ask(Q.nonzero(x)) is True
+    assert ask(Q.zero(x)) is False
+
+    x = symbols('x', zero=True)
+    assert ask(Q.zero(x)) is True
+
+    x = symbols('x', integer=True)
+    assert ask(Q.integer(x)) is True
+
+    x = symbols('x', rational=True)
+    assert ask(Q.rational(x)) is True
+    assert ask(Q.irrational(x)) is False
+
+    x = symbols('x', irrational=True)
+    assert ask(Q.irrational(x)) is True
+    assert ask(Q.rational(x)) is False
+
+
+def test_issue_9636():
+    assert ask(Q.integer(1.0)) is None
+    assert ask(Q.prime(3.0)) is None
+    assert ask(Q.composite(4.0)) is None
+    assert ask(Q.even(2.0)) is None
+    assert ask(Q.odd(3.0)) is None
+
+
+def test_autosimp_used_to_fail():
+    # See issue #9807
+    assert ask(Q.imaginary(0**I)) is None
+    assert ask(Q.imaginary(0**(-I))) is None
+    assert ask(Q.real(0**I)) is None
+    assert ask(Q.real(0**(-I))) is None
+
+
+def test_custom_AskHandler():
+    from sympy.logic.boolalg import conjuncts
+
+    # Old handler system
+    class MersenneHandler(AskHandler):
+        @staticmethod
+        def Integer(expr, assumptions):
+            if ask(Q.integer(log(expr + 1, 2))):
+                return True
+        @staticmethod
+        def Symbol(expr, assumptions):
+            if expr in conjuncts(assumptions):
+                return True
+    try:
+        with warns_deprecated_sympy():
+            register_handler('mersenne', MersenneHandler)
+        n = Symbol('n', integer=True)
+        with warns_deprecated_sympy():
+            assert ask(Q.mersenne(7))
+        with warns_deprecated_sympy():
+            assert ask(Q.mersenne(n), Q.mersenne(n))
+    finally:
+        del Q.mersenne
+
+    # New handler system
+    class MersennePredicate(Predicate):
+        pass
+    try:
+        Q.mersenne = MersennePredicate()
+        @Q.mersenne.register(Integer)
+        def _(expr, assumptions):
+            if ask(Q.integer(log(expr + 1, 2))):
+                return True
+        @Q.mersenne.register(Symbol)
+        def _(expr, assumptions):
+            if expr in conjuncts(assumptions):
+                return True
+        assert ask(Q.mersenne(7))
+        assert ask(Q.mersenne(n), Q.mersenne(n))
+    finally:
+        del Q.mersenne
+
+
+def test_polyadic_predicate():
+
+    class SexyPredicate(Predicate):
+        pass
+    try:
+        Q.sexyprime = SexyPredicate()
+
+        @Q.sexyprime.register(Integer, Integer)
+        def _(int1, int2, assumptions):
+            args = sorted([int1, int2])
+            if not all(ask(Q.prime(a), assumptions) for a in args):
+                return False
+            return args[1] - args[0] == 6
+
+        @Q.sexyprime.register(Integer, Integer, Integer)
+        def _(int1, int2, int3, assumptions):
+            args = sorted([int1, int2, int3])
+            if not all(ask(Q.prime(a), assumptions) for a in args):
+                return False
+            return args[2] - args[1] == 6 and args[1] - args[0] == 6
+
+        assert ask(Q.sexyprime(5, 11))
+        assert ask(Q.sexyprime(7, 13, 19))
+    finally:
+        del Q.sexyprime
+
+
+def test_Predicate_handler_is_unique():
+
+    # Undefined predicate does not have a handler
+    assert Predicate('mypredicate').handler is None
+
+    # Handler of defined predicate is unique to the class
+    class MyPredicate(Predicate):
+        pass
+    mp1 = MyPredicate(Str('mp1'))
+    mp2 = MyPredicate(Str('mp2'))
+    assert mp1.handler is mp2.handler
+
+
+def test_relational():
+    assert ask(Q.eq(x, 0), Q.zero(x))
+    assert not ask(Q.eq(x, 0), Q.nonzero(x))
+    assert not ask(Q.ne(x, 0), Q.zero(x))
+    assert ask(Q.ne(x, 0), Q.nonzero(x))
+
+
+def test_issue_25221():
+    assert ask(Q.transcendental(x), Q.algebraic(x) | Q.positive(y,y)) is None
+    assert ask(Q.transcendental(x), Q.algebraic(x) | (0 > y)) is None
+    assert ask(Q.transcendental(x), Q.algebraic(x) | Q.gt(0,y)) is None
+
+
+def test_issue_27440():
+    nan = S.NaN
+    assert ask(Q.negative(nan)) is None
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_refine.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_refine.py
new file mode 100644
index 0000000000000000000000000000000000000000..81533a88b232cd5c3cfb9be17d09dad404d679dc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_refine.py
@@ -0,0 +1,227 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.refine import refine
+from sympy.core.expr import Expr
+from sympy.core.numbers import (I, Rational, nan, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (Abs, arg, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (atan, atan2)
+from sympy.abc import w, x, y, z
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+
+
+def test_Abs():
+    assert refine(Abs(x), Q.positive(x)) == x
+    assert refine(1 + Abs(x), Q.positive(x)) == 1 + x
+    assert refine(Abs(x), Q.negative(x)) == -x
+    assert refine(1 + Abs(x), Q.negative(x)) == 1 - x
+
+    assert refine(Abs(x**2)) != x**2
+    assert refine(Abs(x**2), Q.real(x)) == x**2
+
+
+def test_pow1():
+    assert refine((-1)**x, Q.even(x)) == 1
+    assert refine((-1)**x, Q.odd(x)) == -1
+    assert refine((-2)**x, Q.even(x)) == 2**x
+
+    # nested powers
+    assert refine(sqrt(x**2)) != Abs(x)
+    assert refine(sqrt(x**2), Q.complex(x)) != Abs(x)
+    assert refine(sqrt(x**2), Q.real(x)) == Abs(x)
+    assert refine(sqrt(x**2), Q.positive(x)) == x
+    assert refine((x**3)**Rational(1, 3)) != x
+
+    assert refine((x**3)**Rational(1, 3), Q.real(x)) != x
+    assert refine((x**3)**Rational(1, 3), Q.positive(x)) == x
+
+    assert refine(sqrt(1/x), Q.real(x)) != 1/sqrt(x)
+    assert refine(sqrt(1/x), Q.positive(x)) == 1/sqrt(x)
+
+    # powers of (-1)
+    assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
+    assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
+    assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
+    assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
+    assert refine((-1)**(x + 3)) == (-1)**(x + 1)
+
+    # continuation
+    assert refine((-1)**((-1)**x/2 - S.Half), Q.integer(x)) == (-1)**x
+    assert refine((-1)**((-1)**x/2 + S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 + 5*S.Half), Q.integer(x)) == (-1)**(x + 1)
+
+
+def test_pow2():
+    assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
+    assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
+
+    # powers of Abs
+    assert refine(Abs(x)**2, Q.real(x)) == x**2
+    assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
+    assert refine(Abs(x)**2) == Abs(x)**2
+
+
+def test_exp():
+    x = Symbol('x', integer=True)
+    assert refine(exp(pi*I*2*x)) == 1
+    assert refine(exp(pi*I*2*(x + S.Half))) == -1
+    assert refine(exp(pi*I*2*(x + Rational(1, 4)))) == I
+    assert refine(exp(pi*I*2*(x + Rational(3, 4)))) == -I
+
+
+def test_Piecewise():
+    assert refine(Piecewise((1, x < 0), (3, True)), (x < 0)) == 1
+    assert refine(Piecewise((1, x < 0), (3, True)), ~(x < 0)) == 3
+    assert refine(Piecewise((1, x < 0), (3, True)), (y < 0)) == \
+        Piecewise((1, x < 0), (3, True))
+    assert refine(Piecewise((1, x > 0), (3, True)), (x > 0)) == 1
+    assert refine(Piecewise((1, x > 0), (3, True)), ~(x > 0)) == 3
+    assert refine(Piecewise((1, x > 0), (3, True)), (y > 0)) == \
+        Piecewise((1, x > 0), (3, True))
+    assert refine(Piecewise((1, x <= 0), (3, True)), (x <= 0)) == 1
+    assert refine(Piecewise((1, x <= 0), (3, True)), ~(x <= 0)) == 3
+    assert refine(Piecewise((1, x <= 0), (3, True)), (y <= 0)) == \
+        Piecewise((1, x <= 0), (3, True))
+    assert refine(Piecewise((1, x >= 0), (3, True)), (x >= 0)) == 1
+    assert refine(Piecewise((1, x >= 0), (3, True)), ~(x >= 0)) == 3
+    assert refine(Piecewise((1, x >= 0), (3, True)), (y >= 0)) == \
+        Piecewise((1, x >= 0), (3, True))
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(0, x)))\
+        == 1
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~(Eq(0, x)))\
+        == 3
+    assert refine(Piecewise((1, Eq(x, 0)), (3, True)), (Eq(y, 0)))\
+        == Piecewise((1, Eq(x, 0)), (3, True))
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(x, 0)))\
+        == 1
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), ~(Ne(x, 0)))\
+        == 3
+    assert refine(Piecewise((1, Ne(x, 0)), (3, True)), (Ne(y, 0)))\
+        == Piecewise((1, Ne(x, 0)), (3, True))
+
+
+def test_atan2():
+    assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y/x)
+    assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y/x) - pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y/x) + pi
+    assert refine(atan2(y, x), Q.zero(y) & Q.negative(x)) == pi
+    assert refine(atan2(y, x), Q.positive(y) & Q.zero(x)) == pi/2
+    assert refine(atan2(y, x), Q.negative(y) & Q.zero(x)) == -pi/2
+    assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) is nan
+
+
+def test_re():
+    assert refine(re(x), Q.real(x)) == x
+    assert refine(re(x), Q.imaginary(x)) is S.Zero
+    assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y
+    assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x
+    assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y
+    assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0
+    assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z
+
+
+def test_im():
+    assert refine(im(x), Q.imaginary(x)) == -I*x
+    assert refine(im(x), Q.real(x)) is S.Zero
+    assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y
+    assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y
+    assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0
+    assert refine(im(1/x), Q.imaginary(x)) == -I/x
+    assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y)
+        & Q.imaginary(z)) == -I*x*y*z
+
+
+def test_complex():
+    assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        x/(x**2 + y**2)
+    assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
+        -y/(x**2 + y**2)
+    assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*y - x*z
+    assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
+        & Q.real(z)) == w*z + x*y
+
+
+def test_sign():
+    x = Symbol('x', real = True)
+    assert refine(sign(x), Q.positive(x)) == 1
+    assert refine(sign(x), Q.negative(x)) == -1
+    assert refine(sign(x), Q.zero(x)) == 0
+    assert refine(sign(x), True) == sign(x)
+    assert refine(sign(Abs(x)), Q.nonzero(x)) == 1
+
+    x = Symbol('x', imaginary=True)
+    assert refine(sign(x), Q.positive(im(x))) == S.ImaginaryUnit
+    assert refine(sign(x), Q.negative(im(x))) == -S.ImaginaryUnit
+    assert refine(sign(x), True) == sign(x)
+
+    x = Symbol('x', complex=True)
+    assert refine(sign(x), Q.zero(x)) == 0
+
+def test_arg():
+    x = Symbol('x', complex = True)
+    assert refine(arg(x), Q.positive(x)) == 0
+    assert refine(arg(x), Q.negative(x)) == pi
+
+def test_func_args():
+    class MyClass(Expr):
+        # A class with nontrivial .func
+
+        def __init__(self, *args):
+            self.my_member = ""
+
+        @property
+        def func(self):
+            def my_func(*args):
+                obj = MyClass(*args)
+                obj.my_member = self.my_member
+                return obj
+            return my_func
+
+    x = MyClass()
+    x.my_member = "A very important value"
+    assert x.my_member == refine(x).my_member
+
+def test_issue_refine_9384():
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.positive(x)) == 0
+    assert refine(Piecewise((1, x < 0), (0, True)), Q.negative(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.positive(x)) == 1
+    assert refine(Piecewise((1, x > 0), (0, True)), Q.negative(x)) == 0
+
+
+def test_eval_refine():
+    class MockExpr(Expr):
+        def _eval_refine(self, assumptions):
+            return True
+
+    mock_obj = MockExpr()
+    assert refine(mock_obj)
+
+def test_refine_issue_12724():
+    expr1 = refine(Abs(x * y), Q.positive(x))
+    expr2 = refine(Abs(x * y * z), Q.positive(x))
+    assert expr1 == x * Abs(y)
+    assert expr2 == x * Abs(y * z)
+    y1 = Symbol('y1', real = True)
+    expr3 = refine(Abs(x * y1**2 * z), Q.positive(x))
+    assert expr3 == x * y1**2 * Abs(z)
+
+
+def test_matrixelement():
+    x = MatrixSymbol('x', 3, 3)
+    i = Symbol('i', positive = True)
+    j = Symbol('j', positive = True)
+    assert refine(x[0, 1], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[1, 0], Q.symmetric(x)) == x[0, 1]
+    assert refine(x[i, j], Q.symmetric(x)) == x[j, i]
+    assert refine(x[j, i], Q.symmetric(x)) == x[j, i]
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_rel_queries.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_rel_queries.py
new file mode 100644
index 0000000000000000000000000000000000000000..46fe3a35dc1adb23668e88d5794fe1c0ab22f33a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_rel_queries.py
@@ -0,0 +1,172 @@
+from sympy.assumptions.lra_satask import lra_satask
+from sympy.logic.algorithms.lra_theory import UnhandledInput
+from sympy.assumptions.ask import Q, ask
+
+from sympy.core import symbols, Symbol
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.numbers import I
+
+from sympy.testing.pytest import raises, XFAIL
+x, y, z = symbols("x y z", real=True)
+
+def test_lra_satask():
+    im = Symbol('im', imaginary=True)
+
+    # test preprocessing of unequalities is working correctly
+    assert lra_satask(Q.eq(x, 1), ~Q.ne(x, 0)) is False
+    assert lra_satask(Q.eq(x, 0), ~Q.ne(x, 0)) is True
+    assert lra_satask(~Q.ne(x, 0), Q.eq(x, 0)) is True
+    assert lra_satask(~Q.eq(x, 0), Q.eq(x, 0)) is False
+    assert lra_satask(Q.ne(x, 0), Q.eq(x, 0)) is False
+
+    # basic tests
+    assert lra_satask(Q.ne(x, x)) is False
+    assert lra_satask(Q.eq(x, x)) is True
+    assert lra_satask(Q.gt(x, 0), Q.gt(x, 1)) is True
+
+    # check that True/False are handled
+    assert lra_satask(Q.gt(x, 0), True) is None
+    assert raises(ValueError, lambda: lra_satask(Q.gt(x, 0), False))
+
+    # check imaginary numbers are correctly handled
+    # (im * I).is_real returns True so this is an edge case
+    raises(UnhandledInput, lambda: lra_satask(Q.gt(im * I, 0), Q.gt(im * I, 0)))
+
+    # check matrix inputs
+    X = MatrixSymbol("X", 2, 2)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(X, 2) & Q.gt(X, 3)))
+
+
+def test_old_assumptions():
+    # test unhandled old assumptions
+    w = symbols("w")
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", rational=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", odd=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", even=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", prime=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", composite=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=True, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+    w = symbols("w", integer=False, real=True)
+    raises(UnhandledInput, lambda: lra_satask(Q.lt(w, 2) & Q.gt(w, 3)))
+
+    # test handled
+    w = symbols("w", positive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is False
+    assert lra_satask(Q.gt(w, 0)) is True
+    w = symbols("w", negative=True, real=True)
+    assert lra_satask(Q.lt(w, 0)) is True
+    assert lra_satask(Q.ge(w, 0)) is False
+    w = symbols("w", zero=True, real=True)
+    assert lra_satask(Q.eq(w, 0)) is True
+    assert lra_satask(Q.ne(w, 0)) is False
+    w = symbols("w", nonzero=True, real=True)
+    assert lra_satask(Q.ne(w, 0)) is True
+    assert lra_satask(Q.eq(w, 1)) is None
+    w = symbols("w", nonpositive=True, real=True)
+    assert lra_satask(Q.le(w, 0)) is True
+    assert lra_satask(Q.gt(w, 0)) is False
+    w = symbols("w", nonnegative=True, real=True)
+    assert lra_satask(Q.ge(w, 0)) is True
+    assert lra_satask(Q.lt(w, 0)) is False
+
+
+def test_rel_queries():
+    assert ask(Q.lt(x, 2) & Q.gt(x, 3)) is False
+    assert ask(Q.positive(x - z), (x > y) & (y > z)) is True
+    assert ask(x + y > 2, (x < 0) & (y <0)) is False
+    assert ask(x > z, (x > y) & (y > z)) is True
+
+
+def test_unhandled_queries():
+    X = MatrixSymbol("X", 2, 2)
+    assert ask(Q.lt(X, 2) & Q.gt(X, 3)) is None
+
+
+def test_all_pred():
+    # test usable pred
+    assert lra_satask(Q.extended_positive(x), (x > 2)) is True
+    assert lra_satask(Q.positive_infinite(x)) is False
+    assert lra_satask(Q.negative_infinite(x)) is False
+
+    # test disallowed pred
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.prime(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.composite(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.odd(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.even(x)))
+    raises(UnhandledInput, lambda: lra_satask((x > 0), (x > 2) & Q.integer(x)))
+
+
+def test_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Transitivity
+    # If a <= b and b <= c, then a <= c.
+    assert ask(a <= c, (a <= b) & (b <= c)) is True
+    # If a <= b and b < c, then a < c.
+    assert ask(a < c, (a <= b) & (b < c)) is True
+    # If a < b and b <= c, then a < c.
+    assert ask(a < c, (a < b) & (b <= c)) is True
+
+    # Addition and subtraction
+    # If a <= b, then a + c <= b + c and a - c <= b - c.
+    assert ask(a + c <= b + c, a <= b) is True
+    assert ask(a - c <= b - c, a <= b) is True
+
+
+@XFAIL
+def test_failing_number_line_properties():
+    # From:
+    # https://en.wikipedia.org/wiki/Inequality_(mathematics)#Properties_on_the_number_line
+
+    a, b, c = symbols("a b c", real=True)
+
+    # Multiplication and division
+    # If a <= b and c > 0, then ac <= bc and a/c <= b/c. (True for non-zero c)
+    assert ask(a*c <= b*c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    assert ask(a/c <= b/c, (a <= b) & (c > 0) & ~ Q.zero(c)) is True
+    # If a <= b and c < 0, then ac >= bc and a/c >= b/c. (True for non-zero c)
+    assert ask(a*c >= b*c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+    assert ask(a/c >= b/c, (a <= b) & (c < 0) & ~ Q.zero(c)) is True
+
+    # Additive inverse
+    # If a <= b, then -a >= -b.
+    assert ask(-a >= -b, a <= b) is True
+
+    # Multiplicative inverse
+    # For a, b that are both negative or both positive:
+    # If a <= b, then 1/a >= 1/b .
+    assert ask(1/a >= 1/b, (a <= b) & Q.positive(x) & Q.positive(b)) is True
+    assert ask(1/a >= 1/b, (a <= b) & Q.negative(x) & Q.negative(b)) is True
+
+
+def test_equality():
+    # test symmetry and reflexivity
+    assert ask(Q.eq(x, x)) is True
+    assert ask(Q.eq(y, x), Q.eq(x, y)) is True
+    assert ask(Q.eq(y, x), ~Q.eq(z, z) | Q.eq(x, y)) is True
+
+    # test transitivity
+    assert ask(Q.eq(x,z), Q.eq(x,y) & Q.eq(y,z)) is True
+
+
+@XFAIL
+def test_equality_failing():
+    # Note that implementing the substitution property of equality
+    # most likely requires a redesign of the new assumptions.
+    # See issue #25485 for why this is the case and general ideas
+    # about how things could be redesigned.
+
+    # test substitution property
+    assert ask(Q.prime(x), Q.eq(x, y) & Q.prime(y)) is True
+    assert ask(Q.real(x), Q.eq(x, y) & Q.real(y)) is True
+    assert ask(Q.imaginary(x), Q.eq(x, y) & Q.imaginary(y)) is True
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_satask.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_satask.py
new file mode 100644
index 0000000000000000000000000000000000000000..5831b69e3e6bf2b1a906d1140967510c2ea8b630
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_satask.py
@@ -0,0 +1,378 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.assume import assuming
+from sympy.core.numbers import (I, pi)
+from sympy.core.relational import (Eq, Gt)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import Abs
+from sympy.logic.boolalg import Implies
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.assumptions.cnf import CNF, Literal
+from sympy.assumptions.satask import (satask, extract_predargs,
+    get_relevant_clsfacts)
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+x, y, z = symbols('x y z')
+
+
+def test_satask():
+    # No relevant facts
+    assert satask(Q.real(x), Q.real(x)) is True
+    assert satask(Q.real(x), ~Q.real(x)) is False
+    assert satask(Q.real(x)) is None
+
+    assert satask(Q.real(x), Q.positive(x)) is True
+    assert satask(Q.positive(x), Q.real(x)) is None
+    assert satask(Q.real(x), ~Q.positive(x)) is None
+    assert satask(Q.positive(x), ~Q.real(x)) is False
+
+    raises(ValueError, lambda: satask(Q.real(x), Q.real(x) & ~Q.real(x)))
+
+    with assuming(Q.positive(x)):
+        assert satask(Q.real(x)) is True
+        assert satask(~Q.positive(x)) is False
+        raises(ValueError, lambda: satask(Q.real(x), ~Q.positive(x)))
+
+    assert satask(Q.zero(x), Q.nonzero(x)) is False
+    assert satask(Q.positive(x), Q.zero(x)) is False
+    assert satask(Q.real(x), Q.zero(x)) is True
+    assert satask(Q.zero(x), Q.zero(x*y)) is None
+    assert satask(Q.zero(x*y), Q.zero(x))
+
+
+def test_zero():
+    """
+    Everything in this test doesn't work with the ask handlers, and most
+    things would be very difficult or impossible to make work under that
+    model.
+
+    """
+    assert satask(Q.zero(x) | Q.zero(y), Q.zero(x*y)) is True
+    assert satask(Q.zero(x*y), Q.zero(x) | Q.zero(y)) is True
+
+    assert satask(Implies(Q.zero(x), Q.zero(x*y))) is True
+
+    # This one in particular requires computing the fixed-point of the
+    # relevant facts, because going from Q.nonzero(x*y) -> ~Q.zero(x*y) and
+    # Q.zero(x*y) -> Equivalent(Q.zero(x*y), Q.zero(x) | Q.zero(y)) takes two
+    # steps.
+    assert satask(Q.zero(x) | Q.zero(y), Q.nonzero(x*y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**2)) is True
+
+
+def test_zero_positive():
+    assert satask(Q.zero(x + y), Q.positive(x) & Q.positive(y)) is False
+    assert satask(Q.positive(x) & Q.positive(y), Q.zero(x + y)) is False
+    assert satask(Q.nonzero(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(x) & Q.positive(y), Q.nonzero(x + y)) is None
+
+    # This one requires several levels of forward chaining
+    assert satask(Q.zero(x*(x + y)), Q.positive(x) & Q.positive(y)) is False
+
+    assert satask(Q.positive(pi*x*y + 1), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.positive(pi*x*y - 5), Q.positive(x) & Q.positive(y)) is None
+
+
+def test_zero_pow():
+    assert satask(Q.zero(x**y), Q.zero(x) & Q.positive(y)) is True
+    assert satask(Q.zero(x**y), Q.nonzero(x) & Q.zero(y)) is False
+
+    assert satask(Q.zero(x), Q.zero(x**y)) is True
+
+    assert satask(Q.zero(x**y), Q.zero(x)) is None
+
+
+@XFAIL
+# Requires correct Q.square calculation first
+def test_invertible():
+    A = MatrixSymbol('A', 5, 5)
+    B = MatrixSymbol('B', 5, 5)
+    assert satask(Q.invertible(A*B), Q.invertible(A) & Q.invertible(B)) is True
+    assert satask(Q.invertible(A), Q.invertible(A*B)) is True
+    assert satask(Q.invertible(A) & Q.invertible(B), Q.invertible(A*B)) is True
+
+
+def test_prime():
+    assert satask(Q.prime(5)) is True
+    assert satask(Q.prime(6)) is False
+    assert satask(Q.prime(-5)) is False
+
+    assert satask(Q.prime(x*y), Q.integer(x) & Q.integer(y)) is None
+    assert satask(Q.prime(x*y), Q.prime(x) & Q.prime(y)) is False
+
+
+def test_old_assump():
+    assert satask(Q.positive(1)) is True
+    assert satask(Q.positive(-1)) is False
+    assert satask(Q.positive(0)) is False
+    assert satask(Q.positive(I)) is False
+    assert satask(Q.positive(pi)) is True
+
+    assert satask(Q.negative(1)) is False
+    assert satask(Q.negative(-1)) is True
+    assert satask(Q.negative(0)) is False
+    assert satask(Q.negative(I)) is False
+    assert satask(Q.negative(pi)) is False
+
+    assert satask(Q.zero(1)) is False
+    assert satask(Q.zero(-1)) is False
+    assert satask(Q.zero(0)) is True
+    assert satask(Q.zero(I)) is False
+    assert satask(Q.zero(pi)) is False
+
+    assert satask(Q.nonzero(1)) is True
+    assert satask(Q.nonzero(-1)) is True
+    assert satask(Q.nonzero(0)) is False
+    assert satask(Q.nonzero(I)) is False
+    assert satask(Q.nonzero(pi)) is True
+
+    assert satask(Q.nonpositive(1)) is False
+    assert satask(Q.nonpositive(-1)) is True
+    assert satask(Q.nonpositive(0)) is True
+    assert satask(Q.nonpositive(I)) is False
+    assert satask(Q.nonpositive(pi)) is False
+
+    assert satask(Q.nonnegative(1)) is True
+    assert satask(Q.nonnegative(-1)) is False
+    assert satask(Q.nonnegative(0)) is True
+    assert satask(Q.nonnegative(I)) is False
+    assert satask(Q.nonnegative(pi)) is True
+
+
+def test_rational_irrational():
+    assert satask(Q.irrational(2)) is False
+    assert satask(Q.rational(2)) is True
+    assert satask(Q.irrational(pi)) is True
+    assert satask(Q.rational(pi)) is False
+    assert satask(Q.irrational(I)) is False
+    assert satask(Q.rational(I)) is False
+
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x*y*z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi*x*y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.irrational(y) &
+        Q.rational(z)) is None
+    assert satask(Q.irrational(x + y + z), Q.irrational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+    assert satask(Q.irrational(pi + x + y), Q.rational(x) & Q.rational(y)) is True
+
+    assert satask(Q.irrational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x*y*z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+    assert satask(Q.irrational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is False
+    assert satask(Q.rational(x + y + z), Q.rational(x) & Q.rational(y) &
+        Q.rational(z)) is True
+
+
+def test_even_satask():
+    assert satask(Q.even(2)) is True
+    assert satask(Q.even(3)) is False
+
+    assert satask(Q.even(x*y), Q.even(x) & Q.odd(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.integer(y)) is True
+    assert satask(Q.even(x*y), Q.even(x) & Q.even(y)) is True
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+    assert satask(Q.even(x*y), Q.even(x)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.even(x*y), Q.odd(x) & Q.odd(y)) is False
+
+    assert satask(Q.even(abs(x)), Q.even(x)) is True
+    assert satask(Q.even(abs(x)), Q.odd(x)) is False
+    assert satask(Q.even(x), Q.even(abs(x))) is None # x could be complex
+
+
+def test_odd_satask():
+    assert satask(Q.odd(2)) is False
+    assert satask(Q.odd(3)) is True
+
+    assert satask(Q.odd(x*y), Q.even(x) & Q.odd(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.integer(y)) is False
+    assert satask(Q.odd(x*y), Q.even(x) & Q.even(y)) is False
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+    assert satask(Q.odd(x*y), Q.even(x)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.integer(y)) is None
+    assert satask(Q.odd(x*y), Q.odd(x) & Q.odd(y)) is True
+
+    assert satask(Q.odd(abs(x)), Q.even(x)) is False
+    assert satask(Q.odd(abs(x)), Q.odd(x)) is True
+    assert satask(Q.odd(x), Q.odd(abs(x))) is None # x could be complex
+
+
+def test_integer():
+    assert satask(Q.integer(1)) is True
+    assert satask(Q.integer(S.Half)) is False
+
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x + y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x + y), Q.integer(x) & ~Q.integer(y)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & Q.integer(y) &
+        ~Q.integer(z)) is False
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y) &
+        ~Q.integer(z)) is None
+    assert satask(Q.integer(x + y + z), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x + y), Q.integer(x) & Q.irrational(y)) is False
+
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.integer(y)) is True
+    assert satask(Q.integer(x*y), Q.integer(x)) is None
+
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.integer(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & ~Q.rational(y)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & Q.integer(y) &
+        ~Q.rational(z)) is False
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y) &
+        ~Q.rational(z)) is None
+    assert satask(Q.integer(x*y*z), Q.integer(x) & ~Q.rational(y)) is None
+    assert satask(Q.integer(x*y), Q.integer(x) & Q.irrational(y)) is False
+
+
+def test_abs():
+    assert satask(Q.nonnegative(abs(x))) is True
+    assert satask(Q.positive(abs(x)), ~Q.zero(x)) is True
+    assert satask(Q.zero(x), ~Q.zero(abs(x))) is False
+    assert satask(Q.zero(x), Q.zero(abs(x))) is True
+    assert satask(Q.nonzero(x), ~Q.zero(abs(x))) is None # x could be complex
+    assert satask(Q.zero(abs(x)), Q.zero(x)) is True
+
+
+def test_imaginary():
+    assert satask(Q.imaginary(2*I)) is True
+    assert satask(Q.imaginary(x*y), Q.imaginary(x)) is None
+    assert satask(Q.imaginary(x*y), Q.imaginary(x) & Q.real(y)) is True
+    assert satask(Q.imaginary(x), Q.real(x)) is False
+    assert satask(Q.imaginary(1)) is False
+    assert satask(Q.imaginary(x*y), Q.real(x) & Q.real(y)) is False
+    assert satask(Q.imaginary(x + y), Q.real(x) & Q.real(y)) is False
+
+
+def test_real():
+    assert satask(Q.real(x*y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x + y), Q.real(x) & Q.real(y)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y)) is None
+    assert satask(Q.real(x*y*z), Q.real(x) & Q.real(y) & Q.imaginary(z)) is False
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y) & Q.real(z)) is True
+    assert satask(Q.real(x + y + z), Q.real(x) & Q.real(y)) is None
+
+
+def test_pos_neg():
+    assert satask(~Q.positive(x), Q.negative(x)) is True
+    assert satask(~Q.negative(x), Q.positive(x)) is True
+    assert satask(Q.positive(x + y), Q.positive(x) & Q.positive(y)) is True
+    assert satask(Q.negative(x + y), Q.negative(x) & Q.negative(y)) is True
+    assert satask(Q.positive(x + y), Q.negative(x) & Q.negative(y)) is False
+    assert satask(Q.negative(x + y), Q.positive(x) & Q.positive(y)) is False
+
+
+def test_pow_pos_neg():
+    assert satask(Q.nonnegative(x**2), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.positive(x)) is False
+    assert satask(Q.positive(x**2), Q.positive(x)) is True
+    assert satask(Q.negative(x**2), Q.positive(x)) is False
+    assert satask(Q.real(x**2), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.negative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.negative(x)) is False
+    assert satask(Q.positive(x**2), Q.negative(x)) is True
+    assert satask(Q.negative(x**2), Q.negative(x)) is False
+    assert satask(Q.real(x**2), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**2), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**2), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**2), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**2), Q.nonpositive(x)) is True
+    assert satask(Q.nonpositive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**2), Q.nonpositive(x)) is False
+    assert satask(Q.real(x**2), Q.nonpositive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.positive(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.positive(x)) is False
+    assert satask(Q.positive(x**3), Q.positive(x)) is True
+    assert satask(Q.negative(x**3), Q.positive(x)) is False
+    assert satask(Q.real(x**3), Q.positive(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.negative(x)) is False
+    assert satask(Q.nonpositive(x**3), Q.negative(x)) is True
+    assert satask(Q.positive(x**3), Q.negative(x)) is False
+    assert satask(Q.negative(x**3), Q.negative(x)) is True
+    assert satask(Q.real(x**3), Q.negative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonnegative(x)) is True
+    assert satask(Q.nonpositive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.positive(x**3), Q.nonnegative(x)) is None
+    assert satask(Q.negative(x**3), Q.nonnegative(x)) is False
+    assert satask(Q.real(x**3), Q.nonnegative(x)) is True
+
+    assert satask(Q.nonnegative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**3), Q.nonpositive(x)) is True
+    assert satask(Q.positive(x**3), Q.nonpositive(x)) is False
+    assert satask(Q.negative(x**3), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**3), Q.nonpositive(x)) is True
+
+    # If x is zero, x**negative is not real.
+    assert satask(Q.nonnegative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.nonpositive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.positive(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.negative(x**-2), Q.nonpositive(x)) is None
+    assert satask(Q.real(x**-2), Q.nonpositive(x)) is None
+
+    # We could deduce things for negative powers if x is nonzero, but it
+    # isn't implemented yet.
+
+
+def test_prime_composite():
+    assert satask(Q.prime(x), Q.composite(x)) is False
+    assert satask(Q.composite(x), Q.prime(x)) is False
+    assert satask(Q.composite(x), ~Q.prime(x)) is None
+    assert satask(Q.prime(x), ~Q.composite(x)) is None
+    # since 1 is neither prime nor composite the following should hold
+    assert satask(Q.prime(x), Q.integer(x) & Q.positive(x) & ~Q.composite(x)) is None
+    assert satask(Q.prime(2)) is True
+    assert satask(Q.prime(4)) is False
+    assert satask(Q.prime(1)) is False
+    assert satask(Q.composite(1)) is False
+
+
+def test_extract_predargs():
+    props = CNF.from_prop(Q.zero(Abs(x*y)) & Q.zero(x*y))
+    assump = CNF.from_prop(Q.zero(x))
+    context = CNF.from_prop(Q.zero(y))
+    assert extract_predargs(props) == {Abs(x*y), x*y}
+    assert extract_predargs(props, assump) == {Abs(x*y), x*y, x}
+    assert extract_predargs(props, assump, context) == {Abs(x*y), x*y, x, y}
+
+    props = CNF.from_prop(Eq(x, y))
+    assump = CNF.from_prop(Gt(y, z))
+    assert extract_predargs(props, assump) == {x, y, z}
+
+
+def test_get_relevant_clsfacts():
+    exprs = {Abs(x*y)}
+    exprs, facts = get_relevant_clsfacts(exprs)
+    assert exprs == {x*y}
+    assert facts.clauses == \
+        {frozenset({Literal(Q.odd(Abs(x*y)), False), Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), False), Literal(Q.zero(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False), Literal(Q.even(x*y), True)}),
+        frozenset({Literal(Q.zero(Abs(x*y)), True), Literal(Q.zero(x*y), False)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.odd(Abs(x*y)), False),
+                    Literal(Q.odd(x*y), True)}),
+        frozenset({Literal(Q.even(Abs(x*y)), False),
+                    Literal(Q.even(x*y), True),
+                    Literal(Q.odd(Abs(x*y)), False)}),
+        frozenset({Literal(Q.positive(Abs(x*y)), False),
+                    Literal(Q.zero(Abs(x*y)), False)})}
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_sathandlers.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_sathandlers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d568ad8efe6ba7cf7f5eb03879ad6764c16e729
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_sathandlers.py
@@ -0,0 +1,50 @@
+from sympy.assumptions.ask import Q
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.mul import Mul
+from sympy.core.symbol import symbols
+from sympy.logic.boolalg import (And, Or)
+
+from sympy.assumptions.sathandlers import (ClassFactRegistry, allargs,
+    anyarg, exactlyonearg,)
+
+x, y, z = symbols('x y z')
+
+
+def test_class_handler_registry():
+    my_handler_registry = ClassFactRegistry()
+
+    # The predicate doesn't matter here, so just pass
+    @my_handler_registry.register(Mul)
+    def fact1(expr):
+        pass
+    @my_handler_registry.multiregister(Expr)
+    def fact2(expr):
+        pass
+
+    assert my_handler_registry[Basic] == (frozenset(), frozenset())
+    assert my_handler_registry[Expr] == (frozenset(), frozenset({fact2}))
+    assert my_handler_registry[Mul] == (frozenset({fact1}), frozenset({fact2}))
+
+
+def test_allargs():
+    assert allargs(x, Q.zero(x), x*y) == And(Q.zero(x), Q.zero(y))
+    assert allargs(x, Q.positive(x) | Q.negative(x), x*y) == And(Q.positive(x) | Q.negative(x), Q.positive(y) | Q.negative(y))
+
+
+def test_anyarg():
+    assert anyarg(x, Q.zero(x), x*y) == Or(Q.zero(x), Q.zero(y))
+    assert anyarg(x, Q.positive(x) & Q.negative(x), x*y) == \
+        Or(Q.positive(x) & Q.negative(x), Q.positive(y) & Q.negative(y))
+
+
+def test_exactlyonearg():
+    assert exactlyonearg(x, Q.zero(x), x*y) == \
+        Or(Q.zero(x) & ~Q.zero(y), Q.zero(y) & ~Q.zero(x))
+    assert exactlyonearg(x, Q.zero(x), x*y*z) == \
+        Or(Q.zero(x) & ~Q.zero(y) & ~Q.zero(z), Q.zero(y)
+        & ~Q.zero(x) & ~Q.zero(z), Q.zero(z) & ~Q.zero(x) & ~Q.zero(y))
+    assert exactlyonearg(x, Q.positive(x) | Q.negative(x), x*y) == \
+        Or((Q.positive(x) | Q.negative(x)) &
+        ~(Q.positive(y) | Q.negative(y)), (Q.positive(y) | Q.negative(y)) &
+        ~(Q.positive(x) | Q.negative(x)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_wrapper.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..af9afd5d51fb1341e0b08149dc842b78a39c329b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/tests/test_wrapper.py
@@ -0,0 +1,39 @@
+from sympy.assumptions.ask import Q
+from sympy.assumptions.wrapper import (AssumptionsWrapper, is_infinite,
+    is_extended_real)
+from sympy.core.symbol import Symbol
+from sympy.core.assumptions import _assume_defined
+
+
+def test_all_predicates():
+    for fact in _assume_defined:
+        method_name = f'_eval_is_{fact}'
+        assert hasattr(AssumptionsWrapper, method_name)
+
+
+def test_AssumptionsWrapper():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert AssumptionsWrapper(x).is_positive
+    assert AssumptionsWrapper(y).is_positive is None
+    assert AssumptionsWrapper(y, Q.positive(y)).is_positive
+
+
+def test_is_infinite():
+    x = Symbol('x', infinite=True)
+    y = Symbol('y', infinite=False)
+    z = Symbol('z')
+    assert is_infinite(x)
+    assert not is_infinite(y)
+    assert is_infinite(z) is None
+    assert is_infinite(z, Q.infinite(z))
+
+
+def test_is_extended_real():
+    x = Symbol('x', extended_real=True)
+    y = Symbol('y', extended_real=False)
+    z = Symbol('z')
+    assert is_extended_real(x)
+    assert not is_extended_real(y)
+    assert is_extended_real(z) is None
+    assert is_extended_real(z, Q.extended_real(z))
diff --git a/.venv/lib/python3.12/site-packages/sympy/assumptions/wrapper.py b/.venv/lib/python3.12/site-packages/sympy/assumptions/wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb06e9de770ed41a2b3d6fe63381ad1cb59acacc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/assumptions/wrapper.py
@@ -0,0 +1,164 @@
+"""
+Functions and wrapper object to call assumption property and predicate
+query with same syntax.
+
+In SymPy, there are two assumption systems. Old assumption system is
+defined in sympy/core/assumptions, and it can be accessed by attribute
+such as ``x.is_even``. New assumption system is defined in
+sympy/assumptions, and it can be accessed by predicates such as
+``Q.even(x)``.
+
+Old assumption is fast, while new assumptions can freely take local facts.
+In general, old assumption is used in evaluation method and new assumption
+is used in refinement method.
+
+In most cases, both evaluation and refinement follow the same process, and
+the only difference is which assumption system is used. This module provides
+``is_[...]()`` functions and ``AssumptionsWrapper()`` class which allows
+using two systems with same syntax so that parallel code implementation can be
+avoided.
+
+Examples
+========
+
+For multiple use, use ``AssumptionsWrapper()``.
+
+>>> from sympy import Q, Symbol
+>>> from sympy.assumptions.wrapper import AssumptionsWrapper
+>>> x = Symbol('x')
+>>> _x = AssumptionsWrapper(x, Q.even(x))
+>>> _x.is_integer
+True
+>>> _x.is_odd
+False
+
+For single use, use ``is_[...]()`` functions.
+
+>>> from sympy.assumptions.wrapper import is_infinite
+>>> a = Symbol('a')
+>>> print(is_infinite(a))
+None
+>>> is_infinite(a, Q.finite(a))
+False
+
+"""
+
+from sympy.assumptions import ask, Q
+from sympy.core.basic import Basic
+from sympy.core.sympify import _sympify
+
+
+def make_eval_method(fact):
+    def getit(self):
+        pred = getattr(Q, fact)
+        ret = ask(pred(self.expr), self.assumptions)
+        return ret
+    return getit
+
+
+# we subclass Basic to use the fact deduction and caching
+class AssumptionsWrapper(Basic):
+    """
+    Wrapper over ``Basic`` instances to call predicate query by
+    ``.is_[...]`` property
+
+    Parameters
+    ==========
+
+    expr : Basic
+
+    assumptions : Boolean, optional
+
+    Examples
+    ========
+
+    >>> from sympy import Q, Symbol
+    >>> from sympy.assumptions.wrapper import AssumptionsWrapper
+    >>> x = Symbol('x', even=True)
+    >>> AssumptionsWrapper(x).is_integer
+    True
+    >>> y = Symbol('y')
+    >>> AssumptionsWrapper(y, Q.even(y)).is_integer
+    True
+
+    With ``AssumptionsWrapper``, both evaluation and refinement can be supported
+    by single implementation.
+
+    >>> from sympy import Function
+    >>> class MyAbs(Function):
+    ...     @classmethod
+    ...     def eval(cls, x, assumptions=True):
+    ...         _x = AssumptionsWrapper(x, assumptions)
+    ...         if _x.is_nonnegative:
+    ...             return x
+    ...         if _x.is_negative:
+    ...             return -x
+    ...     def _eval_refine(self, assumptions):
+    ...         return MyAbs.eval(self.args[0], assumptions)
+    >>> MyAbs(x)
+    MyAbs(x)
+    >>> MyAbs(x).refine(Q.positive(x))
+    x
+    >>> MyAbs(Symbol('y', negative=True))
+    -y
+
+    """
+    def __new__(cls, expr, assumptions=None):
+        if assumptions is None:
+            return expr
+        obj = super().__new__(cls, expr, _sympify(assumptions))
+        obj.expr = expr
+        obj.assumptions = assumptions
+        return obj
+
+    _eval_is_algebraic = make_eval_method("algebraic")
+    _eval_is_antihermitian = make_eval_method("antihermitian")
+    _eval_is_commutative = make_eval_method("commutative")
+    _eval_is_complex = make_eval_method("complex")
+    _eval_is_composite = make_eval_method("composite")
+    _eval_is_even = make_eval_method("even")
+    _eval_is_extended_negative = make_eval_method("extended_negative")
+    _eval_is_extended_nonnegative = make_eval_method("extended_nonnegative")
+    _eval_is_extended_nonpositive = make_eval_method("extended_nonpositive")
+    _eval_is_extended_nonzero = make_eval_method("extended_nonzero")
+    _eval_is_extended_positive = make_eval_method("extended_positive")
+    _eval_is_extended_real = make_eval_method("extended_real")
+    _eval_is_finite = make_eval_method("finite")
+    _eval_is_hermitian = make_eval_method("hermitian")
+    _eval_is_imaginary = make_eval_method("imaginary")
+    _eval_is_infinite = make_eval_method("infinite")
+    _eval_is_integer = make_eval_method("integer")
+    _eval_is_irrational = make_eval_method("irrational")
+    _eval_is_negative = make_eval_method("negative")
+    _eval_is_noninteger = make_eval_method("noninteger")
+    _eval_is_nonnegative = make_eval_method("nonnegative")
+    _eval_is_nonpositive = make_eval_method("nonpositive")
+    _eval_is_nonzero = make_eval_method("nonzero")
+    _eval_is_odd = make_eval_method("odd")
+    _eval_is_polar = make_eval_method("polar")
+    _eval_is_positive = make_eval_method("positive")
+    _eval_is_prime = make_eval_method("prime")
+    _eval_is_rational = make_eval_method("rational")
+    _eval_is_real = make_eval_method("real")
+    _eval_is_transcendental = make_eval_method("transcendental")
+    _eval_is_zero = make_eval_method("zero")
+
+
+# one shot functions which are faster than AssumptionsWrapper
+
+def is_infinite(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_infinite
+    return ask(Q.infinite(obj), assumptions)
+
+
+def is_extended_real(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_extended_real
+    return ask(Q.extended_real(obj), assumptions)
+
+
+def is_extended_nonnegative(obj, assumptions=None):
+    if assumptions is None:
+        return obj.is_extended_nonnegative
+    return ask(Q.extended_nonnegative(obj), assumptions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/__init__.py b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..478c1459143b32d4c31c008e207196fb596dafd6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_discrete_log.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_discrete_log.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..575f39b4b90bc24a3c7a6d8dc43c83f2efb52303
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_discrete_log.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_meijerint.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_meijerint.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a78d09290ffd94e937a30c54936eaf722f534b4c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_meijerint.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_symbench.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_symbench.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ecf51df06724b24f93c5af7c611036647984226
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/benchmarks/__pycache__/bench_symbench.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_discrete_log.py b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_discrete_log.py
new file mode 100644
index 0000000000000000000000000000000000000000..76b273909e415318a7d3bace00ffff2a0bc53762
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_discrete_log.py
@@ -0,0 +1,83 @@
+import sys
+from time import time
+from sympy.ntheory.residue_ntheory import (discrete_log,
+        _discrete_log_trial_mul, _discrete_log_shanks_steps,
+        _discrete_log_pollard_rho, _discrete_log_pohlig_hellman)
+
+
+# Cyclic group (Z/pZ)* with p prime, order p - 1 and generator g
+data_set_1 = [
+        # p, p - 1, g
+        [191, 190, 19],
+        [46639, 46638, 6],
+        [14789363, 14789362, 2],
+        [4254225211, 4254225210, 2],
+        [432751500361, 432751500360, 7],
+        [158505390797053, 158505390797052, 2],
+        [6575202655312007, 6575202655312006, 5],
+        [8430573471995353769, 8430573471995353768, 3],
+        [3938471339744997827267, 3938471339744997827266, 2],
+        [875260951364705563393093, 875260951364705563393092, 5],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with prime order p and generator g
+# (n, p are primes and n = 2 * p + 1)
+data_set_2 = [
+        # n, p, g
+        [227, 113, 3],
+        [2447, 1223, 2],
+        [24527, 12263, 2],
+        [245639, 122819, 2],
+        [2456747, 1228373, 3],
+        [24567899, 12283949, 3],
+        [245679023, 122839511, 2],
+        [2456791307, 1228395653, 3],
+        [24567913439, 12283956719, 2],
+        [245679135407, 122839567703, 2],
+        [2456791354763, 1228395677381, 3],
+        [24567913550903, 12283956775451, 2],
+        [245679135509519, 122839567754759, 2],
+    ]
+
+
+# Cyclic sub-groups of (Z/nZ)* with smooth order o and generator g
+data_set_3 = [
+        # n, o, g
+        [2**118, 2**116, 3],
+    ]
+
+
+def bench_discrete_log(data_set, algo=None):
+    if algo is None:
+        f = discrete_log
+    elif algo == 'trial':
+        f = _discrete_log_trial_mul
+    elif algo == 'shanks':
+        f = _discrete_log_shanks_steps
+    elif algo == 'rho':
+        f = _discrete_log_pollard_rho
+    elif algo == 'ph':
+        f = _discrete_log_pohlig_hellman
+    else:
+        raise ValueError("Argument 'algo' should be one"
+                " of ('trial', 'shanks', 'rho' or 'ph')")
+
+    for i, data in enumerate(data_set):
+        for j, (n, p, g) in enumerate(data):
+            t = time()
+            l = f(n, pow(g, p - 1, n), g, p)
+            t = time() - t
+            print('[%02d-%03d] %15.10f' % (i, j, t))
+            assert l == p - 1
+
+
+if __name__ == '__main__':
+    algo = sys.argv[1] \
+            if len(sys.argv) > 1 else None
+    data_set = [
+            data_set_1,
+            data_set_2,
+            data_set_3,
+        ]
+    bench_discrete_log(data_set, algo)
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_meijerint.py b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_meijerint.py
new file mode 100644
index 0000000000000000000000000000000000000000..d648c3e02463d5a7ee1dcbe3b22af5cc22fef43d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_meijerint.py
@@ -0,0 +1,261 @@
+# conceal the implicit import from the code quality tester
+from sympy.core.numbers import (oo, pi)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.bessel import besseli
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate
+from sympy.integrals.transforms import (mellin_transform,
+    inverse_fourier_transform, inverse_mellin_transform,
+    laplace_transform, inverse_laplace_transform, fourier_transform)
+
+LT = laplace_transform
+FT = fourier_transform
+MT = mellin_transform
+IFT = inverse_fourier_transform
+ILT = inverse_laplace_transform
+IMT = inverse_mellin_transform
+
+from sympy.abc import x, y
+nu, beta, rho = symbols('nu beta rho')
+
+apos, bpos, cpos, dpos, posk, p = symbols('a b c d k p', positive=True)
+k = Symbol('k', real=True)
+negk = Symbol('k', negative=True)
+
+mu1, mu2 = symbols('mu1 mu2', real=True, nonzero=True, finite=True)
+sigma1, sigma2 = symbols('sigma1 sigma2', real=True, nonzero=True,
+                         finite=True, positive=True)
+rate = Symbol('lambda', positive=True)
+
+
+def normal(x, mu, sigma):
+    return 1/sqrt(2*pi*sigma**2)*exp(-(x - mu)**2/2/sigma**2)
+
+
+def exponential(x, rate):
+    return rate*exp(-rate*x)
+alpha, beta = symbols('alpha beta', positive=True)
+betadist = x**(alpha - 1)*(1 + x)**(-alpha - beta)*gamma(alpha + beta) \
+    /gamma(alpha)/gamma(beta)
+kint = Symbol('k', integer=True, positive=True)
+chi = 2**(1 - kint/2)*x**(kint - 1)*exp(-x**2/2)/gamma(kint/2)
+chisquared = 2**(-k/2)/gamma(k/2)*x**(k/2 - 1)*exp(-x/2)
+dagum = apos*p/x*(x/bpos)**(apos*p)/(1 + x**apos/bpos**apos)**(p + 1)
+d1, d2 = symbols('d1 d2', positive=True)
+f = sqrt(((d1*x)**d1 * d2**d2)/(d1*x + d2)**(d1 + d2))/x \
+    /gamma(d1/2)/gamma(d2/2)*gamma((d1 + d2)/2)
+nupos, sigmapos = symbols('nu sigma', positive=True)
+rice = x/sigmapos**2*exp(-(x**2 + nupos**2)/2/sigmapos**2)*besseli(0, x*
+                         nupos/sigmapos**2)
+mu = Symbol('mu', real=True)
+laplace = exp(-abs(x - mu)/bpos)/2/bpos
+
+u = Symbol('u', polar=True)
+tpos = Symbol('t', positive=True)
+
+
+def E(expr):
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (x, 0, oo), (y, -oo, oo), meijerg=True)
+    integrate(expr*exponential(x, rate)*normal(y, mu1, sigma1),
+                     (y, -oo, oo), (x, 0, oo), meijerg=True)
+
+bench = [
+    'MT(x**nu*Heaviside(x - 1), x, s)',
+    'MT(x**nu*Heaviside(1 - x), x, s)',
+    'MT((1-x)**(beta - 1)*Heaviside(1-x), x, s)',
+    'MT((x-1)**(beta - 1)*Heaviside(x-1), x, s)',
+    'MT((1+x)**(-rho), x, s)',
+    'MT(abs(1-x)**(-rho), x, s)',
+    'MT((1-x)**(beta-1)*Heaviside(1-x) + a*(x-1)**(beta-1)*Heaviside(x-1), x, s)',
+    'MT((x**a-b**a)/(x-b), x, s)',
+    'MT((x**a-bpos**a)/(x-bpos), x, s)',
+    'MT(exp(-x), x, s)',
+    'MT(exp(-1/x), x, s)',
+    'MT(log(x)**4*Heaviside(1-x), x, s)',
+    'MT(log(x)**3*Heaviside(x-1), x, s)',
+    'MT(log(x + 1), x, s)',
+    'MT(log(1/x + 1), x, s)',
+    'MT(log(abs(1 - x)), x, s)',
+    'MT(log(abs(1 - 1/x)), x, s)',
+    'MT(log(x)/(x+1), x, s)',
+    'MT(log(x)**2/(x+1), x, s)',
+    'MT(log(x)/(x+1)**2, x, s)',
+    'MT(erf(sqrt(x)), x, s)',
+
+    'MT(besselj(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2, x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(-a, sqrt(x)), x, s)',
+    'MT(besselj(a - 1, sqrt(x))*besselj(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*besselj(b, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))**2 + besselj(-a, sqrt(x))**2, x, s)',
+    'MT(bessely(a, 2*sqrt(x)), x, s)',
+    'MT(sin(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(cos(sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(a, sqrt(x)), x, s)',
+    'MT(besselj(a, sqrt(x))*bessely(b, sqrt(x)), x, s)',
+    'MT(bessely(a, sqrt(x))**2, x, s)',
+
+    'MT(besselk(a, 2*sqrt(x)), x, s)',
+    'MT(besselj(a, 2*sqrt(2*sqrt(x)))*besselk(a, 2*sqrt(2*sqrt(x))), x, s)',
+    'MT(besseli(a, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(besseli(b, sqrt(x))*besselk(a, sqrt(x)), x, s)',
+    'MT(exp(-x/2)*besselk(a, x/2), x, s)',
+
+    # later: ILT, IMT
+
+    'LT((t-apos)**bpos*exp(-cpos*(t-apos))*Heaviside(t-apos), t, s)',
+    'LT(t**apos, t, s)',
+    'LT(Heaviside(t), t, s)',
+    'LT(Heaviside(t - apos), t, s)',
+    'LT(1 - exp(-apos*t), t, s)',
+    'LT((exp(2*t)-1)*exp(-bpos - t)*Heaviside(t)/2, t, s, noconds=True)',
+    'LT(exp(t), t, s)',
+    'LT(exp(2*t), t, s)',
+    'LT(exp(apos*t), t, s)',
+    'LT(log(t/apos), t, s)',
+    'LT(erf(t), t, s)',
+    'LT(sin(apos*t), t, s)',
+    'LT(cos(apos*t), t, s)',
+    'LT(exp(-apos*t)*sin(bpos*t), t, s)',
+    'LT(exp(-apos*t)*cos(bpos*t), t, s)',
+    'LT(besselj(0, t), t, s, noconds=True)',
+    'LT(besselj(1, t), t, s, noconds=True)',
+
+    'FT(Heaviside(1 - abs(2*apos*x)), x, k)',
+    'FT(Heaviside(1-abs(apos*x))*(1-abs(apos*x)), x, k)',
+    'FT(exp(-apos*x)*Heaviside(x), x, k)',
+    'IFT(1/(apos + 2*pi*I*x), x, posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, -posk, noconds=False)',
+    'IFT(1/(apos + 2*pi*I*x), x, negk)',
+    'FT(x*exp(-apos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x)*sin(bpos*x)*Heaviside(x), x, k)',
+    'FT(exp(-apos*x**2), x, k)',
+    'IFT(sqrt(pi/apos)*exp(-(pi*k)**2/apos), k, x)',
+    'FT(exp(-apos*abs(x)), x, k)',
+
+    'integrate(normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(x**3*normal(x, mu1, sigma1), (x, -oo, oo), meijerg=True)',
+    'integrate(normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x*y*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y+1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate((x+y-1)*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                   (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(x**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '                (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(y**2*normal(x, mu1, sigma1)*normal(y, mu2, sigma2),'
+    '          (x, -oo, oo), (y, -oo, oo), meijerg=True)',
+    'integrate(exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'integrate(x**2*exponential(x, rate), (x, 0, oo), meijerg=True)',
+    'E(1)',
+    'E(x*y)',
+    'E(x*y**2)',
+    'E((x+y+1)**2)',
+    'E(x+y+1)',
+    'E((x+y-1)**2)',
+    'integrate(betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*betadist, (x, 0, oo), meijerg=True)',
+    'integrate(chi, (x, 0, oo), meijerg=True)',
+    'integrate(x*chi, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chi, (x, 0, oo), meijerg=True)',
+    'integrate(chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(((x-k)/sqrt(2*k))**3*chisquared, (x, 0, oo), meijerg=True)',
+    'integrate(dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*dagum, (x, 0, oo), meijerg=True)',
+    'integrate(f, (x, 0, oo), meijerg=True)',
+    'integrate(x*f, (x, 0, oo), meijerg=True)',
+    'integrate(x**2*f, (x, 0, oo), meijerg=True)',
+    'integrate(rice, (x, 0, oo), meijerg=True)',
+    'integrate(laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(x**2*laplace, (x, -oo, oo), meijerg=True)',
+    'integrate(log(x) * x**(k-1) * exp(-x) / gamma(k), (x, 0, oo))',
+
+    'integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*besselk(0,x), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(0,x)*besselj(1,x)*exp(-x**2), (x, 0, oo), meijerg=True)',
+    'integrate(besselj(a,x)*besselj(b,x)/x, (x,0,oo), meijerg=True)',
+
+    'hyperexpand(meijerg((-s - a/2 + 1, -s + a/2 + 1), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), (a/2, -a/2), (-a/2 - S(1)/2, -s + a/2 + S(3)/2), 1))',
+    "gammasimp(S('2**(2*s)*(-pi*gamma(-a + 1)*gamma(a + 1)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 3/2)*gamma(a + s + 1)/(a*(a + s)) - gamma(-a - 1/2)*gamma(-a + 1)*gamma(a + 1)*gamma(a + 3/2)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a + s + 1)*gamma(a - s + 1)/(a*(-a + s)))*gamma(-2*s + 1)*gamma(s + 1)/(pi*s*gamma(-a - 1/2)*gamma(a + 3/2)*gamma(-s + 1)*gamma(-s + 3/2)*gamma(s - 1/2)*gamma(-a - s + 1)*gamma(-a + s - 1/2)*gamma(a - s + 1)*gamma(a - s + 3/2))'))",
+
+    'mellin_transform(E1(x), x, s)',
+    'inverse_mellin_transform(gamma(s)/s, s, x, (0, oo))',
+    'mellin_transform(expint(a, x), x, s)',
+    'mellin_transform(Si(x), x, s)',
+    'inverse_mellin_transform(-2**s*sqrt(pi)*gamma((s + 1)/2)/(2*s*gamma(-s/2 + 1)), s, x, (-1, 0))',
+    'mellin_transform(Ci(sqrt(x)), x, s)',
+    'inverse_mellin_transform(-4**s*sqrt(pi)*gamma(s)/(2*s*gamma(-s + S(1)/2)),s, u, (0, 1))',
+    'laplace_transform(Ci(x), x, s)',
+    'laplace_transform(expint(a, x), x, s)',
+    'laplace_transform(expint(1, x), x, s)',
+    'laplace_transform(expint(2, x), x, s)',
+    'inverse_laplace_transform(-log(1 + s**2)/2/s, s, u)',
+    'inverse_laplace_transform(log(s + 1)/s, s, x)',
+    'inverse_laplace_transform((s - log(s + 1))/s**2, s, x)',
+    'laplace_transform(Chi(x), x, s)',
+    'laplace_transform(Shi(x), x, s)',
+
+    'integrate(exp(-z*x)/x, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**2, (x, 1, oo), meijerg=True, conds="none")',
+    'integrate(exp(-z*x)/x**3, (x, 1, oo), meijerg=True,conds="none")',
+    'integrate(-cos(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(-sin(x)/x, (x, tpos, oo), meijerg=True)',
+    'integrate(sin(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(sinh(x)/x, (x, 0, z), meijerg=True)',
+    'integrate(exp(-x)/x, x, meijerg=True)',
+    'integrate(exp(-x)/x**2, x, meijerg=True)',
+    'integrate(cos(u)/u, u, meijerg=True)',
+    'integrate(cosh(u)/u, u, meijerg=True)',
+    'integrate(expint(1, x), x, meijerg=True)',
+    'integrate(expint(2, x), x, meijerg=True)',
+    'integrate(Si(x), x, meijerg=True)',
+    'integrate(Ci(u), u, meijerg=True)',
+    'integrate(Shi(x), x, meijerg=True)',
+    'integrate(Chi(u), u, meijerg=True)',
+    'integrate(Si(x)*exp(-x), (x, 0, oo), meijerg=True)',
+    'integrate(expint(1, x)*sin(x), (x, 0, oo), meijerg=True)'
+]
+
+from time import time
+from sympy.core.cache import clear_cache
+import sys
+
+timings = []
+
+if __name__ == '__main__':
+    for n, string in enumerate(bench):
+        clear_cache()
+        _t = time()
+        exec(string)
+        _t = time() - _t
+        timings += [(_t, string)]
+        sys.stdout.write('.')
+        sys.stdout.flush()
+        if n % (len(bench) // 10) == 0:
+            sys.stdout.write('%s' % (10*n // len(bench)))
+    print()
+
+    timings.sort(key=lambda x: -x[0])
+
+    for ti, string in timings:
+        print('%.2fs %s' % (ti, string))
diff --git a/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_symbench.py b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_symbench.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ea700b44b677107f5345196a8895e8ed5a9d56d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/benchmarks/bench_symbench.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python
+from sympy.core.random import random
+from sympy.core.numbers import (I, Integer, pi)
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+from sympy.polys.polytools import factor
+from sympy.simplify.simplify import simplify
+from sympy.abc import x, y, z
+from timeit import default_timer as clock
+
+
+def bench_R1():
+    "real(f(f(f(f(f(f(f(f(f(f(i/2)))))))))))"
+    def f(z):
+        return sqrt(Integer(1)/3)*z**2 + I/3
+    f(f(f(f(f(f(f(f(f(f(I/2)))))))))).as_real_imag()[0]
+
+
+def bench_R2():
+    "Hermite polynomial hermite(15, y)"
+    def hermite(n, y):
+        if n == 1:
+            return 2*y
+        if n == 0:
+            return 1
+        return (2*y*hermite(n - 1, y) - 2*(n - 1)*hermite(n - 2, y)).expand()
+
+    hermite(15, y)
+
+
+def bench_R3():
+    "a = [bool(f==f) for _ in range(10)]"
+    f = x + y + z
+    [bool(f == f) for _ in range(10)]
+
+
+def bench_R4():
+    # we don't have Tuples
+    pass
+
+
+def bench_R5():
+    "blowup(L, 8); L=uniq(L)"
+    def blowup(L, n):
+        for i in range(n):
+            L.append( (L[i] + L[i + 1]) * L[i + 2] )
+
+    def uniq(x):
+        v = set(x)
+        return v
+    L = [x, y, z]
+    blowup(L, 8)
+    L = uniq(L)
+
+
+def bench_R6():
+    "sum(simplify((x+sin(i))/x+(x-sin(i))/x) for i in range(100))"
+    sum(simplify((x + sin(i))/x + (x - sin(i))/x) for i in range(100))
+
+
+def bench_R7():
+    "[f.subs(x, random()) for _ in range(10**4)]"
+    f = x**24 + 34*x**12 + 45*x**3 + 9*x**18 + 34*x**10 + 32*x**21
+    [f.subs(x, random()) for _ in range(10**4)]
+
+
+def bench_R8():
+    "right(x^2,0,5,10^4)"
+    def right(f, a, b, n):
+        a = sympify(a)
+        b = sympify(b)
+        n = sympify(n)
+        x = f.atoms(Symbol).pop()
+        Deltax = (b - a)/n
+        c = a
+        est = 0
+        for i in range(n):
+            c += Deltax
+            est += f.subs(x, c)
+        return est*Deltax
+
+    right(x**2, 0, 5, 10**4)
+
+
+def _bench_R9():
+    "factor(x^20 - pi^5*y^20)"
+    factor(x**20 - pi**5*y**20)
+
+
+def bench_R10():
+    "v = [-pi,-pi+1/10..,pi]"
+    def srange(min, max, step):
+        v = [min]
+        while (max - v[-1]).evalf() > 0:
+            v.append(v[-1] + step)
+        return v[:-1]
+    srange(-pi, pi, sympify(1)/10)
+
+
+def bench_R11():
+    "a = [random() + random()*I for w in [0..1000]]"
+    [random() + random()*I for w in range(1000)]
+
+
+def bench_S1():
+    "e=(x+y+z+1)**7;f=e*(e+1);f.expand()"
+    e = (x + y + z + 1)**7
+    f = e*(e + 1)
+    f.expand()
+
+
+if __name__ == '__main__':
+    benchmarks = [
+        bench_R1,
+        bench_R2,
+        bench_R3,
+        bench_R5,
+        bench_R6,
+        bench_R7,
+        bench_R8,
+        #_bench_R9,
+        bench_R10,
+        bench_R11,
+        #bench_S1,
+    ]
+
+    report = []
+    for b in benchmarks:
+        t = clock()
+        b()
+        t = clock() - t
+        print("%s%65s: %f" % (b.__name__, b.__doc__, t))
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__init__.py b/.venv/lib/python3.12/site-packages/sympy/calculus/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..865c0556769e35ca7e8a09a4c208a1cfbd17369c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/__init__.py
@@ -0,0 +1,25 @@
+"""Calculus-related methods."""
+
+from .euler import euler_equations
+from .singularities import (singularities, is_increasing,
+                            is_strictly_increasing, is_decreasing,
+                            is_strictly_decreasing, is_monotonic)
+from .finite_diff import finite_diff_weights, apply_finite_diff, differentiate_finite
+from .util import (periodicity, not_empty_in, is_convex,
+                   stationary_points, minimum, maximum)
+from .accumulationbounds import AccumBounds
+
+__all__ = [
+'euler_equations',
+
+'singularities', 'is_increasing',
+'is_strictly_increasing', 'is_decreasing',
+'is_strictly_decreasing', 'is_monotonic',
+
+'finite_diff_weights', 'apply_finite_diff', 'differentiate_finite',
+
+'periodicity', 'not_empty_in', 'is_convex', 'stationary_points',
+'minimum', 'maximum',
+
+'AccumBounds'
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3f99eedc8006b17253989511d9be1d32e954e20
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/accumulationbounds.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/accumulationbounds.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..227a80f97663ad6022228c63aef6b195a1b04239
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/accumulationbounds.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/euler.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/euler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..130ac008462a099102ecb90ecb1bb6fef78ea557
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/euler.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/finite_diff.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/finite_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc49f447ee1126cbdf366e20c00aebcec477a228
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/finite_diff.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/singularities.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/singularities.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef980813bedd8a5d626148969a9c75a739ce97eb
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/singularities.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6bd4edb03b49aef19bb7b36feec812b52e25b29
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/__pycache__/util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/accumulationbounds.py b/.venv/lib/python3.12/site-packages/sympy/calculus/accumulationbounds.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a2b0e634da1028c25399c8b03884865d981a56e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/accumulationbounds.py
@@ -0,0 +1,804 @@
+from sympy.core import Add, Mul, Pow, S
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+from sympy.core.numbers import _sympifyit, oo, zoo
+from sympy.core.relational import is_le, is_lt, is_ge, is_gt
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import And
+from sympy.multipledispatch import dispatch
+from sympy.series.order import Order
+from sympy.sets.sets import FiniteSet
+
+
+class AccumulationBounds(Expr):
+    r"""An accumulation bounds.
+
+    # Note AccumulationBounds has an alias: AccumBounds
+
+    AccumulationBounds represent an interval `[a, b]`, which is always closed
+    at the ends. Here `a` and `b` can be any value from extended real numbers.
+
+    The intended meaning of AccummulationBounds is to give an approximate
+    location of the accumulation points of a real function at a limit point.
+
+    Let `a` and `b` be reals such that `a \le b`.
+
+    `\left\langle a, b\right\rangle = \{x \in \mathbb{R} \mid a \le x \le b\}`
+
+    `\left\langle -\infty, b\right\rangle = \{x \in \mathbb{R} \mid x \le b\} \cup \{-\infty, \infty\}`
+
+    `\left\langle a, \infty \right\rangle = \{x \in \mathbb{R} \mid a \le x\} \cup \{-\infty, \infty\}`
+
+    `\left\langle -\infty, \infty \right\rangle = \mathbb{R} \cup \{-\infty, \infty\}`
+
+    ``oo`` and ``-oo`` are added to the second and third definition respectively,
+    since if either ``-oo`` or ``oo`` is an argument, then the other one should
+    be included (though not as an end point). This is forced, since we have,
+    for example, ``1/AccumBounds(0, 1) = AccumBounds(1, oo)``, and the limit at
+    `0` is not one-sided. As `x` tends to `0-`, then `1/x \rightarrow -\infty`, so `-\infty`
+    should be interpreted as belonging to ``AccumBounds(1, oo)`` though it need
+    not appear explicitly.
+
+    In many cases it suffices to know that the limit set is bounded.
+    However, in some other cases more exact information could be useful.
+    For example, all accumulation values of `\cos(x) + 1` are non-negative.
+    (``AccumBounds(-1, 1) + 1 = AccumBounds(0, 2)``)
+
+    A AccumulationBounds object is defined to be real AccumulationBounds,
+    if its end points are finite reals.
+
+    Let `X`, `Y` be real AccumulationBounds, then their sum, difference,
+    product are defined to be the following sets:
+
+    `X + Y = \{ x+y \mid x \in X \cap y \in Y\}`
+
+    `X - Y = \{ x-y \mid x \in X \cap y \in Y\}`
+
+    `X \times Y = \{ x \times y \mid x \in X \cap y \in Y\}`
+
+    When an AccumBounds is raised to a negative power, if 0 is contained
+    between the bounds then an infinite range is returned, otherwise if an
+    endpoint is 0 then a semi-infinite range with consistent sign will be returned.
+
+    AccumBounds in expressions behave a lot like Intervals but the
+    semantics are not necessarily the same. Division (or exponentiation
+    to a negative integer power) could be handled with *intervals* by
+    returning a union of the results obtained after splitting the
+    bounds between negatives and positives, but that is not done with
+    AccumBounds. In addition, bounds are assumed to be independent of
+    each other; if the same bound is used in more than one place in an
+    expression, the result may not be the supremum or infimum of the
+    expression (see below). Finally, when a boundary is ``1``,
+    exponentiation to the power of ``oo`` yields ``oo``, neither
+    ``1`` nor ``nan``.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, sin, exp, log, pi, E, S, oo
+    >>> from sympy.abc import x
+
+    >>> AccumBounds(0, 1) + AccumBounds(1, 2)
+    AccumBounds(1, 3)
+
+    >>> AccumBounds(0, 1) - AccumBounds(0, 2)
+    AccumBounds(-2, 1)
+
+    >>> AccumBounds(-2, 3)*AccumBounds(-1, 1)
+    AccumBounds(-3, 3)
+
+    >>> AccumBounds(1, 2)*AccumBounds(3, 5)
+    AccumBounds(3, 10)
+
+    The exponentiation of AccumulationBounds is defined
+    as follows:
+
+    If 0 does not belong to `X` or `n > 0` then
+
+    `X^n = \{ x^n \mid x \in X\}`
+
+    >>> AccumBounds(1, 4)**(S(1)/2)
+    AccumBounds(1, 2)
+
+    otherwise, an infinite or semi-infinite result is obtained:
+
+    >>> 1/AccumBounds(-1, 1)
+    AccumBounds(-oo, oo)
+    >>> 1/AccumBounds(0, 2)
+    AccumBounds(1/2, oo)
+    >>> 1/AccumBounds(-oo, 0)
+    AccumBounds(-oo, 0)
+
+    A boundary of 1 will always generate all nonnegatives:
+
+    >>> AccumBounds(1, 2)**oo
+    AccumBounds(0, oo)
+    >>> AccumBounds(0, 1)**oo
+    AccumBounds(0, oo)
+
+    If the exponent is itself an AccumulationBounds or is not an
+    integer then unevaluated results will be returned unless the base
+    values are positive:
+
+    >>> AccumBounds(2, 3)**AccumBounds(-1, 2)
+    AccumBounds(1/3, 9)
+    >>> AccumBounds(-2, 3)**AccumBounds(-1, 2)
+    AccumBounds(-2, 3)**AccumBounds(-1, 2)
+
+    >>> AccumBounds(-2, -1)**(S(1)/2)
+    sqrt(AccumBounds(-2, -1))
+
+    Note: `\left\langle a, b\right\rangle^2` is not same as `\left\langle a, b\right\rangle \times \left\langle a, b\right\rangle`
+
+    >>> AccumBounds(-1, 1)**2
+    AccumBounds(0, 1)
+
+    >>> AccumBounds(1, 3) < 4
+    True
+
+    >>> AccumBounds(1, 3) < -1
+    False
+
+    Some elementary functions can also take AccumulationBounds as input.
+    A function `f` evaluated for some real AccumulationBounds `\left\langle a, b \right\rangle`
+    is defined as `f(\left\langle a, b\right\rangle) = \{ f(x) \mid a \le x \le b \}`
+
+    >>> sin(AccumBounds(pi/6, pi/3))
+    AccumBounds(1/2, sqrt(3)/2)
+
+    >>> exp(AccumBounds(0, 1))
+    AccumBounds(1, E)
+
+    >>> log(AccumBounds(1, E))
+    AccumBounds(0, 1)
+
+    Some symbol in an expression can be substituted for a AccumulationBounds
+    object. But it does not necessarily evaluate the AccumulationBounds for
+    that expression.
+
+    The same expression can be evaluated to different values depending upon
+    the form it is used for substitution since each instance of an
+    AccumulationBounds is considered independent. For example:
+
+    >>> (x**2 + 2*x + 1).subs(x, AccumBounds(-1, 1))
+    AccumBounds(-1, 4)
+
+    >>> ((x + 1)**2).subs(x, AccumBounds(-1, 1))
+    AccumBounds(0, 4)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Interval_arithmetic
+
+    .. [2] https://fab.cba.mit.edu/classes/S62.12/docs/Hickey_interval.pdf
+
+    Notes
+    =====
+
+    Do not use ``AccumulationBounds`` for floating point interval arithmetic
+    calculations, use ``mpmath.iv`` instead.
+    """
+
+    is_extended_real = True
+    is_number = False
+
+    def __new__(cls, min, max) -> Expr: # type: ignore
+
+        min = _sympify(min)
+        max = _sympify(max)
+
+        # Only allow real intervals (use symbols with 'is_extended_real=True').
+        if not min.is_extended_real or not max.is_extended_real:
+            raise ValueError("Only real AccumulationBounds are supported")
+
+        if max == min:
+            return max
+
+        # Make sure that the created AccumBounds object will be valid.
+        if max.is_number and min.is_number:
+            bad = max.is_comparable and min.is_comparable and max < min
+        else:
+            bad = (max - min).is_extended_negative
+        if bad:
+            raise ValueError(
+                "Lower limit should be smaller than upper limit")
+
+        return Basic.__new__(cls, min, max)
+
+    # setting the operation priority
+    _op_priority = 11.0
+
+    def _eval_is_real(self):
+        if self.min.is_real and self.max.is_real:
+            return True
+
+    @property
+    def min(self):
+        """
+        Returns the minimum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).min
+        1
+
+        """
+        return self.args[0]
+
+    @property
+    def max(self):
+        """
+        Returns the maximum possible value attained by AccumulationBounds
+        object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).max
+        3
+
+        """
+        return self.args[1]
+
+    @property
+    def delta(self):
+        """
+        Returns the difference of maximum possible value attained by
+        AccumulationBounds object and minimum possible value attained
+        by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).delta
+        2
+
+        """
+        return self.max - self.min
+
+    @property
+    def mid(self):
+        """
+        Returns the mean of maximum possible value attained by
+        AccumulationBounds object and minimum possible value
+        attained by AccumulationBounds object.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds
+        >>> AccumBounds(1, 3).mid
+        2
+
+        """
+        return (self.min + self.max) / 2
+
+    @_sympifyit('other', NotImplemented)
+    def _eval_power(self, other):
+        return self.__pow__(other)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, other.min),
+                    Add(self.max, other.max))
+            if other is S.Infinity and self.min is S.NegativeInfinity or \
+                    other is S.NegativeInfinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max + other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min + other, oo)
+                else:
+                    return AccumBounds(Add(self.min, other), Add(self.max, other))
+            return Add(self, other, evaluate=False)
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __neg__(self):
+        return AccumBounds(-self.max, -self.min)
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                return AccumBounds(
+                    Add(self.min, -other.max),
+                    Add(self.max, -other.min))
+            if other is S.NegativeInfinity and self.min is S.NegativeInfinity or \
+                    other is S.Infinity and self.max is S.Infinity:
+                return AccumBounds(-oo, oo)
+            elif other.is_extended_real:
+                if self.min is S.NegativeInfinity and self.max is S.Infinity:
+                    return AccumBounds(-oo, oo)
+                elif self.min is S.NegativeInfinity:
+                    return AccumBounds(-oo, self.max - other)
+                elif self.max is S.Infinity:
+                    return AccumBounds(self.min - other, oo)
+                else:
+                    return AccumBounds(
+                        Add(self.min, -other),
+                        Add(self.max, -other))
+            return Add(self, -other, evaluate=False)
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        return self.__neg__() + other
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if self.args == (-oo, oo):
+            return self
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.args == (-oo, oo):
+                    return other
+                v = set()
+                for a in self.args:
+                    vi = other*a
+                    v.update(vi.args or (vi,))
+                return AccumBounds(Min(*v), Max(*v))
+            if other is S.Infinity:
+                if self.min.is_zero:
+                    return AccumBounds(0, oo)
+                if self.max.is_zero:
+                    return AccumBounds(-oo, 0)
+            if other is S.NegativeInfinity:
+                if self.min.is_zero:
+                    return AccumBounds(-oo, 0)
+                if self.max.is_zero:
+                    return AccumBounds(0, oo)
+            if other.is_extended_real:
+                if other.is_zero:
+                    if self.max is S.Infinity:
+                        return AccumBounds(0, oo)
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(-oo, 0)
+                    return S.Zero
+                if other.is_extended_positive:
+                    return AccumBounds(
+                        Mul(self.min, other),
+                        Mul(self.max, other))
+                elif other.is_extended_negative:
+                    return AccumBounds(
+                        Mul(self.max, other),
+                        Mul(self.min, other))
+            if isinstance(other, Order):
+                return other
+            return Mul(self, other, evaluate=False)
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Expr):
+            if isinstance(other, AccumBounds):
+                if other.min.is_positive or other.max.is_negative:
+                    return self * AccumBounds(1/other.max, 1/other.min)
+
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative and
+                    other.min.is_extended_nonpositive and other.max.is_extended_nonnegative):
+                    if self.min.is_zero and other.min.is_zero:
+                        return AccumBounds(0, oo)
+                    if self.max.is_zero and other.min.is_zero:
+                        return AccumBounds(-oo, 0)
+                    return AccumBounds(-oo, oo)
+
+                if self.max.is_extended_negative:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(self.max / other.min, oo)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.max/other.max),
+                            #       Interval(self.max/other.min, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(-oo, self.max / other.max)
+
+                if self.min.is_extended_positive:
+                    if other.min.is_extended_negative:
+                        if other.max.is_zero:
+                            return AccumBounds(-oo, self.min / other.min)
+                        if other.max.is_extended_positive:
+                            # if we were dealing with intervals we would return
+                            # Union(Interval(-oo, self.min/other.min),
+                            #       Interval(self.min/other.max, oo))
+                            return AccumBounds(-oo, oo)
+
+                    if other.min.is_zero and other.max.is_extended_positive:
+                        return AccumBounds(self.min / other.max, oo)
+
+            elif other.is_extended_real:
+                if other in (S.Infinity, S.NegativeInfinity):
+                    if self == AccumBounds(-oo, oo):
+                        return AccumBounds(-oo, oo)
+                    if self.max is S.Infinity:
+                        return AccumBounds(Min(0, other), Max(0, other))
+                    if self.min is S.NegativeInfinity:
+                        return AccumBounds(Min(0, -other), Max(0, -other))
+                if other.is_extended_positive:
+                    return AccumBounds(self.min / other, self.max / other)
+                elif other.is_extended_negative:
+                    return AccumBounds(self.max / other, self.min / other)
+            if (1 / other) is S.ComplexInfinity:
+                return Mul(self, 1 / other, evaluate=False)
+            else:
+                return Mul(self, 1 / other)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rtruediv__(self, other):
+        if isinstance(other, Expr):
+            if other.is_extended_real:
+                if other.is_zero:
+                    return S.Zero
+                if (self.min.is_extended_nonpositive and self.max.is_extended_nonnegative):
+                    if self.min.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(Mul(other, 1 / self.max), oo)
+                        if other.is_extended_negative:
+                            return AccumBounds(-oo, Mul(other, 1 / self.max))
+                    if self.max.is_zero:
+                        if other.is_extended_positive:
+                            return AccumBounds(-oo, Mul(other, 1 / self.min))
+                        if other.is_extended_negative:
+                            return AccumBounds(Mul(other, 1 / self.min), oo)
+                    return AccumBounds(-oo, oo)
+                else:
+                    return AccumBounds(Min(other / self.min, other / self.max),
+                                       Max(other / self.min, other / self.max))
+            return Mul(other, 1 / self, evaluate=False)
+        else:
+            return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __pow__(self, other):
+        if isinstance(other, Expr):
+            if other is S.Infinity:
+                if self.min.is_extended_nonnegative:
+                    if self.max < 1:
+                        return S.Zero
+                    if self.min > 1:
+                        return S.Infinity
+                    return AccumBounds(0, oo)
+                elif self.max.is_extended_negative:
+                    if self.min > -1:
+                        return S.Zero
+                    if self.max < -1:
+                        return zoo
+                    return S.NaN
+                else:
+                    if self.min > -1:
+                        if self.max < 1:
+                            return S.Zero
+                        return AccumBounds(0, oo)
+                    return AccumBounds(-oo, oo)
+
+            if other is S.NegativeInfinity:
+                return (1/self)**oo
+
+            # generically true
+            if (self.max - self.min).is_nonnegative:
+                # well defined
+                if self.min.is_nonnegative:
+                    # no 0 to worry about
+                    if other.is_nonnegative:
+                        # no infinity to worry about
+                        return self.func(self.min**other, self.max**other)
+
+            if other.is_zero:
+                return S.One  # x**0 = 1
+
+            if other.is_Integer or other.is_integer:
+                if self.min.is_extended_positive:
+                    return AccumBounds(
+                        Min(self.min**other, self.max**other),
+                        Max(self.min**other, self.max**other))
+                elif self.max.is_extended_negative:
+                    return AccumBounds(
+                        Min(self.max**other, self.min**other),
+                        Max(self.max**other, self.min**other))
+
+                if other % 2 == 0:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(self.min**other, oo)
+                        return (1/self)**(-other)
+                    return AccumBounds(
+                        S.Zero, Max(self.min**other, self.max**other))
+                elif other % 2 == 1:
+                    if other.is_extended_negative:
+                        if self.min.is_zero:
+                            return AccumBounds(self.max**other, oo)
+                        if self.max.is_zero:
+                            return AccumBounds(-oo, self.min**other)
+                        return (1/self)**(-other)
+                    return AccumBounds(self.min**other, self.max**other)
+
+            # non-integer exponent
+            # 0**neg or neg**frac yields complex
+            if (other.is_number or other.is_rational) and (
+                    self.min.is_extended_nonnegative or (
+                    other.is_extended_nonnegative and
+                    self.min.is_extended_nonnegative)):
+                num, den = other.as_numer_denom()
+                if num is S.One:
+                    return AccumBounds(*[i**(1/den) for i in self.args])
+
+                elif den is not S.One:  # e.g. if other is not Float
+                    return (self**num)**(1/den)  # ok for non-negative base
+
+            if isinstance(other, AccumBounds):
+                if (self.min.is_extended_positive or
+                        self.min.is_extended_nonnegative and
+                        other.min.is_extended_nonnegative):
+                    p = [self**i for i in other.args]
+                    if not any(i.is_Pow for i in p):
+                        a = [j for i in p for j in i.args or (i,)]
+                        try:
+                            return self.func(min(a), max(a))
+                        except TypeError:  # can't sort
+                            pass
+
+            return Pow(self, other, evaluate=False)
+
+        return NotImplemented
+
+    @_sympifyit('other', NotImplemented)
+    def __rpow__(self, other):
+        if other.is_real and other.is_extended_nonnegative and (
+                self.max - self.min).is_extended_positive:
+            if other is S.One:
+                return S.One
+            if other.is_extended_positive:
+                a, b = [other**i for i in self.args]
+                if min(a, b) != a:
+                    a, b = b, a
+                return self.func(a, b)
+            if other.is_zero:
+                if self.min.is_zero:
+                    return self.func(0, 1)
+                if self.min.is_extended_positive:
+                    return S.Zero
+
+        return Pow(other, self, evaluate=False)
+
+    def __abs__(self):
+        if self.max.is_extended_negative:
+            return self.__neg__()
+        elif self.min.is_extended_negative:
+            return AccumBounds(S.Zero, Max(abs(self.min), self.max))
+        else:
+            return self
+
+
+    def __contains__(self, other):
+        """
+        Returns ``True`` if other is contained in self, where other
+        belongs to extended real numbers, ``False`` if not contained,
+        otherwise TypeError is raised.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, oo
+        >>> 1 in AccumBounds(-1, 3)
+        True
+
+        -oo and oo go together as limits (in AccumulationBounds).
+
+        >>> -oo in AccumBounds(1, oo)
+        True
+
+        >>> oo in AccumBounds(-oo, 0)
+        True
+
+        """
+        other = _sympify(other)
+
+        if other in (S.Infinity, S.NegativeInfinity):
+            if self.min is S.NegativeInfinity or self.max is S.Infinity:
+                return True
+            return False
+
+        rv = And(self.min <= other, self.max >= other)
+        if rv not in (True, False):
+            raise TypeError("input failed to evaluate")
+        return rv
+
+    def intersection(self, other):
+        """
+        Returns the intersection of 'self' and 'other'.
+        Here other can be an instance of :py:class:`~.FiniteSet` or AccumulationBounds.
+
+        Parameters
+        ==========
+
+        other : AccumulationBounds
+            Another AccumulationBounds object with which the intersection
+            has to be computed.
+
+        Returns
+        =======
+
+        AccumulationBounds
+            Intersection of ``self`` and ``other``.
+
+        Examples
+        ========
+
+        >>> from sympy import AccumBounds, FiniteSet
+        >>> AccumBounds(1, 3).intersection(AccumBounds(2, 4))
+        AccumBounds(2, 3)
+
+        >>> AccumBounds(1, 3).intersection(AccumBounds(4, 6))
+        EmptySet
+
+        >>> AccumBounds(1, 4).intersection(FiniteSet(1, 2, 5))
+        {1, 2}
+
+        """
+        if not isinstance(other, (AccumBounds, FiniteSet)):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if isinstance(other, FiniteSet):
+            fin_set = S.EmptySet
+            for i in other:
+                if i in self:
+                    fin_set = fin_set + FiniteSet(i)
+            return fin_set
+
+        if self.max < other.min or self.min > other.max:
+            return S.EmptySet
+
+        if self.min <= other.min:
+            if self.max <= other.max:
+                return AccumBounds(other.min, self.max)
+            if self.max > other.max:
+                return other
+
+        if other.min <= self.min:
+            if other.max < self.max:
+                return AccumBounds(self.min, other.max)
+            if other.max > self.max:
+                return self
+
+    def union(self, other):
+        # TODO : Devise a better method for Union of AccumBounds
+        # this method is not actually correct and
+        # can be made better
+        if not isinstance(other, AccumBounds):
+            raise TypeError(
+                "Input must be AccumulationBounds or FiniteSet object")
+
+        if self.min <= other.min and self.max >= other.min:
+            return AccumBounds(self.min, Max(self.max, other.max))
+
+        if other.min <= self.min and other.max >= self.min:
+            return AccumBounds(other.min, Max(self.max, other.max))
+
+
+@dispatch(AccumulationBounds, AccumulationBounds) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa:F811
+    if is_le(lhs.max, rhs.min):
+        return True
+    if is_gt(lhs.min, rhs.max):
+        return False
+
+
+@dispatch(AccumulationBounds, Basic) # type: ignore # noqa:F811
+def _eval_is_le(lhs, rhs): # noqa: F811
+
+    """
+    Returns ``True `` if range of values attained by ``lhs`` AccumulationBounds
+    object is greater than the range of values attained by ``rhs``,
+    where ``rhs`` may be any value of type AccumulationBounds object or
+    extended real number value, ``False`` if ``rhs`` satisfies
+    the same property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) > AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) > AccumBounds(3, 4)
+    AccumBounds(1, 4) > AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) > -1
+    True
+
+    """
+    if not rhs.is_extended_real:
+            raise TypeError(
+                "Invalid comparison of %s %s" %
+                (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_le(lhs.max, rhs):
+            return True
+        if is_gt(lhs.min, rhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+
+@dispatch(AccumulationBounds, Expr)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa: F811
+    """
+    Returns ``True`` if range of values attained by ``lhs`` AccumulationBounds
+    object is less that the range of values attained by ``rhs``, where
+    other may be any value of type AccumulationBounds object or extended
+    real number value, ``False`` if ``rhs`` satisfies the same
+    property, else an unevaluated :py:class:`~.Relational`.
+
+    Examples
+    ========
+
+    >>> from sympy import AccumBounds, oo
+    >>> AccumBounds(1, 3) >= AccumBounds(4, oo)
+    False
+    >>> AccumBounds(1, 4) >= AccumBounds(3, 4)
+    AccumBounds(1, 4) >= AccumBounds(3, 4)
+    >>> AccumBounds(1, oo) >= 1
+    True
+    """
+
+    if not rhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(rhs), rhs))
+    elif rhs.is_comparable:
+        if is_ge(lhs.min, rhs):
+            return True
+        if is_lt(lhs.max, rhs):
+            return False
+
+
+@dispatch(Expr, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if not lhs.is_extended_real:
+        raise TypeError(
+            "Invalid comparison of %s %s" %
+            (type(lhs), lhs))
+    elif lhs.is_comparable:
+        if is_le(rhs.max, lhs):
+            return True
+        if is_gt(rhs.min, lhs):
+            return False
+
+
+@dispatch(AccumulationBounds, AccumulationBounds)  # type:ignore
+def _eval_is_ge(lhs, rhs): # noqa:F811
+    if is_ge(lhs.min, rhs.max):
+        return True
+    if is_lt(lhs.max, rhs.min):
+        return False
+
+# setting an alias for AccumulationBounds
+AccumBounds = AccumulationBounds
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/euler.py b/.venv/lib/python3.12/site-packages/sympy/calculus/euler.py
new file mode 100644
index 0000000000000000000000000000000000000000..817acf76091dfba2dba40487ca7735e307c0fc15
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/euler.py
@@ -0,0 +1,108 @@
+"""
+This module implements a method to find
+Euler-Lagrange Equations for given Lagrangian.
+"""
+from itertools import combinations_with_replacement
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+def euler_equations(L, funcs=(), vars=()):
+    r"""
+    Find the Euler-Lagrange equations [1]_ for a given Lagrangian.
+
+    Parameters
+    ==========
+
+    L : Expr
+        The Lagrangian that should be a function of the functions listed
+        in the second argument and their derivatives.
+
+        For example, in the case of two functions $f(x,y)$, $g(x,y)$ and
+        two independent variables $x$, $y$ the Lagrangian has the form:
+
+            .. math:: L\left(f(x,y),g(x,y),\frac{\partial f(x,y)}{\partial x},
+                      \frac{\partial f(x,y)}{\partial y},
+                      \frac{\partial g(x,y)}{\partial x},
+                      \frac{\partial g(x,y)}{\partial y},x,y\right)
+
+        In many cases it is not necessary to provide anything, except the
+        Lagrangian, it will be auto-detected (and an error raised if this
+        cannot be done).
+
+    funcs : Function or an iterable of Functions
+        The functions that the Lagrangian depends on. The Euler equations
+        are differential equations for each of these functions.
+
+    vars : Symbol or an iterable of Symbols
+        The Symbols that are the independent variables of the functions.
+
+    Returns
+    =======
+
+    eqns : list of Eq
+        The list of differential equations, one for each function.
+
+    Examples
+    ========
+
+    >>> from sympy import euler_equations, Symbol, Function
+    >>> x = Function('x')
+    >>> t = Symbol('t')
+    >>> L = (x(t).diff(t))**2/2 - x(t)**2/2
+    >>> euler_equations(L, x(t), t)
+    [Eq(-x(t) - Derivative(x(t), (t, 2)), 0)]
+    >>> u = Function('u')
+    >>> x = Symbol('x')
+    >>> L = (u(t, x).diff(t))**2/2 - (u(t, x).diff(x))**2/2
+    >>> euler_equations(L, u(t, x), [t, x])
+    [Eq(-Derivative(u(t, x), (t, 2)) + Derivative(u(t, x), (x, 2)), 0)]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Lagrange_equation
+
+    """
+
+    funcs = tuple(funcs) if iterable(funcs) else (funcs,)
+
+    if not funcs:
+        funcs = tuple(L.atoms(Function))
+    else:
+        for f in funcs:
+            if not isinstance(f, Function):
+                raise TypeError('Function expected, got: %s' % f)
+
+    vars = tuple(vars) if iterable(vars) else (vars,)
+
+    if not vars:
+        vars = funcs[0].args
+    else:
+        vars = tuple(sympify(var) for var in vars)
+
+    if not all(isinstance(v, Symbol) for v in vars):
+        raise TypeError('Variables are not symbols, got %s' % vars)
+
+    for f in funcs:
+        if not vars == f.args:
+            raise ValueError("Variables %s do not match args: %s" % (vars, f))
+
+    order = max([len(d.variables) for d in L.atoms(Derivative)
+                        if d.expr in funcs] + [0])
+
+    eqns = []
+    for f in funcs:
+        eq = diff(L, f)
+        for i in range(1, order + 1):
+            for p in combinations_with_replacement(vars, i):
+                eq = eq + S.NegativeOne**i*diff(L, diff(f, *p), *p)
+        new_eq = Eq(eq, 0)
+        if isinstance(new_eq, Eq):
+            eqns.append(new_eq)
+
+    return eqns
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/finite_diff.py b/.venv/lib/python3.12/site-packages/sympy/calculus/finite_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..17eece149aadad236cefeb350e1ef4a383c84f01
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/finite_diff.py
@@ -0,0 +1,476 @@
+"""
+Finite difference weights
+=========================
+
+This module implements an algorithm for efficient generation of finite
+difference weights for ordinary differentials of functions for
+derivatives from 0 (interpolation) up to arbitrary order.
+
+The core algorithm is provided in the finite difference weight generating
+function (``finite_diff_weights``), and two convenience functions are provided
+for:
+
+- estimating a derivative (or interpolate) directly from a series of points
+    is also provided (``apply_finite_diff``).
+- differentiating by using finite difference approximations
+    (``differentiate_finite``).
+
+"""
+
+from sympy.core.function import Derivative
+from sympy.core.singleton import S
+from sympy.core.function import Subs
+from sympy.core.traversal import preorder_traversal
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable
+
+
+
+def finite_diff_weights(order, x_list, x0=S.One):
+    """
+    Calculates the finite difference weights for an arbitrarily spaced
+    one-dimensional grid (``x_list``) for derivatives at ``x0`` of order
+    0, 1, ..., up to ``order`` using a recursive formula. Order of accuracy
+    is at least ``len(x_list) - order``, if ``x_list`` is defined correctly.
+
+    Parameters
+    ==========
+
+    order: int
+        Up to what derivative order weights should be calculated.
+        0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+        It is useful (but not necessary) to order ``x_list`` from
+        nearest to furthest from ``x0``; see examples below.
+    x0: Number or Symbol
+        Root or value of the independent variable for which the finite
+        difference weights should be generated. Default is ``S.One``.
+
+    Returns
+    =======
+
+    list
+        A list of sublists, each corresponding to coefficients for
+        increasing derivative order, and each containing lists of
+        coefficients for increasing subsets of x_list.
+
+    Examples
+    ========
+
+    >>> from sympy import finite_diff_weights, S
+    >>> res = finite_diff_weights(1, [-S(1)/2, S(1)/2, S(3)/2, S(5)/2], 0)
+    >>> res
+    [[[1, 0, 0, 0],
+      [1/2, 1/2, 0, 0],
+      [3/8, 3/4, -1/8, 0],
+      [5/16, 15/16, -5/16, 1/16]],
+     [[0, 0, 0, 0],
+      [-1, 1, 0, 0],
+      [-1, 1, 0, 0],
+      [-23/24, 7/8, 1/8, -1/24]]]
+    >>> res[0][-1]  # FD weights for 0th derivative, using full x_list
+    [5/16, 15/16, -5/16, 1/16]
+    >>> res[1][-1]  # FD weights for 1st derivative
+    [-23/24, 7/8, 1/8, -1/24]
+    >>> res[1][-2]  # FD weights for 1st derivative, using x_list[:-1]
+    [-1, 1, 0, 0]
+    >>> res[1][-1][0]  # FD weight for 1st deriv. for x_list[0]
+    -23/24
+    >>> res[1][-1][1]  # FD weight for 1st deriv. for x_list[1], etc.
+    7/8
+
+    Each sublist contains the most accurate formula at the end.
+    Note, that in the above example ``res[1][1]`` is the same as ``res[1][2]``.
+    Since res[1][2] has an order of accuracy of
+    ``len(x_list[:3]) - order = 3 - 1 = 2``, the same is true for ``res[1][1]``!
+
+    >>> res = finite_diff_weights(1, [S(0), S(1), -S(1), S(2), -S(2)], 0)[1]
+    >>> res
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [0, 1/2, -1/2, 0, 0],
+     [-1/2, 1, -1/3, -1/6, 0],
+     [0, 2/3, -2/3, -1/12, 1/12]]
+    >>> res[0]  # no approximation possible, using x_list[0] only
+    [0, 0, 0, 0, 0]
+    >>> res[1]  # classic forward step approximation
+    [-1, 1, 0, 0, 0]
+    >>> res[2]  # classic centered approximation
+    [0, 1/2, -1/2, 0, 0]
+    >>> res[3:]  # higher order approximations
+    [[-1/2, 1, -1/3, -1/6, 0], [0, 2/3, -2/3, -1/12, 1/12]]
+
+    Let us compare this to a differently defined ``x_list``. Pay attention to
+    ``foo[i][k]`` corresponding to the gridpoint defined by ``x_list[k]``.
+
+    >>> foo = finite_diff_weights(1, [-S(2), -S(1), S(0), S(1), S(2)], 0)[1]
+    >>> foo
+    [[0, 0, 0, 0, 0],
+     [-1, 1, 0, 0, 0],
+     [1/2, -2, 3/2, 0, 0],
+     [1/6, -1, 1/2, 1/3, 0],
+     [1/12, -2/3, 0, 2/3, -1/12]]
+    >>> foo[1]  # not the same and of lower accuracy as res[1]!
+    [-1, 1, 0, 0, 0]
+    >>> foo[2]  # classic double backward step approximation
+    [1/2, -2, 3/2, 0, 0]
+    >>> foo[4]  # the same as res[4]
+    [1/12, -2/3, 0, 2/3, -1/12]
+
+    Note that, unless you plan on using approximations based on subsets of
+    ``x_list``, the order of gridpoints does not matter.
+
+    The capability to generate weights at arbitrary points can be
+    used e.g. to minimize Runge's phenomenon by using Chebyshev nodes:
+
+    >>> from sympy import cos, symbols, pi, simplify
+    >>> N, (h, x) = 4, symbols('h x')
+    >>> x_list = [x+h*cos(i*pi/(N)) for i in range(N,-1,-1)] # chebyshev nodes
+    >>> print(x_list)
+    [-h + x, -sqrt(2)*h/2 + x, x, sqrt(2)*h/2 + x, h + x]
+    >>> mycoeffs = finite_diff_weights(1, x_list, 0)[1][4]
+    >>> [simplify(c) for c in  mycoeffs] #doctest: +NORMALIZE_WHITESPACE
+    [(h**3/2 + h**2*x - 3*h*x**2 - 4*x**3)/h**4,
+    (-sqrt(2)*h**3 - 4*h**2*x + 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (6*h**2*x - 8*x**3)/h**4,
+    (sqrt(2)*h**3 - 4*h**2*x - 3*sqrt(2)*h*x**2 + 8*x**3)/h**4,
+    (-h**3/2 + h**2*x + 3*h*x**2 - 4*x**3)/h**4]
+
+    Notes
+    =====
+
+    If weights for a finite difference approximation of 3rd order
+    derivative is wanted, weights for 0th, 1st and 2nd order are
+    calculated "for free", so are formulae using subsets of ``x_list``.
+    This is something one can take advantage of to save computational cost.
+    Be aware that one should define ``x_list`` from nearest to furthest from
+    ``x0``. If not, subsets of ``x_list`` will yield poorer approximations,
+    which might not grand an order of accuracy of ``len(x_list) - order``.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+
+    References
+    ==========
+
+    .. [1] Generation of Finite Difference Formulas on Arbitrarily Spaced
+            Grids, Bengt Fornberg; Mathematics of computation; 51; 184;
+            (1988); 699-706; doi:10.1090/S0025-5718-1988-0935077-0
+
+    """
+    # The notation below closely corresponds to the one used in the paper.
+    order = S(order)
+    if not order.is_number:
+        raise ValueError("Cannot handle symbolic order.")
+    if order < 0:
+        raise ValueError("Negative derivative order illegal.")
+    if int(order) != order:
+        raise ValueError("Non-integer order illegal")
+    M = order
+    N = len(x_list) - 1
+    delta = [[[0 for nu in range(N+1)] for n in range(N+1)] for
+             m in range(M+1)]
+    delta[0][0][0] = S.One
+    c1 = S.One
+    for n in range(1, N+1):
+        c2 = S.One
+        for nu in range(n):
+            c3 = x_list[n] - x_list[nu]
+            c2 = c2 * c3
+            if n <= M:
+                delta[n][n-1][nu] = 0
+            for m in range(min(n, M)+1):
+                delta[m][n][nu] = (x_list[n]-x0)*delta[m][n-1][nu] -\
+                    m*delta[m-1][n-1][nu]
+                delta[m][n][nu] /= c3
+        for m in range(min(n, M)+1):
+            delta[m][n][n] = c1/c2*(m*delta[m-1][n-1][n-1] -
+                                    (x_list[n-1]-x0)*delta[m][n-1][n-1])
+        c1 = c2
+    return delta
+
+
+def apply_finite_diff(order, x_list, y_list, x0=S.Zero):
+    """
+    Calculates the finite difference approximation of
+    the derivative of requested order at ``x0`` from points
+    provided in ``x_list`` and ``y_list``.
+
+    Parameters
+    ==========
+
+    order: int
+        order of derivative to approximate. 0 corresponds to interpolation.
+    x_list: sequence
+        Sequence of (unique) values for the independent variable.
+    y_list: sequence
+        The function value at corresponding values for the independent
+        variable in x_list.
+    x0: Number or Symbol
+        At what value of the independent variable the derivative should be
+        evaluated. Defaults to 0.
+
+    Returns
+    =======
+
+    sympy.core.add.Add or sympy.core.numbers.Number
+        The finite difference expression approximating the requested
+        derivative order at ``x0``.
+
+    Examples
+    ========
+
+    >>> from sympy import apply_finite_diff
+    >>> cube = lambda arg: (1.0*arg)**3
+    >>> xlist = range(-3,3+1)
+    >>> apply_finite_diff(2, xlist, map(cube, xlist), 2) - 12 # doctest: +SKIP
+    -3.55271367880050e-15
+
+    we see that the example above only contain rounding errors.
+    apply_finite_diff can also be used on more abstract objects:
+
+    >>> from sympy import IndexedBase, Idx
+    >>> x, y = map(IndexedBase, 'xy')
+    >>> i = Idx('i')
+    >>> x_list, y_list = zip(*[(x[i+j], y[i+j]) for j in range(-1,2)])
+    >>> apply_finite_diff(1, x_list, y_list, x[i])
+    ((x[i + 1] - x[i])/(-x[i - 1] + x[i]) - 1)*y[i]/(x[i + 1] - x[i]) -
+    (x[i + 1] - x[i])*y[i - 1]/((x[i + 1] - x[i - 1])*(-x[i - 1] + x[i])) +
+    (-x[i - 1] + x[i])*y[i + 1]/((x[i + 1] - x[i - 1])*(x[i + 1] - x[i]))
+
+    Notes
+    =====
+
+    Order = 0 corresponds to interpolation.
+    Only supply so many points you think makes sense
+    to around x0 when extracting the derivative (the function
+    need to be well behaved within that region). Also beware
+    of Runge's phenomenon.
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    References
+    ==========
+
+    Fortran 90 implementation with Python interface for numerics: finitediff_
+
+    .. _finitediff: https://github.com/bjodah/finitediff
+
+    """
+
+    # In the original paper the following holds for the notation:
+    # M = order
+    # N = len(x_list) - 1
+
+    N = len(x_list) - 1
+    if len(x_list) != len(y_list):
+        raise ValueError("x_list and y_list not equal in length.")
+
+    delta = finite_diff_weights(order, x_list, x0)
+
+    derivative = 0
+    for nu in range(len(x_list)):
+        derivative += delta[order][N][nu]*y_list[nu]
+    return derivative
+
+
+def _as_finite_diff(derivative, points=1, x0=None, wrt=None):
+    """
+    Returns an approximation of a derivative of a function in
+    the form of a finite difference formula. The expression is a
+    weighted sum of the function at a number of discrete values of
+    (one of) the independent variable(s).
+
+    Parameters
+    ==========
+
+    derivative: a Derivative instance
+
+    points: sequence or coefficient, optional
+        If sequence: discrete values (length >= order+1) of the
+        independent variable used for generating the finite
+        difference weights.
+        If it is a coefficient, it will be used as the step-size
+        for generating an equidistant sequence of length order+1
+        centered around ``x0``. default: 1 (step-size 1)
+
+    x0: number or Symbol, optional
+        the value of the independent variable (``wrt``) at which the
+        derivative is to be approximated. Default: same as ``wrt``.
+
+    wrt: Symbol, optional
+        "with respect to" the variable for which the (partial)
+        derivative is to be approximated for. If not provided it
+        is required that the Derivative is ordinary. Default: ``None``.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Function, exp, sqrt, Symbol
+    >>> from sympy.calculus.finite_diff import _as_finite_diff
+    >>> x, h = symbols('x h')
+    >>> f = Function('f')
+    >>> _as_finite_diff(f(x).diff(x))
+    -f(x - 1/2) + f(x + 1/2)
+
+    The default step size and number of points are 1 and ``order + 1``
+    respectively. We can change the step size by passing a symbol
+    as a parameter:
+
+    >>> _as_finite_diff(f(x).diff(x), h)
+    -f(-h/2 + x)/h + f(h/2 + x)/h
+
+    We can also specify the discretized values to be used in a sequence:
+
+    >>> _as_finite_diff(f(x).diff(x), [x, x+h, x+2*h])
+    -3*f(x)/(2*h) + 2*f(h + x)/h - f(2*h + x)/(2*h)
+
+    The algorithm is not restricted to use equidistant spacing, nor
+    do we need to make the approximation around ``x0``, but we can get
+    an expression estimating the derivative at an offset:
+
+    >>> e, sq2 = exp(1), sqrt(2)
+    >>> xl = [x-h, x+h, x+e*h]
+    >>> _as_finite_diff(f(x).diff(x, 1), xl, x+h*sq2)
+    2*h*((h + sqrt(2)*h)/(2*h) - (-sqrt(2)*h + h)/(2*h))*f(E*h + x)/((-h + E*h)*(h + E*h)) +
+    (-(-sqrt(2)*h + h)/(2*h) - (-sqrt(2)*h + E*h)/(2*h))*f(-h + x)/(h + E*h) +
+    (-(h + sqrt(2)*h)/(2*h) + (-sqrt(2)*h + E*h)/(2*h))*f(h + x)/(-h + E*h)
+
+    Partial derivatives are also supported:
+
+    >>> y = Symbol('y')
+    >>> d2fdxdy=f(x,y).diff(x,y)
+    >>> _as_finite_diff(d2fdxdy, wrt=x)
+    -Derivative(f(x - 1/2, y), y) + Derivative(f(x + 1/2, y), y)
+
+    See also
+    ========
+
+    sympy.calculus.finite_diff.apply_finite_diff
+    sympy.calculus.finite_diff.finite_diff_weights
+
+    """
+    if derivative.is_Derivative:
+        pass
+    elif derivative.is_Atom:
+        return derivative
+    else:
+        return derivative.fromiter(
+            [_as_finite_diff(ar, points, x0, wrt) for ar
+             in derivative.args], **derivative.assumptions0)
+
+    if wrt is None:
+        old = None
+        for v in derivative.variables:
+            if old is v:
+                continue
+            derivative = _as_finite_diff(derivative, points, x0, v)
+            old = v
+        return derivative
+
+    order = derivative.variables.count(wrt)
+
+    if x0 is None:
+        x0 = wrt
+
+    if not iterable(points):
+        if getattr(points, 'is_Function', False) and wrt in points.args:
+            points = points.subs(wrt, x0)
+        # points is simply the step-size, let's make it a
+        # equidistant sequence centered around x0
+        if order % 2 == 0:
+            # even order => odd number of points, grid point included
+            points = [x0 + points*i for i
+                      in range(-order//2, order//2 + 1)]
+        else:
+            # odd order => even number of points, half-way wrt grid point
+            points = [x0 + points*S(i)/2 for i
+                      in range(-order, order + 1, 2)]
+    others = [wrt, 0]
+    for v in set(derivative.variables):
+        if v == wrt:
+            continue
+        others += [v, derivative.variables.count(v)]
+    if len(points) < order+1:
+        raise ValueError("Too few points for order %d" % order)
+    return apply_finite_diff(order, points, [
+        Derivative(derivative.expr.subs({wrt: x}), *others) for
+        x in points], x0)
+
+
+def differentiate_finite(expr, *symbols,
+                         points=1, x0=None, wrt=None, evaluate=False):
+    r""" Differentiate expr and replace Derivatives with finite differences.
+
+    Parameters
+    ==========
+
+    expr : expression
+    \*symbols : differentiate with respect to symbols
+    points: sequence, coefficient or undefined function, optional
+        see ``Derivative.as_finite_difference``
+    x0: number or Symbol, optional
+        see ``Derivative.as_finite_difference``
+    wrt: Symbol, optional
+        see ``Derivative.as_finite_difference``
+
+    Examples
+    ========
+
+    >>> from sympy import sin, Function, differentiate_finite
+    >>> from sympy.abc import x, y, h
+    >>> f, g = Function('f'), Function('g')
+    >>> differentiate_finite(f(x)*g(x), x, points=[x-h, x+h])
+    -f(-h + x)*g(-h + x)/(2*h) + f(h + x)*g(h + x)/(2*h)
+
+    ``differentiate_finite`` works on any expression, including the expressions
+    with embedded derivatives:
+
+    >>> differentiate_finite(f(x) + sin(x), x, 2)
+    -2*f(x) + f(x - 1) + f(x + 1) - 2*sin(x) + sin(x - 1) + sin(x + 1)
+    >>> differentiate_finite(f(x, y), x, y)
+    f(x - 1/2, y - 1/2) - f(x - 1/2, y + 1/2) - f(x + 1/2, y - 1/2) + f(x + 1/2, y + 1/2)
+    >>> differentiate_finite(f(x)*g(x).diff(x), x)
+    (-g(x) + g(x + 1))*f(x + 1/2) - (g(x) - g(x - 1))*f(x - 1/2)
+
+    To make finite difference with non-constant discretization step use
+    undefined functions:
+
+    >>> dx = Function('dx')
+    >>> differentiate_finite(f(x)*g(x).diff(x), points=dx(x))
+    -(-g(x - dx(x)/2 - dx(x - dx(x)/2)/2)/dx(x - dx(x)/2) +
+    g(x - dx(x)/2 + dx(x - dx(x)/2)/2)/dx(x - dx(x)/2))*f(x - dx(x)/2)/dx(x) +
+    (-g(x + dx(x)/2 - dx(x + dx(x)/2)/2)/dx(x + dx(x)/2) +
+    g(x + dx(x)/2 + dx(x + dx(x)/2)/2)/dx(x + dx(x)/2))*f(x + dx(x)/2)/dx(x)
+
+    """
+    if any(term.is_Derivative for term in list(preorder_traversal(expr))):
+        evaluate = False
+
+    Dexpr = expr.diff(*symbols, evaluate=evaluate)
+    if evaluate:
+        sympy_deprecation_warning("""
+        The evaluate flag to differentiate_finite() is deprecated.
+
+        evaluate=True expands the intermediate derivatives before computing
+        differences, but this usually not what you want, as it does not
+        satisfy the product rule.
+        """,
+            deprecated_since_version="1.5",
+             active_deprecations_target="deprecated-differentiate_finite-evaluate",
+        )
+        return Dexpr.replace(
+            lambda arg: arg.is_Derivative,
+            lambda arg: arg.as_finite_difference(points=points, x0=x0, wrt=wrt))
+    else:
+        DFexpr = Dexpr.as_finite_difference(points=points, x0=x0, wrt=wrt)
+        return DFexpr.replace(
+            lambda arg: isinstance(arg, Subs),
+            lambda arg: arg.expr.as_finite_difference(
+                    points=points, x0=arg.point[0], wrt=arg.variables[0]))
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/singularities.py b/.venv/lib/python3.12/site-packages/sympy/calculus/singularities.py
new file mode 100644
index 0000000000000000000000000000000000000000..5adafc59efaf0bff44707f6b5e3f074be6bc1f32
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/singularities.py
@@ -0,0 +1,406 @@
+"""
+Singularities
+=============
+
+This module implements algorithms for finding singularities for a function
+and identifying types of functions.
+
+The differential calculus methods in this module include methods to identify
+the following function types in the given ``Interval``:
+- Increasing
+- Strictly Increasing
+- Decreasing
+- Strictly Decreasing
+- Monotonic
+
+"""
+
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import sec, csc, cot, tan, cos
+from sympy.functions.elementary.hyperbolic import (
+    sech, csch, coth, tanh, cosh, asech, acsch, atanh, acoth)
+from sympy.utilities.misc import filldedent
+
+
+def singularities(expression, symbol, domain=None):
+    """
+    Find singularities of a given function.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function in which singularities need to be found.
+    symbol : Symbol
+        The symbol over the values of which the singularity in
+        expression in being searched for.
+
+    Returns
+    =======
+
+    Set
+        A set of values for ``symbol`` for which ``expression`` has a
+        singularity. An ``EmptySet`` is returned if ``expression`` has no
+        singularities for any given value of ``Symbol``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Methods for determining the singularities of this function have
+        not been developed.
+
+    Notes
+    =====
+
+    This function does not find non-isolated singularities
+    nor does it find branch points of the expression.
+
+    Currently supported functions are:
+        - univariate continuous (real or complex) functions
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathematical_singularity
+
+    Examples
+    ========
+
+    >>> from sympy import singularities, Symbol, log
+    >>> x = Symbol('x', real=True)
+    >>> y = Symbol('y', real=False)
+    >>> singularities(x**2 + x + 1, x)
+    EmptySet
+    >>> singularities(1/(x + 1), x)
+    {-1}
+    >>> singularities(1/(y**2 + 1), y)
+    {-I, I}
+    >>> singularities(1/(y**3 + 1), y)
+    {-1, 1/2 - sqrt(3)*I/2, 1/2 + sqrt(3)*I/2}
+    >>> singularities(log(x), x)
+    {0}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is None:
+        domain = S.Reals if symbol.is_real else S.Complexes
+    try:
+        sings = S.EmptySet
+        e = expression.rewrite([sec, csc, cot, tan], cos)
+        e = e.rewrite([sech, csch, coth, tanh], cosh)
+        for i in e.atoms(Pow):
+            if i.exp.is_infinite:
+                raise NotImplementedError
+            if i.exp.is_negative:
+                # XXX: exponent of varying sign not handled
+                sings += solveset(i.base, symbol, domain)
+        for i in expression.atoms(log, asech, acsch):
+            sings += solveset(i.args[0], symbol, domain)
+        for i in expression.atoms(atanh, acoth):
+            sings += solveset(i.args[0] - 1, symbol, domain)
+            sings += solveset(i.args[0] + 1, symbol, domain)
+        return sings
+    except NotImplementedError:
+        raise NotImplementedError(filldedent('''
+            Methods for determining the singularities
+            of this function have not been developed.'''))
+
+
+###########################################################################
+#                      DIFFERENTIAL CALCULUS METHODS                      #
+###########################################################################
+
+
+def monotonicity_helper(expression, predicate, interval=S.Reals, symbol=None):
+    """
+    Helper function for functions checking function monotonicity.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked
+    predicate : function
+        The property being tested for. The function takes in an integer
+        and returns a boolean. The integer input is the derivative and
+        the boolean result should be true if the property is being held,
+        and false otherwise.
+    interval : Set, optional
+        The range of values in which we are testing, defaults to all reals.
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    It returns a boolean indicating whether the interval in which
+    the function's derivative satisfies given predicate is a superset
+    of the given interval.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``predicate`` is true for all the derivatives when ``symbol``
+        is varied in ``range``, False otherwise.
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+    free = expression.free_symbols
+
+    if symbol is None:
+        if len(free) > 1:
+            raise NotImplementedError(
+                'The function has not yet been implemented'
+                ' for all multivariate expressions.'
+            )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    derivative = expression.diff(variable)
+    predicate_interval = solveset(predicate(derivative), variable, S.Reals)
+    return interval.is_subset(predicate_interval)
+
+
+def is_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is increasing (either strictly increasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_increasing(-x**2, Interval(-oo, 0))
+    True
+    >>> is_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    False
+    >>> is_increasing(x**2 + y, Interval(1, 2), x)
+    True
+
+    """
+    return monotonicity_helper(expression, lambda x: x >= 0, interval, symbol)
+
+
+def is_strictly_increasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly increasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly increasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_increasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import Interval, oo
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    False
+    >>> is_strictly_increasing(-x**2, Interval(0, oo))
+    False
+    >>> is_strictly_increasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x > 0, interval, symbol)
+
+
+def is_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is decreasing (either strictly decreasing or
+        constant) in the given ``interval``, False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x <= 0, interval, symbol)
+
+
+def is_strictly_decreasing(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is strictly decreasing in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is strictly decreasing in the given ``interval``,
+        False otherwise.
+
+    Examples
+    ========
+
+    >>> from sympy import is_strictly_decreasing
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, S(3)/2))
+    False
+    >>> is_strictly_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, 1.5))
+    False
+    >>> is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    False
+    >>> is_strictly_decreasing(-x**2 + y, Interval(-oo, 0), x)
+    False
+
+    """
+    return monotonicity_helper(expression, lambda x: x < 0, interval, symbol)
+
+
+def is_monotonic(expression, interval=S.Reals, symbol=None):
+    """
+    Return whether the function is monotonic in the given interval.
+
+    Parameters
+    ==========
+
+    expression : Expr
+        The target function which is being checked.
+    interval : Set, optional
+        The range of values in which we are testing (defaults to set of
+        all real numbers).
+    symbol : Symbol, optional
+        The symbol present in expression which gets varied over the given range.
+
+    Returns
+    =======
+
+    Boolean
+        True if ``expression`` is monotonic in the given ``interval``,
+        False otherwise.
+
+    Raises
+    ======
+
+    NotImplementedError
+        Monotonicity check has not been implemented for the queried function.
+
+    Examples
+    ========
+
+    >>> from sympy import is_monotonic
+    >>> from sympy.abc import x, y
+    >>> from sympy import S, Interval, oo
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(S(3)/2, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    True
+    >>> is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    True
+    >>> is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    True
+    >>> is_monotonic(-x**2, S.Reals)
+    False
+    >>> is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    True
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    expression = sympify(expression)
+
+    free = expression.free_symbols
+    if symbol is None and len(free) > 1:
+        raise NotImplementedError(
+            'is_monotonic has not yet been implemented'
+            ' for all multivariate expressions.'
+        )
+
+    variable = symbol or (free.pop() if free else Symbol('x'))
+    turning_points = solveset(expression.diff(variable), variable, interval)
+    return interval.intersection(turning_points) is S.EmptySet
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b81166c90ca1d0ca5e4bf6dcca795cd70f495f0e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_accumulationbounds.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_accumulationbounds.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b08834edb64f4f1c6a06794151cf942fc764783
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_accumulationbounds.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_euler.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_euler.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfcc563bbf5f3bc57cd2af0ea108e5e5efab0809
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_euler.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_finite_diff.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_finite_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aea7f535f0811d4a8c9a77d424019e70692832c0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_finite_diff.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_singularities.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_singularities.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77b7d5c83f3cb9772b563a9cf0755a4512f9b712
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_singularities.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..035770365074e14c56b5d6cad177dd9a8c6fd8e2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/__pycache__/test_util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_accumulationbounds.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_accumulationbounds.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcc47c66327fe21ddca3a6b73ca5914e0441b38e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_accumulationbounds.py
@@ -0,0 +1,336 @@
+from sympy.core.numbers import (E, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core import Add, Mul, Pow
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import x
+
+a = Symbol('a', real=True)
+B = AccumBounds
+
+
+def test_AccumBounds():
+    assert B(1, 2).args == (1, 2)
+    assert B(1, 2).delta is S.One
+    assert B(1, 2).mid == Rational(3, 2)
+    assert B(1, 3).is_real == True
+
+    assert B(1, 1) is S.One
+
+    assert B(1, 2) + 1 == B(2, 3)
+    assert 1 + B(1, 2) == B(2, 3)
+    assert B(1, 2) + B(2, 3) == B(3, 5)
+
+    assert -B(1, 2) == B(-2, -1)
+
+    assert B(1, 2) - 1 == B(0, 1)
+    assert 1 - B(1, 2) == B(-1, 0)
+    assert B(2, 3) - B(1, 2) == B(0, 2)
+
+    assert x + B(1, 2) == Add(B(1, 2), x)
+    assert a + B(1, 2) == B(1 + a, 2 + a)
+    assert B(1, 2) - x == Add(B(1, 2), -x)
+
+    assert B(-oo, 1) + oo == B(-oo, oo)
+    assert B(1, oo) + oo is oo
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert (-oo - B(-1, oo)) is -oo
+    assert B(-oo, 1) - oo is -oo
+
+    assert B(1, oo) - oo == B(-oo, oo)
+    assert B(-oo, 1) - (-oo) == B(-oo, oo)
+    assert (oo - B(1, oo)) == B(-oo, oo)
+    assert (-oo - B(1, oo)) is -oo
+
+    assert B(1, 2)/2 == B(S.Half, 1)
+    assert 2/B(2, 3) == B(Rational(2, 3), 1)
+    assert 1/B(-1, 1) == B(-oo, oo)
+
+    assert abs(B(1, 2)) == B(1, 2)
+    assert abs(B(-2, -1)) == B(1, 2)
+    assert abs(B(-2, 1)) == B(0, 2)
+    assert abs(B(-1, 2)) == B(0, 2)
+    c = Symbol('c')
+    raises(ValueError, lambda: B(0, c))
+    raises(ValueError, lambda: B(1, -1))
+    r = Symbol('r', real=True)
+    raises(ValueError, lambda: B(r, r - 1))
+
+
+def test_AccumBounds_mul():
+    assert B(1, 2)*2 == B(2, 4)
+    assert 2*B(1, 2) == B(2, 4)
+    assert B(1, 2)*B(2, 3) == B(2, 6)
+    assert B(0, 2)*B(2, oo) == B(0, oo)
+    l, r = B(-oo, oo), B(-a, a)
+    assert l*r == B(-oo, oo)
+    assert r*l == B(-oo, oo)
+    l, r = B(1, oo), B(-3, -2)
+    assert l*r == B(-oo, -2)
+    assert r*l == B(-oo, -2)
+    assert B(1, 2)*0 == 0
+    assert B(1, oo)*0 == B(0, oo)
+    assert B(-oo, 1)*0 == B(-oo, 0)
+    assert B(-oo, oo)*0 == B(-oo, oo)
+
+    assert B(1, 2)*x == Mul(B(1, 2), x, evaluate=False)
+
+    assert B(0, 2)*oo == B(0, oo)
+    assert B(-2, 0)*oo == B(-oo, 0)
+    assert B(0, 2)*(-oo) == B(-oo, 0)
+    assert B(-2, 0)*(-oo) == B(0, oo)
+    assert B(-1, 1)*oo == B(-oo, oo)
+    assert B(-1, 1)*(-oo) == B(-oo, oo)
+    assert B(-oo, oo)*oo == B(-oo, oo)
+
+
+def test_AccumBounds_div():
+    assert B(-1, 3)/B(3, 4) == B(Rational(-1, 3), 1)
+    assert B(-2, 4)/B(-3, 4) == B(-oo, oo)
+    assert B(-3, -2)/B(-4, 0) == B(S.Half, oo)
+
+    # these two tests can have a better answer
+    # after Union of B is improved
+    assert B(-3, -2)/B(-2, 1) == B(-oo, oo)
+    assert B(2, 3)/B(-2, 2) == B(-oo, oo)
+
+    assert B(-3, -2)/B(0, 4) == B(-oo, Rational(-1, 2))
+    assert B(2, 4)/B(-3, 0) == B(-oo, Rational(-2, 3))
+    assert B(2, 4)/B(0, 3) == B(Rational(2, 3), oo)
+
+    assert B(0, 1)/B(0, 1) == B(0, oo)
+    assert B(-1, 0)/B(0, 1) == B(-oo, 0)
+    assert B(-1, 2)/B(-2, 2) == B(-oo, oo)
+
+    assert 1/B(-1, 2) == B(-oo, oo)
+    assert 1/B(0, 2) == B(S.Half, oo)
+    assert (-1)/B(0, 2) == B(-oo, Rational(-1, 2))
+    assert 1/B(-oo, 0) == B(-oo, 0)
+    assert 1/B(-1, 0) == B(-oo, -1)
+    assert (-2)/B(-oo, 0) == B(0, oo)
+    assert 1/B(-oo, -1) == B(-1, 0)
+
+    assert B(1, 2)/a == Mul(B(1, 2), 1/a, evaluate=False)
+
+    assert B(1, 2)/0 == B(1, 2)*zoo
+    assert B(1, oo)/oo == B(0, oo)
+    assert B(1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, -1)/oo == B(-oo, 0)
+    assert B(-oo, -1)/(-oo) == B(0, oo)
+    assert B(-oo, oo)/oo == B(-oo, oo)
+    assert B(-oo, oo)/(-oo) == B(-oo, oo)
+    assert B(-1, oo)/oo == B(0, oo)
+    assert B(-1, oo)/(-oo) == B(-oo, 0)
+    assert B(-oo, 1)/oo == B(-oo, 0)
+    assert B(-oo, 1)/(-oo) == B(0, oo)
+
+
+def test_issue_18795():
+    r = Symbol('r', real=True)
+    a = B(-1,1)
+    c = B(7, oo)
+    b = B(-oo, oo)
+    assert c - tan(r) == B(7-tan(r), oo)
+    assert b + tan(r) == B(-oo, oo)
+    assert (a + r)/a == B(-oo, oo)*B(r - 1, r + 1)
+    assert (b + a)/a == B(-oo, oo)
+
+
+def test_AccumBounds_func():
+    assert (x**2 + 2*x + 1).subs(x, B(-1, 1)) == B(-1, 4)
+    assert exp(B(0, 1)) == B(1, E)
+    assert exp(B(-oo, oo)) == B(0, oo)
+    assert log(B(3, 6)) == B(log(3), log(6))
+
+
+@XFAIL
+def test_AccumBounds_powf():
+    nn = Symbol('nn', nonnegative=True)
+    assert B(1 + nn, 2 + nn)**B(1, 2) == B(1 + nn, (2 + nn)**2)
+    i = Symbol('i', integer=True, negative=True)
+    assert B(1, 2)**i == B(2**i, 1)
+
+
+def test_AccumBounds_pow():
+    assert B(0, 2)**2 == B(0, 4)
+    assert B(-1, 1)**2 == B(0, 1)
+    assert B(1, 2)**2 == B(1, 4)
+    assert B(-1, 2)**3 == B(-1, 8)
+    assert B(-1, 1)**0 == 1
+
+    assert B(1, 2)**Rational(5, 2) == B(1, 4*sqrt(2))
+    assert B(0, 2)**S.Half == B(0, sqrt(2))
+
+    neg = Symbol('neg', negative=True)
+    assert unchanged(Pow, B(neg, 1), S.Half)
+    nn = Symbol('nn', nonnegative=True)
+    assert B(nn, nn + 1)**S.Half == B(sqrt(nn), sqrt(nn + 1))
+    assert B(nn, nn + 1)**nn == B(nn**nn, (nn + 1)**nn)
+    assert unchanged(Pow, B(nn, nn + 1), x)
+    i = Symbol('i', integer=True)
+    assert B(1, 2)**i == B(Min(1, 2**i), Max(1, 2**i))
+    i = Symbol('i', integer=True, nonnegative=True)
+    assert B(1, 2)**i == B(1, 2**i)
+    assert B(0, 1)**i == B(0**i, 1)
+
+    assert B(1, 5)**(-2) == B(Rational(1, 25), 1)
+    assert B(-1, 3)**(-2) == B(0, oo)
+    assert B(0, 2)**(-3) == B(Rational(1, 8), oo)
+    assert B(-2, 0)**(-3) == B(-oo, -Rational(1, 8))
+    assert B(0, 2)**(-2) == B(Rational(1, 4), oo)
+    assert B(-1, 2)**(-3) == B(-oo, oo)
+    assert B(-3, -2)**(-3) == B(Rational(-1, 8), Rational(-1, 27))
+    assert B(-3, -2)**(-2) == B(Rational(1, 9), Rational(1, 4))
+    assert B(0, oo)**S.Half == B(0, oo)
+    assert B(-oo, 0)**(-2) == B(0, oo)
+    assert B(-2, 0)**(-2) == B(Rational(1, 4), oo)
+
+    assert B(Rational(1, 3), S.Half)**oo is S.Zero
+    assert B(0, S.Half)**oo is S.Zero
+    assert B(S.Half, 1)**oo == B(0, oo)
+    assert B(0, 1)**oo == B(0, oo)
+    assert B(2, 3)**oo is oo
+    assert B(1, 2)**oo == B(0, oo)
+    assert B(S.Half, 3)**oo == B(0, oo)
+    assert B(Rational(-1, 3), Rational(-1, 4))**oo is S.Zero
+    assert B(-1, Rational(-1, 2))**oo is S.NaN
+    assert B(-3, -2)**oo is zoo
+    assert B(-2, -1)**oo is S.NaN
+    assert B(-2, Rational(-1, 2))**oo is S.NaN
+    assert B(Rational(-1, 2), S.Half)**oo is S.Zero
+    assert B(Rational(-1, 2), 1)**oo == B(0, oo)
+    assert B(Rational(-2, 3), 2)**oo == B(0, oo)
+    assert B(-1, 1)**oo == B(-oo, oo)
+    assert B(-1, S.Half)**oo == B(-oo, oo)
+    assert B(-1, 2)**oo == B(-oo, oo)
+    assert B(-2, S.Half)**oo == B(-oo, oo)
+
+    assert B(1, 2)**x == Pow(B(1, 2), x, evaluate=False)
+
+    assert B(2, 3)**(-oo) is S.Zero
+    assert B(0, 2)**(-oo) == B(0, oo)
+    assert B(-1, 2)**(-oo) == B(-oo, oo)
+
+    assert (tan(x)**sin(2*x)).subs(x, B(0, pi/2)) == \
+        Pow(B(-oo, oo), B(0, 1))
+
+
+def test_AccumBounds_exponent():
+    # base is 0
+    z = 0**B(a, a + S.Half)
+    assert z.subs(a, 0) == B(0, 1)
+    assert z.subs(a, 1) == 0
+    p = z.subs(a, -1)
+    assert p.is_Pow and p.args == (0, B(-1, -S.Half))
+    # base > 0
+    #   when base is 1 the type of bounds does not matter
+    assert 1**B(a, a + 1) == 1
+    #  otherwise we need to know if 0 is in the bounds
+    assert S.Half**B(-2, 2) == B(S(1)/4, 4)
+    assert 2**B(-2, 2) == B(S(1)/4, 4)
+
+    # +eps may introduce +oo
+    # if there is a negative integer exponent
+    assert B(0, 1)**B(S(1)/2, 1) == B(0, 1)
+    assert B(0, 1)**B(0, 1) == B(0, 1)
+
+    # positive bases have positive bounds
+    assert B(2, 3)**B(-3, -2) == B(S(1)/27, S(1)/4)
+    assert B(2, 3)**B(-3, 2) == B(S(1)/27, 9)
+
+    # bounds generating imaginary parts unevaluated
+    assert unchanged(Pow, B(-1, 1), B(1, 2))
+    assert B(0, S(1)/2)**B(1, oo) == B(0, S(1)/2)
+    assert B(0, 1)**B(1, oo) == B(0, oo)
+    assert B(0, 2)**B(1, oo) == B(0, oo)
+    assert B(0, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 1)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, 2)**B(-oo, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(1, oo) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, -1) == B(0, oo)
+    assert B(S(1)/2, oo)**B(-oo, oo) == B(0, oo)
+    assert B(1, 2)**B(1, oo) == B(0, oo)
+    assert B(1, 2)**B(-oo, -1) == B(0, oo)
+    assert B(1, 2)**B(-oo, oo) == B(0, oo)
+    assert B(1, oo)**B(1, oo) == B(0, oo)
+    assert B(1, oo)**B(-oo, -1) == B(0, oo)
+    assert B(1, oo)**B(-oo, oo) == B(0, oo)
+    assert B(2, oo)**B(1, oo) == B(2, oo)
+    assert B(2, oo)**B(-oo, -1) == B(0, S(1)/2)
+    assert B(2, oo)**B(-oo, oo) == B(0, oo)
+
+
+def test_comparison_AccumBounds():
+    assert (B(1, 3) < 4) == S.true
+    assert (B(1, 3) < -1) == S.false
+    assert (B(1, 3) < 2).rel_op == '<'
+    assert (B(1, 3) <= 2).rel_op == '<='
+
+    assert (B(1, 3) > 4) == S.false
+    assert (B(1, 3) > -1) == S.true
+    assert (B(1, 3) > 2).rel_op == '>'
+    assert (B(1, 3) >= 2).rel_op == '>='
+
+    assert (B(1, 3) < B(4, 6)) == S.true
+    assert (B(1, 3) < B(2, 4)).rel_op == '<'
+    assert (B(1, 3) < B(-2, 0)) == S.false
+
+    assert (B(1, 3) <= B(4, 6)) == S.true
+    assert (B(1, 3) <= B(-2, 0)) == S.false
+
+    assert (B(1, 3) > B(4, 6)) == S.false
+    assert (B(1, 3) > B(-2, 0)) == S.true
+
+    assert (B(1, 3) >= B(4, 6)) == S.false
+    assert (B(1, 3) >= B(-2, 0)) == S.true
+
+    # issue 13499
+    assert (cos(x) > 0).subs(x, oo) == (B(-1, 1) > 0)
+
+    c = Symbol('c')
+    raises(TypeError, lambda: (B(0, 1) < c))
+    raises(TypeError, lambda: (B(0, 1) <= c))
+    raises(TypeError, lambda: (B(0, 1) > c))
+    raises(TypeError, lambda: (B(0, 1) >= c))
+
+
+def test_contains_AccumBounds():
+    assert (1 in B(1, 2)) == S.true
+    raises(TypeError, lambda: a in B(1, 2))
+    assert 0 in B(-1, 0)
+    raises(TypeError, lambda:
+        (cos(1)**2 + sin(1)**2 - 1) in B(-1, 0))
+    assert (-oo in B(1, oo)) == S.true
+    assert (oo in B(-oo, 0)) == S.true
+
+    # issue 13159
+    assert Mul(0, B(-1, 1)) == Mul(B(-1, 1), 0) == 0
+    import itertools
+    for perm in itertools.permutations([0, B(-1, 1), x]):
+        assert Mul(*perm) == 0
+
+
+def test_intersection_AccumBounds():
+    assert B(0, 3).intersection(B(1, 2)) == B(1, 2)
+    assert B(0, 3).intersection(B(1, 4)) == B(1, 3)
+    assert B(0, 3).intersection(B(-1, 2)) == B(0, 2)
+    assert B(0, 3).intersection(B(-1, 4)) == B(0, 3)
+    assert B(0, 1).intersection(B(2, 3)) == S.EmptySet
+    raises(TypeError, lambda: B(0, 3).intersection(1))
+
+
+def test_union_AccumBounds():
+    assert B(0, 3).union(B(1, 2)) == B(0, 3)
+    assert B(0, 3).union(B(1, 4)) == B(0, 4)
+    assert B(0, 3).union(B(-1, 2)) == B(-1, 3)
+    assert B(0, 3).union(B(-1, 4)) == B(-1, 4)
+    raises(TypeError, lambda: B(0, 3).union(1))
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_euler.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_euler.py
new file mode 100644
index 0000000000000000000000000000000000000000..56371c8c787d9459d1390e18c306fddde94d2745
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_euler.py
@@ -0,0 +1,74 @@
+from sympy.core.function import (Derivative as D, Function)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.testing.pytest import raises
+from sympy.calculus.euler import euler_equations as euler
+
+
+def test_euler_interface():
+    x = Function('x')
+    y = Symbol('y')
+    t = Symbol('t')
+    raises(TypeError, lambda: euler())
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [x(t), y]))
+    raises(ValueError, lambda: euler(D(x(t), t)*x(y), [x(t), x(y)]))
+    raises(TypeError, lambda: euler(D(x(t), t)**2, x(0)))
+    raises(TypeError, lambda: euler(D(x(t), t)*y(t), [t]))
+    assert euler(D(x(t), t)**2/2, {x(t)}) == [Eq(-D(x(t), t, t), 0)]
+    assert euler(D(x(t), t)**2/2, x(t), {t}) == [Eq(-D(x(t), t, t), 0)]
+
+
+def test_euler_pendulum():
+    x = Function('x')
+    t = Symbol('t')
+    L = D(x(t), t)**2/2 + cos(x(t))
+    assert euler(L, x(t), t) == [Eq(-sin(x(t)) - D(x(t), t, t), 0)]
+
+
+def test_euler_henonheiles():
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = sum(D(z(t), t)**2/2 - z(t)**2/2 for z in [x, y])
+    L += -x(t)**2*y(t) + y(t)**3/3
+    assert euler(L, [x(t), y(t)], t) == [Eq(-2*x(t)*y(t) - x(t) -
+                                            D(x(t), t, t), 0),
+                                         Eq(-x(t)**2 + y(t)**2 -
+                                            y(t) - D(y(t), t, t), 0)]
+
+
+def test_euler_sineg():
+    psi = Function('psi')
+    t = Symbol('t')
+    x = Symbol('x')
+    L = D(psi(t, x), t)**2/2 - D(psi(t, x), x)**2/2 + cos(psi(t, x))
+    assert euler(L, psi(t, x), [t, x]) == [Eq(-sin(psi(t, x)) -
+                                              D(psi(t, x), t, t) +
+                                              D(psi(t, x), x, x), 0)]
+
+
+def test_euler_high_order():
+    # an example from hep-th/0309038
+    m = Symbol('m')
+    k = Symbol('k')
+    x = Function('x')
+    y = Function('y')
+    t = Symbol('t')
+    L = (m*D(x(t), t)**2/2 + m*D(y(t), t)**2/2 -
+         k*D(x(t), t)*D(y(t), t, t) + k*D(y(t), t)*D(x(t), t, t))
+    assert euler(L, [x(t), y(t)]) == [Eq(2*k*D(y(t), t, t, t) -
+                                         m*D(x(t), t, t), 0),
+                                      Eq(-2*k*D(x(t), t, t, t) -
+                                         m*D(y(t), t, t), 0)]
+
+    w = Symbol('w')
+    L = D(x(t, w), t, w)**2/2
+    assert euler(L) == [Eq(D(x(t, w), t, t, w, w), 0)]
+
+def test_issue_18653():
+    x, y, z = symbols("x y z")
+    f, g, h = symbols("f g h", cls=Function, args=(x, y))
+    f, g, h = f(), g(), h()
+    expr2 = f.diff(x)*h.diff(z)
+    assert euler(expr2, (f,), (x, y)) == []
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_finite_diff.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_finite_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9ecfbdd61b15f516c54bd6d716ba1f264ee2ca0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_finite_diff.py
@@ -0,0 +1,164 @@
+from itertools import product
+
+from sympy.core.function import (Function, diff)
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+from sympy.calculus.finite_diff import (
+    apply_finite_diff, differentiate_finite, finite_diff_weights,
+    _as_finite_diff
+)
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+def test_apply_finite_diff():
+    x, h = symbols('x h')
+    f = Function('f')
+    assert (apply_finite_diff(1, [x-h, x+h], [f(x-h), f(x+h)], x) -
+            (f(x+h)-f(x-h))/(2*h)).simplify() == 0
+
+    assert (apply_finite_diff(1, [5, 6, 7], [f(5), f(6), f(7)], 5) -
+            (Rational(-3, 2)*f(5) + 2*f(6) - S.Half*f(7))).simplify() == 0
+    raises(ValueError, lambda: apply_finite_diff(1, [x, h], [f(x)]))
+
+
+def test_finite_diff_weights():
+
+    d = finite_diff_weights(1, [5, 6, 7], 5)
+    assert d[1][2] == [Rational(-3, 2), 2, Rational(-1, 2)]
+
+    # Table 1, p. 702 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [0, 1, -1, 2, -2, 3, -3, 4, -4]
+
+    # d holds all coefficients
+    d = finite_diff_weights(4, xl, S.Zero)
+
+    # Zeroeth derivative
+    for i in range(5):
+        assert d[0][i] == [S.One] + [S.Zero]*8
+
+    # First derivative
+    assert d[1][0] == [S.Zero]*9
+    assert d[1][2] == [S.Zero, S.Half, Rational(-1, 2)] + [S.Zero]*6
+    assert d[1][4] == [S.Zero, Rational(2, 3), Rational(-2, 3), Rational(-1, 12), Rational(1, 12)] + [S.Zero]*4
+    assert d[1][6] == [S.Zero, Rational(3, 4), Rational(-3, 4), Rational(-3, 20), Rational(3, 20),
+                       Rational(1, 60), Rational(-1, 60)] + [S.Zero]*2
+    assert d[1][8] == [S.Zero, Rational(4, 5), Rational(-4, 5), Rational(-1, 5), Rational(1, 5),
+                       Rational(4, 105), Rational(-4, 105), Rational(-1, 280), Rational(1, 280)]
+
+    # Second derivative
+    for i in range(2):
+        assert d[2][i] == [S.Zero]*9
+    assert d[2][2] == [-S(2), S.One, S.One] + [S.Zero]*6
+    assert d[2][4] == [Rational(-5, 2), Rational(4, 3), Rational(4, 3), Rational(-1, 12), Rational(-1, 12)] + [S.Zero]*4
+    assert d[2][6] == [Rational(-49, 18), Rational(3, 2), Rational(3, 2), Rational(-3, 20), Rational(-3, 20),
+                       Rational(1, 90), Rational(1, 90)] + [S.Zero]*2
+    assert d[2][8] == [Rational(-205, 72), Rational(8, 5), Rational(8, 5), Rational(-1, 5), Rational(-1, 5),
+                       Rational(8, 315), Rational(8, 315), Rational(-1, 560), Rational(-1, 560)]
+
+    # Third derivative
+    for i in range(3):
+        assert d[3][i] == [S.Zero]*9
+    assert d[3][4] == [S.Zero, -S.One, S.One, S.Half, Rational(-1, 2)] + [S.Zero]*4
+    assert d[3][6] == [S.Zero, Rational(-13, 8), Rational(13, 8), S.One, -S.One,
+                       Rational(-1, 8), Rational(1, 8)] + [S.Zero]*2
+    assert d[3][8] == [S.Zero, Rational(-61, 30), Rational(61, 30), Rational(169, 120), Rational(-169, 120),
+                       Rational(-3, 10), Rational(3, 10), Rational(7, 240), Rational(-7, 240)]
+
+    # Fourth derivative
+    for i in range(4):
+        assert d[4][i] == [S.Zero]*9
+    assert d[4][4] == [S(6), -S(4), -S(4), S.One, S.One] + [S.Zero]*4
+    assert d[4][6] == [Rational(28, 3), Rational(-13, 2), Rational(-13, 2), S(2), S(2),
+                       Rational(-1, 6), Rational(-1, 6)] + [S.Zero]*2
+    assert d[4][8] == [Rational(91, 8), Rational(-122, 15), Rational(-122, 15), Rational(169, 60), Rational(169, 60),
+                       Rational(-2, 5), Rational(-2, 5), Rational(7, 240), Rational(7, 240)]
+
+    # Table 2, p. 703 in doi:10.1090/S0025-5718-1988-0935077-0
+    # --------------------------------------------------------
+    xl = [[j/S(2) for j in list(range(-i*2+1, 0, 2))+list(range(1, i*2+1, 2))]
+          for i in range(1, 5)]
+
+    # d holds all coefficients
+    d = [finite_diff_weights({0: 1, 1: 2, 2: 4, 3: 4}[i], xl[i], 0) for
+         i in range(4)]
+
+    # Zeroth derivative
+    assert d[0][0][1] == [S.Half, S.Half]
+    assert d[1][0][3] == [Rational(-1, 16), Rational(9, 16), Rational(9, 16), Rational(-1, 16)]
+    assert d[2][0][5] == [Rational(3, 256), Rational(-25, 256), Rational(75, 128), Rational(75, 128),
+                          Rational(-25, 256), Rational(3, 256)]
+    assert d[3][0][7] == [Rational(-5, 2048), Rational(49, 2048), Rational(-245, 2048), Rational(1225, 2048),
+                          Rational(1225, 2048), Rational(-245, 2048), Rational(49, 2048), Rational(-5, 2048)]
+
+    # First derivative
+    assert d[0][1][1] == [-S.One, S.One]
+    assert d[1][1][3] == [Rational(1, 24), Rational(-9, 8), Rational(9, 8), Rational(-1, 24)]
+    assert d[2][1][5] == [Rational(-3, 640), Rational(25, 384), Rational(-75, 64),
+                          Rational(75, 64), Rational(-25, 384), Rational(3, 640)]
+    assert d[3][1][7] == [Rational(5, 7168), Rational(-49, 5120),
+                          Rational(245, 3072), Rational(-1225, 1024),
+                          Rational(1225, 1024), Rational(-245, 3072),
+                          Rational(49, 5120), Rational(-5, 7168)]
+
+    # Reasonably the rest of the table is also correct... (testing of that
+    # deemed excessive at the moment)
+    raises(ValueError, lambda: finite_diff_weights(-1, [1, 2]))
+    raises(ValueError, lambda: finite_diff_weights(1.2, [1, 2]))
+    x = symbols('x')
+    raises(ValueError, lambda: finite_diff_weights(x, [1, 2]))
+
+
+def test_as_finite_diff():
+    x = symbols('x')
+    f = Function('f')
+    dx = Function('dx')
+
+    _as_finite_diff(f(x).diff(x), [x-2, x-1, x, x+1, x+2])
+
+    # Use of undefined functions in ``points``
+    df_true = -f(x+dx(x)/2-dx(x+dx(x)/2)/2) / dx(x+dx(x)/2) \
+              + f(x+dx(x)/2+dx(x+dx(x)/2)/2) / dx(x+dx(x)/2)
+    df_test = diff(f(x), x).as_finite_difference(points=dx(x), x0=x+dx(x)/2)
+    assert (df_test - df_true).simplify() == 0
+
+
+def test_differentiate_finite():
+    x, y, h = symbols('x y h')
+    f = Function('f')
+    with warns_deprecated_sympy():
+        res0 = differentiate_finite(f(x, y) + exp(42), x, y, evaluate=True)
+    xm, xp, ym, yp = [v + sign*S.Half for v, sign in product([x, y], [-1, 1])]
+    ref0 = f(xm, ym) + f(xp, yp) - f(xm, yp) - f(xp, ym)
+    assert (res0 - ref0).simplify() == 0
+
+    g = Function('g')
+    with warns_deprecated_sympy():
+        res1 = differentiate_finite(f(x)*g(x) + 42, x, evaluate=True)
+    ref1 = (-f(x - S.Half) + f(x + S.Half))*g(x) + \
+           (-g(x - S.Half) + g(x + S.Half))*f(x)
+    assert (res1 - ref1).simplify() == 0
+
+    res2 = differentiate_finite(f(x) + x**3 + 42, x, points=[x-1, x+1])
+    ref2 = (f(x + 1) + (x + 1)**3 - f(x - 1) - (x - 1)**3)/2
+    assert (res2 - ref2).simplify() == 0
+    raises(TypeError, lambda: differentiate_finite(f(x)*g(x), x,
+                                                   pints=[x-1, x+1]))
+
+    res3 = differentiate_finite(f(x)*g(x).diff(x), x)
+    ref3 = (-g(x) + g(x + 1))*f(x + S.Half) - (g(x) - g(x - 1))*f(x - S.Half)
+    assert res3 == ref3
+
+    res4 = differentiate_finite(f(x)*g(x).diff(x).diff(x), x)
+    ref4 = -((g(x - Rational(3, 2)) - 2*g(x - S.Half) + g(x + S.Half))*f(x - S.Half)) \
+           + (g(x - S.Half) - 2*g(x + S.Half) + g(x + Rational(3, 2)))*f(x + S.Half)
+    assert res4 == ref4
+
+    res5_expr = f(x).diff(x)*g(x).diff(x)
+    res5 = differentiate_finite(res5_expr, points=[x-h, x, x+h])
+    ref5 = (-2*f(x)/h + f(-h + x)/(2*h) + 3*f(h + x)/(2*h))*(-2*g(x)/h + g(-h + x)/(2*h) \
+           + 3*g(h + x)/(2*h))/(2*h) - (2*f(x)/h - 3*f(-h + x)/(2*h) - \
+           f(h + x)/(2*h))*(2*g(x)/h - 3*g(-h + x)/(2*h) - g(h + x)/(2*h))/(2*h)
+    assert res5 == ref5
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_singularities.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_singularities.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a042332326658021ce12a38f4e058f55903869
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_singularities.py
@@ -0,0 +1,122 @@
+from sympy.core.numbers import (I, Rational, pi, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.function import Lambda
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import sec, csc
+from sympy.functions.elementary.hyperbolic import (coth, sech,
+                                                   atanh, asech, acoth, acsch)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.calculus.singularities import (
+    singularities,
+    is_increasing,
+    is_strictly_increasing,
+    is_decreasing,
+    is_strictly_decreasing,
+    is_monotonic
+)
+from sympy.sets import Interval, FiniteSet, Union, ImageSet
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+
+def test_singularities():
+    x = Symbol('x')
+    assert singularities(x**2, x) == S.EmptySet
+    assert singularities(x/(x**2 + 3*x + 2), x) == FiniteSet(-2, -1)
+    assert singularities(1/(x**2 + 1), x) == FiniteSet(I, -I)
+    assert singularities(x/(x**3 + 1), x) == \
+        FiniteSet(-1, (1 - sqrt(3) * I) / 2, (1 + sqrt(3) * I) / 2)
+    assert singularities(1/(y**2 + 2*I*y + 1), y) == \
+        FiniteSet(-I + sqrt(2)*I, -I - sqrt(2)*I)
+    _n = Dummy('n')
+    assert singularities(sech(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi/2), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi + 3*I*pi/2), S.Integers)))
+    assert singularities(coth(x), x).dummy_eq(Union(
+        ImageSet(Lambda(_n, 2*_n*I*pi + I*pi), S.Integers),
+        ImageSet(Lambda(_n, 2*_n*I*pi), S.Integers)))
+    assert singularities(atanh(x), x) == FiniteSet(-1, 1)
+    assert singularities(acoth(x), x) == FiniteSet(-1, 1)
+    assert singularities(asech(x), x) == FiniteSet(0)
+    assert singularities(acsch(x), x) == FiniteSet(0)
+
+    x = Symbol('x', real=True)
+    assert singularities(1/(x**2 + 1), x) == S.EmptySet
+    assert singularities(exp(1/x), x, S.Reals) == FiniteSet(0)
+    assert singularities(exp(1/x), x, Interval(1, 2)) == S.EmptySet
+    assert singularities(log((x - 2)**2), x, Interval(1, 3)) == FiniteSet(2)
+    raises(NotImplementedError, lambda: singularities(x**-oo, x))
+    assert singularities(sec(x), x, Interval(0, 3*pi)) == FiniteSet(
+        pi/2, 3*pi/2, 5*pi/2)
+    assert singularities(csc(x), x, Interval(0, 3*pi)) == FiniteSet(
+        0, pi, 2*pi, 3*pi)
+
+
+def test_is_increasing():
+    """Test whether is_increasing returns correct value."""
+    a = Symbol('a', negative=True)
+
+    assert is_increasing(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert is_increasing(-x**2, Interval(-oo, 0))
+    assert not is_increasing(-x**2, Interval(0, oo))
+    assert not is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3))
+    assert is_increasing(x**2 + y, Interval(1, oo), x)
+    assert is_increasing(-x**2*a, Interval(1, oo), x)
+    assert is_increasing(1)
+
+    assert is_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval(-2, 3)) is False
+
+
+def test_is_strictly_increasing():
+    """Test whether is_strictly_increasing returns correct value."""
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Ropen(-oo, -2))
+    assert is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.Lopen(3, oo))
+    assert not is_strictly_increasing(
+        4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3))
+    assert not is_strictly_increasing(-x**2, Interval(0, oo))
+    assert not is_strictly_decreasing(1)
+
+    assert is_strictly_increasing(4*x**3 - 6*x**2 - 72*x + 30, Interval.open(-2, 3)) is False
+
+
+def test_is_decreasing():
+    """Test whether is_decreasing returns correct value."""
+    b = Symbol('b', positive=True)
+
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_decreasing(1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_decreasing(-x**2*b, Interval(-oo, 0), x)
+
+
+def test_is_strictly_decreasing():
+    """Test whether is_strictly_decreasing returns correct value."""
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert not is_strictly_decreasing(
+        1/(x**2 - 3*x), Interval.Ropen(-oo, Rational(3, 2)))
+    assert not is_strictly_decreasing(-x**2, Interval(-oo, 0))
+    assert not is_strictly_decreasing(1)
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_strictly_decreasing(1/(x**2 - 3*x), Interval.open(1.5, 3))
+
+
+def test_is_monotonic():
+    """Test whether is_monotonic returns correct value."""
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(Rational(3,2), 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.open(1.5, 3))
+    assert is_monotonic(1/(x**2 - 3*x), Interval.Lopen(3, oo))
+    assert is_monotonic(x**3 - 3*x**2 + 4*x, S.Reals)
+    assert not is_monotonic(-x**2, S.Reals)
+    assert is_monotonic(x**2 + y + 1, Interval(1, 2), x)
+    raises(NotImplementedError, lambda: is_monotonic(x**2 + y + 1))
+
+
+def test_issue_23401():
+    x = Symbol('x')
+    expr = (x + 1)/(-1.0e-3*x**2 + 0.1*x + 0.1)
+    assert is_increasing(expr, Interval(1,2), x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_util.py b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..c18b7a79fd54fdb2638cc746d43ab26753fc72a9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/tests/test_util.py
@@ -0,0 +1,392 @@
+from sympy.core.function import Lambda
+from sympy.core.numbers import (E, I, Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.complexes import (Abs, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    cos, cot, csc, sec, sin, tan, asin, acos, atan, acot, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.error_functions import expint
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.simplify.simplify import simplify
+from sympy.calculus.util import (function_range, continuous_domain, not_empty_in,
+                                 periodicity, lcim, is_convex,
+                                 stationary_points, minimum, maximum)
+from sympy.sets.sets import (Interval, FiniteSet, Complement, Union)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.testing.pytest import XFAIL, raises, _both_exp_pow, slow
+from sympy.abc import x, y
+
+a = Symbol('a', real=True)
+
+def test_function_range():
+    assert function_range(sin(x), x, Interval(-pi/2, pi/2)
+        ) == Interval(-1, 1)
+    assert function_range(sin(x), x, Interval(0, pi)
+        ) == Interval(0, 1)
+    assert function_range(tan(x), x, Interval(0, pi)
+        ) == Interval(-oo, oo)
+    assert function_range(tan(x), x, Interval(pi/2, pi)
+        ) == Interval(-oo, 0)
+    assert function_range((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) == Union(Interval(-oo, Rational(2, 7)), Interval(Rational(8, 3), oo))
+    assert function_range(1/(x**2), x, Interval(-1, 1)
+        ) == Interval(1, oo)
+    assert function_range(exp(x), x, Interval(-1, 1)
+        ) == Interval(exp(-1), exp(1))
+    assert function_range(log(x) - x, x, S.Reals
+        ) == Interval(-oo, -1)
+    assert function_range(sqrt(3*x - 1), x, Interval(0, 2)
+        ) == Interval(0, sqrt(5))
+    assert function_range(x*(x - 1) - (x**2 - x), x, S.Reals
+        ) == FiniteSet(0)
+    assert function_range(x*(x - 1) - (x**2 - x) + y, x, S.Reals
+        ) == FiniteSet(y)
+    assert function_range(sin(x), x, Union(Interval(-5, -3), FiniteSet(4))
+        ) == Union(Interval(-sin(3), 1), FiniteSet(sin(4)))
+    assert function_range(cos(x), x, Interval(-oo, -4)
+        ) == Interval(-1, 1)
+    assert function_range(cos(x), x, S.EmptySet) == S.EmptySet
+    assert function_range(x/sqrt(x**2+1), x, S.Reals) == Interval.open(-1,1)
+    raises(NotImplementedError, lambda : function_range(
+        exp(x)*(sin(x) - cos(x))/2 - x, x, S.Reals))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x) + x, x, S.Reals)) # issue 13273
+    raises(NotImplementedError, lambda : function_range(
+        log(x), x, S.Integers))
+    raises(NotImplementedError, lambda : function_range(
+        sin(x)/2, x, S.Naturals))
+
+
+@slow
+def test_function_range1():
+    assert function_range(tan(x)**2 + tan(3*x)**2 + 1, x, S.Reals) == Interval(1,oo)
+
+
+def test_continuous_domain():
+    assert continuous_domain(sin(x), x, Interval(0, 2*pi)) == Interval(0, 2*pi)
+    assert continuous_domain(tan(x), x, Interval(0, 2*pi)) == \
+        Union(Interval(0, pi/2, False, True), Interval(pi/2, pi*Rational(3, 2), True, True),
+              Interval(pi*Rational(3, 2), 2*pi, True, False))
+    assert continuous_domain(cot(x), x, Interval(0, 2*pi)) == Union(
+        Interval.open(0, pi), Interval.open(pi, 2*pi))
+    assert continuous_domain((x - 1)/((x - 1)**2), x, S.Reals) == \
+        Union(Interval(-oo, 1, True, True), Interval(1, oo, True, True))
+    assert continuous_domain(log(x) + log(4*x - 1), x, S.Reals) == \
+        Interval(Rational(1, 4), oo, True, True)
+    assert continuous_domain(1/sqrt(x - 3), x, S.Reals) == Interval(3, oo, True, True)
+    assert continuous_domain(1/x - 2, x, S.Reals) == \
+        Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(1/(x**2 - 4) + 2, x, S.Reals) == \
+        Union(Interval.open(-oo, -2), Interval.open(-2, 2), Interval.open(2, oo))
+    assert continuous_domain((x+1)**pi, x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain((x+1)**(pi/2), x, S.Reals) == Interval(-1, oo)
+    assert continuous_domain(x**x, x, S.Reals) == Interval(0, oo)
+    assert continuous_domain((x+1)**log(x**2), x, S.Reals) == Union(
+        Interval.Ropen(-1, 0), Interval.open(0, oo))
+    domain = continuous_domain(log(tan(x)**2 + 1), x, S.Reals)
+    assert not domain.contains(3*pi/2)
+    assert domain.contains(5)
+    d = Symbol('d', even=True, zero=False)
+    assert continuous_domain(x**(1/d), x, S.Reals) == Interval(0, oo)
+    n = Dummy('n')
+    assert continuous_domain(1/sin(x), x, S.Reals).dummy_eq(Complement(
+        S.Reals, Union(ImageSet(Lambda(n, 2*n*pi + pi), S.Integers),
+                       ImageSet(Lambda(n, 2*n*pi), S.Integers))))
+    assert continuous_domain(sin(x) + cos(x), x, S.Reals) == S.Reals
+    assert continuous_domain(asin(x), x, S.Reals) == Interval(-1, 1) # issue #21786
+    assert continuous_domain(1/acos(log(x)), x, S.Reals) == Interval.Ropen(exp(-1), E)
+    assert continuous_domain(sinh(x)+cosh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(tanh(x)+sech(x), x, S.Reals) == S.Reals
+    assert continuous_domain(atan(x)+asinh(x), x, S.Reals) == S.Reals
+    assert continuous_domain(acosh(x), x, S.Reals) == Interval(1, oo)
+    assert continuous_domain(atanh(x), x, S.Reals) == Interval.open(-1, 1)
+    assert continuous_domain(atanh(x)+acosh(x), x, S.Reals) == S.EmptySet
+    assert continuous_domain(asech(x), x, S.Reals) == Interval.Lopen(0, 1)
+    assert continuous_domain(acoth(x), x, S.Reals) == Union(
+        Interval.open(-oo, -1), Interval.open(1, oo))
+    assert continuous_domain(asec(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    assert continuous_domain(acsc(x), x, S.Reals) == Union(
+        Interval(-oo, -1), Interval(1, oo))
+    for f in (coth, acsch, csch):
+        assert continuous_domain(f(x), x, S.Reals) == Union(
+            Interval.open(-oo, 0), Interval.open(0, oo))
+    assert continuous_domain(acot(x), x, S.Reals).contains(0) == False
+    assert continuous_domain(1/(exp(x) - x), x, S.Reals) == Complement(
+        S.Reals, ConditionSet(x, Eq(-x + exp(x), 0), S.Reals))
+    assert continuous_domain(frac(x**2), x, Interval(-2,-1)) == Union(
+        Interval.open(-2, -sqrt(3)), Interval.open(-sqrt(2), -1),
+        Interval.open(-sqrt(3), -sqrt(2)))
+    assert continuous_domain(frac(x), x, S.Reals) == Complement(
+        S.Reals, S.Integers)
+    raises(NotImplementedError, lambda : continuous_domain(
+        1/(x**2+1), x, S.Complexes))
+    raises(NotImplementedError, lambda : continuous_domain(
+        gamma(x), x, Interval(-5,0)))
+    assert continuous_domain(x + gamma(pi), x, S.Reals) == S.Reals
+
+
+@XFAIL
+def test_continuous_domain_acot():
+    acot_cont = Piecewise((pi+acot(x), x<0), (acot(x), True))
+    assert continuous_domain(acot_cont, x, S.Reals) == S.Reals
+
+@XFAIL
+def test_continuous_domain_gamma():
+    assert continuous_domain(gamma(x), x, S.Reals).contains(-1) == False
+
+@XFAIL
+def test_continuous_domain_neg_power():
+    assert continuous_domain((x-2)**(1-x), x, S.Reals) == Interval.open(2, oo)
+
+
+def test_not_empty_in():
+    assert not_empty_in(FiniteSet(x, 2*x).intersect(Interval(1, 2, True, False)), x) == \
+        Interval(S.Half, 2, True, False)
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x) == \
+        Union(Interval(-sqrt(2), -1), Interval(1, 2))
+    assert not_empty_in(FiniteSet(x**2 + x, x).intersect(Interval(2, 4)), x) == \
+        Union(Interval(-sqrt(17)/2 - S.Half, -2),
+              Interval(1, Rational(-1, 2) + sqrt(17)/2), Interval(2, 4))
+    assert not_empty_in(FiniteSet(x/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(a/(a - 1)).intersect(S.Reals), a) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet((x**2 - 3*x + 2)/(x - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(1))
+    assert not_empty_in(FiniteSet(3, 4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(-oo, oo)
+    assert not_empty_in(FiniteSet(4, x/(x - 1)).intersect(Interval(2, 3)), x) == \
+        Interval(S(3)/2, 2)
+    assert not_empty_in(FiniteSet(x/(x**2 - 1)).intersect(S.Reals), x) == \
+        Complement(S.Reals, FiniteSet(-1, 1))
+    assert not_empty_in(FiniteSet(x, x**2).intersect(Union(Interval(1, 3, True, True),
+                                                           Interval(4, 5))), x) == \
+        Union(Interval(-sqrt(5), -2), Interval(-sqrt(3), -1, True, True),
+              Interval(1, 3, True, True), Interval(4, 5))
+    assert not_empty_in(FiniteSet(1).intersect(Interval(3, 4)), x) == S.EmptySet
+    assert not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x) == \
+        Union(Interval(-2, -1, True, False), Interval(2, oo))
+    raises(ValueError, lambda: not_empty_in(x))
+    raises(ValueError, lambda: not_empty_in(Interval(0, 1), x))
+    raises(NotImplementedError,
+           lambda: not_empty_in(FiniteSet(x).intersect(S.Reals), x, a))
+
+
+@_both_exp_pow
+def test_periodicity():
+    assert periodicity(sin(2*x), x) == pi
+    assert periodicity((-2)*tan(4*x), x) == pi/4
+    assert periodicity(sin(x)**2, x) == 2*pi
+    assert periodicity(3**tan(3*x), x) == pi/3
+    assert periodicity(tan(x)*cos(x), x) == 2*pi
+    assert periodicity(sin(x)**(tan(x)), x) == 2*pi
+    assert periodicity(tan(x)*sec(x), x) == 2*pi
+    assert periodicity(sin(2*x)*cos(2*x) - y, x) == pi/2
+    assert periodicity(tan(x) + cot(x), x) == pi
+    assert periodicity(sin(x) - cos(2*x), x) == 2*pi
+    assert periodicity(sin(x) - 1, x) == 2*pi
+    assert periodicity(sin(4*x) + sin(x)*cos(x), x) == pi
+    assert periodicity(exp(sin(x)), x) == 2*pi
+    assert periodicity(log(cot(2*x)) - sin(cos(2*x)), x) == pi
+    assert periodicity(sin(2*x)*exp(tan(x) - csc(2*x)), x) == pi
+    assert periodicity(cos(sec(x) - csc(2*x)), x) == 2*pi
+    assert periodicity(tan(sin(2*x)), x) == pi
+    assert periodicity(2*tan(x)**2, x) == pi
+    assert periodicity(sin(x%4), x) == 4
+    assert periodicity(sin(x)%4, x) == 2*pi
+    assert periodicity(tan((3*x-2)%4), x) == Rational(4, 3)
+    assert periodicity((sqrt(2)*(x+1)+x) % 3, x) == 3 / (sqrt(2)+1)
+    assert periodicity((x**2+1) % x, x) is None
+    assert periodicity(sin(re(x)), x) == 2*pi
+    assert periodicity(sin(x)**2 + cos(x)**2, x) is S.Zero
+    assert periodicity(tan(x), y) is S.Zero
+    assert periodicity(sin(x) + I*cos(x), x) == 2*pi
+    assert periodicity(x - sin(2*y), y) == pi
+
+    assert periodicity(exp(x), x) is None
+    assert periodicity(exp(I*x), x) == 2*pi
+    assert periodicity(exp(I*a), a) == 2*pi
+    assert periodicity(exp(a), a) is None
+    assert periodicity(exp(log(sin(a) + I*cos(2*a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(log(sin(2*a) + I*cos(a)), evaluate=False), a) == 2*pi
+    assert periodicity(exp(sin(a)), a) == 2*pi
+    assert periodicity(exp(2*I*a), a) == pi
+    assert periodicity(exp(a + I*sin(a)), a) is None
+    assert periodicity(exp(cos(a/2) + sin(a)), a) == 4*pi
+    assert periodicity(log(x), x) is None
+    assert periodicity(exp(x)**sin(x), x) is None
+    assert periodicity(sin(x)**y, y) is None
+
+    assert periodicity(Abs(sin(Abs(sin(x)))), x) == pi
+    assert all(periodicity(Abs(f(x)), x) == pi for f in (
+        cos, sin, sec, csc, tan, cot))
+    assert periodicity(Abs(sin(tan(x))), x) == pi
+    assert periodicity(Abs(sin(sin(x) + tan(x))), x) == 2*pi
+    assert periodicity(sin(x) > S.Half, x) == 2*pi
+
+    assert periodicity(x > 2, x) is None
+    assert periodicity(x**3 - x**2 + 1, x) is None
+    assert periodicity(Abs(x), x) is None
+    assert periodicity(Abs(x**2 - 1), x) is None
+
+    assert periodicity((x**2 + 4)%2, x) is None
+    assert periodicity((E**x)%3, x) is None
+
+    assert periodicity(sin(expint(1, x))/expint(1, x), x) is None
+    # returning `None` for any Piecewise
+    p = Piecewise((0, x < -1), (x**2, x <= 1), (log(x), True))
+    assert periodicity(p, x) is None
+
+    m = MatrixSymbol('m', 3, 3)
+    raises(NotImplementedError, lambda: periodicity(sin(m), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m))
+    raises(NotImplementedError, lambda: periodicity(sin(m), m[0, 0]))
+    raises(NotImplementedError, lambda: periodicity(sin(m[0, 0]), m[0, 0]))
+
+
+def test_periodicity_check():
+    assert periodicity(tan(x), x, check=True) == pi
+    assert periodicity(sin(x) + cos(x), x, check=True) == 2*pi
+    assert periodicity(sec(x), x) == 2*pi
+    assert periodicity(sin(x*y), x) == 2*pi/abs(y)
+    assert periodicity(Abs(sec(sec(x))), x) == pi
+
+
+def test_lcim():
+    assert lcim([S.Half, S(2), S(3)]) == 6
+    assert lcim([pi/2, pi/4, pi]) == pi
+    assert lcim([2*pi, pi/2]) == 2*pi
+    assert lcim([S.One, 2*pi]) is None
+    assert lcim([S(2) + 2*E, E/3 + Rational(1, 3), S.One + E]) == S(2) + 2*E
+
+
+def test_is_convex():
+    assert is_convex(1/x, x, domain=Interval.open(0, oo)) == True
+    assert is_convex(1/x, x, domain=Interval(-oo, 0)) == False
+    assert is_convex(x**2, x, domain=Interval(0, oo)) == True
+    assert is_convex(1/x**3, x, domain=Interval.Lopen(0, oo)) == True
+    assert is_convex(-1/x**3, x, domain=Interval.Ropen(-oo, 0)) == True
+    assert is_convex(log(x) ,x) == False
+    assert is_convex(x**2+y**2, x, y) == True
+    assert is_convex(cos(x) + cos(y), x) == False
+    assert is_convex(8*x**2 - 2*y**2, x, y) == False
+
+
+def test_stationary_points():
+    assert stationary_points(sin(x), x, Interval(-pi/2, pi/2)
+        ) == {-pi/2, pi/2}
+    assert  stationary_points(sin(x), x, Interval.Ropen(0, pi/4)
+        ) is S.EmptySet
+    assert stationary_points(tan(x), x,
+        ) is S.EmptySet
+    assert stationary_points(sin(x)*cos(x), x, Interval(0, pi)
+        ) == {pi/4, pi*Rational(3, 4)}
+    assert stationary_points(sec(x), x, Interval(0, pi)
+        ) == {0, pi}
+    assert stationary_points((x+3)*(x-2), x
+        ) == FiniteSet(Rational(-1, 2))
+    assert stationary_points((x + 3)/(x - 2), x, Interval(-5, 5)
+        ) is S.EmptySet
+    assert stationary_points((x**2+3)/(x-2), x
+        ) == {2 - sqrt(7), 2 + sqrt(7)}
+    assert stationary_points((x**2+3)/(x-2), x, Interval(0, 5)
+        ) == {2 + sqrt(7)}
+    assert stationary_points(x**4 + x**3 - 5*x**2, x, S.Reals
+        ) == FiniteSet(-2, 0, Rational(5, 4))
+    assert stationary_points(exp(x), x
+        ) is S.EmptySet
+    assert stationary_points(log(x) - x, x, S.Reals
+        ) == {1}
+    assert stationary_points(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) == {0, -pi, pi}
+    assert stationary_points(y, x, S.Reals
+        ) == S.Reals
+    assert stationary_points(y, x, S.EmptySet) == S.EmptySet
+
+
+def test_maximum():
+    assert maximum(sin(x), x) is S.One
+    assert maximum(sin(x), x, Interval(0, 1)) == sin(1)
+    assert maximum(tan(x), x) is oo
+    assert maximum(tan(x), x, Interval(-pi/4, pi/4)) is S.One
+    assert maximum(sin(x)*cos(x), x, S.Reals) == S.Half
+    assert simplify(maximum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == sqrt(2)/4
+    assert maximum((x+3)*(x-2), x) is oo
+    assert maximum((x+3)*(x-2), x, Interval(-5, 0)) == S(14)
+    assert maximum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(2, 7)
+    assert simplify(maximum(-x**4-x**3+x**2+10, x)
+        ) == 41*sqrt(41)/512 + Rational(5419, 512)
+    assert maximum(exp(x), x, Interval(-oo, 2)) == exp(2)
+    assert maximum(log(x) - x, x, S.Reals) is S.NegativeOne
+    assert maximum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.One
+    assert maximum(cos(x)-sin(x), x, S.Reals) == sqrt(2)
+    assert maximum(y, x, S.Reals) == y
+    assert maximum(abs(a**3 + a), a, Interval(0, 2)) == 10
+    assert maximum(abs(60*a**3 + 24*a), a, Interval(0, 2)) == 528
+    assert maximum(abs(12*a*(5*a**2 + 2)), a, Interval(0, 2)) == 528
+    assert maximum(x/sqrt(x**2+1), x, S.Reals) == 1
+
+    raises(ValueError, lambda : maximum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), sin(x)))
+    raises(ValueError, lambda : maximum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : maximum(sin(x), S.One))
+
+
+def test_minimum():
+    assert minimum(sin(x), x) is S.NegativeOne
+    assert minimum(sin(x), x, Interval(1, 4)) == sin(4)
+    assert minimum(tan(x), x) is -oo
+    assert minimum(tan(x), x, Interval(-pi/4, pi/4)) is S.NegativeOne
+    assert minimum(sin(x)*cos(x), x, S.Reals) == Rational(-1, 2)
+    assert simplify(minimum(sin(x)*cos(x), x, Interval(pi*Rational(3, 8), pi*Rational(5, 8)))
+        ) == -sqrt(2)/4
+    assert minimum((x+3)*(x-2), x) == Rational(-25, 4)
+    assert minimum((x+3)/(x-2), x, Interval(-5, 0)) == Rational(-3, 2)
+    assert minimum(x**4-x**3+x**2+10, x) == S(10)
+    assert minimum(exp(x), x, Interval(-2, oo)) == exp(-2)
+    assert minimum(log(x) - x, x, S.Reals) is -oo
+    assert minimum(cos(x), x, Union(Interval(0, 5), Interval(-6, -3))
+        ) is S.NegativeOne
+    assert minimum(cos(x)-sin(x), x, S.Reals) == -sqrt(2)
+    assert minimum(y, x, S.Reals) == y
+    assert minimum(x/sqrt(x**2+1), x, S.Reals) == -1
+
+    raises(ValueError, lambda : minimum(sin(x), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(log(cos(x)), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(1/(x**2 + y**2 + 1), x, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), sin(x)))
+    raises(ValueError, lambda : minimum(sin(x), x*y, S.EmptySet))
+    raises(ValueError, lambda : minimum(sin(x), S.One))
+
+
+def test_issue_19869():
+    assert (maximum(sqrt(3)*(x - 1)/(3*sqrt(x**2 + 1)), x)
+        ) == sqrt(3)/3
+
+
+def test_issue_16469():
+    f = abs(a)
+    assert function_range(f, a, S.Reals) == Interval(0, oo, False, True)
+
+
+@_both_exp_pow
+def test_issue_18747():
+    assert periodicity(exp(pi*I*(x/4 + S.Half/2)), x) == 8
+
+
+def test_issue_25942():
+    assert (acos(x) > pi/3).as_set() == Interval.Ropen(-1, S(1)/2)
diff --git a/.venv/lib/python3.12/site-packages/sympy/calculus/util.py b/.venv/lib/python3.12/site-packages/sympy/calculus/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..dac316358873de2418dd8ab56445823f07a37b1b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/calculus/util.py
@@ -0,0 +1,895 @@
+from .accumulationbounds import AccumBounds, AccumulationBounds # noqa: F401
+from .singularities import singularities
+from sympy.core import Pow, S
+from sympy.core.function import diff, expand_mul, Function
+from sympy.core.kind import NumberKind
+from sympy.core.mod import Mod
+from sympy.core.numbers import equal_valued
+from sympy.core.relational import Relational
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.integers import frac
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (
+    TrigonometricFunction, sin, cos, tan, cot, csc, sec,
+    asin, acos, acot, atan, asec, acsc)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+    sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.polys.polytools import degree, lcm_list
+from sympy.sets.sets import (Interval, Intersection, FiniteSet, Union,
+                             Complement)
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.conditionset import ConditionSet
+from sympy.utilities import filldedent
+from sympy.utilities.iterables import iterable
+from sympy.matrices.dense import hessian
+
+
+def continuous_domain(f, symbol, domain):
+    """
+    Returns the domain on which the function expression f is continuous.
+
+    This function is limited by the ability to determine the various
+    singularities and discontinuities of the given function.
+    The result is either given as a union of intervals or constructed using
+    other set operations.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the intervals are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the continuity of the symbol has to be checked.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, tan, log, pi, sqrt
+    >>> from sympy.calculus.util import continuous_domain
+    >>> x = Symbol('x')
+    >>> continuous_domain(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> continuous_domain(tan(x), x, Interval(0, pi))
+    Union(Interval.Ropen(0, pi/2), Interval.Lopen(pi/2, pi))
+    >>> continuous_domain(sqrt(x - 2), x, Interval(-5, 5))
+    Interval(2, 5)
+    >>> continuous_domain(log(2*x - 1), x, S.Reals)
+    Interval.open(1/2, oo)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all intervals where the function is continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If the method to determine continuity of such a function
+        has not yet been developed.
+
+    """
+    from sympy.solvers.inequalities import solve_univariate_inequality
+
+    if not domain.is_subset(S.Reals):
+        raise NotImplementedError(filldedent('''
+            Domain must be a subset of S.Reals.
+            '''))
+    implemented = [Pow, exp, log, Abs, frac,
+                   sin, cos, tan, cot, sec, csc,
+                   asin, acos, atan, acot, asec, acsc,
+                   sinh, cosh, tanh, coth, sech, csch,
+                   asinh, acosh, atanh, acoth, asech, acsch]
+    used = [fct.func for fct in f.atoms(Function) if fct.has(symbol)]
+    if any(func not in implemented for func in used):
+        raise NotImplementedError(filldedent('''
+            Unable to determine the domain of the given function.
+            '''))
+
+    x = Symbol('x')
+    constraints = {
+        log: (x > 0,),
+        asin: (x >= -1, x <= 1),
+        acos: (x >= -1, x <= 1),
+        acosh: (x >= 1,),
+        atanh: (x > -1, x < 1),
+        asech: (x > 0, x <= 1)
+    }
+    constraints_union = {
+        asec: (x <= -1, x >= 1),
+        acsc: (x <= -1, x >= 1),
+        acoth: (x < -1, x > 1)
+    }
+
+    cont_domain = domain
+    for atom in f.atoms(Pow):
+        den = atom.exp.as_numer_denom()[1]
+        if atom.exp.is_rational and den.is_odd:
+            pass    # 0**negative handled by singularities()
+        else:
+            constraint = solve_univariate_inequality(atom.base >= 0,
+                                                        symbol).as_set()
+            cont_domain = Intersection(constraint, cont_domain)
+
+    for atom in f.atoms(Function):
+        if atom.func in constraints:
+            for c in constraints[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set = solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+                cont_domain = Intersection(constraint_set, cont_domain)
+        elif atom.func in constraints_union:
+            constraint_set = S.EmptySet
+            for c in constraints_union[atom.func]:
+                constraint_relational = c.subs(x, atom.args[0])
+                constraint_set += solve_univariate_inequality(
+                    constraint_relational, symbol).as_set()
+            cont_domain = Intersection(constraint_set, cont_domain)
+        # XXX: the discontinuities below could be factored out in
+        # a new "discontinuities()".
+        elif atom.func == acot:
+            from sympy.solvers.solveset import solveset_real
+            # Sympy's acot() has a step discontinuity at 0. Since it's
+            # neither an essential singularity nor a pole, singularities()
+            # will not report it. But it's still relevant for determining
+            # the continuity of the function f.
+            cont_domain -= solveset_real(atom.args[0], symbol)
+            # Note that the above may introduce spurious discontinuities, e.g.
+            # for abs(acot(x)) at 0.
+        elif atom.func == frac:
+            from sympy.solvers.solveset import solveset_real
+            r = function_range(atom.args[0], symbol, domain)
+            r = Intersection(r, S.Integers)
+            if r.is_finite_set:
+                discont = S.EmptySet
+                for n in r:
+                    discont += solveset_real(atom.args[0]-n, symbol)
+            else:
+                discont = ConditionSet(
+                    symbol, S.Integers.contains(atom.args[0]), cont_domain)
+            cont_domain -= discont
+
+    return cont_domain - singularities(f, symbol, domain)
+
+
+def function_range(f, symbol, domain):
+    """
+    Finds the range of a function in a given domain.
+    This method is limited by the ability to determine the singularities and
+    determine limits.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the range of function is to be determined.
+    domain : :py:class:`~.Interval`
+        The domain under which the range of the function has to be found.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, exp, log, pi, sqrt, sin, tan
+    >>> from sympy.calculus.util import function_range
+    >>> x = Symbol('x')
+    >>> function_range(sin(x), x, Interval(0, 2*pi))
+    Interval(-1, 1)
+    >>> function_range(tan(x), x, Interval(-pi/2, pi/2))
+    Interval(-oo, oo)
+    >>> function_range(1/x, x, S.Reals)
+    Union(Interval.open(-oo, 0), Interval.open(0, oo))
+    >>> function_range(exp(x), x, S.Reals)
+    Interval.open(0, oo)
+    >>> function_range(log(x), x, S.Reals)
+    Interval(-oo, oo)
+    >>> function_range(sqrt(x), x, Interval(-5, 9))
+    Interval(0, 3)
+
+    Returns
+    =======
+
+    :py:class:`~.Interval`
+        Union of all ranges for all intervals under domain where function is
+        continuous.
+
+    Raises
+    ======
+
+    NotImplementedError
+        If any of the intervals, in the given domain, for which function
+        is continuous are not finite or real,
+        OR if the critical points of the function on the domain cannot be found.
+    """
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    period = periodicity(f, symbol)
+    if period == S.Zero:
+        # the expression is constant wrt symbol
+        return FiniteSet(f.expand())
+
+    from sympy.series.limits import limit
+    from sympy.solvers.solveset import solveset
+
+    if period is not None:
+        if isinstance(domain, Interval):
+            if (domain.inf - domain.sup).is_infinite:
+                domain = Interval(0, period)
+        elif isinstance(domain, Union):
+            for sub_dom in domain.args:
+                if isinstance(sub_dom, Interval) and \
+                ((sub_dom.inf - sub_dom.sup).is_infinite):
+                    domain = Interval(0, period)
+
+    intervals = continuous_domain(f, symbol, domain)
+    range_int = S.EmptySet
+    if isinstance(intervals,(Interval, FiniteSet)):
+        interval_iter = (intervals,)
+    elif isinstance(intervals, Union):
+        interval_iter = intervals.args
+    else:
+        raise NotImplementedError("Unable to find range for the given domain.")
+
+    for interval in interval_iter:
+        if isinstance(interval, FiniteSet):
+            for singleton in interval:
+                if singleton in domain:
+                    range_int += FiniteSet(f.subs(symbol, singleton))
+        elif isinstance(interval, Interval):
+            vals = S.EmptySet
+            critical_values = S.EmptySet
+            bounds = ((interval.left_open, interval.inf, '+'),
+                   (interval.right_open, interval.sup, '-'))
+
+            for is_open, limit_point, direction in bounds:
+                if is_open:
+                    critical_values += FiniteSet(limit(f, symbol, limit_point, direction))
+                    vals += critical_values
+                else:
+                    vals += FiniteSet(f.subs(symbol, limit_point))
+
+            critical_points = solveset(f.diff(symbol), symbol, interval)
+
+            if not iterable(critical_points):
+                raise NotImplementedError(
+                        'Unable to find critical points for {}'.format(f))
+            if isinstance(critical_points, ImageSet):
+                raise NotImplementedError(
+                        'Infinite number of critical points for {}'.format(f))
+
+            for critical_point in critical_points:
+                vals += FiniteSet(f.subs(symbol, critical_point))
+
+            left_open, right_open = False, False
+
+            if critical_values is not S.EmptySet:
+                if critical_values.inf == vals.inf:
+                    left_open = True
+
+                if critical_values.sup == vals.sup:
+                    right_open = True
+
+            range_int += Interval(vals.inf, vals.sup, left_open, right_open)
+        else:
+            raise NotImplementedError("Unable to find range for the given domain.")
+
+    return range_int
+
+
+def not_empty_in(finset_intersection, *syms):
+    """
+    Finds the domain of the functions in ``finset_intersection`` in which the
+    ``finite_set`` is not-empty.
+
+    Parameters
+    ==========
+
+    finset_intersection : Intersection of FiniteSet
+        The unevaluated intersection of FiniteSet containing
+        real-valued functions with Union of Sets
+    syms : Tuple of symbols
+        Symbol for which domain is to be found
+
+    Raises
+    ======
+
+    NotImplementedError
+        The algorithms to find the non-emptiness of the given FiniteSet are
+        not yet implemented.
+    ValueError
+        The input is not valid.
+    RuntimeError
+        It is a bug, please report it to the github issue tracker
+        (https://github.com/sympy/sympy/issues).
+
+    Examples
+    ========
+
+    >>> from sympy import FiniteSet, Interval, not_empty_in, oo
+    >>> from sympy.abc import x
+    >>> not_empty_in(FiniteSet(x/2).intersect(Interval(0, 1)), x)
+    Interval(0, 2)
+    >>> not_empty_in(FiniteSet(x, x**2).intersect(Interval(1, 2)), x)
+    Union(Interval(1, 2), Interval(-sqrt(2), -1))
+    >>> not_empty_in(FiniteSet(x**2/(x + 2)).intersect(Interval(1, oo)), x)
+    Union(Interval.Lopen(-2, -1), Interval(2, oo))
+    """
+
+    # TODO: handle piecewise defined functions
+    # TODO: handle transcendental functions
+    # TODO: handle multivariate functions
+    if len(syms) == 0:
+        raise ValueError("One or more symbols must be given in syms.")
+
+    if finset_intersection is S.EmptySet:
+        return S.EmptySet
+
+    if isinstance(finset_intersection, Union):
+        elm_in_sets = finset_intersection.args[0]
+        return Union(not_empty_in(finset_intersection.args[1], *syms),
+                     elm_in_sets)
+
+    if isinstance(finset_intersection, FiniteSet):
+        finite_set = finset_intersection
+        _sets = S.Reals
+    else:
+        finite_set = finset_intersection.args[1]
+        _sets = finset_intersection.args[0]
+
+    if not isinstance(finite_set, FiniteSet):
+        raise ValueError('A FiniteSet must be given, not %s: %s' %
+                         (type(finite_set), finite_set))
+
+    if len(syms) == 1:
+        symb = syms[0]
+    else:
+        raise NotImplementedError('more than one variables %s not handled' %
+                                  (syms,))
+
+    def elm_domain(expr, intrvl):
+        """ Finds the domain of an expression in any given interval """
+        from sympy.solvers.solveset import solveset
+
+        _start = intrvl.start
+        _end = intrvl.end
+        _singularities = solveset(expr.as_numer_denom()[1], symb,
+                                  domain=S.Reals)
+
+        if intrvl.right_open:
+            if _end is S.Infinity:
+                _domain1 = S.Reals
+            else:
+                _domain1 = solveset(expr < _end, symb, domain=S.Reals)
+        else:
+            _domain1 = solveset(expr <= _end, symb, domain=S.Reals)
+
+        if intrvl.left_open:
+            if _start is S.NegativeInfinity:
+                _domain2 = S.Reals
+            else:
+                _domain2 = solveset(expr > _start, symb, domain=S.Reals)
+        else:
+            _domain2 = solveset(expr >= _start, symb, domain=S.Reals)
+
+        # domain in the interval
+        expr_with_sing = Intersection(_domain1, _domain2)
+        expr_domain = Complement(expr_with_sing, _singularities)
+        return expr_domain
+
+    if isinstance(_sets, Interval):
+        return Union(*[elm_domain(element, _sets) for element in finite_set])
+
+    if isinstance(_sets, Union):
+        _domain = S.EmptySet
+        for intrvl in _sets.args:
+            _domain_element = Union(*[elm_domain(element, intrvl)
+                                      for element in finite_set])
+            _domain = Union(_domain, _domain_element)
+        return _domain
+
+
+def periodicity(f, symbol, check=False):
+    """
+    Tests the given function for periodicity in the given symbol.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the period is to be determined.
+    check : bool, optional
+        The flag to verify whether the value being returned is a period or not.
+
+    Returns
+    =======
+
+    period
+        The period of the function is returned.
+        ``None`` is returned when the function is aperiodic or has a complex period.
+        The value of $0$ is returned as the period of a constant function.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The value of the period computed cannot be verified.
+
+
+    Notes
+    =====
+
+    Currently, we do not support functions with a complex period.
+    The period of functions having complex periodic values such
+    as ``exp``, ``sinh`` is evaluated to ``None``.
+
+    The value returned might not be the "fundamental" period of the given
+    function i.e. it may not be the smallest periodic value of the function.
+
+    The verification of the period through the ``check`` flag is not reliable
+    due to internal simplification of the given expression. Hence, it is set
+    to ``False`` by default.
+
+    Examples
+    ========
+    >>> from sympy import periodicity, Symbol, sin, cos, tan, exp
+    >>> x = Symbol('x')
+    >>> f = sin(x) + sin(2*x) + sin(3*x)
+    >>> periodicity(f, x)
+    2*pi
+    >>> periodicity(sin(x)*cos(x), x)
+    pi
+    >>> periodicity(exp(tan(2*x) - 1), x)
+    pi/2
+    >>> periodicity(sin(4*x)**cos(2*x), x)
+    pi
+    >>> periodicity(exp(x), x)
+    """
+    if symbol.kind is not NumberKind:
+        raise NotImplementedError("Cannot use symbol of kind %s" % symbol.kind)
+    temp = Dummy('x', real=True)
+    f = f.subs(symbol, temp)
+    symbol = temp
+
+    def _check(orig_f, period):
+        '''Return the checked period or raise an error.'''
+        new_f = orig_f.subs(symbol, symbol + period)
+        if new_f.equals(orig_f):
+            return period
+        else:
+            raise NotImplementedError(filldedent('''
+                The period of the given function cannot be verified.
+                When `%s` was replaced with `%s + %s` in `%s`, the result
+                was `%s` which was not recognized as being the same as
+                the original function.
+                So either the period was wrong or the two forms were
+                not recognized as being equal.
+                Set check=False to obtain the value.''' %
+                (symbol, symbol, period, orig_f, new_f)))
+
+    orig_f = f
+    period = None
+
+    if isinstance(f, Relational):
+        f = f.lhs - f.rhs
+
+    f = f.simplify()
+
+    if symbol not in f.free_symbols:
+        return S.Zero
+
+    if isinstance(f, TrigonometricFunction):
+        try:
+            period = f.period(symbol)
+        except NotImplementedError:
+            pass
+
+    if isinstance(f, Abs):
+        arg = f.args[0]
+        if isinstance(arg, (sec, csc, cos)):
+            # all but tan and cot might have a
+            # a period that is half as large
+            # so recast as sin
+            arg = sin(arg.args[0])
+        period = periodicity(arg, symbol)
+        if period is not None and isinstance(arg, sin):
+            # the argument of Abs was a trigonometric other than
+            # cot or tan; test to see if the half-period
+            # is valid. Abs(arg) has behaviour equivalent to
+            # orig_f, so use that for test:
+            orig_f = Abs(arg)
+            try:
+                return _check(orig_f, period/2)
+            except NotImplementedError as err:
+                if check:
+                    raise NotImplementedError(err)
+            # else let new orig_f and period be
+            # checked below
+
+    if isinstance(f, exp) or (f.is_Pow and f.base == S.Exp1):
+        f = Pow(S.Exp1, expand_mul(f.exp))
+        if im(f) != 0:
+            period_real = periodicity(re(f), symbol)
+            period_imag = periodicity(im(f), symbol)
+            if period_real is not None and period_imag is not None:
+                period = lcim([period_real, period_imag])
+
+    if f.is_Pow and f.base != S.Exp1:
+        base, expo = f.args
+        base_has_sym = base.has(symbol)
+        expo_has_sym = expo.has(symbol)
+
+        if base_has_sym and not expo_has_sym:
+            period = periodicity(base, symbol)
+
+        elif expo_has_sym and not base_has_sym:
+            period = periodicity(expo, symbol)
+
+        else:
+            period = _periodicity(f.args, symbol)
+
+    elif f.is_Mul:
+        coeff, g = f.as_independent(symbol, as_Add=False)
+        if isinstance(g, TrigonometricFunction) or not equal_valued(coeff, 1):
+            period = periodicity(g, symbol)
+        else:
+            period = _periodicity(g.args, symbol)
+
+    elif f.is_Add:
+        k, g = f.as_independent(symbol)
+        if k is not S.Zero:
+            return periodicity(g, symbol)
+
+        period = _periodicity(g.args, symbol)
+
+    elif isinstance(f, Mod):
+        a, n = f.args
+
+        if a == symbol:
+            period = n
+        elif isinstance(a, TrigonometricFunction):
+            period = periodicity(a, symbol)
+        #check if 'f' is linear in 'symbol'
+        elif (a.is_polynomial(symbol) and degree(a, symbol) == 1 and
+            symbol not in n.free_symbols):
+                period = Abs(n / a.diff(symbol))
+
+    elif isinstance(f, Piecewise):
+        pass  # not handling Piecewise yet as the return type is not favorable
+
+    elif period is None:
+        from sympy.solvers.decompogen import compogen, decompogen
+        g_s = decompogen(f, symbol)
+        num_of_gs = len(g_s)
+        if num_of_gs > 1:
+            for index, g in enumerate(reversed(g_s)):
+                start_index = num_of_gs - 1 - index
+                g = compogen(g_s[start_index:], symbol)
+                if g not in (orig_f, f): # Fix for issue 12620
+                    period = periodicity(g, symbol)
+                    if period is not None:
+                        break
+
+    if period is not None:
+        if check:
+            return _check(orig_f, period)
+        return period
+
+    return None
+
+
+def _periodicity(args, symbol):
+    """
+    Helper for `periodicity` to find the period of a list of simpler
+    functions.
+    It uses the `lcim` method to find the least common period of
+    all the functions.
+
+    Parameters
+    ==========
+
+    args : Tuple of :py:class:`~.Symbol`
+        All the symbols present in a function.
+
+    symbol : :py:class:`~.Symbol`
+        The symbol over which the function is to be evaluated.
+
+    Returns
+    =======
+
+    period
+        The least common period of the function for all the symbols
+        of the function.
+        ``None`` if for at least one of the symbols the function is aperiodic.
+
+    """
+    periods = []
+    for f in args:
+        period = periodicity(f, symbol)
+        if period is None:
+            return None
+
+        if period is not S.Zero:
+            periods.append(period)
+
+    if len(periods) > 1:
+        return lcim(periods)
+
+    if periods:
+        return periods[0]
+
+
+def lcim(numbers):
+    """Returns the least common integral multiple of a list of numbers.
+
+    The numbers can be rational or irrational or a mixture of both.
+    `None` is returned for incommensurable numbers.
+
+    Parameters
+    ==========
+
+    numbers : list
+        Numbers (rational and/or irrational) for which lcim is to be found.
+
+    Returns
+    =======
+
+    number
+        lcim if it exists, otherwise ``None`` for incommensurable numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.calculus.util import lcim
+    >>> from sympy import S, pi
+    >>> lcim([S(1)/2, S(3)/4, S(5)/6])
+    15/2
+    >>> lcim([2*pi, 3*pi, pi, pi/2])
+    6*pi
+    >>> lcim([S(1), 2*pi])
+    """
+    result = None
+    if all(num.is_irrational for num in numbers):
+        factorized_nums = [num.factor() for num in numbers]
+        factors_num = [num.as_coeff_Mul() for num in factorized_nums]
+        term = factors_num[0][1]
+        if all(factor == term for coeff, factor in factors_num):
+            common_term = term
+            coeffs = [coeff for coeff, factor in factors_num]
+            result = lcm_list(coeffs) * common_term
+
+    elif all(num.is_rational for num in numbers):
+        result = lcm_list(numbers)
+
+    else:
+        pass
+
+    return result
+
+def is_convex(f, *syms, domain=S.Reals):
+    r"""Determines the  convexity of the function passed in the argument.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    syms : Tuple of :py:class:`~.Symbol`
+        The variables with respect to which the convexity is to be determined.
+    domain : :py:class:`~.Interval`, optional
+        The domain over which the convexity of the function has to be checked.
+        If unspecified, S.Reals will be the default domain.
+
+    Returns
+    =======
+
+    bool
+        The method returns ``True`` if the function is convex otherwise it
+        returns ``False``.
+
+    Raises
+    ======
+
+    NotImplementedError
+        The check for the convexity of multivariate functions is not implemented yet.
+
+    Notes
+    =====
+
+    To determine concavity of a function pass `-f` as the concerned function.
+    To determine logarithmic convexity of a function pass `\log(f)` as
+    concerned function.
+    To determine logarithmic concavity of a function pass `-\log(f)` as
+    concerned function.
+
+    Currently, convexity check of multivariate functions is not handled.
+
+    Examples
+    ========
+
+    >>> from sympy import is_convex, symbols, exp, oo, Interval
+    >>> x = symbols('x')
+    >>> is_convex(exp(x), x)
+    True
+    >>> is_convex(x**3, x, domain = Interval(-1, oo))
+    False
+    >>> is_convex(1/x**2, x, domain=Interval.open(0, oo))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convex_function
+    .. [2] http://www.ifp.illinois.edu/~angelia/L3_convfunc.pdf
+    .. [3] https://en.wikipedia.org/wiki/Logarithmically_convex_function
+    .. [4] https://en.wikipedia.org/wiki/Logarithmically_concave_function
+    .. [5] https://en.wikipedia.org/wiki/Concave_function
+
+    """
+    if len(syms) > 1 :
+        return hessian(f, syms).is_positive_semidefinite
+    from sympy.solvers.inequalities import solve_univariate_inequality
+    f = _sympify(f)
+    var = syms[0]
+    if any(s in domain for s in singularities(f, var)):
+        return False
+    condition = f.diff(var, 2) < 0
+    if solve_univariate_inequality(condition, var, False, domain):
+        return False
+    return True
+
+
+def stationary_points(f, symbol, domain=S.Reals):
+    """
+    Returns the stationary points of a function (where derivative of the
+    function is 0) in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for which the stationary points are to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the stationary points have to be checked.
+        If unspecified, ``S.Reals`` will be the default domain.
+
+    Returns
+    =======
+
+    Set
+        A set of stationary points for the function. If there are no
+        stationary point, an :py:class:`~.EmptySet` is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, pi, pprint, stationary_points
+    >>> x = Symbol('x')
+
+    >>> stationary_points(1/x, x, S.Reals)
+    EmptySet
+
+    >>> pprint(stationary_points(sin(x), x), use_unicode=False)
+              pi                              3*pi
+    {2*n*pi + -- | n in Integers} U {2*n*pi + ---- | n in Integers}
+              2                                2
+
+    >>> stationary_points(sin(x),x, Interval(0, 4*pi))
+    {pi/2, 3*pi/2, 5*pi/2, 7*pi/2}
+
+    """
+    from sympy.solvers.solveset import solveset
+
+    if domain is S.EmptySet:
+        return S.EmptySet
+
+    domain = continuous_domain(f, symbol, domain)
+    set = solveset(diff(f, symbol), symbol, domain)
+
+    return set
+
+
+def maximum(f, symbol, domain=S.Reals):
+    """
+    Returns the maximum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for maximum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the maximum have to be checked.
+        If unspecified, then the global maximum is returned.
+
+    Returns
+    =======
+
+    number
+        Maximum value of the function in given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, pi, maximum
+    >>> x = Symbol('x')
+
+    >>> f = -x**2 + 2*x + 5
+    >>> maximum(f, x, S.Reals)
+    6
+
+    >>> maximum(sin(x), x, Interval(-pi, pi/4))
+    sqrt(2)/2
+
+    >>> maximum(sin(x)*cos(x), x)
+    1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Maximum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).sup
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
+
+
+def minimum(f, symbol, domain=S.Reals):
+    """
+    Returns the minimum value of a function in the given domain.
+
+    Parameters
+    ==========
+
+    f : :py:class:`~.Expr`
+        The concerned function.
+    symbol : :py:class:`~.Symbol`
+        The variable for minimum value needs to be determined.
+    domain : :py:class:`~.Interval`
+        The domain over which the minimum have to be checked.
+        If unspecified, then the global minimum is returned.
+
+    Returns
+    =======
+
+    number
+        Minimum value of the function in the given domain.
+
+    Examples
+    ========
+
+    >>> from sympy import Interval, Symbol, S, sin, cos, minimum
+    >>> x = Symbol('x')
+
+    >>> f = x**2 + 2*x + 5
+    >>> minimum(f, x, S.Reals)
+    4
+
+    >>> minimum(sin(x), x, Interval(2, 3))
+    sin(3)
+
+    >>> minimum(sin(x)*cos(x), x)
+    -1/2
+
+    """
+    if isinstance(symbol, Symbol):
+        if domain is S.EmptySet:
+            raise ValueError("Minimum value not defined for empty domain.")
+
+        return function_range(f, symbol, domain).inf
+    else:
+        raise ValueError("%s is not a valid symbol." % symbol)
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/__init__.py b/.venv/lib/python3.12/site-packages/sympy/categories/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c5007308a1b232e57f9ed164276862df0c5f265
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/categories/__init__.py
@@ -0,0 +1,33 @@
+"""
+Category Theory module.
+
+Provides some of the fundamental category-theory-related classes,
+including categories, morphisms, diagrams.  Functors are not
+implemented yet.
+
+The general reference work this module tries to follow is
+
+  [JoyOfCats] J. Adamek, H. Herrlich. G. E. Strecker: Abstract and
+              Concrete Categories. The Joy of Cats.
+
+The latest version of this book should be available for free download
+from
+
+   katmat.math.uni-bremen.de/acc/acc.pdf
+
+"""
+
+from .baseclasses import (Object, Morphism, IdentityMorphism,
+                         NamedMorphism, CompositeMorphism, Category,
+                         Diagram)
+
+from .diagram_drawing import (DiagramGrid, XypicDiagramDrawer,
+                             xypic_draw_diagram, preview_diagram)
+
+__all__ = [
+    'Object', 'Morphism', 'IdentityMorphism', 'NamedMorphism',
+    'CompositeMorphism', 'Category', 'Diagram',
+
+    'DiagramGrid', 'XypicDiagramDrawer', 'xypic_draw_diagram',
+    'preview_diagram',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..71034e0e25c832757e72eff5de28bbf428051dc4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/baseclasses.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/baseclasses.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a4b720105c9fc567b7005f8a0ecedb500454d86
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/baseclasses.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/diagram_drawing.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/diagram_drawing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..96be4768de666b6fb54adc56352ba505add702fa
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/__pycache__/diagram_drawing.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/baseclasses.py b/.venv/lib/python3.12/site-packages/sympy/categories/baseclasses.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6ab5153ae4e95f193030864c8f32a52254f2458
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/categories/baseclasses.py
@@ -0,0 +1,978 @@
+from sympy.core import S, Basic, Dict, Symbol, Tuple, sympify
+from sympy.core.symbol import Str
+from sympy.sets import Set, FiniteSet, EmptySet
+from sympy.utilities.iterables import iterable
+
+
+class Class(Set):
+    r"""
+    The base class for any kind of class in the set-theoretic sense.
+
+    Explanation
+    ===========
+
+    In axiomatic set theories, everything is a class.  A class which
+    can be a member of another class is a set.  A class which is not a
+    member of another class is a proper class.  The class `\{1, 2\}`
+    is a set; the class of all sets is a proper class.
+
+    This class is essentially a synonym for :class:`sympy.core.Set`.
+    The goal of this class is to assure easier migration to the
+    eventual proper implementation of set theory.
+    """
+    is_proper = False
+
+
+class Object(Symbol):
+    """
+    The base class for any kind of object in an abstract category.
+
+    Explanation
+    ===========
+
+    While technically any instance of :class:`~.Basic` will do, this
+    class is the recommended way to create abstract objects in
+    abstract categories.
+    """
+
+
+class Morphism(Basic):
+    """
+    The base class for any morphism in an abstract category.
+
+    Explanation
+    ===========
+
+    In abstract categories, a morphism is an arrow between two
+    category objects.  The object where the arrow starts is called the
+    domain, while the object where the arrow ends is called the
+    codomain.
+
+    Two morphisms between the same pair of objects are considered to
+    be the same morphisms.  To distinguish between morphisms between
+    the same objects use :class:`NamedMorphism`.
+
+    It is prohibited to instantiate this class.  Use one of the
+    derived classes instead.
+
+    See Also
+    ========
+
+    IdentityMorphism, NamedMorphism, CompositeMorphism
+    """
+    def __new__(cls, domain, codomain):
+        raise(NotImplementedError(
+            "Cannot instantiate Morphism.  Use derived classes instead."))
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.domain
+        Object("A")
+
+        """
+        return self.args[0]
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.codomain
+        Object("B")
+
+        """
+        return self.args[1]
+
+    def compose(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The order of elements in the composition is the usual order,
+        i.e., to construct `g\circ f` use ``g.compose(f)``.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> g * f
+        CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g")))
+        >>> (g * f).domain
+        Object("A")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return CompositeMorphism(other, self)
+
+    def __mul__(self, other):
+        r"""
+        Composes self with the supplied morphism.
+
+        The semantics of this operation is given by the following
+        equation: ``g * f == g.compose(f)`` for composable morphisms
+        ``g`` and ``f``.
+
+        See Also
+        ========
+
+        compose
+        """
+        return self.compose(other)
+
+
+class IdentityMorphism(Morphism):
+    """
+    Represents an identity morphism.
+
+    Explanation
+    ===========
+
+    An identity morphism is a morphism with equal domain and codomain,
+    which acts as an identity with respect to composition.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, IdentityMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> id_A = IdentityMorphism(A)
+    >>> id_B = IdentityMorphism(B)
+    >>> f * id_A == f
+    True
+    >>> id_B * f == f
+    True
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain):
+        return Basic.__new__(cls, domain)
+
+    @property
+    def codomain(self):
+        return self.domain
+
+
+class NamedMorphism(Morphism):
+    """
+    Represents a morphism which has a name.
+
+    Explanation
+    ===========
+
+    Names are used to distinguish between morphisms which have the
+    same domain and codomain: two named morphisms are equal if they
+    have the same domains, codomains, and names.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> f
+    NamedMorphism(Object("A"), Object("B"), "f")
+    >>> f.name
+    'f'
+
+    See Also
+    ========
+
+    Morphism
+    """
+    def __new__(cls, domain, codomain, name):
+        if not name:
+            raise ValueError("Empty morphism names not allowed.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        return Basic.__new__(cls, domain, codomain, name)
+
+    @property
+    def name(self):
+        """
+        Returns the name of the morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> f.name
+        'f'
+
+        """
+        return self.args[2].name
+
+
+class CompositeMorphism(Morphism):
+    r"""
+    Represents a morphism which is a composition of other morphisms.
+
+    Explanation
+    ===========
+
+    Two composite morphisms are equal if the morphisms they were
+    obtained from (components) are the same and were listed in the
+    same order.
+
+    The arguments to the constructor for this class should be listed
+    in diagram order: to obtain the composition `g\circ f` from the
+    instances of :class:`Morphism` ``g`` and ``f`` use
+    ``CompositeMorphism(f, g)``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, CompositeMorphism
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> g * f
+    CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"),
+    NamedMorphism(Object("B"), Object("C"), "g")))
+    >>> CompositeMorphism(f, g) == g * f
+    True
+
+    """
+    @staticmethod
+    def _add_morphism(t, morphism):
+        """
+        Intelligently adds ``morphism`` to tuple ``t``.
+
+        Explanation
+        ===========
+
+        If ``morphism`` is a composite morphism, its components are
+        added to the tuple.  If ``morphism`` is an identity, nothing
+        is added to the tuple.
+
+        No composability checks are performed.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            # ``morphism`` is a composite morphism; we have to
+            # denest its components.
+            return t + morphism.components
+        elif isinstance(morphism, IdentityMorphism):
+            # ``morphism`` is an identity.  Nothing happens.
+            return t
+        else:
+            return t + Tuple(morphism)
+
+    def __new__(cls, *components):
+        if components and not isinstance(components[0], Morphism):
+            # Maybe the user has explicitly supplied a list of
+            # morphisms.
+            return CompositeMorphism.__new__(cls, *components[0])
+
+        normalised_components = Tuple()
+
+        for current, following in zip(components, components[1:]):
+            if not isinstance(current, Morphism) or \
+                    not isinstance(following, Morphism):
+                raise TypeError("All components must be morphisms.")
+
+            if current.codomain != following.domain:
+                raise ValueError("Uncomposable morphisms.")
+
+            normalised_components = CompositeMorphism._add_morphism(
+                normalised_components, current)
+
+        # We haven't added the last morphism to the list of normalised
+        # components.  Add it now.
+        normalised_components = CompositeMorphism._add_morphism(
+            normalised_components, components[-1])
+
+        if not normalised_components:
+            # If ``normalised_components`` is empty, only identities
+            # were supplied.  Since they all were composable, they are
+            # all the same identities.
+            return components[0]
+        elif len(normalised_components) == 1:
+            # No sense to construct a whole CompositeMorphism.
+            return normalised_components[0]
+
+        return Basic.__new__(cls, normalised_components)
+
+    @property
+    def components(self):
+        """
+        Returns the components of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).components
+        (NamedMorphism(Object("A"), Object("B"), "f"),
+        NamedMorphism(Object("B"), Object("C"), "g"))
+
+        """
+        return self.args[0]
+
+    @property
+    def domain(self):
+        """
+        Returns the domain of this composite morphism.
+
+        The domain of the composite morphism is the domain of its
+        first component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).domain
+        Object("A")
+
+        """
+        return self.components[0].domain
+
+    @property
+    def codomain(self):
+        """
+        Returns the codomain of this composite morphism.
+
+        The codomain of the composite morphism is the codomain of its
+        last component.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).codomain
+        Object("C")
+
+        """
+        return self.components[-1].codomain
+
+    def flatten(self, new_name):
+        """
+        Forgets the composite structure of this morphism.
+
+        Explanation
+        ===========
+
+        If ``new_name`` is not empty, returns a :class:`NamedMorphism`
+        with the supplied name, otherwise returns a :class:`Morphism`.
+        In both cases the domain of the new morphism is the domain of
+        this composite morphism and the codomain of the new morphism
+        is the codomain of this composite morphism.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> (g * f).flatten("h")
+        NamedMorphism(Object("A"), Object("C"), "h")
+
+        """
+        return NamedMorphism(self.domain, self.codomain, new_name)
+
+
+class Category(Basic):
+    r"""
+    An (abstract) category.
+
+    Explanation
+    ===========
+
+    A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id,
+    \circ)` consisting of
+
+    * a (set-theoretical) class `O`, whose members are called
+      `K`-objects,
+
+    * for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose
+      members are called `K`-morphisms from `A` to `B`,
+
+    * for a each `K`-object `A`, a morphism `id:A\rightarrow A`,
+      called the `K`-identity of `A`,
+
+    * a composition law `\circ` associating with every `K`-morphisms
+      `f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ
+      f:A\rightarrow C`, called the composite of `f` and `g`.
+
+    Composition is associative, `K`-identities are identities with
+    respect to composition, and the sets `\hom(A, B)` are pairwise
+    disjoint.
+
+    This class knows nothing about its objects and morphisms.
+    Concrete cases of (abstract) categories should be implemented as
+    classes derived from this one.
+
+    Certain instances of :class:`Diagram` can be asserted to be
+    commutative in a :class:`Category` by supplying the argument
+    ``commutative_diagrams`` in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+    >>> from sympy import FiniteSet
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> K = Category("K", commutative_diagrams=[d])
+    >>> K.commutative_diagrams == FiniteSet(d)
+    True
+
+    See Also
+    ========
+
+    Diagram
+    """
+    def __new__(cls, name, objects=EmptySet, commutative_diagrams=EmptySet):
+        if not name:
+            raise ValueError("A Category cannot have an empty name.")
+
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        if not isinstance(objects, Class):
+            objects = Class(objects)
+
+        new_category = Basic.__new__(cls, name, objects,
+                                     FiniteSet(*commutative_diagrams))
+        return new_category
+
+    @property
+    def name(self):
+        """
+        Returns the name of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Category
+        >>> K = Category("K")
+        >>> K.name
+        'K'
+
+        """
+        return self.args[0].name
+
+    @property
+    def objects(self):
+        """
+        Returns the class of objects of this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> K = Category("K", FiniteSet(A, B))
+        >>> K.objects
+        Class({Object("A"), Object("B")})
+
+        """
+        return self.args[1]
+
+    @property
+    def commutative_diagrams(self):
+        """
+        Returns the :class:`~.FiniteSet` of diagrams which are known to
+        be commutative in this category.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram, Category
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> K = Category("K", commutative_diagrams=[d])
+        >>> K.commutative_diagrams == FiniteSet(d)
+        True
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        raise NotImplementedError(
+            "hom-sets are not implemented in Category.")
+
+    def all_morphisms(self):
+        raise NotImplementedError(
+            "Obtaining the class of morphisms is not implemented in Category.")
+
+
+class Diagram(Basic):
+    r"""
+    Represents a diagram in a certain category.
+
+    Explanation
+    ===========
+
+    Informally, a diagram is a collection of objects of a category and
+    certain morphisms between them.  A diagram is still a monoid with
+    respect to morphism composition; i.e., identity morphisms, as well
+    as all composites of morphisms included in the diagram belong to
+    the diagram.  For a more formal approach to this notion see
+    [Pare1970].
+
+    The components of composite morphisms are also added to the
+    diagram.  No properties are assigned to such morphisms by default.
+
+    A commutative diagram is often accompanied by a statement of the
+    following kind: "if such morphisms with such properties exist,
+    then such morphisms which such properties exist and the diagram is
+    commutative".  To represent this, an instance of :class:`Diagram`
+    includes a collection of morphisms which are the premises and
+    another collection of conclusions.  ``premises`` and
+    ``conclusions`` associate morphisms belonging to the corresponding
+    categories with the :class:`~.FiniteSet`'s of their properties.
+
+    The set of properties of a composite morphism is the intersection
+    of the sets of properties of its components.  The domain and
+    codomain of a conclusion morphism should be among the domains and
+    codomains of the morphisms listed as the premises of a diagram.
+
+    No checks are carried out of whether the supplied object and
+    morphisms do belong to one and the same category.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy import pprint, default_sort_key
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g])
+    >>> premises_keys = sorted(d.premises.keys(), key=default_sort_key)
+    >>> pprint(premises_keys, use_unicode=False)
+    [g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C]
+    >>> pprint(d.premises, use_unicode=False)
+    {g*f:A-->C: EmptySet, id:A-->A: EmptySet, id:B-->B: EmptySet,
+     id:C-->C: EmptySet, f:A-->B: EmptySet, g:B-->C: EmptySet}
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> pprint(d.conclusions,use_unicode=False)
+    {g*f:A-->C: {unique}}
+
+    References
+    ==========
+
+    [Pare1970] B. Pareigis: Categories and functors.  Academic Press, 1970.
+
+    """
+    @staticmethod
+    def _set_dict_union(dictionary, key, value):
+        """
+        If ``key`` is in ``dictionary``, set the new value of ``key``
+        to be the union between the old value and ``value``.
+        Otherwise, set the value of ``key`` to ``value.
+
+        Returns ``True`` if the key already was in the dictionary and
+        ``False`` otherwise.
+        """
+        if key in dictionary:
+            dictionary[key] = dictionary[key] | value
+            return True
+        else:
+            dictionary[key] = value
+            return False
+
+    @staticmethod
+    def _add_morphism_closure(morphisms, morphism, props, add_identities=True,
+                              recurse_composites=True):
+        """
+        Adds a morphism and its attributes to the supplied dictionary
+        ``morphisms``.  If ``add_identities`` is True, also adds the
+        identity morphisms for the domain and the codomain of
+        ``morphism``.
+        """
+        if not Diagram._set_dict_union(morphisms, morphism, props):
+            # We have just added a new morphism.
+
+            if isinstance(morphism, IdentityMorphism):
+                if props:
+                    # Properties for identity morphisms don't really
+                    # make sense, because very much is known about
+                    # identity morphisms already, so much that they
+                    # are trivial.  Having properties for identity
+                    # morphisms would only be confusing.
+                    raise ValueError(
+                        "Instances of IdentityMorphism cannot have properties.")
+                return
+
+            if add_identities:
+                empty = EmptySet
+
+                id_dom = IdentityMorphism(morphism.domain)
+                id_cod = IdentityMorphism(morphism.codomain)
+
+                Diagram._set_dict_union(morphisms, id_dom, empty)
+                Diagram._set_dict_union(morphisms, id_cod, empty)
+
+            for existing_morphism, existing_props in list(morphisms.items()):
+                new_props = existing_props & props
+                if morphism.domain == existing_morphism.codomain:
+                    left = morphism * existing_morphism
+                    Diagram._set_dict_union(morphisms, left, new_props)
+                if morphism.codomain == existing_morphism.domain:
+                    right = existing_morphism * morphism
+                    Diagram._set_dict_union(morphisms, right, new_props)
+
+            if isinstance(morphism, CompositeMorphism) and recurse_composites:
+                # This is a composite morphism, add its components as
+                # well.
+                empty = EmptySet
+                for component in morphism.components:
+                    Diagram._add_morphism_closure(morphisms, component, empty,
+                                                  add_identities)
+
+    def __new__(cls, *args):
+        """
+        Construct a new instance of Diagram.
+
+        Explanation
+        ===========
+
+        If no arguments are supplied, an empty diagram is created.
+
+        If at least an argument is supplied, ``args[0]`` is
+        interpreted as the premises of the diagram.  If ``args[0]`` is
+        a list, it is interpreted as a list of :class:`Morphism`'s, in
+        which each :class:`Morphism` has an empty set of properties.
+        If ``args[0]`` is a Python dictionary or a :class:`Dict`, it
+        is interpreted as a dictionary associating to some
+        :class:`Morphism`'s some properties.
+
+        If at least two arguments are supplied ``args[1]`` is
+        interpreted as the conclusions of the diagram.  The type of
+        ``args[1]`` is interpreted in exactly the same way as the type
+        of ``args[0]``.  If only one argument is supplied, the diagram
+        has no conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f]
+        {unique}
+
+        """
+        premises = {}
+        conclusions = {}
+
+        # Here we will keep track of the objects which appear in the
+        # premises.
+        objects = EmptySet
+
+        if len(args) >= 1:
+            # We've got some premises in the arguments.
+            premises_arg = args[0]
+
+            if isinstance(premises_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in premises_arg:
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(premises, morphism, empty)
+            elif isinstance(premises_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in premises_arg.items():
+                    objects |= FiniteSet(morphism.domain, morphism.codomain)
+                    Diagram._add_morphism_closure(
+                        premises, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props))
+
+        if len(args) >= 2:
+            # We also have some conclusions.
+            conclusions_arg = args[1]
+
+            if isinstance(conclusions_arg, list):
+                # The user has supplied a list of morphisms, none of
+                # which have any attributes.
+                empty = EmptySet
+
+                for morphism in conclusions_arg:
+                    # Check that no new objects appear in conclusions.
+                    if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                        (sympify(objects.contains(morphism.codomain)) is S.true)):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, empty, add_identities=False,
+                            recurse_composites=False)
+            elif isinstance(conclusions_arg, (dict, Dict)):
+                # The user has supplied a dictionary of morphisms and
+                # their properties.
+                for morphism, props in conclusions_arg.items():
+                    # Check that no new objects appear in conclusions.
+                    if (morphism.domain in objects) and \
+                       (morphism.codomain in objects):
+                        # No need to add identities and recurse
+                        # composites this time.
+                        Diagram._add_morphism_closure(
+                            conclusions, morphism, FiniteSet(*props) if iterable(props) else FiniteSet(props),
+                            add_identities=False, recurse_composites=False)
+
+        return Basic.__new__(cls, Dict(premises), Dict(conclusions), objects)
+
+    @property
+    def premises(self):
+        """
+        Returns the premises of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> id_A = IdentityMorphism(A)
+        >>> id_B = IdentityMorphism(B)
+        >>> d = Diagram([f])
+        >>> print(pretty(d.premises, use_unicode=False))
+        {id:A-->A: EmptySet, id:B-->B: EmptySet, f:A-->B: EmptySet}
+
+        """
+        return self.args[0]
+
+    @property
+    def conclusions(self):
+        """
+        Returns the conclusions of this diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import IdentityMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> IdentityMorphism(A) in d.premises.keys()
+        True
+        >>> g * f in d.premises.keys()
+        True
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d.conclusions[g * f] == FiniteSet("unique")
+        True
+
+        """
+        return self.args[1]
+
+    @property
+    def objects(self):
+        """
+        Returns the :class:`~.FiniteSet` of objects that appear in this
+        diagram.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g])
+        >>> d.objects
+        {Object("A"), Object("B"), Object("C")}
+
+        """
+        return self.args[2]
+
+    def hom(self, A, B):
+        """
+        Returns a 2-tuple of sets of morphisms between objects ``A`` and
+        ``B``: one set of morphisms listed as premises, and the other set
+        of morphisms listed as conclusions.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import pretty
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> print(pretty(d.hom(A, C), use_unicode=False))
+        ({g*f:A-->C}, {g*f:A-->C})
+
+        See Also
+        ========
+        Object, Morphism
+        """
+        premises = EmptySet
+        conclusions = EmptySet
+
+        for morphism in self.premises.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                premises |= FiniteSet(morphism)
+        for morphism in self.conclusions.keys():
+            if (morphism.domain == A) and (morphism.codomain == B):
+                conclusions |= FiniteSet(morphism)
+
+        return (premises, conclusions)
+
+    def is_subdiagram(self, diagram):
+        """
+        Checks whether ``diagram`` is a subdiagram of ``self``.
+        Diagram `D'` is a subdiagram of `D` if all premises
+        (conclusions) of `D'` are contained in the premises
+        (conclusions) of `D`.  The morphisms contained
+        both in `D'` and `D` should have the same properties for `D'`
+        to be a subdiagram of `D`.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {g * f: "unique"})
+        >>> d1 = Diagram([f])
+        >>> d.is_subdiagram(d1)
+        True
+        >>> d1.is_subdiagram(d)
+        False
+        """
+        premises = all((m in self.premises) and
+                       (diagram.premises[m] == self.premises[m])
+                       for m in diagram.premises)
+        if not premises:
+            return False
+
+        conclusions = all((m in self.conclusions) and
+                          (diagram.conclusions[m] == self.conclusions[m])
+                          for m in diagram.conclusions)
+
+        # Premises is surely ``True`` here.
+        return conclusions
+
+    def subdiagram_from_objects(self, objects):
+        """
+        If ``objects`` is a subset of the objects of ``self``, returns
+        a diagram which has as premises all those premises of ``self``
+        which have a domains and codomains in ``objects``, likewise
+        for conclusions.  Properties are preserved.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy import FiniteSet
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"})
+        >>> d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+        >>> d1 == Diagram([f], {f: "unique"})
+        True
+        """
+        if not objects.is_subset(self.objects):
+            raise ValueError(
+                "Supplied objects should all belong to the diagram.")
+
+        new_premises = {}
+        for morphism, props in self.premises.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_premises[morphism] = props
+
+        new_conclusions = {}
+        for morphism, props in self.conclusions.items():
+            if ((sympify(objects.contains(morphism.domain)) is S.true) and
+                (sympify(objects.contains(morphism.codomain)) is S.true)):
+                new_conclusions[morphism] = props
+
+        return Diagram(new_premises, new_conclusions)
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/diagram_drawing.py b/.venv/lib/python3.12/site-packages/sympy/categories/diagram_drawing.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a9b507cd86cf0e633b5abf7a0c9a353740af334
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/categories/diagram_drawing.py
@@ -0,0 +1,2580 @@
+r"""
+This module contains the functionality to arrange the nodes of a
+diagram on an abstract grid, and then to produce a graphical
+representation of the grid.
+
+The currently supported back-ends are Xy-pic [Xypic].
+
+Layout Algorithm
+================
+
+This section provides an overview of the algorithms implemented in
+:class:`DiagramGrid` to lay out diagrams.
+
+The first step of the algorithm is the removal composite and identity
+morphisms which do not have properties in the supplied diagram.  The
+premises and conclusions of the diagram are then merged.
+
+The generic layout algorithm begins with the construction of the
+"skeleton" of the diagram.  The skeleton is an undirected graph which
+has the objects of the diagram as vertices and has an (undirected)
+edge between each pair of objects between which there exist morphisms.
+The direction of the morphisms does not matter at this stage.  The
+skeleton also includes an edge between each pair of vertices `A` and
+`C` such that there exists an object `B` which is connected via
+a morphism to `A`, and via a morphism to `C`.
+
+The skeleton constructed in this way has the property that every
+object is a vertex of a triangle formed by three edges of the
+skeleton.  This property lies at the base of the generic layout
+algorithm.
+
+After the skeleton has been constructed, the algorithm lists all
+triangles which can be formed.  Note that some triangles will not have
+all edges corresponding to morphisms which will actually be drawn.
+Triangles which have only one edge or less which will actually be
+drawn are immediately discarded.
+
+The list of triangles is sorted according to the number of edges which
+correspond to morphisms, then the triangle with the least number of such
+edges is selected.  One of such edges is picked and the corresponding
+objects are placed horizontally, on a grid.  This edge is recorded to
+be in the fringe.  The algorithm then finds a "welding" of a triangle
+to the fringe.  A welding is an edge in the fringe where a triangle
+could be attached.  If the algorithm succeeds in finding such a
+welding, it adds to the grid that vertex of the triangle which was not
+yet included in any edge in the fringe and records the two new edges in
+the fringe.  This process continues iteratively until all objects of
+the diagram has been placed or until no more weldings can be found.
+
+An edge is only removed from the fringe when a welding to this edge
+has been found, and there is no room around this edge to place
+another vertex.
+
+When no more weldings can be found, but there are still triangles
+left, the algorithm searches for a possibility of attaching one of the
+remaining triangles to the existing structure by a vertex.  If such a
+possibility is found, the corresponding edge of the found triangle is
+placed in the found space and the iterative process of welding
+triangles restarts.
+
+When logical groups are supplied, each of these groups is laid out
+independently.  Then a diagram is constructed in which groups are
+objects and any two logical groups between which there exist morphisms
+are connected via a morphism.  This diagram is laid out.  Finally,
+the grid which includes all objects of the initial diagram is
+constructed by replacing the cells which contain logical groups with
+the corresponding laid out grids, and by correspondingly expanding the
+rows and columns.
+
+The sequential layout algorithm begins by constructing the
+underlying undirected graph defined by the morphisms obtained after
+simplifying premises and conclusions and merging them (see above).
+The vertex with the minimal degree is then picked up and depth-first
+search is started from it.  All objects which are located at distance
+`n` from the root in the depth-first search tree, are positioned in
+the `n`-th column of the resulting grid.  The sequential layout will
+therefore attempt to lay the objects out along a line.
+
+References
+==========
+
+.. [Xypic] https://xy-pic.sourceforge.net/
+
+"""
+from sympy.categories import (CompositeMorphism, IdentityMorphism,
+                              NamedMorphism, Diagram)
+from sympy.core import Dict, Symbol, default_sort_key
+from sympy.printing.latex import latex
+from sympy.sets import FiniteSet
+from sympy.utilities.iterables import iterable
+from sympy.utilities.decorator import doctest_depends_on
+
+from itertools import chain
+
+
+__doctest_requires__ = {('preview_diagram',): 'pyglet'}
+
+
+class _GrowableGrid:
+    """
+    Holds a growable grid of objects.
+
+    Explanation
+    ===========
+
+    It is possible to append or prepend a row or a column to the grid
+    using the corresponding methods.  Prepending rows or columns has
+    the effect of changing the coordinates of the already existing
+    elements.
+
+    This class currently represents a naive implementation of the
+    functionality with little attempt at optimisation.
+    """
+    def __init__(self, width, height):
+        self._width = width
+        self._height = height
+
+        self._array = [[None for j in range(width)] for i in range(height)]
+
+    @property
+    def width(self):
+        return self._width
+
+    @property
+    def height(self):
+        return self._height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        return self._array[i][j]
+
+    def __setitem__(self, i_j, newvalue):
+        """
+        Sets the element located at in the i-th line and j-th
+        column.
+        """
+        i, j = i_j
+        self._array[i][j] = newvalue
+
+    def append_row(self):
+        """
+        Appends an empty row to the grid.
+        """
+        self._height += 1
+        self._array.append([None for j in range(self._width)])
+
+    def append_column(self):
+        """
+        Appends an empty column to the grid.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].append(None)
+
+    def prepend_row(self):
+        """
+        Prepends the grid with an empty row.
+        """
+        self._height += 1
+        self._array.insert(0, [None for j in range(self._width)])
+
+    def prepend_column(self):
+        """
+        Prepends the grid with an empty column.
+        """
+        self._width += 1
+        for i in range(self._height):
+            self._array[i].insert(0, None)
+
+
+class DiagramGrid:
+    r"""
+    Constructs and holds the fitting of the diagram into a grid.
+
+    Explanation
+    ===========
+
+    The mission of this class is to analyse the structure of the
+    supplied diagram and to place its objects on a grid such that,
+    when the objects and the morphisms are actually drawn, the diagram
+    would be "readable", in the sense that there will not be many
+    intersections of moprhisms.  This class does not perform any
+    actual drawing.  It does strive nevertheless to offer sufficient
+    metadata to draw a diagram.
+
+    Consider the following simple diagram.
+
+    >>> from sympy.categories import Object, NamedMorphism
+    >>> from sympy.categories import Diagram, DiagramGrid
+    >>> from sympy import pprint
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g])
+
+    The simplest way to have a diagram laid out is the following:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> (grid.width, grid.height)
+    (2, 2)
+    >>> pprint(grid)
+    A  B
+    
+       C
+
+    Sometimes one sees the diagram as consisting of logical groups.
+    One can advise ``DiagramGrid`` as to such groups by employing the
+    ``groups`` keyword argument.
+
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+
+    Lay it out with generic layout:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B  D
+    
+       C
+
+    Now, we can group the objects `A` and `D` to have them near one
+    another:
+
+    >>> grid = DiagramGrid(diagram, groups=[[A, D], B, C])
+    >>> pprint(grid)
+    B     C
+    
+    A  D
+
+    Note how the positioning of the other objects changes.
+
+    Further indications can be supplied to the constructor of
+    :class:`DiagramGrid` using keyword arguments.  The currently
+    supported hints are explained in the following paragraphs.
+
+    :class:`DiagramGrid` does not automatically guess which layout
+    would suit the supplied diagram better.  Consider, for example,
+    the following linear diagram:
+
+    >>> E = Object("E")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> h = NamedMorphism(C, D, "h")
+    >>> i = NamedMorphism(D, E, "i")
+    >>> diagram = Diagram([f, g, h, i])
+
+    When laid out with the generic layout, it does not get to look
+    linear:
+
+    >>> grid = DiagramGrid(diagram)
+    >>> pprint(grid)
+    A  B
+    
+       C  D
+    
+          E
+
+    To get it laid out in a line, use ``layout="sequential"``:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential")
+    >>> pprint(grid)
+    A  B  C  D  E
+
+    One may sometimes need to transpose the resulting layout.  While
+    this can always be done by hand, :class:`DiagramGrid` provides a
+    hint for that purpose:
+
+    >>> grid = DiagramGrid(diagram, layout="sequential", transpose=True)
+    >>> pprint(grid)
+    A
+    
+    B
+    
+    C
+    
+    D
+    
+    E
+
+    Separate hints can also be provided for each group.  For an
+    example, refer to ``tests/test_drawing.py``, and see the different
+    ways in which the five lemma [FiveLemma] can be laid out.
+
+    See Also
+    ========
+
+    Diagram
+
+    References
+    ==========
+
+    .. [FiveLemma] https://en.wikipedia.org/wiki/Five_lemma
+    """
+    @staticmethod
+    def _simplify_morphisms(morphisms):
+        """
+        Given a dictionary mapping morphisms to their properties,
+        returns a new dictionary in which there are no morphisms which
+        do not have properties, and which are compositions of other
+        morphisms included in the dictionary.  Identities are dropped
+        as well.
+        """
+        newmorphisms = {}
+        for morphism, props in morphisms.items():
+            if isinstance(morphism, CompositeMorphism) and not props:
+                continue
+            elif isinstance(morphism, IdentityMorphism):
+                continue
+            else:
+                newmorphisms[morphism] = props
+        return newmorphisms
+
+    @staticmethod
+    def _merge_premises_conclusions(premises, conclusions):
+        """
+        Given two dictionaries of morphisms and their properties,
+        produces a single dictionary which includes elements from both
+        dictionaries.  If a morphism has some properties in premises
+        and also in conclusions, the properties in conclusions take
+        priority.
+        """
+        return dict(chain(premises.items(), conclusions.items()))
+
+    @staticmethod
+    def _juxtapose_edges(edge1, edge2):
+        """
+        If ``edge1`` and ``edge2`` have precisely one common endpoint,
+        returns an edge which would form a triangle with ``edge1`` and
+        ``edge2``.
+
+        If ``edge1`` and ``edge2`` do not have a common endpoint,
+        returns ``None``.
+
+        If ``edge1`` and ``edge`` are the same edge, returns ``None``.
+        """
+        intersection = edge1 & edge2
+        if len(intersection) != 1:
+            # The edges either have no common points or are equal.
+            return None
+
+        # The edges have a common endpoint.  Extract the different
+        # endpoints and set up the new edge.
+        return (edge1 - intersection) | (edge2 - intersection)
+
+    @staticmethod
+    def _add_edge_append(dictionary, edge, elem):
+        """
+        If ``edge`` is not in ``dictionary``, adds ``edge`` to the
+        dictionary and sets its value to ``[elem]``.  Otherwise
+        appends ``elem`` to the value of existing entry.
+
+        Note that edges are undirected, thus `(A, B) = (B, A)`.
+        """
+        if edge in dictionary:
+            dictionary[edge].append(elem)
+        else:
+            dictionary[edge] = [elem]
+
+    @staticmethod
+    def _build_skeleton(morphisms):
+        """
+        Creates a dictionary which maps edges to corresponding
+        morphisms.  Thus for a morphism `f:A\rightarrow B`, the edge
+        `(A, B)` will be associated with `f`.  This function also adds
+        to the list those edges which are formed by juxtaposition of
+        two edges already in the list.  These new edges are not
+        associated with any morphism and are only added to assure that
+        the diagram can be decomposed into triangles.
+        """
+        edges = {}
+        # Create edges for morphisms.
+        for morphism in morphisms:
+            DiagramGrid._add_edge_append(
+                edges, frozenset([morphism.domain, morphism.codomain]), morphism)
+
+        # Create new edges by juxtaposing existing edges.
+        edges1 = dict(edges)
+        for w in edges1:
+            for v in edges1:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv not in edges:
+                    edges[wv] = []
+
+        return edges
+
+    @staticmethod
+    def _list_triangles(edges):
+        """
+        Builds the set of triangles formed by the supplied edges.  The
+        triangles are arbitrary and need not be commutative.  A
+        triangle is a set that contains all three of its sides.
+        """
+        triangles = set()
+
+        for w in edges:
+            for v in edges:
+                wv = DiagramGrid._juxtapose_edges(w, v)
+                if wv and wv in edges:
+                    triangles.add(frozenset([w, v, wv]))
+
+        return triangles
+
+    @staticmethod
+    def _drop_redundant_triangles(triangles, skeleton):
+        """
+        Returns a list which contains only those triangles who have
+        morphisms associated with at least two edges.
+        """
+        return [tri for tri in triangles
+                if len([e for e in tri if skeleton[e]]) >= 2]
+
+    @staticmethod
+    def _morphism_length(morphism):
+        """
+        Returns the length of a morphism.  The length of a morphism is
+        the number of components it consists of.  A non-composite
+        morphism is of length 1.
+        """
+        if isinstance(morphism, CompositeMorphism):
+            return len(morphism.components)
+        else:
+            return 1
+
+    @staticmethod
+    def _compute_triangle_min_sizes(triangles, edges):
+        r"""
+        Returns a dictionary mapping triangles to their minimal sizes.
+        The minimal size of a triangle is the sum of maximal lengths
+        of morphisms associated to the sides of the triangle.  The
+        length of a morphism is the number of components it consists
+        of.  A non-composite morphism is of length 1.
+
+        Sorting triangles by this metric attempts to address two
+        aspects of layout.  For triangles with only simple morphisms
+        in the edge, this assures that triangles with all three edges
+        visible will get typeset after triangles with less visible
+        edges, which sometimes minimizes the necessity in diagonal
+        arrows.  For triangles with composite morphisms in the edges,
+        this assures that objects connected with shorter morphisms
+        will be laid out first, resulting the visual proximity of
+        those objects which are connected by shorter morphisms.
+        """
+        triangle_sizes = {}
+        for triangle in triangles:
+            size = 0
+            for e in triangle:
+                morphisms = edges[e]
+                if morphisms:
+                    size += max(DiagramGrid._morphism_length(m)
+                                for m in morphisms)
+            triangle_sizes[triangle] = size
+        return triangle_sizes
+
+    @staticmethod
+    def _triangle_objects(triangle):
+        """
+        Given a triangle, returns the objects included in it.
+        """
+        # A triangle is a frozenset of three two-element frozensets
+        # (the edges).  This chains the three edges together and
+        # creates a frozenset from the iterator, thus producing a
+        # frozenset of objects of the triangle.
+        return frozenset(chain(*tuple(triangle)))
+
+    @staticmethod
+    def _other_vertex(triangle, edge):
+        """
+        Given a triangle and an edge of it, returns the vertex which
+        opposes the edge.
+        """
+        # This gets the set of objects of the triangle and then
+        # subtracts the set of objects employed in ``edge`` to get the
+        # vertex opposite to ``edge``.
+        return list(DiagramGrid._triangle_objects(triangle) - set(edge))[0]
+
+    @staticmethod
+    def _empty_point(pt, grid):
+        """
+        Checks if the cell at coordinates ``pt`` is either empty or
+        out of the bounds of the grid.
+        """
+        if (pt[0] < 0) or (pt[1] < 0) or \
+           (pt[0] >= grid.height) or (pt[1] >= grid.width):
+            return True
+        return grid[pt] is None
+
+    @staticmethod
+    def _put_object(coords, obj, grid, fringe):
+        """
+        Places an object at the coordinate ``cords`` in ``grid``,
+        growing the grid and updating ``fringe``, if necessary.
+        Returns (0, 0) if no row or column has been prepended, (1, 0)
+        if a row was prepended, (0, 1) if a column was prepended and
+        (1, 1) if both a column and a row were prepended.
+        """
+        (i, j) = coords
+        offset = (0, 0)
+        if i == -1:
+            grid.prepend_row()
+            i = 0
+            offset = (1, 0)
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1 + 1, j1), (i2 + 1, j2))
+        elif i == grid.height:
+            grid.append_row()
+
+        if j == -1:
+            j = 0
+            offset = (offset[0], 1)
+            grid.prepend_column()
+            for k in range(len(fringe)):
+                ((i1, j1), (i2, j2)) = fringe[k]
+                fringe[k] = ((i1, j1 + 1), (i2, j2 + 1))
+        elif j == grid.width:
+            grid.append_column()
+
+        grid[i, j] = obj
+        return offset
+
+    @staticmethod
+    def _choose_target_cell(pt1, pt2, edge, obj, skeleton, grid):
+        """
+        Given two points, ``pt1`` and ``pt2``, and the welding edge
+        ``edge``, chooses one of the two points to place the opposing
+        vertex ``obj`` of the triangle.  If neither of this points
+        fits, returns ``None``.
+        """
+        pt1_empty = DiagramGrid._empty_point(pt1, grid)
+        pt2_empty = DiagramGrid._empty_point(pt2, grid)
+
+        if pt1_empty and pt2_empty:
+            # Both cells are empty.  Of these two, choose that cell
+            # which will assure that a visible edge of the triangle
+            # will be drawn perpendicularly to the current welding
+            # edge.
+
+            A = grid[edge[0]]
+
+            if skeleton.get(frozenset([A, obj])):
+                return pt1
+            else:
+                return pt2
+        if pt1_empty:
+            return pt1
+        elif pt2_empty:
+            return pt2
+        else:
+            return None
+
+    @staticmethod
+    def _find_triangle_to_weld(triangles, fringe, grid):
+        """
+        Finds, if possible, a triangle and an edge in the ``fringe`` to
+        which the triangle could be attached.  Returns the tuple
+        containing the triangle and the index of the corresponding
+        edge in the ``fringe``.
+
+        This function relies on the fact that objects are unique in
+        the diagram.
+        """
+        for triangle in triangles:
+            for (a, b) in fringe:
+                if frozenset([grid[a], grid[b]]) in triangle:
+                    return (triangle, (a, b))
+        return None
+
+    @staticmethod
+    def _weld_triangle(tri, welding_edge, fringe, grid, skeleton):
+        """
+        If possible, welds the triangle ``tri`` to ``fringe`` and
+        returns ``False``.  If this method encounters a degenerate
+        situation in the fringe and corrects it such that a restart of
+        the search is required, it returns ``True`` (which means that
+        a restart in finding triangle weldings is required).
+
+        A degenerate situation is a situation when an edge listed in
+        the fringe does not belong to the visual boundary of the
+        diagram.
+        """
+        a, b = welding_edge
+        target_cell = None
+
+        obj = DiagramGrid._other_vertex(tri, (grid[a], grid[b]))
+
+        # We now have a triangle and an edge where it can be welded to
+        # the fringe.  Decide where to place the other vertex of the
+        # triangle and check for degenerate situations en route.
+
+        if (abs(a[0] - b[0]) == 1) and (abs(a[1] - b[1]) == 1):
+            # A diagonal edge.
+            target_cell = (a[0], b[1])
+            if grid[target_cell]:
+                # That cell is already occupied.
+                target_cell = (b[0], a[1])
+
+                if grid[target_cell]:
+                    # Degenerate situation, this edge is not
+                    # on the actual fringe.  Correct the
+                    # fringe and go on.
+                    fringe.remove((a, b))
+                    return True
+        elif a[0] == b[0]:
+            # A horizontal edge.  We first attempt to build the
+            # triangle in the downward direction.
+
+            down_left = a[0] + 1, a[1]
+            down_right = a[0] + 1, b[1]
+
+            target_cell = DiagramGrid._choose_target_cell(
+                down_left, down_right, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room below this edge.  Check above.
+                up_left = a[0] - 1, a[1]
+                up_right = a[0] - 1, b[1]
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    up_left, up_right, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+        elif a[1] == b[1]:
+            # A vertical edge.  We will attempt to place the other
+            # vertex of the triangle to the right of this edge.
+            right_up = a[0], a[1] + 1
+            right_down = b[0], a[1] + 1
+
+            target_cell = DiagramGrid._choose_target_cell(
+                right_up, right_down, (a, b), obj, skeleton, grid)
+
+            if not target_cell:
+                # No room to the left.  See what's to the right.
+                left_up = a[0], a[1] - 1
+                left_down = b[0], a[1] - 1
+
+                target_cell = DiagramGrid._choose_target_cell(
+                    left_up, left_down, (a, b), obj, skeleton, grid)
+
+                if not target_cell:
+                    # This edge is not in the fringe, remove it
+                    # and restart.
+                    fringe.remove((a, b))
+                    return True
+
+        # We now know where to place the other vertex of the
+        # triangle.
+        offset = DiagramGrid._put_object(target_cell, obj, grid, fringe)
+
+        # Take care of the displacement of coordinates if a row or
+        # a column was prepended.
+        target_cell = (target_cell[0] + offset[0],
+                       target_cell[1] + offset[1])
+        a = (a[0] + offset[0], a[1] + offset[1])
+        b = (b[0] + offset[0], b[1] + offset[1])
+
+        fringe.extend([(a, target_cell), (b, target_cell)])
+
+        # No restart is required.
+        return False
+
+    @staticmethod
+    def _triangle_key(tri, triangle_sizes):
+        """
+        Returns a key for the supplied triangle.  It should be the
+        same independently of the hash randomisation.
+        """
+        objects = sorted(
+            DiagramGrid._triangle_objects(tri), key=default_sort_key)
+        return (triangle_sizes[tri], default_sort_key(objects))
+
+    @staticmethod
+    def _pick_root_edge(tri, skeleton):
+        """
+        For a given triangle always picks the same root edge.  The
+        root edge is the edge that will be placed first on the grid.
+        """
+        candidates = [sorted(e, key=default_sort_key)
+                      for e in tri if skeleton[e]]
+        sorted_candidates = sorted(candidates, key=default_sort_key)
+        # Don't forget to assure the proper ordering of the vertices
+        # in this edge.
+        return tuple(sorted(sorted_candidates[0], key=default_sort_key))
+
+    @staticmethod
+    def _drop_irrelevant_triangles(triangles, placed_objects):
+        """
+        Returns only those triangles whose set of objects is not
+        completely included in ``placed_objects``.
+        """
+        return [tri for tri in triangles if not placed_objects.issuperset(
+            DiagramGrid._triangle_objects(tri))]
+
+    @staticmethod
+    def _grow_pseudopod(triangles, fringe, grid, skeleton, placed_objects):
+        """
+        Starting from an object in the existing structure on the ``grid``,
+        adds an edge to which a triangle from ``triangles`` could be
+        welded.  If this method has found a way to do so, it returns
+        the object it has just added.
+
+        This method should be applied when ``_weld_triangle`` cannot
+        find weldings any more.
+        """
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if not obj:
+                    continue
+
+                # Here we need to choose a triangle which has only
+                # ``obj`` in common with the existing structure.  The
+                # situations when this is not possible should be
+                # handled elsewhere.
+
+                def good_triangle(tri):
+                    objs = DiagramGrid._triangle_objects(tri)
+                    return obj in objs and \
+                        placed_objects & (objs - {obj}) == set()
+
+                tris = [tri for tri in triangles if good_triangle(tri)]
+                if not tris:
+                    # This object is not interesting.
+                    continue
+
+                # Pick the "simplest" of the triangles which could be
+                # attached.  Remember that the list of triangles is
+                # sorted according to their "simplicity" (see
+                # _compute_triangle_min_sizes for the metric).
+                #
+                # Note that ``tris`` are sequentially built from
+                # ``triangles``, so we don't have to worry about hash
+                # randomisation.
+                tri = tris[0]
+
+                # We have found a triangle which could be attached to
+                # the existing structure by a vertex.
+
+                candidates = sorted([e for e in tri if skeleton[e]],
+                                    key=lambda e: FiniteSet(*e).sort_key())
+                edges = [e for e in candidates if obj in e]
+
+                # Note that a meaningful edge (i.e., and edge that is
+                # associated with a morphism) containing ``obj``
+                # always exists.  That's because all triangles are
+                # guaranteed to have at least two meaningful edges.
+                # See _drop_redundant_triangles.
+
+                # Get the object at the other end of the edge.
+                edge = edges[0]
+                other_obj = tuple(edge - frozenset([obj]))[0]
+
+                # Now check for free directions.  When checking for
+                # free directions, prefer the horizontal and vertical
+                # directions.
+                neighbours = [(i - 1, j), (i, j + 1), (i + 1, j), (i, j - 1),
+                              (i - 1, j - 1), (i - 1, j + 1), (i + 1, j - 1), (i + 1, j + 1)]
+
+                for pt in neighbours:
+                    if DiagramGrid._empty_point(pt, grid):
+                        # We have a found a place to grow the
+                        # pseudopod into.
+                        offset = DiagramGrid._put_object(
+                            pt, other_obj, grid, fringe)
+
+                        i += offset[0]
+                        j += offset[1]
+                        pt = (pt[0] + offset[0], pt[1] + offset[1])
+                        fringe.append(((i, j), pt))
+
+                        return other_obj
+
+        # This diagram is actually cooler that I can handle.  Fail cowardly.
+        return None
+
+    @staticmethod
+    def _handle_groups(diagram, groups, merged_morphisms, hints):
+        """
+        Given the slightly preprocessed morphisms of the diagram,
+        produces a grid laid out according to ``groups``.
+
+        If a group has hints, it is laid out with those hints only,
+        without any influence from ``hints``.  Otherwise, it is laid
+        out with ``hints``.
+        """
+        def lay_out_group(group, local_hints):
+            """
+            If ``group`` is a set of objects, uses a ``DiagramGrid``
+            to lay it out and returns the grid.  Otherwise returns the
+            object (i.e., ``group``).  If ``local_hints`` is not
+            empty, it is supplied to ``DiagramGrid`` as the dictionary
+            of hints.  Otherwise, the ``hints`` argument of
+            ``_handle_groups`` is used.
+            """
+            if isinstance(group, FiniteSet):
+                # Set up the corresponding object-to-group
+                # mappings.
+                for obj in group:
+                    obj_groups[obj] = group
+
+                # Lay out the current group.
+                if local_hints:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **local_hints)
+                else:
+                    groups_grids[group] = DiagramGrid(
+                        diagram.subdiagram_from_objects(group), **hints)
+            else:
+                obj_groups[group] = group
+
+        def group_to_finiteset(group):
+            """
+            Converts ``group`` to a :class:``FiniteSet`` if it is an
+            iterable.
+            """
+            if iterable(group):
+                return FiniteSet(*group)
+            else:
+                return group
+
+        obj_groups = {}
+        groups_grids = {}
+
+        # We would like to support various containers to represent
+        # groups.  To achieve that, before laying each group out, it
+        # should be converted to a FiniteSet, because that is what the
+        # following code expects.
+
+        if isinstance(groups, (dict, Dict)):
+            finiteset_groups = {}
+            for group, local_hints in groups.items():
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups[finiteset_group] = local_hints
+                lay_out_group(group, local_hints)
+            groups = finiteset_groups
+        else:
+            finiteset_groups = []
+            for group in groups:
+                finiteset_group = group_to_finiteset(group)
+                finiteset_groups.append(finiteset_group)
+                lay_out_group(finiteset_group, None)
+            groups = finiteset_groups
+
+        new_morphisms = []
+        for morphism in merged_morphisms:
+            dom = obj_groups[morphism.domain]
+            cod = obj_groups[morphism.codomain]
+            # Note that we are not really interested in morphisms
+            # which do not employ two different groups, because
+            # these do not influence the layout.
+            if dom != cod:
+                # These are essentially unnamed morphisms; they are
+                # not going to mess in the final layout.  By giving
+                # them the same names, we avoid unnecessary
+                # duplicates.
+                new_morphisms.append(NamedMorphism(dom, cod, "dummy"))
+
+        # Lay out the new diagram.  Since these are dummy morphisms,
+        # properties and conclusions are irrelevant.
+        top_grid = DiagramGrid(Diagram(new_morphisms))
+
+        # We now have to substitute the groups with the corresponding
+        # grids, laid out at the beginning of this function.  Compute
+        # the size of each row and column in the grid, so that all
+        # nested grids fit.
+
+        def group_size(group):
+            """
+            For the supplied group (or object, eventually), returns
+            the size of the cell that will hold this group (object).
+            """
+            if group in groups_grids:
+                grid = groups_grids[group]
+                return (grid.height, grid.width)
+            else:
+                return (1, 1)
+
+        row_heights = [max(group_size(top_grid[i, j])[0]
+                           for j in range(top_grid.width))
+                       for i in range(top_grid.height)]
+
+        column_widths = [max(group_size(top_grid[i, j])[1]
+                             for i in range(top_grid.height))
+                         for j in range(top_grid.width)]
+
+        grid = _GrowableGrid(sum(column_widths), sum(row_heights))
+
+        real_row = 0
+        real_column = 0
+        for logical_row in range(top_grid.height):
+            for logical_column in range(top_grid.width):
+                obj = top_grid[logical_row, logical_column]
+
+                if obj in groups_grids:
+                    # This is a group.  Copy the corresponding grid in
+                    # place.
+                    local_grid = groups_grids[obj]
+                    for i in range(local_grid.height):
+                        for j in range(local_grid.width):
+                            grid[real_row + i,
+                                real_column + j] = local_grid[i, j]
+                else:
+                    # This is an object.  Just put it there.
+                    grid[real_row, real_column] = obj
+
+                real_column += column_widths[logical_column]
+            real_column = 0
+            real_row += row_heights[logical_row]
+
+        return grid
+
+    @staticmethod
+    def _generic_layout(diagram, merged_morphisms):
+        """
+        Produces the generic layout for the supplied diagram.
+        """
+        all_objects = set(diagram.objects)
+        if len(all_objects) == 1:
+            # There only one object in the diagram, just put in on 1x1
+            # grid.
+            grid = _GrowableGrid(1, 1)
+            grid[0, 0] = tuple(all_objects)[0]
+            return grid
+
+        skeleton = DiagramGrid._build_skeleton(merged_morphisms)
+
+        grid = _GrowableGrid(2, 1)
+
+        if len(skeleton) == 1:
+            # This diagram contains only one morphism.  Draw it
+            # horizontally.
+            objects = sorted(all_objects, key=default_sort_key)
+            grid[0, 0] = objects[0]
+            grid[0, 1] = objects[1]
+
+            return grid
+
+        triangles = DiagramGrid._list_triangles(skeleton)
+        triangles = DiagramGrid._drop_redundant_triangles(triangles, skeleton)
+        triangle_sizes = DiagramGrid._compute_triangle_min_sizes(
+            triangles, skeleton)
+
+        triangles = sorted(triangles, key=lambda tri:
+                           DiagramGrid._triangle_key(tri, triangle_sizes))
+
+        # Place the first edge on the grid.
+        root_edge = DiagramGrid._pick_root_edge(triangles[0], skeleton)
+        grid[0, 0], grid[0, 1] = root_edge
+        fringe = [((0, 0), (0, 1))]
+
+        # Record which objects we now have on the grid.
+        placed_objects = set(root_edge)
+
+        while placed_objects != all_objects:
+            welding = DiagramGrid._find_triangle_to_weld(
+                triangles, fringe, grid)
+
+            if welding:
+                (triangle, welding_edge) = welding
+
+                restart_required = DiagramGrid._weld_triangle(
+                    triangle, welding_edge, fringe, grid, skeleton)
+                if restart_required:
+                    continue
+
+                placed_objects.update(
+                    DiagramGrid._triangle_objects(triangle))
+            else:
+                # No more weldings found.  Try to attach triangles by
+                # vertices.
+                new_obj = DiagramGrid._grow_pseudopod(
+                    triangles, fringe, grid, skeleton, placed_objects)
+
+                if not new_obj:
+                    # No more triangles can be attached, not even by
+                    # the edge.  We will set up a new diagram out of
+                    # what has been left, laid it out independently,
+                    # and then attach it to this one.
+
+                    remaining_objects = all_objects - placed_objects
+
+                    remaining_diagram = diagram.subdiagram_from_objects(
+                        FiniteSet(*remaining_objects))
+                    remaining_grid = DiagramGrid(remaining_diagram)
+
+                    # Now, let's glue ``remaining_grid`` to ``grid``.
+                    final_width = grid.width + remaining_grid.width
+                    final_height = max(grid.height, remaining_grid.height)
+                    final_grid = _GrowableGrid(final_width, final_height)
+
+                    for i in range(grid.width):
+                        for j in range(grid.height):
+                            final_grid[i, j] = grid[i, j]
+
+                    start_j = grid.width
+                    for i in range(remaining_grid.height):
+                        for j in range(remaining_grid.width):
+                            final_grid[i, start_j + j] = remaining_grid[i, j]
+
+                    return final_grid
+
+                placed_objects.add(new_obj)
+
+            triangles = DiagramGrid._drop_irrelevant_triangles(
+                triangles, placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _get_undirected_graph(objects, merged_morphisms):
+        """
+        Given the objects and the relevant morphisms of a diagram,
+        returns the adjacency lists of the underlying undirected
+        graph.
+        """
+        adjlists = {obj: [] for obj in objects}
+
+        for morphism in merged_morphisms:
+            adjlists[morphism.domain].append(morphism.codomain)
+            adjlists[morphism.codomain].append(morphism.domain)
+
+        # Assure that the objects in the adjacency list are always in
+        # the same order.
+        for obj in adjlists.keys():
+            adjlists[obj].sort(key=default_sort_key)
+
+        return adjlists
+
+    @staticmethod
+    def _sequential_layout(diagram, merged_morphisms):
+        r"""
+        Lays out the diagram in "sequential" layout.  This method
+        will attempt to produce a result as close to a line as
+        possible.  For linear diagrams, the result will actually be a
+        line.
+        """
+        objects = diagram.objects
+        sorted_objects = sorted(objects, key=default_sort_key)
+
+        # Set up the adjacency lists of the underlying undirected
+        # graph of ``merged_morphisms``.
+        adjlists = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        root = min(sorted_objects, key=lambda x: len(adjlists[x]))
+        grid = _GrowableGrid(1, 1)
+        grid[0, 0] = root
+
+        placed_objects = {root}
+
+        def place_objects(pt, placed_objects):
+            """
+            Does depth-first search in the underlying graph of the
+            diagram and places the objects en route.
+            """
+            # We will start placing new objects from here.
+            new_pt = (pt[0], pt[1] + 1)
+
+            for adjacent_obj in adjlists[grid[pt]]:
+                if adjacent_obj in placed_objects:
+                    # This object has already been placed.
+                    continue
+
+                DiagramGrid._put_object(new_pt, adjacent_obj, grid, [])
+                placed_objects.add(adjacent_obj)
+                placed_objects.update(place_objects(new_pt, placed_objects))
+
+                new_pt = (new_pt[0] + 1, new_pt[1])
+
+            return placed_objects
+
+        place_objects((0, 0), placed_objects)
+
+        return grid
+
+    @staticmethod
+    def _drop_inessential_morphisms(merged_morphisms):
+        r"""
+        Removes those morphisms which should appear in the diagram,
+        but which have no relevance to object layout.
+
+        Currently this removes "loop" morphisms: the non-identity
+        morphisms with the same domains and codomains.
+        """
+        morphisms = [m for m in merged_morphisms if m.domain != m.codomain]
+        return morphisms
+
+    @staticmethod
+    def _get_connected_components(objects, merged_morphisms):
+        """
+        Given a container of morphisms, returns a list of connected
+        components formed by these morphisms.  A connected component
+        is represented by a diagram consisting of the corresponding
+        morphisms.
+        """
+        component_index = {}
+        for o in objects:
+            component_index[o] = None
+
+        # Get the underlying undirected graph of the diagram.
+        adjlist = DiagramGrid._get_undirected_graph(objects, merged_morphisms)
+
+        def traverse_component(object, current_index):
+            """
+            Does a depth-first search traversal of the component
+            containing ``object``.
+            """
+            component_index[object] = current_index
+            for o in adjlist[object]:
+                if component_index[o] is None:
+                    traverse_component(o, current_index)
+
+        # Traverse all components.
+        current_index = 0
+        for o in adjlist:
+            if component_index[o] is None:
+                traverse_component(o, current_index)
+                current_index += 1
+
+        # List the objects of the components.
+        component_objects = [[] for i in range(current_index)]
+        for o, idx in component_index.items():
+            component_objects[idx].append(o)
+
+        # Finally, list the morphisms belonging to each component.
+        #
+        # Note: If some objects are isolated, they will not get any
+        # morphisms at this stage, and since the layout algorithm
+        # relies, we are essentially going to lose this object.
+        # Therefore, check if there are isolated objects and, for each
+        # of them, provide the trivial identity morphism.  It will get
+        # discarded later, but the object will be there.
+
+        component_morphisms = []
+        for component in component_objects:
+            current_morphisms = {}
+            for m in merged_morphisms:
+                if (m.domain in component) and (m.codomain in component):
+                    current_morphisms[m] = merged_morphisms[m]
+
+            if len(component) == 1:
+                # Let's add an identity morphism, for the sake of
+                # surely having morphisms in this component.
+                current_morphisms[IdentityMorphism(component[0])] = FiniteSet()
+
+            component_morphisms.append(Diagram(current_morphisms))
+
+        return component_morphisms
+
+    def __init__(self, diagram, groups=None, **hints):
+        premises = DiagramGrid._simplify_morphisms(diagram.premises)
+        conclusions = DiagramGrid._simplify_morphisms(diagram.conclusions)
+        all_merged_morphisms = DiagramGrid._merge_premises_conclusions(
+            premises, conclusions)
+        merged_morphisms = DiagramGrid._drop_inessential_morphisms(
+            all_merged_morphisms)
+
+        # Store the merged morphisms for later use.
+        self._morphisms = all_merged_morphisms
+
+        components = DiagramGrid._get_connected_components(
+            diagram.objects, all_merged_morphisms)
+
+        if groups and (groups != diagram.objects):
+            # Lay out the diagram according to the groups.
+            self._grid = DiagramGrid._handle_groups(
+                diagram, groups, merged_morphisms, hints)
+        elif len(components) > 1:
+            # Note that we check for connectedness _before_ checking
+            # the layout hints because the layout strategies don't
+            # know how to deal with disconnected diagrams.
+
+            # The diagram is disconnected.  Lay out the components
+            # independently.
+            grids = []
+
+            # Sort the components to eventually get the grids arranged
+            # in a fixed, hash-independent order.
+            components = sorted(components, key=default_sort_key)
+
+            for component in components:
+                grid = DiagramGrid(component, **hints)
+                grids.append(grid)
+
+            # Throw the grids together, in a line.
+            total_width = sum(g.width for g in grids)
+            total_height = max(g.height for g in grids)
+
+            grid = _GrowableGrid(total_width, total_height)
+            start_j = 0
+            for g in grids:
+                for i in range(g.height):
+                    for j in range(g.width):
+                        grid[i, start_j + j] = g[i, j]
+
+                start_j += g.width
+
+            self._grid = grid
+        elif "layout" in hints:
+            if hints["layout"] == "sequential":
+                self._grid = DiagramGrid._sequential_layout(
+                    diagram, merged_morphisms)
+        else:
+            self._grid = DiagramGrid._generic_layout(diagram, merged_morphisms)
+
+        if hints.get("transpose"):
+            # Transpose the resulting grid.
+            grid = _GrowableGrid(self._grid.height, self._grid.width)
+            for i in range(self._grid.height):
+                for j in range(self._grid.width):
+                    grid[j, i] = self._grid[i, j]
+            self._grid = grid
+
+    @property
+    def width(self):
+        """
+        Returns the number of columns in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.width
+        2
+
+        """
+        return self._grid.width
+
+    @property
+    def height(self):
+        """
+        Returns the number of rows in this diagram layout.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.height
+        2
+
+        """
+        return self._grid.height
+
+    def __getitem__(self, i_j):
+        """
+        Returns the object placed in the row ``i`` and column ``j``.
+        The indices are 0-based.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> (grid[0, 0], grid[0, 1])
+        (Object("A"), Object("B"))
+        >>> (grid[1, 0], grid[1, 1])
+        (None, Object("C"))
+
+        """
+        i, j = i_j
+        return self._grid[i, j]
+
+    @property
+    def morphisms(self):
+        """
+        Returns those morphisms (and their properties) which are
+        sufficiently meaningful to be drawn.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> grid.morphisms
+        {NamedMorphism(Object("A"), Object("B"), "f"): EmptySet,
+        NamedMorphism(Object("B"), Object("C"), "g"): EmptySet}
+
+        """
+        return self._morphisms
+
+    def __str__(self):
+        """
+        Produces a string representation of this class.
+
+        This method returns a string representation of the underlying
+        list of lists of objects.
+
+        Examples
+        ========
+
+        >>> from sympy.categories import Object, NamedMorphism
+        >>> from sympy.categories import Diagram, DiagramGrid
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g])
+        >>> grid = DiagramGrid(diagram)
+        >>> print(grid)
+        [[Object("A"), Object("B")],
+        [None, Object("C")]]
+
+        """
+        return repr(self._grid._array)
+
+
+class ArrowStringDescription:
+    r"""
+    Stores the information necessary for producing an Xy-pic
+    description of an arrow.
+
+    The principal goal of this class is to abstract away the string
+    representation of an arrow and to also provide the functionality
+    to produce the actual Xy-pic string.
+
+    ``unit`` sets the unit which will be used to specify the amount of
+    curving and other distances.  ``horizontal_direction`` should be a
+    string of ``"r"`` or ``"l"`` specifying the horizontal offset of the
+    target cell of the arrow relatively to the current one.
+    ``vertical_direction`` should  specify the vertical offset using a
+    series of either ``"d"`` or ``"u"``.  ``label_position`` should be
+    either ``"^"``, ``"_"``,  or ``"|"`` to specify that the label should
+    be positioned above the arrow, below the arrow or just over the arrow,
+    in a break.  Note that the notions "above" and "below" are relative
+    to arrow direction.  ``label`` stores the morphism label.
+
+    This works as follows (disregard the yet unexplained arguments):
+
+    >>> from sympy.categories.diagram_drawing import ArrowStringDescription
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar[dr]_{f}
+
+    ``curving`` should be one of ``"^"``, ``"_"`` to specify in which
+    direction the arrow is going to curve. ``curving_amount`` is a number
+    describing how many ``unit``'s the morphism is going to curve:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_{f}
+
+    ``looping_start`` and ``looping_end`` are currently only used for
+    loop morphisms, those which have the same domain and codomain.
+    These two attributes should store a valid Xy-pic direction and
+    specify, correspondingly, the direction the arrow gets out into
+    and the direction the arrow gets back from:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving=None, curving_amount=None,
+    ... looping_start="u", looping_end="l", horizontal_direction="",
+    ... vertical_direction="", label_position="_", label="f")
+    >>> print(str(astr))
+    \ar@(u,l)[]_{f}
+
+    ``label_displacement`` controls how far the arrow label is from
+    the ends of the arrow.  For example, to position the arrow label
+    near the arrow head, use ">":
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.label_displacement = ">"
+    >>> print(str(astr))
+    \ar@/^12mm/[dr]_>{f}
+
+    Finally, ``arrow_style`` is used to specify the arrow style.  To
+    get a dashed arrow, for example, use "{-->}" as arrow style:
+
+    >>> astr = ArrowStringDescription(
+    ... unit="mm", curving="^", curving_amount=12,
+    ... looping_start=None, looping_end=None, horizontal_direction="d",
+    ... vertical_direction="r", label_position="_", label="f")
+    >>> astr.arrow_style = "{-->}"
+    >>> print(str(astr))
+    \ar@/^12mm/@{-->}[dr]_{f}
+
+    Notes
+    =====
+
+    Instances of :class:`ArrowStringDescription` will be constructed
+    by :class:`XypicDiagramDrawer` and provided for further use in
+    formatters.  The user is not expected to construct instances of
+    :class:`ArrowStringDescription` themselves.
+
+    To be able to properly utilise this class, the reader is encouraged
+    to checkout the Xy-pic user guide, available at [Xypic].
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+
+    References
+    ==========
+
+    .. [Xypic] https://xy-pic.sourceforge.net/
+    """
+    def __init__(self, unit, curving, curving_amount, looping_start,
+                 looping_end, horizontal_direction, vertical_direction,
+                 label_position, label):
+        self.unit = unit
+        self.curving = curving
+        self.curving_amount = curving_amount
+        self.looping_start = looping_start
+        self.looping_end = looping_end
+        self.horizontal_direction = horizontal_direction
+        self.vertical_direction = vertical_direction
+        self.label_position = label_position
+        self.label = label
+
+        self.label_displacement = ""
+        self.arrow_style = ""
+
+        # This flag shows that the position of the label of this
+        # morphism was set while typesetting a curved morphism and
+        # should not be modified later.
+        self.forced_label_position = False
+
+    def __str__(self):
+        if self.curving:
+            curving_str = "@/%s%d%s/" % (self.curving, self.curving_amount,
+                                         self.unit)
+        else:
+            curving_str = ""
+
+        if self.looping_start and self.looping_end:
+            looping_str = "@(%s,%s)" % (self.looping_start, self.looping_end)
+        else:
+            looping_str = ""
+
+        if self.arrow_style:
+
+            style_str = "@" + self.arrow_style
+        else:
+            style_str = ""
+
+        return "\\ar%s%s%s[%s%s]%s%s{%s}" % \
+               (curving_str, looping_str, style_str, self.horizontal_direction,
+                self.vertical_direction, self.label_position,
+                self.label_displacement, self.label)
+
+
+class XypicDiagramDrawer:
+    r"""
+    Given a :class:`~.Diagram` and the corresponding
+    :class:`DiagramGrid`, produces the Xy-pic representation of the
+    diagram.
+
+    The most important method in this class is ``draw``.  Consider the
+    following triangle diagram:
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+    To draw this diagram, its objects need to be laid out with a
+    :class:`DiagramGrid`::
+
+    >>> grid = DiagramGrid(diagram)
+
+    Finally, the drawing:
+
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    For further details see the docstring of this method.
+
+    To control the appearance of the arrows, formatters are used.  The
+    dictionary ``arrow_formatters`` maps morphisms to formatter
+    functions.  A formatter is accepts an
+    :class:`ArrowStringDescription` and is allowed to modify any of
+    the arrow properties exposed thereby.  For example, to have all
+    morphisms with the property ``unique`` appear as dashed arrows,
+    and to have their names prepended with `\exists !`, the following
+    should be done:
+
+    >>> def formatter(astr):
+    ...   astr.label = r"\exists !" + astr.label
+    ...   astr.arrow_style = "{-->}"
+    >>> drawer.arrow_formatters["unique"] = formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    To modify the appearance of all arrows in the diagram, set
+    ``default_arrow_formatter``.  For example, to place all morphism
+    labels a little bit farther from the arrow head so that they look
+    more centred, do as follows:
+
+    >>> def default_formatter(astr):
+    ...   astr.label_displacement = "(0.45)"
+    >>> drawer.default_arrow_formatter = default_formatter
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\
+    C &
+    }
+
+    In some diagrams some morphisms are drawn as curved arrows.
+    Consider the following diagram:
+
+    >>> D = Object("D")
+    >>> E = Object("E")
+    >>> h = NamedMorphism(D, A, "h")
+    >>> k = NamedMorphism(D, B, "k")
+    >>> diagram = Diagram([f, g, h, k])
+    >>> grid = DiagramGrid(diagram)
+    >>> drawer = XypicDiagramDrawer()
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\
+    & C &
+    }
+
+    To control how far the morphisms are curved by default, one can
+    use the ``unit`` and ``default_curving_amount`` attributes:
+
+    >>> drawer.unit = "cm"
+    >>> drawer.default_curving_amount = 1
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\
+    & C &
+    }
+
+    In some diagrams, there are multiple curved morphisms between the
+    same two objects.  To control by how much the curving changes
+    between two such successive morphisms, use
+    ``default_curving_step``:
+
+    >>> drawer.default_curving_step = 1
+    >>> h1 = NamedMorphism(A, D, "h1")
+    >>> diagram = Diagram([f, g, h, k, h1])
+    >>> grid = DiagramGrid(diagram)
+    >>> print(drawer.draw(diagram, grid))
+    \xymatrix{
+    A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\
+    & C &
+    }
+
+    The default value of ``default_curving_step`` is 4 units.
+
+    See Also
+    ========
+
+    draw, ArrowStringDescription
+    """
+    def __init__(self):
+        self.unit = "mm"
+        self.default_curving_amount = 3
+        self.default_curving_step = 4
+
+        # This dictionary maps properties to the corresponding arrow
+        # formatters.
+        self.arrow_formatters = {}
+
+        # This is the default arrow formatter which will be applied to
+        # each arrow independently of its properties.
+        self.default_arrow_formatter = None
+
+    @staticmethod
+    def _process_loop_morphism(i, j, grid, morphisms_str_info, object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a loop morphism.  This function is invoked
+        from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        # This is a loop morphism.  Count how many morphisms stick
+        # in each of the four quadrants.  Note that straight
+        # vertical and horizontal morphisms count in two quadrants
+        # at the same time (i.e., a morphism going up counts both
+        # in the first and the second quadrants).
+
+        # The usual numbering (counterclockwise) of quadrants
+        # applies.
+        quadrant = [0, 0, 0, 0]
+
+        obj = grid[i, j]
+
+        for m, m_str_info in morphisms_str_info.items():
+            if (m.domain == obj) and (m.codomain == obj):
+                # That's another loop morphism.  Check how it
+                # loops and mark the corresponding quadrants as
+                # busy.
+                (l_s, l_e) = (m_str_info.looping_start, m_str_info.looping_end)
+
+                if (l_s, l_e) == ("r", "u"):
+                    quadrant[0] += 1
+                elif (l_s, l_e) == ("u", "l"):
+                    quadrant[1] += 1
+                elif (l_s, l_e) == ("l", "d"):
+                    quadrant[2] += 1
+                elif (l_s, l_e) == ("d", "r"):
+                    quadrant[3] += 1
+
+                continue
+            if m.domain == obj:
+                (end_i, end_j) = object_coords[m.codomain]
+                goes_out = True
+            elif m.codomain == obj:
+                (end_i, end_j) = object_coords[m.domain]
+                goes_out = False
+            else:
+                continue
+
+            d_i = end_i - i
+            d_j = end_j - j
+            m_curving = m_str_info.curving
+
+            if (d_i != 0) and (d_j != 0):
+                # This is really a diagonal morphism.  Detect the
+                # quadrant.
+                if (d_i > 0) and (d_j > 0):
+                    quadrant[0] += 1
+                elif (d_i > 0) and (d_j < 0):
+                    quadrant[1] += 1
+                elif (d_i < 0) and (d_j < 0):
+                    quadrant[2] += 1
+                elif (d_i < 0) and (d_j > 0):
+                    quadrant[3] += 1
+            elif d_i == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the upper one and which is
+                # the lower one.
+                if d_j > 0:
+                    if goes_out:
+                        upper_quadrant = 0
+                        lower_quadrant = 3
+                    else:
+                        upper_quadrant = 3
+                        lower_quadrant = 0
+                else:
+                    if goes_out:
+                        upper_quadrant = 2
+                        lower_quadrant = 1
+                    else:
+                        upper_quadrant = 1
+                        lower_quadrant = 2
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[upper_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[lower_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[upper_quadrant] += 1
+                    quadrant[lower_quadrant] += 1
+            elif d_j == 0:
+                # Knowing where the other end of the morphism is
+                # and which way it goes, we now have to decide
+                # which quadrant is now the left one and which is
+                # the right one.
+                if d_i < 0:
+                    if goes_out:
+                        left_quadrant = 1
+                        right_quadrant = 0
+                    else:
+                        left_quadrant = 0
+                        right_quadrant = 1
+                else:
+                    if goes_out:
+                        left_quadrant = 3
+                        right_quadrant = 2
+                    else:
+                        left_quadrant = 2
+                        right_quadrant = 3
+
+                if m_curving:
+                    if m_curving == "^":
+                        quadrant[left_quadrant] += 1
+                    elif m_curving == "_":
+                        quadrant[right_quadrant] += 1
+                else:
+                    # This morphism counts in both upper and lower
+                    # quadrants.
+                    quadrant[left_quadrant] += 1
+                    quadrant[right_quadrant] += 1
+
+        # Pick the freest quadrant to curve our morphism into.
+        freest_quadrant = 0
+        for i in range(4):
+            if quadrant[i] < quadrant[freest_quadrant]:
+                freest_quadrant = i
+
+        # Now set up proper looping.
+        (looping_start, looping_end) = [("r", "u"), ("u", "l"), ("l", "d"),
+                                        ("d", "r")][freest_quadrant]
+
+        return (curving, label_pos, looping_start, looping_end)
+
+    @staticmethod
+    def _process_horizontal_morphism(i, j, target_j, grid, morphisms_str_info,
+                                     object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a horizontal morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # The arrow is horizontal.  Check if it goes from left to
+        # right (``backwards == False``) or from right to left
+        # (``backwards == True``).
+        backwards = False
+        start = j
+        end = target_j
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out
+        # upwards, and how many stick out downwards.
+        #
+        # For example, consider the situation:
+        #
+        #    B1 C1
+        #    |  |
+        # A--B--C--D
+        #    |
+        #    B2
+        #
+        # Between the objects `A` and `D` there are two objects:
+        # `B` and `C`.  Further, there are two morphisms which
+        # stick out upward (the ones between `B1` and `B` and
+        # between `C` and `C1`) and one morphism which sticks out
+        # downward (the one between `B and `B2`).
+        #
+        # We need this information to decide how to curve the
+        # arrow between `A` and `D`.  First of all, since there
+        # are two objects between `A` and `D``, we must curve the
+        # arrow.  Then, we will have it curve downward, because
+        # there is more space (less morphisms stick out downward
+        # than upward).
+        up = []
+        down = []
+        straight_horizontal = []
+        for k in range(start + 1, end):
+            obj = grid[i, k]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_i > i:
+                    down.append(m)
+                elif end_i < i:
+                    up.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight horizontal morphism,
+                    # because it has no curving.
+                    straight_horizontal.append(m)
+
+        if len(up) < len(down):
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the lower side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out downward than upward, let's
+            # curve the morphism up.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight horizontal morphisms have
+            # their labels on the upper side of the arrow.
+            for m in straight_horizontal:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if j1 < j2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    @staticmethod
+    def _process_vertical_morphism(i, j, target_i, grid, morphisms_str_info,
+                                   object_coords):
+        """
+        Produces the information required for constructing the string
+        representation of a vertical morphism.  This function is
+        invoked from ``_process_morphism``.
+
+        See Also
+        ========
+
+        _process_morphism
+        """
+        # This arrow is vertical.  Check if it goes from top to
+        # bottom (``backwards == False``) or from bottom to top
+        # (``backwards == True``).
+        backwards = False
+        start = i
+        end = target_i
+        if end < start:
+            (start, end) = (end, start)
+            backwards = True
+
+        # Let's see which objects are there between ``start`` and
+        # ``end``, and then count how many morphisms stick out to
+        # the left, and how many stick out to the right.
+        #
+        # See the corresponding comment in the previous branch of
+        # this if-statement for more details.
+        left = []
+        right = []
+        straight_vertical = []
+        for k in range(start + 1, end):
+            obj = grid[k, j]
+            if not obj:
+                continue
+
+            for m in morphisms_str_info:
+                if m.domain == obj:
+                    (end_i, end_j) = object_coords[m.codomain]
+                elif m.codomain == obj:
+                    (end_i, end_j) = object_coords[m.domain]
+                else:
+                    continue
+
+                if end_j > j:
+                    right.append(m)
+                elif end_j < j:
+                    left.append(m)
+                elif not morphisms_str_info[m].curving:
+                    # This is a straight vertical morphism,
+                    # because it has no curving.
+                    straight_vertical.append(m)
+
+        if len(left) < len(right):
+            # More morphisms stick out to the left than to the
+            # right, let's curve the morphism to the right.
+            if backwards:
+                curving = "^"
+                label_pos = "^"
+            else:
+                curving = "_"
+                label_pos = "_"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the left side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "^"
+                else:
+                    m_str_info.label_position = "_"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+        else:
+            # More morphisms stick out to the right than to the
+            # left, let's curve the morphism to the left.
+            if backwards:
+                curving = "_"
+                label_pos = "_"
+            else:
+                curving = "^"
+                label_pos = "^"
+
+            # Assure that the straight vertical morphisms have
+            # their labels on the right side of the arrow.
+            for m in straight_vertical:
+                (i1, j1) = object_coords[m.domain]
+                (i2, j2) = object_coords[m.codomain]
+
+                m_str_info = morphisms_str_info[m]
+                if i1 < i2:
+                    m_str_info.label_position = "_"
+                else:
+                    m_str_info.label_position = "^"
+
+                # Don't allow any further modifications of the
+                # position of this label.
+                m_str_info.forced_label_position = True
+
+        return (curving, label_pos)
+
+    def _process_morphism(self, diagram, grid, morphism, object_coords,
+                          morphisms, morphisms_str_info):
+        """
+        Given the required information, produces the string
+        representation of ``morphism``.
+        """
+        def repeat_string_cond(times, str_gt, str_lt):
+            """
+            If ``times > 0``, repeats ``str_gt`` ``times`` times.
+            Otherwise, repeats ``str_lt`` ``-times`` times.
+            """
+            if times > 0:
+                return str_gt * times
+            else:
+                return str_lt * (-times)
+
+        def count_morphisms_undirected(A, B):
+            """
+            Counts how many processed morphisms there are between the
+            two supplied objects.
+            """
+            return len([m for m in morphisms_str_info
+                        if {m.domain, m.codomain} == {A, B}])
+
+        def count_morphisms_filtered(dom, cod, curving):
+            """
+            Counts the processed morphisms which go out of ``dom``
+            into ``cod`` with curving ``curving``.
+            """
+            return len([m for m, m_str_info in morphisms_str_info.items()
+                        if (m.domain, m.codomain) == (dom, cod) and
+                        (m_str_info.curving == curving)])
+
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        # We now need to determine the direction of
+        # the arrow.
+        delta_i = target_i - i
+        delta_j = target_j - j
+        vertical_direction = repeat_string_cond(delta_i,
+                                                "d", "u")
+        horizontal_direction = repeat_string_cond(delta_j,
+                                                  "r", "l")
+
+        curving = ""
+        label_pos = "^"
+        looping_start = ""
+        looping_end = ""
+
+        if (delta_i == 0) and (delta_j == 0):
+            # This is a loop morphism.
+            (curving, label_pos, looping_start,
+             looping_end) = XypicDiagramDrawer._process_loop_morphism(
+                 i, j, grid, morphisms_str_info, object_coords)
+        elif (delta_i == 0) and (abs(j - target_j) > 1):
+            # This is a horizontal morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_horizontal_morphism(
+                i, j, target_j, grid, morphisms_str_info, object_coords)
+        elif (delta_j == 0) and (abs(i - target_i) > 1):
+            # This is a vertical morphism.
+            (curving, label_pos) = XypicDiagramDrawer._process_vertical_morphism(
+                i, j, target_i, grid, morphisms_str_info, object_coords)
+
+        count = count_morphisms_undirected(morphism.domain, morphism.codomain)
+        curving_amount = ""
+        if curving:
+            # This morphisms should be curved anyway.
+            curving_amount = self.default_curving_amount + count * \
+                self.default_curving_step
+        elif count:
+            # There are no objects between the domain and codomain of
+            # the current morphism, but this is not there already are
+            # some morphisms with the same domain and codomain, so we
+            # have to curve this one.
+            curving = "^"
+            filtered_morphisms = count_morphisms_filtered(
+                morphism.domain, morphism.codomain, curving)
+            curving_amount = self.default_curving_amount + \
+                filtered_morphisms * \
+                self.default_curving_step
+
+        # Let's now get the name of the morphism.
+        morphism_name = ""
+        if isinstance(morphism, IdentityMorphism):
+            morphism_name = "id_{%s}" + latex(grid[i, j])
+        elif isinstance(morphism, CompositeMorphism):
+            component_names = [latex(Symbol(component.name)) for
+                               component in morphism.components]
+            component_names.reverse()
+            morphism_name = "\\circ ".join(component_names)
+        elif isinstance(morphism, NamedMorphism):
+            morphism_name = latex(Symbol(morphism.name))
+
+        return ArrowStringDescription(
+            self.unit, curving, curving_amount, looping_start,
+            looping_end, horizontal_direction, vertical_direction,
+            label_pos, morphism_name)
+
+    @staticmethod
+    def _check_free_space_horizontal(dom_i, dom_j, cod_j, grid):
+        """
+        For a horizontal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        if dom_j < cod_j:
+            (start, end) = (dom_j, cod_j)
+            backwards = False
+        else:
+            (start, end) = (cod_j, dom_j)
+            backwards = True
+
+        # Check for free space above.
+        if dom_i == 0:
+            free_up = True
+        else:
+            free_up = all(grid[dom_i - 1, j] for j in
+                          range(start, end + 1))
+
+        # Check for free space below.
+        if dom_i == grid.height - 1:
+            free_down = True
+        else:
+            free_down = not any(grid[dom_i + 1, j] for j in
+                                range(start, end + 1))
+
+        return (free_up, free_down, backwards)
+
+    @staticmethod
+    def _check_free_space_vertical(dom_i, cod_i, dom_j, grid):
+        """
+        For a vertical morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) to the left of the
+        morphism or to the right of it.
+        """
+        if dom_i < cod_i:
+            (start, end) = (dom_i, cod_i)
+            backwards = False
+        else:
+            (start, end) = (cod_i, dom_i)
+            backwards = True
+
+        # Check if there's space to the left.
+        if dom_j == 0:
+            free_left = True
+        else:
+            free_left = not any(grid[i, dom_j - 1] for i in
+                                range(start, end + 1))
+
+        if dom_j == grid.width - 1:
+            free_right = True
+        else:
+            free_right = not any(grid[i, dom_j + 1] for i in
+                                 range(start, end + 1))
+
+        return (free_left, free_right, backwards)
+
+    @staticmethod
+    def _check_free_space_diagonal(dom_i, cod_i, dom_j, cod_j, grid):
+        """
+        For a diagonal morphism, checks whether there is free space
+        (i.e., space not occupied by any objects) above the morphism
+        or below it.
+        """
+        def abs_xrange(start, end):
+            if start < end:
+                return range(start, end + 1)
+            else:
+                return range(end, start + 1)
+
+        if dom_i < cod_i and dom_j < cod_j:
+            # This morphism goes from top-left to
+            # bottom-right.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = False
+        elif dom_i > cod_i and dom_j > cod_j:
+            # This morphism goes from bottom-right to
+            # top-left.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = True
+        if dom_i < cod_i and dom_j > cod_j:
+            # This morphism goes from top-right to
+            # bottom-left.
+            (start_i, start_j) = (dom_i, dom_j)
+            (end_i, end_j) = (cod_i, cod_j)
+            backwards = True
+        elif dom_i > cod_i and dom_j < cod_j:
+            # This morphism goes from bottom-left to
+            # top-right.
+            (start_i, start_j) = (cod_i, cod_j)
+            (end_i, end_j) = (dom_i, dom_j)
+            backwards = False
+
+        # This is an attempt at a fast and furious strategy to
+        # decide where there is free space on the two sides of
+        # a diagonal morphism.  For a diagonal morphism
+        # starting at ``(start_i, start_j)`` and ending at
+        # ``(end_i, end_j)`` the rectangle defined by these
+        # two points is considered.  The slope of the diagonal
+        # ``alpha`` is then computed.  Then, for every cell
+        # ``(i, j)`` within the rectangle, the slope
+        # ``alpha1`` of the line through ``(start_i,
+        # start_j)`` and ``(i, j)`` is considered.  If
+        # ``alpha1`` is between 0 and ``alpha``, the point
+        # ``(i, j)`` is above the diagonal, if ``alpha1`` is
+        # between ``alpha`` and infinity, the point is below
+        # the diagonal.  Also note that, with some beforehand
+        # precautions, this trick works for both the main and
+        # the secondary diagonals of the rectangle.
+
+        # I have considered the possibility to only follow the
+        # shorter diagonals immediately above and below the
+        # main (or secondary) diagonal.  This, however,
+        # wouldn't have resulted in much performance gain or
+        # better detection of outer edges, because of
+        # relatively small sizes of diagram grids, while the
+        # code would have become harder to understand.
+
+        alpha = float(end_i - start_i)/(end_j - start_j)
+        free_up = True
+        free_down = True
+        for i in abs_xrange(start_i, end_i):
+            if not free_up and not free_down:
+                break
+
+            for j in abs_xrange(start_j, end_j):
+                if not free_up and not free_down:
+                    break
+
+                if (i, j) == (start_i, start_j):
+                    continue
+
+                if j == start_j:
+                    alpha1 = "inf"
+                else:
+                    alpha1 = float(i - start_i)/(j - start_j)
+
+                if grid[i, j]:
+                    if (alpha1 == "inf") or (abs(alpha1) > abs(alpha)):
+                        free_down = False
+                    elif abs(alpha1) < abs(alpha):
+                        free_up = False
+
+        return (free_up, free_down, backwards)
+
+    def _push_labels_out(self, morphisms_str_info, grid, object_coords):
+        """
+        For all straight morphisms which form the visual boundary of
+        the laid out diagram, puts their labels on their outer sides.
+        """
+        def set_label_position(free1, free2, pos1, pos2, backwards, m_str_info):
+            """
+            Given the information about room available to one side and
+            to the other side of a morphism (``free1`` and ``free2``),
+            sets the position of the morphism label in such a way that
+            it is on the freer side.  This latter operations involves
+            choice between ``pos1`` and ``pos2``, taking ``backwards``
+            in consideration.
+
+            Thus this function will do nothing if either both ``free1
+            == True`` and ``free2 == True`` or both ``free1 == False``
+            and ``free2 == False``.  In either case, choosing one side
+            over the other presents no advantage.
+            """
+            if backwards:
+                (pos1, pos2) = (pos2, pos1)
+
+            if free1 and not free2:
+                m_str_info.label_position = pos1
+            elif free2 and not free1:
+                m_str_info.label_position = pos2
+
+        for m, m_str_info in morphisms_str_info.items():
+            if m_str_info.curving or m_str_info.forced_label_position:
+                # This is either a curved morphism, and curved
+                # morphisms have other magic, or the position of this
+                # label has already been fixed.
+                continue
+
+            if m.domain == m.codomain:
+                # This is a loop morphism, their labels, again have a
+                # different magic.
+                continue
+
+            (dom_i, dom_j) = object_coords[m.domain]
+            (cod_i, cod_j) = object_coords[m.codomain]
+
+            if dom_i == cod_i:
+                # Horizontal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_horizontal(
+                     dom_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+            elif dom_j == cod_j:
+                # Vertical morphism.
+                (free_left, free_right,
+                 backwards) = XypicDiagramDrawer._check_free_space_vertical(
+                     dom_i, cod_i, dom_j, grid)
+
+                set_label_position(free_left, free_right, "_", "^",
+                                   backwards, m_str_info)
+            else:
+                # A diagonal morphism.
+                (free_up, free_down,
+                 backwards) = XypicDiagramDrawer._check_free_space_diagonal(
+                     dom_i, cod_i, dom_j, cod_j, grid)
+
+                set_label_position(free_up, free_down, "^", "_",
+                                   backwards, m_str_info)
+
+    @staticmethod
+    def _morphism_sort_key(morphism, object_coords):
+        """
+        Provides a morphism sorting key such that horizontal or
+        vertical morphisms between neighbouring objects come
+        first, then horizontal or vertical morphisms between more
+        far away objects, and finally, all other morphisms.
+        """
+        (i, j) = object_coords[morphism.domain]
+        (target_i, target_j) = object_coords[morphism.codomain]
+
+        if morphism.domain == morphism.codomain:
+            # Loop morphisms should get after diagonal morphisms
+            # so that the proper direction in which to curve the
+            # loop can be determined.
+            return (3, 0, default_sort_key(morphism))
+
+        if target_i == i:
+            return (1, abs(target_j - j), default_sort_key(morphism))
+
+        if target_j == j:
+            return (1, abs(target_i - i), default_sort_key(morphism))
+
+        # Diagonal morphism.
+        return (2, 0, default_sort_key(morphism))
+
+    @staticmethod
+    def _build_xypic_string(diagram, grid, morphisms,
+                            morphisms_str_info, diagram_format):
+        """
+        Given a collection of :class:`ArrowStringDescription`
+        describing the morphisms of a diagram and the object layout
+        information of a diagram, produces the final Xy-pic picture.
+        """
+        # Build the mapping between objects and morphisms which have
+        # them as domains.
+        object_morphisms = {}
+        for obj in diagram.objects:
+            object_morphisms[obj] = []
+        for morphism in morphisms:
+            object_morphisms[morphism.domain].append(morphism)
+
+        result = "\\xymatrix%s{\n" % diagram_format
+
+        for i in range(grid.height):
+            for j in range(grid.width):
+                obj = grid[i, j]
+                if obj:
+                    result += latex(obj) + " "
+
+                    morphisms_to_draw = object_morphisms[obj]
+                    for morphism in morphisms_to_draw:
+                        result += str(morphisms_str_info[morphism]) + " "
+
+                # Don't put the & after the last column.
+                if j < grid.width - 1:
+                    result += "& "
+
+            # Don't put the line break after the last row.
+            if i < grid.height - 1:
+                result += "\\\\"
+            result += "\n"
+
+        result += "}\n"
+
+        return result
+
+    def draw(self, diagram, grid, masked=None, diagram_format=""):
+        r"""
+        Returns the Xy-pic representation of ``diagram`` laid out in
+        ``grid``.
+
+        Consider the following simple triangle diagram.
+
+        >>> from sympy.categories import Object, NamedMorphism, Diagram
+        >>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
+        >>> A = Object("A")
+        >>> B = Object("B")
+        >>> C = Object("C")
+        >>> f = NamedMorphism(A, B, "f")
+        >>> g = NamedMorphism(B, C, "g")
+        >>> diagram = Diagram([f, g], {g * f: "unique"})
+
+        To draw this diagram, its objects need to be laid out with a
+        :class:`DiagramGrid`::
+
+        >>> grid = DiagramGrid(diagram)
+
+        Finally, the drawing:
+
+        >>> drawer = XypicDiagramDrawer()
+        >>> print(drawer.draw(diagram, grid))
+        \xymatrix{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        The argument ``masked`` can be used to skip morphisms in the
+        presentation of the diagram:
+
+        >>> print(drawer.draw(diagram, grid, masked=[g * f]))
+        \xymatrix{
+        A \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        Finally, the ``diagram_format`` argument can be used to
+        specify the format string of the diagram.  For example, to
+        increase the spacing by 1 cm, proceeding as follows:
+
+        >>> print(drawer.draw(diagram, grid, diagram_format="@+1cm"))
+        \xymatrix@+1cm{
+        A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+        C &
+        }
+
+        """
+        # This method works in several steps.  It starts by removing
+        # the masked morphisms, if necessary, and then maps objects to
+        # their positions in the grid (coordinate tuples).  Remember
+        # that objects are unique in ``Diagram`` and in the layout
+        # produced by ``DiagramGrid``, so every object is mapped to a
+        # single coordinate pair.
+        #
+        # The next step is the central step and is concerned with
+        # analysing the morphisms of the diagram and deciding how to
+        # draw them.  For example, how to curve the arrows is decided
+        # at this step.  The bulk of the analysis is implemented in
+        # ``_process_morphism``, to the result of which the
+        # appropriate formatters are applied.
+        #
+        # The result of the previous step is a list of
+        # ``ArrowStringDescription``.  After the analysis and
+        # application of formatters, some extra logic tries to assure
+        # better positioning of morphism labels (for example, an
+        # attempt is made to avoid the situations when arrows cross
+        # labels).  This functionality constitutes the next step and
+        # is implemented in ``_push_labels_out``.  Note that label
+        # positions which have been set via a formatter are not
+        # affected in this step.
+        #
+        # Finally, at the closing step, the array of
+        # ``ArrowStringDescription`` and the layout information
+        # incorporated in ``DiagramGrid`` are combined to produce the
+        # resulting Xy-pic picture.  This part of code lies in
+        # ``_build_xypic_string``.
+
+        if not masked:
+            morphisms_props = grid.morphisms
+        else:
+            morphisms_props = {}
+            for m, props in grid.morphisms.items():
+                if m in masked:
+                    continue
+                morphisms_props[m] = props
+
+        # Build the mapping between objects and their position in the
+        # grid.
+        object_coords = {}
+        for i in range(grid.height):
+            for j in range(grid.width):
+                if grid[i, j]:
+                    object_coords[grid[i, j]] = (i, j)
+
+        morphisms = sorted(morphisms_props,
+                           key=lambda m: XypicDiagramDrawer._morphism_sort_key(
+                               m, object_coords))
+
+        # Build the tuples defining the string representations of
+        # morphisms.
+        morphisms_str_info = {}
+        for morphism in morphisms:
+            string_description = self._process_morphism(
+                diagram, grid, morphism, object_coords, morphisms,
+                morphisms_str_info)
+
+            if self.default_arrow_formatter:
+                self.default_arrow_formatter(string_description)
+
+            for prop in morphisms_props[morphism]:
+                # prop is a Symbol.  TODO: Find out why.
+                if prop.name in self.arrow_formatters:
+                    formatter = self.arrow_formatters[prop.name]
+                    formatter(string_description)
+
+            morphisms_str_info[morphism] = string_description
+
+        # Reposition the labels a bit.
+        self._push_labels_out(morphisms_str_info, grid, object_coords)
+
+        return XypicDiagramDrawer._build_xypic_string(
+            diagram, grid, morphisms, morphisms_str_info, diagram_format)
+
+
+def xypic_draw_diagram(diagram, masked=None, diagram_format="",
+                       groups=None, **hints):
+    r"""
+    Provides a shortcut combining :class:`DiagramGrid` and
+    :class:`XypicDiagramDrawer`.  Returns an Xy-pic presentation of
+    ``diagram``.  The argument ``masked`` is a list of morphisms which
+    will be not be drawn.  The argument ``diagram_format`` is the
+    format string inserted after "\xymatrix".  ``groups`` should be a
+    set of logical groups.  The ``hints`` will be passed directly to
+    the constructor of :class:`DiagramGrid`.
+
+    For more information about the arguments, see the docstrings of
+    :class:`DiagramGrid` and ``XypicDiagramDrawer.draw``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import xypic_draw_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> diagram = Diagram([f, g], {g * f: "unique"})
+    >>> print(xypic_draw_diagram(diagram))
+    \xymatrix{
+    A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
+    C &
+    }
+
+    See Also
+    ========
+
+    XypicDiagramDrawer, DiagramGrid
+    """
+    grid = DiagramGrid(diagram, groups, **hints)
+    drawer = XypicDiagramDrawer()
+    return drawer.draw(diagram, grid, masked, diagram_format)
+
+
+@doctest_depends_on(exe=('latex', 'dvipng'), modules=('pyglet',))
+def preview_diagram(diagram, masked=None, diagram_format="", groups=None,
+                    output='png', viewer=None, euler=True, **hints):
+    """
+    Combines the functionality of ``xypic_draw_diagram`` and
+    ``sympy.printing.preview``.  The arguments ``masked``,
+    ``diagram_format``, ``groups``, and ``hints`` are passed to
+    ``xypic_draw_diagram``, while ``output``, ``viewer, and ``euler``
+    are passed to ``preview``.
+
+    Examples
+    ========
+
+    >>> from sympy.categories import Object, NamedMorphism, Diagram
+    >>> from sympy.categories import preview_diagram
+    >>> A = Object("A")
+    >>> B = Object("B")
+    >>> C = Object("C")
+    >>> f = NamedMorphism(A, B, "f")
+    >>> g = NamedMorphism(B, C, "g")
+    >>> d = Diagram([f, g], {g * f: "unique"})
+    >>> preview_diagram(d)
+
+    See Also
+    ========
+
+    XypicDiagramDrawer
+    """
+    from sympy.printing import preview
+    latex_output = xypic_draw_diagram(diagram, masked, diagram_format,
+                                      groups, **hints)
+    preview(latex_output, output, viewer, euler, ("xypic",))
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2eba4d7ca29ec3ba0d3ebc87bf189e1f5b7befd7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_baseclasses.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_baseclasses.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11178177c2ba75df11d20dd5fc31e4b91833b304
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_baseclasses.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_drawing.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_drawing.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6125386e1f44fdddd109102a41d29e5d3f1422b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/categories/tests/__pycache__/test_drawing.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_baseclasses.py b/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_baseclasses.py
new file mode 100644
index 0000000000000000000000000000000000000000..cfac32229768fb5903b23b11ffb236912c0b931e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_baseclasses.py
@@ -0,0 +1,209 @@
+from sympy.categories import (Object, Morphism, IdentityMorphism,
+                              NamedMorphism, CompositeMorphism,
+                              Diagram, Category)
+from sympy.categories.baseclasses import Class
+from sympy.testing.pytest import raises
+from sympy.core.containers import (Dict, Tuple)
+from sympy.sets import EmptySet
+from sympy.sets.sets import FiniteSet
+
+
+def test_morphisms():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    # Test the base morphism.
+    f = NamedMorphism(A, B, "f")
+    assert f.domain == A
+    assert f.codomain == B
+    assert f == NamedMorphism(A, B, "f")
+
+    # Test identities.
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+    assert id_A.domain == A
+    assert id_A.codomain == A
+    assert id_A == IdentityMorphism(A)
+    assert id_A != id_B
+
+    # Test named morphisms.
+    g = NamedMorphism(B, C, "g")
+    assert g.name == "g"
+    assert g != f
+    assert g == NamedMorphism(B, C, "g")
+    assert g != NamedMorphism(B, C, "f")
+
+    # Test composite morphisms.
+    assert f == CompositeMorphism(f)
+
+    k = g.compose(f)
+    assert k.domain == A
+    assert k.codomain == C
+    assert k.components == Tuple(f, g)
+    assert g * f == k
+    assert CompositeMorphism(f, g) == k
+
+    assert CompositeMorphism(g * f) == g * f
+
+    # Test the associativity of composition.
+    h = NamedMorphism(C, D, "h")
+
+    p = h * g
+    u = h * g * f
+
+    assert h * k == u
+    assert p * f == u
+    assert CompositeMorphism(f, g, h) == u
+
+    # Test flattening.
+    u2 = u.flatten("u")
+    assert isinstance(u2, NamedMorphism)
+    assert u2.name == "u"
+    assert u2.domain == A
+    assert u2.codomain == D
+
+    # Test identities.
+    assert f * id_A == f
+    assert id_B * f == f
+    assert id_A * id_A == id_A
+    assert CompositeMorphism(id_A) == id_A
+
+    # Test bad compositions.
+    raises(ValueError, lambda: f * g)
+
+    raises(TypeError, lambda: f.compose(None))
+    raises(TypeError, lambda: id_A.compose(None))
+    raises(TypeError, lambda: f * None)
+    raises(TypeError, lambda: id_A * None)
+
+    raises(TypeError, lambda: CompositeMorphism(f, None, 1))
+
+    raises(ValueError, lambda: NamedMorphism(A, B, ""))
+    raises(NotImplementedError, lambda: Morphism(A, B))
+
+
+def test_diagram():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    id_A = IdentityMorphism(A)
+    id_B = IdentityMorphism(B)
+
+    empty = EmptySet
+
+    # Test the addition of identities.
+    d1 = Diagram([f])
+
+    assert d1.objects == FiniteSet(A, B)
+    assert d1.hom(A, B) == (FiniteSet(f), empty)
+    assert d1.hom(A, A) == (FiniteSet(id_A), empty)
+    assert d1.hom(B, B) == (FiniteSet(id_B), empty)
+
+    assert d1 == Diagram([id_A, f])
+    assert d1 == Diagram([f, f])
+
+    # Test the addition of composites.
+    d2 = Diagram([f, g])
+    homAC = d2.hom(A, C)[0]
+
+    assert d2.objects == FiniteSet(A, B, C)
+    assert g * f in d2.premises.keys()
+    assert homAC == FiniteSet(g * f)
+
+    # Test equality, inequality and hash.
+    d11 = Diagram([f])
+
+    assert d1 == d11
+    assert d1 != d2
+    assert hash(d1) == hash(d11)
+
+    d11 = Diagram({f: "unique"})
+    assert d1 != d11
+
+    # Make sure that (re-)adding composites (with new properties)
+    # works as expected.
+    d = Diagram([f, g], {g * f: "unique"})
+    assert d.conclusions == Dict({g * f: FiniteSet("unique")})
+
+    # Check the hom-sets when there are premises and conclusions.
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+    d = Diagram([f, g], [g * f])
+    assert d.hom(A, C) == (FiniteSet(g * f), FiniteSet(g * f))
+
+    # Check how the properties of composite morphisms are computed.
+    d = Diagram({f: ["unique", "isomorphism"], g: "unique"})
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check that conclusion morphisms with new objects are not allowed.
+    d = Diagram([f], [g])
+    assert d.conclusions == Dict({})
+
+    # Test an empty diagram.
+    d = Diagram()
+    assert d.premises == Dict({})
+    assert d.conclusions == Dict({})
+    assert d.objects == empty
+
+    # Check a SymPy Dict object.
+    d = Diagram(Dict({f: FiniteSet("unique", "isomorphism"), g: "unique"}))
+    assert d.premises[g * f] == FiniteSet("unique")
+
+    # Check the addition of components of composite morphisms.
+    d = Diagram([g * f])
+    assert f in d.premises
+    assert g in d.premises
+
+    # Check subdiagrams.
+    d = Diagram([f, g], {g * f: "unique"})
+
+    d1 = Diagram([f])
+    assert d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([NamedMorphism(B, A, "f'")])
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d1 = Diagram([f, g], {g * f: ["unique", "something"]})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram({f: "blooh"})
+    d1 = Diagram({f: "bleeh"})
+    assert not d.is_subdiagram(d1)
+    assert not d1.is_subdiagram(d)
+
+    d = Diagram([f, g], {f: "unique", g * f: "veryunique"})
+    d1 = d.subdiagram_from_objects(FiniteSet(A, B))
+    assert d1 == Diagram([f], {f: "unique"})
+    raises(ValueError, lambda: d.subdiagram_from_objects(FiniteSet(A,
+           Object("D"))))
+
+    raises(ValueError, lambda: Diagram({IdentityMorphism(A): "unique"}))
+
+
+def test_category():
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+
+    objects = d1.objects | d2.objects
+
+    K = Category("K", objects, commutative_diagrams=[d1, d2])
+
+    assert K.name == "K"
+    assert K.objects == Class(objects)
+    assert K.commutative_diagrams == FiniteSet(d1, d2)
+
+    raises(ValueError, lambda: Category(""))
diff --git a/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_drawing.py b/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_drawing.py
new file mode 100644
index 0000000000000000000000000000000000000000..63a13266cd6b58f6a85aad4af0813b395acbb5e1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/categories/tests/test_drawing.py
@@ -0,0 +1,919 @@
+from sympy.categories.diagram_drawing import _GrowableGrid, ArrowStringDescription
+from sympy.categories import (DiagramGrid, Object, NamedMorphism,
+                              Diagram, XypicDiagramDrawer, xypic_draw_diagram)
+from sympy.sets.sets import FiniteSet
+
+
+def test_GrowableGrid():
+    grid = _GrowableGrid(1, 2)
+
+    # Check dimensions.
+    assert grid.width == 1
+    assert grid.height == 2
+
+    # Check initialization of elements.
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+
+    # Check assignment to elements.
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+
+    # Check appending a row.
+    grid.append_row()
+
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    # Check appending a column.
+    grid.append_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] == 1
+    assert grid[1, 0] == "two"
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] is None
+    assert grid[2, 1] is None
+
+    grid = _GrowableGrid(1, 2)
+    grid[0, 0] = 1
+    grid[1, 0] = "two"
+
+    # Check prepending a row.
+    grid.prepend_row()
+    assert grid.width == 1
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] == 1
+    assert grid[2, 0] == "two"
+
+    # Check prepending a column.
+    grid.prepend_column()
+    assert grid.width == 2
+    assert grid.height == 3
+
+    assert grid[0, 0] is None
+    assert grid[1, 0] is None
+    assert grid[2, 0] is None
+
+    assert grid[0, 1] is None
+    assert grid[1, 1] == 1
+    assert grid[2, 1] == "two"
+
+
+def test_DiagramGrid():
+    # Set up some objects and morphisms.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+
+    # A one-morphism diagram.
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid.morphisms == {f: FiniteSet()}
+
+    # A triangle.
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(),
+                              g * f: FiniteSet("unique")}
+
+    # A triangle with a "loop" morphism.
+    l_A = NamedMorphism(A, A, "l_A")
+    d = Diagram([f, g, l_A])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), l_A: FiniteSet()}
+
+    # A simple diagram.
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == D
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    assert str(grid) == '[[Object("A"), Object("B"), Object("D")], ' \
+        '[None, Object("C"), None]]'
+
+    # A chain of morphisms.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    k = NamedMorphism(D, E, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A square.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, D, "g")
+    h = NamedMorphism(A, C, "h")
+    k = NamedMorphism(C, D, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              k: FiniteSet()}
+
+    # A strange diagram which resulted from a typo when creating a
+    # test for five lemma, but which allowed to stop one extra problem
+    # in the algorithm.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    # These 4 morphisms should be between primed objects.
+    j = NamedMorphism(A, B, "j")
+    k = NamedMorphism(B, C, "k")
+    l = NamedMorphism(C, D, "l")
+    m = NamedMorphism(D, E, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 4
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[2, 0] == C_
+    assert grid[2, 1] == D
+    assert grid[2, 2] == D_
+    assert grid[3, 0] is None
+    assert grid[3, 1] == E
+    assert grid[3, 2] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A cube.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A5
+    assert grid[0, 2] == A6
+    assert grid[0, 3] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == A1
+    assert grid[1, 2] == A2
+    assert grid[1, 3] is None
+    assert grid[2, 0] == A7
+    assert grid[2, 1] == A3
+    assert grid[2, 2] == A4
+    assert grid[2, 3] == A8
+
+    morphisms = {}
+    for m in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # A line diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # Test the transposed version.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+
+    assert grid.width == 1
+    assert grid.height == 5
+    assert grid[0, 0] == A
+    assert grid[1, 0] == B
+    assert grid[2, 0] == C
+    assert grid[3, 0] == D
+    assert grid[4, 0] == E
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), h: FiniteSet(),
+                              i: FiniteSet()}
+
+    # A pullback.
+    m1 = NamedMorphism(A, B, "m1")
+    m2 = NamedMorphism(A, C, "m2")
+    s1 = NamedMorphism(B, D, "s1")
+    s2 = NamedMorphism(C, D, "s2")
+    f1 = NamedMorphism(E, B, "f1")
+    f2 = NamedMorphism(E, C, "f2")
+    g = NamedMorphism(E, A, "g")
+
+    d = Diagram([m1, m2, s1, s2, f1, f2], {g: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == E
+    assert grid[1, 0] == C
+    assert grid[1, 1] == D
+    assert grid[1, 2] is None
+
+    morphisms = {g: FiniteSet("unique")}
+    for m in [m1, m2, s1, s2, f1, f2]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the pullback with sequential layout, just for stress
+    # testing.
+    grid = DiagramGrid(d, layout="sequential")
+
+    assert grid.width == 5
+    assert grid.height == 1
+    assert grid[0, 0] == D
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A
+    assert grid[0, 3] == C
+    assert grid[0, 4] == E
+    assert grid.morphisms == morphisms
+
+    # Test a pullback with object grouping.
+    grid = DiagramGrid(d, groups=FiniteSet(E, FiniteSet(A, B, C, D)))
+
+    assert grid.width == 3
+    assert grid.height == 2
+    assert grid[0, 0] == E
+    assert grid[0, 1] == A
+    assert grid[0, 2] == B
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid.morphisms == morphisms
+
+    # Five lemma, actually.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+
+    j = NamedMorphism(A_, B_, "j")
+    k = NamedMorphism(B_, C_, "k")
+    l = NamedMorphism(C_, D_, "l")
+    m = NamedMorphism(D_, E_, "m")
+
+    o = NamedMorphism(A, A_, "o")
+    p = NamedMorphism(B, B_, "p")
+    q = NamedMorphism(C, C_, "q")
+    r = NamedMorphism(D, D_, "r")
+    s = NamedMorphism(E, E_, "s")
+
+    d = Diagram([f, g, h, i, j, k, l, m, o, p, q, r, s])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] is None
+    assert grid[0, 1] == A
+    assert grid[0, 2] == A_
+    assert grid[0, 3] is None
+    assert grid[0, 4] is None
+    assert grid[1, 0] == C
+    assert grid[1, 1] == B
+    assert grid[1, 2] == B_
+    assert grid[1, 3] == C_
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D
+    assert grid[2, 1] == E
+    assert grid[2, 2] is None
+    assert grid[2, 3] == D_
+    assert grid[2, 4] == E_
+
+    morphisms = {}
+    for m in [f, g, h, i, j, k, l, m, o, p, q, r, s]:
+        morphisms[m] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping.
+    grid = DiagramGrid(d, FiniteSet(
+        FiniteSet(A, B, C, D, E), FiniteSet(A_, B_, C_, D_, E_)))
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping, but mixing containers
+    # to represent groups.
+    grid = DiagramGrid(d, [(A, B, C, D, E), {A_, B_, C_, D_, E_}])
+
+    assert grid.width == 6
+    assert grid.height == 3
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] is None
+    assert grid[0, 3] == A_
+    assert grid[0, 4] == B_
+    assert grid[0, 5] is None
+    assert grid[1, 0] is None
+    assert grid[1, 1] == C
+    assert grid[1, 2] == D
+    assert grid[1, 3] is None
+    assert grid[1, 4] == C_
+    assert grid[1, 5] == D_
+    assert grid[2, 0] is None
+    assert grid[2, 1] is None
+    assert grid[2, 2] == E
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+    assert grid[2, 5] == E_
+    assert grid.morphisms == morphisms
+
+    # Test the five lemma with object grouping and hints.
+    grid = DiagramGrid(d, {
+        FiniteSet(A, B, C, D, E): {"layout": "sequential",
+                                   "transpose": True},
+        FiniteSet(A_, B_, C_, D_, E_): {"layout": "sequential",
+                                        "transpose": True}},
+        transpose=True)
+
+    assert grid.width == 5
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid[0, 4] == E
+    assert grid[1, 0] == A_
+    assert grid[1, 1] == B_
+    assert grid[1, 2] == C_
+    assert grid[1, 3] == D_
+    assert grid[1, 4] == E_
+    assert grid.morphisms == morphisms
+
+    # A two-triangle disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    f_ = NamedMorphism(A_, B_, "f")
+    g_ = NamedMorphism(B_, C_, "g")
+    d = Diagram([f, g, f_, g_], {g * f: "unique", g_ * f_: "unique"})
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 2
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == A_
+    assert grid[0, 3] == B_
+    assert grid[1, 0] == C
+    assert grid[1, 1] is None
+    assert grid[1, 2] == C_
+    assert grid[1, 3] is None
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet(), f_: FiniteSet(),
+                              g_: FiniteSet(), g * f: FiniteSet("unique"),
+                              g_ * f_: FiniteSet("unique")}
+
+    # A two-morphism disconnected diagram.
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(C, D, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 4
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+    assert grid[0, 2] == C
+    assert grid[0, 3] == D
+    assert grid.morphisms == {f: FiniteSet(), g: FiniteSet()}
+
+    # Test a one-object diagram.
+    f = NamedMorphism(A, A, "f")
+    d = Diagram([f])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 1
+    assert grid.height == 1
+    assert grid[0, 0] == A
+
+    # Test a two-object disconnected diagram.
+    g = NamedMorphism(B, B, "g")
+    d = Diagram([f, g])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 2
+    assert grid.height == 1
+    assert grid[0, 0] == A
+    assert grid[0, 1] == B
+
+
+def test_DiagramGrid_pseudopod():
+    # Test a diagram in which even growing a pseudopod does not
+    # eventually help.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+    F = Object("F")
+    A_ = Object("A'")
+    B_ = Object("B'")
+    C_ = Object("C'")
+    D_ = Object("D'")
+    E_ = Object("E'")
+
+    f1 = NamedMorphism(A, B, "f1")
+    f2 = NamedMorphism(A, C, "f2")
+    f3 = NamedMorphism(A, D, "f3")
+    f4 = NamedMorphism(A, E, "f4")
+    f5 = NamedMorphism(A, A_, "f5")
+    f6 = NamedMorphism(A, B_, "f6")
+    f7 = NamedMorphism(A, C_, "f7")
+    f8 = NamedMorphism(A, D_, "f8")
+    f9 = NamedMorphism(A, E_, "f9")
+    f10 = NamedMorphism(A, F, "f10")
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10])
+    grid = DiagramGrid(d)
+
+    assert grid.width == 5
+    assert grid.height == 3
+    assert grid[0, 0] == E
+    assert grid[0, 1] == C
+    assert grid[0, 2] == C_
+    assert grid[0, 3] == E_
+    assert grid[0, 4] == F
+    assert grid[1, 0] == D
+    assert grid[1, 1] == A
+    assert grid[1, 2] == A_
+    assert grid[1, 3] is None
+    assert grid[1, 4] is None
+    assert grid[2, 0] == D_
+    assert grid[2, 1] == B
+    assert grid[2, 2] == B_
+    assert grid[2, 3] is None
+    assert grid[2, 4] is None
+
+    morphisms = {}
+    for f in [f1, f2, f3, f4, f5, f6, f7, f8, f9, f10]:
+        morphisms[f] = FiniteSet()
+    assert grid.morphisms == morphisms
+
+
+def test_ArrowStringDescription():
+    astr = ArrowStringDescription("cm", "", None, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "^", 12, "", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@/^12cm/[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "", "d", "r", "_", "f")
+    assert str(astr) == "\\ar[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    assert str(astr) == "\\ar@(r,u)[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "", 12, "r", "u", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@(r,u)@{-->}[dr]_{f}"
+
+    astr = ArrowStringDescription("cm", "_", 12, "", "", "d", "r", "_", "f")
+    astr.arrow_style = "{-->}"
+    assert str(astr) == "\\ar@/_12cm/@{-->}[dr]_{f}"
+
+
+def test_XypicDiagramDrawer_line():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{f} & B \\ar[r]^{g} & C \\ar[r]^{h} & D \\ar[r]^{i} & E \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, layout="sequential", transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\\\\n" \
+        "B \\ar[d]^{g} \\\\\n" \
+        "C \\ar[d]^{h} \\\\\n" \
+        "D \\ar[d]^{i} \\\\\n" \
+        "E \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_triangle():
+    # A triangle diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+
+    d = Diagram([f, g], {g * f: "unique"})
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]_{g\\circ f} \\ar[r]^{f} & B \\ar[ld]^{g} \\\\\n" \
+        "C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram, with a masked morphism.
+    assert drawer.draw(d, grid, masked=[g]) == "\\xymatrix{\n" \
+        "A \\ar[r]^{g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B & \n" \
+        "}\n"
+
+    # The same diagram with a formatter for "unique".
+    def formatter(astr):
+        astr.label = "\\exists !" + astr.label
+        astr.arrow_style = "{-->}"
+
+    drawer.arrow_formatters["unique"] = formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^{\\exists !g\\circ f} \\ar[d]_{f} & C \\\\\n" \
+        "B \\ar[ru]_{g} & \n" \
+        "}\n"
+
+    # The same diagram with a default formatter.
+    def default_formatter(astr):
+        astr.label_displacement = "(0.45)"
+
+    drawer.default_arrow_formatter = default_formatter
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar@{-->}[r]^(0.45){\\exists !g\\circ f} \\ar[d]_(0.45){f} & C \\\\\n" \
+        "B \\ar[ru]_(0.45){g} & \n" \
+        "}\n"
+
+    # A triangle diagram with a lot of morphisms between the same
+    # objects.
+    f1 = NamedMorphism(B, A, "f1")
+    f2 = NamedMorphism(A, B, "f2")
+    g1 = NamedMorphism(C, B, "g1")
+    g2 = NamedMorphism(B, C, "g2")
+    d = Diagram([f, f1, f2, g, g1, g2], {f1 * g1: "unique", g2 * f2: "unique"})
+
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid, masked=[f1*g1*g2*f2, g2*f2*f1*g1]) == \
+        "\\xymatrix{\n" \
+        "A \\ar[r]^{g_{2}\\circ f_{2}} \\ar[d]_{f} \\ar@/^3mm/[d]^{f_{2}} " \
+        "& C \\ar@/^3mm/[l]^{f_{1}\\circ g_{1}} \\ar@/^3mm/[ld]^{g_{1}} \\\\\n" \
+        "B \\ar@/^3mm/[u]^{f_{1}} \\ar[ru]_{g} \\ar@/^3mm/[ru]^{g_{2}} & \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_cube():
+    # A cube diagram.
+    A1 = Object("A1")
+    A2 = Object("A2")
+    A3 = Object("A3")
+    A4 = Object("A4")
+    A5 = Object("A5")
+    A6 = Object("A6")
+    A7 = Object("A7")
+    A8 = Object("A8")
+
+    # The top face of the cube.
+    f1 = NamedMorphism(A1, A2, "f1")
+    f2 = NamedMorphism(A1, A3, "f2")
+    f3 = NamedMorphism(A2, A4, "f3")
+    f4 = NamedMorphism(A3, A4, "f3")
+
+    # The bottom face of the cube.
+    f5 = NamedMorphism(A5, A6, "f5")
+    f6 = NamedMorphism(A5, A7, "f6")
+    f7 = NamedMorphism(A6, A8, "f7")
+    f8 = NamedMorphism(A7, A8, "f8")
+
+    # The remaining morphisms.
+    f9 = NamedMorphism(A1, A5, "f9")
+    f10 = NamedMorphism(A2, A6, "f10")
+    f11 = NamedMorphism(A3, A7, "f11")
+    f12 = NamedMorphism(A4, A8, "f11")
+
+    d = Diagram([f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& A_{5} \\ar[r]^{f_{5}} \\ar[ldd]_{f_{6}} & A_{6} \\ar[rdd]^{f_{7}} " \
+        "& \\\\\n" \
+        "& A_{1} \\ar[r]^{f_{1}} \\ar[d]^{f_{2}} \\ar[u]^{f_{9}} & A_{2} " \
+        "\\ar[d]^{f_{3}} \\ar[u]_{f_{10}} & \\\\\n" \
+        "A_{7} \\ar@/_3mm/[rrr]_{f_{8}} & A_{3} \\ar[r]^{f_{3}} \\ar[l]_{f_{11}} " \
+        "& A_{4} \\ar[r]^{f_{11}} & A_{8} \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "& & A_{7} \\ar@/^3mm/[ddd]^{f_{8}} \\\\\n" \
+        "A_{5} \\ar[d]_{f_{5}} \\ar[rru]^{f_{6}} & A_{1} \\ar[d]^{f_{1}} " \
+        "\\ar[r]^{f_{2}} \\ar[l]^{f_{9}} & A_{3} \\ar[d]_{f_{3}} " \
+        "\\ar[u]^{f_{11}} \\\\\n" \
+        "A_{6} \\ar[rrd]_{f_{7}} & A_{2} \\ar[r]^{f_{3}} \\ar[l]^{f_{10}} " \
+        "& A_{4} \\ar[d]_{f_{11}} \\\\\n" \
+        "& & A_{8} \n" \
+        "}\n"
+
+
+def test_XypicDiagramDrawer_curved_and_loops():
+    # A simple diagram, with a curved arrow.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(D, A, "h")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} & B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_3mm/[ll]_{h} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # The same diagram, larger and rotated.
+    assert drawer.draw(d, grid, diagram_format="@+1cm@dr") == \
+        "\\xymatrix@+1cm@dr{\n" \
+        "A \\ar[d]^{f} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^3mm/[uu]^{h} & \n" \
+        "}\n"
+
+    # A simple diagram with three curved arrows.
+    h1 = NamedMorphism(D, A, "h1")
+    h2 = NamedMorphism(A, D, "h2")
+    k = NamedMorphism(D, B, "k")
+    d = Diagram([f, g, h, k, h1, h2])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\\\\n" \
+        "& C & \n" \
+        "}\n"
+
+    # The same diagram, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} & \n" \
+        "}\n"
+
+    # The same diagram, with "loop" morphisms.
+    l_A = NamedMorphism(A, A, "l_A")
+    l_D = NamedMorphism(D, D, "l_D")
+    l_C = NamedMorphism(C, C, "l_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "& B \\ar[d]^{g} & D \\ar[l]^{k} \\ar@/_7mm/[ll]_{h} " \
+        "\\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with "loop" morphisms, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object.
+    l_A_ = NamedMorphism(A, A, "n_A")
+    l_D_ = NamedMorphism(D, D, "n_D")
+    l_C_ = NamedMorphism(C, C, "n_C")
+    d = Diagram([f, g, h, k, h1, h2, l_A, l_D, l_C, l_A_, l_D_, l_C_])
+    grid = DiagramGrid(d)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[r]_{f} \\ar@/^3mm/[rr]^{h_{2}} \\ar@(u,l)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(l,d)[]^{n_{A}} & B \\ar[d]^{g} & D \\ar[l]^{k} " \
+        "\\ar@/_7mm/[ll]_{h} \\ar@/_11mm/[ll]_{h_{1}} \\ar@(r,u)[]^{l_{D}} " \
+        "\\ar@/^3mm/@(d,r)[]^{n_{D}} \\\\\n" \
+        "& C \\ar@(l,d)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} & \n" \
+        "}\n"
+
+    # The same diagram with two "loop" morphisms per object, transposed.
+    grid = DiagramGrid(d, transpose=True)
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == "\\xymatrix{\n" \
+        "A \\ar[d]^{f} \\ar@/_3mm/[dd]_{h_{2}} \\ar@(r,u)[]^{l_{A}} " \
+        "\\ar@/^3mm/@(u,l)[]^{n_{A}} & \\\\\n" \
+        "B \\ar[r]^{g} & C \\ar@(r,u)[]^{l_{C}} \\ar@/^3mm/@(d,r)[]^{n_{C}} \\\\\n" \
+        "D \\ar[u]_{k} \\ar@/^7mm/[uu]^{h} \\ar@/^11mm/[uu]^{h_{1}} " \
+        "\\ar@(l,d)[]^{l_{D}} \\ar@/^3mm/@(d,r)[]^{n_{D}} & \n" \
+        "}\n"
+
+
+def test_xypic_draw_diagram():
+    # A linear diagram.
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    D = Object("D")
+    E = Object("E")
+
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    h = NamedMorphism(C, D, "h")
+    i = NamedMorphism(D, E, "i")
+    d = Diagram([f, g, h, i])
+
+    grid = DiagramGrid(d, layout="sequential")
+    drawer = XypicDiagramDrawer()
+    assert drawer.draw(d, grid) == xypic_draw_diagram(d, layout="sequential")
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__init__.py b/.venv/lib/python3.12/site-packages/sympy/codegen/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..62b195633bae28371bdf9e79317050d7fa7125ae
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/__init__.py
@@ -0,0 +1,24 @@
+""" The ``sympy.codegen`` module contains classes and functions for building
+abstract syntax trees of algorithms. These trees may then be printed by the
+code-printers in ``sympy.printing``.
+
+There are several submodules available:
+- ``sympy.codegen.ast``: AST nodes useful across multiple languages.
+- ``sympy.codegen.cnodes``: AST nodes useful for the C family of languages.
+- ``sympy.codegen.fnodes``: AST nodes useful for Fortran.
+- ``sympy.codegen.cfunctions``: functions specific to C (C99 math functions)
+- ``sympy.codegen.ffunctions``: functions specific to Fortran (e.g. ``kind``).
+
+
+
+"""
+from .ast import (
+    Assignment, aug_assign, CodeBlock, For, Attribute, Variable, Declaration,
+    While, Scope, Print, FunctionPrototype, FunctionDefinition, FunctionCall
+)
+
+__all__ = [
+    'Assignment', 'aug_assign', 'CodeBlock', 'For', 'Attribute', 'Variable',
+    'Declaration', 'While', 'Scope', 'Print', 'FunctionPrototype',
+    'FunctionDefinition', 'FunctionCall',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..466ef4d68cd6615d6c5dd8cbe9ec1d12f2178f06
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/abstract_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/abstract_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67cec1dfa872318f813f8c6526f80bfd4f9446dd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/abstract_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/algorithms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/algorithms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..141968394883a13836f28847fc5939ae757743df
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/algorithms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/approximations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/approximations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25f586f3cc993b4dec44fc5b3e92374b4b323ad9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/approximations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/ast.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/ast.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6800e928c132e716905f8f011af5e2c9def2cdb7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/ast.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cfunctions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cfunctions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da66ba03186dd4f5c113424b2d97eab4ef0c69b2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cfunctions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..20a9e2dfdcb6f368d7cf79ebb80371ef6d541b33
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cutils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..130d1a0663820ac85d1a38da7929ab86fb6349e1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cutils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cxxnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cxxnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45a4c6198a1a7b477f4957cb5a9c2982900c9977
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/cxxnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/fnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/fnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf70be7416b36e2acd7b078105be828a89fac3bd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/fnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/futils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/futils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e43ac9438d556939f62d5099859fd3db587c8588
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/futils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/matrix_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/matrix_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9e31db8862d1d3ccac1bb54c529f610262246ed
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/matrix_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/numpy_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/numpy_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a11fdb979cc884a5233946afb45645805812fecd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/numpy_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pynodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pynodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fcf698648e562fb8b2d2ea92089050c953e2a809
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pynodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pyutils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pyutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2309509b5ec32520bf8c79c3bdce4e05b27d1f6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/pyutils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/rewriting.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/rewriting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1c2608e92c1753795303a828b56f1ba640fc960
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/rewriting.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/scipy_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/scipy_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d43b628dc00d0e5d36547f2ec17044538637f118
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/__pycache__/scipy_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/abstract_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/abstract_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae0a8b3e996a7112edf2568c00138e11c3f3327d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/abstract_nodes.py
@@ -0,0 +1,18 @@
+"""This module provides containers for python objects that are valid
+printing targets but are not a subclass of SymPy's Printable.
+"""
+
+
+from sympy.core.containers import Tuple
+
+
+class List(Tuple):
+    """Represents a (frozen) (Python) list (for code printing purposes)."""
+    def __eq__(self, other):
+        if isinstance(other, list):
+            return self == List(*other)
+        else:
+            return self.args == other
+
+    def __hash__(self):
+        return super().__hash__()
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/algorithms.py b/.venv/lib/python3.12/site-packages/sympy/codegen/algorithms.py
new file mode 100644
index 0000000000000000000000000000000000000000..f4890eb8c25e565095600e2713c0de270aa0cf97
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/algorithms.py
@@ -0,0 +1,180 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import oo
+from sympy.core.relational import (Gt, Lt)
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import Min, Max
+from sympy.logic.boolalg import And
+from sympy.codegen.ast import (
+    Assignment, AddAugmentedAssignment, break_, CodeBlock, Declaration, FunctionDefinition,
+    Print, Return, Scope, While, Variable, Pointer, real
+)
+from sympy.codegen.cfunctions import isnan
+
+""" This module collects functions for constructing ASTs representing algorithms. """
+
+def newtons_method(expr, wrt, atol=1e-12, delta=None, *, rtol=4e-16, debug=False,
+                   itermax=None, counter=None, delta_fn=lambda e, x: -e/e.diff(x),
+                   cse=False, handle_nan=None,
+                   bounds=None):
+    """ Generates an AST for Newton-Raphson method (a root-finding algorithm).
+
+    Explanation
+    ===========
+
+    Returns an abstract syntax tree (AST) based on ``sympy.codegen.ast`` for Netwon's
+    method of root-finding.
+
+    Parameters
+    ==========
+
+    expr : expression
+    wrt : Symbol
+        With respect to, i.e. what is the variable.
+    atol : number or expression
+        Absolute tolerance (stopping criterion)
+    rtol : number or expression
+        Relative tolerance (stopping criterion)
+    delta : Symbol
+        Will be a ``Dummy`` if ``None``.
+    debug : bool
+        Whether to print convergence information during iterations
+    itermax : number or expr
+        Maximum number of iterations.
+    counter : Symbol
+        Will be a ``Dummy`` if ``None``.
+    delta_fn: Callable[[Expr, Symbol], Expr]
+        computes the step, default is newtons method. For e.g. Halley's method
+        use delta_fn=lambda e, x: -2*e*e.diff(x)/(2*e.diff(x)**2 - e*e.diff(x, 2))
+    cse: bool
+        Perform common sub-expression elimination on delta expression
+    handle_nan: Token
+        How to handle occurrence of not-a-number (NaN).
+    bounds: Optional[tuple[Expr, Expr]]
+        Perform optimization within bounds
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, cos
+    >>> from sympy.codegen.ast import Assignment
+    >>> from sympy.codegen.algorithms import newtons_method
+    >>> x, dx, atol = symbols('x dx atol')
+    >>> expr = cos(x) - x**3
+    >>> algo = newtons_method(expr, x, atol=atol, delta=dx)
+    >>> algo.has(Assignment(dx, -expr/expr.diff(x)))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Newton%27s_method
+
+    """
+
+    if delta is None:
+        delta = Dummy()
+        Wrapper = Scope
+        name_d = 'delta'
+    else:
+        Wrapper = lambda x: x
+        name_d = delta.name
+
+    delta_expr = delta_fn(expr, wrt)
+    if cse:
+        from sympy.simplify.cse_main import cse
+        cses, (red,) = cse([delta_expr.factor()])
+        whl_bdy = [Assignment(dum, sub_e) for dum, sub_e in cses]
+        whl_bdy += [Assignment(delta, red)]
+    else:
+        whl_bdy = [Assignment(delta, delta_expr)]
+    if handle_nan is not None:
+        whl_bdy += [While(isnan(delta), CodeBlock(handle_nan, break_))]
+    whl_bdy += [AddAugmentedAssignment(wrt, delta)]
+    if bounds is not None:
+        whl_bdy += [Assignment(wrt, Min(Max(wrt, bounds[0]), bounds[1]))]
+    if debug:
+        prnt = Print([wrt, delta], r"{}=%12.5g {}=%12.5g\n".format(wrt.name, name_d))
+        whl_bdy += [prnt]
+    req = Gt(Abs(delta), atol + rtol*Abs(wrt))
+    declars = [Declaration(Variable(delta, type=real, value=oo))]
+    if itermax is not None:
+        counter = counter or Dummy(integer=True)
+        v_counter = Variable.deduced(counter, 0)
+        declars.append(Declaration(v_counter))
+        whl_bdy.append(AddAugmentedAssignment(counter, 1))
+        req = And(req, Lt(counter, itermax))
+    whl = While(req, CodeBlock(*whl_bdy))
+    blck = declars
+    if debug:
+        blck.append(Print([wrt], r"{}=%12.5g\n".format(wrt.name)))
+    blck += [whl]
+    return Wrapper(CodeBlock(*blck))
+
+
+def _symbol_of(arg):
+    if isinstance(arg, Declaration):
+        arg = arg.variable.symbol
+    elif isinstance(arg, Variable):
+        arg = arg.symbol
+    return arg
+
+
+def newtons_method_function(expr, wrt, params=None, func_name="newton", attrs=Tuple(), *, delta=None, **kwargs):
+    """ Generates an AST for a function implementing the Newton-Raphson method.
+
+    Parameters
+    ==========
+
+    expr : expression
+    wrt : Symbol
+        With respect to, i.e. what is the variable
+    params : iterable of symbols
+        Symbols appearing in expr that are taken as constants during the iterations
+        (these will be accepted as parameters to the generated function).
+    func_name : str
+        Name of the generated function.
+    attrs : Tuple
+        Attribute instances passed as ``attrs`` to ``FunctionDefinition``.
+    \\*\\*kwargs :
+        Keyword arguments passed to :func:`sympy.codegen.algorithms.newtons_method`.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, cos
+    >>> from sympy.codegen.algorithms import newtons_method_function
+    >>> from sympy.codegen.pyutils import render_as_module
+    >>> x = symbols('x')
+    >>> expr = cos(x) - x**3
+    >>> func = newtons_method_function(expr, x)
+    >>> py_mod = render_as_module(func)  # source code as string
+    >>> namespace = {}
+    >>> exec(py_mod, namespace, namespace)
+    >>> res = eval('newton(0.5)', namespace)
+    >>> abs(res - 0.865474033102) < 1e-12
+    True
+
+    See Also
+    ========
+
+    sympy.codegen.algorithms.newtons_method
+
+    """
+    if params is None:
+        params = (wrt,)
+    pointer_subs = {p.symbol: Symbol('(*%s)' % p.symbol.name)
+                    for p in params if isinstance(p, Pointer)}
+    if delta is None:
+        delta = Symbol('d_' + wrt.name)
+        if expr.has(delta):
+            delta = None  # will use Dummy
+    algo = newtons_method(expr, wrt, delta=delta, **kwargs).xreplace(pointer_subs)
+    if isinstance(algo, Scope):
+        algo = algo.body
+    not_in_params = expr.free_symbols.difference({_symbol_of(p) for p in params})
+    if not_in_params:
+        raise ValueError("Missing symbols in params: %s" % ', '.join(map(str, not_in_params)))
+    declars = tuple(Variable(p, real) for p in params)
+    body = CodeBlock(algo, Return(wrt))
+    return FunctionDefinition(real, func_name, declars, body, attrs=attrs)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/approximations.py b/.venv/lib/python3.12/site-packages/sympy/codegen/approximations.py
new file mode 100644
index 0000000000000000000000000000000000000000..c6486926938224c5052dc5adfac29807e82eb4d8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/approximations.py
@@ -0,0 +1,187 @@
+import math
+from sympy.sets.sets import Interval
+from sympy.calculus.singularities import is_increasing, is_decreasing
+from sympy.codegen.rewriting import Optimization
+from sympy.core.function import UndefinedFunction
+
+"""
+This module collects classes useful for approximate rewriting of expressions.
+This can be beneficial when generating numeric code for which performance is
+of greater importance than precision (e.g. for preconditioners used in iterative
+methods).
+"""
+
+class SumApprox(Optimization):
+    """
+    Approximates sum by neglecting small terms.
+
+    Explanation
+    ===========
+
+    If terms are expressions which can be determined to be monotonic, then
+    bounds for those expressions are added.
+
+    Parameters
+    ==========
+
+    bounds : dict
+        Mapping expressions to length 2 tuple of bounds (low, high).
+    reltol : number
+        Threshold for when to ignore a term. Taken relative to the largest
+        lower bound among bounds.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.codegen.rewriting import optimize
+    >>> from sympy.codegen.approximations import SumApprox
+    >>> bounds = {x: (-1, 1), y: (1000, 2000), z: (-10, 3)}
+    >>> sum_approx3 = SumApprox(bounds, reltol=1e-3)
+    >>> sum_approx2 = SumApprox(bounds, reltol=1e-2)
+    >>> sum_approx1 = SumApprox(bounds, reltol=1e-1)
+    >>> expr = 3*(x + y + exp(z))
+    >>> optimize(expr, [sum_approx3])
+    3*(x + y + exp(z))
+    >>> optimize(expr, [sum_approx2])
+    3*y + 3*exp(z)
+    >>> optimize(expr, [sum_approx1])
+    3*y
+
+    """
+
+    def __init__(self, bounds, reltol, **kwargs):
+        super().__init__(**kwargs)
+        self.bounds = bounds
+        self.reltol = reltol
+
+    def __call__(self, expr):
+        return expr.factor().replace(self.query, lambda arg: self.value(arg))
+
+    def query(self, expr):
+        return expr.is_Add
+
+    def value(self, add):
+        for term in add.args:
+            if term.is_number or term in self.bounds or len(term.free_symbols) != 1:
+                continue
+            fs, = term.free_symbols
+            if fs not in self.bounds:
+                continue
+            intrvl = Interval(*self.bounds[fs])
+            if is_increasing(term, intrvl, fs):
+                self.bounds[term] = (
+                    term.subs({fs: self.bounds[fs][0]}),
+                    term.subs({fs: self.bounds[fs][1]})
+                )
+            elif is_decreasing(term, intrvl, fs):
+                self.bounds[term] = (
+                    term.subs({fs: self.bounds[fs][1]}),
+                    term.subs({fs: self.bounds[fs][0]})
+                )
+            else:
+                return add
+
+        if all(term.is_number or term in self.bounds for term in add.args):
+            bounds = [(term, term) if term.is_number else self.bounds[term] for term in add.args]
+            largest_abs_guarantee = 0
+            for lo, hi in bounds:
+                if lo <= 0 <= hi:
+                    continue
+                largest_abs_guarantee = max(largest_abs_guarantee,
+                                            min(abs(lo), abs(hi)))
+            new_terms = []
+            for term, (lo, hi) in zip(add.args, bounds):
+                if max(abs(lo), abs(hi)) >= largest_abs_guarantee*self.reltol:
+                    new_terms.append(term)
+            return add.func(*new_terms)
+        else:
+            return add
+
+
+class SeriesApprox(Optimization):
+    """ Approximates functions by expanding them as a series.
+
+    Parameters
+    ==========
+
+    bounds : dict
+        Mapping expressions to length 2 tuple of bounds (low, high).
+    reltol : number
+        Threshold for when to ignore a term. Taken relative to the largest
+        lower bound among bounds.
+    max_order : int
+        Largest order to include in series expansion
+    n_point_checks : int (even)
+        The validity of an expansion (with respect to reltol) is checked at
+        discrete points (linearly spaced over the bounds of the variable). The
+        number of points used in this numerical check is given by this number.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, pi
+    >>> from sympy.abc import x, y
+    >>> from sympy.codegen.rewriting import optimize
+    >>> from sympy.codegen.approximations import SeriesApprox
+    >>> bounds = {x: (-.1, .1), y: (pi-1, pi+1)}
+    >>> series_approx2 = SeriesApprox(bounds, reltol=1e-2)
+    >>> series_approx3 = SeriesApprox(bounds, reltol=1e-3)
+    >>> series_approx8 = SeriesApprox(bounds, reltol=1e-8)
+    >>> expr = sin(x)*sin(y)
+    >>> optimize(expr, [series_approx2])
+    x*(-y + (y - pi)**3/6 + pi)
+    >>> optimize(expr, [series_approx3])
+    (-x**3/6 + x)*sin(y)
+    >>> optimize(expr, [series_approx8])
+    sin(x)*sin(y)
+
+    """
+    def __init__(self, bounds, reltol, max_order=4, n_point_checks=4, **kwargs):
+        super().__init__(**kwargs)
+        self.bounds = bounds
+        self.reltol = reltol
+        self.max_order = max_order
+        if n_point_checks % 2 == 1:
+            raise ValueError("Checking the solution at expansion point is not helpful")
+        self.n_point_checks = n_point_checks
+        self._prec = math.ceil(-math.log10(self.reltol))
+
+    def __call__(self, expr):
+        return expr.factor().replace(self.query, lambda arg: self.value(arg))
+
+    def query(self, expr):
+        return (expr.is_Function and not isinstance(expr, UndefinedFunction)
+                and len(expr.args) == 1)
+
+    def value(self, fexpr):
+        free_symbols = fexpr.free_symbols
+        if len(free_symbols) != 1:
+            return fexpr
+        symb, = free_symbols
+        if symb not in self.bounds:
+            return fexpr
+        lo, hi = self.bounds[symb]
+        x0 = (lo + hi)/2
+        cheapest = None
+        for n in range(self.max_order+1, 0, -1):
+            fseri = fexpr.series(symb, x0=x0, n=n).removeO()
+            n_ok = True
+            for idx in range(self.n_point_checks):
+                x = lo + idx*(hi - lo)/(self.n_point_checks - 1)
+                val = fseri.xreplace({symb: x})
+                ref = fexpr.xreplace({symb: x})
+                if abs((1 - val/ref).evalf(self._prec)) > self.reltol:
+                    n_ok = False
+                    break
+
+            if n_ok:
+                cheapest = fseri
+            else:
+                break
+
+        if cheapest is None:
+            return fexpr
+        else:
+            return cheapest
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/ast.py b/.venv/lib/python3.12/site-packages/sympy/codegen/ast.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd774ca87c5c9d4b55c8ea7a3b68837035b0d06d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/ast.py
@@ -0,0 +1,1906 @@
+"""
+Types used to represent a full function/module as an Abstract Syntax Tree.
+
+Most types are small, and are merely used as tokens in the AST. A tree diagram
+has been included below to illustrate the relationships between the AST types.
+
+
+AST Type Tree
+-------------
+::
+
+  *Basic*
+       |
+       |
+   CodegenAST
+       |
+       |--->AssignmentBase
+       |             |--->Assignment
+       |             |--->AugmentedAssignment
+       |                                    |--->AddAugmentedAssignment
+       |                                    |--->SubAugmentedAssignment
+       |                                    |--->MulAugmentedAssignment
+       |                                    |--->DivAugmentedAssignment
+       |                                    |--->ModAugmentedAssignment
+       |
+       |--->CodeBlock
+       |
+       |
+       |--->Token
+                |--->Attribute
+                |--->For
+                |--->String
+                |       |--->QuotedString
+                |       |--->Comment
+                |--->Type
+                |       |--->IntBaseType
+                |       |              |--->_SizedIntType
+                |       |                               |--->SignedIntType
+                |       |                               |--->UnsignedIntType
+                |       |--->FloatBaseType
+                |                        |--->FloatType
+                |                        |--->ComplexBaseType
+                |                                           |--->ComplexType
+                |--->Node
+                |       |--->Variable
+                |       |           |---> Pointer
+                |       |--->FunctionPrototype
+                |                            |--->FunctionDefinition
+                |--->Element
+                |--->Declaration
+                |--->While
+                |--->Scope
+                |--->Stream
+                |--->Print
+                |--->FunctionCall
+                |--->BreakToken
+                |--->ContinueToken
+                |--->NoneToken
+                |--->Return
+
+
+Predefined types
+----------------
+
+A number of ``Type`` instances are provided in the ``sympy.codegen.ast`` module
+for convenience. Perhaps the two most common ones for code-generation (of numeric
+codes) are ``float32`` and ``float64`` (known as single and double precision respectively).
+There are also precision generic versions of Types (for which the codeprinters selects the
+underlying data type at time of printing): ``real``, ``integer``, ``complex_``, ``bool_``.
+
+The other ``Type`` instances defined are:
+
+- ``intc``: Integer type used by C's "int".
+- ``intp``: Integer type used by C's "unsigned".
+- ``int8``, ``int16``, ``int32``, ``int64``: n-bit integers.
+- ``uint8``, ``uint16``, ``uint32``, ``uint64``: n-bit unsigned integers.
+- ``float80``: known as "extended precision" on modern x86/amd64 hardware.
+- ``complex64``: Complex number represented by two ``float32`` numbers
+- ``complex128``: Complex number represented by two ``float64`` numbers
+
+Using the nodes
+---------------
+
+It is possible to construct simple algorithms using the AST nodes. Let's construct a loop applying
+Newton's method::
+
+    >>> from sympy import symbols, cos
+    >>> from sympy.codegen.ast import While, Assignment, aug_assign, Print, QuotedString
+    >>> t, dx, x = symbols('tol delta val')
+    >>> expr = cos(x) - x**3
+    >>> whl = While(abs(dx) > t, [
+    ...     Assignment(dx, -expr/expr.diff(x)),
+    ...     aug_assign(x, '+', dx),
+    ...     Print([x])
+    ... ])
+    >>> from sympy import pycode
+    >>> py_str = pycode(whl)
+    >>> print(py_str)
+    while (abs(delta) > tol):
+        delta = (val**3 - math.cos(val))/(-3*val**2 - math.sin(val))
+        val += delta
+        print(val)
+    >>> import math
+    >>> tol, val, delta = 1e-5, 0.5, float('inf')
+    >>> exec(py_str)
+    1.1121416371
+    0.909672693737
+    0.867263818209
+    0.865477135298
+    0.865474033111
+    >>> print('%3.1g' % (math.cos(val) - val**3))
+    -3e-11
+
+If we want to generate Fortran code for the same while loop we simple call ``fcode``::
+
+    >>> from sympy import fcode
+    >>> print(fcode(whl, standard=2003, source_format='free'))
+    do while (abs(delta) > tol)
+       delta = (val**3 - cos(val))/(-3*val**2 - sin(val))
+       val = val + delta
+       print *, val
+    end do
+
+There is a function constructing a loop (or a complete function) like this in
+:mod:`sympy.codegen.algorithms`.
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from collections import defaultdict
+
+from sympy.core.relational import (Ge, Gt, Le, Lt)
+from sympy.core import Symbol, Tuple, Dummy
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr, Atom
+from sympy.core.numbers import Float, Integer, oo
+from sympy.core.sympify import _sympify, sympify, SympifyError
+from sympy.utilities.iterables import (iterable, topological_sort,
+                                       numbered_symbols, filter_symbols)
+
+
+def _mk_Tuple(args):
+    """
+    Create a SymPy Tuple object from an iterable, converting Python strings to
+    AST strings.
+
+    Parameters
+    ==========
+
+    args: iterable
+        Arguments to :class:`sympy.Tuple`.
+
+    Returns
+    =======
+
+    sympy.Tuple
+    """
+    args = [String(arg) if isinstance(arg, str) else arg for arg in args]
+    return Tuple(*args)
+
+
+class CodegenAST(Basic):
+    __slots__ = ()
+
+
+class Token(CodegenAST):
+    """ Base class for the AST types.
+
+    Explanation
+    ===========
+
+    Defining fields are set in ``_fields``. Attributes (defined in _fields)
+    are only allowed to contain instances of Basic (unless atomic, see
+    ``String``). The arguments to ``__new__()`` correspond to the attributes in
+    the order defined in ``_fields`. The ``defaults`` class attribute is a
+    dictionary mapping attribute names to their default values.
+
+    Subclasses should not need to override the ``__new__()`` method. They may
+    define a class or static method named ``_construct_`` for each
+    attribute to process the value passed to ``__new__()``. Attributes listed
+    in the class attribute ``not_in_args`` are not passed to :class:`~.Basic`.
+    """
+
+    __slots__: tuple[str, ...] = ()
+    _fields = __slots__
+    defaults: dict[str, Any] = {}
+    not_in_args: list[str] = []
+    indented_args = ['body']
+
+    @property
+    def is_Atom(self):
+        return len(self._fields) == 0
+
+    @classmethod
+    def _get_constructor(cls, attr):
+        """ Get the constructor function for an attribute by name. """
+        return getattr(cls, '_construct_%s' % attr, lambda x: x)
+
+    @classmethod
+    def _construct(cls, attr, arg):
+        """ Construct an attribute value from argument passed to ``__new__()``. """
+        # arg may be ``NoneToken()``, so comparison is done using == instead of ``is`` operator
+        if arg == None:
+            return cls.defaults.get(attr, none)
+        else:
+            if isinstance(arg, Dummy):  # SymPy's replace uses Dummy instances
+                return arg
+            else:
+                return cls._get_constructor(attr)(arg)
+
+    def __new__(cls, *args, **kwargs):
+        # Pass through existing instances when given as sole argument
+        if len(args) == 1 and not kwargs and isinstance(args[0], cls):
+            return args[0]
+
+        if len(args) > len(cls._fields):
+            raise ValueError("Too many arguments (%d), expected at most %d" % (len(args), len(cls._fields)))
+
+        attrvals = []
+
+        # Process positional arguments
+        for attrname, argval in zip(cls._fields, args):
+            if attrname in kwargs:
+                raise TypeError('Got multiple values for attribute %r' % attrname)
+
+            attrvals.append(cls._construct(attrname, argval))
+
+        # Process keyword arguments
+        for attrname in cls._fields[len(args):]:
+            if attrname in kwargs:
+                argval = kwargs.pop(attrname)
+
+            elif attrname in cls.defaults:
+                argval = cls.defaults[attrname]
+
+            else:
+                raise TypeError('No value for %r given and attribute has no default' % attrname)
+
+            attrvals.append(cls._construct(attrname, argval))
+
+        if kwargs:
+            raise ValueError("Unknown keyword arguments: %s" % ' '.join(kwargs))
+
+        # Parent constructor
+        basic_args = [
+            val for attr, val in zip(cls._fields, attrvals)
+            if attr not in cls.not_in_args
+        ]
+        obj = CodegenAST.__new__(cls, *basic_args)
+
+        # Set attributes
+        for attr, arg in zip(cls._fields, attrvals):
+            setattr(obj, attr, arg)
+
+        return obj
+
+    def __eq__(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        for attr in self._fields:
+            if getattr(self, attr) != getattr(other, attr):
+                return False
+        return True
+
+    def _hashable_content(self):
+        return tuple([getattr(self, attr) for attr in self._fields])
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def _joiner(self, k, indent_level):
+        return (',\n' + ' '*indent_level) if k in self.indented_args else ', '
+
+    def _indented(self, printer, k, v, *args, **kwargs):
+        il = printer._context['indent_level']
+        def _print(arg):
+            if isinstance(arg, Token):
+                return printer._print(arg, *args, joiner=self._joiner(k, il), **kwargs)
+            else:
+                return printer._print(arg, *args, **kwargs)
+
+        if isinstance(v, Tuple):
+            joined = self._joiner(k, il).join([_print(arg) for arg in v.args])
+            if k in self.indented_args:
+                return '(\n' + ' '*il + joined + ',\n' + ' '*(il - 4) + ')'
+            else:
+                return ('({0},)' if len(v.args) == 1 else '({0})').format(joined)
+        else:
+            return _print(v)
+
+    def _sympyrepr(self, printer, *args, joiner=', ', **kwargs):
+        from sympy.printing.printer import printer_context
+        exclude = kwargs.get('exclude', ())
+        values = [getattr(self, k) for k in self._fields]
+        indent_level = printer._context.get('indent_level', 0)
+
+        arg_reprs = []
+
+        for i, (attr, value) in enumerate(zip(self._fields, values)):
+            if attr in exclude:
+                continue
+
+            # Skip attributes which have the default value
+            if attr in self.defaults and value == self.defaults[attr]:
+                continue
+
+            ilvl = indent_level + 4 if attr in self.indented_args else 0
+            with printer_context(printer, indent_level=ilvl):
+                indented = self._indented(printer, attr, value, *args, **kwargs)
+            arg_reprs.append(('{1}' if i == 0 else '{0}={1}').format(attr, indented.lstrip()))
+
+        return "{}({})".format(self.__class__.__name__, joiner.join(arg_reprs))
+
+    _sympystr = _sympyrepr
+
+    def __repr__(self):  # sympy.core.Basic.__repr__ uses sstr
+        from sympy.printing import srepr
+        return srepr(self)
+
+    def kwargs(self, exclude=(), apply=None):
+        """ Get instance's attributes as dict of keyword arguments.
+
+        Parameters
+        ==========
+
+        exclude : collection of str
+            Collection of keywords to exclude.
+
+        apply : callable, optional
+            Function to apply to all values.
+        """
+        kwargs = {k: getattr(self, k) for k in self._fields if k not in exclude}
+        if apply is not None:
+            return {k: apply(v) for k, v in kwargs.items()}
+        else:
+            return kwargs
+
+class BreakToken(Token):
+    """ Represents 'break' in C/Python ('exit' in Fortran).
+
+    Use the premade instance ``break_`` or instantiate manually.
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, fcode
+    >>> from sympy.codegen.ast import break_
+    >>> ccode(break_)
+    'break'
+    >>> fcode(break_, source_format='free')
+    'exit'
+    """
+
+break_ = BreakToken()
+
+
+class ContinueToken(Token):
+    """ Represents 'continue' in C/Python ('cycle' in Fortran)
+
+    Use the premade instance ``continue_`` or instantiate manually.
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, fcode
+    >>> from sympy.codegen.ast import continue_
+    >>> ccode(continue_)
+    'continue'
+    >>> fcode(continue_, source_format='free')
+    'cycle'
+    """
+
+continue_ = ContinueToken()
+
+class NoneToken(Token):
+    """ The AST equivalence of Python's NoneType
+
+    The corresponding instance of Python's ``None`` is ``none``.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import none, Variable
+    >>> from sympy import pycode
+    >>> print(pycode(Variable('x').as_Declaration(value=none)))
+    x = None
+
+    """
+    def __eq__(self, other):
+        return other is None or isinstance(other, NoneToken)
+
+    def _hashable_content(self):
+        return ()
+
+    def __hash__(self):
+        return super().__hash__()
+
+
+none = NoneToken()
+
+
+class AssignmentBase(CodegenAST):
+    """ Abstract base class for Assignment and AugmentedAssignment.
+
+    Attributes:
+    ===========
+
+    op : str
+        Symbol for assignment operator, e.g. "=", "+=", etc.
+    """
+
+    def __new__(cls, lhs, rhs):
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+
+        cls._check_args(lhs, rhs)
+
+        return super().__new__(cls, lhs, rhs)
+
+    @property
+    def lhs(self):
+        return self.args[0]
+
+    @property
+    def rhs(self):
+        return self.args[1]
+
+    @classmethod
+    def _check_args(cls, lhs, rhs):
+        """ Check arguments to __new__ and raise exception if any problems found.
+
+        Derived classes may wish to override this.
+        """
+        from sympy.matrices.expressions.matexpr import (
+            MatrixElement, MatrixSymbol)
+        from sympy.tensor.indexed import Indexed
+        from sympy.tensor.array.expressions import ArrayElement
+
+        # Tuple of things that can be on the lhs of an assignment
+        assignable = (Symbol, MatrixSymbol, MatrixElement, Indexed, Element, Variable,
+                ArrayElement)
+        if not isinstance(lhs, assignable):
+            raise TypeError("Cannot assign to lhs of type %s." % type(lhs))
+
+        # Indexed types implement shape, but don't define it until later. This
+        # causes issues in assignment validation. For now, matrices are defined
+        # as anything with a shape that is not an Indexed
+        lhs_is_mat = hasattr(lhs, 'shape') and not isinstance(lhs, Indexed)
+        rhs_is_mat = hasattr(rhs, 'shape') and not isinstance(rhs, Indexed)
+
+        # If lhs and rhs have same structure, then this assignment is ok
+        if lhs_is_mat:
+            if not rhs_is_mat:
+                raise ValueError("Cannot assign a scalar to a matrix.")
+            elif lhs.shape != rhs.shape:
+                raise ValueError("Dimensions of lhs and rhs do not align.")
+        elif rhs_is_mat and not lhs_is_mat:
+            raise ValueError("Cannot assign a matrix to a scalar.")
+
+
+class Assignment(AssignmentBase):
+    """
+    Represents variable assignment for code generation.
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        SymPy object representing the lhs of the expression. These should be
+        singular objects, such as one would use in writing code. Notable types
+        include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that
+        subclass these types are also supported.
+
+    rhs : Expr
+        SymPy object representing the rhs of the expression. This can be any
+        type, provided its shape corresponds to that of the lhs. For example,
+        a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as
+        the dimensions will not align.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, MatrixSymbol, Matrix
+    >>> from sympy.codegen.ast import Assignment
+    >>> x, y, z = symbols('x, y, z')
+    >>> Assignment(x, y)
+    Assignment(x, y)
+    >>> Assignment(x, 0)
+    Assignment(x, 0)
+    >>> A = MatrixSymbol('A', 1, 3)
+    >>> mat = Matrix([x, y, z]).T
+    >>> Assignment(A, mat)
+    Assignment(A, Matrix([[x, y, z]]))
+    >>> Assignment(A[0, 1], x)
+    Assignment(A[0, 1], x)
+    """
+
+    op = ':='
+
+
+class AugmentedAssignment(AssignmentBase):
+    """
+    Base class for augmented assignments.
+
+    Attributes:
+    ===========
+
+    binop : str
+       Symbol for binary operation being applied in the assignment, such as "+",
+       "*", etc.
+    """
+    binop: str | None
+
+    @property
+    def op(self):
+        return self.binop + '='
+
+
+class AddAugmentedAssignment(AugmentedAssignment):
+    binop = '+'
+
+
+class SubAugmentedAssignment(AugmentedAssignment):
+    binop = '-'
+
+
+class MulAugmentedAssignment(AugmentedAssignment):
+    binop = '*'
+
+
+class DivAugmentedAssignment(AugmentedAssignment):
+    binop = '/'
+
+
+class ModAugmentedAssignment(AugmentedAssignment):
+    binop = '%'
+
+
+# Mapping from binary op strings to AugmentedAssignment subclasses
+augassign_classes = {
+    cls.binop: cls for cls in [
+        AddAugmentedAssignment, SubAugmentedAssignment, MulAugmentedAssignment,
+        DivAugmentedAssignment, ModAugmentedAssignment
+    ]
+}
+
+
+def aug_assign(lhs, op, rhs):
+    """
+    Create 'lhs op= rhs'.
+
+    Explanation
+    ===========
+
+    Represents augmented variable assignment for code generation. This is a
+    convenience function. You can also use the AugmentedAssignment classes
+    directly, like AddAugmentedAssignment(x, y).
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        SymPy object representing the lhs of the expression. These should be
+        singular objects, such as one would use in writing code. Notable types
+        include Symbol, MatrixSymbol, MatrixElement, and Indexed. Types that
+        subclass these types are also supported.
+
+    op : str
+        Operator (+, -, /, \\*, %).
+
+    rhs : Expr
+        SymPy object representing the rhs of the expression. This can be any
+        type, provided its shape corresponds to that of the lhs. For example,
+        a Matrix type can be assigned to MatrixSymbol, but not to Symbol, as
+        the dimensions will not align.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy.codegen.ast import aug_assign
+    >>> x, y = symbols('x, y')
+    >>> aug_assign(x, '+', y)
+    AddAugmentedAssignment(x, y)
+    """
+    if op not in augassign_classes:
+        raise ValueError("Unrecognized operator %s" % op)
+    return augassign_classes[op](lhs, rhs)
+
+
+class CodeBlock(CodegenAST):
+    """
+    Represents a block of code.
+
+    Explanation
+    ===========
+
+    For now only assignments are supported. This restriction will be lifted in
+    the future.
+
+    Useful attributes on this object are:
+
+    ``left_hand_sides``:
+        Tuple of left-hand sides of assignments, in order.
+    ``left_hand_sides``:
+        Tuple of right-hand sides of assignments, in order.
+    ``free_symbols``: Free symbols of the expressions in the right-hand sides
+        which do not appear in the left-hand side of an assignment.
+
+    Useful methods on this object are:
+
+    ``topological_sort``:
+        Class method. Return a CodeBlock with assignments
+        sorted so that variables are assigned before they
+        are used.
+    ``cse``:
+        Return a new CodeBlock with common subexpressions eliminated and
+        pulled out as assignments.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, ccode
+    >>> from sympy.codegen.ast import CodeBlock, Assignment
+    >>> x, y = symbols('x y')
+    >>> c = CodeBlock(Assignment(x, 1), Assignment(y, x + 1))
+    >>> print(ccode(c))
+    x = 1;
+    y = x + 1;
+
+    """
+    def __new__(cls, *args):
+        left_hand_sides = []
+        right_hand_sides = []
+        for i in args:
+            if isinstance(i, Assignment):
+                lhs, rhs = i.args
+                left_hand_sides.append(lhs)
+                right_hand_sides.append(rhs)
+
+        obj = CodegenAST.__new__(cls, *args)
+
+        obj.left_hand_sides = Tuple(*left_hand_sides)
+        obj.right_hand_sides = Tuple(*right_hand_sides)
+        return obj
+
+    def __iter__(self):
+        return iter(self.args)
+
+    def _sympyrepr(self, printer, *args, **kwargs):
+        il = printer._context.get('indent_level', 0)
+        joiner = ',\n' + ' '*il
+        joined = joiner.join(map(printer._print, self.args))
+        return ('{}(\n'.format(' '*(il-4) + self.__class__.__name__,) +
+                ' '*il + joined + '\n' + ' '*(il - 4) + ')')
+
+    _sympystr = _sympyrepr
+
+    @property
+    def free_symbols(self):
+        return super().free_symbols - set(self.left_hand_sides)
+
+    @classmethod
+    def topological_sort(cls, assignments):
+        """
+        Return a CodeBlock with topologically sorted assignments so that
+        variables are assigned before they are used.
+
+        Examples
+        ========
+
+        The existing order of assignments is preserved as much as possible.
+
+        This function assumes that variables are assigned to only once.
+
+        This is a class constructor so that the default constructor for
+        CodeBlock can error when variables are used before they are assigned.
+
+        >>> from sympy import symbols
+        >>> from sympy.codegen.ast import CodeBlock, Assignment
+        >>> x, y, z = symbols('x y z')
+
+        >>> assignments = [
+        ...     Assignment(x, y + z),
+        ...     Assignment(y, z + 1),
+        ...     Assignment(z, 2),
+        ... ]
+        >>> CodeBlock.topological_sort(assignments)
+        CodeBlock(
+            Assignment(z, 2),
+            Assignment(y, z + 1),
+            Assignment(x, y + z)
+        )
+
+        """
+
+        if not all(isinstance(i, Assignment) for i in assignments):
+            # Will support more things later
+            raise NotImplementedError("CodeBlock.topological_sort only supports Assignments")
+
+        if any(isinstance(i, AugmentedAssignment) for i in assignments):
+            raise NotImplementedError("CodeBlock.topological_sort does not yet work with AugmentedAssignments")
+
+        # Create a graph where the nodes are assignments and there is a directed edge
+        # between nodes that use a variable and nodes that assign that
+        # variable, like
+
+        # [(x := 1, y := x + 1), (x := 1, z := y + z), (y := x + 1, z := y + z)]
+
+        # If we then topologically sort these nodes, they will be in
+        # assignment order, like
+
+        # x := 1
+        # y := x + 1
+        # z := y + z
+
+        # A = The nodes
+        #
+        # enumerate keeps nodes in the same order they are already in if
+        # possible. It will also allow us to handle duplicate assignments to
+        # the same variable when those are implemented.
+        A = list(enumerate(assignments))
+
+        # var_map = {variable: [nodes for which this variable is assigned to]}
+        # like {x: [(1, x := y + z), (4, x := 2 * w)], ...}
+        var_map = defaultdict(list)
+        for node in A:
+            i, a = node
+            var_map[a.lhs].append(node)
+
+        # E = Edges in the graph
+        E = []
+        for dst_node in A:
+            i, a = dst_node
+            for s in a.rhs.free_symbols:
+                for src_node in var_map[s]:
+                    E.append((src_node, dst_node))
+
+        ordered_assignments = topological_sort([A, E])
+
+        # De-enumerate the result
+        return cls(*[a for i, a in ordered_assignments])
+
+    def cse(self, symbols=None, optimizations=None, postprocess=None,
+        order='canonical'):
+        """
+        Return a new code block with common subexpressions eliminated.
+
+        Explanation
+        ===========
+
+        See the docstring of :func:`sympy.simplify.cse_main.cse` for more
+        information.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, sin
+        >>> from sympy.codegen.ast import CodeBlock, Assignment
+        >>> x, y, z = symbols('x y z')
+
+        >>> c = CodeBlock(
+        ...     Assignment(x, 1),
+        ...     Assignment(y, sin(x) + 1),
+        ...     Assignment(z, sin(x) - 1),
+        ... )
+        ...
+        >>> c.cse()
+        CodeBlock(
+            Assignment(x, 1),
+            Assignment(x0, sin(x)),
+            Assignment(y, x0 + 1),
+            Assignment(z, x0 - 1)
+        )
+
+        """
+        from sympy.simplify.cse_main import cse
+
+        # Check that the CodeBlock only contains assignments to unique variables
+        if not all(isinstance(i, Assignment) for i in self.args):
+            # Will support more things later
+            raise NotImplementedError("CodeBlock.cse only supports Assignments")
+
+        if any(isinstance(i, AugmentedAssignment) for i in self.args):
+            raise NotImplementedError("CodeBlock.cse does not yet work with AugmentedAssignments")
+
+        for i, lhs in enumerate(self.left_hand_sides):
+            if lhs in self.left_hand_sides[:i]:
+                raise NotImplementedError("Duplicate assignments to the same "
+                    "variable are not yet supported (%s)" % lhs)
+
+        # Ensure new symbols for subexpressions do not conflict with existing
+        existing_symbols = self.atoms(Symbol)
+        if symbols is None:
+            symbols = numbered_symbols()
+        symbols = filter_symbols(symbols, existing_symbols)
+
+        replacements, reduced_exprs = cse(list(self.right_hand_sides),
+            symbols=symbols, optimizations=optimizations, postprocess=postprocess,
+            order=order)
+
+        new_block = [Assignment(var, expr) for var, expr in
+            zip(self.left_hand_sides, reduced_exprs)]
+        new_assignments = [Assignment(var, expr) for var, expr in replacements]
+        return self.topological_sort(new_assignments + new_block)
+
+
+class For(Token):
+    """Represents a 'for-loop' in the code.
+
+    Expressions are of the form:
+        "for target in iter:
+            body..."
+
+    Parameters
+    ==========
+
+    target : symbol
+    iter : iterable
+    body : CodeBlock or iterable
+!        When passed an iterable it is used to instantiate a CodeBlock.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Range
+    >>> from sympy.codegen.ast import aug_assign, For
+    >>> x, i, j, k = symbols('x i j k')
+    >>> for_i = For(i, Range(10), [aug_assign(x, '+', i*j*k)])
+    >>> for_i  # doctest: -NORMALIZE_WHITESPACE
+    For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+        AddAugmentedAssignment(x, i*j*k)
+    ))
+    >>> for_ji = For(j, Range(7), [for_i])
+    >>> for_ji  # doctest: -NORMALIZE_WHITESPACE
+    For(j, iterable=Range(0, 7, 1), body=CodeBlock(
+        For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+            AddAugmentedAssignment(x, i*j*k)
+        ))
+    ))
+    >>> for_kji =For(k, Range(5), [for_ji])
+    >>> for_kji  # doctest: -NORMALIZE_WHITESPACE
+    For(k, iterable=Range(0, 5, 1), body=CodeBlock(
+        For(j, iterable=Range(0, 7, 1), body=CodeBlock(
+            For(i, iterable=Range(0, 10, 1), body=CodeBlock(
+                AddAugmentedAssignment(x, i*j*k)
+            ))
+        ))
+    ))
+    """
+    __slots__ = _fields = ('target', 'iterable', 'body')
+    _construct_target = staticmethod(_sympify)
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+    @classmethod
+    def _construct_iterable(cls, itr):
+        if not iterable(itr):
+            raise TypeError("iterable must be an iterable")
+        if isinstance(itr, list):  # _sympify errors on lists because they are mutable
+            itr = tuple(itr)
+        return _sympify(itr)
+
+
+class String(Atom, Token):
+    """ SymPy object representing a string.
+
+    Atomic object which is not an expression (as opposed to Symbol).
+
+    Parameters
+    ==========
+
+    text : str
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import String
+    >>> f = String('foo')
+    >>> f
+    foo
+    >>> str(f)
+    'foo'
+    >>> f.text
+    'foo'
+    >>> print(repr(f))
+    String('foo')
+
+    """
+    __slots__ = _fields = ('text',)
+    not_in_args = ['text']
+    is_Atom = True
+
+    @classmethod
+    def _construct_text(cls, text):
+        if not isinstance(text, str):
+            raise TypeError("Argument text is not a string type.")
+        return text
+
+    def _sympystr(self, printer, *args, **kwargs):
+        return self.text
+
+    def kwargs(self, exclude = (), apply = None):
+        return {}
+
+    #to be removed when Atom is given a suitable func
+    @property
+    def func(self):
+        return lambda: self
+
+    def _latex(self, printer):
+        from sympy.printing.latex import latex_escape
+        return r'\texttt{{"{}"}}'.format(latex_escape(self.text))
+
+class QuotedString(String):
+    """ Represents a string which should be printed with quotes. """
+
+class Comment(String):
+    """ Represents a comment. """
+
+class Node(Token):
+    """ Subclass of Token, carrying the attribute 'attrs' (Tuple)
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Node, value_const, pointer_const
+    >>> n1 = Node([value_const])
+    >>> n1.attr_params('value_const')  # get the parameters of attribute (by name)
+    ()
+    >>> from sympy.codegen.fnodes import dimension
+    >>> n2 = Node([value_const, dimension(5, 3)])
+    >>> n2.attr_params(value_const)  # get the parameters of attribute (by Attribute instance)
+    ()
+    >>> n2.attr_params('dimension')  # get the parameters of attribute (by name)
+    (5, 3)
+    >>> n2.attr_params(pointer_const) is None
+    True
+
+    """
+
+    __slots__: tuple[str, ...] = ('attrs',)
+    _fields = __slots__
+
+    defaults: dict[str, Any] = {'attrs': Tuple()}
+
+    _construct_attrs = staticmethod(_mk_Tuple)
+
+    def attr_params(self, looking_for):
+        """ Returns the parameters of the Attribute with name ``looking_for`` in self.attrs """
+        for attr in self.attrs:
+            if str(attr.name) == str(looking_for):
+                return attr.parameters
+
+
+class Type(Token):
+    """ Represents a type.
+
+    Explanation
+    ===========
+
+    The naming is a super-set of NumPy naming. Type has a classmethod
+    ``from_expr`` which offer type deduction. It also has a method
+    ``cast_check`` which casts the argument to its type, possibly raising an
+    exception if rounding error is not within tolerances, or if the value is not
+    representable by the underlying data type (e.g. unsigned integers).
+
+    Parameters
+    ==========
+
+    name : str
+        Name of the type, e.g. ``object``, ``int16``, ``float16`` (where the latter two
+        would use the ``Type`` sub-classes ``IntType`` and ``FloatType`` respectively).
+        If a ``Type`` instance is given, the said instance is returned.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Type
+    >>> t = Type.from_expr(42)
+    >>> t
+    integer
+    >>> print(repr(t))
+    IntBaseType(String('integer'))
+    >>> from sympy.codegen.ast import uint8
+    >>> uint8.cast_check(-1)   # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Minimum value for data type bigger than new value.
+    >>> from sympy.codegen.ast import float32
+    >>> v6 = 0.123456
+    >>> float32.cast_check(v6)
+    0.123456
+    >>> v10 = 12345.67894
+    >>> float32.cast_check(v10)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Casting gives a significantly different value.
+    >>> boost_mp50 = Type('boost::multiprecision::cpp_dec_float_50')
+    >>> from sympy import cxxcode
+    >>> from sympy.codegen.ast import Declaration, Variable
+    >>> cxxcode(Declaration(Variable('x', type=boost_mp50)))
+    'boost::multiprecision::cpp_dec_float_50 x'
+
+    References
+    ==========
+
+    .. [1] https://numpy.org/doc/stable/user/basics.types.html
+
+    """
+    __slots__: tuple[str, ...] = ('name',)
+    _fields = __slots__
+
+    _construct_name = String
+
+    def _sympystr(self, printer, *args, **kwargs):
+        return str(self.name)
+
+    @classmethod
+    def from_expr(cls, expr):
+        """ Deduces type from an expression or a ``Symbol``.
+
+        Parameters
+        ==========
+
+        expr : number or SymPy object
+            The type will be deduced from type or properties.
+
+        Examples
+        ========
+
+        >>> from sympy.codegen.ast import Type, integer, complex_
+        >>> Type.from_expr(2) == integer
+        True
+        >>> from sympy import Symbol
+        >>> Type.from_expr(Symbol('z', complex=True)) == complex_
+        True
+        >>> Type.from_expr(sum)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Could not deduce type from expr.
+
+        Raises
+        ======
+
+        ValueError when type deduction fails.
+
+        """
+        if isinstance(expr, (float, Float)):
+            return real
+        if isinstance(expr, (int, Integer)) or getattr(expr, 'is_integer', False):
+            return integer
+        if getattr(expr, 'is_real', False):
+            return real
+        if isinstance(expr, complex) or getattr(expr, 'is_complex', False):
+            return complex_
+        if isinstance(expr, bool) or getattr(expr, 'is_Relational', False):
+            return bool_
+        else:
+            raise ValueError("Could not deduce type from expr.")
+
+    def _check(self, value):
+        pass
+
+    def cast_check(self, value, rtol=None, atol=0, precision_targets=None):
+        """ Casts a value to the data type of the instance.
+
+        Parameters
+        ==========
+
+        value : number
+        rtol : floating point number
+            Relative tolerance. (will be deduced if not given).
+        atol : floating point number
+            Absolute tolerance (in addition to ``rtol``).
+        type_aliases : dict
+            Maps substitutions for Type, e.g. {integer: int64, real: float32}
+
+        Examples
+        ========
+
+        >>> from sympy.codegen.ast import integer, float32, int8
+        >>> integer.cast_check(3.0) == 3
+        True
+        >>> float32.cast_check(1e-40)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Minimum value for data type bigger than new value.
+        >>> int8.cast_check(256)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Maximum value for data type smaller than new value.
+        >>> v10 = 12345.67894
+        >>> float32.cast_check(v10)  # doctest: +ELLIPSIS
+        Traceback (most recent call last):
+          ...
+        ValueError: Casting gives a significantly different value.
+        >>> from sympy.codegen.ast import float64
+        >>> float64.cast_check(v10)
+        12345.67894
+        >>> from sympy import Float
+        >>> v18 = Float('0.123456789012345646')
+        >>> float64.cast_check(v18)
+        Traceback (most recent call last):
+          ...
+        ValueError: Casting gives a significantly different value.
+        >>> from sympy.codegen.ast import float80
+        >>> float80.cast_check(v18)
+        0.123456789012345649
+
+        """
+        val = sympify(value)
+
+        ten = Integer(10)
+        exp10 = getattr(self, 'decimal_dig', None)
+
+        if rtol is None:
+            rtol = 1e-15 if exp10 is None else 2.0*ten**(-exp10)
+
+        def tol(num):
+            return atol + rtol*abs(num)
+
+        new_val = self.cast_nocheck(value)
+        self._check(new_val)
+
+        delta = new_val - val
+        if abs(delta) > tol(val):  # rounding, e.g. int(3.5) != 3.5
+            raise ValueError("Casting gives a significantly different value.")
+
+        return new_val
+
+    def _latex(self, printer):
+        from sympy.printing.latex import latex_escape
+        type_name = latex_escape(self.__class__.__name__)
+        name = latex_escape(self.name.text)
+        return r"\text{{{}}}\left(\texttt{{{}}}\right)".format(type_name, name)
+
+
+class IntBaseType(Type):
+    """ Integer base type, contains no size information. """
+    __slots__ = ()
+    cast_nocheck = lambda self, i: Integer(int(i))
+
+
+class _SizedIntType(IntBaseType):
+    __slots__ = ('nbits',)
+    _fields = Type._fields + __slots__
+
+    _construct_nbits = Integer
+
+    def _check(self, value):
+        if value < self.min:
+            raise ValueError("Value is too small: %d < %d" % (value, self.min))
+        if value > self.max:
+            raise ValueError("Value is too big: %d > %d" % (value, self.max))
+
+
+class SignedIntType(_SizedIntType):
+    """ Represents a signed integer type. """
+    __slots__ = ()
+    @property
+    def min(self):
+        return -2**(self.nbits-1)
+
+    @property
+    def max(self):
+        return 2**(self.nbits-1) - 1
+
+
+class UnsignedIntType(_SizedIntType):
+    """ Represents an unsigned integer type. """
+    __slots__ = ()
+    @property
+    def min(self):
+        return 0
+
+    @property
+    def max(self):
+        return 2**self.nbits - 1
+
+two = Integer(2)
+
+class FloatBaseType(Type):
+    """ Represents a floating point number type. """
+    __slots__ = ()
+    cast_nocheck = Float
+
+class FloatType(FloatBaseType):
+    """ Represents a floating point type with fixed bit width.
+
+    Base 2 & one sign bit is assumed.
+
+    Parameters
+    ==========
+
+    name : str
+        Name of the type.
+    nbits : integer
+        Number of bits used (storage).
+    nmant : integer
+        Number of bits used to represent the mantissa.
+    nexp : integer
+        Number of bits used to represent the mantissa.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> from sympy.codegen.ast import FloatType
+    >>> half_precision = FloatType('f16', nbits=16, nmant=10, nexp=5)
+    >>> half_precision.max
+    65504
+    >>> half_precision.tiny == S(2)**-14
+    True
+    >>> half_precision.eps == S(2)**-10
+    True
+    >>> half_precision.dig == 3
+    True
+    >>> half_precision.decimal_dig == 5
+    True
+    >>> half_precision.cast_check(1.0)
+    1.0
+    >>> half_precision.cast_check(1e5)  # doctest: +ELLIPSIS
+    Traceback (most recent call last):
+      ...
+    ValueError: Maximum value for data type smaller than new value.
+    """
+
+    __slots__ = ('nbits', 'nmant', 'nexp',)
+    _fields = Type._fields + __slots__
+
+    _construct_nbits = _construct_nmant = _construct_nexp = Integer
+
+
+    @property
+    def max_exponent(self):
+        """ The largest positive number n, such that 2**(n - 1) is a representable finite value. """
+        # cf. C++'s ``std::numeric_limits::max_exponent``
+        return two**(self.nexp - 1)
+
+    @property
+    def min_exponent(self):
+        """ The lowest negative number n, such that 2**(n - 1) is a valid normalized number. """
+        # cf. C++'s ``std::numeric_limits::min_exponent``
+        return 3 - self.max_exponent
+
+    @property
+    def max(self):
+        """ Maximum value representable. """
+        return (1 - two**-(self.nmant+1))*two**self.max_exponent
+
+    @property
+    def tiny(self):
+        """ The minimum positive normalized value. """
+        # See C macros: FLT_MIN, DBL_MIN, LDBL_MIN
+        # or C++'s ``std::numeric_limits::min``
+        # or numpy.finfo(dtype).tiny
+        return two**(self.min_exponent - 1)
+
+
+    @property
+    def eps(self):
+        """ Difference between 1.0 and the next representable value. """
+        return two**(-self.nmant)
+
+    @property
+    def dig(self):
+        """ Number of decimal digits that are guaranteed to be preserved in text.
+
+        When converting text -> float -> text, you are guaranteed that at least ``dig``
+        number of digits are preserved with respect to rounding or overflow.
+        """
+        from sympy.functions import floor, log
+        return floor(self.nmant * log(2)/log(10))
+
+    @property
+    def decimal_dig(self):
+        """ Number of digits needed to store & load without loss.
+
+        Explanation
+        ===========
+
+        Number of decimal digits needed to guarantee that two consecutive conversions
+        (float -> text -> float) to be idempotent. This is useful when one do not want
+        to loose precision due to rounding errors when storing a floating point value
+        as text.
+        """
+        from sympy.functions import ceiling, log
+        return ceiling((self.nmant + 1) * log(2)/log(10) + 1)
+
+    def cast_nocheck(self, value):
+        """ Casts without checking if out of bounds or subnormal. """
+        if value == oo:  # float(oo) or oo
+            return float(oo)
+        elif value == -oo:  # float(-oo) or -oo
+            return float(-oo)
+        return Float(str(sympify(value).evalf(self.decimal_dig)), self.decimal_dig)
+
+    def _check(self, value):
+        if value < -self.max:
+            raise ValueError("Value is too small: %d < %d" % (value, -self.max))
+        if value > self.max:
+            raise ValueError("Value is too big: %d > %d" % (value, self.max))
+        if abs(value) < self.tiny:
+            raise ValueError("Smallest (absolute) value for data type bigger than new value.")
+
+class ComplexBaseType(FloatBaseType):
+
+    __slots__ = ()
+
+    def cast_nocheck(self, value):
+        """ Casts without checking if out of bounds or subnormal. """
+        from sympy.functions import re, im
+        return (
+            super().cast_nocheck(re(value)) +
+            super().cast_nocheck(im(value))*1j
+        )
+
+    def _check(self, value):
+        from sympy.functions import re, im
+        super()._check(re(value))
+        super()._check(im(value))
+
+
+class ComplexType(ComplexBaseType, FloatType):
+    """ Represents a complex floating point number. """
+    __slots__ = ()
+
+
+# NumPy types:
+intc = IntBaseType('intc')
+intp = IntBaseType('intp')
+int8 = SignedIntType('int8', 8)
+int16 = SignedIntType('int16', 16)
+int32 = SignedIntType('int32', 32)
+int64 = SignedIntType('int64', 64)
+uint8 = UnsignedIntType('uint8', 8)
+uint16 = UnsignedIntType('uint16', 16)
+uint32 = UnsignedIntType('uint32', 32)
+uint64 = UnsignedIntType('uint64', 64)
+float16 = FloatType('float16', 16, nexp=5, nmant=10)  # IEEE 754 binary16, Half precision
+float32 = FloatType('float32', 32, nexp=8, nmant=23)  # IEEE 754 binary32, Single precision
+float64 = FloatType('float64', 64, nexp=11, nmant=52)  # IEEE 754 binary64, Double precision
+float80 = FloatType('float80', 80, nexp=15, nmant=63)  # x86 extended precision (1 integer part bit), "long double"
+float128 = FloatType('float128', 128, nexp=15, nmant=112)  # IEEE 754 binary128, Quadruple precision
+float256 = FloatType('float256', 256, nexp=19, nmant=236)  # IEEE 754 binary256, Octuple precision
+
+complex64 = ComplexType('complex64', nbits=64, **float32.kwargs(exclude=('name', 'nbits')))
+complex128 = ComplexType('complex128', nbits=128, **float64.kwargs(exclude=('name', 'nbits')))
+
+# Generic types (precision may be chosen by code printers):
+untyped = Type('untyped')
+real = FloatBaseType('real')
+integer = IntBaseType('integer')
+complex_ = ComplexBaseType('complex')
+bool_ = Type('bool')
+
+
+class Attribute(Token):
+    """ Attribute (possibly parametrized)
+
+    For use with :class:`sympy.codegen.ast.Node` (which takes instances of
+    ``Attribute`` as ``attrs``).
+
+    Parameters
+    ==========
+
+    name : str
+    parameters : Tuple
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Attribute
+    >>> volatile = Attribute('volatile')
+    >>> volatile
+    volatile
+    >>> print(repr(volatile))
+    Attribute(String('volatile'))
+    >>> a = Attribute('foo', [1, 2, 3])
+    >>> a
+    foo(1, 2, 3)
+    >>> a.parameters == (1, 2, 3)
+    True
+    """
+    __slots__ = _fields = ('name', 'parameters')
+    defaults = {'parameters': Tuple()}
+
+    _construct_name = String
+    _construct_parameters = staticmethod(_mk_Tuple)
+
+    def _sympystr(self, printer, *args, **kwargs):
+        result = str(self.name)
+        if self.parameters:
+            result += '(%s)' % ', '.join((printer._print(
+                arg, *args, **kwargs) for arg in self.parameters))
+        return result
+
+value_const = Attribute('value_const')
+pointer_const = Attribute('pointer_const')
+
+
+class Variable(Node):
+    """ Represents a variable.
+
+    Parameters
+    ==========
+
+    symbol : Symbol
+    type : Type (optional)
+        Type of the variable.
+    attrs : iterable of Attribute instances
+        Will be stored as a Tuple.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.codegen.ast import Variable, float32, integer
+    >>> x = Symbol('x')
+    >>> v = Variable(x, type=float32)
+    >>> v.attrs
+    ()
+    >>> v == Variable('x')
+    False
+    >>> v == Variable('x', type=float32)
+    True
+    >>> v
+    Variable(x, type=float32)
+
+    One may also construct a ``Variable`` instance with the type deduced from
+    assumptions about the symbol using the ``deduced`` classmethod:
+
+    >>> i = Symbol('i', integer=True)
+    >>> v = Variable.deduced(i)
+    >>> v.type == integer
+    True
+    >>> v == Variable('i')
+    False
+    >>> from sympy.codegen.ast import value_const
+    >>> value_const in v.attrs
+    False
+    >>> w = Variable('w', attrs=[value_const])
+    >>> w
+    Variable(w, attrs=(value_const,))
+    >>> value_const in w.attrs
+    True
+    >>> w.as_Declaration(value=42)
+    Declaration(Variable(w, value=42, attrs=(value_const,)))
+
+    """
+
+    __slots__ = ('symbol', 'type', 'value')
+    _fields = __slots__ + Node._fields
+
+    defaults = Node.defaults.copy()
+    defaults.update({'type': untyped, 'value': none})
+
+    _construct_symbol = staticmethod(sympify)
+    _construct_value = staticmethod(sympify)
+
+    @classmethod
+    def deduced(cls, symbol, value=None, attrs=Tuple(), cast_check=True):
+        """ Alt. constructor with type deduction from ``Type.from_expr``.
+
+        Deduces type primarily from ``symbol``, secondarily from ``value``.
+
+        Parameters
+        ==========
+
+        symbol : Symbol
+        value : expr
+            (optional) value of the variable.
+        attrs : iterable of Attribute instances
+        cast_check : bool
+            Whether to apply ``Type.cast_check`` on ``value``.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.codegen.ast import Variable, complex_
+        >>> n = Symbol('n', integer=True)
+        >>> str(Variable.deduced(n).type)
+        'integer'
+        >>> x = Symbol('x', real=True)
+        >>> v = Variable.deduced(x)
+        >>> v.type
+        real
+        >>> z = Symbol('z', complex=True)
+        >>> Variable.deduced(z).type == complex_
+        True
+
+        """
+        if isinstance(symbol, Variable):
+            return symbol
+
+        try:
+            type_ = Type.from_expr(symbol)
+        except ValueError:
+            type_ = Type.from_expr(value)
+
+        if value is not None and cast_check:
+            value = type_.cast_check(value)
+        return cls(symbol, type=type_, value=value, attrs=attrs)
+
+    def as_Declaration(self, **kwargs):
+        """ Convenience method for creating a Declaration instance.
+
+        Explanation
+        ===========
+
+        If the variable of the Declaration need to wrap a modified
+        variable keyword arguments may be passed (overriding e.g.
+        the ``value`` of the Variable instance).
+
+        Examples
+        ========
+
+        >>> from sympy.codegen.ast import Variable, NoneToken
+        >>> x = Variable('x')
+        >>> decl1 = x.as_Declaration()
+        >>> # value is special NoneToken() which must be tested with == operator
+        >>> decl1.variable.value is None  # won't work
+        False
+        >>> decl1.variable.value == None  # not PEP-8 compliant
+        True
+        >>> decl1.variable.value == NoneToken()  # OK
+        True
+        >>> decl2 = x.as_Declaration(value=42.0)
+        >>> decl2.variable.value == 42.0
+        True
+
+        """
+        kw = self.kwargs()
+        kw.update(kwargs)
+        return Declaration(self.func(**kw))
+
+    def _relation(self, rhs, op):
+        try:
+            rhs = _sympify(rhs)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s < %s" % (self, rhs))
+        return op(self, rhs, evaluate=False)
+
+    __lt__ = lambda self, other: self._relation(other, Lt)
+    __le__ = lambda self, other: self._relation(other, Le)
+    __ge__ = lambda self, other: self._relation(other, Ge)
+    __gt__ = lambda self, other: self._relation(other, Gt)
+
+class Pointer(Variable):
+    """ Represents a pointer. See ``Variable``.
+
+    Examples
+    ========
+
+    Can create instances of ``Element``:
+
+    >>> from sympy import Symbol
+    >>> from sympy.codegen.ast import Pointer
+    >>> i = Symbol('i', integer=True)
+    >>> p = Pointer('x')
+    >>> p[i+1]
+    Element(x, indices=(i + 1,))
+
+    """
+    __slots__ = ()
+
+    def __getitem__(self, key):
+        try:
+            return Element(self.symbol, key)
+        except TypeError:
+            return Element(self.symbol, (key,))
+
+
+class Element(Token):
+    """ Element in (a possibly N-dimensional) array.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Element
+    >>> elem = Element('x', 'ijk')
+    >>> elem.symbol.name == 'x'
+    True
+    >>> elem.indices
+    (i, j, k)
+    >>> from sympy import ccode
+    >>> ccode(elem)
+    'x[i][j][k]'
+    >>> ccode(Element('x', 'ijk', strides='lmn', offset='o'))
+    'x[i*l + j*m + k*n + o]'
+
+    """
+    __slots__ = _fields = ('symbol', 'indices', 'strides', 'offset')
+    defaults = {'strides': none, 'offset': none}
+    _construct_symbol = staticmethod(sympify)
+    _construct_indices = staticmethod(lambda arg: Tuple(*arg))
+    _construct_strides = staticmethod(lambda arg: Tuple(*arg))
+    _construct_offset = staticmethod(sympify)
+
+
+class Declaration(Token):
+    """ Represents a variable declaration
+
+    Parameters
+    ==========
+
+    variable : Variable
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Declaration, NoneToken, untyped
+    >>> z = Declaration('z')
+    >>> z.variable.type == untyped
+    True
+    >>> # value is special NoneToken() which must be tested with == operator
+    >>> z.variable.value is None  # won't work
+    False
+    >>> z.variable.value == None  # not PEP-8 compliant
+    True
+    >>> z.variable.value == NoneToken()  # OK
+    True
+    """
+    __slots__ = _fields = ('variable',)
+    _construct_variable = Variable
+
+
+class While(Token):
+    """ Represents a 'for-loop' in the code.
+
+    Expressions are of the form:
+        "while condition:
+             body..."
+
+    Parameters
+    ==========
+
+    condition : expression convertible to Boolean
+    body : CodeBlock or iterable
+        When passed an iterable it is used to instantiate a CodeBlock.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Gt, Abs
+    >>> from sympy.codegen import aug_assign, Assignment, While
+    >>> x, dx = symbols('x dx')
+    >>> expr = 1 - x**2
+    >>> whl = While(Gt(Abs(dx), 1e-9), [
+    ...     Assignment(dx, -expr/expr.diff(x)),
+    ...     aug_assign(x, '+', dx)
+    ... ])
+
+    """
+    __slots__ = _fields = ('condition', 'body')
+    _construct_condition = staticmethod(lambda cond: _sympify(cond))
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+
+class Scope(Token):
+    """ Represents a scope in the code.
+
+    Parameters
+    ==========
+
+    body : CodeBlock or iterable
+        When passed an iterable it is used to instantiate a CodeBlock.
+
+    """
+    __slots__ = _fields = ('body',)
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+
+class Stream(Token):
+    """ Represents a stream.
+
+    There are two predefined Stream instances ``stdout`` & ``stderr``.
+
+    Parameters
+    ==========
+
+    name : str
+
+    Examples
+    ========
+
+    >>> from sympy import pycode, Symbol
+    >>> from sympy.codegen.ast import Print, stderr, QuotedString
+    >>> print(pycode(Print(['x'], file=stderr)))
+    print(x, file=sys.stderr)
+    >>> x = Symbol('x')
+    >>> print(pycode(Print([QuotedString('x')], file=stderr)))  # print literally "x"
+    print("x", file=sys.stderr)
+
+    """
+    __slots__ = _fields = ('name',)
+    _construct_name = String
+
+stdout = Stream('stdout')
+stderr = Stream('stderr')
+
+
+class Print(Token):
+    r""" Represents print command in the code.
+
+    Parameters
+    ==========
+
+    formatstring : str
+    *args : Basic instances (or convertible to such through sympify)
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Print
+    >>> from sympy import pycode
+    >>> print(pycode(Print('x y'.split(), "coordinate: %12.5g %12.5g\\n")))
+    print("coordinate: %12.5g %12.5g\n" % (x, y), end="")
+
+    """
+
+    __slots__ = _fields = ('print_args', 'format_string', 'file')
+    defaults = {'format_string': none, 'file': none}
+
+    _construct_print_args = staticmethod(_mk_Tuple)
+    _construct_format_string = QuotedString
+    _construct_file = Stream
+
+
+class FunctionPrototype(Node):
+    """ Represents a function prototype
+
+    Allows the user to generate forward declaration in e.g. C/C++.
+
+    Parameters
+    ==========
+
+    return_type : Type
+    name : str
+    parameters: iterable of Variable instances
+    attrs : iterable of Attribute instances
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, symbols
+    >>> from sympy.codegen.ast import real, FunctionPrototype
+    >>> x, y = symbols('x y', real=True)
+    >>> fp = FunctionPrototype(real, 'foo', [x, y])
+    >>> ccode(fp)
+    'double foo(double x, double y)'
+
+    """
+
+    __slots__ = ('return_type', 'name', 'parameters')
+    _fields: tuple[str, ...] = __slots__ + Node._fields
+
+    _construct_return_type = Type
+    _construct_name = String
+
+    @staticmethod
+    def _construct_parameters(args):
+        def _var(arg):
+            if isinstance(arg, Declaration):
+                return arg.variable
+            elif isinstance(arg, Variable):
+                return arg
+            else:
+                return Variable.deduced(arg)
+        return Tuple(*map(_var, args))
+
+    @classmethod
+    def from_FunctionDefinition(cls, func_def):
+        if not isinstance(func_def, FunctionDefinition):
+            raise TypeError("func_def is not an instance of FunctionDefinition")
+        return cls(**func_def.kwargs(exclude=('body',)))
+
+
+class FunctionDefinition(FunctionPrototype):
+    """ Represents a function definition in the code.
+
+    Parameters
+    ==========
+
+    return_type : Type
+    name : str
+    parameters: iterable of Variable instances
+    body : CodeBlock or iterable
+    attrs : iterable of Attribute instances
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, symbols
+    >>> from sympy.codegen.ast import real, FunctionPrototype
+    >>> x, y = symbols('x y', real=True)
+    >>> fp = FunctionPrototype(real, 'foo', [x, y])
+    >>> ccode(fp)
+    'double foo(double x, double y)'
+    >>> from sympy.codegen.ast import FunctionDefinition, Return
+    >>> body = [Return(x*y)]
+    >>> fd = FunctionDefinition.from_FunctionPrototype(fp, body)
+    >>> print(ccode(fd))
+    double foo(double x, double y){
+        return x*y;
+    }
+    """
+
+    __slots__ = ('body', )
+    _fields = FunctionPrototype._fields[:-1] + __slots__ + Node._fields
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+    @classmethod
+    def from_FunctionPrototype(cls, func_proto, body):
+        if not isinstance(func_proto, FunctionPrototype):
+            raise TypeError("func_proto is not an instance of FunctionPrototype")
+        return cls(body=body, **func_proto.kwargs())
+
+
+class Return(Token):
+    """ Represents a return command in the code.
+
+    Parameters
+    ==========
+
+    return : Basic
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Return
+    >>> from sympy.printing.pycode import pycode
+    >>> from sympy import Symbol
+    >>> x = Symbol('x')
+    >>> print(pycode(Return(x)))
+    return x
+
+    """
+    __slots__ = _fields = ('return',)
+    _construct_return=staticmethod(_sympify)
+
+
+class FunctionCall(Token, Expr):
+    """ Represents a call to a function in the code.
+
+    Parameters
+    ==========
+
+    name : str
+    function_args : Tuple
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import FunctionCall
+    >>> from sympy import pycode
+    >>> fcall = FunctionCall('foo', 'bar baz'.split())
+    >>> print(pycode(fcall))
+    foo(bar, baz)
+
+    """
+    __slots__ = _fields = ('name', 'function_args')
+
+    _construct_name = String
+    _construct_function_args = staticmethod(lambda args: Tuple(*args))
+
+
+class Raise(Token):
+    """ Prints as 'raise ...' in Python, 'throw ...' in C++"""
+    __slots__ = _fields = ('exception',)
+
+
+class RuntimeError_(Token):
+    """ Represents 'std::runtime_error' in C++ and 'RuntimeError' in Python.
+
+    Note that the latter is uncommon, and you might want to use e.g. ValueError.
+    """
+    __slots__ = _fields = ('message',)
+    _construct_message = String
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/cfunctions.py b/.venv/lib/python3.12/site-packages/sympy/codegen/cfunctions.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b79291f128aef1cb83b327782840508e59a9cc8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/cfunctions.py
@@ -0,0 +1,558 @@
+"""
+This module contains SymPy functions mathcin corresponding to special math functions in the
+C standard library (since C99, also available in C++11).
+
+The functions defined in this module allows the user to express functions such as ``expm1``
+as a SymPy function for symbolic manipulation.
+
+"""
+from sympy.core.function import ArgumentIndexError, Function
+from sympy.core.numbers import Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.logic.boolalg import BooleanFunction, true, false
+
+def _expm1(x):
+    return exp(x) - S.One
+
+
+class expm1(Function):
+    """
+    Represents the exponential function minus one.
+
+    Explanation
+    ===========
+
+    The benefit of using ``expm1(x)`` over ``exp(x) - 1``
+    is that the latter is prone to cancellation under finite precision
+    arithmetic when x is close to zero.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import expm1
+    >>> '%.0e' % expm1(1e-99).evalf()
+    '1e-99'
+    >>> from math import exp
+    >>> exp(1e-99) - 1
+    0.0
+    >>> expm1(x).diff(x)
+    exp(x)
+
+    See Also
+    ========
+
+    log1p
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return exp(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_expand_func(self, **hints):
+        return _expm1(*self.args)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return exp(arg) - S.One
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_exp
+
+    @classmethod
+    def eval(cls, arg):
+        exp_arg = exp.eval(arg)
+        if exp_arg is not None:
+            return exp_arg - S.One
+
+    def _eval_is_real(self):
+        return self.args[0].is_real
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+def _log1p(x):
+    return log(x + S.One)
+
+
+class log1p(Function):
+    """
+    Represents the natural logarithm of a number plus one.
+
+    Explanation
+    ===========
+
+    The benefit of using ``log1p(x)`` over ``log(x + 1)``
+    is that the latter is prone to cancellation under finite precision
+    arithmetic when x is close to zero.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log1p
+    >>> from sympy import expand_log
+    >>> '%.0e' % expand_log(log1p(1e-99)).evalf()
+    '1e-99'
+    >>> from math import log
+    >>> log(1 + 1e-99)
+    0.0
+    >>> log1p(x).diff(x)
+    1/(x + 1)
+
+    See Also
+    ========
+
+    expm1
+    """
+    nargs = 1
+
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(self.args[0] + S.One)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _log1p(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log1p(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Rational:
+            return log(arg + S.One)
+        elif not arg.is_Float:  # not safe to add 1 to Float
+            return log.eval(arg + S.One)
+        elif arg.is_number:
+            return log(Rational(arg) + S.One)
+
+    def _eval_is_real(self):
+        return (self.args[0] + S.One).is_nonnegative
+
+    def _eval_is_finite(self):
+        if (self.args[0] + S.One).is_zero:
+            return False
+        return self.args[0].is_finite
+
+    def _eval_is_positive(self):
+        return self.args[0].is_positive
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_nonnegative
+
+_Two = S(2)
+
+def _exp2(x):
+    return Pow(_Two, x)
+
+class exp2(Function):
+    """
+    Represents the exponential function with base two.
+
+    Explanation
+    ===========
+
+    The benefit of using ``exp2(x)`` over ``2**x``
+    is that the latter is not as efficient under finite precision
+    arithmetic.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import exp2
+    >>> exp2(2).evalf() == 4.0
+    True
+    >>> exp2(x).diff(x)
+    log(2)*exp2(x)
+
+    See Also
+    ========
+
+    log2
+    """
+    nargs = 1
+
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return self*log(_Two)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _exp2(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+    def _eval_expand_func(self, **hints):
+        return _exp2(*self.args)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            return _exp2(arg)
+
+
+def _log2(x):
+    return log(x)/log(_Two)
+
+
+class log2(Function):
+    """
+    Represents the logarithm function with base two.
+
+    Explanation
+    ===========
+
+    The benefit of using ``log2(x)`` over ``log(x)/log(2)``
+    is that the latter is not as efficient under finite precision
+    arithmetic.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log2
+    >>> log2(4).evalf() == 2.0
+    True
+    >>> log2(x).diff(x)
+    1/(x*log(2))
+
+    See Also
+    ========
+
+    exp2
+    log10
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(log(_Two)*self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            result = log.eval(arg, base=_Two)
+            if result.is_Atom:
+                return result
+        elif arg.is_Pow and arg.base == _Two:
+            return arg.exp
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(log).evalf(*args, **kwargs)
+
+    def _eval_expand_func(self, **hints):
+        return _log2(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log2(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+
+def _fma(x, y, z):
+    return x*y + z
+
+
+class fma(Function):
+    """
+    Represents "fused multiply add".
+
+    Explanation
+    ===========
+
+    The benefit of using ``fma(x, y, z)`` over ``x*y + z``
+    is that, under finite precision arithmetic, the former is
+    supported by special instructions on some CPUs.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.codegen.cfunctions import fma
+    >>> fma(x, y, z).diff(x)
+    y
+
+    """
+    nargs = 3
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex in (1, 2):
+            return self.args[2 - argindex]
+        elif argindex == 3:
+            return S.One
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _fma(*self.args)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return _fma(arg)
+
+
+_Ten = S(10)
+
+
+def _log10(x):
+    return log(x)/log(_Ten)
+
+
+class log10(Function):
+    """
+    Represents the logarithm function with base ten.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import log10
+    >>> log10(100).evalf() == 2.0
+    True
+    >>> log10(x).diff(x)
+    1/(x*log(10))
+
+    See Also
+    ========
+
+    log2
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return S.One/(log(_Ten)*self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_number:
+            result = log.eval(arg, base=_Ten)
+            if result.is_Atom:
+                return result
+        elif arg.is_Pow and arg.base == _Ten:
+            return arg.exp
+
+    def _eval_expand_func(self, **hints):
+        return _log10(*self.args)
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return _log10(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+
+def _Sqrt(x):
+    return Pow(x, S.Half)
+
+
+class Sqrt(Function):  # 'sqrt' already defined in sympy.functions.elementary.miscellaneous
+    """
+    Represents the square root function.
+
+    Explanation
+    ===========
+
+    The reason why one would use ``Sqrt(x)`` over ``sqrt(x)``
+    is that the latter is internally represented as ``Pow(x, S.Half)`` which
+    may not be what one wants when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import Sqrt
+    >>> Sqrt(x)
+    Sqrt(x)
+    >>> Sqrt(x).diff(x)
+    1/(2*sqrt(x))
+
+    See Also
+    ========
+
+    Cbrt
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], Rational(-1, 2))/_Two
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_expand_func(self, **hints):
+        return _Sqrt(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _Sqrt(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+def _Cbrt(x):
+    return Pow(x, Rational(1, 3))
+
+
+class Cbrt(Function):  # 'cbrt' already defined in sympy.functions.elementary.miscellaneous
+    """
+    Represents the cube root function.
+
+    Explanation
+    ===========
+
+    The reason why one would use ``Cbrt(x)`` over ``cbrt(x)``
+    is that the latter is internally represented as ``Pow(x, Rational(1, 3))`` which
+    may not be what one wants when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cfunctions import Cbrt
+    >>> Cbrt(x)
+    Cbrt(x)
+    >>> Cbrt(x).diff(x)
+    1/(3*x**(2/3))
+
+    See Also
+    ========
+
+    Sqrt
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], Rational(-_Two/3))/3
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _Cbrt(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _Cbrt(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+def _hypot(x, y):
+    return sqrt(Pow(x, 2) + Pow(y, 2))
+
+
+class hypot(Function):
+    """
+    Represents the hypotenuse function.
+
+    Explanation
+    ===========
+
+    The hypotenuse function is provided by e.g. the math library
+    in the C99 standard, hence one may want to represent the function
+    symbolically when doing code-generation.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy.codegen.cfunctions import hypot
+    >>> hypot(3, 4).evalf() == 5.0
+    True
+    >>> hypot(x, y)
+    hypot(x, y)
+    >>> hypot(x, y).diff(x)
+    x/hypot(x, y)
+
+    """
+    nargs = 2
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex in (1, 2):
+            return 2*self.args[argindex-1]/(_Two*self.func(*self.args))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def _eval_expand_func(self, **hints):
+        return _hypot(*self.args)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return _hypot(arg)
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_Pow
+
+
+class isnan(BooleanFunction):
+    nargs = 1
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return true
+        elif arg.is_number:
+            return false
+        else:
+            return None
+
+
+class isinf(BooleanFunction):
+    nargs = 1
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_infinite:
+            return true
+        elif arg.is_finite:
+            return false
+        else:
+            return None
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/cnodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/cnodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd2a324ee49cabcd42e99ca5d8e5379cc9262c4e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/cnodes.py
@@ -0,0 +1,156 @@
+"""
+AST nodes specific to the C family of languages
+"""
+
+from sympy.codegen.ast import (
+    Attribute, Declaration, Node, String, Token, Type, none,
+    FunctionCall, CodeBlock
+    )
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.sympify import sympify
+
+void = Type('void')
+
+restrict = Attribute('restrict')  # guarantees no pointer aliasing
+volatile = Attribute('volatile')
+static = Attribute('static')
+
+
+def alignof(arg):
+    """ Generate of FunctionCall instance for calling 'alignof' """
+    return FunctionCall('alignof', [String(arg) if isinstance(arg, str) else arg])
+
+
+def sizeof(arg):
+    """ Generate of FunctionCall instance for calling 'sizeof'
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import real
+    >>> from sympy.codegen.cnodes import sizeof
+    >>> from sympy import ccode
+    >>> ccode(sizeof(real))
+    'sizeof(double)'
+    """
+    return FunctionCall('sizeof', [String(arg) if isinstance(arg, str) else arg])
+
+
+class CommaOperator(Basic):
+    """ Represents the comma operator in C """
+    def __new__(cls, *args):
+        return Basic.__new__(cls, *[sympify(arg) for arg in args])
+
+
+class Label(Node):
+    """ Label for use with e.g. goto statement.
+
+    Examples
+    ========
+
+    >>> from sympy import ccode, Symbol
+    >>> from sympy.codegen.cnodes import Label, PreIncrement
+    >>> print(ccode(Label('foo')))
+    foo:
+    >>> print(ccode(Label('bar', [PreIncrement(Symbol('a'))])))
+    bar:
+    ++(a);
+
+    """
+    __slots__ = _fields = ('name', 'body')
+    defaults = {'body': none}
+    _construct_name = String
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+
+class goto(Token):
+    """ Represents goto in C """
+    __slots__ = _fields = ('label',)
+    _construct_label = Label
+
+
+class PreDecrement(Basic):
+    """ Represents the pre-decrement operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreDecrement
+    >>> from sympy import ccode
+    >>> ccode(PreDecrement(x))
+    '--(x)'
+
+    """
+    nargs = 1
+
+
+class PostDecrement(Basic):
+    """ Represents the post-decrement operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostDecrement
+    >>> from sympy import ccode
+    >>> ccode(PostDecrement(x))
+    '(x)--'
+
+    """
+    nargs = 1
+
+
+class PreIncrement(Basic):
+    """ Represents the pre-increment operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PreIncrement
+    >>> from sympy import ccode
+    >>> ccode(PreIncrement(x))
+    '++(x)'
+
+    """
+    nargs = 1
+
+
+class PostIncrement(Basic):
+    """ Represents the post-increment operator
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.codegen.cnodes import PostIncrement
+    >>> from sympy import ccode
+    >>> ccode(PostIncrement(x))
+    '(x)++'
+
+    """
+    nargs = 1
+
+
+class struct(Node):
+    """ Represents a struct in C """
+    __slots__ = _fields = ('name', 'declarations')
+    defaults = {'name': none}
+    _construct_name = String
+
+    @classmethod
+    def _construct_declarations(cls, args):
+        return Tuple(*[Declaration(arg) for arg in args])
+
+
+class union(struct):
+    """ Represents a union in C """
+    __slots__ = ()
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/cutils.py b/.venv/lib/python3.12/site-packages/sympy/codegen/cutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..2182ac1f3455da490a0bb57f8d6731fe8a29a232
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/cutils.py
@@ -0,0 +1,8 @@
+from sympy.printing.c import C99CodePrinter
+
+def render_as_source_file(content, Printer=C99CodePrinter, settings=None):
+    """ Renders a C source file (with required #include statements) """
+    printer = Printer(settings or {})
+    code_str = printer.doprint(content)
+    includes = '\n'.join(['#include <%s>' % h for h in printer.headers])
+    return includes + '\n\n' + code_str
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/cxxnodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/cxxnodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..7f7aafd01ab2de99ad0f668275889863fc73f5aa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/cxxnodes.py
@@ -0,0 +1,14 @@
+"""
+AST nodes specific to C++.
+"""
+
+from sympy.codegen.ast import Attribute, String, Token, Type, none
+
+class using(Token):
+    """ Represents a 'using' statement in C++ """
+    __slots__ = _fields = ('type', 'alias')
+    defaults = {'alias': none}
+    _construct_type = Type
+    _construct_alias = String
+
+constexpr = Attribute('constexpr')
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/fnodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/fnodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..8b972fcfe4d4de4cfe74d75705f42c5e112a9b43
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/fnodes.py
@@ -0,0 +1,658 @@
+"""
+AST nodes specific to Fortran.
+
+The functions defined in this module allows the user to express functions such as ``dsign``
+as a SymPy function for symbolic manipulation.
+"""
+
+from __future__ import annotations
+from sympy.codegen.ast import (
+    Attribute, CodeBlock, FunctionCall, Node, none, String,
+    Token, _mk_Tuple, Variable
+)
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import Function
+from sympy.core.numbers import Float, Integer
+from sympy.core.symbol import Str
+from sympy.core.sympify import sympify
+from sympy.logic import true, false
+from sympy.utilities.iterables import iterable
+
+
+
+pure = Attribute('pure')
+elemental = Attribute('elemental')  # (all elemental procedures are also pure)
+
+intent_in = Attribute('intent_in')
+intent_out = Attribute('intent_out')
+intent_inout = Attribute('intent_inout')
+
+allocatable = Attribute('allocatable')
+
+class Program(Token):
+    """ Represents a 'program' block in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.ast import Print
+    >>> from sympy.codegen.fnodes import Program
+    >>> prog = Program('myprogram', [Print([42])])
+    >>> from sympy import fcode
+    >>> print(fcode(prog, source_format='free'))
+    program myprogram
+        print *, 42
+    end program
+
+    """
+    __slots__ = _fields = ('name', 'body')
+    _construct_name = String
+    _construct_body = staticmethod(lambda body: CodeBlock(*body))
+
+
+class use_rename(Token):
+    """ Represents a renaming in a use statement in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import use_rename, use
+    >>> from sympy import fcode
+    >>> ren = use_rename("thingy", "convolution2d")
+    >>> print(fcode(ren, source_format='free'))
+    thingy => convolution2d
+    >>> full = use('signallib', only=['snr', ren])
+    >>> print(fcode(full, source_format='free'))
+    use signallib, only: snr, thingy => convolution2d
+
+    """
+    __slots__ = _fields = ('local', 'original')
+    _construct_local = String
+    _construct_original = String
+
+def _name(arg):
+    if hasattr(arg, 'name'):
+        return arg.name
+    else:
+        return String(arg)
+
+class use(Token):
+    """ Represents a use statement in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import use
+    >>> from sympy import fcode
+    >>> fcode(use('signallib'), source_format='free')
+    'use signallib'
+    >>> fcode(use('signallib', [('metric', 'snr')]), source_format='free')
+    'use signallib, metric => snr'
+    >>> fcode(use('signallib', only=['snr', 'convolution2d']), source_format='free')
+    'use signallib, only: snr, convolution2d'
+
+    """
+    __slots__ = _fields = ('namespace', 'rename', 'only')
+    defaults = {'rename': none, 'only': none}
+    _construct_namespace = staticmethod(_name)
+    _construct_rename = staticmethod(lambda args: Tuple(*[arg if isinstance(arg, use_rename) else use_rename(*arg) for arg in args]))
+    _construct_only = staticmethod(lambda args: Tuple(*[arg if isinstance(arg, use_rename) else _name(arg) for arg in args]))
+
+
+class Module(Token):
+    """ Represents a module in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import Module
+    >>> from sympy import fcode
+    >>> print(fcode(Module('signallib', ['implicit none'], []), source_format='free'))
+    module signallib
+    implicit none
+    
+    contains
+    
+    
+    end module
+
+    """
+    __slots__ = _fields = ('name', 'declarations', 'definitions')
+    defaults = {'declarations': Tuple()}
+    _construct_name = String
+
+    @classmethod
+    def _construct_declarations(cls, args):
+        args = [Str(arg) if isinstance(arg, str) else arg for arg in args]
+        return CodeBlock(*args)
+
+    _construct_definitions = staticmethod(lambda arg: CodeBlock(*arg))
+
+
+class Subroutine(Node):
+    """ Represents a subroutine in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy import fcode, symbols
+    >>> from sympy.codegen.ast import Print
+    >>> from sympy.codegen.fnodes import Subroutine
+    >>> x, y = symbols('x y', real=True)
+    >>> sub = Subroutine('mysub', [x, y], [Print([x**2 + y**2, x*y])])
+    >>> print(fcode(sub, source_format='free', standard=2003))
+    subroutine mysub(x, y)
+    real*8 :: x
+    real*8 :: y
+    print *, x**2 + y**2, x*y
+    end subroutine
+
+    """
+    __slots__ = ('name', 'parameters', 'body')
+    _fields = __slots__ + Node._fields
+    _construct_name = String
+    _construct_parameters = staticmethod(lambda params: Tuple(*map(Variable.deduced, params)))
+
+    @classmethod
+    def _construct_body(cls, itr):
+        if isinstance(itr, CodeBlock):
+            return itr
+        else:
+            return CodeBlock(*itr)
+
+class SubroutineCall(Token):
+    """ Represents a call to a subroutine in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import SubroutineCall
+    >>> from sympy import fcode
+    >>> fcode(SubroutineCall('mysub', 'x y'.split()))
+    '       call mysub(x, y)'
+
+    """
+    __slots__ = _fields = ('name', 'subroutine_args')
+    _construct_name = staticmethod(_name)
+    _construct_subroutine_args = staticmethod(_mk_Tuple)
+
+
+class Do(Token):
+    """ Represents a Do loop in in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy import fcode, symbols
+    >>> from sympy.codegen.ast import aug_assign, Print
+    >>> from sympy.codegen.fnodes import Do
+    >>> i, n = symbols('i n', integer=True)
+    >>> r = symbols('r', real=True)
+    >>> body = [aug_assign(r, '+', 1/i), Print([i, r])]
+    >>> do1 = Do(body, i, 1, n)
+    >>> print(fcode(do1, source_format='free'))
+    do i = 1, n
+        r = r + 1d0/i
+        print *, i, r
+    end do
+    >>> do2 = Do(body, i, 1, n, 2)
+    >>> print(fcode(do2, source_format='free'))
+    do i = 1, n, 2
+        r = r + 1d0/i
+        print *, i, r
+    end do
+
+    """
+
+    __slots__ = _fields = ('body', 'counter', 'first', 'last', 'step', 'concurrent')
+    defaults = {'step': Integer(1), 'concurrent': false}
+    _construct_body = staticmethod(lambda body: CodeBlock(*body))
+    _construct_counter = staticmethod(sympify)
+    _construct_first = staticmethod(sympify)
+    _construct_last = staticmethod(sympify)
+    _construct_step = staticmethod(sympify)
+    _construct_concurrent = staticmethod(lambda arg: true if arg else false)
+
+
+class ArrayConstructor(Token):
+    """ Represents an array constructor.
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.fnodes import ArrayConstructor
+    >>> ac = ArrayConstructor([1, 2, 3])
+    >>> fcode(ac, standard=95, source_format='free')
+    '(/1, 2, 3/)'
+    >>> fcode(ac, standard=2003, source_format='free')
+    '[1, 2, 3]'
+
+    """
+    __slots__ = _fields = ('elements',)
+    _construct_elements = staticmethod(_mk_Tuple)
+
+
+class ImpliedDoLoop(Token):
+    """ Represents an implied do loop in Fortran.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, fcode
+    >>> from sympy.codegen.fnodes import ImpliedDoLoop, ArrayConstructor
+    >>> i = Symbol('i', integer=True)
+    >>> idl = ImpliedDoLoop(i**3, i, -3, 3, 2)  # -27, -1, 1, 27
+    >>> ac = ArrayConstructor([-28, idl, 28]) # -28, -27, -1, 1, 27, 28
+    >>> fcode(ac, standard=2003, source_format='free')
+    '[-28, (i**3, i = -3, 3, 2), 28]'
+
+    """
+    __slots__ = _fields = ('expr', 'counter', 'first', 'last', 'step')
+    defaults = {'step': Integer(1)}
+    _construct_expr = staticmethod(sympify)
+    _construct_counter = staticmethod(sympify)
+    _construct_first = staticmethod(sympify)
+    _construct_last = staticmethod(sympify)
+    _construct_step = staticmethod(sympify)
+
+
+class Extent(Basic):
+    """ Represents a dimension extent.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import Extent
+    >>> e = Extent(-3, 3)  # -3, -2, -1, 0, 1, 2, 3
+    >>> from sympy import fcode
+    >>> fcode(e, source_format='free')
+    '-3:3'
+    >>> from sympy.codegen.ast import Variable, real
+    >>> from sympy.codegen.fnodes import dimension, intent_out
+    >>> dim = dimension(e, e)
+    >>> arr = Variable('x', real, attrs=[dim, intent_out])
+    >>> fcode(arr.as_Declaration(), source_format='free', standard=2003)
+    'real*8, dimension(-3:3, -3:3), intent(out) :: x'
+
+    """
+    def __new__(cls, *args):
+        if len(args) == 2:
+            low, high = args
+            return Basic.__new__(cls, sympify(low), sympify(high))
+        elif len(args) == 0 or (len(args) == 1 and args[0] in (':', None)):
+            return Basic.__new__(cls)  # assumed shape
+        else:
+            raise ValueError("Expected 0 or 2 args (or one argument == None or ':')")
+
+    def _sympystr(self, printer):
+        if len(self.args) == 0:
+            return ':'
+        return ":".join(str(arg) for arg in self.args)
+
+assumed_extent = Extent() # or Extent(':'), Extent(None)
+
+
+def dimension(*args):
+    """ Creates a 'dimension' Attribute with (up to 7) extents.
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.fnodes import dimension, intent_in
+    >>> dim = dimension('2', ':')  # 2 rows, runtime determined number of columns
+    >>> from sympy.codegen.ast import Variable, integer
+    >>> arr = Variable('a', integer, attrs=[dim, intent_in])
+    >>> fcode(arr.as_Declaration(), source_format='free', standard=2003)
+    'integer*4, dimension(2, :), intent(in) :: a'
+
+    """
+    if len(args) > 7:
+        raise ValueError("Fortran only supports up to 7 dimensional arrays")
+    parameters = []
+    for arg in args:
+        if isinstance(arg, Extent):
+            parameters.append(arg)
+        elif isinstance(arg, str):
+            if arg == ':':
+                parameters.append(Extent())
+            else:
+                parameters.append(String(arg))
+        elif iterable(arg):
+            parameters.append(Extent(*arg))
+        else:
+            parameters.append(sympify(arg))
+    if len(args) == 0:
+        raise ValueError("Need at least one dimension")
+    return Attribute('dimension', parameters)
+
+
+assumed_size = dimension('*')
+
+def array(symbol, dim, intent=None, *, attrs=(), value=None, type=None):
+    """ Convenience function for creating a Variable instance for a Fortran array.
+
+    Parameters
+    ==========
+
+    symbol : symbol
+    dim : Attribute or iterable
+        If dim is an ``Attribute`` it need to have the name 'dimension'. If it is
+        not an ``Attribute``, then it is passed to :func:`dimension` as ``*dim``
+    intent : str
+        One of: 'in', 'out', 'inout' or None
+    \\*\\*kwargs:
+        Keyword arguments for ``Variable`` ('type' & 'value')
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.ast import integer, real
+    >>> from sympy.codegen.fnodes import array
+    >>> arr = array('a', '*', 'in', type=integer)
+    >>> print(fcode(arr.as_Declaration(), source_format='free', standard=2003))
+    integer*4, dimension(*), intent(in) :: a
+    >>> x = array('x', [3, ':', ':'], intent='out', type=real)
+    >>> print(fcode(x.as_Declaration(value=1), source_format='free', standard=2003))
+    real*8, dimension(3, :, :), intent(out) :: x = 1
+
+    """
+    if isinstance(dim, Attribute):
+        if str(dim.name) != 'dimension':
+            raise ValueError("Got an unexpected Attribute argument as dim: %s" % str(dim))
+    else:
+        dim = dimension(*dim)
+
+    attrs = list(attrs) + [dim]
+    if intent is not None:
+        if intent not in (intent_in, intent_out, intent_inout):
+            intent = {'in': intent_in, 'out': intent_out, 'inout': intent_inout}[intent]
+        attrs.append(intent)
+    if type is None:
+        return Variable.deduced(symbol, value=value, attrs=attrs)
+    else:
+        return Variable(symbol, type, value=value, attrs=attrs)
+
+def _printable(arg):
+    return String(arg) if isinstance(arg, str) else sympify(arg)
+
+
+def allocated(array):
+    """ Creates an AST node for a function call to Fortran's "allocated(...)"
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.fnodes import allocated
+    >>> alloc = allocated('x')
+    >>> fcode(alloc, source_format='free')
+    'allocated(x)'
+
+    """
+    return FunctionCall('allocated', [_printable(array)])
+
+
+def lbound(array, dim=None, kind=None):
+    """ Creates an AST node for a function call to Fortran's "lbound(...)"
+
+    Parameters
+    ==========
+
+    array : Symbol or String
+    dim : expr
+    kind : expr
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.fnodes import lbound
+    >>> lb = lbound('arr', dim=2)
+    >>> fcode(lb, source_format='free')
+    'lbound(arr, 2)'
+
+    """
+    return FunctionCall(
+        'lbound',
+        [_printable(array)] +
+        ([_printable(dim)] if dim else []) +
+        ([_printable(kind)] if kind else [])
+    )
+
+
+def ubound(array, dim=None, kind=None):
+    return FunctionCall(
+        'ubound',
+        [_printable(array)] +
+        ([_printable(dim)] if dim else []) +
+        ([_printable(kind)] if kind else [])
+    )
+
+
+def shape(source, kind=None):
+    """ Creates an AST node for a function call to Fortran's "shape(...)"
+
+    Parameters
+    ==========
+
+    source : Symbol or String
+    kind : expr
+
+    Examples
+    ========
+
+    >>> from sympy import fcode
+    >>> from sympy.codegen.fnodes import shape
+    >>> shp = shape('x')
+    >>> fcode(shp, source_format='free')
+    'shape(x)'
+
+    """
+    return FunctionCall(
+        'shape',
+        [_printable(source)] +
+        ([_printable(kind)] if kind else [])
+    )
+
+
+def size(array, dim=None, kind=None):
+    """ Creates an AST node for a function call to Fortran's "size(...)"
+
+    Examples
+    ========
+
+    >>> from sympy import fcode, Symbol
+    >>> from sympy.codegen.ast import FunctionDefinition, real, Return
+    >>> from sympy.codegen.fnodes import array, sum_, size
+    >>> a = Symbol('a', real=True)
+    >>> body = [Return((sum_(a**2)/size(a))**.5)]
+    >>> arr = array(a, dim=[':'], intent='in')
+    >>> fd = FunctionDefinition(real, 'rms', [arr], body)
+    >>> print(fcode(fd, source_format='free', standard=2003))
+    real*8 function rms(a)
+    real*8, dimension(:), intent(in) :: a
+    rms = sqrt(sum(a**2)*1d0/size(a))
+    end function
+
+    """
+    return FunctionCall(
+        'size',
+        [_printable(array)] +
+        ([_printable(dim)] if dim else []) +
+        ([_printable(kind)] if kind else [])
+    )
+
+
+def reshape(source, shape, pad=None, order=None):
+    """ Creates an AST node for a function call to Fortran's "reshape(...)"
+
+    Parameters
+    ==========
+
+    source : Symbol or String
+    shape : ArrayExpr
+
+    """
+    return FunctionCall(
+        'reshape',
+        [_printable(source), _printable(shape)] +
+        ([_printable(pad)] if pad else []) +
+        ([_printable(order)] if pad else [])
+    )
+
+
+def bind_C(name=None):
+    """ Creates an Attribute ``bind_C`` with a name.
+
+    Parameters
+    ==========
+
+    name : str
+
+    Examples
+    ========
+
+    >>> from sympy import fcode, Symbol
+    >>> from sympy.codegen.ast import FunctionDefinition, real, Return
+    >>> from sympy.codegen.fnodes import array, sum_, bind_C
+    >>> a = Symbol('a', real=True)
+    >>> s = Symbol('s', integer=True)
+    >>> arr = array(a, dim=[s], intent='in')
+    >>> body = [Return((sum_(a**2)/s)**.5)]
+    >>> fd = FunctionDefinition(real, 'rms', [arr, s], body, attrs=[bind_C('rms')])
+    >>> print(fcode(fd, source_format='free', standard=2003))
+    real*8 function rms(a, s) bind(C, name="rms")
+    real*8, dimension(s), intent(in) :: a
+    integer*4 :: s
+    rms = sqrt(sum(a**2)/s)
+    end function
+
+    """
+    return Attribute('bind_C', [String(name)] if name else [])
+
+class GoTo(Token):
+    """ Represents a goto statement in Fortran
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import GoTo
+    >>> go = GoTo([10, 20, 30], 'i')
+    >>> from sympy import fcode
+    >>> fcode(go, source_format='free')
+    'go to (10, 20, 30), i'
+
+    """
+    __slots__ = _fields = ('labels', 'expr')
+    defaults = {'expr': none}
+    _construct_labels = staticmethod(_mk_Tuple)
+    _construct_expr = staticmethod(sympify)
+
+
+class FortranReturn(Token):
+    """ AST node explicitly mapped to a fortran "return".
+
+    Explanation
+    ===========
+
+    Because a return statement in fortran is different from C, and
+    in order to aid reuse of our codegen ASTs the ordinary
+    ``.codegen.ast.Return`` is interpreted as assignment to
+    the result variable of the function. If one for some reason needs
+    to generate a fortran RETURN statement, this node should be used.
+
+    Examples
+    ========
+
+    >>> from sympy.codegen.fnodes import FortranReturn
+    >>> from sympy import fcode
+    >>> fcode(FortranReturn('x'))
+    '       return x'
+
+    """
+    __slots__ = _fields = ('return_value',)
+    defaults = {'return_value': none}
+    _construct_return_value = staticmethod(sympify)
+
+
+class FFunction(Function):
+    _required_standard = 77
+
+    def _fcode(self, printer):
+        name = self.__class__.__name__
+        if printer._settings['standard'] < self._required_standard:
+            raise NotImplementedError("%s requires Fortran %d or newer" %
+                                      (name, self._required_standard))
+        return '{}({})'.format(name, ', '.join(map(printer._print, self.args)))
+
+
+class F95Function(FFunction):
+    _required_standard = 95
+
+
+class isign(FFunction):
+    """ Fortran sign intrinsic for integer arguments. """
+    nargs = 2
+
+
+class dsign(FFunction):
+    """ Fortran sign intrinsic for double precision arguments. """
+    nargs = 2
+
+
+class cmplx(FFunction):
+    """ Fortran complex conversion function. """
+    nargs = 2  # may be extended to (2, 3) at a later point
+
+
+class kind(FFunction):
+    """ Fortran kind function. """
+    nargs = 1
+
+
+class merge(F95Function):
+    """ Fortran merge function """
+    nargs = 3
+
+
+class _literal(Float):
+    _token: str
+    _decimals: int
+
+    def _fcode(self, printer, *args, **kwargs):
+        mantissa, sgnd_ex = ('%.{}e'.format(self._decimals) % self).split('e')
+        mantissa = mantissa.strip('0').rstrip('.')
+        ex_sgn, ex_num = sgnd_ex[0], sgnd_ex[1:].lstrip('0')
+        ex_sgn = '' if ex_sgn == '+' else ex_sgn
+        return (mantissa or '0') + self._token + ex_sgn + (ex_num or '0')
+
+
+class literal_sp(_literal):
+    """ Fortran single precision real literal """
+    _token = 'e'
+    _decimals = 9
+
+
+class literal_dp(_literal):
+    """ Fortran double precision real literal """
+    _token = 'd'
+    _decimals = 17
+
+
+class sum_(Token, Expr):
+    __slots__ = _fields = ('array', 'dim', 'mask')
+    defaults = {'dim': none, 'mask': none}
+    _construct_array = staticmethod(sympify)
+    _construct_dim = staticmethod(sympify)
+
+
+class product_(Token, Expr):
+    __slots__ = _fields = ('array', 'dim', 'mask')
+    defaults = {'dim': none, 'mask': none}
+    _construct_array = staticmethod(sympify)
+    _construct_dim = staticmethod(sympify)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/futils.py b/.venv/lib/python3.12/site-packages/sympy/codegen/futils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a1f5751fbd4d6b44d99c69a74ad89a8496f8648
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/futils.py
@@ -0,0 +1,40 @@
+from itertools import chain
+from sympy.codegen.fnodes import Module
+from sympy.core.symbol import Dummy
+from sympy.printing.fortran import FCodePrinter
+
+""" This module collects utilities for rendering Fortran code. """
+
+
+def render_as_module(definitions, name, declarations=(), printer_settings=None):
+    """ Creates a ``Module`` instance and renders it as a string.
+
+    This generates Fortran source code for a module with the correct ``use`` statements.
+
+    Parameters
+    ==========
+
+    definitions : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    name : str
+        Passed to :class:`sympy.codegen.fnodes.Module`.
+    declarations : iterable
+        Passed to :class:`sympy.codegen.fnodes.Module`. It will be extended with
+        use statements, 'implicit none' and public list generated from ``definitions``.
+    printer_settings : dict
+        Passed to ``FCodePrinter`` (default: ``{'standard': 2003, 'source_format': 'free'}``).
+
+    """
+    printer_settings = printer_settings or {'standard': 2003, 'source_format': 'free'}
+    printer = FCodePrinter(printer_settings)
+    dummy = Dummy()
+    if isinstance(definitions, Module):
+        raise ValueError("This function expects to construct a module on its own.")
+    mod = Module(name, chain(declarations, [dummy]), definitions)
+    fstr = printer.doprint(mod)
+    module_use_str = '   %s\n' % '   \n'.join(['use %s, only: %s' % (k, ', '.join(v)) for
+                                                k, v in printer.module_uses.items()])
+    module_use_str += '   implicit none\n'
+    module_use_str += '   private\n'
+    module_use_str += '   public %s\n' % ', '.join([str(node.name) for node in definitions if getattr(node, 'name', None)])
+    return fstr.replace(printer.doprint(dummy), module_use_str)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/matrix_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/matrix_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf0a13a81c963e2c9e2b885dabd0ff3e2d2b3eb9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/matrix_nodes.py
@@ -0,0 +1,71 @@
+"""
+Additional AST nodes for operations on matrices. The nodes in this module
+are meant to represent optimization of matrix expressions within codegen's
+target languages that cannot be represented by SymPy expressions.
+
+As an example, we can use :meth:`sympy.codegen.rewriting.optimize` and the
+``matin_opt`` optimization provided in :mod:`sympy.codegen.rewriting` to
+transform matrix multiplication under certain assumptions:
+
+    >>> from sympy import symbols, MatrixSymbol
+    >>> n = symbols('n', integer=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> x = MatrixSymbol('x', n, 1)
+    >>> expr = A**(-1) * x
+    >>> from sympy import assuming, Q
+    >>> from sympy.codegen.rewriting import matinv_opt, optimize
+    >>> with assuming(Q.fullrank(A)):
+    ...     optimize(expr, [matinv_opt])
+    MatrixSolve(A, vector=x)
+"""
+
+from .ast import Token
+from sympy.matrices import MatrixExpr
+from sympy.core.sympify import sympify
+
+
+class MatrixSolve(Token, MatrixExpr):
+    """Represents an operation to solve a linear matrix equation.
+
+    Parameters
+    ==========
+
+    matrix : MatrixSymbol
+
+      Matrix representing the coefficients of variables in the linear
+      equation. This matrix must be square and full-rank (i.e. all columns must
+      be linearly independent) for the solving operation to be valid.
+
+    vector : MatrixSymbol
+
+      One-column matrix representing the solutions to the equations
+      represented in ``matrix``.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, MatrixSymbol
+    >>> from sympy.codegen.matrix_nodes import MatrixSolve
+    >>> n = symbols('n', integer=True)
+    >>> A = MatrixSymbol('A', n, n)
+    >>> x = MatrixSymbol('x', n, 1)
+    >>> from sympy.printing.numpy import NumPyPrinter
+    >>> NumPyPrinter().doprint(MatrixSolve(A, x))
+    'numpy.linalg.solve(A, x)'
+    >>> from sympy import octave_code
+    >>> octave_code(MatrixSolve(A, x))
+    'A \\\\ x'
+
+    """
+    __slots__ = _fields = ('matrix', 'vector')
+
+    _construct_matrix = staticmethod(sympify)
+    _construct_vector = staticmethod(sympify)
+
+    @property
+    def shape(self):
+        return self.vector.shape
+
+    def _eval_derivative(self, x):
+        A, b = self.matrix, self.vector
+        return MatrixSolve(A, b.diff(x) - A.diff(x) * MatrixSolve(A, b))
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/numpy_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/numpy_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..c47c87f0e1df74cd314bb70674ebff732fe500aa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/numpy_nodes.py
@@ -0,0 +1,177 @@
+from sympy.core.function import Add, ArgumentIndexError, Function
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import Max, Min
+from .ast import Token, none
+
+
+def _logaddexp(x1, x2, *, evaluate=True):
+    return log(Add(exp(x1, evaluate=evaluate), exp(x2, evaluate=evaluate), evaluate=evaluate))
+
+
+_two = S.One*2
+_ln2 = log(_two)
+
+
+def _lb(x, *, evaluate=True):
+    return log(x, evaluate=evaluate)/_ln2
+
+
+def _exp2(x, *, evaluate=True):
+    return Pow(_two, x, evaluate=evaluate)
+
+
+def _logaddexp2(x1, x2, *, evaluate=True):
+    return _lb(Add(_exp2(x1, evaluate=evaluate),
+                   _exp2(x2, evaluate=evaluate), evaluate=evaluate))
+
+
+class logaddexp(Function):
+    """ Logarithm of the sum of exponentiations of the inputs.
+
+    Helper class for use with e.g. numpy.logaddexp
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.logaddexp.html
+    """
+    nargs = 2
+
+    def __new__(cls, *args):
+        return Function.__new__(cls, *sorted(args, key=default_sort_key))
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            wrt, other = self.args
+        elif argindex == 2:
+            other, wrt = self.args
+        else:
+            raise ArgumentIndexError(self, argindex)
+        return S.One/(S.One + exp(other-wrt))
+
+    def _eval_rewrite_as_log(self, x1, x2, **kwargs):
+        return _logaddexp(x1, x2)
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(log).evalf(*args, **kwargs)
+
+    def _eval_simplify(self, *args, **kwargs):
+        a, b = (x.simplify(**kwargs) for x in self.args)
+        candidate = _logaddexp(a, b)
+        if candidate != _logaddexp(a, b, evaluate=False):
+            return candidate
+        else:
+            return logaddexp(a, b)
+
+
+class logaddexp2(Function):
+    """ Logarithm of the sum of exponentiations of the inputs in base-2.
+
+    Helper class for use with e.g. numpy.logaddexp2
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.logaddexp2.html
+    """
+    nargs = 2
+
+    def __new__(cls, *args):
+        return Function.__new__(cls, *sorted(args, key=default_sort_key))
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            wrt, other = self.args
+        elif argindex == 2:
+            other, wrt = self.args
+        else:
+            raise ArgumentIndexError(self, argindex)
+        return S.One/(S.One + _exp2(other-wrt))
+
+    def _eval_rewrite_as_log(self, x1, x2, **kwargs):
+        return _logaddexp2(x1, x2)
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(log).evalf(*args, **kwargs)
+
+    def _eval_simplify(self, *args, **kwargs):
+        a, b = (x.simplify(**kwargs).factor() for x in self.args)
+        candidate = _logaddexp2(a, b)
+        if candidate != _logaddexp2(a, b, evaluate=False):
+            return candidate
+        else:
+            return logaddexp2(a, b)
+
+
+class amin(Token):
+    """ Minimum value along an axis.
+
+    Helper class for use with e.g. numpy.amin
+
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.amin.html
+    """
+    __slots__ = _fields = ('array', 'axis')
+    defaults = {'axis': none}
+    _construct_axis = staticmethod(sympify)
+
+
+class amax(Token):
+    """ Maximum value along an axis.
+
+    Helper class for use with e.g. numpy.amax
+
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.amax.html
+    """
+    __slots__ = _fields = ('array', 'axis')
+    defaults = {'axis': none}
+    _construct_axis = staticmethod(sympify)
+
+
+class maximum(Function):
+    """ Element-wise maximum of array elements.
+
+    Helper class for use with e.g. numpy.maximum
+
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.maximum.html
+    """
+
+    def _eval_rewrite_as_Max(self, *args):
+        return Max(*self.args)
+
+
+class minimum(Function):
+    """ Element-wise minimum of array elements.
+
+    Helper class for use with e.g. numpy.minimum
+
+
+    See Also
+    ========
+
+    https://numpy.org/doc/stable/reference/generated/numpy.minimum.html
+    """
+
+    def _eval_rewrite_as_Min(self, *args):
+        return Min(*self.args)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/pynodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/pynodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0a08b4a79d32f63d345947d6be310b44504dbf5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/pynodes.py
@@ -0,0 +1,11 @@
+from .abstract_nodes import List as AbstractList
+from .ast import Token
+
+
+class List(AbstractList):
+    pass
+
+
+class NumExprEvaluate(Token):
+    """represents a call to :class:`numexpr`s :func:`evaluate`"""
+    __slots__ = _fields = ('expr',)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/pyutils.py b/.venv/lib/python3.12/site-packages/sympy/codegen/pyutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..e14eabe92ce50105a4055b71a49767aae04610b9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/pyutils.py
@@ -0,0 +1,24 @@
+from sympy.printing.pycode import PythonCodePrinter
+
+""" This module collects utilities for rendering Python code. """
+
+
+def render_as_module(content, standard='python3'):
+    """Renders Python code as a module (with the required imports).
+
+    Parameters
+    ==========
+
+    standard :
+        See the parameter ``standard`` in
+        :meth:`sympy.printing.pycode.pycode`
+    """
+
+    printer = PythonCodePrinter({'standard':standard})
+    pystr = printer.doprint(content)
+    if printer._settings['fully_qualified_modules']:
+        module_imports_str = '\n'.join('import %s' % k for k in printer.module_imports)
+    else:
+        module_imports_str = '\n'.join(['from %s import %s' % (k, ', '.join(v)) for
+                                        k, v in printer.module_imports.items()])
+    return module_imports_str + '\n\n' + pystr
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/rewriting.py b/.venv/lib/python3.12/site-packages/sympy/codegen/rewriting.py
new file mode 100644
index 0000000000000000000000000000000000000000..274b7770b46ded6711468ab2a01db3a53d6fde87
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/rewriting.py
@@ -0,0 +1,357 @@
+"""
+Classes and functions useful for rewriting expressions for optimized code
+generation. Some languages (or standards thereof), e.g. C99, offer specialized
+math functions for better performance and/or precision.
+
+Using the ``optimize`` function in this module, together with a collection of
+rules (represented as instances of ``Optimization``), one can rewrite the
+expressions for this purpose::
+
+    >>> from sympy import Symbol, exp, log
+    >>> from sympy.codegen.rewriting import optimize, optims_c99
+    >>> x = Symbol('x')
+    >>> optimize(3*exp(2*x) - 3, optims_c99)
+    3*expm1(2*x)
+    >>> optimize(exp(2*x) - 1 - exp(-33), optims_c99)
+    expm1(2*x) - exp(-33)
+    >>> optimize(log(3*x + 3), optims_c99)
+    log1p(x) + log(3)
+    >>> optimize(log(2*x + 3), optims_c99)
+    log(2*x + 3)
+
+The ``optims_c99`` imported above is tuple containing the following instances
+(which may be imported from ``sympy.codegen.rewriting``):
+
+- ``expm1_opt``
+- ``log1p_opt``
+- ``exp2_opt``
+- ``log2_opt``
+- ``log2const_opt``
+
+
+"""
+from sympy.core.function import expand_log
+from sympy.core.singleton import S
+from sympy.core.symbol import Wild
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min)
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.assumptions import Q, ask
+from sympy.codegen.cfunctions import log1p, log2, exp2, expm1
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.core.expr import UnevaluatedExpr
+from sympy.core.power import Pow
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2
+from sympy.codegen.scipy_nodes import cosm1, powm1
+from sympy.core.mul import Mul
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.utilities.iterables import sift
+
+
+class Optimization:
+    """ Abstract base class for rewriting optimization.
+
+    Subclasses should implement ``__call__`` taking an expression
+    as argument.
+
+    Parameters
+    ==========
+    cost_function : callable returning number
+    priority : number
+
+    """
+    def __init__(self, cost_function=None, priority=1):
+        self.cost_function = cost_function
+        self.priority=priority
+
+    def cheapest(self, *args):
+        return min(args, key=self.cost_function)
+
+
+class ReplaceOptim(Optimization):
+    """ Rewriting optimization calling replace on expressions.
+
+    Explanation
+    ===========
+
+    The instance can be used as a function on expressions for which
+    it will apply the ``replace`` method (see
+    :meth:`sympy.core.basic.Basic.replace`).
+
+    Parameters
+    ==========
+
+    query :
+        First argument passed to replace.
+    value :
+        Second argument passed to replace.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.codegen.rewriting import ReplaceOptim
+    >>> from sympy.codegen.cfunctions import exp2
+    >>> x = Symbol('x')
+    >>> exp2_opt = ReplaceOptim(lambda p: p.is_Pow and p.base == 2,
+    ...     lambda p: exp2(p.exp))
+    >>> exp2_opt(2**x)
+    exp2(x)
+
+    """
+
+    def __init__(self, query, value, **kwargs):
+        super().__init__(**kwargs)
+        self.query = query
+        self.value = value
+
+    def __call__(self, expr):
+        return expr.replace(self.query, self.value)
+
+
+def optimize(expr, optimizations):
+    """ Apply optimizations to an expression.
+
+    Parameters
+    ==========
+
+    expr : expression
+    optimizations : iterable of ``Optimization`` instances
+        The optimizations will be sorted with respect to ``priority`` (highest first).
+
+    Examples
+    ========
+
+    >>> from sympy import log, Symbol
+    >>> from sympy.codegen.rewriting import optims_c99, optimize
+    >>> x = Symbol('x')
+    >>> optimize(log(x+3)/log(2) + log(x**2 + 1), optims_c99)
+    log1p(x**2) + log2(x + 3)
+
+    """
+
+    for optim in sorted(optimizations, key=lambda opt: opt.priority, reverse=True):
+        new_expr = optim(expr)
+        if optim.cost_function is None:
+            expr = new_expr
+        else:
+            expr = optim.cheapest(expr, new_expr)
+    return expr
+
+
+exp2_opt = ReplaceOptim(
+    lambda p: p.is_Pow and p.base == 2,
+    lambda p: exp2(p.exp)
+)
+
+
+_d = Wild('d', properties=[lambda x: x.is_Dummy])
+_u = Wild('u', properties=[lambda x: not x.is_number and not x.is_Add])
+_v = Wild('v')
+_w = Wild('w')
+_n = Wild('n', properties=[lambda x: x.is_number])
+
+sinc_opt1 = ReplaceOptim(
+    sin(_w)/_w, sinc(_w)
+)
+sinc_opt2 = ReplaceOptim(
+    sin(_n*_w)/_w, _n*sinc(_n*_w)
+)
+sinc_opts = (sinc_opt1, sinc_opt2)
+
+log2_opt = ReplaceOptim(_v*log(_w)/log(2), _v*log2(_w), cost_function=lambda expr: expr.count(
+    lambda e: (  # division & eval of transcendentals are expensive floating point operations...
+        e.is_Pow and e.exp.is_negative  # division
+        or (isinstance(e, (log, log2)) and not e.args[0].is_number))  # transcendental
+    )
+)
+
+log2const_opt = ReplaceOptim(log(2)*log2(_w), log(_w))
+
+logsumexp_2terms_opt = ReplaceOptim(
+    lambda l: (isinstance(l, log)
+               and l.args[0].is_Add
+               and len(l.args[0].args) == 2
+               and all(isinstance(t, exp) for t in l.args[0].args)),
+    lambda l: (
+        Max(*[e.args[0] for e in l.args[0].args]) +
+        log1p(exp(Min(*[e.args[0] for e in l.args[0].args])))
+    )
+)
+
+
+class FuncMinusOneOptim(ReplaceOptim):
+    """Specialization of ReplaceOptim for functions evaluating "f(x) - 1".
+
+    Explanation
+    ===========
+
+    Numerical functions which go toward one as x go toward zero is often best
+    implemented by a dedicated function in order to avoid catastrophic
+    cancellation. One such example is ``expm1(x)`` in the C standard library
+    which evaluates ``exp(x) - 1``. Such functions preserves many more
+    significant digits when its argument is much smaller than one, compared
+    to subtracting one afterwards.
+
+    Parameters
+    ==========
+
+    func :
+        The function which is subtracted by one.
+    func_m_1 :
+        The specialized function evaluating ``func(x) - 1``.
+    opportunistic : bool
+        When ``True``, apply the transformation as long as the magnitude of the
+        remaining number terms decreases. When ``False``, only apply the
+        transformation if it completely eliminates the number term.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, exp
+    >>> from sympy.codegen.rewriting import FuncMinusOneOptim
+    >>> from sympy.codegen.cfunctions import expm1
+    >>> x, y = symbols('x y')
+    >>> expm1_opt = FuncMinusOneOptim(exp, expm1)
+    >>> expm1_opt(exp(x) + 2*exp(5*y) - 3)
+    expm1(x) + 2*expm1(5*y)
+
+
+    """
+
+    def __init__(self, func, func_m_1, opportunistic=True):
+        weight = 10  # <-- this is an arbitrary number (heuristic)
+        super().__init__(lambda e: e.is_Add, self.replace_in_Add,
+                         cost_function=lambda expr: expr.count_ops() - weight*expr.count(func_m_1))
+        self.func = func
+        self.func_m_1 = func_m_1
+        self.opportunistic = opportunistic
+
+    def _group_Add_terms(self, add):
+        numbers, non_num = sift(add.args, lambda arg: arg.is_number, binary=True)
+        numsum = sum(numbers)
+        terms_with_func, other = sift(non_num, lambda arg: arg.has(self.func), binary=True)
+        return numsum, terms_with_func, other
+
+    def replace_in_Add(self, e):
+        """ passed as second argument to Basic.replace(...) """
+        numsum, terms_with_func, other_non_num_terms = self._group_Add_terms(e)
+        if numsum == 0:
+            return e
+        substituted, untouched = [], []
+        for with_func in terms_with_func:
+            if with_func.is_Mul:
+                func, coeff = sift(with_func.args, lambda arg: arg.func == self.func, binary=True)
+                if len(func) == 1 and len(coeff) == 1:
+                    func, coeff = func[0], coeff[0]
+                else:
+                    coeff = None
+            elif with_func.func == self.func:
+                func, coeff = with_func, S.One
+            else:
+                coeff = None
+
+            if coeff is not None and coeff.is_number and sign(coeff) == -sign(numsum):
+                if self.opportunistic:
+                    do_substitute = abs(coeff+numsum) < abs(numsum)
+                else:
+                    do_substitute = coeff+numsum == 0
+
+                if do_substitute:  # advantageous substitution
+                    numsum += coeff
+                    substituted.append(coeff*self.func_m_1(*func.args))
+                    continue
+            untouched.append(with_func)
+
+        return e.func(numsum, *substituted, *untouched, *other_non_num_terms)
+
+    def __call__(self, expr):
+        alt1 = super().__call__(expr)
+        alt2 = super().__call__(expr.factor())
+        return self.cheapest(alt1, alt2)
+
+
+expm1_opt = FuncMinusOneOptim(exp, expm1)
+cosm1_opt = FuncMinusOneOptim(cos, cosm1)
+powm1_opt = FuncMinusOneOptim(Pow, powm1)
+
+log1p_opt = ReplaceOptim(
+    lambda e: isinstance(e, log),
+    lambda l: expand_log(l.replace(
+        log, lambda arg: log(arg.factor())
+    )).replace(log(_u+1), log1p(_u))
+)
+
+def create_expand_pow_optimization(limit, *, base_req=lambda b: b.is_symbol):
+    """ Creates an instance of :class:`ReplaceOptim` for expanding ``Pow``.
+
+    Explanation
+    ===========
+
+    The requirements for expansions are that the base needs to be a symbol
+    and the exponent needs to be an Integer (and be less than or equal to
+    ``limit``).
+
+    Parameters
+    ==========
+
+    limit : int
+         The highest power which is expanded into multiplication.
+    base_req : function returning bool
+         Requirement on base for expansion to happen, default is to return
+         the ``is_symbol`` attribute of the base.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, sin
+    >>> from sympy.codegen.rewriting import create_expand_pow_optimization
+    >>> x = Symbol('x')
+    >>> expand_opt = create_expand_pow_optimization(3)
+    >>> expand_opt(x**5 + x**3)
+    x**5 + x*x*x
+    >>> expand_opt(x**5 + x**3 + sin(x)**3)
+    x**5 + sin(x)**3 + x*x*x
+    >>> opt2 = create_expand_pow_optimization(3, base_req=lambda b: not b.is_Function)
+    >>> opt2((x+1)**2 + sin(x)**2)
+    sin(x)**2 + (x + 1)*(x + 1)
+
+    """
+    return ReplaceOptim(
+        lambda e: e.is_Pow and base_req(e.base) and e.exp.is_Integer and abs(e.exp) <= limit,
+        lambda p: (
+            UnevaluatedExpr(Mul(*([p.base]*+p.exp), evaluate=False)) if p.exp > 0 else
+            1/UnevaluatedExpr(Mul(*([p.base]*-p.exp), evaluate=False))
+        ))
+
+# Optimization procedures for turning A**(-1) * x into MatrixSolve(A, x)
+def _matinv_predicate(expr):
+    # TODO: We should be able to support more than 2 elements
+    if expr.is_MatMul and len(expr.args) == 2:
+        left, right = expr.args
+        if left.is_Inverse and right.shape[1] == 1:
+            inv_arg = left.arg
+            if isinstance(inv_arg, MatrixSymbol):
+                return bool(ask(Q.fullrank(left.arg)))
+
+    return False
+
+def _matinv_transform(expr):
+    left, right = expr.args
+    inv_arg = left.arg
+    return MatrixSolve(inv_arg, right)
+
+
+matinv_opt = ReplaceOptim(_matinv_predicate, _matinv_transform)
+
+
+logaddexp_opt = ReplaceOptim(log(exp(_v)+exp(_w)), logaddexp(_v, _w))
+logaddexp2_opt = ReplaceOptim(log(Pow(2, _v)+Pow(2, _w)), logaddexp2(_v, _w)*log(2))
+
+# Collections of optimizations:
+optims_c99 = (expm1_opt, log1p_opt, exp2_opt, log2_opt, log2const_opt)
+
+optims_numpy = optims_c99 + (logaddexp_opt, logaddexp2_opt,) + sinc_opts
+
+optims_scipy = (cosm1_opt, powm1_opt)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/scipy_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/scipy_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..059a853fc8cac6e0b9a1a3c7395dd3a15384dcba
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/scipy_nodes.py
@@ -0,0 +1,79 @@
+from sympy.core.function import Add, ArgumentIndexError, Function
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.trigonometric import cos, sin
+
+
+def _cosm1(x, *, evaluate=True):
+    return Add(cos(x, evaluate=evaluate), -S.One, evaluate=evaluate)
+
+
+class cosm1(Function):
+    """ Minus one plus cosine of x, i.e. cos(x) - 1. For use when x is close to zero.
+
+    Helper class for use with e.g. scipy.special.cosm1
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.cosm1.html
+    """
+    nargs = 1
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return -sin(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_cos(self, x, **kwargs):
+        return _cosm1(x)
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(cos).evalf(*args, **kwargs)
+
+    def _eval_simplify(self, **kwargs):
+        x, = self.args
+        candidate = _cosm1(x.simplify(**kwargs))
+        if candidate != _cosm1(x, evaluate=False):
+            return candidate
+        else:
+            return cosm1(x)
+
+
+def _powm1(x, y, *, evaluate=True):
+    return Add(Pow(x, y, evaluate=evaluate), -S.One, evaluate=evaluate)
+
+
+class powm1(Function):
+    """ Minus one plus x to the power of y, i.e. x**y - 1. For use when x is close to one or y is close to zero.
+
+    Helper class for use with e.g. scipy.special.powm1
+    See: https://docs.scipy.org/doc/scipy/reference/generated/scipy.special.powm1.html
+    """
+    nargs = 2
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return Pow(self.args[0], self.args[1])*self.args[1]/self.args[0]
+        elif argindex == 2:
+            return log(self.args[0])*Pow(*self.args)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Pow(self, x, y, **kwargs):
+        return _powm1(x, y)
+
+    def _eval_evalf(self, *args, **kwargs):
+        return self.rewrite(Pow).evalf(*args, **kwargs)
+
+    def _eval_simplify(self, **kwargs):
+        x, y = self.args
+        candidate = _powm1(x.simplify(**kwargs), y.simplify(**kwargs))
+        if candidate != _powm1(x, y, evaluate=False):
+            return candidate
+        else:
+            return powm1(x, y)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d04137c2d59ba8544ab45fdaaa8e6ae9022d5e4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_abstract_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_abstract_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c922884a77a47dfd4d7f6d24c80903f8a7e7a479
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_abstract_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_algorithms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_algorithms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5382b65d9610b13f1a8e17e55499d6565910f07a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_algorithms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_applications.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_applications.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7bb06e2a817f68b5a66f6d5bb6203d3f2cac1399
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_applications.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_approximations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_approximations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..011bb30b96744d252aaa67ac09f3b857d6c22c61
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_approximations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_ast.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_ast.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..298d917bf1a19e79bf77e83da76c852086592acc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_ast.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cfunctions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cfunctions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..222b606121e634e3e7c2d3c0a7facb11f37f24bc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cfunctions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9ca2e8e45abbab8a7560d5666b096a86f66360c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cxxnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cxxnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0a5adcbb364f2809955ec02106994115c85b4f2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_cxxnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_fnodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_fnodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a90ea8f13654ee5f4c7af5b2a9377f626f88c3c9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_fnodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_matrix_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_matrix_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..11fef2fa36ab06d6ec06b7e2b5bc2bb004eb7efc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_matrix_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_numpy_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_numpy_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1fa627608c9d166bfd35f4b91d1f195dacecf54
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_numpy_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pynodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pynodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..966e69bc47179743db7f9d087b3d456e2a633e80
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pynodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pyutils.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pyutils.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df75096e3d925170b786dca13f1f9291c9cce3b7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_pyutils.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_rewriting.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_rewriting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..34109a1abe89fb7121cc8c83eca2aec62151f1cc
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_rewriting.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_scipy_nodes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_scipy_nodes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a3984b0e7c023ca2a99f43564d84fa1a8d2de79a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/__pycache__/test_scipy_nodes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_abstract_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_abstract_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..89e1f73ff8cb24a4a865aa51304ec66e9901e3cb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_abstract_nodes.py
@@ -0,0 +1,14 @@
+from sympy.core.symbol import symbols
+from sympy.codegen.abstract_nodes import List
+
+
+def test_List():
+    l = List(2, 3, 4)
+    assert l == List(2, 3, 4)
+    assert str(l) == "[2, 3, 4]"
+    x, y, z = symbols('x y z')
+    l = List(x**2,y**3,z**4)
+    # contrary to python's built-in list, we can call e.g. "replace" on List.
+    m = l.replace(lambda arg: arg.is_Pow and arg.exp>2, lambda p: p.base-p.exp)
+    assert m == [x**2, y-3, z-4]
+    hash(m)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_algorithms.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_algorithms.py
new file mode 100644
index 0000000000000000000000000000000000000000..c684229ec18a1e02a97eee6db8537b8d12af0582
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_algorithms.py
@@ -0,0 +1,180 @@
+import tempfile
+from sympy import log, Min, Max, sqrt
+from sympy.core.numbers import Float
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.trigonometric import cos
+from sympy.codegen.ast import Assignment, Raise, RuntimeError_, QuotedString
+from sympy.codegen.algorithms import newtons_method, newtons_method_function
+from sympy.codegen.cfunctions import expm1
+from sympy.codegen.fnodes import bind_C
+from sympy.codegen.futils import render_as_module as f_module
+from sympy.codegen.pyutils import render_as_module as py_module
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.utilities._compilation import compile_link_import_strings, has_c, has_fortran
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, raises, skip_under_pyodide
+
+cython = import_module('cython')
+wurlitzer = import_module('wurlitzer')
+
+def test_newtons_method():
+    x, dx, atol = symbols('x dx atol')
+    expr = cos(x) - x**3
+    algo = newtons_method(expr, x, atol, dx)
+    assert algo.has(Assignment(dx, -expr/expr.diff(x)))
+
+
+@may_xfail
+def test_newtons_method_function__ccode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.c', ('#include \n'
+                          '#include \n') + ccode(func)),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double)\n"
+                             "def py_newton(x):\n"
+                             "    return newton(x)\n"))
+        ], build_dir=folder, compile_kwargs=compile_kw)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+@may_xfail
+def test_newtons_method_function__fcode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x, attrs=[bind_C(name='newton')])
+
+    if not cython:
+        skip("cython not installed.")
+    if not has_fortran():
+        skip("No Fortran compiler found.")
+
+    f_mod = f_module([func], 'mod_newton')
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton.f90', f_mod),
+            ('_newton.pyx', ("#cython: language_level={}\n".format("3") +
+                             "cdef extern double newton(double*)\n"
+                             "def py_newton(double x):\n"
+                             "    return newton(&x)\n"))
+        ], build_dir=folder)
+        assert abs(mod.py_newton(0.5) - 0.865474033102) < 1e-12
+
+
+def test_newtons_method_function__pycode():
+    x = Symbol('x', real=True)
+    expr = cos(x) - x**3
+    func = newtons_method_function(expr, x)
+    py_mod = py_module(func)
+    namespace = {}
+    exec(py_mod, namespace, namespace)
+    res = eval('newton(0.5)', namespace)
+    assert abs(res - 0.865474033102) < 1e-12
+
+
+@may_xfail
+@skip_under_pyodide("Emscripten does not support process spawning")
+def test_newtons_method_function__ccode_parameters():
+    args = x, A, k, p = symbols('x A k p')
+    expr = A*cos(k*x) - p*x**3
+    raises(ValueError, lambda: newtons_method_function(expr, x))
+    use_wurlitzer = wurlitzer
+
+    func = newtons_method_function(expr, x, args, debug=use_wurlitzer)
+
+    if not has_c():
+        skip("No C compiler found.")
+    if not cython:
+        skip("cython not installed.")
+
+    compile_kw = {"std": 'c99'}
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings([
+            ('newton_par.c', ('#include \n'
+                          '#include \n') + ccode(func)),
+            ('_newton_par.pyx', ("#cython: language_level={}\n".format("3") +
+                                 "cdef extern double newton(double, double, double, double)\n"
+                             "def py_newton(x, A=1, k=1, p=1):\n"
+                             "    return newton(x, A, k, p)\n"))
+        ], compile_kwargs=compile_kw, build_dir=folder)
+
+        if use_wurlitzer:
+            with wurlitzer.pipes() as (out, err):
+                result = mod.py_newton(0.5)
+        else:
+            result = mod.py_newton(0.5)
+
+        assert abs(result - 0.865474033102) < 1e-12
+
+        if not use_wurlitzer:
+            skip("C-level output only tested when package 'wurlitzer' is available.")
+
+        out, err = out.read(), err.read()
+        assert err == ''
+        assert out == """\
+x=         0.5
+x=      1.1121 d_x=     0.61214
+x=     0.90967 d_x=    -0.20247
+x=     0.86726 d_x=   -0.042409
+x=     0.86548 d_x=  -0.0017867
+x=     0.86547 d_x= -3.1022e-06
+x=     0.86547 d_x= -9.3421e-12
+x=     0.86547 d_x=  3.6902e-17
+"""  # try to run tests with LC_ALL=C if this assertion fails
+
+
+def test_newtons_method_function__rtol_cse_nan():
+    a, b, c, N_geo, N_tot = symbols('a b c N_geo N_tot', real=True, nonnegative=True)
+    i = Symbol('i', integer=True, nonnegative=True)
+    N_ari = N_tot - N_geo - 1
+    delta_ari = (c-b)/N_ari
+    ln_delta_geo = log(b) + log(-expm1((log(a)-log(b))/N_geo))
+    eqb_log = ln_delta_geo - log(delta_ari)
+
+    def _clamp(low, expr, high):
+        return Min(Max(low, expr), high)
+
+    meth_kw = {
+        'clamped_newton': {'delta_fn': lambda e, x: _clamp(
+            (sqrt(a*x)-x)*0.99,
+            -e/e.diff(x),
+            (sqrt(c*x)-x)*0.99
+        )},
+        'halley': {'delta_fn': lambda e, x: (-2*(e*e.diff(x))/(2*e.diff(x)**2 - e*e.diff(x, 2)))},
+        'halley_alt': {'delta_fn': lambda e, x: (-e/e.diff(x)/(1-e/e.diff(x)*e.diff(x,2)/2/e.diff(x)))},
+    }
+    args = eqb_log, b
+    for use_cse in [False, True]:
+        kwargs = {
+            'params': (b, a, c, N_geo, N_tot), 'itermax': 60, 'debug': True, 'cse': use_cse,
+            'counter': i, 'atol': 1e-100, 'rtol': 2e-16, 'bounds': (a,c),
+            'handle_nan': Raise(RuntimeError_(QuotedString("encountered NaN.")))
+        }
+        func = {k: newtons_method_function(*args, func_name=f"{k}_b", **dict(kwargs, **kw)) for k, kw in meth_kw.items()}
+        py_mod = {k: py_module(v) for k, v in func.items()}
+        namespace = {}
+        root_find_b = {}
+        for k, v in py_mod.items():
+            ns = namespace[k] = {}
+            exec(v, ns, ns)
+            root_find_b[k] = ns[f'{k}_b']
+        ref = Float('13.2261515064168768938151923226496')
+        reftol = {'clamped_newton': 2e-16, 'halley': 2e-16, 'halley_alt': 3e-16}
+        guess = 4.0
+        for meth, func in root_find_b.items():
+            result = func(guess, 1e-2, 1e2, 50, 100)
+            req = ref*reftol[meth]
+            if use_cse:
+                req *= 2
+            assert abs(result - ref) < req
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_applications.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_applications.py
new file mode 100644
index 0000000000000000000000000000000000000000..9519c06b96042b383314ef928d2ad0c1a2f92650
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_applications.py
@@ -0,0 +1,58 @@
+# This file contains tests that exercise multiple AST nodes
+
+import tempfile
+
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.utilities._compilation import compile_link_import_strings, has_c
+from sympy.utilities._compilation.util import may_xfail
+from sympy.testing.pytest import skip, skip_under_pyodide
+from sympy.codegen.ast import (
+    FunctionDefinition, FunctionPrototype, Variable, Pointer, real, Assignment,
+    integer, CodeBlock, While
+)
+from sympy.codegen.cnodes import void, PreIncrement
+from sympy.codegen.cutils import render_as_source_file
+
+cython = import_module('cython')
+np = import_module('numpy')
+
+def _mk_func1():
+    declars = n, inp, out = Variable('n', integer), Pointer('inp', real), Pointer('out', real)
+    i = Variable('i', integer)
+    whl = While(i2, lambda p: p.base-p.exp)
+    assert m == [x**2, y-3, z-4]
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_pyutils.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_pyutils.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a2f0ff358f333635c8d44195a5c39d63ac8f16f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_pyutils.py
@@ -0,0 +1,7 @@
+from sympy.codegen.ast import Print
+from sympy.codegen.pyutils import render_as_module
+
+def test_standard():
+    ast = Print('x y'.split(), r"coordinate: %12.5g %12.5g\n")
+    assert render_as_module(ast, standard='python3') == \
+        '\n\nprint("coordinate: %12.5g %12.5g\\n" % (x, y), end="")'
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_rewriting.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_rewriting.py
new file mode 100644
index 0000000000000000000000000000000000000000..51e0c9ecc940f60186cc04d4bf15650281d31cd8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_rewriting.py
@@ -0,0 +1,479 @@
+import tempfile
+from sympy.core.numbers import pi, Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.assumptions import assuming, Q
+from sympy.external import import_module
+from sympy.printing.codeprinter import ccode
+from sympy.codegen.matrix_nodes import MatrixSolve
+from sympy.codegen.cfunctions import log2, exp2, expm1, log1p
+from sympy.codegen.numpy_nodes import logaddexp, logaddexp2
+from sympy.codegen.scipy_nodes import cosm1, powm1
+from sympy.codegen.rewriting import (
+    optimize, cosm1_opt, log2_opt, exp2_opt, expm1_opt, log1p_opt, powm1_opt, optims_c99,
+    create_expand_pow_optimization, matinv_opt, logaddexp_opt, logaddexp2_opt,
+    optims_numpy, optims_scipy, sinc_opts, FuncMinusOneOptim
+)
+from sympy.testing.pytest import XFAIL, skip
+from sympy.utilities import lambdify
+from sympy.utilities._compilation import compile_link_import_strings, has_c
+from sympy.utilities._compilation.util import may_xfail
+
+cython = import_module('cython')
+numpy = import_module('numpy')
+scipy = import_module('scipy')
+
+
+def test_log2_opt():
+    x = Symbol('x')
+    expr1 = 7*log(3*x + 5)/(log(2))
+    opt1 = optimize(expr1, [log2_opt])
+    assert opt1 == 7*log2(3*x + 5)
+    assert opt1.rewrite(log) == expr1
+
+    expr2 = 3*log(5*x + 7)/(13*log(2))
+    opt2 = optimize(expr2, [log2_opt])
+    assert opt2 == 3*log2(5*x + 7)/13
+    assert opt2.rewrite(log) == expr2
+
+    expr3 = log(x)/log(2)
+    opt3 = optimize(expr3, [log2_opt])
+    assert opt3 == log2(x)
+    assert opt3.rewrite(log) == expr3
+
+    expr4 = log(x)/log(2) + log(x+1)
+    opt4 = optimize(expr4, [log2_opt])
+    assert opt4 == log2(x) + log(2)*log2(x+1)
+    assert opt4.rewrite(log) == expr4
+
+    expr5 = log(17)
+    opt5 = optimize(expr5, [log2_opt])
+    assert opt5 == expr5
+
+    expr6 = log(x + 3)/log(2)
+    opt6 = optimize(expr6, [log2_opt])
+    assert str(opt6) == 'log2(x + 3)'
+    assert opt6.rewrite(log) == expr6
+
+
+def test_exp2_opt():
+    x = Symbol('x')
+    expr1 = 1 + 2**x
+    opt1 = optimize(expr1, [exp2_opt])
+    assert opt1 == 1 + exp2(x)
+    assert opt1.rewrite(Pow) == expr1
+
+    expr2 = 1 + 3**x
+    assert expr2 == optimize(expr2, [exp2_opt])
+
+
+def test_expm1_opt():
+    x = Symbol('x')
+
+    expr1 = exp(x) - 1
+    opt1 = optimize(expr1, [expm1_opt])
+    assert expm1(x) - opt1 == 0
+    assert opt1.rewrite(exp) == expr1
+
+    expr2 = 3*exp(x) - 3
+    opt2 = optimize(expr2, [expm1_opt])
+    assert 3*expm1(x) == opt2
+    assert opt2.rewrite(exp) == expr2
+
+    expr3 = 3*exp(x) - 5
+    opt3 = optimize(expr3, [expm1_opt])
+    assert 3*expm1(x) - 2 == opt3
+    assert opt3.rewrite(exp) == expr3
+    expm1_opt_non_opportunistic = FuncMinusOneOptim(exp, expm1, opportunistic=False)
+    assert expr3 == optimize(expr3, [expm1_opt_non_opportunistic])
+    assert opt1 == optimize(expr1, [expm1_opt_non_opportunistic])
+    assert opt2 == optimize(expr2, [expm1_opt_non_opportunistic])
+
+    expr4 = 3*exp(x) + log(x) - 3
+    opt4 = optimize(expr4, [expm1_opt])
+    assert 3*expm1(x) + log(x) == opt4
+    assert opt4.rewrite(exp) == expr4
+
+    expr5 = 3*exp(2*x) - 3
+    opt5 = optimize(expr5, [expm1_opt])
+    assert 3*expm1(2*x) == opt5
+    assert opt5.rewrite(exp) == expr5
+
+    expr6 = (2*exp(x) + 1)/(exp(x) + 1) + 1
+    opt6 = optimize(expr6, [expm1_opt])
+    assert opt6.count_ops() <= expr6.count_ops()
+
+    def ev(e):
+        return e.subs(x, 3).evalf()
+    assert abs(ev(expr6) - ev(opt6)) < 1e-15
+
+    y = Symbol('y')
+    expr7 = (2*exp(x) - 1)/(1 - exp(y)) - 1/(1-exp(y))
+    opt7 = optimize(expr7, [expm1_opt])
+    assert -2*expm1(x)/expm1(y) == opt7
+    assert (opt7.rewrite(exp) - expr7).factor() == 0
+
+    expr8 = (1+exp(x))**2 - 4
+    opt8 = optimize(expr8, [expm1_opt])
+    tgt8a = (exp(x) + 3)*expm1(x)
+    tgt8b = 2*expm1(x) + expm1(2*x)
+    # Both tgt8a & tgt8b seem to give full precision (~16 digits for double)
+    # for x=1e-7 (compare with expr8 which only achieves ~8 significant digits).
+    # If we can show that either tgt8a or tgt8b is preferable, we can
+    # change this test to ensure the preferable version is returned.
+    assert (tgt8a - tgt8b).rewrite(exp).factor() == 0
+    assert opt8 in (tgt8a, tgt8b)
+    assert (opt8.rewrite(exp) - expr8).factor() == 0
+
+    expr9 = sin(expr8)
+    opt9 = optimize(expr9, [expm1_opt])
+    tgt9a = sin(tgt8a)
+    tgt9b = sin(tgt8b)
+    assert opt9 in (tgt9a, tgt9b)
+    assert (opt9.rewrite(exp) - expr9.rewrite(exp)).factor().is_zero
+
+
+def test_expm1_two_exp_terms():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = exp(x) + exp(y) - 2
+    opt1 = optimize(expr1, [expm1_opt])
+    assert opt1 == expm1(x) + expm1(y)
+
+
+def test_cosm1_opt():
+    x = Symbol('x')
+
+    expr1 = cos(x) - 1
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert cosm1(x) - opt1 == 0
+    assert opt1.rewrite(cos) == expr1
+
+    expr2 = 3*cos(x) - 3
+    opt2 = optimize(expr2, [cosm1_opt])
+    assert 3*cosm1(x) == opt2
+    assert opt2.rewrite(cos) == expr2
+
+    expr3 = 3*cos(x) - 5
+    opt3 = optimize(expr3, [cosm1_opt])
+    assert 3*cosm1(x) - 2 == opt3
+    assert opt3.rewrite(cos) == expr3
+    cosm1_opt_non_opportunistic = FuncMinusOneOptim(cos, cosm1, opportunistic=False)
+    assert expr3 == optimize(expr3, [cosm1_opt_non_opportunistic])
+    assert opt1 == optimize(expr1, [cosm1_opt_non_opportunistic])
+    assert opt2 == optimize(expr2, [cosm1_opt_non_opportunistic])
+
+    expr4 = 3*cos(x) + log(x) - 3
+    opt4 = optimize(expr4, [cosm1_opt])
+    assert 3*cosm1(x) + log(x) == opt4
+    assert opt4.rewrite(cos) == expr4
+
+    expr5 = 3*cos(2*x) - 3
+    opt5 = optimize(expr5, [cosm1_opt])
+    assert 3*cosm1(2*x) == opt5
+    assert opt5.rewrite(cos) == expr5
+
+    expr6 = 2 - 2*cos(x)
+    opt6 = optimize(expr6, [cosm1_opt])
+    assert -2*cosm1(x) == opt6
+    assert opt6.rewrite(cos) == expr6
+
+
+def test_cosm1_two_cos_terms():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = cos(x) + cos(y) - 2
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert opt1 == cosm1(x) + cosm1(y)
+
+
+def test_expm1_cosm1_mixed():
+    x = Symbol('x')
+    expr1 = exp(x) + cos(x) - 2
+    opt1 = optimize(expr1, [expm1_opt, cosm1_opt])
+    assert opt1 == cosm1(x) + expm1(x)
+
+
+def _check_num_lambdify(expr, opt, val_subs, approx_ref, lambdify_kw=None, poorness=1e10):
+    """ poorness=1e10 signifies that `expr` loses precision of at least ten decimal digits. """
+    num_ref = expr.subs(val_subs).evalf()
+    eps = numpy.finfo(numpy.float64).eps
+    assert abs(num_ref - approx_ref) < approx_ref*eps
+    f1 = lambdify(list(val_subs.keys()), opt, **(lambdify_kw or {}))
+    args_float = tuple(map(float, val_subs.values()))
+    num_err1 = abs(f1(*args_float) - approx_ref)
+    assert num_err1 < abs(num_ref*eps)
+    f2 = lambdify(list(val_subs.keys()), expr, **(lambdify_kw or {}))
+    num_err2 = abs(f2(*args_float) - approx_ref)
+    assert num_err2 > abs(num_ref*eps*poorness)   # this only ensures that the *test* works as intended
+
+
+def test_cosm1_apart():
+    x = Symbol('x')
+
+    expr1 = 1/cos(x) - 1
+    opt1 = optimize(expr1, [cosm1_opt])
+    assert opt1 == -cosm1(x)/cos(x)
+    if scipy:
+        _check_num_lambdify(expr1, opt1, {x: S(10)**-30}, 5e-61, lambdify_kw={"modules": 'scipy'})
+
+    expr2 = 2/cos(x) - 2
+    opt2 = optimize(expr2, optims_scipy)
+    assert opt2 == -2*cosm1(x)/cos(x)
+    if scipy:
+        _check_num_lambdify(expr2, opt2, {x: S(10)**-30}, 1e-60, lambdify_kw={"modules": 'scipy'})
+
+    expr3 = pi/cos(3*x) - pi
+    opt3 = optimize(expr3, [cosm1_opt])
+    assert opt3 == -pi*cosm1(3*x)/cos(3*x)
+    if scipy:
+        _check_num_lambdify(expr3, opt3, {x: S(10)**-30/3}, float(5e-61*pi), lambdify_kw={"modules": 'scipy'})
+
+
+def test_powm1():
+    args = x, y = map(Symbol, "xy")
+
+    expr1 = x**y - 1
+    opt1 = optimize(expr1, [powm1_opt])
+    assert opt1 == powm1(x, y)
+    for arg in args:
+        assert expr1.diff(arg) == opt1.diff(arg)
+    if scipy and tuple(map(int, scipy.version.version.split('.')[:3])) >= (1, 10, 0):
+        subs1_a = {x: Rational(*(1.0+1e-13).as_integer_ratio()), y: pi}
+        ref1_f64_a = 3.139081648208105e-13
+        _check_num_lambdify(expr1, opt1, subs1_a, ref1_f64_a, lambdify_kw={"modules": 'scipy'}, poorness=10**11)
+
+        subs1_b = {x: pi, y: Rational(*(1e-10).as_integer_ratio())}
+        ref1_f64_b = 1.1447298859149205e-10
+        _check_num_lambdify(expr1, opt1, subs1_b, ref1_f64_b, lambdify_kw={"modules": 'scipy'}, poorness=10**9)
+
+
+def test_log1p_opt():
+    x = Symbol('x')
+    expr1 = log(x + 1)
+    opt1 = optimize(expr1, [log1p_opt])
+    assert log1p(x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+    expr2 = log(3*x + 3)
+    opt2 = optimize(expr2, [log1p_opt])
+    assert log1p(x) + log(3) == opt2
+    assert (opt2.rewrite(log) - expr2).simplify() == 0
+
+    expr3 = log(2*x + 1)
+    opt3 = optimize(expr3, [log1p_opt])
+    assert log1p(2*x) - opt3 == 0
+    assert opt3.rewrite(log) == expr3
+
+    expr4 = log(x+3)
+    opt4 = optimize(expr4, [log1p_opt])
+    assert str(opt4) == 'log(x + 3)'
+
+
+def test_optims_c99():
+    x = Symbol('x')
+
+    expr1 = 2**x + log(x)/log(2) + log(x + 1) + exp(x) - 1
+    opt1 = optimize(expr1, optims_c99).simplify()
+    assert opt1 == exp2(x) + log2(x) + log1p(x) + expm1(x)
+    assert opt1.rewrite(exp).rewrite(log).rewrite(Pow) == expr1
+
+    expr2 = log(x)/log(2) + log(x + 1)
+    opt2 = optimize(expr2, optims_c99)
+    assert opt2 == log2(x) + log1p(x)
+    assert opt2.rewrite(log) == expr2
+
+    expr3 = log(x)/log(2) + log(17*x + 17)
+    opt3 = optimize(expr3, optims_c99)
+    delta3 = opt3 - (log2(x) + log(17) + log1p(x))
+    assert delta3 == 0
+    assert (opt3.rewrite(log) - expr3).simplify() == 0
+
+    expr4 = 2**x + 3*log(5*x + 7)/(13*log(2)) + 11*exp(x) - 11 + log(17*x + 17)
+    opt4 = optimize(expr4, optims_c99).simplify()
+    delta4 = opt4 - (exp2(x) + 3*log2(5*x + 7)/13 + 11*expm1(x) + log(17) + log1p(x))
+    assert delta4 == 0
+    assert (opt4.rewrite(exp).rewrite(log).rewrite(Pow) - expr4).simplify() == 0
+
+    expr5 = 3*exp(2*x) - 3
+    opt5 = optimize(expr5, optims_c99)
+    delta5 = opt5 - 3*expm1(2*x)
+    assert delta5 == 0
+    assert opt5.rewrite(exp) == expr5
+
+    expr6 = exp(2*x) - 3
+    opt6 = optimize(expr6, optims_c99)
+    assert opt6 in (expm1(2*x) - 2, expr6)  # expm1(2*x) - 2 is not better or worse
+
+    expr7 = log(3*x + 3)
+    opt7 = optimize(expr7, optims_c99)
+    delta7 = opt7 - (log(3) + log1p(x))
+    assert delta7 == 0
+    assert (opt7.rewrite(log) - expr7).simplify() == 0
+
+    expr8 = log(2*x + 3)
+    opt8 = optimize(expr8, optims_c99)
+    assert opt8 == expr8
+
+
+def test_create_expand_pow_optimization():
+    cc = lambda x: ccode(
+        optimize(x, [create_expand_pow_optimization(4)]))
+    x = Symbol('x')
+    assert cc(x**4) == 'x*x*x*x'
+    assert cc(x**4 + x**2) == 'x*x + x*x*x*x'
+    assert cc(x**5 + x**4) == 'pow(x, 5) + x*x*x*x'
+    assert cc(sin(x)**4) == 'pow(sin(x), 4)'
+    # gh issue 15335
+    assert cc(x**(-4)) == '1.0/(x*x*x*x)'
+    assert cc(x**(-5)) == 'pow(x, -5)'
+    assert cc(-x**4) == '-(x*x*x*x)'
+    assert cc(x**4 - x**2) == '-(x*x) + x*x*x*x'
+    i = Symbol('i', integer=True)
+    assert cc(x**i - x**2) == 'pow(x, i) - (x*x)'
+    y = Symbol('y', real=True)
+    assert cc(Abs(exp(y**4))) == "exp(y*y*y*y)"
+
+    # gh issue 20753
+    cc2 = lambda x: ccode(optimize(x, [create_expand_pow_optimization(
+        4, base_req=lambda b: b.is_Function)]))
+    assert cc2(x**3 + sin(x)**3) == "pow(x, 3) + sin(x)*sin(x)*sin(x)"
+
+
+def test_matsolve():
+    n = Symbol('n', integer=True)
+    A = MatrixSymbol('A', n, n)
+    x = MatrixSymbol('x', n, 1)
+
+    with assuming(Q.fullrank(A)):
+        assert optimize(A**(-1) * x, [matinv_opt]) == MatrixSolve(A, x)
+        assert optimize(A**(-1) * x + x, [matinv_opt]) == MatrixSolve(A, x) + x
+
+
+def test_logaddexp_opt():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = log(exp(x) + exp(y))
+    opt1 = optimize(expr1, [logaddexp_opt])
+    assert logaddexp(x, y) - opt1 == 0
+    assert logaddexp(y, x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+
+def test_logaddexp2_opt():
+    x, y = map(Symbol, 'x y'.split())
+    expr1 = log(2**x + 2**y)/log(2)
+    opt1 = optimize(expr1, [logaddexp2_opt])
+    assert logaddexp2(x, y) - opt1 == 0
+    assert logaddexp2(y, x) - opt1 == 0
+    assert opt1.rewrite(log) == expr1
+
+
+def test_sinc_opts():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, sinc_opts) == v
+
+    x = Symbol('x')
+    check({
+        sin(x)/x       : sinc(x),
+        sin(2*x)/(2*x) : sinc(2*x),
+        sin(3*x)/x     : 3*sinc(3*x),
+        x*sin(x)       : x*sin(x)
+    })
+
+    y = Symbol('y')
+    check({
+        sin(x*y)/(x*y)       : sinc(x*y),
+        y*sin(x/y)/x         : sinc(x/y),
+        sin(sin(x))/sin(x)   : sinc(sin(x)),
+        sin(3*sin(x))/sin(x) : 3*sinc(3*sin(x)),
+        sin(x)/y             : sin(x)/y
+    })
+
+
+def test_optims_numpy():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, optims_numpy) == v
+
+    x = Symbol('x')
+    check({
+        sin(2*x)/(2*x) + exp(2*x) - 1: sinc(2*x) + expm1(2*x),
+        log(x+3)/log(2) + log(x**2 + 1): log1p(x**2) + log2(x+3)
+    })
+
+
+@XFAIL  # room for improvement, ideally this test case should pass.
+def test_optims_numpy_TODO():
+    def check(d):
+        for k, v in d.items():
+            assert optimize(k, optims_numpy) == v
+
+    x, y = map(Symbol, 'x y'.split())
+    check({
+        log(x*y)*sin(x*y)*log(x*y+1)/(log(2)*x*y): log2(x*y)*sinc(x*y)*log1p(x*y),
+        exp(x*sin(y)/y) - 1: expm1(x*sinc(y))
+    })
+
+
+@may_xfail
+def test_compiled_ccode_with_rewriting():
+    if not cython:
+        skip("cython not installed.")
+    if not has_c():
+        skip("No C compiler found.")
+
+    x = Symbol('x')
+    about_two = 2**(58/S(117))*3**(97/S(117))*5**(4/S(39))*7**(92/S(117))/S(30)*pi
+    # about_two: 1.999999999999581826
+    unchanged = 2*exp(x) - about_two
+    xval = S(10)**-11
+    ref = unchanged.subs(x, xval).n(19) # 2.0418173913673213e-11
+
+    rewritten = optimize(2*exp(x) - about_two, [expm1_opt])
+
+    # Unfortunately, we need to call ``.n()`` on our expressions before we hand them
+    # to ``ccode``, and we need to request a large number of significant digits.
+    # In this test, results converged for double precision when the following number
+    # of significant digits were chosen:
+    NUMBER_OF_DIGITS = 25   # TODO: this should ideally be automatically handled.
+
+    func_c = '''
+#include 
+
+double func_unchanged(double x) {
+    return %(unchanged)s;
+}
+double func_rewritten(double x) {
+    return %(rewritten)s;
+}
+''' % {"unchanged": ccode(unchanged.n(NUMBER_OF_DIGITS)),
+           "rewritten": ccode(rewritten.n(NUMBER_OF_DIGITS))}
+
+    func_pyx = '''
+#cython: language_level=3
+cdef extern double func_unchanged(double)
+cdef extern double func_rewritten(double)
+def py_unchanged(x):
+    return func_unchanged(x)
+def py_rewritten(x):
+    return func_rewritten(x)
+'''
+    with tempfile.TemporaryDirectory() as folder:
+        mod, info = compile_link_import_strings(
+            [('func.c', func_c), ('_func.pyx', func_pyx)],
+            build_dir=folder, compile_kwargs={"std": 'c99'}
+        )
+        err_rewritten = abs(mod.py_rewritten(1e-11) - ref)
+        err_unchanged = abs(mod.py_unchanged(1e-11) - ref)
+        assert 1e-27 < err_rewritten < 1e-25  # highly accurate.
+        assert 1e-19 < err_unchanged < 1e-16  # quite poor.
+
+    # Tolerances used above were determined as follows:
+    # >>> no_opt = unchanged.subs(x, xval.evalf()).evalf()
+    # >>> with_opt = rewritten.n(25).subs(x, 1e-11).evalf()
+    # >>> with_opt - ref, no_opt - ref
+    # (1.1536301877952077e-26, 1.6547074214222335e-18)
diff --git a/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_scipy_nodes.py b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_scipy_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0d1461037eec81ade0c99b18fbbf5a4517ce0b7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/codegen/tests/test_scipy_nodes.py
@@ -0,0 +1,44 @@
+from itertools import product
+from sympy.core.power import Pow
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.trigonometric import cos
+from sympy.core.numbers import pi
+from sympy.codegen.scipy_nodes import cosm1, powm1
+
+x, y, z = symbols('x y z')
+
+
+def test_cosm1():
+    cm1_xy = cosm1(x*y)
+    ref_xy = cos(x*y) - 1
+    for wrt, deriv_order in product([x, y, z], range(3)):
+        assert (
+            cm1_xy.diff(wrt, deriv_order) -
+            ref_xy.diff(wrt, deriv_order)
+        ).rewrite(cos).simplify() == 0
+
+    expr_minus2 = cosm1(pi)
+    assert expr_minus2.rewrite(cos) == -2
+    assert cosm1(3.14).simplify() == cosm1(3.14)  # cannot simplify with 3.14
+    assert cosm1(pi/2).simplify() == -1
+    assert (1/cos(x) - 1 + cosm1(x)/cos(x)).simplify() == 0
+
+
+def test_powm1():
+    cases = {
+            powm1(x, y): x**y - 1,
+            powm1(x*y, z): (x*y)**z - 1,
+            powm1(x, y*z): x**(y*z)-1,
+            powm1(x*y*z, x*y*z): (x*y*z)**(x*y*z)-1
+    }
+    for pm1_e, ref_e in cases.items():
+        for wrt, deriv_order in product([x, y, z], range(3)):
+            der = pm1_e.diff(wrt, deriv_order)
+            ref = ref_e.diff(wrt, deriv_order)
+            delta = (der - ref).rewrite(Pow)
+            assert delta.simplify() == 0
+
+    eulers_constant_m1 = powm1(x, 1/log(x))
+    assert eulers_constant_m1.rewrite(Pow) == exp(1) - 1
+    assert eulers_constant_m1.simplify() == exp(1) - 1
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__init__.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..220c27a42975555f8fe7770fcef0dd18475c89e1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__init__.py
@@ -0,0 +1,43 @@
+from sympy.combinatorics.permutations import Permutation, Cycle
+from sympy.combinatorics.prufer import Prufer
+from sympy.combinatorics.generators import cyclic, alternating, symmetric, dihedral
+from sympy.combinatorics.subsets import Subset
+from sympy.combinatorics.partitions import (Partition, IntegerPartition,
+    RGS_rank, RGS_unrank, RGS_enum)
+from sympy.combinatorics.polyhedron import (Polyhedron, tetrahedron, cube,
+    octahedron, dodecahedron, icosahedron)
+from sympy.combinatorics.perm_groups import PermutationGroup, Coset, SymmetricPermutationGroup
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.graycode import GrayCode
+from sympy.combinatorics.named_groups import (SymmetricGroup, DihedralGroup,
+    CyclicGroup, AlternatingGroup, AbelianGroup, RubikGroup)
+from sympy.combinatorics.pc_groups import PolycyclicGroup, Collector
+from sympy.combinatorics.free_groups import free_group
+
+__all__ = [
+    'Permutation', 'Cycle',
+
+    'Prufer',
+
+    'cyclic', 'alternating', 'symmetric', 'dihedral',
+
+    'Subset',
+
+    'Partition', 'IntegerPartition', 'RGS_rank', 'RGS_unrank', 'RGS_enum',
+
+    'Polyhedron', 'tetrahedron', 'cube', 'octahedron', 'dodecahedron',
+    'icosahedron',
+
+    'PermutationGroup', 'Coset', 'SymmetricPermutationGroup',
+
+    'DirectProduct',
+
+    'GrayCode',
+
+    'SymmetricGroup', 'DihedralGroup', 'CyclicGroup', 'AlternatingGroup',
+    'AbelianGroup', 'RubikGroup',
+
+    'PolycyclicGroup', 'Collector',
+
+    'free_group',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a23cd56ff8ed5f0f730651e9358a63b9b736216c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/coset_table.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/coset_table.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e88da29f661b1d6090f94d9630cdc2e4aab82cba
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/coset_table.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..158f7e44637505dbaddbfe05f19f8e7777a48727
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/fp_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/free_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/free_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d759ab3ea06aef6d0844201dc05d4b675d6b1d8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/free_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/galois.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/galois.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..006f0329faabb8761c2e2c20365e73564d2010a6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/galois.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/generators.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/generators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3bcb7ff57523008a89e23c110d626e0191728fe0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/generators.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b79d77d572078461ebedb4ba4ec0bc13d1e2c1f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/graycode.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_constructs.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_constructs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbf64f8a3fb103e10b75eeb9f53ce44269ae1946
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_constructs.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ec5650f523c4d95176b55c5714e1c76fd79adb5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/group_numbers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/homomorphisms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/homomorphisms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c52c7799323e4248916d0338e4b95f8db83a69f1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/homomorphisms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/named_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/named_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1edcc9c24398a5efa4841a9339bbd46d81108e6d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/named_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2b9b881077bc137ba452f0298969265a20105df2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/partitions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0d599457afaa2fefbf5eb3b2b84dfdf1844543d9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/pc_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a14930226fe45f7efb6489b1d909d4214ae372d7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/perm_groups.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1762ab2acca261f7cab7198af6230ed21d7e2bcf70c892624eea843d9258caf1
+size 202415
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..662d9f25bf9824f30aa43acbb71ddeb0ee09a44e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/permutations.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:844dba84d44f7d3ef82f7298561d105b7bbf099b010bb89b10346739e22070c9
+size 106816
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d048ca20ca86d1985e4b2eb3d89b77a20b27426a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/polyhedron.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/prufer.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/prufer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8dc85d02f1247b88d1a6f6793ab9c650152445f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/prufer.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c6031489f800c601e730d86043b25ce6d84c27b7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45aeab7c192e8ce4247c6f31af49a01f7cd2ef8f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/rewritingsystem_fsm.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/schur_number.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/schur_number.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2e0db0e8d24094d675c82cff44f51596e144922
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/schur_number.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/subsets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/subsets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..697b4f9192f879238b1cb29b9cb0a3169de59f4c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/subsets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f91c23885169ba26fd88d237a56df7b455fa48f6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/tensor_can.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d822c64c2a005123ffb8d31ee89e7231b54f2b9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/testutil.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..412d1807df078a7407294bc483ce71ac4d30a8aa
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/__pycache__/util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/coset_table.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/coset_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..0687aa34ec70e9062f65ff6413213848cf03e51b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/coset_table.py
@@ -0,0 +1,1259 @@
+from sympy.combinatorics.free_groups import free_group
+from sympy.printing.defaults import DefaultPrinting
+
+from itertools import chain, product
+from bisect import bisect_left
+
+
+###############################################################################
+#                           COSET TABLE                                       #
+###############################################################################
+
+class CosetTable(DefaultPrinting):
+    # coset_table: Mathematically a coset table
+    #               represented using a list of lists
+    # alpha: Mathematically a coset (precisely, a live coset)
+    #       represented by an integer between i with 1 <= i <= n
+    #       alpha in c
+    # x: Mathematically an element of "A" (set of generators and
+    #   their inverses), represented using "FpGroupElement"
+    # fp_grp: Finitely Presented Group with < X|R > as presentation.
+    # H: subgroup of fp_grp.
+    # NOTE: We start with H as being only a list of words in generators
+    #       of "fp_grp". Since `.subgroup` method has not been implemented.
+
+    r"""
+
+    Properties
+    ==========
+
+    [1] `0 \in \Omega` and `\tau(1) = \epsilon`
+    [2] `\alpha^x = \beta \Leftrightarrow \beta^{x^{-1}} = \alpha`
+    [3] If `\alpha^x = \beta`, then `H \tau(\alpha)x = H \tau(\beta)`
+    [4] `\forall \alpha \in \Omega, 1^{\tau(\alpha)} = \alpha`
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+
+    .. [2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+           Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+           "Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+    """
+    # default limit for the number of cosets allowed in a
+    # coset enumeration.
+    coset_table_max_limit = 4096000
+    # limit for the current instance
+    coset_table_limit = None
+    # maximum size of deduction stack above or equal to
+    # which it is emptied
+    max_stack_size = 100
+
+    def __init__(self, fp_grp, subgroup, max_cosets=None):
+        if not max_cosets:
+            max_cosets = CosetTable.coset_table_max_limit
+        self.fp_group = fp_grp
+        self.subgroup = subgroup
+        self.coset_table_limit = max_cosets
+        # "p" is setup independent of Omega and n
+        self.p = [0]
+        # a list of the form `[gen_1, gen_1^{-1}, ... , gen_k, gen_k^{-1}]`
+        self.A = list(chain.from_iterable((gen, gen**-1) \
+                for gen in self.fp_group.generators))
+        #P[alpha, x] Only defined when alpha^x is defined.
+        self.P = [[None]*len(self.A)]
+        # the mathematical coset table which is a list of lists
+        self.table = [[None]*len(self.A)]
+        self.A_dict = {x: self.A.index(x) for x in self.A}
+        self.A_dict_inv = {}
+        for x, index in self.A_dict.items():
+            if index % 2 == 0:
+                self.A_dict_inv[x] = self.A_dict[x] + 1
+            else:
+                self.A_dict_inv[x] = self.A_dict[x] - 1
+        # used in the coset-table based method of coset enumeration. Each of
+        # the element is called a "deduction" which is the form (alpha, x) whenever
+        # a value is assigned to alpha^x during a definition or "deduction process"
+        self.deduction_stack = []
+        # Attributes for modified methods.
+        H = self.subgroup
+        self._grp = free_group(', ' .join(["a_%d" % i for i in range(len(H))]))[0]
+        self.P = [[None]*len(self.A)]
+        self.p_p = {}
+
+    @property
+    def omega(self):
+        """Set of live cosets. """
+        return [coset for coset in range(len(self.p)) if self.p[coset] == coset]
+
+    def copy(self):
+        """
+        Return a shallow copy of Coset Table instance ``self``.
+
+        """
+        self_copy = self.__class__(self.fp_group, self.subgroup)
+        self_copy.table = [list(perm_rep) for perm_rep in self.table]
+        self_copy.p = list(self.p)
+        self_copy.deduction_stack = list(self.deduction_stack)
+        return self_copy
+
+    def __str__(self):
+        return "Coset Table on %s with %s as subgroup generators" \
+                % (self.fp_group, self.subgroup)
+
+    __repr__ = __str__
+
+    @property
+    def n(self):
+        """The number `n` represents the length of the sublist containing the
+        live cosets.
+
+        """
+        if not self.table:
+            return 0
+        return max(self.omega) + 1
+
+    # Pg. 152 [1]
+    def is_complete(self):
+        r"""
+        The coset table is called complete if it has no undefined entries
+        on the live cosets; that is, `\alpha^x` is defined for all
+        `\alpha \in \Omega` and `x \in A`.
+
+        """
+        return not any(None in self.table[coset] for coset in self.omega)
+
+    # Pg. 153 [1]
+    def define(self, alpha, x, modified=False):
+        r"""
+        This routine is used in the relator-based strategy of Todd-Coxeter
+        algorithm if some `\alpha^x` is undefined. We check whether there is
+        space available for defining a new coset. If there is enough space
+        then we remedy this by adjoining a new coset `\beta` to `\Omega`
+        (i.e to set of live cosets) and put that equal to `\alpha^x`, then
+        make an assignment satisfying Property[1]. If there is not enough space
+        then we halt the Coset Table creation. The maximum amount of space that
+        can be used by Coset Table can be manipulated using the class variable
+        ``CosetTable.coset_table_max_limit``.
+
+        See Also
+        ========
+
+        define_c
+
+        """
+        A = self.A
+        table = self.table
+        len_table = len(table)
+        if len_table >= self.coset_table_limit:
+            # abort the further generation of cosets
+            raise ValueError("the coset enumeration has defined more than "
+                    "%s cosets. Try with a greater value max number of cosets "
+                    % self.coset_table_limit)
+        table.append([None]*len(A))
+        self.P.append([None]*len(self.A))
+        # beta is the new coset generated
+        beta = len_table
+        self.p.append(beta)
+        table[alpha][self.A_dict[x]] = beta
+        table[beta][self.A_dict_inv[x]] = alpha
+        # P[alpha][x] = epsilon, P[beta][x**-1] = epsilon
+        if modified:
+            self.P[alpha][self.A_dict[x]] = self._grp.identity
+            self.P[beta][self.A_dict_inv[x]] = self._grp.identity
+            self.p_p[beta] = self._grp.identity
+
+    def define_c(self, alpha, x):
+        r"""
+        A variation of ``define`` routine, described on Pg. 165 [1], used in
+        the coset table-based strategy of Todd-Coxeter algorithm. It differs
+        from ``define`` routine in that for each definition it also adds the
+        tuple `(\alpha, x)` to the deduction stack.
+
+        See Also
+        ========
+
+        define
+
+        """
+        A = self.A
+        table = self.table
+        len_table = len(table)
+        if len_table >= self.coset_table_limit:
+            # abort the further generation of cosets
+            raise ValueError("the coset enumeration has defined more than "
+                    "%s cosets. Try with a greater value max number of cosets "
+                    % self.coset_table_limit)
+        table.append([None]*len(A))
+        # beta is the new coset generated
+        beta = len_table
+        self.p.append(beta)
+        table[alpha][self.A_dict[x]] = beta
+        table[beta][self.A_dict_inv[x]] = alpha
+        # append to deduction stack
+        self.deduction_stack.append((alpha, x))
+
+    def scan_c(self, alpha, word):
+        """
+        A variation of ``scan`` routine, described on pg. 165 of [1], which
+        puts at tuple, whenever a deduction occurs, to deduction stack.
+
+        See Also
+        ========
+
+        scan, scan_check, scan_and_fill, scan_and_fill_c
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        # list of union of generators and their inverses
+        while i <= j and table[f][A_dict[word[i]]] is not None:
+            f = table[f][A_dict[word[i]]]
+            i += 1
+        if i > j:
+            if f != b:
+                self.coincidence_c(f, b)
+            return
+        while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+            b = table[b][A_dict_inv[word[j]]]
+            j -= 1
+        if j < i:
+            # we have an incorrect completed scan with coincidence f ~ b
+            # run the "coincidence" routine
+            self.coincidence_c(f, b)
+        elif j == i:
+            # deduction process
+            table[f][A_dict[word[i]]] = b
+            table[b][A_dict_inv[word[i]]] = f
+            self.deduction_stack.append((f, word[i]))
+        # otherwise scan is incomplete and yields no information
+
+    # alpha, beta coincide, i.e. alpha, beta represent the pair of cosets where
+    # coincidence occurs
+    def coincidence_c(self, alpha, beta):
+        """
+        A variation of ``coincidence`` routine used in the coset-table based
+        method of coset enumeration. The only difference being on addition of
+        a new coset in coset table(i.e new coset introduction), then it is
+        appended to ``deduction_stack``.
+
+        See Also
+        ========
+
+        coincidence
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        # behaves as a queue
+        q = []
+        self.merge(alpha, beta, q)
+        while len(q) > 0:
+            gamma = q.pop(0)
+            for x in A_dict:
+                delta = table[gamma][A_dict[x]]
+                if delta is not None:
+                    table[delta][A_dict_inv[x]] = None
+                    # only line of difference from ``coincidence`` routine
+                    self.deduction_stack.append((delta, x**-1))
+                    mu = self.rep(gamma)
+                    nu = self.rep(delta)
+                    if table[mu][A_dict[x]] is not None:
+                        self.merge(nu, table[mu][A_dict[x]], q)
+                    elif table[nu][A_dict_inv[x]] is not None:
+                        self.merge(mu, table[nu][A_dict_inv[x]], q)
+                    else:
+                        table[mu][A_dict[x]] = nu
+                        table[nu][A_dict_inv[x]] = mu
+
+    def scan(self, alpha, word, y=None, fill=False, modified=False):
+        r"""
+        ``scan`` performs a scanning process on the input ``word``.
+        It first locates the largest prefix ``s`` of ``word`` for which
+        `\alpha^s` is defined (i.e is not ``None``), ``s`` may be empty. Let
+        ``word=sv``, let ``t`` be the longest suffix of ``v`` for which
+        `\alpha^{t^{-1}}` is defined, and let ``v=ut``. Then three
+        possibilities are there:
+
+        1. If ``t=v``, then we say that the scan completes, and if, in addition
+        `\alpha^s = \alpha^{t^{-1}}`, then we say that the scan completes
+        correctly.
+
+        2. It can also happen that scan does not complete, but `|u|=1`; that
+        is, the word ``u`` consists of a single generator `x \in A`. In that
+        case, if `\alpha^s = \beta` and `\alpha^{t^{-1}} = \gamma`, then we can
+        set `\beta^x = \gamma` and `\gamma^{x^{-1}} = \beta`. These assignments
+        are known as deductions and enable the scan to complete correctly.
+
+        3. See ``coicidence`` routine for explanation of third condition.
+
+        Notes
+        =====
+
+        The code for the procedure of scanning `\alpha \in \Omega`
+        under `w \in A*` is defined on pg. 155 [1]
+
+        See Also
+        ========
+
+        scan_c, scan_check, scan_and_fill, scan_and_fill_c
+
+        Scan and Fill
+        =============
+
+        Performed when the default argument fill=True.
+
+        Modified Scan
+        =============
+
+        Performed when the default argument modified=True
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        b_p = y
+        if modified:
+            f_p = self._grp.identity
+        flag = 0
+        while fill or flag == 0:
+            flag = 1
+            while i <= j and table[f][A_dict[word[i]]] is not None:
+                if modified:
+                    f_p = f_p*self.P[f][A_dict[word[i]]]
+                f = table[f][A_dict[word[i]]]
+                i += 1
+            if i > j:
+                if f != b:
+                    if modified:
+                        self.modified_coincidence(f, b, f_p**-1*y)
+                    else:
+                        self.coincidence(f, b)
+                return
+            while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+                if modified:
+                    b_p = b_p*self.P[b][self.A_dict_inv[word[j]]]
+                b = table[b][A_dict_inv[word[j]]]
+                j -= 1
+            if j < i:
+                # we have an incorrect completed scan with coincidence f ~ b
+                # run the "coincidence" routine
+                if modified:
+                    self.modified_coincidence(f, b, f_p**-1*b_p)
+                else:
+                    self.coincidence(f, b)
+            elif j == i:
+                # deduction process
+                table[f][A_dict[word[i]]] = b
+                table[b][A_dict_inv[word[i]]] = f
+                if modified:
+                    self.P[f][self.A_dict[word[i]]] = f_p**-1*b_p
+                    self.P[b][self.A_dict_inv[word[i]]] = b_p**-1*f_p
+                return
+            elif fill:
+                self.define(f, word[i], modified=modified)
+            # otherwise scan is incomplete and yields no information
+
+    # used in the low-index subgroups algorithm
+    def scan_check(self, alpha, word):
+        r"""
+        Another version of ``scan`` routine, described on, it checks whether
+        `\alpha` scans correctly under `word`, it is a straightforward
+        modification of ``scan``. ``scan_check`` returns ``False`` (rather than
+        calling ``coincidence``) if the scan completes incorrectly; otherwise
+        it returns ``True``.
+
+        See Also
+        ========
+
+        scan, scan_c, scan_and_fill, scan_and_fill_c
+
+        """
+        # alpha is an integer representing a "coset"
+        # since scanning can be in two cases
+        # 1. for alpha=0 and w in Y (i.e generating set of H)
+        # 2. alpha in Omega (set of live cosets), w in R (relators)
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        f = alpha
+        i = 0
+        r = len(word)
+        b = alpha
+        j = r - 1
+        while i <= j and table[f][A_dict[word[i]]] is not None:
+            f = table[f][A_dict[word[i]]]
+            i += 1
+        if i > j:
+            return f == b
+        while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+            b = table[b][A_dict_inv[word[j]]]
+            j -= 1
+        if j < i:
+            # we have an incorrect completed scan with coincidence f ~ b
+            # return False, instead of calling coincidence routine
+            return False
+        elif j == i:
+            # deduction process
+            table[f][A_dict[word[i]]] = b
+            table[b][A_dict_inv[word[i]]] = f
+        return True
+
+    def merge(self, k, lamda, q, w=None, modified=False):
+        """
+        Merge two classes with representatives ``k`` and ``lamda``, described
+        on Pg. 157 [1] (for pseudocode), start by putting ``p[k] = lamda``.
+        It is more efficient to choose the new representative from the larger
+        of the two classes being merged, i.e larger among ``k`` and ``lamda``.
+        procedure ``merge`` performs the merging operation, adds the deleted
+        class representative to the queue ``q``.
+
+        Parameters
+        ==========
+
+        'k', 'lamda' being the two class representatives to be merged.
+
+        Notes
+        =====
+
+        Pg. 86-87 [1] contains a description of this method.
+
+        See Also
+        ========
+
+        coincidence, rep
+
+        """
+        p = self.p
+        rep = self.rep
+        phi = rep(k, modified=modified)
+        psi = rep(lamda, modified=modified)
+        if phi != psi:
+            mu = min(phi, psi)
+            v = max(phi, psi)
+            p[v] = mu
+            if modified:
+                if v == phi:
+                    self.p_p[phi] = self.p_p[k]**-1*w*self.p_p[lamda]
+                else:
+                    self.p_p[psi] = self.p_p[lamda]**-1*w**-1*self.p_p[k]
+            q.append(v)
+
+    def rep(self, k, modified=False):
+        r"""
+        Parameters
+        ==========
+
+        `k \in [0 \ldots n-1]`, as for ``self`` only array ``p`` is used
+
+        Returns
+        =======
+
+        Representative of the class containing ``k``.
+
+        Returns the representative of `\sim` class containing ``k``, it also
+        makes some modification to array ``p`` of ``self`` to ease further
+        computations, described on Pg. 157 [1].
+
+        The information on classes under `\sim` is stored in array `p` of
+        ``self`` argument, which will always satisfy the property:
+
+        `p[\alpha] \sim \alpha` and `p[\alpha]=\alpha \iff \alpha=rep(\alpha)`
+        `\forall \in [0 \ldots n-1]`.
+
+        So, for `\alpha \in [0 \ldots n-1]`, we find `rep(self, \alpha)` by
+        continually replacing `\alpha` by `p[\alpha]` until it becomes
+        constant (i.e satisfies `p[\alpha] = \alpha`):w
+
+        To increase the efficiency of later ``rep`` calculations, whenever we
+        find `rep(self, \alpha)=\beta`, we set
+        `p[\gamma] = \beta \forall \gamma \in p-chain` from `\alpha` to `\beta`
+
+        Notes
+        =====
+
+        ``rep`` routine is also described on Pg. 85-87 [1] in Atkinson's
+        algorithm, this results from the fact that ``coincidence`` routine
+        introduces functionality similar to that introduced by the
+        ``minimal_block`` routine on Pg. 85-87 [1].
+
+        See Also
+        ========
+
+        coincidence, merge
+
+        """
+        p = self.p
+        lamda = k
+        rho = p[lamda]
+        if modified:
+            s = p[:]
+        while rho != lamda:
+            if modified:
+                s[rho] = lamda
+            lamda = rho
+            rho = p[lamda]
+        if modified:
+            rho = s[lamda]
+            while rho != k:
+                mu = rho
+                rho = s[mu]
+                p[rho] = lamda
+                self.p_p[rho] = self.p_p[rho]*self.p_p[mu]
+        else:
+            mu = k
+            rho = p[mu]
+            while rho != lamda:
+                p[mu] = lamda
+                mu = rho
+                rho = p[mu]
+        return lamda
+
+    # alpha, beta coincide, i.e. alpha, beta represent the pair of cosets
+    # where coincidence occurs
+    def coincidence(self, alpha, beta, w=None, modified=False):
+        r"""
+        The third situation described in ``scan`` routine is handled by this
+        routine, described on Pg. 156-161 [1].
+
+        The unfortunate situation when the scan completes but not correctly,
+        then ``coincidence`` routine is run. i.e when for some `i` with
+        `1 \le i \le r+1`, we have `w=st` with `s = x_1 x_2 \dots x_{i-1}`,
+        `t = x_i x_{i+1} \dots x_r`, and `\beta = \alpha^s` and
+        `\gamma = \alpha^{t-1}` are defined but unequal. This means that
+        `\beta` and `\gamma` represent the same coset of `H` in `G`. Described
+        on Pg. 156 [1]. ``rep``
+
+        See Also
+        ========
+
+        scan
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        # behaves as a queue
+        q = []
+        if modified:
+            self.modified_merge(alpha, beta, w, q)
+        else:
+            self.merge(alpha, beta, q)
+        while len(q) > 0:
+            gamma = q.pop(0)
+            for x in A_dict:
+                delta = table[gamma][A_dict[x]]
+                if delta is not None:
+                    table[delta][A_dict_inv[x]] = None
+                    mu = self.rep(gamma, modified=modified)
+                    nu = self.rep(delta, modified=modified)
+                    if table[mu][A_dict[x]] is not None:
+                        if modified:
+                            v = self.p_p[delta]**-1*self.P[gamma][self.A_dict[x]]**-1
+                            v = v*self.p_p[gamma]*self.P[mu][self.A_dict[x]]
+                            self.modified_merge(nu, table[mu][self.A_dict[x]], v, q)
+                        else:
+                            self.merge(nu, table[mu][A_dict[x]], q)
+                    elif table[nu][A_dict_inv[x]] is not None:
+                        if modified:
+                            v = self.p_p[gamma]**-1*self.P[gamma][self.A_dict[x]]
+                            v = v*self.p_p[delta]*self.P[mu][self.A_dict_inv[x]]
+                            self.modified_merge(mu, table[nu][self.A_dict_inv[x]], v, q)
+                        else:
+                            self.merge(mu, table[nu][A_dict_inv[x]], q)
+                    else:
+                        table[mu][A_dict[x]] = nu
+                        table[nu][A_dict_inv[x]] = mu
+                        if modified:
+                            v = self.p_p[gamma]**-1*self.P[gamma][self.A_dict[x]]*self.p_p[delta]
+                            self.P[mu][self.A_dict[x]] = v
+                            self.P[nu][self.A_dict_inv[x]] = v**-1
+
+    # method used in the HLT strategy
+    def scan_and_fill(self, alpha, word):
+        """
+        A modified version of ``scan`` routine used in the relator-based
+        method of coset enumeration, described on pg. 162-163 [1], which
+        follows the idea that whenever the procedure is called and the scan
+        is incomplete then it makes new definitions to enable the scan to
+        complete; i.e it fills in the gaps in the scan of the relator or
+        subgroup generator.
+
+        """
+        self.scan(alpha, word, fill=True)
+
+    def scan_and_fill_c(self, alpha, word):
+        """
+        A modified version of ``scan`` routine, described on Pg. 165 second
+        para. [1], with modification similar to that of ``scan_anf_fill`` the
+        only difference being it calls the coincidence procedure used in the
+        coset-table based method i.e. the routine ``coincidence_c`` is used.
+
+        See Also
+        ========
+
+        scan, scan_and_fill
+
+        """
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        r = len(word)
+        f = alpha
+        i = 0
+        b = alpha
+        j = r - 1
+        # loop until it has filled the alpha row in the table.
+        while True:
+            # do the forward scanning
+            while i <= j and table[f][A_dict[word[i]]] is not None:
+                f = table[f][A_dict[word[i]]]
+                i += 1
+            if i > j:
+                if f != b:
+                    self.coincidence_c(f, b)
+                return
+            # forward scan was incomplete, scan backwards
+            while j >= i and table[b][A_dict_inv[word[j]]] is not None:
+                b = table[b][A_dict_inv[word[j]]]
+                j -= 1
+            if j < i:
+                self.coincidence_c(f, b)
+            elif j == i:
+                table[f][A_dict[word[i]]] = b
+                table[b][A_dict_inv[word[i]]] = f
+                self.deduction_stack.append((f, word[i]))
+            else:
+                self.define_c(f, word[i])
+
+    # method used in the HLT strategy
+    def look_ahead(self):
+        """
+        When combined with the HLT method this is known as HLT+Lookahead
+        method of coset enumeration, described on pg. 164 [1]. Whenever
+        ``define`` aborts due to lack of space available this procedure is
+        executed. This routine helps in recovering space resulting from
+        "coincidence" of cosets.
+
+        """
+        R = self.fp_group.relators
+        p = self.p
+        # complete scan all relators under all cosets(obviously live)
+        # without making new definitions
+        for beta in self.omega:
+            for w in R:
+                self.scan(beta, w)
+                if p[beta] < beta:
+                    break
+
+    # Pg. 166
+    def process_deductions(self, R_c_x, R_c_x_inv):
+        """
+        Processes the deductions that have been pushed onto ``deduction_stack``,
+        described on Pg. 166 [1] and is used in coset-table based enumeration.
+
+        See Also
+        ========
+
+        deduction_stack
+
+        """
+        p = self.p
+        table = self.table
+        while len(self.deduction_stack) > 0:
+            if len(self.deduction_stack) >= CosetTable.max_stack_size:
+                self.look_ahead()
+                del self.deduction_stack[:]
+                continue
+            else:
+                alpha, x = self.deduction_stack.pop()
+                if p[alpha] == alpha:
+                    for w in R_c_x:
+                        self.scan_c(alpha, w)
+                        if p[alpha] < alpha:
+                            break
+            beta = table[alpha][self.A_dict[x]]
+            if beta is not None and p[beta] == beta:
+                for w in R_c_x_inv:
+                    self.scan_c(beta, w)
+                    if p[beta] < beta:
+                        break
+
+    def process_deductions_check(self, R_c_x, R_c_x_inv):
+        """
+        A variation of ``process_deductions``, this calls ``scan_check``
+        wherever ``process_deductions`` calls ``scan``, described on Pg. [1].
+
+        See Also
+        ========
+
+        process_deductions
+
+        """
+        table = self.table
+        while len(self.deduction_stack) > 0:
+            alpha, x = self.deduction_stack.pop()
+            if not all(self.scan_check(alpha, w) for w in R_c_x):
+                return False
+            beta = table[alpha][self.A_dict[x]]
+            if beta is not None:
+                if not all(self.scan_check(beta, w) for w in R_c_x_inv):
+                    return False
+        return True
+
+    def switch(self, beta, gamma):
+        r"""Switch the elements `\beta, \gamma \in \Omega` of ``self``, used
+        by the ``standardize`` procedure, described on Pg. 167 [1].
+
+        See Also
+        ========
+
+        standardize
+
+        """
+        A = self.A
+        A_dict = self.A_dict
+        table = self.table
+        for x in A:
+            z = table[gamma][A_dict[x]]
+            table[gamma][A_dict[x]] = table[beta][A_dict[x]]
+            table[beta][A_dict[x]] = z
+            for alpha in range(len(self.p)):
+                if self.p[alpha] == alpha:
+                    if table[alpha][A_dict[x]] == beta:
+                        table[alpha][A_dict[x]] = gamma
+                    elif table[alpha][A_dict[x]] == gamma:
+                        table[alpha][A_dict[x]] = beta
+
+    def standardize(self):
+        r"""
+        A coset table is standardized if when running through the cosets and
+        within each coset through the generator images (ignoring generator
+        inverses), the cosets appear in order of the integers
+        `0, 1, \dots, n`. "Standardize" reorders the elements of `\Omega`
+        such that, if we scan the coset table first by elements of `\Omega`
+        and then by elements of A, then the cosets occur in ascending order.
+        ``standardize()`` is used at the end of an enumeration to permute the
+        cosets so that they occur in some sort of standard order.
+
+        Notes
+        =====
+
+        procedure is described on pg. 167-168 [1], it also makes use of the
+        ``switch`` routine to replace by smaller integer value.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+        >>> F, x, y = free_group("x, y")
+
+        # Example 5.3 from [1]
+        >>> f = FpGroup(F, [x**2*y**2, x**3*y**5])
+        >>> C = coset_enumeration_r(f, [])
+        >>> C.compress()
+        >>> C.table
+        [[1, 3, 1, 3], [2, 0, 2, 0], [3, 1, 3, 1], [0, 2, 0, 2]]
+        >>> C.standardize()
+        >>> C.table
+        [[1, 2, 1, 2], [3, 0, 3, 0], [0, 3, 0, 3], [2, 1, 2, 1]]
+
+        """
+        A = self.A
+        A_dict = self.A_dict
+        gamma = 1
+        for alpha, x in product(range(self.n), A):
+            beta = self.table[alpha][A_dict[x]]
+            if beta >= gamma:
+                if beta > gamma:
+                    self.switch(gamma, beta)
+                gamma += 1
+                if gamma == self.n:
+                    return
+
+    # Compression of a Coset Table
+    def compress(self):
+        """Removes the non-live cosets from the coset table, described on
+        pg. 167 [1].
+
+        """
+        gamma = -1
+        A = self.A
+        A_dict = self.A_dict
+        A_dict_inv = self.A_dict_inv
+        table = self.table
+        chi = tuple([i for i in range(len(self.p)) if self.p[i] != i])
+        for alpha in self.omega:
+            gamma += 1
+            if gamma != alpha:
+                # replace alpha by gamma in coset table
+                for x in A:
+                    beta = table[alpha][A_dict[x]]
+                    table[gamma][A_dict[x]] = beta
+                    # XXX: The line below uses == rather than = which means
+                    # that it has no effect. It is not clear though if it is
+                    # correct simply to delete the line or to change it to
+                    # use =. Changing it causes some tests to fail.
+                    #
+                    # https://github.com/sympy/sympy/issues/27633
+                    table[beta][A_dict_inv[x]] == gamma # noqa: B015
+        # all the cosets in the table are live cosets
+        self.p = list(range(gamma + 1))
+        # delete the useless columns
+        del table[len(self.p):]
+        # re-define values
+        for row in table:
+            for j in range(len(self.A)):
+                row[j] -= bisect_left(chi, row[j])
+
+    def conjugates(self, R):
+        R_c = list(chain.from_iterable((rel.cyclic_conjugates(), \
+                (rel**-1).cyclic_conjugates()) for rel in R))
+        R_set = set()
+        for conjugate in R_c:
+            R_set = R_set.union(conjugate)
+        R_c_list = []
+        for x in self.A:
+            r = {word for word in R_set if word[0] == x}
+            R_c_list.append(r)
+            R_set.difference_update(r)
+        return R_c_list
+
+    def coset_representative(self, coset):
+        '''
+        Compute the coset representative of a given coset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+        >>> C = coset_enumeration_r(f, [x])
+        >>> C.compress()
+        >>> C.table
+        [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+        >>> C.coset_representative(0)
+        
+        >>> C.coset_representative(1)
+        y
+        >>> C.coset_representative(2)
+        y**-1
+
+        '''
+        for x in self.A:
+            gamma = self.table[coset][self.A_dict[x]]
+            if coset == 0:
+                return self.fp_group.identity
+            if gamma < coset:
+                return self.coset_representative(gamma)*x**-1
+
+    ##############################
+    #      Modified Methods      #
+    ##############################
+
+    def modified_define(self, alpha, x):
+        r"""
+        Define a function p_p from from [1..n] to A* as
+        an additional component of the modified coset table.
+
+        Parameters
+        ==========
+
+        \alpha \in \Omega
+        x \in A*
+
+        See Also
+        ========
+
+        define
+
+        """
+        self.define(alpha, x, modified=True)
+
+    def modified_scan(self, alpha, w, y, fill=False):
+        r"""
+        Parameters
+        ==========
+        \alpha \in \Omega
+        w \in A*
+        y \in (YUY^-1)
+        fill -- `modified_scan_and_fill` when set to True.
+
+        See Also
+        ========
+
+        scan
+        """
+        self.scan(alpha, w, y=y, fill=fill, modified=True)
+
+    def modified_scan_and_fill(self, alpha, w, y):
+        self.modified_scan(alpha, w, y, fill=True)
+
+    def modified_merge(self, k, lamda, w, q):
+        r"""
+        Parameters
+        ==========
+
+        'k', 'lamda' -- the two class representatives to be merged.
+        q -- queue of length l of elements to be deleted from `\Omega` *.
+        w -- Word in (YUY^-1)
+
+        See Also
+        ========
+
+        merge
+        """
+        self.merge(k, lamda, q, w=w, modified=True)
+
+    def modified_rep(self, k):
+        r"""
+        Parameters
+        ==========
+
+        `k \in [0 \ldots n-1]`
+
+        See Also
+        ========
+
+        rep
+        """
+        self.rep(k, modified=True)
+
+    def modified_coincidence(self, alpha, beta, w):
+        r"""
+        Parameters
+        ==========
+
+        A coincident pair `\alpha, \beta \in \Omega, w \in Y \cup Y^{-1}`
+
+        See Also
+        ========
+
+        coincidence
+
+        """
+        self.coincidence(alpha, beta, w=w, modified=True)
+
+###############################################################################
+#                           COSET ENUMERATION                                 #
+###############################################################################
+
+# relator-based method
+def coset_enumeration_r(fp_grp, Y, max_cosets=None, draft=None,
+                                    incomplete=False, modified=False):
+    """
+    This is easier of the two implemented methods of coset enumeration.
+    and is often called the HLT method, after Hazelgrove, Leech, Trotter
+    The idea is that we make use of ``scan_and_fill`` makes new definitions
+    whenever the scan is incomplete to enable the scan to complete; this way
+    we fill in the gaps in the scan of the relator or subgroup generator,
+    that's why the name relator-based method.
+
+    An instance of `CosetTable` for `fp_grp` can be passed as the keyword
+    argument `draft` in which case the coset enumeration will start with
+    that instance and attempt to complete it.
+
+    When `incomplete` is `True` and the function is unable to complete for
+    some reason, the partially complete table will be returned.
+
+    # TODO: complete the docstring
+
+    See Also
+    ========
+
+    scan_and_fill,
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r
+    >>> F, x, y = free_group("x, y")
+
+    # Example 5.1 from [1]
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = coset_enumeration_r(f, [x])
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 1, 2]
+    [1, 1, 2, 0]
+    [2, 2, 0, 1]
+    >>> C.p
+    [0, 1, 2, 1, 1]
+
+    # Example from exercises Q2 [1]
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> C = coset_enumeration_r(f, [])
+    >>> C.compress(); C.standardize()
+    >>> C.table
+    [[1, 2, 3, 4],
+    [5, 0, 6, 7],
+    [0, 5, 7, 6],
+    [7, 6, 5, 0],
+    [6, 7, 0, 5],
+    [2, 1, 4, 3],
+    [3, 4, 2, 1],
+    [4, 3, 1, 2]]
+
+    # Example 5.2
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**3])
+    >>> Y = [x*y]
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [1, 1, 2, 1]
+    [0, 0, 0, 2]
+    [3, 3, 1, 0]
+    [2, 2, 3, 3]
+
+    # Example 5.3
+    >>> f = FpGroup(F, [x**2*y**2, x**3*y**5])
+    >>> Y = []
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [1, 3, 1, 3]
+    [2, 0, 2, 0]
+    [3, 1, 3, 1]
+    [0, 2, 0, 2]
+
+    # Example 5.4
+    >>> F, a, b, c, d, e = free_group("a, b, c, d, e")
+    >>> f = FpGroup(F, [a*b*c**-1, b*c*d**-1, c*d*e**-1, d*e*a**-1, e*a*b**-1])
+    >>> Y = [a]
+    >>> C = coset_enumeration_r(f, Y)
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+    # example of "compress" method
+    >>> C.compress()
+    >>> C.table
+    [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
+
+    # Exercises Pg. 161, Q2.
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> Y = []
+    >>> C = coset_enumeration_r(f, Y)
+    >>> C.compress()
+    >>> C.standardize()
+    >>> C.table
+    [[1, 2, 3, 4],
+    [5, 0, 6, 7],
+    [0, 5, 7, 6],
+    [7, 6, 5, 0],
+    [6, 7, 0, 5],
+    [2, 1, 4, 3],
+    [3, 4, 2, 1],
+    [4, 3, 1, 2]]
+
+    # John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+    # Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490
+    # from 1973chwd.pdf
+    # Table 1. Ex. 1
+    >>> F, r, s, t = free_group("r, s, t")
+    >>> E1 = FpGroup(F, [t**-1*r*t*r**-2, r**-1*s*r*s**-2, s**-1*t*s*t**-2])
+    >>> C = coset_enumeration_r(E1, [r])
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         print(C.table[i])
+    [0, 0, 0, 0, 0, 0]
+
+    Ex. 2
+    >>> F, a, b = free_group("a, b")
+    >>> Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5])
+    >>> C = coset_enumeration_r(Cox, [a])
+    >>> index = 0
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         index += 1
+    >>> index
+    500
+
+    # Ex. 3
+    >>> F, a, b = free_group("a, b")
+    >>> B_2_4 = FpGroup(F, [a**4, b**4, (a*b)**4, (a**-1*b)**4, (a**2*b)**4, \
+            (a*b**2)**4, (a**2*b**2)**4, (a**-1*b*a*b)**4, (a*b**-1*a*b)**4])
+    >>> C = coset_enumeration_r(B_2_4, [a])
+    >>> index = 0
+    >>> for i in range(len(C.p)):
+    ...     if C.p[i] == i:
+    ...         index += 1
+    >>> index
+    1024
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of computational group theory"
+
+    """
+    # 1. Initialize a coset table C for < X|R >
+    C = CosetTable(fp_grp, Y, max_cosets=max_cosets)
+    # Define coset table methods.
+    if modified:
+        _scan_and_fill = C.modified_scan_and_fill
+        _define = C.modified_define
+    else:
+        _scan_and_fill = C.scan_and_fill
+        _define = C.define
+    if draft:
+        C.table = draft.table[:]
+        C.p = draft.p[:]
+    R = fp_grp.relators
+    A_dict = C.A_dict
+    p = C.p
+    for i in range(len(Y)):
+        if modified:
+            _scan_and_fill(0, Y[i], C._grp.generators[i])
+        else:
+            _scan_and_fill(0, Y[i])
+    alpha = 0
+    while alpha < C.n:
+        if p[alpha] == alpha:
+            try:
+                for w in R:
+                    if modified:
+                        _scan_and_fill(alpha, w, C._grp.identity)
+                    else:
+                        _scan_and_fill(alpha, w)
+                    # if alpha was eliminated during the scan then break
+                    if p[alpha] < alpha:
+                        break
+                if p[alpha] == alpha:
+                    for x in A_dict:
+                        if C.table[alpha][A_dict[x]] is None:
+                            _define(alpha, x)
+            except ValueError as e:
+                if incomplete:
+                    return C
+                raise e
+        alpha += 1
+    return C
+
+def modified_coset_enumeration_r(fp_grp, Y, max_cosets=None, draft=None,
+                                    incomplete=False):
+    r"""
+    Introduce a new set of symbols y \in Y that correspond to the
+    generators of the subgroup. Store the elements of Y as a
+    word P[\alpha, x] and compute the coset table similar to that of
+    the regular coset enumeration methods.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup
+    >>> from sympy.combinatorics.coset_table import modified_coset_enumeration_r
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = modified_coset_enumeration_r(f, [x])
+    >>> C.table
+    [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1], [None, 1, None, None], [1, 3, None, None]]
+
+    See Also
+    ========
+
+    coset_enumertation_r
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.,
+           "Handbook of Computational Group Theory",
+           Section 5.3.2
+    """
+    return coset_enumeration_r(fp_grp, Y, max_cosets=max_cosets, draft=draft,
+                             incomplete=incomplete, modified=True)
+
+# Pg. 166
+# coset-table based method
+def coset_enumeration_c(fp_grp, Y, max_cosets=None, draft=None,
+                                                incomplete=False):
+    """
+    >>> from sympy.combinatorics.free_groups import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_c
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    >>> C = coset_enumeration_c(f, [x])
+    >>> C.table
+    [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+
+    """
+    # Initialize a coset table C for < X|R >
+    X = fp_grp.generators
+    R = fp_grp.relators
+    C = CosetTable(fp_grp, Y, max_cosets=max_cosets)
+    if draft:
+        C.table = draft.table[:]
+        C.p = draft.p[:]
+        C.deduction_stack = draft.deduction_stack
+        for alpha, x in product(range(len(C.table)), X):
+            if C.table[alpha][C.A_dict[x]] is not None:
+                C.deduction_stack.append((alpha, x))
+    A = C.A
+    # replace all the elements by cyclic reductions
+    R_cyc_red = [rel.identity_cyclic_reduction() for rel in R]
+    R_c = list(chain.from_iterable((rel.cyclic_conjugates(), (rel**-1).cyclic_conjugates()) \
+            for rel in R_cyc_red))
+    R_set = set()
+    for conjugate in R_c:
+        R_set = R_set.union(conjugate)
+    # a list of subsets of R_c whose words start with "x".
+    R_c_list = []
+    for x in C.A:
+        r = {word for word in R_set if word[0] == x}
+        R_c_list.append(r)
+        R_set.difference_update(r)
+    for w in Y:
+        C.scan_and_fill_c(0, w)
+    for x in A:
+        C.process_deductions(R_c_list[C.A_dict[x]], R_c_list[C.A_dict_inv[x]])
+    alpha = 0
+    while alpha < len(C.table):
+        if C.p[alpha] == alpha:
+            try:
+                for x in C.A:
+                    if C.p[alpha] != alpha:
+                        break
+                    if C.table[alpha][C.A_dict[x]] is None:
+                        C.define_c(alpha, x)
+                        C.process_deductions(R_c_list[C.A_dict[x]], R_c_list[C.A_dict_inv[x]])
+            except ValueError as e:
+                if incomplete:
+                    return C
+                raise e
+        alpha += 1
+    return C
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/fp_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/fp_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..95530ccd44f025eca5f029c6ba60d3727cbcb29d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/fp_groups.py
@@ -0,0 +1,1352 @@
+"""Finitely Presented Groups and its algorithms. """
+
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.combinatorics.free_groups import (FreeGroup, FreeGroupElement,
+                                                free_group)
+from sympy.combinatorics.rewritingsystem import RewritingSystem
+from sympy.combinatorics.coset_table import (CosetTable,
+                                             coset_enumeration_r,
+                                             coset_enumeration_c)
+from sympy.combinatorics import PermutationGroup
+from sympy.matrices.normalforms import invariant_factors
+from sympy.matrices import Matrix
+from sympy.polys.polytools import gcd
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public
+from sympy.utilities.magic import pollute
+
+from itertools import product
+
+
+@public
+def fp_group(fr_grp, relators=()):
+    _fp_group = FpGroup(fr_grp, relators)
+    return (_fp_group,) + tuple(_fp_group._generators)
+
+@public
+def xfp_group(fr_grp, relators=()):
+    _fp_group = FpGroup(fr_grp, relators)
+    return (_fp_group, _fp_group._generators)
+
+# Does not work. Both symbols and pollute are undefined. Never tested.
+@public
+def vfp_group(fr_grpm, relators):
+    _fp_group = FpGroup(symbols, relators)
+    pollute([sym.name for sym in _fp_group.symbols], _fp_group.generators)
+    return _fp_group
+
+
+def _parse_relators(rels):
+    """Parse the passed relators."""
+    return rels
+
+
+###############################################################################
+#                           FINITELY PRESENTED GROUPS                         #
+###############################################################################
+
+
+class FpGroup(DefaultPrinting):
+    """
+    The FpGroup would take a FreeGroup and a list/tuple of relators, the
+    relators would be specified in such a way that each of them be equal to the
+    identity of the provided free group.
+
+    """
+    is_group = True
+    is_FpGroup = True
+    is_PermutationGroup = False
+
+    def __init__(self, fr_grp, relators):
+        relators = _parse_relators(relators)
+        self.free_group = fr_grp
+        self.relators = relators
+        self.generators = self._generators()
+        self.dtype = type("FpGroupElement", (FpGroupElement,), {"group": self})
+
+        # CosetTable instance on identity subgroup
+        self._coset_table = None
+        # returns whether coset table on identity subgroup
+        # has been standardized
+        self._is_standardized = False
+
+        self._order = None
+        self._center = None
+
+        self._rewriting_system = RewritingSystem(self)
+        self._perm_isomorphism = None
+        return
+
+    def _generators(self):
+        return self.free_group.generators
+
+    def make_confluent(self):
+        '''
+        Try to make the group's rewriting system confluent
+
+        '''
+        self._rewriting_system.make_confluent()
+        return
+
+    def reduce(self, word):
+        '''
+        Return the reduced form of `word` in `self` according to the group's
+        rewriting system. If it's confluent, the reduced form is the unique normal
+        form of the word in the group.
+
+        '''
+        return self._rewriting_system.reduce(word)
+
+    def equals(self, word1, word2):
+        '''
+        Compare `word1` and `word2` for equality in the group
+        using the group's rewriting system. If the system is
+        confluent, the returned answer is necessarily correct.
+        (If it is not, `False` could be returned in some cases
+        where in fact `word1 == word2`)
+
+        '''
+        if self.reduce(word1*word2**-1) == self.identity:
+            return True
+        elif self._rewriting_system.is_confluent:
+            return False
+        return None
+
+    @property
+    def identity(self):
+        return self.free_group.identity
+
+    def __contains__(self, g):
+        return g in self.free_group
+
+    def subgroup(self, gens, C=None, homomorphism=False):
+        '''
+        Return the subgroup generated by `gens` using the
+        Reidemeister-Schreier algorithm
+        homomorphism -- When set to True, return a dictionary containing the images
+                     of the presentation generators in the original group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x**3, y**5, (x*y)**2])
+        >>> H = [x*y, x**-1*y**-1*x*y*x]
+        >>> K, T = f.subgroup(H, homomorphism=True)
+        >>> T(K.generators)
+        [x*y, x**-1*y**2*x**-1]
+
+        '''
+
+        if not all(isinstance(g, FreeGroupElement) for g in gens):
+            raise ValueError("Generators must be `FreeGroupElement`s")
+        if not all(g.group == self.free_group for g in gens):
+                raise ValueError("Given generators are not members of the group")
+        if homomorphism:
+            g, rels, _gens = reidemeister_presentation(self, gens, C=C, homomorphism=True)
+        else:
+            g, rels = reidemeister_presentation(self, gens, C=C)
+        if g:
+            g = FpGroup(g[0].group, rels)
+        else:
+            g = FpGroup(free_group('')[0], [])
+        if homomorphism:
+            from sympy.combinatorics.homomorphisms import homomorphism
+            return g, homomorphism(g, self, g.generators, _gens, check=False)
+        return g
+
+    def coset_enumeration(self, H, strategy="relator_based", max_cosets=None,
+                                                        draft=None, incomplete=False):
+        """
+        Return an instance of ``coset table``, when Todd-Coxeter algorithm is
+        run over the ``self`` with ``H`` as subgroup, using ``strategy``
+        argument as strategy. The returned coset table is compressed but not
+        standardized.
+
+        An instance of `CosetTable` for `fp_grp` can be passed as the keyword
+        argument `draft` in which case the coset enumeration will start with
+        that instance and attempt to complete it.
+
+        When `incomplete` is `True` and the function is unable to complete for
+        some reason, the partially complete table will be returned.
+
+        """
+        if not max_cosets:
+            max_cosets = CosetTable.coset_table_max_limit
+        if strategy == 'relator_based':
+            C = coset_enumeration_r(self, H, max_cosets=max_cosets,
+                                                    draft=draft, incomplete=incomplete)
+        else:
+            C = coset_enumeration_c(self, H, max_cosets=max_cosets,
+                                                    draft=draft, incomplete=incomplete)
+        if C.is_complete():
+            C.compress()
+        return C
+
+    def standardize_coset_table(self):
+        """
+        Standardized the coset table ``self`` and makes the internal variable
+        ``_is_standardized`` equal to ``True``.
+
+        """
+        self._coset_table.standardize()
+        self._is_standardized = True
+
+    def coset_table(self, H, strategy="relator_based", max_cosets=None,
+                                                 draft=None, incomplete=False):
+        """
+        Return the mathematical coset table of ``self`` in ``H``.
+
+        """
+        if not H:
+            if self._coset_table is not None:
+                if not self._is_standardized:
+                    self.standardize_coset_table()
+            else:
+                C = self.coset_enumeration([], strategy, max_cosets=max_cosets,
+                                            draft=draft, incomplete=incomplete)
+                self._coset_table = C
+                self.standardize_coset_table()
+            return self._coset_table.table
+        else:
+            C = self.coset_enumeration(H, strategy, max_cosets=max_cosets,
+                                            draft=draft, incomplete=incomplete)
+            C.standardize()
+            return C.table
+
+    def order(self, strategy="relator_based"):
+        """
+        Returns the order of the finitely presented group ``self``. It uses
+        the coset enumeration with identity group as subgroup, i.e ``H=[]``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x, y**2])
+        >>> f.order(strategy="coset_table_based")
+        2
+
+        """
+        if self._order is not None:
+            return self._order
+        if self._coset_table is not None:
+            self._order = len(self._coset_table.table)
+        elif len(self.relators) == 0:
+            self._order = self.free_group.order()
+        elif len(self.generators) == 1:
+            self._order = abs(gcd([r.array_form[0][1] for r in self.relators]))
+        elif self._is_infinite():
+            self._order = S.Infinity
+        else:
+            gens, C = self._finite_index_subgroup()
+            if C:
+                ind = len(C.table)
+                self._order = ind*self.subgroup(gens, C=C).order()
+            else:
+                self._order = self.index([])
+        return self._order
+
+    def _is_infinite(self):
+        '''
+        Test if the group is infinite. Return `True` if the test succeeds
+        and `None` otherwise
+
+        '''
+        used_gens = set()
+        for r in self.relators:
+            used_gens.update(r.contains_generators())
+        if not set(self.generators) <= used_gens:
+            return True
+        # Abelianisation test: check is the abelianisation is infinite
+        abelian_rels = []
+        for rel in self.relators:
+            abelian_rels.append([rel.exponent_sum(g) for g in self.generators])
+        m = Matrix(Matrix(abelian_rels))
+        if 0 in invariant_factors(m):
+            return True
+        else:
+            return None
+
+
+    def _finite_index_subgroup(self, s=None):
+        '''
+        Find the elements of `self` that generate a finite index subgroup
+        and, if found, return the list of elements and the coset table of `self` by
+        the subgroup, otherwise return `(None, None)`
+
+        '''
+        gen = self.most_frequent_generator()
+        rels = list(self.generators)
+        rels.extend(self.relators)
+        if not s:
+            if len(self.generators) == 2:
+                s = [gen] + [g for g in self.generators if g != gen]
+            else:
+                rand = self.free_group.identity
+                i = 0
+                while ((rand in rels or rand**-1 in rels or rand.is_identity)
+                        and i<10):
+                    rand = self.random()
+                    i += 1
+                s = [gen, rand] + [g for g in self.generators if g != gen]
+        mid = (len(s)+1)//2
+        half1 = s[:mid]
+        half2 = s[mid:]
+        draft1 = None
+        draft2 = None
+        m = 200
+        C = None
+        while not C and (m/2 < CosetTable.coset_table_max_limit):
+            m = min(m, CosetTable.coset_table_max_limit)
+            draft1 = self.coset_enumeration(half1, max_cosets=m,
+                                 draft=draft1, incomplete=True)
+            if draft1.is_complete():
+                C = draft1
+                half = half1
+            else:
+                draft2 = self.coset_enumeration(half2, max_cosets=m,
+                                 draft=draft2, incomplete=True)
+                if draft2.is_complete():
+                    C = draft2
+                    half = half2
+            if not C:
+                m *= 2
+        if not C:
+            return None, None
+        C.compress()
+        return half, C
+
+    def most_frequent_generator(self):
+        gens = self.generators
+        rels = self.relators
+        freqs = [sum(r.generator_count(g) for r in rels) for g in gens]
+        return gens[freqs.index(max(freqs))]
+
+    def random(self):
+        import random
+        r = self.free_group.identity
+        for i in range(random.randint(2,3)):
+            r = r*random.choice(self.generators)**random.choice([1,-1])
+        return r
+
+    def index(self, H, strategy="relator_based"):
+        """
+        Return the index of subgroup ``H`` in group ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+        >>> F, x, y = free_group("x, y")
+        >>> f = FpGroup(F, [x**5, y**4, y*x*y**3*x**3])
+        >>> f.index([x])
+        4
+
+        """
+        # TODO: use |G:H| = |G|/|H| (currently H can't be made into a group)
+        # when we know |G| and |H|
+
+        if H == []:
+            return self.order()
+        else:
+            C = self.coset_enumeration(H, strategy)
+            return len(C.table)
+
+    def __str__(self):
+        if self.free_group.rank > 30:
+            str_form = "" % self.free_group.rank
+        else:
+            str_form = "" % str(self.generators)
+        return str_form
+
+    __repr__ = __str__
+
+#==============================================================================
+#                       PERMUTATION GROUP METHODS
+#==============================================================================
+
+    def _to_perm_group(self):
+        '''
+        Return an isomorphic permutation group and the isomorphism.
+        The implementation is dependent on coset enumeration so
+        will only terminate for finite groups.
+
+        '''
+        from sympy.combinatorics import Permutation
+        from sympy.combinatorics.homomorphisms import homomorphism
+        if self.order() is S.Infinity:
+            raise NotImplementedError("Permutation presentation of infinite "
+                                                  "groups is not implemented")
+        if self._perm_isomorphism:
+            T = self._perm_isomorphism
+            P = T.image()
+        else:
+            C = self.coset_table([])
+            gens = self.generators
+            images = [[C[i][2*gens.index(g)] for i in range(len(C))] for g in gens]
+            images = [Permutation(i) for i in images]
+            P = PermutationGroup(images)
+            T = homomorphism(self, P, gens, images, check=False)
+            self._perm_isomorphism = T
+        return P, T
+
+    def _perm_group_list(self, method_name, *args):
+        '''
+        Given the name of a `PermutationGroup` method (returning a subgroup
+        or a list of subgroups) and (optionally) additional arguments it takes,
+        return a list or a list of lists containing the generators of this (or
+        these) subgroups in terms of the generators of `self`.
+
+        '''
+        P, T = self._to_perm_group()
+        perm_result = getattr(P, method_name)(*args)
+        single = False
+        if isinstance(perm_result, PermutationGroup):
+            perm_result, single = [perm_result], True
+        result = []
+        for group in perm_result:
+            gens = group.generators
+            result.append(T.invert(gens))
+        return result[0] if single else result
+
+    def derived_series(self):
+        '''
+        Return the list of lists containing the generators
+        of the subgroups in the derived series of `self`.
+
+        '''
+        return self._perm_group_list('derived_series')
+
+    def lower_central_series(self):
+        '''
+        Return the list of lists containing the generators
+        of the subgroups in the lower central series of `self`.
+
+        '''
+        return self._perm_group_list('lower_central_series')
+
+    def center(self):
+        '''
+        Return the list of generators of the center of `self`.
+
+        '''
+        return self._perm_group_list('center')
+
+
+    def derived_subgroup(self):
+        '''
+        Return the list of generators of the derived subgroup of `self`.
+
+        '''
+        return self._perm_group_list('derived_subgroup')
+
+
+    def centralizer(self, other):
+        '''
+        Return the list of generators of the centralizer of `other`
+        (a list of elements of `self`) in `self`.
+
+        '''
+        T = self._to_perm_group()[1]
+        other = T(other)
+        return self._perm_group_list('centralizer', other)
+
+    def normal_closure(self, other):
+        '''
+        Return the list of generators of the normal closure of `other`
+        (a list of elements of `self`) in `self`.
+
+        '''
+        T = self._to_perm_group()[1]
+        other = T(other)
+        return self._perm_group_list('normal_closure', other)
+
+    def _perm_property(self, attr):
+        '''
+        Given an attribute of a `PermutationGroup`, return
+        its value for a permutation group isomorphic to `self`.
+
+        '''
+        P = self._to_perm_group()[0]
+        return getattr(P, attr)
+
+    @property
+    def is_abelian(self):
+        '''
+        Check if `self` is abelian.
+
+        '''
+        return self._perm_property("is_abelian")
+
+    @property
+    def is_nilpotent(self):
+        '''
+        Check if `self` is nilpotent.
+
+        '''
+        return self._perm_property("is_nilpotent")
+
+    @property
+    def is_solvable(self):
+        '''
+        Check if `self` is solvable.
+
+        '''
+        return self._perm_property("is_solvable")
+
+    @property
+    def elements(self):
+        '''
+        List the elements of `self`.
+
+        '''
+        P, T = self._to_perm_group()
+        return T.invert(P.elements)
+
+    @property
+    def is_cyclic(self):
+        """
+        Return ``True`` if group is Cyclic.
+
+        """
+        if len(self.generators) <= 1:
+            return True
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("Check for infinite Cyclic group "
+                                      "is not implemented")
+        return P.is_cyclic
+
+    def abelian_invariants(self):
+        """
+        Return Abelian Invariants of a group.
+        """
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("abelian invariants is not implemented"
+                                      "for infinite group")
+        return P.abelian_invariants()
+
+    def composition_series(self):
+        """
+        Return subnormal series of maximum length for a group.
+        """
+        try:
+            P, T = self._to_perm_group()
+        except NotImplementedError:
+            raise NotImplementedError("composition series is not implemented"
+                                      "for infinite group")
+        return P.composition_series()
+
+
+class FpSubgroup(DefaultPrinting):
+    '''
+    The class implementing a subgroup of an FpGroup or a FreeGroup
+    (only finite index subgroups are supported at this point). This
+    is to be used if one wishes to check if an element of the original
+    group belongs to the subgroup
+
+    '''
+    def __init__(self, G, gens, normal=False):
+        super().__init__()
+        self.parent = G
+        self.generators = list({g for g in gens if g != G.identity})
+        self._min_words = None #for use in __contains__
+        self.C = None
+        self.normal = normal
+
+    def __contains__(self, g):
+
+        if isinstance(self.parent, FreeGroup):
+            if self._min_words is None:
+                # make _min_words - a list of subwords such that
+                # g is in the subgroup if and only if it can be
+                # partitioned into these subwords. Infinite families of
+                # subwords are presented by tuples, e.g. (r, w)
+                # stands for the family of subwords r*w**n*r**-1
+
+                def _process(w):
+                    # this is to be used before adding new words
+                    # into _min_words; if the word w is not cyclically
+                    # reduced, it will generate an infinite family of
+                    # subwords so should be written as a tuple;
+                    # if it is, w**-1 should be added to the list
+                    # as well
+                    p, r = w.cyclic_reduction(removed=True)
+                    if not r.is_identity:
+                        return [(r, p)]
+                    else:
+                        return [w, w**-1]
+
+                # make the initial list
+                gens = []
+                for w in self.generators:
+                    if self.normal:
+                        w = w.cyclic_reduction()
+                    gens.extend(_process(w))
+
+                for w1 in gens:
+                    for w2 in gens:
+                        # if w1 and w2 are equal or are inverses, continue
+                        if w1 == w2 or (not isinstance(w1, tuple)
+                                                        and w1**-1 == w2):
+                            continue
+
+                        # if the start of one word is the inverse of the
+                        # end of the other, their multiple should be added
+                        # to _min_words because of cancellation
+                        if isinstance(w1, tuple):
+                            # start, end
+                            s1, s2 = w1[0][0], w1[0][0]**-1
+                        else:
+                            s1, s2 = w1[0], w1[len(w1)-1]
+
+                        if isinstance(w2, tuple):
+                            # start, end
+                            r1, r2 = w2[0][0], w2[0][0]**-1
+                        else:
+                            r1, r2 = w2[0], w2[len(w1)-1]
+
+                        # p1 and p2 are w1 and w2 or, in case when
+                        # w1 or w2 is an infinite family, a representative
+                        p1, p2 = w1, w2
+                        if isinstance(w1, tuple):
+                            p1 = w1[0]*w1[1]*w1[0]**-1
+                        if isinstance(w2, tuple):
+                            p2 = w2[0]*w2[1]*w2[0]**-1
+
+                        # add the product of the words to the list is necessary
+                        if r1**-1 == s2 and not (p1*p2).is_identity:
+                            new = _process(p1*p2)
+                            if new not in gens:
+                                gens.extend(new)
+
+                        if r2**-1 == s1 and not (p2*p1).is_identity:
+                            new = _process(p2*p1)
+                            if new not in gens:
+                                gens.extend(new)
+
+                self._min_words = gens
+
+            min_words = self._min_words
+
+            def _is_subword(w):
+                # check if w is a word in _min_words or one of
+                # the infinite families in it
+                w, r = w.cyclic_reduction(removed=True)
+                if r.is_identity or self.normal:
+                    return w in min_words
+                else:
+                    t = [s[1] for s in min_words if isinstance(s, tuple)
+                                                                and s[0] == r]
+                    return [s for s in t if w.power_of(s)] != []
+
+            # store the solution of words for which the result of
+            # _word_break (below) is known
+            known = {}
+
+            def _word_break(w):
+                # check if w can be written as a product of words
+                # in min_words
+                if len(w) == 0:
+                    return True
+                i = 0
+                while i < len(w):
+                    i += 1
+                    prefix = w.subword(0, i)
+                    if not _is_subword(prefix):
+                        continue
+                    rest = w.subword(i, len(w))
+                    if rest not in known:
+                        known[rest] = _word_break(rest)
+                    if known[rest]:
+                        return True
+                return False
+
+            if self.normal:
+                g = g.cyclic_reduction()
+            return _word_break(g)
+        else:
+            if self.C is None:
+                C = self.parent.coset_enumeration(self.generators)
+                self.C = C
+            i = 0
+            C = self.C
+            for j in range(len(g)):
+                i = C.table[i][C.A_dict[g[j]]]
+            return i == 0
+
+    def order(self):
+        if not self.generators:
+            return S.One
+        if isinstance(self.parent, FreeGroup):
+            return S.Infinity
+        if self.C is None:
+            C = self.parent.coset_enumeration(self.generators)
+            self.C = C
+        # This is valid because `len(self.C.table)` (the index of the subgroup)
+        # will always be finite - otherwise coset enumeration doesn't terminate
+        return self.parent.order()/len(self.C.table)
+
+    def to_FpGroup(self):
+        if isinstance(self.parent, FreeGroup):
+            gen_syms = [('x_%d'%i) for i in range(len(self.generators))]
+            return free_group(', '.join(gen_syms))[0]
+        return self.parent.subgroup(C=self.C)
+
+    def __str__(self):
+        if len(self.generators) > 30:
+            str_form = "" % len(self.generators)
+        else:
+            str_form = "" % str(self.generators)
+        return str_form
+
+    __repr__ = __str__
+
+
+###############################################################################
+#                           LOW INDEX SUBGROUPS                               #
+###############################################################################
+
+def low_index_subgroups(G, N, Y=()):
+    """
+    Implements the Low Index Subgroups algorithm, i.e find all subgroups of
+    ``G`` upto a given index ``N``. This implements the method described in
+    [Sim94]. This procedure involves a backtrack search over incomplete Coset
+    Tables, rather than over forced coincidences.
+
+    Parameters
+    ==========
+
+    G: An FpGroup < X|R >
+    N: positive integer, representing the maximum index value for subgroups
+    Y: (an optional argument) specifying a list of subgroup generators, such
+    that each of the resulting subgroup contains the subgroup generated by Y.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, low_index_subgroups
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    >>> L = low_index_subgroups(f, 4)
+    >>> for coset_table in L:
+    ...     print(coset_table.table)
+    [[0, 0, 0, 0]]
+    [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]]
+    [[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]]
+    [[1, 1, 0, 0], [0, 0, 1, 1]]
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+           Section 5.4
+
+    .. [2] Marston Conder and Peter Dobcsanyi
+           "Applications and Adaptions of the Low Index Subgroups Procedure"
+
+    """
+    C = CosetTable(G, [])
+    R = G.relators
+    # length chosen for the length of the short relators
+    len_short_rel = 5
+    # elements of R2 only checked at the last step for complete
+    # coset tables
+    R2 = {rel for rel in R if len(rel) > len_short_rel}
+    # elements of R1 are used in inner parts of the process to prune
+    # branches of the search tree,
+    R1 = {rel.identity_cyclic_reduction() for rel in set(R) - R2}
+    R1_c_list = C.conjugates(R1)
+    S = []
+    descendant_subgroups(S, C, R1_c_list, C.A[0], R2, N, Y)
+    return S
+
+
+def descendant_subgroups(S, C, R1_c_list, x, R2, N, Y):
+    A_dict = C.A_dict
+    A_dict_inv = C.A_dict_inv
+    if C.is_complete():
+        # if C is complete then it only needs to test
+        # whether the relators in R2 are satisfied
+        for w, alpha in product(R2, C.omega):
+            if not C.scan_check(alpha, w):
+                return
+        # relators in R2 are satisfied, append the table to list
+        S.append(C)
+    else:
+        # find the first undefined entry in Coset Table
+        for alpha, x in product(range(len(C.table)), C.A):
+            if C.table[alpha][A_dict[x]] is None:
+                # this is "x" in pseudo-code (using "y" makes it clear)
+                undefined_coset, undefined_gen = alpha, x
+                break
+        # for filling up the undefine entry we try all possible values
+        # of beta in Omega or beta = n where beta^(undefined_gen^-1) is undefined
+        reach = C.omega + [C.n]
+        for beta in reach:
+            if beta < N:
+                if beta == C.n or C.table[beta][A_dict_inv[undefined_gen]] is None:
+                    try_descendant(S, C, R1_c_list, R2, N, undefined_coset, \
+                            undefined_gen, beta, Y)
+
+
+def try_descendant(S, C, R1_c_list, R2, N, alpha, x, beta, Y):
+    r"""
+    Solves the problem of trying out each individual possibility
+    for `\alpha^x.
+
+    """
+    D = C.copy()
+    if beta == D.n and beta < N:
+        D.table.append([None]*len(D.A))
+        D.p.append(beta)
+    D.table[alpha][D.A_dict[x]] = beta
+    D.table[beta][D.A_dict_inv[x]] = alpha
+    D.deduction_stack.append((alpha, x))
+    if not D.process_deductions_check(R1_c_list[D.A_dict[x]], \
+            R1_c_list[D.A_dict_inv[x]]):
+        return
+    for w in Y:
+        if not D.scan_check(0, w):
+            return
+    if first_in_class(D, Y):
+        descendant_subgroups(S, D, R1_c_list, x, R2, N, Y)
+
+
+def first_in_class(C, Y=()):
+    """
+    Checks whether the subgroup ``H=G1`` corresponding to the Coset Table
+    could possibly be the canonical representative of its conjugacy class.
+
+    Parameters
+    ==========
+
+    C: CosetTable
+
+    Returns
+    =======
+
+    bool: True/False
+
+    If this returns False, then no descendant of C can have that property, and
+    so we can abandon C. If it returns True, then we need to process further
+    the node of the search tree corresponding to C, and so we call
+    ``descendant_subgroups`` recursively on C.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, first_in_class
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    >>> C = CosetTable(f, [])
+    >>> C.table = [[0, 0, None, None]]
+    >>> first_in_class(C)
+    True
+    >>> C.table = [[1, 1, 1, None], [0, 0, None, 1]]; C.p = [0, 1]
+    >>> first_in_class(C)
+    True
+    >>> C.table = [[1, 1, 2, 1], [0, 0, 0, None], [None, None, None, 0]]
+    >>> C.p = [0, 1, 2]
+    >>> first_in_class(C)
+    False
+    >>> C.table = [[1, 1, 1, 2], [0, 0, 2, 0], [2, None, 0, 1]]
+    >>> first_in_class(C)
+    False
+
+    # TODO:: Sims points out in [Sim94] that performance can be improved by
+    # remembering some of the information computed by ``first_in_class``. If
+    # the ``continue alpha`` statement is executed at line 14, then the same thing
+    # will happen for that value of alpha in any descendant of the table C, and so
+    # the values the values of alpha for which this occurs could profitably be
+    # stored and passed through to the descendants of C. Of course this would
+    # make the code more complicated.
+
+    # The code below is taken directly from the function on page 208 of [Sim94]
+    # nu[alpha]
+
+    """
+    n = C.n
+    # lamda is the largest numbered point in Omega_c_alpha which is currently defined
+    lamda = -1
+    # for alpha in Omega_c, nu[alpha] is the point in Omega_c_alpha corresponding to alpha
+    nu = [None]*n
+    # for alpha in Omega_c_alpha, mu[alpha] is the point in Omega_c corresponding to alpha
+    mu = [None]*n
+    # mutually nu and mu are the mutually-inverse equivalence maps between
+    # Omega_c_alpha and Omega_c
+    next_alpha = False
+    # For each 0!=alpha in [0 .. nc-1], we start by constructing the equivalent
+    # standardized coset table C_alpha corresponding to H_alpha
+    for alpha in range(1, n):
+        # reset nu to "None" after previous value of alpha
+        for beta in range(lamda+1):
+            nu[mu[beta]] = None
+        # we only want to reject our current table in favour of a preceding
+        # table in the ordering in which 1 is replaced by alpha, if the subgroup
+        # G_alpha corresponding to this preceding table definitely contains the
+        # given subgroup
+        for w in Y:
+            # TODO: this should support input of a list of general words
+            # not just the words which are in "A" (i.e gen and gen^-1)
+            if C.table[alpha][C.A_dict[w]] != alpha:
+                # continue with alpha
+                next_alpha = True
+                break
+        if next_alpha:
+            next_alpha = False
+            continue
+        # try alpha as the new point 0 in Omega_C_alpha
+        mu[0] = alpha
+        nu[alpha] = 0
+        # compare corresponding entries in C and C_alpha
+        lamda = 0
+        for beta in range(n):
+            for x in C.A:
+                gamma = C.table[beta][C.A_dict[x]]
+                delta = C.table[mu[beta]][C.A_dict[x]]
+                # if either of the entries is undefined,
+                # we move with next alpha
+                if gamma is None or delta is None:
+                    # continue with alpha
+                    next_alpha = True
+                    break
+                if nu[delta] is None:
+                    # delta becomes the next point in Omega_C_alpha
+                    lamda += 1
+                    nu[delta] = lamda
+                    mu[lamda] = delta
+                if nu[delta] < gamma:
+                    return False
+                if nu[delta] > gamma:
+                    # continue with alpha
+                    next_alpha = True
+                    break
+            if next_alpha:
+                next_alpha = False
+                break
+    return True
+
+#========================================================================
+#                    Simplifying Presentation
+#========================================================================
+
+def simplify_presentation(*args, change_gens=False):
+    '''
+    For an instance of `FpGroup`, return a simplified isomorphic copy of
+    the group (e.g. remove redundant generators or relators). Alternatively,
+    a list of generators and relators can be passed in which case the
+    simplified lists will be returned.
+
+    By default, the generators of the group are unchanged. If you would
+    like to remove redundant generators, set the keyword argument
+    `change_gens = True`.
+
+    '''
+    if len(args) == 1:
+        if not isinstance(args[0], FpGroup):
+            raise TypeError("The argument must be an instance of FpGroup")
+        G = args[0]
+        gens, rels = simplify_presentation(G.generators, G.relators,
+                                              change_gens=change_gens)
+        if gens:
+            return FpGroup(gens[0].group, rels)
+        return FpGroup(FreeGroup([]), [])
+    elif len(args) == 2:
+        gens, rels = args[0][:], args[1][:]
+        if not gens:
+            return gens, rels
+        identity = gens[0].group.identity
+    else:
+        if len(args) == 0:
+            m = "Not enough arguments"
+        else:
+            m = "Too many arguments"
+        raise RuntimeError(m)
+
+    prev_gens = []
+    prev_rels = []
+    while not set(prev_rels) == set(rels):
+        prev_rels = rels
+        while change_gens and not set(prev_gens) == set(gens):
+            prev_gens = gens
+            gens, rels = elimination_technique_1(gens, rels, identity)
+        rels = _simplify_relators(rels)
+
+    if change_gens:
+        syms = [g.array_form[0][0] for g in gens]
+        F = free_group(syms)[0]
+        identity = F.identity
+        gens = F.generators
+        subs = dict(zip(syms, gens))
+        for j, r in enumerate(rels):
+            a = r.array_form
+            rel = identity
+            for sym, p in a:
+                rel = rel*subs[sym]**p
+            rels[j] = rel
+    return gens, rels
+
+def _simplify_relators(rels):
+    """
+    Simplifies a set of relators. All relators are checked to see if they are
+    of the form `gen^n`. If any such relators are found then all other relators
+    are processed for strings in the `gen` known order.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import _simplify_relators
+    >>> F, x, y = free_group("x, y")
+    >>> w1 = [x**2*y**4, x**3]
+    >>> _simplify_relators(w1)
+    [x**3, x**-1*y**4]
+
+    >>> w2 = [x**2*y**-4*x**5, x**3, x**2*y**8, y**5]
+    >>> _simplify_relators(w2)
+    [x**-1*y**-2, x**-1*y*x**-1, x**3, y**5]
+
+    >>> w3 = [x**6*y**4, x**4]
+    >>> _simplify_relators(w3)
+    [x**4, x**2*y**4]
+
+    >>> w4 = [x**2, x**5, y**3]
+    >>> _simplify_relators(w4)
+    [x, y**3]
+
+    """
+    rels = rels[:]
+
+    if not rels:
+        return []
+
+    identity = rels[0].group.identity
+
+    # build dictionary with "gen: n" where gen^n is one of the relators
+    exps = {}
+    for i in range(len(rels)):
+        rel = rels[i]
+        if rel.number_syllables() == 1:
+            g = rel[0]
+            exp = abs(rel.array_form[0][1])
+            if rel.array_form[0][1] < 0:
+                rels[i] = rels[i]**-1
+                g = g**-1
+            if g in exps:
+                exp = gcd(exp, exps[g].array_form[0][1])
+            exps[g] = g**exp
+
+    one_syllables_words = list(exps.values())
+    # decrease some of the exponents in relators, making use of the single
+    # syllable relators
+    for i, rel in enumerate(rels):
+        if rel in one_syllables_words:
+            continue
+        rel = rel.eliminate_words(one_syllables_words, _all = True)
+        # if rels[i] contains g**n where abs(n) is greater than half of the power p
+        # of g in exps, g**n can be replaced by g**(n-p) (or g**(p-n) if n<0)
+        for g in rel.contains_generators():
+            if g in exps:
+                exp = exps[g].array_form[0][1]
+                max_exp = (exp + 1)//2
+                rel = rel.eliminate_word(g**(max_exp), g**(max_exp-exp), _all = True)
+                rel = rel.eliminate_word(g**(-max_exp), g**(-(max_exp-exp)), _all = True)
+        rels[i] = rel
+
+    rels = [r.identity_cyclic_reduction() for r in rels]
+
+    rels += one_syllables_words # include one_syllable_words in the list of relators
+    rels = list(set(rels)) # get unique values in rels
+    rels.sort()
+
+    # remove  entries in rels
+    try:
+        rels.remove(identity)
+    except ValueError:
+        pass
+    return rels
+
+# Pg 350, section 2.5.1 from [2]
+def elimination_technique_1(gens, rels, identity):
+    rels = rels[:]
+    # the shorter relators are examined first so that generators selected for
+    # elimination will have shorter strings as equivalent
+    rels.sort()
+    gens = gens[:]
+    redundant_gens = {}
+    redundant_rels = []
+    used_gens = set()
+    # examine each relator in relator list for any generator occurring exactly
+    # once
+    for rel in rels:
+        # don't look for a redundant generator in a relator which
+        # depends on previously found ones
+        contained_gens = rel.contains_generators()
+        if any(g in contained_gens for g in redundant_gens):
+            continue
+        contained_gens = list(contained_gens)
+        contained_gens.sort(reverse = True)
+        for gen in contained_gens:
+            if rel.generator_count(gen) == 1 and gen not in used_gens:
+                k = rel.exponent_sum(gen)
+                gen_index = rel.index(gen**k)
+                bk = rel.subword(gen_index + 1, len(rel))
+                fw = rel.subword(0, gen_index)
+                chi = bk*fw
+                redundant_gens[gen] = chi**(-1*k)
+                used_gens.update(chi.contains_generators())
+                redundant_rels.append(rel)
+                break
+    rels = [r for r in rels if r not in redundant_rels]
+    # eliminate the redundant generators from remaining relators
+    rels = [r.eliminate_words(redundant_gens, _all = True).identity_cyclic_reduction() for r in rels]
+    rels = list(set(rels))
+    try:
+        rels.remove(identity)
+    except ValueError:
+        pass
+    gens = [g for g in gens if g not in redundant_gens]
+    return gens, rels
+
+###############################################################################
+#                           SUBGROUP PRESENTATIONS                            #
+###############################################################################
+
+# Pg 175 [1]
+def define_schreier_generators(C, homomorphism=False):
+    '''
+    Parameters
+    ==========
+
+    C -- Coset table.
+    homomorphism -- When set to True, return a dictionary containing the images
+                     of the presentation generators in the original group.
+    '''
+    y = []
+    gamma = 1
+    f = C.fp_group
+    X = f.generators
+    if homomorphism:
+        # `_gens` stores the elements of the parent group to
+        # to which the schreier generators correspond to.
+        _gens = {}
+        # compute the schreier Traversal
+        tau = {}
+        tau[0] = f.identity
+    C.P = [[None]*len(C.A) for i in range(C.n)]
+    for alpha, x in product(C.omega, C.A):
+        beta = C.table[alpha][C.A_dict[x]]
+        if beta == gamma:
+            C.P[alpha][C.A_dict[x]] = ""
+            C.P[beta][C.A_dict_inv[x]] = ""
+            gamma += 1
+            if homomorphism:
+                tau[beta] = tau[alpha]*x
+        elif x in X and C.P[alpha][C.A_dict[x]] is None:
+            y_alpha_x = '%s_%s' % (x, alpha)
+            y.append(y_alpha_x)
+            C.P[alpha][C.A_dict[x]] = y_alpha_x
+            if homomorphism:
+                _gens[y_alpha_x] = tau[alpha]*x*tau[beta]**-1
+    grp_gens = list(free_group(', '.join(y)))
+    C._schreier_free_group = grp_gens.pop(0)
+    C._schreier_generators = grp_gens
+    if homomorphism:
+        C._schreier_gen_elem = _gens
+    # replace all elements of P by, free group elements
+    for i, j in product(range(len(C.P)), range(len(C.A))):
+        # if equals "", replace by identity element
+        if C.P[i][j] == "":
+            C.P[i][j] = C._schreier_free_group.identity
+        elif isinstance(C.P[i][j], str):
+            r = C._schreier_generators[y.index(C.P[i][j])]
+            C.P[i][j] = r
+            beta = C.table[i][j]
+            C.P[beta][j + 1] = r**-1
+
+def reidemeister_relators(C):
+    R = C.fp_group.relators
+    rels = [rewrite(C, coset, word) for word in R for coset in range(C.n)]
+    order_1_gens = {i for i in rels if len(i) == 1}
+
+    # remove all the order 1 generators from relators
+    rels = list(filter(lambda rel: rel not in order_1_gens, rels))
+
+    # replace order 1 generators by identity element in reidemeister relators
+    for i in range(len(rels)):
+        w = rels[i]
+        w = w.eliminate_words(order_1_gens, _all=True)
+        rels[i] = w
+
+    C._schreier_generators = [i for i in C._schreier_generators
+                    if not (i in order_1_gens or i**-1 in order_1_gens)]
+
+    # Tietze transformation 1 i.e TT_1
+    # remove cyclic conjugate elements from relators
+    i = 0
+    while i < len(rels):
+        w = rels[i]
+        j = i + 1
+        while j < len(rels):
+            if w.is_cyclic_conjugate(rels[j]):
+                del rels[j]
+            else:
+                j += 1
+        i += 1
+
+    C._reidemeister_relators = rels
+
+
+def rewrite(C, alpha, w):
+    """
+    Parameters
+    ==========
+
+    C: CosetTable
+    alpha: A live coset
+    w: A word in `A*`
+
+    Returns
+    =======
+
+    rho(tau(alpha), w)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.fp_groups import FpGroup, CosetTable, define_schreier_generators, rewrite
+    >>> from sympy.combinatorics import free_group
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**2, y**3, (x*y)**6])
+    >>> C = CosetTable(f, [])
+    >>> C.table = [[1, 1, 2, 3], [0, 0, 4, 5], [4, 4, 3, 0], [5, 5, 0, 2], [2, 2, 5, 1], [3, 3, 1, 4]]
+    >>> C.p = [0, 1, 2, 3, 4, 5]
+    >>> define_schreier_generators(C)
+    >>> rewrite(C, 0, (x*y)**6)
+    x_4*y_2*x_3*x_1*x_2*y_4*x_5
+
+    """
+    v = C._schreier_free_group.identity
+    for i in range(len(w)):
+        x_i = w[i]
+        v = v*C.P[alpha][C.A_dict[x_i]]
+        alpha = C.table[alpha][C.A_dict[x_i]]
+    return v
+
+# Pg 350, section 2.5.2 from [2]
+def elimination_technique_2(C):
+    """
+    This technique eliminates one generator at a time. Heuristically this
+    seems superior in that we may select for elimination the generator with
+    shortest equivalent string at each stage.
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, coset_enumeration_r, \
+            reidemeister_relators, define_schreier_generators, elimination_technique_2
+    >>> F, x, y = free_group("x, y")
+    >>> f = FpGroup(F, [x**3, y**5, (x*y)**2]); H = [x*y, x**-1*y**-1*x*y*x]
+    >>> C = coset_enumeration_r(f, H)
+    >>> C.compress(); C.standardize()
+    >>> define_schreier_generators(C)
+    >>> reidemeister_relators(C)
+    >>> elimination_technique_2(C)
+    ([y_1, y_2], [y_2**-3, y_2*y_1*y_2*y_1*y_2*y_1, y_1**2])
+
+    """
+    rels = C._reidemeister_relators
+    rels.sort(reverse=True)
+    gens = C._schreier_generators
+    for i in range(len(gens) - 1, -1, -1):
+        rel = rels[i]
+        for j in range(len(gens) - 1, -1, -1):
+            gen = gens[j]
+            if rel.generator_count(gen) == 1:
+                k = rel.exponent_sum(gen)
+                gen_index = rel.index(gen**k)
+                bk = rel.subword(gen_index + 1, len(rel))
+                fw = rel.subword(0, gen_index)
+                rep_by = (bk*fw)**(-1*k)
+                del rels[i]
+                del gens[j]
+                rels = [rel.eliminate_word(gen, rep_by) for rel in rels]
+                break
+    C._reidemeister_relators = rels
+    C._schreier_generators = gens
+    return C._schreier_generators, C._reidemeister_relators
+
+def reidemeister_presentation(fp_grp, H, C=None, homomorphism=False):
+    """
+    Parameters
+    ==========
+
+    fp_group: A finitely presented group, an instance of FpGroup
+    H: A subgroup whose presentation is to be found, given as a list
+    of words in generators of `fp_grp`
+    homomorphism: When set to True, return a homomorphism from the subgroup
+                    to the parent group
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> from sympy.combinatorics.fp_groups import FpGroup, reidemeister_presentation
+    >>> F, x, y = free_group("x, y")
+
+    Example 5.6 Pg. 177 from [1]
+    >>> f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    >>> H = [x*y, x**-1*y**-1*x*y*x]
+    >>> reidemeister_presentation(f, H)
+    ((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1))
+
+    Example 5.8 Pg. 183 from [1]
+    >>> f = FpGroup(F, [x**3, y**3, (x*y)**3])
+    >>> H = [x*y, x*y**-1]
+    >>> reidemeister_presentation(f, H)
+    ((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0))
+
+    Exercises Q2. Pg 187 from [1]
+    >>> f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    >>> H = [x]
+    >>> reidemeister_presentation(f, H)
+    ((x_0,), (x_0**4,))
+
+    Example 5.9 Pg. 183 from [1]
+    >>> f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2])
+    >>> H = [x]
+    >>> reidemeister_presentation(f, H)
+    ((x_0,), (x_0**6,))
+
+    """
+    if not C:
+        C = coset_enumeration_r(fp_grp, H)
+    C.compress(); C.standardize()
+    define_schreier_generators(C, homomorphism=homomorphism)
+    reidemeister_relators(C)
+    gens, rels = C._schreier_generators, C._reidemeister_relators
+    gens, rels = simplify_presentation(gens, rels, change_gens=True)
+
+    C.schreier_generators = tuple(gens)
+    C.reidemeister_relators = tuple(rels)
+
+    if homomorphism:
+        _gens = [C._schreier_gen_elem[str(gen)] for gen in gens]
+        return C.schreier_generators, C.reidemeister_relators, _gens
+
+    return C.schreier_generators, C.reidemeister_relators
+
+
+FpGroupElement = FreeGroupElement
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/free_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/free_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ec85f4fac73fba95d4644a37ecb27140e45a4c5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/free_groups.py
@@ -0,0 +1,1360 @@
+from __future__ import annotations
+
+from sympy.core import S
+from sympy.core.expr import Expr
+from sympy.core.symbol import Symbol, symbols as _symbols
+from sympy.core.sympify import CantSympify
+from sympy.printing.defaults import DefaultPrinting
+from sympy.utilities import public
+from sympy.utilities.iterables import flatten, is_sequence
+from sympy.utilities.magic import pollute
+from sympy.utilities.misc import as_int
+
+
+@public
+def free_group(symbols):
+    """Construct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1))``.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group
+    >>> F, x, y, z = free_group("x, y, z")
+    >>> F
+    
+    >>> x**2*y**-1
+    x**2*y**-1
+    >>> type(_)
+    
+
+    """
+    _free_group = FreeGroup(symbols)
+    return (_free_group,) + tuple(_free_group.generators)
+
+@public
+def xfree_group(symbols):
+    """Construct a free group returning ``(FreeGroup, (f_0, f_1, ..., f_(n-1)))``.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import xfree_group
+    >>> F, (x, y, z) = xfree_group("x, y, z")
+    >>> F
+    
+    >>> y**2*x**-2*z**-1
+    y**2*x**-2*z**-1
+    >>> type(_)
+    
+
+    """
+    _free_group = FreeGroup(symbols)
+    return (_free_group, _free_group.generators)
+
+@public
+def vfree_group(symbols):
+    """Construct a free group and inject ``f_0, f_1, ..., f_(n-1)`` as symbols
+    into the global namespace.
+
+    Parameters
+    ==========
+
+    symbols : str, Symbol/Expr or sequence of str, Symbol/Expr (may be empty)
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.free_groups import vfree_group
+    >>> vfree_group("x, y, z")
+    
+    >>> x**2*y**-2*z # noqa: F821
+    x**2*y**-2*z
+    >>> type(_)
+    
+
+    """
+    _free_group = FreeGroup(symbols)
+    pollute([sym.name for sym in _free_group.symbols], _free_group.generators)
+    return _free_group
+
+
+def _parse_symbols(symbols):
+    if not symbols:
+        return ()
+    if isinstance(symbols, str):
+        return _symbols(symbols, seq=True)
+    elif isinstance(symbols, (Expr, FreeGroupElement)):
+        return (symbols,)
+    elif is_sequence(symbols):
+        if all(isinstance(s, str) for s in symbols):
+            return _symbols(symbols)
+        elif all(isinstance(s, Expr) for s in symbols):
+            return symbols
+    raise ValueError("The type of `symbols` must be one of the following: "
+                     "a str, Symbol/Expr or a sequence of "
+                     "one of these types")
+
+
+##############################################################################
+#                          FREE GROUP                                        #
+##############################################################################
+
+_free_group_cache: dict[int, FreeGroup] = {}
+
+class FreeGroup(DefaultPrinting):
+    """
+    Free group with finite or infinite number of generators. Its input API
+    is that of a str, Symbol/Expr or a sequence of one of
+    these types (which may be empty)
+
+    See Also
+    ========
+
+    sympy.polys.rings.PolyRing
+
+    References
+    ==========
+
+    .. [1] https://www.gap-system.org/Manuals/doc/ref/chap37.html
+
+    .. [2] https://en.wikipedia.org/wiki/Free_group
+
+    """
+    is_associative = True
+    is_group = True
+    is_FreeGroup = True
+    is_PermutationGroup = False
+    relators: list[Expr] = []
+
+    def __new__(cls, symbols):
+        symbols = tuple(_parse_symbols(symbols))
+        rank = len(symbols)
+        _hash = hash((cls.__name__, symbols, rank))
+        obj = _free_group_cache.get(_hash)
+
+        if obj is None:
+            obj = object.__new__(cls)
+            obj._hash = _hash
+            obj._rank = rank
+            # dtype method is used to create new instances of FreeGroupElement
+            obj.dtype = type("FreeGroupElement", (FreeGroupElement,), {"group": obj})
+            obj.symbols = symbols
+            obj.generators = obj._generators()
+            obj._gens_set = set(obj.generators)
+            for symbol, generator in zip(obj.symbols, obj.generators):
+                if isinstance(symbol, Symbol):
+                    name = symbol.name
+                    if hasattr(obj, name):
+                        setattr(obj, name, generator)
+
+            _free_group_cache[_hash] = obj
+
+        return obj
+
+    def __getnewargs__(self):
+        """Return a tuple of arguments that must be passed to __new__ in order to support pickling this object."""
+        return (self.symbols,)
+
+    def __getstate__(self):
+        # Don't pickle any fields because they are regenerated within __new__
+        return None
+
+    def _generators(group):
+        """Returns the generators of the FreeGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y, z = free_group("x, y, z")
+        >>> F.generators
+        (x, y, z)
+
+        """
+        gens = []
+        for sym in group.symbols:
+            elm = ((sym, 1),)
+            gens.append(group.dtype(elm))
+        return tuple(gens)
+
+    def clone(self, symbols=None):
+        return self.__class__(symbols or self.symbols)
+
+    def __contains__(self, i):
+        """Return True if ``i`` is contained in FreeGroup."""
+        if not isinstance(i, FreeGroupElement):
+            return False
+        group = i.group
+        return self == group
+
+    def __hash__(self):
+        return self._hash
+
+    def __len__(self):
+        return self.rank
+
+    def __str__(self):
+        if self.rank > 30:
+            str_form = "" % self.rank
+        else:
+            str_form = ""
+        return str_form
+
+    __repr__ = __str__
+
+    def __getitem__(self, index):
+        symbols = self.symbols[index]
+        return self.clone(symbols=symbols)
+
+    def __eq__(self, other):
+        """No ``FreeGroup`` is equal to any "other" ``FreeGroup``.
+        """
+        return self is other
+
+    def index(self, gen):
+        """Return the index of the generator `gen` from ``(f_0, ..., f_(n-1))``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> F.index(y)
+        1
+        >>> F.index(x)
+        0
+
+        """
+        if isinstance(gen, self.dtype):
+            return self.generators.index(gen)
+        else:
+            raise ValueError("expected a generator of Free Group %s, got %s" % (self, gen))
+
+    def order(self):
+        """Return the order of the free group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> F.order()
+        oo
+
+        >>> free_group("")[0].order()
+        1
+
+        """
+        if self.rank == 0:
+            return S.One
+        else:
+            return S.Infinity
+
+    @property
+    def elements(self):
+        """
+        Return the elements of the free group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> (z,) = free_group("")
+        >>> z.elements
+        {}
+
+        """
+        if self.rank == 0:
+            # A set containing Identity element of `FreeGroup` self is returned
+            return {self.identity}
+        else:
+            raise ValueError("Group contains infinitely many elements"
+                            ", hence cannot be represented")
+
+    @property
+    def rank(self):
+        r"""
+        In group theory, the `rank` of a group `G`, denoted `G.rank`,
+        can refer to the smallest cardinality of a generating set
+        for G, that is
+
+        \operatorname{rank}(G)=\min\{ |X|: X\subseteq G, \left\langle X\right\rangle =G\}.
+
+        """
+        return self._rank
+
+    @property
+    def is_abelian(self):
+        """Returns if the group is Abelian.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> f.is_abelian
+        False
+
+        """
+        return self.rank in (0, 1)
+
+    @property
+    def identity(self):
+        """Returns the identity element of free group."""
+        return self.dtype()
+
+    def contains(self, g):
+        """Tests if Free Group element ``g`` belong to self, ``G``.
+
+        In mathematical terms any linear combination of generators
+        of a Free Group is contained in it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> f.contains(x**3*y**2)
+        True
+
+        """
+        if not isinstance(g, FreeGroupElement):
+            return False
+        elif self != g.group:
+            return False
+        else:
+            return True
+
+    def center(self):
+        """Returns the center of the free group `self`."""
+        return {self.identity}
+
+
+############################################################################
+#                          FreeGroupElement                                #
+############################################################################
+
+
+class FreeGroupElement(CantSympify, DefaultPrinting, tuple):
+    """Used to create elements of FreeGroup. It cannot be used directly to
+    create a free group element. It is called by the `dtype` method of the
+    `FreeGroup` class.
+
+    """
+    __slots__ = ()
+    is_assoc_word = True
+
+    def new(self, init):
+        return self.__class__(init)
+
+    _hash = None
+
+    def __hash__(self):
+        _hash = self._hash
+        if _hash is None:
+            self._hash = _hash = hash((self.group, frozenset(tuple(self))))
+        return _hash
+
+    def copy(self):
+        return self.new(self)
+
+    @property
+    def is_identity(self):
+        return not self.array_form
+
+    @property
+    def array_form(self):
+        """
+        SymPy provides two different internal kinds of representation
+        of associative words. The first one is called the `array_form`
+        which is a tuple containing `tuples` as its elements, where the
+        size of each tuple is two. At the first position the tuple
+        contains the `symbol-generator`, while at the second position
+        of tuple contains the exponent of that generator at the position.
+        Since elements (i.e. words) do not commute, the indexing of tuple
+        makes that property to stay.
+
+        The structure in ``array_form`` of ``FreeGroupElement`` is of form:
+
+        ``( ( symbol_of_gen, exponent ), ( , ), ... ( , ) )``
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> (x*z).array_form
+        ((x, 1), (z, 1))
+        >>> (x**2*z*y*x**2).array_form
+        ((x, 2), (z, 1), (y, 1), (x, 2))
+
+        See Also
+        ========
+
+        letter_repr
+
+        """
+        return tuple(self)
+
+    @property
+    def letter_form(self):
+        """
+        The letter representation of a ``FreeGroupElement`` is a tuple
+        of generator symbols, with each entry corresponding to a group
+        generator. Inverses of the generators are represented by
+        negative generator symbols.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b, c, d = free_group("a b c d")
+        >>> (a**3).letter_form
+        (a, a, a)
+        >>> (a**2*d**-2*a*b**-4).letter_form
+        (a, a, -d, -d, a, -b, -b, -b, -b)
+        >>> (a**-2*b**3*d).letter_form
+        (-a, -a, b, b, b, d)
+
+        See Also
+        ========
+
+        array_form
+
+        """
+        return tuple(flatten([(i,)*j if j > 0 else (-i,)*(-j)
+                    for i, j in self.array_form]))
+
+    def __getitem__(self, i):
+        group = self.group
+        r = self.letter_form[i]
+        if r.is_Symbol:
+            return group.dtype(((r, 1),))
+        else:
+            return group.dtype(((-r, -1),))
+
+    def index(self, gen):
+        if len(gen) != 1:
+            raise ValueError()
+        return (self.letter_form).index(gen.letter_form[0])
+
+    @property
+    def letter_form_elm(self):
+        """
+        """
+        group = self.group
+        r = self.letter_form
+        return [group.dtype(((elm,1),)) if elm.is_Symbol \
+                else group.dtype(((-elm,-1),)) for elm in r]
+
+    @property
+    def ext_rep(self):
+        """This is called the External Representation of ``FreeGroupElement``
+        """
+        return tuple(flatten(self.array_form))
+
+    def __contains__(self, gen):
+        return gen.array_form[0][0] in tuple([r[0] for r in self.array_form])
+
+    def __str__(self):
+        if self.is_identity:
+            return ""
+
+        str_form = ""
+        array_form = self.array_form
+        for i in range(len(array_form)):
+            if i == len(array_form) - 1:
+                if array_form[i][1] == 1:
+                    str_form += str(array_form[i][0])
+                else:
+                    str_form += str(array_form[i][0]) + \
+                                    "**" + str(array_form[i][1])
+            else:
+                if array_form[i][1] == 1:
+                    str_form += str(array_form[i][0]) + "*"
+                else:
+                    str_form += str(array_form[i][0]) + \
+                                    "**" + str(array_form[i][1]) + "*"
+        return str_form
+
+    __repr__ = __str__
+
+    def __pow__(self, n):
+        n = as_int(n)
+        result = self.group.identity
+        if n == 0:
+            return result
+        if n < 0:
+            n = -n
+            x = self.inverse()
+        else:
+            x = self
+        while True:
+            if n % 2:
+                result *= x
+            n >>= 1
+            if not n:
+                break
+            x *= x
+        return result
+
+    def __mul__(self, other):
+        """Returns the product of elements belonging to the same ``FreeGroup``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> x*y**2*y**-4
+        x*y**-2
+        >>> z*y**-2
+        z*y**-2
+        >>> x**2*y*y**-1*x**-2
+        
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        if self.is_identity:
+            return other
+        if other.is_identity:
+            return self
+        r = list(self.array_form + other.array_form)
+        zero_mul_simp(r, len(self.array_form) - 1)
+        return group.dtype(tuple(r))
+
+    def __truediv__(self, other):
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        return self*(other.inverse())
+
+    def __rtruediv__(self, other):
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                    "be multiplied")
+        return other*(self.inverse())
+
+    def __add__(self, other):
+        return NotImplemented
+
+    def inverse(self):
+        """
+        Returns the inverse of a ``FreeGroupElement`` element
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> x.inverse()
+        x**-1
+        >>> (x*y).inverse()
+        y**-1*x**-1
+
+        """
+        group = self.group
+        r = tuple([(i, -j) for i, j in self.array_form[::-1]])
+        return group.dtype(r)
+
+    def order(self):
+        """Find the order of a ``FreeGroupElement``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y = free_group("x y")
+        >>> (x**2*y*y**-1*x**-2).order()
+        1
+
+        """
+        if self.is_identity:
+            return S.One
+        else:
+            return S.Infinity
+
+    def commutator(self, other):
+        """
+        Return the commutator of `self` and `x`: ``~x*~self*x*self``
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise ValueError("commutator of only FreeGroupElement of the same "
+                    "FreeGroup exists")
+        else:
+            return self.inverse()*other.inverse()*self*other
+
+    def eliminate_words(self, words, _all=False, inverse=True):
+        '''
+        Replace each subword from the dictionary `words` by words[subword].
+        If words is a list, replace the words by the identity.
+
+        '''
+        again = True
+        new = self
+        if isinstance(words, dict):
+            while again:
+                again = False
+                for sub in words:
+                    prev = new
+                    new = new.eliminate_word(sub, words[sub], _all=_all, inverse=inverse)
+                    if new != prev:
+                        again = True
+        else:
+            while again:
+                again = False
+                for sub in words:
+                    prev = new
+                    new = new.eliminate_word(sub, _all=_all, inverse=inverse)
+                    if new != prev:
+                        again = True
+        return new
+
+    def eliminate_word(self, gen, by=None, _all=False, inverse=True):
+        """
+        For an associative word `self`, a subword `gen`, and an associative
+        word `by` (identity by default), return the associative word obtained by
+        replacing each occurrence of `gen` in `self` by `by`. If `_all = True`,
+        the occurrences of `gen` that may appear after the first substitution will
+        also be replaced and so on until no occurrences are found. This might not
+        always terminate (e.g. `(x).eliminate_word(x, x**2, _all=True)`).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y = free_group("x y")
+        >>> w = x**5*y*x**2*y**-4*x
+        >>> w.eliminate_word( x, x**2 )
+        x**10*y*x**4*y**-4*x**2
+        >>> w.eliminate_word( x, y**-1 )
+        y**-11
+        >>> w.eliminate_word(x**5)
+        y*x**2*y**-4*x
+        >>> w.eliminate_word(x*y, y)
+        x**4*y*x**2*y**-4*x
+
+        See Also
+        ========
+        substituted_word
+
+        """
+        if by is None:
+            by = self.group.identity
+        if self.is_independent(gen) or gen == by:
+            return self
+        if gen == self:
+            return by
+        if gen**-1 == by:
+            _all = False
+        word = self
+        l = len(gen)
+
+        try:
+            i = word.subword_index(gen)
+            k = 1
+        except ValueError:
+            if not inverse:
+                return word
+            try:
+                i = word.subword_index(gen**-1)
+                k = -1
+            except ValueError:
+                return word
+
+        word = word.subword(0, i)*by**k*word.subword(i+l, len(word)).eliminate_word(gen, by)
+
+        if _all:
+            return word.eliminate_word(gen, by, _all=True, inverse=inverse)
+        else:
+            return word
+
+    def __len__(self):
+        """
+        For an associative word `self`, returns the number of letters in it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> len(w)
+        13
+        >>> len(a**17)
+        17
+        >>> len(w**0)
+        0
+
+        """
+        return sum(abs(j) for (i, j) in self)
+
+    def __eq__(self, other):
+        """
+        Two  associative words are equal if they are words over the
+        same alphabet and if they are sequences of the same letters.
+        This is equivalent to saying that the external representations
+        of the words are equal.
+        There is no "universal" empty word, every alphabet has its own
+        empty word.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1")
+        >>> f
+        
+        >>> g, swap0, swap1 = free_group("swap0 swap1")
+        >>> g
+        
+
+        >>> swapnil0 == swapnil1
+        False
+        >>> swapnil0*swapnil1 == swapnil1/swapnil1*swapnil0*swapnil1
+        True
+        >>> swapnil0*swapnil1 == swapnil1*swapnil0
+        False
+        >>> swapnil1**0 == swap0**0
+        False
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            return False
+        return tuple.__eq__(self, other)
+
+    def __lt__(self, other):
+        """
+        The  ordering  of  associative  words is defined by length and
+        lexicography (this ordering is called short-lex ordering), that
+        is, shorter words are smaller than longer words, and words of the
+        same length are compared w.r.t. the lexicographical ordering induced
+        by the ordering of generators. Generators  are  sorted  according
+        to the order in which they were created. If the generators are
+        invertible then each generator `g` is larger than its inverse `g^{-1}`,
+        and `g^{-1}` is larger than every generator that is smaller than `g`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> b < a
+        False
+        >>> a < a.inverse()
+        False
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                             "be compared")
+        l = len(self)
+        m = len(other)
+        # implement lenlex order
+        if l < m:
+            return True
+        elif l > m:
+            return False
+        for i in range(l):
+            a = self[i].array_form[0]
+            b = other[i].array_form[0]
+            p = group.symbols.index(a[0])
+            q = group.symbols.index(b[0])
+            if p < q:
+                return True
+            elif p > q:
+                return False
+            elif a[1] < b[1]:
+                return True
+            elif a[1] > b[1]:
+                return False
+        return False
+
+    def __le__(self, other):
+        return (self == other or self < other)
+
+    def __gt__(self, other):
+        """
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, x, y, z = free_group("x y z")
+        >>> y**2 > x**2
+        True
+        >>> y*z > z*y
+        False
+        >>> x > x.inverse()
+        True
+
+        """
+        group = self.group
+        if not isinstance(other, group.dtype):
+            raise TypeError("only FreeGroup elements of same FreeGroup can "
+                             "be compared")
+        return not self <= other
+
+    def __ge__(self, other):
+        return not self < other
+
+    def exponent_sum(self, gen):
+        """
+        For an associative word `self` and a generator or inverse of generator
+        `gen`, ``exponent_sum`` returns the number of times `gen` appears in
+        `self` minus the number of times its inverse appears in `self`. If
+        neither `gen` nor its inverse occur in `self` then 0 is returned.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x**2*y**3
+        >>> w.exponent_sum(x)
+        2
+        >>> w.exponent_sum(x**-1)
+        -2
+        >>> w = x**2*y**4*x**-3
+        >>> w.exponent_sum(x)
+        -1
+
+        See Also
+        ========
+
+        generator_count
+
+        """
+        if len(gen) != 1:
+            raise ValueError("gen must be a generator or inverse of a generator")
+        s = gen.array_form[0]
+        return s[1]*sum(i[1] for i in self.array_form if i[0] == s[0])
+
+    def generator_count(self, gen):
+        """
+        For an associative word `self` and a generator `gen`,
+        ``generator_count`` returns the multiplicity of generator
+        `gen` in `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x**2*y**3
+        >>> w.generator_count(x)
+        2
+        >>> w = x**2*y**4*x**-3
+        >>> w.generator_count(x)
+        5
+
+        See Also
+        ========
+
+        exponent_sum
+
+        """
+        if len(gen) != 1 or gen.array_form[0][1] < 0:
+            raise ValueError("gen must be a generator")
+        s = gen.array_form[0]
+        return s[1]*sum(abs(i[1]) for i in self.array_form if i[0] == s[0])
+
+    def subword(self, from_i, to_j, strict=True):
+        """
+        For an associative word `self` and two positive integers `from_i` and
+        `to_j`, `subword` returns the subword of `self` that begins at position
+        `from_i` and ends at `to_j - 1`, indexing is done with origin 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.subword(2, 6)
+        a**3*b
+
+        """
+        group = self.group
+        if not strict:
+            from_i = max(from_i, 0)
+            to_j = min(len(self), to_j)
+        if from_i < 0 or to_j > len(self):
+            raise ValueError("`from_i`, `to_j` must be positive and no greater than "
+                    "the length of associative word")
+        if to_j <= from_i:
+            return group.identity
+        else:
+            letter_form = self.letter_form[from_i: to_j]
+            array_form = letter_form_to_array_form(letter_form, group)
+            return group.dtype(array_form)
+
+    def subword_index(self, word, start = 0):
+        '''
+        Find the index of `word` in `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**2*b*a*b**3
+        >>> w.subword_index(a*b*a*b)
+        1
+
+        '''
+        l = len(word)
+        self_lf = self.letter_form
+        word_lf = word.letter_form
+        index = None
+        for i in range(start,len(self_lf)-l+1):
+            if self_lf[i:i+l] == word_lf:
+                index = i
+                break
+        if index is not None:
+            return index
+        else:
+            raise ValueError("The given word is not a subword of self")
+
+    def is_dependent(self, word):
+        """
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**4*y**-3).is_dependent(x**4*y**-2)
+        True
+        >>> (x**2*y**-1).is_dependent(x*y)
+        False
+        >>> (x*y**2*x*y**2).is_dependent(x*y**2)
+        True
+        >>> (x**12).is_dependent(x**-4)
+        True
+
+        See Also
+        ========
+
+        is_independent
+
+        """
+        try:
+            return self.subword_index(word) is not None
+        except ValueError:
+            pass
+        try:
+            return self.subword_index(word**-1) is not None
+        except ValueError:
+            return False
+
+    def is_independent(self, word):
+        """
+
+        See Also
+        ========
+
+        is_dependent
+
+        """
+        return not self.is_dependent(word)
+
+    def contains_generators(self):
+        """
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y, z = free_group("x, y, z")
+        >>> (x**2*y**-1).contains_generators()
+        {x, y}
+        >>> (x**3*z).contains_generators()
+        {x, z}
+
+        """
+        group = self.group
+        gens = {group.dtype(((syllable[0], 1),)) for syllable in self.array_form}
+        return gens
+
+    def cyclic_subword(self, from_i, to_j):
+        group = self.group
+        l = len(self)
+        letter_form = self.letter_form
+        period1 = int(from_i/l)
+        if from_i >= l:
+            from_i -= l*period1
+            to_j -= l*period1
+        diff = to_j - from_i
+        word = letter_form[from_i: to_j]
+        period2 = int(to_j/l) - 1
+        word += letter_form*period2 + letter_form[:diff-l+from_i-l*period2]
+        word = letter_form_to_array_form(word, group)
+        return group.dtype(word)
+
+    def cyclic_conjugates(self):
+        """Returns a words which are cyclic to the word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w = x*y*x*y*x
+        >>> w.cyclic_conjugates()
+        {x*y*x**2*y, x**2*y*x*y, y*x*y*x**2, y*x**2*y*x, x*y*x*y*x}
+        >>> s = x*y*x**2*y*x
+        >>> s.cyclic_conjugates()
+        {x**2*y*x**2*y, y*x**2*y*x**2, x*y*x**2*y*x}
+
+        References
+        ==========
+
+        .. [1] https://planetmath.org/cyclicpermutation
+
+        """
+        return {self.cyclic_subword(i, i+len(self)) for i in range(len(self))}
+
+    def is_cyclic_conjugate(self, w):
+        """
+        Checks whether words ``self``, ``w`` are cyclic conjugates.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> w1 = x**2*y**5
+        >>> w2 = x*y**5*x
+        >>> w1.is_cyclic_conjugate(w2)
+        True
+        >>> w3 = x**-1*y**5*x**-1
+        >>> w3.is_cyclic_conjugate(w2)
+        False
+
+        """
+        l1 = len(self)
+        l2 = len(w)
+        if l1 != l2:
+            return False
+        w1 = self.identity_cyclic_reduction()
+        w2 = w.identity_cyclic_reduction()
+        letter1 = w1.letter_form
+        letter2 = w2.letter_form
+        str1 = ' '.join(map(str, letter1))
+        str2 = ' '.join(map(str, letter2))
+        if len(str1) != len(str2):
+            return False
+
+        return str1 in str2 + ' ' + str2
+
+    def number_syllables(self):
+        """Returns the number of syllables of the associative word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, swapnil0, swapnil1 = free_group("swapnil0 swapnil1")
+        >>> (swapnil1**3*swapnil0*swapnil1**-1).number_syllables()
+        3
+
+        """
+        return len(self.array_form)
+
+    def exponent_syllable(self, i):
+        """
+        Returns the exponent of the `i`-th syllable of the associative word
+        `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.exponent_syllable( 2 )
+        2
+
+        """
+        return self.array_form[i][1]
+
+    def generator_syllable(self, i):
+        """
+        Returns the symbol of the generator that is involved in the
+        i-th syllable of the associative word `self`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.generator_syllable( 3 )
+        b
+
+        """
+        return self.array_form[i][0]
+
+    def sub_syllables(self, from_i, to_j):
+        """
+        `sub_syllables` returns the subword of the associative word `self` that
+        consists of syllables from positions `from_to` to `to_j`, where
+        `from_to` and `to_j` must be positive integers and indexing is done
+        with origin 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> f, a, b = free_group("a, b")
+        >>> w = a**5*b*a**2*b**-4*a
+        >>> w.sub_syllables(1, 2)
+        b
+        >>> w.sub_syllables(3, 3)
+        
+
+        """
+        if not isinstance(from_i, int) or not isinstance(to_j, int):
+            raise ValueError("both arguments should be integers")
+        group = self.group
+        if to_j <= from_i:
+            return group.identity
+        else:
+            r = tuple(self.array_form[from_i: to_j])
+            return group.dtype(r)
+
+    def substituted_word(self, from_i, to_j, by):
+        """
+        Returns the associative word obtained by replacing the subword of
+        `self` that begins at position `from_i` and ends at position `to_j - 1`
+        by the associative word `by`. `from_i` and `to_j` must be positive
+        integers, indexing is done with origin 0. In other words,
+        `w.substituted_word(w, from_i, to_j, by)` is the product of the three
+        words: `w.subword(0, from_i)`, `by`, and
+        `w.subword(to_j len(w))`.
+
+        See Also
+        ========
+
+        eliminate_word
+
+        """
+        lw = len(self)
+        if from_i >= to_j or from_i > lw or to_j > lw:
+            raise ValueError("values should be within bounds")
+
+        # otherwise there are four possibilities
+
+        # first if from=1 and to=lw then
+        if from_i == 0 and to_j == lw:
+            return by
+        elif from_i == 0:  # second if from_i=1 (and to_j < lw) then
+            return by*self.subword(to_j, lw)
+        elif to_j == lw:   # third if to_j=1 (and from_i > 1) then
+            return self.subword(0, from_i)*by
+        else:              # finally
+            return self.subword(0, from_i)*by*self.subword(to_j, lw)
+
+    def is_cyclically_reduced(self):
+        r"""Returns whether the word is cyclically reduced or not.
+        A word is cyclically reduced if by forming the cycle of the
+        word, the word is not reduced, i.e a word w = `a_1 ... a_n`
+        is called cyclically reduced if `a_1 \ne a_n^{-1}`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**-1*x**-1).is_cyclically_reduced()
+        False
+        >>> (y*x**2*y**2).is_cyclically_reduced()
+        True
+
+        """
+        if not self:
+            return True
+        return self[0] != self[-1]**-1
+
+    def identity_cyclic_reduction(self):
+        """Return a unique cyclically reduced version of the word.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**2*x**-1).identity_cyclic_reduction()
+        x*y**2
+        >>> (x**-3*y**-1*x**5).identity_cyclic_reduction()
+        x**2*y**-1
+
+        References
+        ==========
+
+        .. [1] https://planetmath.org/cyclicallyreduced
+
+        """
+        word = self.copy()
+        group = self.group
+        while not word.is_cyclically_reduced():
+            exp1 = word.exponent_syllable(0)
+            exp2 = word.exponent_syllable(-1)
+            r = exp1 + exp2
+            if r == 0:
+                rep = word.array_form[1: word.number_syllables() - 1]
+            else:
+                rep = ((word.generator_syllable(0), exp1 + exp2),) + \
+                        word.array_form[1: word.number_syllables() - 1]
+            word = group.dtype(rep)
+        return word
+
+    def cyclic_reduction(self, removed=False):
+        """Return a cyclically reduced version of the word. Unlike
+        `identity_cyclic_reduction`, this will not cyclically permute
+        the reduced word - just remove the "unreduced" bits on either
+        side of it. Compare the examples with those of
+        `identity_cyclic_reduction`.
+
+        When `removed` is `True`, return a tuple `(word, r)` where
+        self `r` is such that before the reduction the word was either
+        `r*word*r**-1`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> (x**2*y**2*x**-1).cyclic_reduction()
+        x*y**2
+        >>> (x**-3*y**-1*x**5).cyclic_reduction()
+        y**-1*x**2
+        >>> (x**-3*y**-1*x**5).cyclic_reduction(removed=True)
+        (y**-1*x**2, x**-3)
+
+        """
+        word = self.copy()
+        g = self.group.identity
+        while not word.is_cyclically_reduced():
+            exp1 = abs(word.exponent_syllable(0))
+            exp2 = abs(word.exponent_syllable(-1))
+            exp = min(exp1, exp2)
+            start = word[0]**abs(exp)
+            end = word[-1]**abs(exp)
+            word = start**-1*word*end**-1
+            g = g*start
+        if removed:
+            return word, g
+        return word
+
+    def power_of(self, other):
+        '''
+        Check if `self == other**n` for some integer n.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group
+        >>> F, x, y = free_group("x, y")
+        >>> ((x*y)**2).power_of(x*y)
+        True
+        >>> (x**-3*y**-2*x**3).power_of(x**-3*y*x**3)
+        True
+
+        '''
+        if self.is_identity:
+            return True
+
+        l = len(other)
+        if l == 1:
+            # self has to be a power of one generator
+            gens = self.contains_generators()
+            s = other in gens or other**-1 in gens
+            return len(gens) == 1 and s
+
+        # if self is not cyclically reduced and it is a power of other,
+        # other isn't cyclically reduced and the parts removed during
+        # their reduction must be equal
+        reduced, r1 = self.cyclic_reduction(removed=True)
+        if not r1.is_identity:
+            other, r2 = other.cyclic_reduction(removed=True)
+            if r1 == r2:
+                return reduced.power_of(other)
+            return False
+
+        if len(self) < l or len(self) % l:
+            return False
+
+        prefix = self.subword(0, l)
+        if prefix == other or prefix**-1 == other:
+            rest = self.subword(l, len(self))
+            return rest.power_of(other)
+        return False
+
+
+def letter_form_to_array_form(array_form, group):
+    """
+    This method converts a list given with possible repetitions of elements in
+    it. It returns a new list such that repetitions of consecutive elements is
+    removed and replace with a tuple element of size two such that the first
+    index contains `value` and the second index contains the number of
+    consecutive repetitions of `value`.
+
+    """
+    a = list(array_form[:])
+    new_array = []
+    n = 1
+    symbols = group.symbols
+    for i in range(len(a)):
+        if i == len(a) - 1:
+            if a[i] == a[i - 1]:
+                if (-a[i]) in symbols:
+                    new_array.append((-a[i], -n))
+                else:
+                    new_array.append((a[i], n))
+            else:
+                if (-a[i]) in symbols:
+                    new_array.append((-a[i], -1))
+                else:
+                    new_array.append((a[i], 1))
+            return new_array
+        elif a[i] == a[i + 1]:
+            n += 1
+        else:
+            if (-a[i]) in symbols:
+                new_array.append((-a[i], -n))
+            else:
+                new_array.append((a[i], n))
+            n = 1
+
+
+def zero_mul_simp(l, index):
+    """Used to combine two reduced words."""
+    while index >=0 and index < len(l) - 1 and l[index][0] == l[index + 1][0]:
+        exp = l[index][1] + l[index + 1][1]
+        base = l[index][0]
+        l[index] = (base, exp)
+        del l[index + 1]
+        if l[index][1] == 0:
+            del l[index]
+            index -= 1
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/galois.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/galois.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8ff89886283903e116bf40e1be6f6131386e802
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/galois.py
@@ -0,0 +1,611 @@
+r"""
+Construct transitive subgroups of symmetric groups, useful in Galois theory.
+
+Besides constructing instances of the :py:class:`~.PermutationGroup` class to
+represent the transitive subgroups of $S_n$ for small $n$, this module provides
+*names* for these groups.
+
+In some applications, it may be preferable to know the name of a group,
+rather than receive an instance of the :py:class:`~.PermutationGroup`
+class, and then have to do extra work to determine which group it is, by
+checking various properties.
+
+Names are instances of ``Enum`` classes defined in this module. With a name in
+hand, the name's ``get_perm_group`` method can then be used to retrieve a
+:py:class:`~.PermutationGroup`.
+
+The names used for groups in this module are taken from [1].
+
+References
+==========
+
+.. [1] Cohen, H. *A Course in Computational Algebraic Number Theory*.
+
+"""
+
+from collections import defaultdict
+from enum import Enum
+import itertools
+
+from sympy.combinatorics.named_groups import (
+    SymmetricGroup, AlternatingGroup, CyclicGroup, DihedralGroup,
+    set_symmetric_group_properties, set_alternating_group_properties,
+)
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+
+
+class S1TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S1.
+    """
+    S1 = "S1"
+
+    def get_perm_group(self):
+        return SymmetricGroup(1)
+
+
+class S2TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S2.
+    """
+    S2 = "S2"
+
+    def get_perm_group(self):
+        return SymmetricGroup(2)
+
+
+class S3TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S3.
+    """
+    A3 = "A3"
+    S3 = "S3"
+
+    def get_perm_group(self):
+        if self == S3TransitiveSubgroups.A3:
+            return AlternatingGroup(3)
+        elif self == S3TransitiveSubgroups.S3:
+            return SymmetricGroup(3)
+
+
+class S4TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S4.
+    """
+    C4 = "C4"
+    V = "V"
+    D4 = "D4"
+    A4 = "A4"
+    S4 = "S4"
+
+    def get_perm_group(self):
+        if self == S4TransitiveSubgroups.C4:
+            return CyclicGroup(4)
+        elif self == S4TransitiveSubgroups.V:
+            return four_group()
+        elif self == S4TransitiveSubgroups.D4:
+            return DihedralGroup(4)
+        elif self == S4TransitiveSubgroups.A4:
+            return AlternatingGroup(4)
+        elif self == S4TransitiveSubgroups.S4:
+            return SymmetricGroup(4)
+
+
+class S5TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S5.
+    """
+    C5 = "C5"
+    D5 = "D5"
+    M20 = "M20"
+    A5 = "A5"
+    S5 = "S5"
+
+    def get_perm_group(self):
+        if self == S5TransitiveSubgroups.C5:
+            return CyclicGroup(5)
+        elif self == S5TransitiveSubgroups.D5:
+            return DihedralGroup(5)
+        elif self == S5TransitiveSubgroups.M20:
+            return M20()
+        elif self == S5TransitiveSubgroups.A5:
+            return AlternatingGroup(5)
+        elif self == S5TransitiveSubgroups.S5:
+            return SymmetricGroup(5)
+
+
+class S6TransitiveSubgroups(Enum):
+    """
+    Names for the transitive subgroups of S6.
+    """
+    C6 = "C6"
+    S3 = "S3"
+    D6 = "D6"
+    A4 = "A4"
+    G18 = "G18"
+    A4xC2 = "A4 x C2"
+    S4m = "S4-"
+    S4p = "S4+"
+    G36m = "G36-"
+    G36p = "G36+"
+    S4xC2 = "S4 x C2"
+    PSL2F5 = "PSL2(F5)"
+    G72 = "G72"
+    PGL2F5 = "PGL2(F5)"
+    A6 = "A6"
+    S6 = "S6"
+
+    def get_perm_group(self):
+        if self == S6TransitiveSubgroups.C6:
+            return CyclicGroup(6)
+        elif self == S6TransitiveSubgroups.S3:
+            return S3_in_S6()
+        elif self == S6TransitiveSubgroups.D6:
+            return DihedralGroup(6)
+        elif self == S6TransitiveSubgroups.A4:
+            return A4_in_S6()
+        elif self == S6TransitiveSubgroups.G18:
+            return G18()
+        elif self == S6TransitiveSubgroups.A4xC2:
+            return A4xC2()
+        elif self == S6TransitiveSubgroups.S4m:
+            return S4m()
+        elif self == S6TransitiveSubgroups.S4p:
+            return S4p()
+        elif self == S6TransitiveSubgroups.G36m:
+            return G36m()
+        elif self == S6TransitiveSubgroups.G36p:
+            return G36p()
+        elif self == S6TransitiveSubgroups.S4xC2:
+            return S4xC2()
+        elif self == S6TransitiveSubgroups.PSL2F5:
+            return PSL2F5()
+        elif self == S6TransitiveSubgroups.G72:
+            return G72()
+        elif self == S6TransitiveSubgroups.PGL2F5:
+            return PGL2F5()
+        elif self == S6TransitiveSubgroups.A6:
+            return AlternatingGroup(6)
+        elif self == S6TransitiveSubgroups.S6:
+            return SymmetricGroup(6)
+
+
+def four_group():
+    """
+    Return a representation of the Klein four-group as a transitive subgroup
+    of S4.
+    """
+    return PermutationGroup(
+        Permutation(0, 1)(2, 3),
+        Permutation(0, 2)(1, 3)
+    )
+
+
+def M20():
+    """
+    Return a representation of the metacyclic group M20, a transitive subgroup
+    of S5 that is one of the possible Galois groups for polys of degree 5.
+
+    Notes
+    =====
+
+    See [1], Page 323.
+
+    """
+    G = PermutationGroup(Permutation(0, 1, 2, 3, 4), Permutation(1, 2, 4, 3))
+    G._degree = 5
+    G._order = 20
+    G._is_transitive = True
+    G._is_sym = False
+    G._is_alt = False
+    G._is_cyclic = False
+    G._is_dihedral = False
+    return G
+
+
+def S3_in_S6():
+    """
+    Return a representation of S3 as a transitive subgroup of S6.
+
+    Notes
+    =====
+
+    The representation is found by viewing the group as the symmetries of a
+    triangular prism.
+
+    """
+    G = PermutationGroup(Permutation(0, 1, 2)(3, 4, 5), Permutation(0, 3)(2, 4)(1, 5))
+    set_symmetric_group_properties(G, 3, 6)
+    return G
+
+
+def A4_in_S6():
+    """
+    Return a representation of A4 as a transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 1, 2)(3, 5, 4))
+    set_alternating_group_properties(G, 4, 6)
+    return G
+
+
+def S4m():
+    """
+    Return a representation of the S4- transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(1, 4, 5, 3), Permutation(0, 4)(1, 5)(2, 3))
+    set_symmetric_group_properties(G, 4, 6)
+    return G
+
+
+def S4p():
+    """
+    Return a representation of the S4+ transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(Permutation(0, 2, 4, 1)(3, 5), Permutation(0, 3)(4, 5))
+    set_symmetric_group_properties(G, 4, 6)
+    return G
+
+
+def A4xC2():
+    """
+    Return a representation of the (A4 x C2) transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 1, 2)(3, 5, 4),
+        Permutation(5)(2, 4))
+
+
+def S4xC2():
+    """
+    Return a representation of the (S4 x C2) transitive subgroup of S6.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(1, 4, 5, 3), Permutation(0, 4)(1, 5)(2, 3),
+        Permutation(1, 4)(3, 5))
+
+
+def G18():
+    """
+    Return a representation of the group G18, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C2.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(0, 4)(1, 5)(2, 3))
+
+
+def G36m():
+    """
+    Return a representation of the group G36-, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C2^2.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(1, 2)(3, 5), Permutation(0, 4)(1, 5)(2, 3))
+
+
+def G36p():
+    """
+    Return a representation of the group G36+, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with C4.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2), Permutation(3, 4, 5),
+        Permutation(0, 5, 2, 3)(1, 4))
+
+
+def G72():
+    """
+    Return a representation of the group G72, a transitive subgroup of S6
+    isomorphic to the semidirect product of C3^2 with D4.
+
+    Notes
+    =====
+
+    See [1], Page 325.
+
+    """
+    return PermutationGroup(
+        Permutation(5)(0, 1, 2),
+        Permutation(0, 4, 1, 3)(2, 5), Permutation(0, 3)(1, 4)(2, 5))
+
+
+def PSL2F5():
+    r"""
+    Return a representation of the group $PSL_2(\mathbb{F}_5)$, as a transitive
+    subgroup of S6, isomorphic to $A_5$.
+
+    Notes
+    =====
+
+    This was computed using :py:func:`~.find_transitive_subgroups_of_S6`.
+
+    """
+    G = PermutationGroup(
+        Permutation(0, 4, 5)(1, 3, 2), Permutation(0, 4, 3, 1, 5))
+    set_alternating_group_properties(G, 5, 6)
+    return G
+
+
+def PGL2F5():
+    r"""
+    Return a representation of the group $PGL_2(\mathbb{F}_5)$, as a transitive
+    subgroup of S6, isomorphic to $S_5$.
+
+    Notes
+    =====
+
+    See [1], Page 325.
+
+    """
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3, 4), Permutation(0, 5)(1, 2)(3, 4))
+    set_symmetric_group_properties(G, 5, 6)
+    return G
+
+
+def find_transitive_subgroups_of_S6(*targets, print_report=False):
+    r"""
+    Search for certain transitive subgroups of $S_6$.
+
+    The symmetric group $S_6$ has 16 different transitive subgroups, up to
+    conjugacy. Some are more easily constructed than others. For example, the
+    dihedral group $D_6$ is immediately found, but it is not at all obvious how
+    to realize $S_4$ or $S_5$ *transitively* within $S_6$.
+
+    In some cases there are well-known constructions that can be used. For
+    example, $S_5$ is isomorphic to $PGL_2(\mathbb{F}_5)$, which acts in a
+    natural way on the projective line $P^1(\mathbb{F}_5)$, a set of order 6.
+
+    In absence of such special constructions however, we can simply search for
+    generators. For example, transitive instances of $A_4$ and $S_4$ can be
+    found within $S_6$ in this way.
+
+    Once we are engaged in such searches, it may then be easier (if less
+    elegant) to find even those groups like $S_5$ that do have special
+    constructions, by mere search.
+
+    This function locates generators for transitive instances in $S_6$ of the
+    following subgroups:
+
+    * $A_4$
+    * $S_4^-$ ($S_4$ not contained within $A_6$)
+    * $S_4^+$ ($S_4$ contained within $A_6$)
+    * $A_4 \times C_2$
+    * $S_4 \times C_2$
+    * $G_{18}   = C_3^2 \rtimes C_2$
+    * $G_{36}^- = C_3^2 \rtimes C_2^2$
+    * $G_{36}^+ = C_3^2 \rtimes C_4$
+    * $G_{72}   = C_3^2 \rtimes D_4$
+    * $A_5$
+    * $S_5$
+
+    Note: Each of these groups also has a dedicated function in this module
+    that returns the group immediately, using generators that were found by
+    this search procedure.
+
+    The search procedure serves as a record of how these generators were
+    found. Also, due to randomness in the generation of the elements of
+    permutation groups, it can be called again, in order to (probably) get
+    different generators for the same groups.
+
+    Parameters
+    ==========
+
+    targets : list of :py:class:`~.S6TransitiveSubgroups` values
+        The groups you want to find.
+
+    print_report : bool (default False)
+        If True, print to stdout the generators found for each group.
+
+    Returns
+    =======
+
+    dict
+        mapping each name in *targets* to the :py:class:`~.PermutationGroup`
+        that was found
+
+    References
+    ==========
+
+    .. [2] https://en.wikipedia.org/wiki/Projective_linear_group#Exceptional_isomorphisms
+    .. [3] https://en.wikipedia.org/wiki/Automorphisms_of_the_symmetric_and_alternating_groups#PGL%282,5%29
+
+    """
+    def elts_by_order(G):
+        """Sort the elements of a group by their order. """
+        elts = defaultdict(list)
+        for g in G.elements:
+            elts[g.order()].append(g)
+        return elts
+
+    def order_profile(G, name=None):
+        """Determine how many elements a group has, of each order. """
+        elts = elts_by_order(G)
+        profile = {o:len(e) for o, e in elts.items()}
+        if name:
+            print(f'{name}: ' + ' '.join(f'{len(profile[r])}@{r}' for r in sorted(profile.keys())))
+        return profile
+
+    S6 = SymmetricGroup(6)
+    A6 = AlternatingGroup(6)
+    S6_by_order = elts_by_order(S6)
+
+    def search(existing_gens, needed_gen_orders, order, alt=None, profile=None, anti_profile=None):
+        """
+        Find a transitive subgroup of S6.
+
+        Parameters
+        ==========
+
+        existing_gens : list of Permutation
+            Optionally empty list of generators that must be in the group.
+
+        needed_gen_orders : list of positive int
+            Nonempty list of the orders of the additional generators that are
+            to be found.
+
+        order: int
+            The order of the group being sought.
+
+        alt: bool, None
+            If True, require the group to be contained in A6.
+            If False, require the group not to be contained in A6.
+
+        profile : dict
+            If given, the group's order profile must equal this.
+
+        anti_profile : dict
+            If given, the group's order profile must *not* equal this.
+
+        """
+        for gens in itertools.product(*[S6_by_order[n] for n in needed_gen_orders]):
+            if len(set(gens)) < len(gens):
+                continue
+            G = PermutationGroup(existing_gens + list(gens))
+            if G.order() == order and G.is_transitive():
+                if alt is not None and G.is_subgroup(A6) != alt:
+                    continue
+                if profile and order_profile(G) != profile:
+                    continue
+                if anti_profile and order_profile(G) == anti_profile:
+                    continue
+                return G
+
+    def match_known_group(G, alt=None):
+        needed = [g.order() for g in G.generators]
+        return search([], needed, G.order(), alt=alt, profile=order_profile(G))
+
+    found = {}
+
+    def finish_up(name, G):
+        found[name] = G
+        if print_report:
+            print("=" * 40)
+            print(f"{name}:")
+            print(G.generators)
+
+    if S6TransitiveSubgroups.A4 in targets or S6TransitiveSubgroups.A4xC2 in targets:
+        A4_in_S6 = match_known_group(AlternatingGroup(4))
+        finish_up(S6TransitiveSubgroups.A4, A4_in_S6)
+
+    if S6TransitiveSubgroups.S4m in targets or S6TransitiveSubgroups.S4xC2 in targets:
+        S4m_in_S6 = match_known_group(SymmetricGroup(4), alt=False)
+        finish_up(S6TransitiveSubgroups.S4m, S4m_in_S6)
+
+    if S6TransitiveSubgroups.S4p in targets:
+        S4p_in_S6 = match_known_group(SymmetricGroup(4), alt=True)
+        finish_up(S6TransitiveSubgroups.S4p, S4p_in_S6)
+
+    if S6TransitiveSubgroups.A4xC2 in targets:
+        A4xC2_in_S6 = search(A4_in_S6.generators, [2], 24, anti_profile=order_profile(SymmetricGroup(4)))
+        finish_up(S6TransitiveSubgroups.A4xC2, A4xC2_in_S6)
+
+    if S6TransitiveSubgroups.S4xC2 in targets:
+        S4xC2_in_S6 = search(S4m_in_S6.generators, [2], 48)
+        finish_up(S6TransitiveSubgroups.S4xC2, S4xC2_in_S6)
+
+    # For the normal factor N = C3^2 in any of the G_n subgroups, we take one
+    # obvious instance of C3^2 in S6:
+    N_gens = [Permutation(5)(0, 1, 2), Permutation(5)(3, 4, 5)]
+
+    if S6TransitiveSubgroups.G18 in targets:
+        G18_in_S6 = search(N_gens, [2], 18)
+        finish_up(S6TransitiveSubgroups.G18, G18_in_S6)
+
+    if S6TransitiveSubgroups.G36m in targets:
+        G36m_in_S6 = search(N_gens, [2, 2], 36, alt=False)
+        finish_up(S6TransitiveSubgroups.G36m, G36m_in_S6)
+
+    if S6TransitiveSubgroups.G36p in targets:
+        G36p_in_S6 = search(N_gens, [4], 36, alt=True)
+        finish_up(S6TransitiveSubgroups.G36p, G36p_in_S6)
+
+    if S6TransitiveSubgroups.G72 in targets:
+        G72_in_S6 = search(N_gens, [4, 2], 72)
+        finish_up(S6TransitiveSubgroups.G72, G72_in_S6)
+
+    # The PSL2(F5) and PGL2(F5) subgroups are isomorphic to A5 and S5, resp.
+
+    if S6TransitiveSubgroups.PSL2F5 in targets:
+        PSL2F5_in_S6 = match_known_group(AlternatingGroup(5))
+        finish_up(S6TransitiveSubgroups.PSL2F5, PSL2F5_in_S6)
+
+    if S6TransitiveSubgroups.PGL2F5 in targets:
+        PGL2F5_in_S6 = match_known_group(SymmetricGroup(5))
+        finish_up(S6TransitiveSubgroups.PGL2F5, PGL2F5_in_S6)
+
+    # There is little need to "search" for any of the groups C6, S3, D6, A6,
+    # or S6, since they all have obvious realizations within S6. However, we
+    # support them here just in case a random representation is desired.
+
+    if S6TransitiveSubgroups.C6 in targets:
+        C6 = match_known_group(CyclicGroup(6))
+        finish_up(S6TransitiveSubgroups.C6, C6)
+
+    if S6TransitiveSubgroups.S3 in targets:
+        S3 = match_known_group(SymmetricGroup(3))
+        finish_up(S6TransitiveSubgroups.S3, S3)
+
+    if S6TransitiveSubgroups.D6 in targets:
+        D6 = match_known_group(DihedralGroup(6))
+        finish_up(S6TransitiveSubgroups.D6, D6)
+
+    if S6TransitiveSubgroups.A6 in targets:
+        A6 = match_known_group(A6)
+        finish_up(S6TransitiveSubgroups.A6, A6)
+
+    if S6TransitiveSubgroups.S6 in targets:
+        S6 = match_known_group(S6)
+        finish_up(S6TransitiveSubgroups.S6, S6)
+
+    return found
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/generators.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/generators.py
new file mode 100644
index 0000000000000000000000000000000000000000..19e274a4c5b4bf0781855db6bc6bf499349fff31
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/generators.py
@@ -0,0 +1,301 @@
+from sympy.combinatorics.permutations import Permutation
+from sympy.core.symbol import symbols
+from sympy.matrices import Matrix
+from sympy.utilities.iterables import variations, rotate_left
+
+
+def symmetric(n):
+    """
+    Generates the symmetric group of order n, Sn.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import symmetric
+    >>> list(symmetric(3))
+    [(2), (1 2), (2)(0 1), (0 1 2), (0 2 1), (0 2)]
+    """
+    yield from (Permutation(perm) for perm in variations(range(n), n))
+
+
+def cyclic(n):
+    """
+    Generates the cyclic group of order n, Cn.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import cyclic
+    >>> list(cyclic(5))
+    [(4), (0 1 2 3 4), (0 2 4 1 3),
+     (0 3 1 4 2), (0 4 3 2 1)]
+
+    See Also
+    ========
+
+    dihedral
+    """
+    gen = list(range(n))
+    for i in range(n):
+        yield Permutation(gen)
+        gen = rotate_left(gen, 1)
+
+
+def alternating(n):
+    """
+    Generates the alternating group of order n, An.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import alternating
+    >>> list(alternating(3))
+    [(2), (0 1 2), (0 2 1)]
+    """
+    for perm in variations(range(n), n):
+        p = Permutation(perm)
+        if p.is_even:
+            yield p
+
+
+def dihedral(n):
+    """
+    Generates the dihedral group of order 2n, Dn.
+
+    The result is given as a subgroup of Sn, except for the special cases n=1
+    (the group S2) and n=2 (the Klein 4-group) where that's not possible
+    and embeddings in S2 and S4 respectively are given.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.generators import dihedral
+    >>> list(dihedral(3))
+    [(2), (0 2), (0 1 2), (1 2), (0 2 1), (2)(0 1)]
+
+    See Also
+    ========
+
+    cyclic
+    """
+    if n == 1:
+        yield Permutation([0, 1])
+        yield Permutation([1, 0])
+    elif n == 2:
+        yield Permutation([0, 1, 2, 3])
+        yield Permutation([1, 0, 3, 2])
+        yield Permutation([2, 3, 0, 1])
+        yield Permutation([3, 2, 1, 0])
+    else:
+        gen = list(range(n))
+        for i in range(n):
+            yield Permutation(gen)
+            yield Permutation(gen[::-1])
+            gen = rotate_left(gen, 1)
+
+
+def rubik_cube_generators():
+    """Return the permutations of the 3x3 Rubik's cube, see
+    https://www.gap-system.org/Doc/Examples/rubik.html
+    """
+    a = [
+        [(1, 3, 8, 6), (2, 5, 7, 4), (9, 33, 25, 17), (10, 34, 26, 18),
+         (11, 35, 27, 19)],
+        [(9, 11, 16, 14), (10, 13, 15, 12), (1, 17, 41, 40), (4, 20, 44, 37),
+         (6, 22, 46, 35)],
+        [(17, 19, 24, 22), (18, 21, 23, 20), (6, 25, 43, 16), (7, 28, 42, 13),
+         (8, 30, 41, 11)],
+        [(25, 27, 32, 30), (26, 29, 31, 28), (3, 38, 43, 19), (5, 36, 45, 21),
+         (8, 33, 48, 24)],
+        [(33, 35, 40, 38), (34, 37, 39, 36), (3, 9, 46, 32), (2, 12, 47, 29),
+         (1, 14, 48, 27)],
+        [(41, 43, 48, 46), (42, 45, 47, 44), (14, 22, 30, 38),
+         (15, 23, 31, 39), (16, 24, 32, 40)]
+    ]
+    return [Permutation([[i - 1 for i in xi] for xi in x], size=48) for x in a]
+
+
+def rubik(n):
+    """Return permutations for an nxn Rubik's cube.
+
+    Permutations returned are for rotation of each of the slice
+    from the face up to the last face for each of the 3 sides (in this order):
+    front, right and bottom. Hence, the first n - 1 permutations are for the
+    slices from the front.
+    """
+
+    if n < 2:
+        raise ValueError('dimension of cube must be > 1')
+
+    # 1-based reference to rows and columns in Matrix
+    def getr(f, i):
+        return faces[f].col(n - i)
+
+    def getl(f, i):
+        return faces[f].col(i - 1)
+
+    def getu(f, i):
+        return faces[f].row(i - 1)
+
+    def getd(f, i):
+        return faces[f].row(n - i)
+
+    def setr(f, i, s):
+        faces[f][:, n - i] = Matrix(n, 1, s)
+
+    def setl(f, i, s):
+        faces[f][:, i - 1] = Matrix(n, 1, s)
+
+    def setu(f, i, s):
+        faces[f][i - 1, :] = Matrix(1, n, s)
+
+    def setd(f, i, s):
+        faces[f][n - i, :] = Matrix(1, n, s)
+
+    # motion of a single face
+    def cw(F, r=1):
+        for _ in range(r):
+            face = faces[F]
+            rv = []
+            for c in range(n):
+                for r in range(n - 1, -1, -1):
+                    rv.append(face[r, c])
+            faces[F] = Matrix(n, n, rv)
+
+    def ccw(F):
+        cw(F, 3)
+
+    # motion of plane i from the F side;
+    # fcw(0) moves the F face, fcw(1) moves the plane
+    # just behind the front face, etc...
+    def fcw(i, r=1):
+        for _ in range(r):
+            if i == 0:
+                cw(F)
+            i += 1
+            temp = getr(L, i)
+            setr(L, i, list(getu(D, i)))
+            setu(D, i, list(reversed(getl(R, i))))
+            setl(R, i, list(getd(U, i)))
+            setd(U, i, list(reversed(temp)))
+            i -= 1
+
+    def fccw(i):
+        fcw(i, 3)
+
+    # motion of the entire cube from the F side
+    def FCW(r=1):
+        for _ in range(r):
+            cw(F)
+            ccw(B)
+            cw(U)
+            t = faces[U]
+            cw(L)
+            faces[U] = faces[L]
+            cw(D)
+            faces[L] = faces[D]
+            cw(R)
+            faces[D] = faces[R]
+            faces[R] = t
+
+    def FCCW():
+        FCW(3)
+
+    # motion of the entire cube from the U side
+    def UCW(r=1):
+        for _ in range(r):
+            cw(U)
+            ccw(D)
+            t = faces[F]
+            faces[F] = faces[R]
+            faces[R] = faces[B]
+            faces[B] = faces[L]
+            faces[L] = t
+
+    def UCCW():
+        UCW(3)
+
+    # defining the permutations for the cube
+
+    U, F, R, B, L, D = names = symbols('U, F, R, B, L, D')
+
+    # the faces are represented by nxn matrices
+    faces = {}
+    count = 0
+    for fi in range(6):
+        f = []
+        for a in range(n**2):
+            f.append(count)
+            count += 1
+        faces[names[fi]] = Matrix(n, n, f)
+
+    # this will either return the value of the current permutation
+    # (show != 1) or else append the permutation to the group, g
+    def perm(show=0):
+        # add perm to the list of perms
+        p = []
+        for f in names:
+            p.extend(faces[f])
+        if show:
+            return p
+        g.append(Permutation(p))
+
+    g = []  # container for the group's permutations
+    I = list(range(6*n**2))  # the identity permutation used for checking
+
+    # define permutations corresponding to cw rotations of the planes
+    # up TO the last plane from that direction; by not including the
+    # last plane, the orientation of the cube is maintained.
+
+    # F slices
+    for i in range(n - 1):
+        fcw(i)
+        perm()
+        fccw(i)  # restore
+    assert perm(1) == I
+
+    # R slices
+    # bring R to front
+    UCW()
+    for i in range(n - 1):
+        fcw(i)
+        # put it back in place
+        UCCW()
+        # record
+        perm()
+        # restore
+        # bring face to front
+        UCW()
+        fccw(i)
+    # restore
+    UCCW()
+    assert perm(1) == I
+
+    # D slices
+    # bring up bottom
+    FCW()
+    UCCW()
+    FCCW()
+    for i in range(n - 1):
+        # turn strip
+        fcw(i)
+        # put bottom back on the bottom
+        FCW()
+        UCW()
+        FCCW()
+        # record
+        perm()
+        # restore
+        # bring up bottom
+        FCW()
+        UCCW()
+        FCCW()
+        # turn strip
+        fccw(i)
+    # put bottom back on the bottom
+    FCW()
+    UCW()
+    FCCW()
+    assert perm(1) == I
+
+    return g
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/graycode.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/graycode.py
new file mode 100644
index 0000000000000000000000000000000000000000..930fd337862a70e920a985947d74375b27741293
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/graycode.py
@@ -0,0 +1,430 @@
+from sympy.core import Basic, Integer
+
+import random
+
+
+class GrayCode(Basic):
+    """
+    A Gray code is essentially a Hamiltonian walk on
+    a n-dimensional cube with edge length of one.
+    The vertices of the cube are represented by vectors
+    whose values are binary. The Hamilton walk visits
+    each vertex exactly once. The Gray code for a 3d
+    cube is ['000','100','110','010','011','111','101',
+    '001'].
+
+    A Gray code solves the problem of sequentially
+    generating all possible subsets of n objects in such
+    a way that each subset is obtained from the previous
+    one by either deleting or adding a single object.
+    In the above example, 1 indicates that the object is
+    present, and 0 indicates that its absent.
+
+    Gray codes have applications in statistics as well when
+    we want to compute various statistics related to subsets
+    in an efficient manner.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import GrayCode
+    >>> a = GrayCode(3)
+    >>> list(a.generate_gray())
+    ['000', '001', '011', '010', '110', '111', '101', '100']
+    >>> a = GrayCode(4)
+    >>> list(a.generate_gray())
+    ['0000', '0001', '0011', '0010', '0110', '0111', '0101', '0100', \
+    '1100', '1101', '1111', '1110', '1010', '1011', '1001', '1000']
+
+    References
+    ==========
+
+    .. [1] Nijenhuis,A. and Wilf,H.S.(1978).
+           Combinatorial Algorithms. Academic Press.
+    .. [2] Knuth, D. (2011). The Art of Computer Programming, Vol 4
+           Addison Wesley
+
+
+    """
+
+    _skip = False
+    _current = 0
+    _rank = None
+
+    def __new__(cls, n, *args, **kw_args):
+        """
+        Default constructor.
+
+        It takes a single argument ``n`` which gives the dimension of the Gray
+        code. The starting Gray code string (``start``) or the starting ``rank``
+        may also be given; the default is to start at rank = 0 ('0...0').
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3)
+        >>> a
+        GrayCode(3)
+        >>> a.n
+        3
+
+        >>> a = GrayCode(3, start='100')
+        >>> a.current
+        '100'
+
+        >>> a = GrayCode(4, rank=4)
+        >>> a.current
+        '0110'
+        >>> a.rank
+        4
+
+        """
+        if n < 1 or int(n) != n:
+            raise ValueError(
+                'Gray code dimension must be a positive integer, not %i' % n)
+        n = Integer(n)
+        args = (n,) + args
+        obj = Basic.__new__(cls, *args)
+        if 'start' in kw_args:
+            obj._current = kw_args["start"]
+            if len(obj._current) > n:
+                raise ValueError('Gray code start has length %i but '
+                'should not be greater than %i' % (len(obj._current), n))
+        elif 'rank' in kw_args:
+            if int(kw_args["rank"]) != kw_args["rank"]:
+                raise ValueError('Gray code rank must be a positive integer, '
+                'not %i' % kw_args["rank"])
+            obj._rank = int(kw_args["rank"]) % obj.selections
+            obj._current = obj.unrank(n, obj._rank)
+        return obj
+
+    def next(self, delta=1):
+        """
+        Returns the Gray code a distance ``delta`` (default = 1) from the
+        current value in canonical order.
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3, start='110')
+        >>> a.next().current
+        '111'
+        >>> a.next(-1).current
+        '010'
+        """
+        return GrayCode(self.n, rank=(self.rank + delta) % self.selections)
+
+    @property
+    def selections(self):
+        """
+        Returns the number of bit vectors in the Gray code.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3)
+        >>> a.selections
+        8
+        """
+        return 2**self.n
+
+    @property
+    def n(self):
+        """
+        Returns the dimension of the Gray code.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(5)
+        >>> a.n
+        5
+        """
+        return self.args[0]
+
+    def generate_gray(self, **hints):
+        """
+        Generates the sequence of bit vectors of a Gray Code.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3)
+        >>> list(a.generate_gray())
+        ['000', '001', '011', '010', '110', '111', '101', '100']
+        >>> list(a.generate_gray(start='011'))
+        ['011', '010', '110', '111', '101', '100']
+        >>> list(a.generate_gray(rank=4))
+        ['110', '111', '101', '100']
+
+        See Also
+        ========
+
+        skip
+
+        References
+        ==========
+
+        .. [1] Knuth, D. (2011). The Art of Computer Programming,
+               Vol 4, Addison Wesley
+
+        """
+        bits = self.n
+        start = None
+        if "start" in hints:
+            start = hints["start"]
+        elif "rank" in hints:
+            start = GrayCode.unrank(self.n, hints["rank"])
+        if start is not None:
+            self._current = start
+        current = self.current
+        graycode_bin = gray_to_bin(current)
+        if len(graycode_bin) > self.n:
+            raise ValueError('Gray code start has length %i but should '
+            'not be greater than %i' % (len(graycode_bin), bits))
+        self._current = int(current, 2)
+        graycode_int = int(''.join(graycode_bin), 2)
+        for i in range(graycode_int, 1 << bits):
+            if self._skip:
+                self._skip = False
+            else:
+                yield self.current
+            bbtc = (i ^ (i + 1))
+            gbtc = (bbtc ^ (bbtc >> 1))
+            self._current = (self._current ^ gbtc)
+        self._current = 0
+
+    def skip(self):
+        """
+        Skips the bit generation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3)
+        >>> for i in a.generate_gray():
+        ...     if i == '010':
+        ...         a.skip()
+        ...     print(i)
+        ...
+        000
+        001
+        011
+        010
+        111
+        101
+        100
+
+        See Also
+        ========
+
+        generate_gray
+        """
+        self._skip = True
+
+    @property
+    def rank(self):
+        """
+        Ranks the Gray code.
+
+        A ranking algorithm determines the position (or rank)
+        of a combinatorial object among all the objects w.r.t.
+        a given order. For example, the 4 bit binary reflected
+        Gray code (BRGC) '0101' has a rank of 6 as it appears in
+        the 6th position in the canonical ordering of the family
+        of 4 bit Gray codes.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> a = GrayCode(3)
+        >>> list(a.generate_gray())
+        ['000', '001', '011', '010', '110', '111', '101', '100']
+        >>> GrayCode(3, start='100').rank
+        7
+        >>> GrayCode(3, rank=7).current
+        '100'
+
+        See Also
+        ========
+
+        unrank
+
+        References
+        ==========
+
+        .. [1] https://web.archive.org/web/20200224064753/http://statweb.stanford.edu/~susan/courses/s208/node12.html
+
+        """
+        if self._rank is None:
+            self._rank = int(gray_to_bin(self.current), 2)
+        return self._rank
+
+    @property
+    def current(self):
+        """
+        Returns the currently referenced Gray code as a bit string.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> GrayCode(3, start='100').current
+        '100'
+        """
+        rv = self._current or '0'
+        if not isinstance(rv, str):
+            rv = bin(rv)[2:]
+        return rv.rjust(self.n, '0')
+
+    @classmethod
+    def unrank(self, n, rank):
+        """
+        Unranks an n-bit sized Gray code of rank k. This method exists
+        so that a derivative GrayCode class can define its own code of
+        a given rank.
+
+        The string here is generated in reverse order to allow for tail-call
+        optimization.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import GrayCode
+        >>> GrayCode(5, rank=3).current
+        '00010'
+        >>> GrayCode.unrank(5, 3)
+        '00010'
+
+        See Also
+        ========
+
+        rank
+        """
+        def _unrank(k, n):
+            if n == 1:
+                return str(k % 2)
+            m = 2**(n - 1)
+            if k < m:
+                return '0' + _unrank(k, n - 1)
+            return '1' + _unrank(m - (k % m) - 1, n - 1)
+        return _unrank(rank, n)
+
+
+def random_bitstring(n):
+    """
+    Generates a random bitlist of length n.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.graycode import random_bitstring
+    >>> random_bitstring(3) # doctest: +SKIP
+    100
+    """
+    return ''.join([random.choice('01') for i in range(n)])
+
+
+def gray_to_bin(bin_list):
+    """
+    Convert from Gray coding to binary coding.
+
+    We assume big endian encoding.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.graycode import gray_to_bin
+    >>> gray_to_bin('100')
+    '111'
+
+    See Also
+    ========
+
+    bin_to_gray
+    """
+    b = [bin_list[0]]
+    for i in range(1, len(bin_list)):
+        b += str(int(b[i - 1] != bin_list[i]))
+    return ''.join(b)
+
+
+def bin_to_gray(bin_list):
+    """
+    Convert from binary coding to gray coding.
+
+    We assume big endian encoding.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.graycode import bin_to_gray
+    >>> bin_to_gray('111')
+    '100'
+
+    See Also
+    ========
+
+    gray_to_bin
+    """
+    b = [bin_list[0]]
+    for i in range(1, len(bin_list)):
+        b += str(int(bin_list[i]) ^ int(bin_list[i - 1]))
+    return ''.join(b)
+
+
+def get_subset_from_bitstring(super_set, bitstring):
+    """
+    Gets the subset defined by the bitstring.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.graycode import get_subset_from_bitstring
+    >>> get_subset_from_bitstring(['a', 'b', 'c', 'd'], '0011')
+    ['c', 'd']
+    >>> get_subset_from_bitstring(['c', 'a', 'c', 'c'], '1100')
+    ['c', 'a']
+
+    See Also
+    ========
+
+    graycode_subsets
+    """
+    if len(super_set) != len(bitstring):
+        raise ValueError("The sizes of the lists are not equal")
+    return [super_set[i] for i, j in enumerate(bitstring)
+            if bitstring[i] == '1']
+
+
+def graycode_subsets(gray_code_set):
+    """
+    Generates the subsets as enumerated by a Gray code.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.graycode import graycode_subsets
+    >>> list(graycode_subsets(['a', 'b', 'c']))
+    [[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'], \
+    ['a', 'c'], ['a']]
+    >>> list(graycode_subsets(['a', 'b', 'c', 'c']))
+    [[], ['c'], ['c', 'c'], ['c'], ['b', 'c'], ['b', 'c', 'c'], \
+    ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'], ['a', 'b', 'c', 'c'], \
+    ['a', 'b', 'c'], ['a', 'c'], ['a', 'c', 'c'], ['a', 'c'], ['a']]
+
+    See Also
+    ========
+
+    get_subset_from_bitstring
+    """
+    for bitstring in list(GrayCode(len(gray_code_set)).generate_gray()):
+        yield get_subset_from_bitstring(gray_code_set, bitstring)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_constructs.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_constructs.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5c16ec254191646b26eee869763e2926e187da5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_constructs.py
@@ -0,0 +1,61 @@
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+from sympy.utilities.iterables import uniq
+
+_af_new = Permutation._af_new
+
+
+def DirectProduct(*groups):
+    """
+    Returns the direct product of several groups as a permutation group.
+
+    Explanation
+    ===========
+
+    This is implemented much like the __mul__ procedure for taking the direct
+    product of two permutation groups, but the idea of shifting the
+    generators is realized in the case of an arbitrary number of groups.
+    A call to DirectProduct(G1, G2, ..., Gn) is generally expected to be faster
+    than a call to G1*G2*...*Gn (and thus the need for this algorithm).
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_constructs import DirectProduct
+    >>> from sympy.combinatorics.named_groups import CyclicGroup
+    >>> C = CyclicGroup(4)
+    >>> G = DirectProduct(C, C, C)
+    >>> G.order()
+    64
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.__mul__
+
+    """
+    degrees = []
+    gens_count = []
+    total_degree = 0
+    total_gens = 0
+    for group in groups:
+        current_deg = group.degree
+        current_num_gens = len(group.generators)
+        degrees.append(current_deg)
+        total_degree += current_deg
+        gens_count.append(current_num_gens)
+        total_gens += current_num_gens
+    array_gens = []
+    for i in range(total_gens):
+        array_gens.append(list(range(total_degree)))
+    current_gen = 0
+    current_deg = 0
+    for i in range(len(gens_count)):
+        for j in range(current_gen, current_gen + gens_count[i]):
+            gen = ((groups[i].generators)[j - current_gen]).array_form
+            array_gens[j][current_deg:current_deg + degrees[i]] = \
+                [x + current_deg for x in gen]
+        current_gen += gens_count[i]
+        current_deg += degrees[i]
+    perm_gens = list(uniq([_af_new(list(a)) for a in array_gens]))
+    return PermutationGroup(perm_gens, dups=False)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_numbers.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..8099dfc2ed8a6943aa1261f9374ed84f0ad3c522
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/group_numbers.py
@@ -0,0 +1,294 @@
+from itertools import chain, combinations
+
+from sympy.external.gmpy import gcd
+from sympy.ntheory.factor_ import factorint
+from sympy.utilities.misc import as_int
+
+
+def _is_nilpotent_number(factors: dict) -> bool:
+    """ Check whether `n` is a nilpotent number.
+    Note that ``factors`` is a prime factorization of `n`.
+
+    This is a low-level helper for ``is_nilpotent_number``, for internal use.
+    """
+    for p in factors.keys():
+        for q, e in factors.items():
+            # We want to calculate
+            # any(pow(q, k, p) == 1 for k in range(1, e + 1))
+            m = 1
+            for _ in range(e):
+                m = m*q % p
+                if m == 1:
+                    return False
+    return True
+
+
+def is_nilpotent_number(n) -> bool:
+    """
+    Check whether `n` is a nilpotent number. A number `n` is said to be
+    nilpotent if and only if every finite group of order `n` is nilpotent.
+    For more information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_nilpotent_number
+    >>> from sympy import randprime
+    >>> is_nilpotent_number(21)
+    False
+    >>> is_nilpotent_number(randprime(1, 30)**12)
+    True
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., Nilpotent Numbers,
+           The American Mathematical Monthly, 107(7), 631-634.
+    .. [2] https://oeis.org/A056867
+
+    """
+    n = as_int(n)
+    if n <= 0:
+        raise ValueError("n must be a positive integer, not %i" % n)
+    return _is_nilpotent_number(factorint(n))
+
+
+def is_abelian_number(n) -> bool:
+    """
+    Check whether `n` is an abelian number. A number `n` is said to be abelian
+    if and only if every finite group of order `n` is abelian. For more
+    information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_abelian_number
+    >>> from sympy import randprime
+    >>> is_abelian_number(4)
+    True
+    >>> is_abelian_number(randprime(1, 2000)**2)
+    True
+    >>> is_abelian_number(60)
+    False
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., Nilpotent Numbers,
+           The American Mathematical Monthly, 107(7), 631-634.
+    .. [2] https://oeis.org/A051532
+
+    """
+    n = as_int(n)
+    if n <= 0:
+        raise ValueError("n must be a positive integer, not %i" % n)
+    factors = factorint(n)
+    return all(e < 3 for e in factors.values()) and _is_nilpotent_number(factors)
+
+
+def is_cyclic_number(n) -> bool:
+    """
+    Check whether `n` is a cyclic number. A number `n` is said to be cyclic
+    if and only if every finite group of order `n` is cyclic. For more
+    information see [1]_.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import is_cyclic_number
+    >>> from sympy import randprime
+    >>> is_cyclic_number(15)
+    True
+    >>> is_cyclic_number(randprime(1, 2000)**2)
+    False
+    >>> is_cyclic_number(4)
+    False
+
+    References
+    ==========
+
+    .. [1] Pakianathan, J., Shankar, K., Nilpotent Numbers,
+           The American Mathematical Monthly, 107(7), 631-634.
+    .. [2] https://oeis.org/A003277
+
+    """
+    n = as_int(n)
+    if n <= 0:
+        raise ValueError("n must be a positive integer, not %i" % n)
+    factors = factorint(n)
+    return all(e == 1 for e in factors.values()) and _is_nilpotent_number(factors)
+
+
+def _holder_formula(prime_factors):
+    r""" Number of groups of order `n`.
+    where `n` is squarefree and its prime factors are ``prime_factors``.
+    i.e., ``n == math.prod(prime_factors)``
+
+    Explanation
+    ===========
+
+    When `n` is squarefree, the number of groups of order `n` is expressed by
+
+    .. math ::
+        \sum_{d \mid n} \prod_p \frac{p^{c(p, d)} - 1}{p - 1}
+
+    where `n=de`, `p` is the prime factor of `e`,
+    and `c(p, d)` is the number of prime factors `q` of `d` such that `q \equiv 1 \pmod{p}` [2]_.
+
+    The formula is elegant, but can be improved when implemented as an algorithm.
+    Since `n` is assumed to be squarefree, the divisor `d` of `n` can be identified with the power set of prime factors.
+    We let `N` be the set of prime factors of `n`.
+    `F = \{p \in N : \forall q \in N, q \not\equiv 1 \pmod{p} \}, M = N \setminus F`, we have the following.
+
+    .. math ::
+        \sum_{d \in 2^{M}} \prod_{p \in M \setminus d} \frac{p^{c(p, F \cup d)} - 1}{p - 1}
+
+    Practically, many prime factors are expected to be members of `F`, thus reducing computation time.
+
+    Parameters
+    ==========
+
+    prime_factors : set
+        The set of prime factors of ``n``. where `n` is squarefree.
+
+    Returns
+    =======
+
+    int : Number of groups of order ``n``
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import _holder_formula
+    >>> _holder_formula({2}) # n = 2
+    1
+    >>> _holder_formula({2, 3}) # n = 2*3 = 6
+    2
+
+    See Also
+    ========
+
+    groups_count
+
+    References
+    ==========
+
+    .. [1] Otto Holder, Die Gruppen der Ordnungen p^3, pq^2, pqr, p^4,
+           Math. Ann. 43 pp. 301-412 (1893).
+           http://dx.doi.org/10.1007/BF01443651
+    .. [2] John H. Conway, Heiko Dietrich and E.A. O'Brien,
+           Counting groups: gnus, moas and other exotica
+           The Mathematical Intelligencer 30, 6-15 (2008)
+           https://doi.org/10.1007/BF02985731
+
+    """
+    F = {p for p in prime_factors if all(q % p != 1 for q in prime_factors)}
+    M = prime_factors - F
+
+    s = 0
+    powerset = chain.from_iterable(combinations(M, r) for r in range(len(M)+1))
+    for ps in powerset:
+        ps = set(ps)
+        prod = 1
+        for p in M - ps:
+            c = len([q for q in F | ps if q % p == 1])
+            prod *= (p**c - 1) // (p - 1)
+            if not prod:
+                break
+        s += prod
+    return s
+
+
+def groups_count(n):
+    r""" Number of groups of order `n`.
+    In [1]_, ``gnu(n)`` is given, so we follow this notation here as well.
+
+    Parameters
+    ==========
+
+    n : Integer
+        ``n`` is a positive integer
+
+    Returns
+    =======
+
+    int : ``gnu(n)``
+
+    Raises
+    ======
+
+    ValueError
+        Number of groups of order ``n`` is unknown or not implemented.
+        For example, gnu(`2^{11}`) is not yet known.
+        On the other hand, gnu(99) is known to be 2,
+        but this has not yet been implemented in this function.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.group_numbers import groups_count
+    >>> groups_count(3) # There is only one cyclic group of order 3
+    1
+    >>> # There are two groups of order 10: the cyclic group and the dihedral group
+    >>> groups_count(10)
+    2
+
+    See Also
+    ========
+
+    is_cyclic_number
+        `n` is cyclic iff gnu(n) = 1
+
+    References
+    ==========
+
+    .. [1] John H. Conway, Heiko Dietrich and E.A. O'Brien,
+           Counting groups: gnus, moas and other exotica
+           The Mathematical Intelligencer 30, 6-15 (2008)
+           https://doi.org/10.1007/BF02985731
+    .. [2] https://oeis.org/A000001
+
+    """
+    n = as_int(n)
+    if n <= 0:
+        raise ValueError("n must be a positive integer, not %i" % n)
+    factors = factorint(n)
+    if len(factors) == 1:
+        (p, e) = list(factors.items())[0]
+        if p == 2:
+            A000679 = [1, 1, 2, 5, 14, 51, 267, 2328, 56092, 10494213, 49487367289]
+            if e < len(A000679):
+                return A000679[e]
+        if p == 3:
+            A090091 = [1, 1, 2, 5, 15, 67, 504, 9310, 1396077, 5937876645]
+            if e < len(A090091):
+                return A090091[e]
+        if e <= 2: # gnu(p) = 1, gnu(p**2) = 2
+            return e
+        if e == 3: # gnu(p**3) = 5
+            return 5
+        if e == 4: # if p is an odd prime, gnu(p**4) = 15
+            return 15
+        if e == 5: # if p >= 5, gnu(p**5) is expressed by the following equation
+            return 61 + 2*p + 2*gcd(p-1, 3) + gcd(p-1, 4)
+        if e == 6: # if p >= 6, gnu(p**6) is expressed by the following equation
+            return 3*p**2 + 39*p + 344 +\
+                  24*gcd(p-1, 3) + 11*gcd(p-1, 4) + 2*gcd(p-1, 5)
+        if e == 7: # if p >= 7, gnu(p**7) is expressed by the following equation
+            if p == 5:
+                return 34297
+            return 3*p**5 + 12*p**4 + 44*p**3 + 170*p**2 + 707*p + 2455 +\
+                  (4*p**2 + 44*p + 291)*gcd(p-1, 3) + (p**2 + 19*p + 135)*gcd(p-1, 4) + \
+                  (3*p + 31)*gcd(p-1, 5) + 4*gcd(p-1, 7) + 5*gcd(p-1, 8) + gcd(p-1, 9)
+    if any(e > 1 for e in factors.values()): # n is not squarefree
+        # some known values for small n that have more than 1 factor and are not square free (https://oeis.org/A000001)
+        small = {12: 5, 18: 5, 20: 5, 24: 15, 28: 4, 36: 14, 40: 14, 44: 4, 45: 2, 48: 52,
+                50: 5, 52: 5, 54: 15, 56: 13, 60: 13, 63: 4, 68: 5, 72: 50, 75: 3, 76: 4,
+                80: 52, 84: 15, 88: 12, 90: 10, 92: 4}
+        if n in small:
+            return small[n]
+        raise ValueError("Number of groups of order n is unknown or not implemented")
+    if len(factors) == 2: # n is squarefree semiprime
+        p, q = sorted(factors.keys())
+        return 2 if q % p == 1 else 1
+    return _holder_formula(set(factors.keys()))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/homomorphisms.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/homomorphisms.py
new file mode 100644
index 0000000000000000000000000000000000000000..256f56b3aa7c5404d332f42e37d4f1117ea81db7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/homomorphisms.py
@@ -0,0 +1,549 @@
+import itertools
+from sympy.combinatorics.fp_groups import FpGroup, FpSubgroup, simplify_presentation
+from sympy.combinatorics.free_groups import FreeGroup
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.core.intfunc import igcd
+from sympy.functions.combinatorial.numbers import totient
+from sympy.core.singleton import S
+
+class GroupHomomorphism:
+    '''
+    A class representing group homomorphisms. Instantiate using `homomorphism()`.
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B. and O'Brien, E. (2005). Handbook of computational group theory.
+
+    '''
+
+    def __init__(self, domain, codomain, images):
+        self.domain = domain
+        self.codomain = codomain
+        self.images = images
+        self._inverses = None
+        self._kernel = None
+        self._image = None
+
+    def _invs(self):
+        '''
+        Return a dictionary with `{gen: inverse}` where `gen` is a rewriting
+        generator of `codomain` (e.g. strong generator for permutation groups)
+        and `inverse` is an element of its preimage
+
+        '''
+        image = self.image()
+        inverses = {}
+        for k in list(self.images.keys()):
+            v = self.images[k]
+            if not (v in inverses
+                    or v.is_identity):
+                inverses[v] = k
+        if isinstance(self.codomain, PermutationGroup):
+            gens = image.strong_gens
+        else:
+            gens = image.generators
+        for g in gens:
+            if g in inverses or g.is_identity:
+                continue
+            w = self.domain.identity
+            if isinstance(self.codomain, PermutationGroup):
+                parts = image._strong_gens_slp[g][::-1]
+            else:
+                parts = g
+            for s in parts:
+                if s in inverses:
+                    w = w*inverses[s]
+                else:
+                    w = w*inverses[s**-1]**-1
+            inverses[g] = w
+
+        return inverses
+
+    def invert(self, g):
+        '''
+        Return an element of the preimage of ``g`` or of each element
+        of ``g`` if ``g`` is a list.
+
+        Explanation
+        ===========
+
+        If the codomain is an FpGroup, the inverse for equal
+        elements might not always be the same unless the FpGroup's
+        rewriting system is confluent. However, making a system
+        confluent can be time-consuming. If it's important, try
+        `self.codomain.make_confluent()` first.
+
+        '''
+        from sympy.combinatorics import Permutation
+        from sympy.combinatorics.free_groups import FreeGroupElement
+        if isinstance(g, (Permutation, FreeGroupElement)):
+            if isinstance(self.codomain, FpGroup):
+                g = self.codomain.reduce(g)
+            if self._inverses is None:
+                self._inverses = self._invs()
+            image = self.image()
+            w = self.domain.identity
+            if isinstance(self.codomain, PermutationGroup):
+                gens = image.generator_product(g)[::-1]
+            else:
+                gens = g
+            # the following can't be "for s in gens:"
+            # because that would be equivalent to
+            # "for s in gens.array_form:" when g is
+            # a FreeGroupElement. On the other hand,
+            # when you call gens by index, the generator
+            # (or inverse) at position i is returned.
+            for i in range(len(gens)):
+                s = gens[i]
+                if s.is_identity:
+                    continue
+                if s in self._inverses:
+                    w = w*self._inverses[s]
+                else:
+                    w = w*self._inverses[s**-1]**-1
+            return w
+        elif isinstance(g, list):
+            return [self.invert(e) for e in g]
+
+    def kernel(self):
+        '''
+        Compute the kernel of `self`.
+
+        '''
+        if self._kernel is None:
+            self._kernel = self._compute_kernel()
+        return self._kernel
+
+    def _compute_kernel(self):
+        G = self.domain
+        G_order = G.order()
+        if G_order is S.Infinity:
+            raise NotImplementedError(
+                "Kernel computation is not implemented for infinite groups")
+        gens = []
+        if isinstance(G, PermutationGroup):
+            K = PermutationGroup(G.identity)
+        else:
+            K = FpSubgroup(G, gens, normal=True)
+        i = self.image().order()
+        while K.order()*i != G_order:
+            r = G.random()
+            k = r*self.invert(self(r))**-1
+            if k not in K:
+                gens.append(k)
+                if isinstance(G, PermutationGroup):
+                    K = PermutationGroup(gens)
+                else:
+                    K = FpSubgroup(G, gens, normal=True)
+        return K
+
+    def image(self):
+        '''
+        Compute the image of `self`.
+
+        '''
+        if self._image is None:
+            values = list(set(self.images.values()))
+            if isinstance(self.codomain, PermutationGroup):
+                self._image = self.codomain.subgroup(values)
+            else:
+                self._image = FpSubgroup(self.codomain, values)
+        return self._image
+
+    def _apply(self, elem):
+        '''
+        Apply `self` to `elem`.
+
+        '''
+        if elem not in self.domain:
+            if isinstance(elem, (list, tuple)):
+                return [self._apply(e) for e in elem]
+            raise ValueError("The supplied element does not belong to the domain")
+        if elem.is_identity:
+            return self.codomain.identity
+        else:
+            images = self.images
+            value = self.codomain.identity
+            if isinstance(self.domain, PermutationGroup):
+                gens = self.domain.generator_product(elem, original=True)
+                for g in gens:
+                    if g in self.images:
+                        value = images[g]*value
+                    else:
+                        value = images[g**-1]**-1*value
+            else:
+                i = 0
+                for _, p in elem.array_form:
+                    if p < 0:
+                        g = elem[i]**-1
+                    else:
+                        g = elem[i]
+                    value = value*images[g]**p
+                    i += abs(p)
+        return value
+
+    def __call__(self, elem):
+        return self._apply(elem)
+
+    def is_injective(self):
+        '''
+        Check if the homomorphism is injective
+
+        '''
+        return self.kernel().order() == 1
+
+    def is_surjective(self):
+        '''
+        Check if the homomorphism is surjective
+
+        '''
+        im = self.image().order()
+        oth = self.codomain.order()
+        if im is S.Infinity and oth is S.Infinity:
+            return None
+        else:
+            return im == oth
+
+    def is_isomorphism(self):
+        '''
+        Check if `self` is an isomorphism.
+
+        '''
+        return self.is_injective() and self.is_surjective()
+
+    def is_trivial(self):
+        '''
+        Check is `self` is a trivial homomorphism, i.e. all elements
+        are mapped to the identity.
+
+        '''
+        return self.image().order() == 1
+
+    def compose(self, other):
+        '''
+        Return the composition of `self` and `other`, i.e.
+        the homomorphism phi such that for all g in the domain
+        of `other`, phi(g) = self(other(g))
+
+        '''
+        if not other.image().is_subgroup(self.domain):
+            raise ValueError("The image of `other` must be a subgroup of "
+                    "the domain of `self`")
+        images = {g: self(other(g)) for g in other.images}
+        return GroupHomomorphism(other.domain, self.codomain, images)
+
+    def restrict_to(self, H):
+        '''
+        Return the restriction of the homomorphism to the subgroup `H`
+        of the domain.
+
+        '''
+        if not isinstance(H, PermutationGroup) or not H.is_subgroup(self.domain):
+            raise ValueError("Given H is not a subgroup of the domain")
+        domain = H
+        images = {g: self(g) for g in H.generators}
+        return GroupHomomorphism(domain, self.codomain, images)
+
+    def invert_subgroup(self, H):
+        '''
+        Return the subgroup of the domain that is the inverse image
+        of the subgroup ``H`` of the homomorphism image
+
+        '''
+        if not H.is_subgroup(self.image()):
+            raise ValueError("Given H is not a subgroup of the image")
+        gens = []
+        P = PermutationGroup(self.image().identity)
+        for h in H.generators:
+            h_i = self.invert(h)
+            if h_i not in P:
+                gens.append(h_i)
+                P = PermutationGroup(gens)
+            for k in self.kernel().generators:
+                if k*h_i not in P:
+                    gens.append(k*h_i)
+                    P = PermutationGroup(gens)
+        return P
+
+def homomorphism(domain, codomain, gens, images=(), check=True):
+    '''
+    Create (if possible) a group homomorphism from the group ``domain``
+    to the group ``codomain`` defined by the images of the domain's
+    generators ``gens``. ``gens`` and ``images`` can be either lists or tuples
+    of equal sizes. If ``gens`` is a proper subset of the group's generators,
+    the unspecified generators will be mapped to the identity. If the
+    images are not specified, a trivial homomorphism will be created.
+
+    If the given images of the generators do not define a homomorphism,
+    an exception is raised.
+
+    If ``check`` is ``False``, do not check whether the given images actually
+    define a homomorphism.
+
+    '''
+    if not isinstance(domain, (PermutationGroup, FpGroup, FreeGroup)):
+        raise TypeError("The domain must be a group")
+    if not isinstance(codomain, (PermutationGroup, FpGroup, FreeGroup)):
+        raise TypeError("The codomain must be a group")
+
+    generators = domain.generators
+    if not all(g in generators for g in gens):
+        raise ValueError("The supplied generators must be a subset of the domain's generators")
+    if not all(g in codomain for g in images):
+        raise ValueError("The images must be elements of the codomain")
+
+    if images and len(images) != len(gens):
+        raise ValueError("The number of images must be equal to the number of generators")
+
+    gens = list(gens)
+    images = list(images)
+
+    images.extend([codomain.identity]*(len(generators)-len(images)))
+    gens.extend([g for g in generators if g not in gens])
+    images = dict(zip(gens,images))
+
+    if check and not _check_homomorphism(domain, codomain, images):
+        raise ValueError("The given images do not define a homomorphism")
+    return GroupHomomorphism(domain, codomain, images)
+
+def _check_homomorphism(domain, codomain, images):
+    """
+    Check that a given mapping of generators to images defines a homomorphism.
+
+    Parameters
+    ==========
+    domain : PermutationGroup, FpGroup, FreeGroup
+    codomain : PermutationGroup, FpGroup, FreeGroup
+    images : dict
+        The set of keys must be equal to domain.generators.
+        The values must be elements of the codomain.
+
+    """
+    pres = domain if hasattr(domain, 'relators') else domain.presentation()
+    rels = pres.relators
+    gens = pres.generators
+    symbols = [g.ext_rep[0] for g in gens]
+    symbols_to_domain_generators = dict(zip(symbols, domain.generators))
+    identity = codomain.identity
+
+    def _image(r):
+        w = identity
+        for symbol, power in r.array_form:
+            g = symbols_to_domain_generators[symbol]
+            w *= images[g]**power
+        return w
+
+    for r in rels:
+        if isinstance(codomain, FpGroup):
+            s = codomain.equals(_image(r), identity)
+            if s is None:
+                # only try to make the rewriting system
+                # confluent when it can't determine the
+                # truth of equality otherwise
+                success = codomain.make_confluent()
+                s = codomain.equals(_image(r), identity)
+                if s is None and not success:
+                    raise RuntimeError("Can't determine if the images "
+                        "define a homomorphism. Try increasing "
+                        "the maximum number of rewriting rules "
+                        "(group._rewriting_system.set_max(new_value); "
+                        "the current value is stored in group._rewriting"
+                        "_system.maxeqns)")
+        else:
+            s = _image(r).is_identity
+        if not s:
+            return False
+    return True
+
+def orbit_homomorphism(group, omega):
+    '''
+    Return the homomorphism induced by the action of the permutation
+    group ``group`` on the set ``omega`` that is closed under the action.
+
+    '''
+    from sympy.combinatorics import Permutation
+    from sympy.combinatorics.named_groups import SymmetricGroup
+    codomain = SymmetricGroup(len(omega))
+    identity = codomain.identity
+    omega = list(omega)
+    images = {g: identity*Permutation([omega.index(o^g) for o in omega]) for g in group.generators}
+    group._schreier_sims(base=omega)
+    H = GroupHomomorphism(group, codomain, images)
+    if len(group.basic_stabilizers) > len(omega):
+        H._kernel = group.basic_stabilizers[len(omega)]
+    else:
+        H._kernel = PermutationGroup([group.identity])
+    return H
+
+def block_homomorphism(group, blocks):
+    '''
+    Return the homomorphism induced by the action of the permutation
+    group ``group`` on the block system ``blocks``. The latter should be
+    of the same form as returned by the ``minimal_block`` method for
+    permutation groups, namely a list of length ``group.degree`` where
+    the i-th entry is a representative of the block i belongs to.
+
+    '''
+    from sympy.combinatorics import Permutation
+    from sympy.combinatorics.named_groups import SymmetricGroup
+
+    n = len(blocks)
+
+    # number the blocks; m is the total number,
+    # b is such that b[i] is the number of the block i belongs to,
+    # p is the list of length m such that p[i] is the representative
+    # of the i-th block
+    m = 0
+    p = []
+    b = [None]*n
+    for i in range(n):
+        if blocks[i] == i:
+            p.append(i)
+            b[i] = m
+            m += 1
+    for i in range(n):
+        b[i] = b[blocks[i]]
+
+    codomain = SymmetricGroup(m)
+    # the list corresponding to the identity permutation in codomain
+    identity = range(m)
+    images = {g: Permutation([b[p[i]^g] for i in identity]) for g in group.generators}
+    H = GroupHomomorphism(group, codomain, images)
+    return H
+
+def group_isomorphism(G, H, isomorphism=True):
+    '''
+    Compute an isomorphism between 2 given groups.
+
+    Parameters
+    ==========
+
+    G : A finite ``FpGroup`` or a ``PermutationGroup``.
+        First group.
+
+    H : A finite ``FpGroup`` or a ``PermutationGroup``
+        Second group.
+
+    isomorphism : bool
+        This is used to avoid the computation of homomorphism
+        when the user only wants to check if there exists
+        an isomorphism between the groups.
+
+    Returns
+    =======
+
+    If isomorphism = False -- Returns a boolean.
+    If isomorphism = True  -- Returns a boolean and an isomorphism between `G` and `H`.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import free_group, Permutation
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> from sympy.combinatorics.fp_groups import FpGroup
+    >>> from sympy.combinatorics.homomorphisms import group_isomorphism
+    >>> from sympy.combinatorics.named_groups import DihedralGroup, AlternatingGroup
+
+    >>> D = DihedralGroup(8)
+    >>> p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    >>> P = PermutationGroup(p)
+    >>> group_isomorphism(D, P)
+    (False, None)
+
+    >>> F, a, b = free_group("a, b")
+    >>> G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    >>> H = AlternatingGroup(4)
+    >>> (check, T) = group_isomorphism(G, H)
+    >>> check
+    True
+    >>> T(b*a*b**-1*a**-1*b**-1)
+    (0 2 3)
+
+    Notes
+    =====
+
+    Uses the approach suggested by Robert Tarjan to compute the isomorphism between two groups.
+    First, the generators of ``G`` are mapped to the elements of ``H`` and
+    we check if the mapping induces an isomorphism.
+
+    '''
+    if not isinstance(G, (PermutationGroup, FpGroup)):
+        raise TypeError("The group must be a PermutationGroup or an FpGroup")
+    if not isinstance(H, (PermutationGroup, FpGroup)):
+        raise TypeError("The group must be a PermutationGroup or an FpGroup")
+
+    if isinstance(G, FpGroup) and isinstance(H, FpGroup):
+        G = simplify_presentation(G)
+        H = simplify_presentation(H)
+        # Two infinite FpGroups with the same generators are isomorphic
+        # when the relators are same but are ordered differently.
+        if G.generators == H.generators and (G.relators).sort() == (H.relators).sort():
+            if not isomorphism:
+                return True
+            return (True, homomorphism(G, H, G.generators, H.generators))
+
+    #  `_H` is the permutation group isomorphic to `H`.
+    _H = H
+    g_order = G.order()
+    h_order = H.order()
+
+    if g_order is S.Infinity:
+        raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
+
+    if isinstance(H, FpGroup):
+        if h_order is S.Infinity:
+            raise NotImplementedError("Isomorphism methods are not implemented for infinite groups.")
+        _H, h_isomorphism = H._to_perm_group()
+
+    if (g_order != h_order) or (G.is_abelian != H.is_abelian):
+        if not isomorphism:
+            return False
+        return (False, None)
+
+    if not isomorphism:
+        # Two groups of the same cyclic numbered order
+        # are isomorphic to each other.
+        n = g_order
+        if (igcd(n, totient(n))) == 1:
+            return True
+
+    # Match the generators of `G` with subsets of `_H`
+    gens = list(G.generators)
+    for subset in itertools.permutations(_H, len(gens)):
+        images = list(subset)
+        images.extend([_H.identity]*(len(G.generators)-len(images)))
+        _images = dict(zip(gens,images))
+        if _check_homomorphism(G, _H, _images):
+            if isinstance(H, FpGroup):
+                images = h_isomorphism.invert(images)
+            T =  homomorphism(G, H, G.generators, images, check=False)
+            if T.is_isomorphism():
+                # It is a valid isomorphism
+                if not isomorphism:
+                    return True
+                return (True, T)
+
+    if not isomorphism:
+        return False
+    return (False, None)
+
+def is_isomorphic(G, H):
+    '''
+    Check if the groups are isomorphic to each other
+
+    Parameters
+    ==========
+
+    G : A finite ``FpGroup`` or a ``PermutationGroup``
+        First group.
+
+    H : A finite ``FpGroup`` or a ``PermutationGroup``
+        Second group.
+
+    Returns
+    =======
+
+    boolean
+    '''
+    return group_isomorphism(G, H, isomorphism=False)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/named_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/named_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..59f10c40ef716e3b644e00f936323e9f6936eb88
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/named_groups.py
@@ -0,0 +1,332 @@
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.permutations import Permutation
+
+_af_new = Permutation._af_new
+
+
+def AbelianGroup(*cyclic_orders):
+    """
+    Returns the direct product of cyclic groups with the given orders.
+
+    Explanation
+    ===========
+
+    According to the structure theorem for finite abelian groups ([1]),
+    every finite abelian group can be written as the direct product of
+    finitely many cyclic groups.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AbelianGroup
+    >>> AbelianGroup(3, 4)
+    PermutationGroup([
+            (6)(0 1 2),
+            (3 4 5 6)])
+    >>> _.is_group
+    True
+
+    See Also
+    ========
+
+    DirectProduct
+
+    References
+    ==========
+
+    .. [1] https://groupprops.subwiki.org/wiki/Structure_theorem_for_finitely_generated_abelian_groups
+
+    """
+    groups = []
+    degree = 0
+    order = 1
+    for size in cyclic_orders:
+        degree += size
+        order *= size
+        groups.append(CyclicGroup(size))
+    G = DirectProduct(*groups)
+    G._is_abelian = True
+    G._degree = degree
+    G._order = order
+
+    return G
+
+
+def AlternatingGroup(n):
+    """
+    Generates the alternating group on ``n`` elements as a permutation group.
+
+    Explanation
+    ===========
+
+    For ``n > 2``, the generators taken are ``(0 1 2), (0 1 2 ... n-1)`` for
+    ``n`` odd
+    and ``(0 1 2), (1 2 ... n-1)`` for ``n`` even (See [1], p.31, ex.6.9.).
+    After the group is generated, some of its basic properties are set.
+    The cases ``n = 1, 2`` are handled separately.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AlternatingGroup
+    >>> G = AlternatingGroup(4)
+    >>> G.is_group
+    True
+    >>> a = list(G.generate_dimino())
+    >>> len(a)
+    12
+    >>> all(perm.is_even for perm in a)
+    True
+
+    See Also
+    ========
+
+    SymmetricGroup, CyclicGroup, DihedralGroup
+
+    References
+    ==========
+
+    .. [1] Armstrong, M. "Groups and Symmetry"
+
+    """
+    # small cases are special
+    if n in (1, 2):
+        return PermutationGroup([Permutation([0])])
+
+    a = list(range(n))
+    a[0], a[1], a[2] = a[1], a[2], a[0]
+    gen1 = a
+    if n % 2:
+        a = list(range(1, n))
+        a.append(0)
+        gen2 = a
+    else:
+        a = list(range(2, n))
+        a.append(1)
+        a.insert(0, 0)
+        gen2 = a
+    gens = [gen1, gen2]
+    if gen1 == gen2:
+        gens = gens[:1]
+    G = PermutationGroup([_af_new(a) for a in gens], dups=False)
+
+    set_alternating_group_properties(G, n, n)
+    G._is_alt = True
+    return G
+
+
+def set_alternating_group_properties(G, n, degree):
+    """Set known properties of an alternating group. """
+    if n < 4:
+        G._is_abelian = True
+        G._is_nilpotent = True
+    else:
+        G._is_abelian = False
+        G._is_nilpotent = False
+    if n < 5:
+        G._is_solvable = True
+    else:
+        G._is_solvable = False
+    G._degree = degree
+    G._is_transitive = True
+    G._is_dihedral = False
+
+
+def CyclicGroup(n):
+    """
+    Generates the cyclic group of order ``n`` as a permutation group.
+
+    Explanation
+    ===========
+
+    The generator taken is the ``n``-cycle ``(0 1 2 ... n-1)``
+    (in cycle notation). After the group is generated, some of its basic
+    properties are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import CyclicGroup
+    >>> G = CyclicGroup(6)
+    >>> G.is_group
+    True
+    >>> G.order()
+    6
+    >>> list(G.generate_schreier_sims(af=True))
+    [[0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 0], [2, 3, 4, 5, 0, 1],
+    [3, 4, 5, 0, 1, 2], [4, 5, 0, 1, 2, 3], [5, 0, 1, 2, 3, 4]]
+
+    See Also
+    ========
+
+    SymmetricGroup, DihedralGroup, AlternatingGroup
+
+    """
+    a = list(range(1, n))
+    a.append(0)
+    gen = _af_new(a)
+    G = PermutationGroup([gen])
+
+    G._is_abelian = True
+    G._is_nilpotent = True
+    G._is_solvable = True
+    G._degree = n
+    G._is_transitive = True
+    G._order = n
+    G._is_dihedral = (n == 2)
+    return G
+
+
+def DihedralGroup(n):
+    r"""
+    Generates the dihedral group `D_n` as a permutation group.
+
+    Explanation
+    ===========
+
+    The dihedral group `D_n` is the group of symmetries of the regular
+    ``n``-gon. The generators taken are the ``n``-cycle ``a = (0 1 2 ... n-1)``
+    (a rotation of the ``n``-gon) and ``b = (0 n-1)(1 n-2)...``
+    (a reflection of the ``n``-gon) in cycle rotation. It is easy to see that
+    these satisfy ``a**n = b**2 = 1`` and ``bab = ~a`` so they indeed generate
+    `D_n` (See [1]). After the group is generated, some of its basic properties
+    are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> G = DihedralGroup(5)
+    >>> G.is_group
+    True
+    >>> a = list(G.generate_dimino())
+    >>> [perm.cyclic_form for perm in a]
+    [[], [[0, 1, 2, 3, 4]], [[0, 2, 4, 1, 3]],
+    [[0, 3, 1, 4, 2]], [[0, 4, 3, 2, 1]], [[0, 4], [1, 3]],
+    [[1, 4], [2, 3]], [[0, 1], [2, 4]], [[0, 2], [3, 4]],
+    [[0, 3], [1, 2]]]
+
+    See Also
+    ========
+
+    SymmetricGroup, CyclicGroup, AlternatingGroup
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dihedral_group
+
+    """
+    # small cases are special
+    if n == 1:
+        return PermutationGroup([Permutation([1, 0])])
+    if n == 2:
+        return PermutationGroup([Permutation([1, 0, 3, 2]),
+               Permutation([2, 3, 0, 1]), Permutation([3, 2, 1, 0])])
+
+    a = list(range(1, n))
+    a.append(0)
+    gen1 = _af_new(a)
+    a = list(range(n))
+    a.reverse()
+    gen2 = _af_new(a)
+    G = PermutationGroup([gen1, gen2])
+    # if n is a power of 2, group is nilpotent
+    if n & (n-1) == 0:
+        G._is_nilpotent = True
+    else:
+        G._is_nilpotent = False
+    G._is_dihedral = True
+    G._is_abelian = False
+    G._is_solvable = True
+    G._degree = n
+    G._is_transitive = True
+    G._order = 2*n
+    return G
+
+
+def SymmetricGroup(n):
+    """
+    Generates the symmetric group on ``n`` elements as a permutation group.
+
+    Explanation
+    ===========
+
+    The generators taken are the ``n``-cycle
+    ``(0 1 2 ... n-1)`` and the transposition ``(0 1)`` (in cycle notation).
+    (See [1]). After the group is generated, some of its basic properties
+    are set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import SymmetricGroup
+    >>> G = SymmetricGroup(4)
+    >>> G.is_group
+    True
+    >>> G.order()
+    24
+    >>> list(G.generate_schreier_sims(af=True))
+    [[0, 1, 2, 3], [1, 2, 3, 0], [2, 3, 0, 1], [3, 1, 2, 0], [0, 2, 3, 1],
+    [1, 3, 0, 2], [2, 0, 1, 3], [3, 2, 0, 1], [0, 3, 1, 2], [1, 0, 2, 3],
+    [2, 1, 3, 0], [3, 0, 1, 2], [0, 1, 3, 2], [1, 2, 0, 3], [2, 3, 1, 0],
+    [3, 1, 0, 2], [0, 2, 1, 3], [1, 3, 2, 0], [2, 0, 3, 1], [3, 2, 1, 0],
+    [0, 3, 2, 1], [1, 0, 3, 2], [2, 1, 0, 3], [3, 0, 2, 1]]
+
+    See Also
+    ========
+
+    CyclicGroup, DihedralGroup, AlternatingGroup
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Symmetric_group#Generators_and_relations
+
+    """
+    if n == 1:
+        G = PermutationGroup([Permutation([0])])
+    elif n == 2:
+        G = PermutationGroup([Permutation([1, 0])])
+    else:
+        a = list(range(1, n))
+        a.append(0)
+        gen1 = _af_new(a)
+        a = list(range(n))
+        a[0], a[1] = a[1], a[0]
+        gen2 = _af_new(a)
+        G = PermutationGroup([gen1, gen2])
+    set_symmetric_group_properties(G, n, n)
+    G._is_sym = True
+    return G
+
+
+def set_symmetric_group_properties(G, n, degree):
+    """Set known properties of a symmetric group. """
+    if n < 3:
+        G._is_abelian = True
+        G._is_nilpotent = True
+    else:
+        G._is_abelian = False
+        G._is_nilpotent = False
+    if n < 5:
+        G._is_solvable = True
+    else:
+        G._is_solvable = False
+    G._degree = degree
+    G._is_transitive = True
+    G._is_dihedral = (n in [2, 3])  # cf Landau's func and Stirling's approx
+
+
+def RubikGroup(n):
+    """Return a group of Rubik's cube generators
+
+    >>> from sympy.combinatorics.named_groups import RubikGroup
+    >>> RubikGroup(2).is_group
+    True
+    """
+    from sympy.combinatorics.generators import rubik
+    if n <= 1:
+        raise ValueError("Invalid cube. n has to be greater than 1")
+    return PermutationGroup(rubik(n))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/partitions.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/partitions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfe646baabbb5bf2350cba859a265ac32bbfaf53
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/partitions.py
@@ -0,0 +1,745 @@
+from sympy.core import Basic, Dict, sympify, Tuple
+from sympy.core.numbers import Integer
+from sympy.core.sorting import default_sort_key
+from sympy.core.sympify import _sympify
+from sympy.functions.combinatorial.numbers import bell
+from sympy.matrices import zeros
+from sympy.sets.sets import FiniteSet, Union
+from sympy.utilities.iterables import flatten, group
+from sympy.utilities.misc import as_int
+
+
+from collections import defaultdict
+
+
+class Partition(FiniteSet):
+    """
+    This class represents an abstract partition.
+
+    A partition is a set of disjoint sets whose union equals a given set.
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.partitions,
+    sympy.utilities.iterables.multiset_partitions
+    """
+
+    _rank = None
+    _partition = None
+
+    def __new__(cls, *partition):
+        """
+        Generates a new partition object.
+
+        This method also verifies if the arguments passed are
+        valid and raises a ValueError if they are not.
+
+        Examples
+        ========
+
+        Creating Partition from Python lists:
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3])
+        >>> a
+        Partition({3}, {1, 2})
+        >>> a.partition
+        [[1, 2], [3]]
+        >>> len(a)
+        2
+        >>> a.members
+        (1, 2, 3)
+
+        Creating Partition from Python sets:
+
+        >>> Partition({1, 2, 3}, {4, 5})
+        Partition({4, 5}, {1, 2, 3})
+
+        Creating Partition from SymPy finite sets:
+
+        >>> from sympy import FiniteSet
+        >>> a = FiniteSet(1, 2, 3)
+        >>> b = FiniteSet(4, 5)
+        >>> Partition(a, b)
+        Partition({4, 5}, {1, 2, 3})
+        """
+        args = []
+        dups = False
+        for arg in partition:
+            if isinstance(arg, list):
+                as_set = set(arg)
+                if len(as_set) < len(arg):
+                    dups = True
+                    break  # error below
+                arg = as_set
+            args.append(_sympify(arg))
+
+        if not all(isinstance(part, FiniteSet) for part in args):
+            raise ValueError(
+                "Each argument to Partition should be " \
+                "a list, set, or a FiniteSet")
+
+        # sort so we have a canonical reference for RGS
+        U = Union(*args)
+        if dups or len(U) < sum(len(arg) for arg in args):
+            raise ValueError("Partition contained duplicate elements.")
+
+        obj = FiniteSet.__new__(cls, *args)
+        obj.members = tuple(U)
+        obj.size = len(U)
+        return obj
+
+    def sort_key(self, order=None):
+        """Return a canonical key that can be used for sorting.
+
+        Ordering is based on the size and sorted elements of the partition
+        and ties are broken with the rank.
+
+        Examples
+        ========
+
+        >>> from sympy import default_sort_key
+        >>> from sympy.combinatorics import Partition
+        >>> from sympy.abc import x
+        >>> a = Partition([1, 2])
+        >>> b = Partition([3, 4])
+        >>> c = Partition([1, x])
+        >>> d = Partition(list(range(4)))
+        >>> l = [d, b, a + 1, a, c]
+        >>> l.sort(key=default_sort_key); l
+        [Partition({1, 2}), Partition({1}, {2}), Partition({1, x}), Partition({3, 4}), Partition({0, 1, 2, 3})]
+        """
+        if order is None:
+            members = self.members
+        else:
+            members = tuple(sorted(self.members,
+                             key=lambda w: default_sort_key(w, order)))
+        return tuple(map(default_sort_key, (self.size, members, self.rank)))
+
+    @property
+    def partition(self):
+        """Return partition as a sorted list of lists.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> Partition([1], [2, 3]).partition
+        [[1], [2, 3]]
+        """
+        if self._partition is None:
+            self._partition = sorted([sorted(p, key=default_sort_key)
+                                      for p in self.args])
+        return self._partition
+
+    def __add__(self, other):
+        """
+        Return permutation whose rank is ``other`` greater than current rank,
+        (mod the maximum rank for the set).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3])
+        >>> a.rank
+        1
+        >>> (a + 1).rank
+        2
+        >>> (a + 100).rank
+        1
+        """
+        other = as_int(other)
+        offset = self.rank + other
+        result = RGS_unrank((offset) %
+                            RGS_enum(self.size),
+                            self.size)
+        return Partition.from_rgs(result, self.members)
+
+    def __sub__(self, other):
+        """
+        Return permutation whose rank is ``other`` less than current rank,
+        (mod the maximum rank for the set).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3])
+        >>> a.rank
+        1
+        >>> (a - 1).rank
+        0
+        >>> (a - 100).rank
+        1
+        """
+        return self.__add__(-other)
+
+    def __le__(self, other):
+        """
+        Checks if a partition is less than or equal to
+        the other based on rank.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3, 4, 5])
+        >>> b = Partition([1], [2, 3], [4], [5])
+        >>> a.rank, b.rank
+        (9, 34)
+        >>> a <= a
+        True
+        >>> a <= b
+        True
+        """
+        return self.sort_key() <= sympify(other).sort_key()
+
+    def __lt__(self, other):
+        """
+        Checks if a partition is less than the other.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3, 4, 5])
+        >>> b = Partition([1], [2, 3], [4], [5])
+        >>> a.rank, b.rank
+        (9, 34)
+        >>> a < b
+        True
+        """
+        return self.sort_key() < sympify(other).sort_key()
+
+    @property
+    def rank(self):
+        """
+        Gets the rank of a partition.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3], [4, 5])
+        >>> a.rank
+        13
+        """
+        if self._rank is not None:
+            return self._rank
+        self._rank = RGS_rank(self.RGS)
+        return self._rank
+
+    @property
+    def RGS(self):
+        """
+        Returns the "restricted growth string" of the partition.
+
+        Explanation
+        ===========
+
+        The RGS is returned as a list of indices, L, where L[i] indicates
+        the block in which element i appears. For example, in a partition
+        of 3 elements (a, b, c) into 2 blocks ([c], [a, b]) the RGS is
+        [1, 1, 0]: "a" is in block 1, "b" is in block 1 and "c" is in block 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> a = Partition([1, 2], [3], [4, 5])
+        >>> a.members
+        (1, 2, 3, 4, 5)
+        >>> a.RGS
+        (0, 0, 1, 2, 2)
+        >>> a + 1
+        Partition({3}, {4}, {5}, {1, 2})
+        >>> _.RGS
+        (0, 0, 1, 2, 3)
+        """
+        rgs = {}
+        partition = self.partition
+        for i, part in enumerate(partition):
+            for j in part:
+                rgs[j] = i
+        return tuple([rgs[i] for i in sorted(
+            [i for p in partition for i in p], key=default_sort_key)])
+
+    @classmethod
+    def from_rgs(self, rgs, elements):
+        """
+        Creates a set partition from a restricted growth string.
+
+        Explanation
+        ===========
+
+        The indices given in rgs are assumed to be the index
+        of the element as given in elements *as provided* (the
+        elements are not sorted by this routine). Block numbering
+        starts from 0. If any block was not referenced in ``rgs``
+        an error will be raised.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Partition
+        >>> Partition.from_rgs([0, 1, 2, 0, 1], list('abcde'))
+        Partition({c}, {a, d}, {b, e})
+        >>> Partition.from_rgs([0, 1, 2, 0, 1], list('cbead'))
+        Partition({e}, {a, c}, {b, d})
+        >>> a = Partition([1, 4], [2], [3, 5])
+        >>> Partition.from_rgs(a.RGS, a.members)
+        Partition({2}, {1, 4}, {3, 5})
+        """
+        if len(rgs) != len(elements):
+            raise ValueError('mismatch in rgs and element lengths')
+        max_elem = max(rgs) + 1
+        partition = [[] for i in range(max_elem)]
+        j = 0
+        for i in rgs:
+            partition[i].append(elements[j])
+            j += 1
+        if not all(p for p in partition):
+            raise ValueError('some blocks of the partition were empty.')
+        return Partition(*partition)
+
+
+class IntegerPartition(Basic):
+    """
+    This class represents an integer partition.
+
+    Explanation
+    ===========
+
+    In number theory and combinatorics, a partition of a positive integer,
+    ``n``, also called an integer partition, is a way of writing ``n`` as a
+    list of positive integers that sum to n. Two partitions that differ only
+    in the order of summands are considered to be the same partition; if order
+    matters then the partitions are referred to as compositions. For example,
+    4 has five partitions: [4], [3, 1], [2, 2], [2, 1, 1], and [1, 1, 1, 1];
+    the compositions [1, 2, 1] and [1, 1, 2] are the same as partition
+    [2, 1, 1].
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.partitions,
+    sympy.utilities.iterables.multiset_partitions
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Partition_%28number_theory%29
+    """
+
+    _dict = None
+    _keys = None
+
+    def __new__(cls, partition, integer=None):
+        """
+        Generates a new IntegerPartition object from a list or dictionary.
+
+        Explanation
+        ===========
+
+        The partition can be given as a list of positive integers or a
+        dictionary of (integer, multiplicity) items. If the partition is
+        preceded by an integer an error will be raised if the partition
+        does not sum to that given integer.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> a = IntegerPartition([5, 4, 3, 1, 1])
+        >>> a
+        IntegerPartition(14, (5, 4, 3, 1, 1))
+        >>> print(a)
+        [5, 4, 3, 1, 1]
+        >>> IntegerPartition({1:3, 2:1})
+        IntegerPartition(5, (2, 1, 1, 1))
+
+        If the value that the partition should sum to is given first, a check
+        will be made to see n error will be raised if there is a discrepancy:
+
+        >>> IntegerPartition(10, [5, 4, 3, 1])
+        Traceback (most recent call last):
+        ...
+        ValueError: The partition is not valid
+
+        """
+        if integer is not None:
+            integer, partition = partition, integer
+        if isinstance(partition, (dict, Dict)):
+            _ = []
+            for k, v in sorted(partition.items(), reverse=True):
+                if not v:
+                    continue
+                k, v = as_int(k), as_int(v)
+                _.extend([k]*v)
+            partition = tuple(_)
+        else:
+            partition = tuple(sorted(map(as_int, partition), reverse=True))
+        sum_ok = False
+        if integer is None:
+            integer = sum(partition)
+            sum_ok = True
+        else:
+            integer = as_int(integer)
+
+        if not sum_ok and sum(partition) != integer:
+            raise ValueError("Partition did not add to %s" % integer)
+        if any(i < 1 for i in partition):
+            raise ValueError("All integer summands must be greater than one")
+
+        obj = Basic.__new__(cls, Integer(integer), Tuple(*partition))
+        obj.partition = list(partition)
+        obj.integer = integer
+        return obj
+
+    def prev_lex(self):
+        """Return the previous partition of the integer, n, in lexical order,
+        wrapping around to [1, ..., 1] if the partition is [n].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> p = IntegerPartition([4])
+        >>> print(p.prev_lex())
+        [3, 1]
+        >>> p.partition > p.prev_lex().partition
+        True
+        """
+        d = defaultdict(int)
+        d.update(self.as_dict())
+        keys = self._keys
+        if keys == [1]:
+            return IntegerPartition({self.integer: 1})
+        if keys[-1] != 1:
+            d[keys[-1]] -= 1
+            if keys[-1] == 2:
+                d[1] = 2
+            else:
+                d[keys[-1] - 1] = d[1] = 1
+        else:
+            d[keys[-2]] -= 1
+            left = d[1] + keys[-2]
+            new = keys[-2]
+            d[1] = 0
+            while left:
+                new -= 1
+                if left - new >= 0:
+                    d[new] += left//new
+                    left -= d[new]*new
+        return IntegerPartition(self.integer, d)
+
+    def next_lex(self):
+        """Return the next partition of the integer, n, in lexical order,
+        wrapping around to [n] if the partition is [1, ..., 1].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> p = IntegerPartition([3, 1])
+        >>> print(p.next_lex())
+        [4]
+        >>> p.partition < p.next_lex().partition
+        True
+        """
+        d = defaultdict(int)
+        d.update(self.as_dict())
+        key = self._keys
+        a = key[-1]
+        if a == self.integer:
+            d.clear()
+            d[1] = self.integer
+        elif a == 1:
+            if d[a] > 1:
+                d[a + 1] += 1
+                d[a] -= 2
+            else:
+                b = key[-2]
+                d[b + 1] += 1
+                d[1] = (d[b] - 1)*b
+                d[b] = 0
+        else:
+            if d[a] > 1:
+                if len(key) == 1:
+                    d.clear()
+                    d[a + 1] = 1
+                    d[1] = self.integer - a - 1
+                else:
+                    a1 = a + 1
+                    d[a1] += 1
+                    d[1] = d[a]*a - a1
+                    d[a] = 0
+            else:
+                b = key[-2]
+                b1 = b + 1
+                d[b1] += 1
+                need = d[b]*b + d[a]*a - b1
+                d[a] = d[b] = 0
+                d[1] = need
+        return IntegerPartition(self.integer, d)
+
+    def as_dict(self):
+        """Return the partition as a dictionary whose keys are the
+        partition integers and the values are the multiplicity of that
+        integer.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> IntegerPartition([1]*3 + [2] + [3]*4).as_dict()
+        {1: 3, 2: 1, 3: 4}
+        """
+        if self._dict is None:
+            groups = group(self.partition, multiple=False)
+            self._keys = [g[0] for g in groups]
+            self._dict = dict(groups)
+        return self._dict
+
+    @property
+    def conjugate(self):
+        """
+        Computes the conjugate partition of itself.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> a = IntegerPartition([6, 3, 3, 2, 1])
+        >>> a.conjugate
+        [5, 4, 3, 1, 1, 1]
+        """
+        j = 1
+        temp_arr = list(self.partition) + [0]
+        k = temp_arr[0]
+        b = [0]*k
+        while k > 0:
+            while k > temp_arr[j]:
+                b[k - 1] = j
+                k -= 1
+            j += 1
+        return b
+
+    def __lt__(self, other):
+        """Return True if self is less than other when the partition
+        is listed from smallest to biggest.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> a = IntegerPartition([3, 1])
+        >>> a < a
+        False
+        >>> b = a.next_lex()
+        >>> a < b
+        True
+        >>> a == b
+        False
+        """
+        return list(reversed(self.partition)) < list(reversed(other.partition))
+
+    def __le__(self, other):
+        """Return True if self is less than other when the partition
+        is listed from smallest to biggest.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> a = IntegerPartition([4])
+        >>> a <= a
+        True
+        """
+        return list(reversed(self.partition)) <= list(reversed(other.partition))
+
+    def as_ferrers(self, char='#'):
+        """
+        Prints the ferrer diagram of a partition.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.partitions import IntegerPartition
+        >>> print(IntegerPartition([1, 1, 5]).as_ferrers())
+        #####
+        #
+        #
+        """
+        return "\n".join([char*i for i in self.partition])
+
+    def __str__(self):
+        return str(list(self.partition))
+
+
+def random_integer_partition(n, seed=None):
+    """
+    Generates a random integer partition summing to ``n`` as a list
+    of reverse-sorted integers.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.partitions import random_integer_partition
+
+    For the following, a seed is given so a known value can be shown; in
+    practice, the seed would not be given.
+
+    >>> random_integer_partition(100, seed=[1, 1, 12, 1, 2, 1, 85, 1])
+    [85, 12, 2, 1]
+    >>> random_integer_partition(10, seed=[1, 2, 3, 1, 5, 1])
+    [5, 3, 1, 1]
+    >>> random_integer_partition(1)
+    [1]
+    """
+    from sympy.core.random import _randint
+
+    n = as_int(n)
+    if n < 1:
+        raise ValueError('n must be a positive integer')
+
+    randint = _randint(seed)
+
+    partition = []
+    while (n > 0):
+        k = randint(1, n)
+        mult = randint(1, n//k)
+        partition.append((k, mult))
+        n -= k*mult
+    partition.sort(reverse=True)
+    partition = flatten([[k]*m for k, m in partition])
+    return partition
+
+
+def RGS_generalized(m):
+    """
+    Computes the m + 1 generalized unrestricted growth strings
+    and returns them as rows in matrix.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.partitions import RGS_generalized
+    >>> RGS_generalized(6)
+    Matrix([
+    [  1,   1,   1,  1,  1, 1, 1],
+    [  1,   2,   3,  4,  5, 6, 0],
+    [  2,   5,  10, 17, 26, 0, 0],
+    [  5,  15,  37, 77,  0, 0, 0],
+    [ 15,  52, 151,  0,  0, 0, 0],
+    [ 52, 203,   0,  0,  0, 0, 0],
+    [203,   0,   0,  0,  0, 0, 0]])
+    """
+    d = zeros(m + 1)
+    for i in range(m + 1):
+        d[0, i] = 1
+
+    for i in range(1, m + 1):
+        for j in range(m):
+            if j <= m - i:
+                d[i, j] = j * d[i - 1, j] + d[i - 1, j + 1]
+            else:
+                d[i, j] = 0
+    return d
+
+
+def RGS_enum(m):
+    """
+    RGS_enum computes the total number of restricted growth strings
+    possible for a superset of size m.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.partitions import RGS_enum
+    >>> from sympy.combinatorics import Partition
+    >>> RGS_enum(4)
+    15
+    >>> RGS_enum(5)
+    52
+    >>> RGS_enum(6)
+    203
+
+    We can check that the enumeration is correct by actually generating
+    the partitions. Here, the 15 partitions of 4 items are generated:
+
+    >>> a = Partition(list(range(4)))
+    >>> s = set()
+    >>> for i in range(20):
+    ...     s.add(a)
+    ...     a += 1
+    ...
+    >>> assert len(s) == 15
+
+    """
+    if (m < 1):
+        return 0
+    elif (m == 1):
+        return 1
+    else:
+        return bell(m)
+
+
+def RGS_unrank(rank, m):
+    """
+    Gives the unranked restricted growth string for a given
+    superset size.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.partitions import RGS_unrank
+    >>> RGS_unrank(14, 4)
+    [0, 1, 2, 3]
+    >>> RGS_unrank(0, 4)
+    [0, 0, 0, 0]
+    """
+    if m < 1:
+        raise ValueError("The superset size must be >= 1")
+    if rank < 0 or RGS_enum(m) <= rank:
+        raise ValueError("Invalid arguments")
+
+    L = [1] * (m + 1)
+    j = 1
+    D = RGS_generalized(m)
+    for i in range(2, m + 1):
+        v = D[m - i, j]
+        cr = j*v
+        if cr <= rank:
+            L[i] = j + 1
+            rank -= cr
+            j += 1
+        else:
+            L[i] = int(rank / v + 1)
+            rank %= v
+    return [x - 1 for x in L[1:]]
+
+
+def RGS_rank(rgs):
+    """
+    Computes the rank of a restricted growth string.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.partitions import RGS_rank, RGS_unrank
+    >>> RGS_rank([0, 1, 2, 1, 3])
+    42
+    >>> RGS_rank(RGS_unrank(4, 7))
+    4
+    """
+    rgs_size = len(rgs)
+    rank = 0
+    D = RGS_generalized(rgs_size)
+    for i in range(1, rgs_size):
+        n = len(rgs[(i + 1):])
+        m = max(rgs[0:i])
+        rank += D[n, m + 1] * rgs[i]
+    return rank
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/pc_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/pc_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..abf7b82258d8bb61ba350509fcbb3110a035fc88
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/pc_groups.py
@@ -0,0 +1,710 @@
+from sympy.ntheory.primetest import isprime
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.printing.defaults import DefaultPrinting
+from sympy.combinatorics.free_groups import free_group
+
+
+class PolycyclicGroup(DefaultPrinting):
+
+    is_group = True
+    is_solvable = True
+
+    def __init__(self, pc_sequence, pc_series, relative_order, collector=None):
+        """
+
+        Parameters
+        ==========
+
+        pc_sequence : list
+            A sequence of elements whose classes generate the cyclic factor
+            groups of pc_series.
+        pc_series : list
+            A subnormal sequence of subgroups where each factor group is cyclic.
+        relative_order : list
+            The orders of factor groups of pc_series.
+        collector : Collector
+            By default, it is None. Collector class provides the
+            polycyclic presentation with various other functionalities.
+
+        """
+        self.pcgs = pc_sequence
+        self.pc_series = pc_series
+        self.relative_order = relative_order
+        self.collector = Collector(self.pcgs, pc_series, relative_order) if not collector else collector
+
+    def is_prime_order(self):
+        return all(isprime(order) for order in self.relative_order)
+
+    def length(self):
+        return len(self.pcgs)
+
+
+class Collector(DefaultPrinting):
+
+    """
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+           Section 8.1.3
+    """
+
+    def __init__(self, pcgs, pc_series, relative_order, free_group_=None, pc_presentation=None):
+        """
+
+        Most of the parameters for the Collector class are the same as for PolycyclicGroup.
+        Others are described below.
+
+        Parameters
+        ==========
+
+        free_group_ : tuple
+            free_group_ provides the mapping of polycyclic generating
+            sequence with the free group elements.
+        pc_presentation : dict
+            Provides the presentation of polycyclic groups with the
+            help of power and conjugate relators.
+
+        See Also
+        ========
+
+        PolycyclicGroup
+
+        """
+        self.pcgs = pcgs
+        self.pc_series = pc_series
+        self.relative_order = relative_order
+        self.free_group = free_group('x:{}'.format(len(pcgs)))[0] if not free_group_ else free_group_
+        self.index = {s: i for i, s in enumerate(self.free_group.symbols)}
+        self.pc_presentation = self.pc_relators()
+
+    def minimal_uncollected_subword(self, word):
+        r"""
+        Returns the minimal uncollected subwords.
+
+        Explanation
+        ===========
+
+        A word ``v`` defined on generators in ``X`` is a minimal
+        uncollected subword of the word ``w`` if ``v`` is a subword
+        of ``w`` and it has one of the following form
+
+        * `v = {x_{i+1}}^{a_j}x_i`
+
+        * `v = {x_{i+1}}^{a_j}{x_i}^{-1}`
+
+        * `v = {x_i}^{a_j}`
+
+        for `a_j` not in `\{1, \ldots, s-1\}`. Where, ``s`` is the power
+        exponent of the corresponding generator.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics import free_group
+        >>> G = SymmetricGroup(4)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> F, x1, x2 = free_group("x1, x2")
+        >>> word = x2**2*x1**7
+        >>> collector.minimal_uncollected_subword(word)
+        ((x2, 2),)
+
+        """
+        # To handle the case word = 
+        if not word:
+            return None
+
+        array = word.array_form
+        re = self.relative_order
+        index = self.index
+
+        for i in range(len(array)):
+            s1, e1 = array[i]
+
+            if re[index[s1]] and (e1 < 0 or e1 > re[index[s1]]-1):
+                return ((s1, e1), )
+
+        for i in range(len(array)-1):
+            s1, e1 = array[i]
+            s2, e2 = array[i+1]
+
+            if index[s1] > index[s2]:
+                e = 1 if e2 > 0 else -1
+                return ((s1, e1), (s2, e))
+
+        return None
+
+    def relations(self):
+        """
+        Separates the given relators of pc presentation in power and
+        conjugate relations.
+
+        Returns
+        =======
+
+        (power_rel, conj_rel)
+            Separates pc presentation into power and conjugate relations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> G = SymmetricGroup(3)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> power_rel, conj_rel = collector.relations()
+        >>> power_rel
+        {x0**2: (), x1**3: ()}
+        >>> conj_rel
+        {x0**-1*x1*x0: x1**2}
+
+        See Also
+        ========
+
+        pc_relators
+
+        """
+        power_relators = {}
+        conjugate_relators = {}
+        for key, value in self.pc_presentation.items():
+            if len(key.array_form) == 1:
+                power_relators[key] = value
+            else:
+                conjugate_relators[key] = value
+        return power_relators, conjugate_relators
+
+    def subword_index(self, word, w):
+        """
+        Returns the start and ending index of a given
+        subword in a word.
+
+        Parameters
+        ==========
+
+        word : FreeGroupElement
+            word defined on free group elements for a
+            polycyclic group.
+        w : FreeGroupElement
+            subword of a given word, whose starting and
+            ending index to be computed.
+
+        Returns
+        =======
+
+        (i, j)
+            A tuple containing starting and ending index of ``w``
+            in the given word. If not exists, (-1,-1) is returned.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics import free_group
+        >>> G = SymmetricGroup(4)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> F, x1, x2 = free_group("x1, x2")
+        >>> word = x2**2*x1**7
+        >>> w = x2**2*x1
+        >>> collector.subword_index(word, w)
+        (0, 3)
+        >>> w = x1**7
+        >>> collector.subword_index(word, w)
+        (2, 9)
+        >>> w = x1**8
+        >>> collector.subword_index(word, w)
+        (-1, -1)
+
+        """
+        low = -1
+        high = -1
+        for i in range(len(word)-len(w)+1):
+            if word.subword(i, i+len(w)) == w:
+                low = i
+                high = i+len(w)
+                break
+        return low, high
+
+    def map_relation(self, w):
+        """
+        Return a conjugate relation.
+
+        Explanation
+        ===========
+
+        Given a word formed by two free group elements, the
+        corresponding conjugate relation with those free
+        group elements is formed and mapped with the collected
+        word in the polycyclic presentation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics import free_group
+        >>> G = SymmetricGroup(3)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> F, x0, x1 = free_group("x0, x1")
+        >>> w = x1*x0
+        >>> collector.map_relation(w)
+        x1**2
+
+        See Also
+        ========
+
+        pc_presentation
+
+        """
+        array = w.array_form
+        s1 = array[0][0]
+        s2 = array[1][0]
+        key = ((s2, -1), (s1, 1), (s2, 1))
+        key = self.free_group.dtype(key)
+        return self.pc_presentation[key]
+
+
+    def collected_word(self, word):
+        r"""
+        Return the collected form of a word.
+
+        Explanation
+        ===========
+
+        A word ``w`` is called collected, if `w = {x_{i_1}}^{a_1} * \ldots *
+        {x_{i_r}}^{a_r}` with `i_1 < i_2< \ldots < i_r` and `a_j` is in
+        `\{1, \ldots, {s_j}-1\}`.
+
+        Otherwise w is uncollected.
+
+        Parameters
+        ==========
+
+        word : FreeGroupElement
+            An uncollected word.
+
+        Returns
+        =======
+
+        word
+            A collected word of form `w = {x_{i_1}}^{a_1}, \ldots,
+            {x_{i_r}}^{a_r}` with `i_1, i_2, \ldots, i_r` and `a_j \in
+            \{1, \ldots, {s_j}-1\}`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.perm_groups import PermutationGroup
+        >>> from sympy.combinatorics import free_group
+        >>> G = SymmetricGroup(4)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> F, x0, x1, x2, x3 = free_group("x0, x1, x2, x3")
+        >>> word = x3*x2*x1*x0
+        >>> collected_word = collector.collected_word(word)
+        >>> free_to_perm = {}
+        >>> free_group = collector.free_group
+        >>> for sym, gen in zip(free_group.symbols, collector.pcgs):
+        ...     free_to_perm[sym] = gen
+        >>> G1 = PermutationGroup()
+        >>> for w in word:
+        ...     sym = w[0]
+        ...     perm = free_to_perm[sym]
+        ...     G1 = PermutationGroup([perm] + G1.generators)
+        >>> G2 = PermutationGroup()
+        >>> for w in collected_word:
+        ...     sym = w[0]
+        ...     perm = free_to_perm[sym]
+        ...     G2 = PermutationGroup([perm] + G2.generators)
+
+        The two are not identical, but they are equivalent:
+
+        >>> G1.equals(G2), G1 == G2
+        (True, False)
+
+        See Also
+        ========
+
+        minimal_uncollected_subword
+
+        """
+        free_group = self.free_group
+        while True:
+            w = self.minimal_uncollected_subword(word)
+            if not w:
+                break
+
+            low, high = self.subword_index(word, free_group.dtype(w))
+            if low == -1:
+                continue
+
+            s1, e1 = w[0]
+            if len(w) == 1:
+                re = self.relative_order[self.index[s1]]
+                q = e1 // re
+                r = e1-q*re
+
+                key = ((w[0][0], re), )
+                key = free_group.dtype(key)
+                if self.pc_presentation[key]:
+                    presentation = self.pc_presentation[key].array_form
+                    sym, exp = presentation[0]
+                    word_ = ((w[0][0], r), (sym, q*exp))
+                    word_ = free_group.dtype(word_)
+                else:
+                    if r != 0:
+                        word_ = ((w[0][0], r), )
+                        word_ = free_group.dtype(word_)
+                    else:
+                        word_ = None
+                word = word.eliminate_word(free_group.dtype(w), word_)
+
+            if len(w) == 2 and w[1][1] > 0:
+                s2, e2 = w[1]
+                s2 = ((s2, 1), )
+                s2 = free_group.dtype(s2)
+                word_ = self.map_relation(free_group.dtype(w))
+                word_ = s2*word_**e1
+                word_ = free_group.dtype(word_)
+                word = word.substituted_word(low, high, word_)
+
+            elif len(w) == 2 and w[1][1] < 0:
+                s2, e2 = w[1]
+                s2 = ((s2, 1), )
+                s2 = free_group.dtype(s2)
+                word_ = self.map_relation(free_group.dtype(w))
+                word_ = s2**-1*word_**e1
+                word_ = free_group.dtype(word_)
+                word = word.substituted_word(low, high, word_)
+
+        return word
+
+
+    def pc_relators(self):
+        r"""
+        Return the polycyclic presentation.
+
+        Explanation
+        ===========
+
+        There are two types of relations used in polycyclic
+        presentation.
+
+        * Power relations : Power relators are of the form `x_i^{re_i}`,
+          where `i \in \{0, \ldots, \mathrm{len(pcgs)}\}`, ``x`` represents polycyclic
+          generator and ``re`` is the corresponding relative order.
+
+        * Conjugate relations : Conjugate relators are of the form `x_j^-1x_ix_j`,
+          where `j < i \in \{0, \ldots, \mathrm{len(pcgs)}\}`.
+
+        Returns
+        =======
+
+        A dictionary with power and conjugate relations as key and
+        their collected form as corresponding values.
+
+        Notes
+        =====
+
+        Identity Permutation is mapped with empty ``()``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.permutations import Permutation
+        >>> S = SymmetricGroup(49).sylow_subgroup(7)
+        >>> der = S.derived_series()
+        >>> G = der[len(der)-2]
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> pcgs = PcGroup.pcgs
+        >>> len(pcgs)
+        6
+        >>> free_group = collector.free_group
+        >>> pc_resentation = collector.pc_presentation
+        >>> free_to_perm = {}
+        >>> for s, g in zip(free_group.symbols, pcgs):
+        ...     free_to_perm[s] = g
+
+        >>> for k, v in pc_resentation.items():
+        ...     k_array = k.array_form
+        ...     if v != ():
+        ...        v_array = v.array_form
+        ...     lhs = Permutation()
+        ...     for gen in k_array:
+        ...         s = gen[0]
+        ...         e = gen[1]
+        ...         lhs = lhs*free_to_perm[s]**e
+        ...     if v == ():
+        ...         assert lhs.is_identity
+        ...         continue
+        ...     rhs = Permutation()
+        ...     for gen in v_array:
+        ...         s = gen[0]
+        ...         e = gen[1]
+        ...         rhs = rhs*free_to_perm[s]**e
+        ...     assert lhs == rhs
+
+        """
+        free_group = self.free_group
+        rel_order = self.relative_order
+        pc_relators = {}
+        perm_to_free = {}
+        pcgs = self.pcgs
+
+        for gen, s in zip(pcgs, free_group.generators):
+            perm_to_free[gen**-1] = s**-1
+            perm_to_free[gen] = s
+
+        pcgs = pcgs[::-1]
+        series = self.pc_series[::-1]
+        rel_order = rel_order[::-1]
+        collected_gens = []
+
+        for i, gen in enumerate(pcgs):
+            re = rel_order[i]
+            relation = perm_to_free[gen]**re
+            G = series[i]
+
+            l = G.generator_product(gen**re, original = True)
+            l.reverse()
+
+            word = free_group.identity
+            for g in l:
+                word = word*perm_to_free[g]
+
+            word = self.collected_word(word)
+            pc_relators[relation] = word if word else ()
+            self.pc_presentation = pc_relators
+
+            collected_gens.append(gen)
+            if len(collected_gens) > 1:
+                conj = collected_gens[len(collected_gens)-1]
+                conjugator = perm_to_free[conj]
+
+                for j in range(len(collected_gens)-1):
+                    conjugated = perm_to_free[collected_gens[j]]
+
+                    relation = conjugator**-1*conjugated*conjugator
+                    gens = conj**-1*collected_gens[j]*conj
+
+                    l = G.generator_product(gens, original = True)
+                    l.reverse()
+                    word = free_group.identity
+                    for g in l:
+                        word = word*perm_to_free[g]
+
+                    word = self.collected_word(word)
+                    pc_relators[relation] = word if word else ()
+                    self.pc_presentation = pc_relators
+
+        return pc_relators
+
+    def exponent_vector(self, element):
+        r"""
+        Return the exponent vector of length equal to the
+        length of polycyclic generating sequence.
+
+        Explanation
+        ===========
+
+        For a given generator/element ``g`` of the polycyclic group,
+        it can be represented as `g = {x_1}^{e_1}, \ldots, {x_n}^{e_n}`,
+        where `x_i` represents polycyclic generators and ``n`` is
+        the number of generators in the free_group equal to the length
+        of pcgs.
+
+        Parameters
+        ==========
+
+        element : Permutation
+            Generator of a polycyclic group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.permutations import Permutation
+        >>> G = SymmetricGroup(4)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> pcgs = PcGroup.pcgs
+        >>> collector.exponent_vector(G[0])
+        [1, 0, 0, 0]
+        >>> exp = collector.exponent_vector(G[1])
+        >>> g = Permutation()
+        >>> for i in range(len(exp)):
+        ...     g = g*pcgs[i]**exp[i] if exp[i] else g
+        >>> assert g == G[1]
+
+        References
+        ==========
+
+        .. [1] Holt, D., Eick, B., O'Brien, E.
+               "Handbook of Computational Group Theory"
+               Section 8.1.1, Definition 8.4
+
+        """
+        free_group = self.free_group
+        G = PermutationGroup()
+        for g in self.pcgs:
+            G = PermutationGroup([g] + G.generators)
+        gens = G.generator_product(element, original = True)
+        gens.reverse()
+
+        perm_to_free = {}
+        for sym, g in zip(free_group.generators, self.pcgs):
+            perm_to_free[g**-1] = sym**-1
+            perm_to_free[g] = sym
+        w = free_group.identity
+        for g in gens:
+            w = w*perm_to_free[g]
+
+        word = self.collected_word(w)
+
+        index = self.index
+        exp_vector = [0]*len(free_group)
+        word = word.array_form
+        for t in word:
+            exp_vector[index[t[0]]] = t[1]
+        return exp_vector
+
+    def depth(self, element):
+        r"""
+        Return the depth of a given element.
+
+        Explanation
+        ===========
+
+        The depth of a given element ``g`` is defined by
+        `\mathrm{dep}[g] = i` if `e_1 = e_2 = \ldots = e_{i-1} = 0`
+        and `e_i != 0`, where ``e`` represents the exponent-vector.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> G = SymmetricGroup(3)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> collector.depth(G[0])
+        2
+        >>> collector.depth(G[1])
+        1
+
+        References
+        ==========
+
+        .. [1] Holt, D., Eick, B., O'Brien, E.
+               "Handbook of Computational Group Theory"
+               Section 8.1.1, Definition 8.5
+
+        """
+        exp_vector = self.exponent_vector(element)
+        return next((i+1 for i, x in enumerate(exp_vector) if x), len(self.pcgs)+1)
+
+    def leading_exponent(self, element):
+        r"""
+        Return the leading non-zero exponent.
+
+        Explanation
+        ===========
+
+        The leading exponent for a given element `g` is defined
+        by `\mathrm{leading\_exponent}[g]` `= e_i`, if `\mathrm{depth}[g] = i`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> G = SymmetricGroup(3)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> collector.leading_exponent(G[1])
+        1
+
+        """
+        exp_vector = self.exponent_vector(element)
+        depth = self.depth(element)
+        if depth != len(self.pcgs)+1:
+            return exp_vector[depth-1]
+        return None
+
+    def _sift(self, z, g):
+        h = g
+        d = self.depth(h)
+        while d < len(self.pcgs) and z[d-1] != 1:
+            k = z[d-1]
+            e = self.leading_exponent(h)*(self.leading_exponent(k))**-1
+            e = e % self.relative_order[d-1]
+            h = k**-e*h
+            d = self.depth(h)
+        return h
+
+    def induced_pcgs(self, gens):
+        """
+
+        Parameters
+        ==========
+
+        gens : list
+            A list of generators on which polycyclic subgroup
+            is to be defined.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> S = SymmetricGroup(8)
+        >>> G = S.sylow_subgroup(2)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> gens = [G[0], G[1]]
+        >>> ipcgs = collector.induced_pcgs(gens)
+        >>> [gen.order() for gen in ipcgs]
+        [2, 2, 2]
+        >>> G = S.sylow_subgroup(3)
+        >>> PcGroup = G.polycyclic_group()
+        >>> collector = PcGroup.collector
+        >>> gens = [G[0], G[1]]
+        >>> ipcgs = collector.induced_pcgs(gens)
+        >>> [gen.order() for gen in ipcgs]
+        [3]
+
+        """
+        z = [1]*len(self.pcgs)
+        G = gens
+        while G:
+            g = G.pop(0)
+            h = self._sift(z, g)
+            d = self.depth(h)
+            if d < len(self.pcgs):
+                for gen in z:
+                    if gen != 1:
+                        G.append(h**-1*gen**-1*h*gen)
+                z[d-1] = h
+        z = [gen for gen in z if gen != 1]
+        return z
+
+    def constructive_membership_test(self, ipcgs, g):
+        """
+        Return the exponent vector for induced pcgs.
+        """
+        e = [0]*len(ipcgs)
+        h = g
+        d = self.depth(h)
+        for i, gen in enumerate(ipcgs):
+            while self.depth(gen) == d:
+                f = self.leading_exponent(h)*self.leading_exponent(gen)
+                f = f % self.relative_order[d-1]
+                h = gen**(-f)*h
+                e[i] = f
+                d = self.depth(h)
+        if h == 1:
+            return e
+        return False
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/perm_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/perm_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..24359cb546246d63470de92b2fb2ab0804fc9886
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/perm_groups.py
@@ -0,0 +1,5459 @@
+from math import factorial as _factorial, log, prod
+from itertools import chain, product
+
+
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.permutations import (_af_commutes_with, _af_invert,
+    _af_rmul, _af_rmuln, _af_pow, Cycle)
+from sympy.combinatorics.util import (_check_cycles_alt_sym,
+    _distribute_gens_by_base, _orbits_transversals_from_bsgs,
+    _handle_precomputed_bsgs, _base_ordering, _strong_gens_from_distr,
+    _strip, _strip_af)
+from sympy.core import Basic
+from sympy.core.random import _randrange, randrange, choice
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import _sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.ntheory import primefactors, sieve
+from sympy.ntheory.factor_ import (factorint, multiplicity)
+from sympy.ntheory.primetest import isprime
+from sympy.utilities.iterables import has_variety, is_sequence, uniq
+
+rmul = Permutation.rmul_with_af
+_af_new = Permutation._af_new
+
+
+class PermutationGroup(Basic):
+    r"""The class defining a Permutation group.
+
+    Explanation
+    ===========
+
+    ``PermutationGroup([p1, p2, ..., pn])`` returns the permutation group
+    generated by the list of permutations. This group can be supplied
+    to Polyhedron if one desires to decorate the elements to which the
+    indices of the permutation refer.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation, PermutationGroup
+    >>> from sympy.combinatorics import Polyhedron
+
+    The permutations corresponding to motion of the front, right and
+    bottom face of a $2 \times 2$ Rubik's cube are defined:
+
+    >>> F = Permutation(2, 19, 21, 8)(3, 17, 20, 10)(4, 6, 7, 5)
+    >>> R = Permutation(1, 5, 21, 14)(3, 7, 23, 12)(8, 10, 11, 9)
+    >>> D = Permutation(6, 18, 14, 10)(7, 19, 15, 11)(20, 22, 23, 21)
+
+    These are passed as permutations to PermutationGroup:
+
+    >>> G = PermutationGroup(F, R, D)
+    >>> G.order()
+    3674160
+
+    The group can be supplied to a Polyhedron in order to track the
+    objects being moved. An example involving the $2 \times 2$ Rubik's cube is
+    given there, but here is a simple demonstration:
+
+    >>> a = Permutation(2, 1)
+    >>> b = Permutation(1, 0)
+    >>> G = PermutationGroup(a, b)
+    >>> P = Polyhedron(list('ABC'), pgroup=G)
+    >>> P.corners
+    (A, B, C)
+    >>> P.rotate(0) # apply permutation 0
+    >>> P.corners
+    (A, C, B)
+    >>> P.reset()
+    >>> P.corners
+    (A, B, C)
+
+    Or one can make a permutation as a product of selected permutations
+    and apply them to an iterable directly:
+
+    >>> P10 = G.make_perm([0, 1])
+    >>> P10('ABC')
+    ['C', 'A', 'B']
+
+    See Also
+    ========
+
+    sympy.combinatorics.polyhedron.Polyhedron,
+    sympy.combinatorics.permutations.Permutation
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of Computational Group Theory"
+
+    .. [2] Seress, A.
+           "Permutation Group Algorithms"
+
+    .. [3] https://en.wikipedia.org/wiki/Schreier_vector
+
+    .. [4] https://en.wikipedia.org/wiki/Nielsen_transformation#Product_replacement_algorithm
+
+    .. [5] Frank Celler, Charles R.Leedham-Green, Scott H.Murray,
+           Alice C.Niemeyer, and E.A.O'Brien. "Generating Random
+           Elements of a Finite Group"
+
+    .. [6] https://en.wikipedia.org/wiki/Block_%28permutation_group_theory%29
+
+    .. [7] https://algorithmist.com/wiki/Union_find
+
+    .. [8] https://en.wikipedia.org/wiki/Multiply_transitive_group#Multiply_transitive_groups
+
+    .. [9] https://en.wikipedia.org/wiki/Center_%28group_theory%29
+
+    .. [10] https://en.wikipedia.org/wiki/Centralizer_and_normalizer
+
+    .. [11] https://groupprops.subwiki.org/wiki/Derived_subgroup
+
+    .. [12] https://en.wikipedia.org/wiki/Nilpotent_group
+
+    .. [13] https://www.math.colostate.edu/~hulpke/CGT/cgtnotes.pdf
+
+    .. [14] https://docs.gap-system.org/doc/ref/manual.pdf
+
+    """
+    is_group = True
+
+    def __new__(cls, *args, dups=True, **kwargs):
+        """The default constructor. Accepts Cycle and Permutation forms.
+        Removes duplicates unless ``dups`` keyword is ``False``.
+        """
+        if not args:
+            args = [Permutation()]
+        else:
+            args = list(args[0] if is_sequence(args[0]) else args)
+            if not args:
+                args = [Permutation()]
+        if any(isinstance(a, Cycle) for a in args):
+            args = [Permutation(a) for a in args]
+        if has_variety(a.size for a in args):
+            degree = kwargs.pop('degree', None)
+            if degree is None:
+                degree = max(a.size for a in args)
+            for i in range(len(args)):
+                if args[i].size != degree:
+                    args[i] = Permutation(args[i], size=degree)
+        if dups:
+            args = list(uniq([_af_new(list(a)) for a in args]))
+        if len(args) > 1:
+            args = [g for g in args if not g.is_identity]
+        return Basic.__new__(cls, *args, **kwargs)
+
+    def __init__(self, *args, **kwargs):
+        self._generators = list(self.args)
+        self._order = None
+        self._elements = []
+        self._center = None
+        self._is_abelian = None
+        self._is_transitive = None
+        self._is_sym = None
+        self._is_alt = None
+        self._is_primitive = None
+        self._is_nilpotent = None
+        self._is_solvable = None
+        self._is_trivial = None
+        self._transitivity_degree = None
+        self._max_div = None
+        self._is_perfect = None
+        self._is_cyclic = None
+        self._is_dihedral = None
+        self._r = len(self._generators)
+        self._degree = self._generators[0].size
+
+        # these attributes are assigned after running schreier_sims
+        self._base = []
+        self._strong_gens = []
+        self._strong_gens_slp = []
+        self._basic_orbits = []
+        self._transversals = []
+        self._transversal_slp = []
+
+        # these attributes are assigned after running _random_pr_init
+        self._random_gens = []
+
+        # finite presentation of the group as an instance of `FpGroup`
+        self._fp_presentation = None
+
+    def __getitem__(self, i):
+        return self._generators[i]
+
+    def __contains__(self, i):
+        """Return ``True`` if *i* is contained in PermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> p = Permutation(1, 2, 3)
+        >>> Permutation(3) in PermutationGroup(p)
+        True
+
+        """
+        if not isinstance(i, Permutation):
+            raise TypeError("A PermutationGroup contains only Permutations as "
+                            "elements, not elements of type %s" % type(i))
+        return self.contains(i)
+
+    def __len__(self):
+        return len(self._generators)
+
+    def equals(self, other):
+        """Return ``True`` if PermutationGroup generated by elements in the
+        group are same i.e they represent the same PermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> p = Permutation(0, 1, 2, 3, 4, 5)
+        >>> G = PermutationGroup([p, p**2])
+        >>> H = PermutationGroup([p**2, p])
+        >>> G.generators == H.generators
+        False
+        >>> G.equals(H)
+        True
+
+        """
+        if not isinstance(other, PermutationGroup):
+            return False
+
+        set_self_gens = set(self.generators)
+        set_other_gens = set(other.generators)
+
+        # before reaching the general case there are also certain
+        # optimisation and obvious cases requiring less or no actual
+        # computation.
+        if set_self_gens == set_other_gens:
+            return True
+
+        # in the most general case it will check that each generator of
+        # one group belongs to the other PermutationGroup and vice-versa
+        for gen1 in set_self_gens:
+            if not other.contains(gen1):
+                return False
+        for gen2 in set_other_gens:
+            if not self.contains(gen2):
+                return False
+        return True
+
+    def __mul__(self, other):
+        """
+        Return the direct product of two permutation groups as a permutation
+        group.
+
+        Explanation
+        ===========
+
+        This implementation realizes the direct product by shifting the index
+        set for the generators of the second group: so if we have ``G`` acting
+        on ``n1`` points and ``H`` acting on ``n2`` points, ``G*H`` acts on
+        ``n1 + n2`` points.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import CyclicGroup
+        >>> G = CyclicGroup(5)
+        >>> H = G*G
+        >>> H
+        PermutationGroup([
+            (9)(0 1 2 3 4),
+            (5 6 7 8 9)])
+        >>> H.order()
+        25
+
+        """
+        if isinstance(other, Permutation):
+            return Coset(other, self, dir='+')
+        gens1 = [perm._array_form for perm in self.generators]
+        gens2 = [perm._array_form for perm in other.generators]
+        n1 = self._degree
+        n2 = other._degree
+        start = list(range(n1))
+        end = list(range(n1, n1 + n2))
+        for i in range(len(gens2)):
+            gens2[i] = [x + n1 for x in gens2[i]]
+        gens2 = [start + gen for gen in gens2]
+        gens1 = [gen + end for gen in gens1]
+        together = gens1 + gens2
+        gens = [_af_new(x) for x in together]
+        return PermutationGroup(gens)
+
+    def _random_pr_init(self, r, n, _random_prec_n=None):
+        r"""Initialize random generators for the product replacement algorithm.
+
+        Explanation
+        ===========
+
+        The implementation uses a modification of the original product
+        replacement algorithm due to Leedham-Green, as described in [1],
+        pp. 69-71; also, see [2], pp. 27-29 for a detailed theoretical
+        analysis of the original product replacement algorithm, and [4].
+
+        The product replacement algorithm is used for producing random,
+        uniformly distributed elements of a group `G` with a set of generators
+        `S`. For the initialization ``_random_pr_init``, a list ``R`` of
+        `\max\{r, |S|\}` group generators is created as the attribute
+        ``G._random_gens``, repeating elements of `S` if necessary, and the
+        identity element of `G` is appended to ``R`` - we shall refer to this
+        last element as the accumulator. Then the function ``random_pr()``
+        is called ``n`` times, randomizing the list ``R`` while preserving
+        the generation of `G` by ``R``. The function ``random_pr()`` itself
+        takes two random elements ``g, h`` among all elements of ``R`` but
+        the accumulator and replaces ``g`` with a randomly chosen element
+        from `\{gh, g(~h), hg, (~h)g\}`. Then the accumulator is multiplied
+        by whatever ``g`` was replaced by. The new value of the accumulator is
+        then returned by ``random_pr()``.
+
+        The elements returned will eventually (for ``n`` large enough) become
+        uniformly distributed across `G` ([5]). For practical purposes however,
+        the values ``n = 50, r = 11`` are suggested in [1].
+
+        Notes
+        =====
+
+        THIS FUNCTION HAS SIDE EFFECTS: it changes the attribute
+        self._random_gens
+
+        See Also
+        ========
+
+        random_pr
+
+        """
+        deg = self.degree
+        random_gens = [x._array_form for x in self.generators]
+        k = len(random_gens)
+        if k < r:
+            for i in range(k, r):
+                random_gens.append(random_gens[i - k])
+        acc = list(range(deg))
+        random_gens.append(acc)
+        self._random_gens = random_gens
+
+        # handle randomized input for testing purposes
+        if _random_prec_n is None:
+            for i in range(n):
+                self.random_pr()
+        else:
+            for i in range(n):
+                self.random_pr(_random_prec=_random_prec_n[i])
+
+    def _union_find_merge(self, first, second, ranks, parents, not_rep):
+        """Merges two classes in a union-find data structure.
+
+        Explanation
+        ===========
+
+        Used in the implementation of Atkinson's algorithm as suggested in [1],
+        pp. 83-87. The class merging process uses union by rank as an
+        optimization. ([7])
+
+        Notes
+        =====
+
+        THIS FUNCTION HAS SIDE EFFECTS: the list of class representatives,
+        ``parents``, the list of class sizes, ``ranks``, and the list of
+        elements that are not representatives, ``not_rep``, are changed due to
+        class merging.
+
+        See Also
+        ========
+
+        minimal_block, _union_find_rep
+
+        References
+        ==========
+
+        .. [1] Holt, D., Eick, B., O'Brien, E.
+               "Handbook of computational group theory"
+
+        .. [7] https://algorithmist.com/wiki/Union_find
+
+        """
+        rep_first = self._union_find_rep(first, parents)
+        rep_second = self._union_find_rep(second, parents)
+        if rep_first != rep_second:
+            # union by rank
+            if ranks[rep_first] >= ranks[rep_second]:
+                new_1, new_2 = rep_first, rep_second
+            else:
+                new_1, new_2 = rep_second, rep_first
+            total_rank = ranks[new_1] + ranks[new_2]
+            if total_rank > self.max_div:
+                return -1
+            parents[new_2] = new_1
+            ranks[new_1] = total_rank
+            not_rep.append(new_2)
+            return 1
+        return 0
+
+    def _union_find_rep(self, num, parents):
+        """Find representative of a class in a union-find data structure.
+
+        Explanation
+        ===========
+
+        Used in the implementation of Atkinson's algorithm as suggested in [1],
+        pp. 83-87. After the representative of the class to which ``num``
+        belongs is found, path compression is performed as an optimization
+        ([7]).
+
+        Notes
+        =====
+
+        THIS FUNCTION HAS SIDE EFFECTS: the list of class representatives,
+        ``parents``, is altered due to path compression.
+
+        See Also
+        ========
+
+        minimal_block, _union_find_merge
+
+        References
+        ==========
+
+        .. [1] Holt, D., Eick, B., O'Brien, E.
+               "Handbook of computational group theory"
+
+        .. [7] https://algorithmist.com/wiki/Union_find
+
+        """
+        rep, parent = num, parents[num]
+        while parent != rep:
+            rep = parent
+            parent = parents[rep]
+        # path compression
+        temp, parent = num, parents[num]
+        while parent != rep:
+            parents[temp] = rep
+            temp = parent
+            parent = parents[temp]
+        return rep
+
+    @property
+    def base(self):
+        r"""Return a base from the Schreier-Sims algorithm.
+
+        Explanation
+        ===========
+
+        For a permutation group `G`, a base is a sequence of points
+        `B = (b_1, b_2, \dots, b_k)` such that no element of `G` apart
+        from the identity fixes all the points in `B`. The concepts of
+        a base and strong generating set and their applications are
+        discussed in depth in [1], pp. 87-89 and [2], pp. 55-57.
+
+        An alternative way to think of `B` is that it gives the
+        indices of the stabilizer cosets that contain more than the
+        identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> G = PermutationGroup([Permutation(0, 1, 3)(2, 4)])
+        >>> G.base
+        [0, 2]
+
+        See Also
+        ========
+
+        strong_gens, basic_transversals, basic_orbits, basic_stabilizers
+
+        """
+        if self._base == []:
+            self.schreier_sims()
+        return self._base
+
+    def baseswap(self, base, strong_gens, pos, randomized=False,
+                 transversals=None, basic_orbits=None, strong_gens_distr=None):
+        r"""Swap two consecutive base points in base and strong generating set.
+
+        Explanation
+        ===========
+
+        If a base for a group `G` is given by `(b_1, b_2, \dots, b_k)`, this
+        function returns a base `(b_1, b_2, \dots, b_{i+1}, b_i, \dots, b_k)`,
+        where `i` is given by ``pos``, and a strong generating set relative
+        to that base. The original base and strong generating set are not
+        modified.
+
+        The randomized version (default) is of Las Vegas type.
+
+        Parameters
+        ==========
+
+        base, strong_gens
+            The base and strong generating set.
+        pos
+            The position at which swapping is performed.
+        randomized
+            A switch between randomized and deterministic version.
+        transversals
+            The transversals for the basic orbits, if known.
+        basic_orbits
+            The basic orbits, if known.
+        strong_gens_distr
+            The strong generators distributed by basic stabilizers, if known.
+
+        Returns
+        =======
+
+        (base, strong_gens)
+            ``base`` is the new base, and ``strong_gens`` is a generating set
+            relative to it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.testutil import _verify_bsgs
+        >>> from sympy.combinatorics.perm_groups import PermutationGroup
+        >>> S = SymmetricGroup(4)
+        >>> S.schreier_sims()
+        >>> S.base
+        [0, 1, 2]
+        >>> base, gens = S.baseswap(S.base, S.strong_gens, 1, randomized=False)
+        >>> base, gens
+        ([0, 2, 1],
+        [(0 1 2 3), (3)(0 1), (1 3 2),
+         (2 3), (1 3)])
+
+        check that base, gens is a BSGS
+
+        >>> S1 = PermutationGroup(gens)
+        >>> _verify_bsgs(S1, base, gens)
+        True
+
+        See Also
+        ========
+
+        schreier_sims
+
+        Notes
+        =====
+
+        The deterministic version of the algorithm is discussed in
+        [1], pp. 102-103; the randomized version is discussed in [1], p.103, and
+        [2], p.98. It is of Las Vegas type.
+        Notice that [1] contains a mistake in the pseudocode and
+        discussion of BASESWAP: on line 3 of the pseudocode,
+        `|\beta_{i+1}^{\left\langle T\right\rangle}|` should be replaced by
+        `|\beta_{i}^{\left\langle T\right\rangle}|`, and the same for the
+        discussion of the algorithm.
+
+        """
+        # construct the basic orbits, generators for the stabilizer chain
+        # and transversal elements from whatever was provided
+        transversals, basic_orbits, strong_gens_distr = \
+            _handle_precomputed_bsgs(base, strong_gens, transversals,
+                                 basic_orbits, strong_gens_distr)
+        base_len = len(base)
+        degree = self.degree
+        # size of orbit of base[pos] under the stabilizer we seek to insert
+        # in the stabilizer chain at position pos + 1
+        size = len(basic_orbits[pos])*len(basic_orbits[pos + 1]) \
+            //len(_orbit(degree, strong_gens_distr[pos], base[pos + 1]))
+        # initialize the wanted stabilizer by a subgroup
+        if pos + 2 > base_len - 1:
+            T = []
+        else:
+            T = strong_gens_distr[pos + 2][:]
+        # randomized version
+        if randomized is True:
+            stab_pos = PermutationGroup(strong_gens_distr[pos])
+            schreier_vector = stab_pos.schreier_vector(base[pos + 1])
+            # add random elements of the stabilizer until they generate it
+            while len(_orbit(degree, T, base[pos])) != size:
+                new = stab_pos.random_stab(base[pos + 1],
+                                           schreier_vector=schreier_vector)
+                T.append(new)
+        # deterministic version
+        else:
+            Gamma = set(basic_orbits[pos])
+            Gamma.remove(base[pos])
+            if base[pos + 1] in Gamma:
+                Gamma.remove(base[pos + 1])
+            # add elements of the stabilizer until they generate it by
+            # ruling out member of the basic orbit of base[pos] along the way
+            while len(_orbit(degree, T, base[pos])) != size:
+                gamma = next(iter(Gamma))
+                x = transversals[pos][gamma]
+                temp = x._array_form.index(base[pos + 1]) # (~x)(base[pos + 1])
+                if temp not in basic_orbits[pos + 1]:
+                    Gamma = Gamma - _orbit(degree, T, gamma)
+                else:
+                    y = transversals[pos + 1][temp]
+                    el = rmul(x, y)
+                    if el(base[pos]) not in _orbit(degree, T, base[pos]):
+                        T.append(el)
+                        Gamma = Gamma - _orbit(degree, T, base[pos])
+        # build the new base and strong generating set
+        strong_gens_new_distr = strong_gens_distr[:]
+        strong_gens_new_distr[pos + 1] = T
+        base_new = base[:]
+        base_new[pos], base_new[pos + 1] = base_new[pos + 1], base_new[pos]
+        strong_gens_new = _strong_gens_from_distr(strong_gens_new_distr)
+        for gen in T:
+            if gen not in strong_gens_new:
+                strong_gens_new.append(gen)
+        return base_new, strong_gens_new
+
+    @property
+    def basic_orbits(self):
+        r"""
+        Return the basic orbits relative to a base and strong generating set.
+
+        Explanation
+        ===========
+
+        If `(b_1, b_2, \dots, b_k)` is a base for a group `G`, and
+        `G^{(i)} = G_{b_1, b_2, \dots, b_{i-1}}` is the ``i``-th basic stabilizer
+        (so that `G^{(1)} = G`), the ``i``-th basic orbit relative to this base
+        is the orbit of `b_i` under `G^{(i)}`. See [1], pp. 87-89 for more
+        information.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> S = SymmetricGroup(4)
+        >>> S.basic_orbits
+        [[0, 1, 2, 3], [1, 2, 3], [2, 3]]
+
+        See Also
+        ========
+
+        base, strong_gens, basic_transversals, basic_stabilizers
+
+        """
+        if self._basic_orbits == []:
+            self.schreier_sims()
+        return self._basic_orbits
+
+    @property
+    def basic_stabilizers(self):
+        r"""
+        Return a chain of stabilizers relative to a base and strong generating
+        set.
+
+        Explanation
+        ===========
+
+        The ``i``-th basic stabilizer `G^{(i)}` relative to a base
+        `(b_1, b_2, \dots, b_k)` is `G_{b_1, b_2, \dots, b_{i-1}}`. For more
+        information, see [1], pp. 87-89.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import AlternatingGroup
+        >>> A = AlternatingGroup(4)
+        >>> A.schreier_sims()
+        >>> A.base
+        [0, 1]
+        >>> for g in A.basic_stabilizers:
+        ...     print(g)
+        ...
+        PermutationGroup([
+            (3)(0 1 2),
+            (1 2 3)])
+        PermutationGroup([
+            (1 2 3)])
+
+        See Also
+        ========
+
+        base, strong_gens, basic_orbits, basic_transversals
+
+        """
+
+        if self._transversals == []:
+            self.schreier_sims()
+        strong_gens = self._strong_gens
+        base = self._base
+        if not base: # e.g. if self is trivial
+            return []
+        strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+        basic_stabilizers = []
+        for gens in strong_gens_distr:
+            basic_stabilizers.append(PermutationGroup(gens))
+        return basic_stabilizers
+
+    @property
+    def basic_transversals(self):
+        """
+        Return basic transversals relative to a base and strong generating set.
+
+        Explanation
+        ===========
+
+        The basic transversals are transversals of the basic orbits. They
+        are provided as a list of dictionaries, each dictionary having
+        keys - the elements of one of the basic orbits, and values - the
+        corresponding transversal elements. See [1], pp. 87-89 for more
+        information.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import AlternatingGroup
+        >>> A = AlternatingGroup(4)
+        >>> A.basic_transversals
+        [{0: (3), 1: (3)(0 1 2), 2: (3)(0 2 1), 3: (0 3 1)}, {1: (3), 2: (1 2 3), 3: (1 3 2)}]
+
+        See Also
+        ========
+
+        strong_gens, base, basic_orbits, basic_stabilizers
+
+        """
+
+        if self._transversals == []:
+            self.schreier_sims()
+        return self._transversals
+
+    def composition_series(self):
+        r"""
+        Return the composition series for a group as a list
+        of permutation groups.
+
+        Explanation
+        ===========
+
+        The composition series for a group `G` is defined as a
+        subnormal series `G = H_0 > H_1 > H_2 \ldots` A composition
+        series is a subnormal series such that each factor group
+        `H(i+1) / H(i)` is simple.
+        A subnormal series is a composition series only if it is of
+        maximum length.
+
+        The algorithm works as follows:
+        Starting with the derived series the idea is to fill
+        the gap between `G = der[i]` and `H = der[i+1]` for each
+        `i` independently. Since, all subgroups of the abelian group
+        `G/H` are normal so, first step is to take the generators
+        `g` of `G` and add them to generators of `H` one by one.
+
+        The factor groups formed are not simple in general. Each
+        group is obtained from the previous one by adding one
+        generator `g`, if the previous group is denoted by `H`
+        then the next group `K` is generated by `g` and `H`.
+        The factor group `K/H` is cyclic and it's order is
+        `K.order()//G.order()`. The series is then extended between
+        `K` and `H` by groups generated by powers of `g` and `H`.
+        The series formed is then prepended to the already existing
+        series.
+
+        Examples
+        ========
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.named_groups import CyclicGroup
+        >>> S = SymmetricGroup(12)
+        >>> G = S.sylow_subgroup(2)
+        >>> C = G.composition_series()
+        >>> [H.order() for H in C]
+        [1024, 512, 256, 128, 64, 32, 16, 8, 4, 2, 1]
+        >>> G = S.sylow_subgroup(3)
+        >>> C = G.composition_series()
+        >>> [H.order() for H in C]
+        [243, 81, 27, 9, 3, 1]
+        >>> G = CyclicGroup(12)
+        >>> C = G.composition_series()
+        >>> [H.order() for H in C]
+        [12, 6, 3, 1]
+
+        """
+        der = self.derived_series()
+        if not all(g.is_identity for g in der[-1].generators):
+            raise NotImplementedError('Group should be solvable')
+        series = []
+
+        for i in range(len(der)-1):
+            H = der[i+1]
+            up_seg = []
+            for g in der[i].generators:
+                K = PermutationGroup([g] + H.generators)
+                order = K.order() // H.order()
+                down_seg = []
+                for p, e in factorint(order).items():
+                    for _ in range(e):
+                        down_seg.append(PermutationGroup([g] + H.generators))
+                        g = g**p
+                up_seg = down_seg + up_seg
+                H = K
+            up_seg[0] = der[i]
+            series.extend(up_seg)
+        series.append(der[-1])
+        return series
+
+    def coset_transversal(self, H):
+        """Return a transversal of the right cosets of self by its subgroup H
+        using the second method described in [1], Subsection 4.6.7
+
+        """
+
+        if not H.is_subgroup(self):
+            raise ValueError("The argument must be a subgroup")
+
+        if H.order() == 1:
+            return self.elements
+
+        self._schreier_sims(base=H.base) # make G.base an extension of H.base
+
+        base = self.base
+        base_ordering = _base_ordering(base, self.degree)
+        identity = Permutation(self.degree - 1)
+
+        transversals = self.basic_transversals[:]
+        # transversals is a list of dictionaries. Get rid of the keys
+        # so that it is a list of lists and sort each list in
+        # the increasing order of base[l]^x
+        for l, t in enumerate(transversals):
+            transversals[l] = sorted(t.values(),
+                                key = lambda x: base_ordering[base[l]^x])
+
+        orbits = H.basic_orbits
+        h_stabs = H.basic_stabilizers
+        g_stabs = self.basic_stabilizers
+
+        indices = [x.order()//y.order() for x, y in zip(g_stabs, h_stabs)]
+
+        # T^(l) should be a right transversal of H^(l) in G^(l) for
+        # 1<=l<=len(base). While H^(l) is the trivial group, T^(l)
+        # contains all the elements of G^(l) so we might just as well
+        # start with l = len(h_stabs)-1
+        if len(g_stabs) > len(h_stabs):
+            T = g_stabs[len(h_stabs)].elements
+        else:
+            T = [identity]
+        l = len(h_stabs)-1
+        t_len = len(T)
+        while l > -1:
+            T_next = []
+            for u in transversals[l]:
+                if u == identity:
+                    continue
+                b = base_ordering[base[l]^u]
+                for t in T:
+                    p = t*u
+                    if all(base_ordering[h^p] >= b for h in orbits[l]):
+                        T_next.append(p)
+                    if t_len + len(T_next) == indices[l]:
+                        break
+                if t_len + len(T_next) == indices[l]:
+                    break
+            T += T_next
+            t_len += len(T_next)
+            l -= 1
+        T.remove(identity)
+        T = [identity] + T
+        return T
+
+    def _coset_representative(self, g, H):
+        """Return the representative of Hg from the transversal that
+        would be computed by ``self.coset_transversal(H)``.
+
+        """
+        if H.order() == 1:
+            return g
+        # The base of self must be an extension of H.base.
+        if not(self.base[:len(H.base)] == H.base):
+            self._schreier_sims(base=H.base)
+        orbits = H.basic_orbits[:]
+        h_transversals = [list(_.values()) for _ in H.basic_transversals]
+        transversals = [list(_.values()) for _ in self.basic_transversals]
+        base = self.base
+        base_ordering = _base_ordering(base, self.degree)
+        def step(l, x):
+            gamma = min(orbits[l], key = lambda y: base_ordering[y^x])
+            i = [base[l]^h for h in h_transversals[l]].index(gamma)
+            x = h_transversals[l][i]*x
+            if l < len(orbits)-1:
+                for u in transversals[l]:
+                    if base[l]^u == base[l]^x:
+                        break
+                x = step(l+1, x*u**-1)*u
+            return x
+        return step(0, g)
+
+    def coset_table(self, H):
+        """Return the standardised (right) coset table of self in H as
+        a list of lists.
+        """
+        # Maybe this should be made to return an instance of CosetTable
+        # from fp_groups.py but the class would need to be changed first
+        # to be compatible with PermutationGroups
+
+        if not H.is_subgroup(self):
+            raise ValueError("The argument must be a subgroup")
+        T = self.coset_transversal(H)
+        n = len(T)
+
+        A = list(chain.from_iterable((gen, gen**-1)
+                    for gen in self.generators))
+
+        table = []
+        for i in range(n):
+            row = [self._coset_representative(T[i]*x, H) for x in A]
+            row = [T.index(r) for r in row]
+            table.append(row)
+
+        # standardize (this is the same as the algorithm used in coset_table)
+        # If CosetTable is made compatible with PermutationGroups, this
+        # should be replaced by table.standardize()
+        A = range(len(A))
+        gamma = 1
+        for alpha, a in product(range(n), A):
+            beta = table[alpha][a]
+            if beta >= gamma:
+                if beta > gamma:
+                    for x in A:
+                        z = table[gamma][x]
+                        table[gamma][x] = table[beta][x]
+                        table[beta][x] = z
+                        for i in range(n):
+                            if table[i][x] == beta:
+                                table[i][x] = gamma
+                            elif table[i][x] == gamma:
+                                table[i][x] = beta
+                gamma += 1
+            if gamma >= n-1:
+                return table
+
+    def center(self):
+        r"""
+        Return the center of a permutation group.
+
+        Explanation
+        ===========
+
+        The center for a group `G` is defined as
+        `Z(G) = \{z\in G | \forall g\in G, zg = gz \}`,
+        the set of elements of `G` that commute with all elements of `G`.
+        It is equal to the centralizer of `G` inside `G`, and is naturally a
+        subgroup of `G` ([9]).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> D = DihedralGroup(4)
+        >>> G = D.center()
+        >>> G.order()
+        2
+
+        See Also
+        ========
+
+        centralizer
+
+        Notes
+        =====
+
+        This is a naive implementation that is a straightforward application
+        of ``.centralizer()``
+
+        """
+        if not self._center:
+            self._center = self.centralizer(self)
+        return self._center
+
+    def centralizer(self, other):
+        r"""
+        Return the centralizer of a group/set/element.
+
+        Explanation
+        ===========
+
+        The centralizer of a set of permutations ``S`` inside
+        a group ``G`` is the set of elements of ``G`` that commute with all
+        elements of ``S``::
+
+            `C_G(S) = \{ g \in G | gs = sg \forall s \in S\}` ([10])
+
+        Usually, ``S`` is a subset of ``G``, but if ``G`` is a proper subgroup of
+        the full symmetric group, we allow for ``S`` to have elements outside
+        ``G``.
+
+        It is naturally a subgroup of ``G``; the centralizer of a permutation
+        group is equal to the centralizer of any set of generators for that
+        group, since any element commuting with the generators commutes with
+        any product of the  generators.
+
+        Parameters
+        ==========
+
+        other
+            a permutation group/list of permutations/single permutation
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... CyclicGroup)
+        >>> S = SymmetricGroup(6)
+        >>> C = CyclicGroup(6)
+        >>> H = S.centralizer(C)
+        >>> H.is_subgroup(C)
+        True
+
+        See Also
+        ========
+
+        subgroup_search
+
+        Notes
+        =====
+
+        The implementation is an application of ``.subgroup_search()`` with
+        tests using a specific base for the group ``G``.
+
+        """
+        if hasattr(other, 'generators'):
+            if other.is_trivial or self.is_trivial:
+                return self
+            degree = self.degree
+            identity = _af_new(list(range(degree)))
+            orbits = other.orbits()
+            num_orbits = len(orbits)
+            orbits.sort(key=lambda x: -len(x))
+            long_base = []
+            orbit_reps = [None]*num_orbits
+            orbit_reps_indices = [None]*num_orbits
+            orbit_descr = [None]*degree
+            for i in range(num_orbits):
+                orbit = list(orbits[i])
+                orbit_reps[i] = orbit[0]
+                orbit_reps_indices[i] = len(long_base)
+                for point in orbit:
+                    orbit_descr[point] = i
+                long_base = long_base + orbit
+            base, strong_gens = self.schreier_sims_incremental(base=long_base)
+            strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+            i = 0
+            for i in range(len(base)):
+                if strong_gens_distr[i] == [identity]:
+                    break
+            base = base[:i]
+            base_len = i
+            for j in range(num_orbits):
+                if base[base_len - 1] in orbits[j]:
+                    break
+            rel_orbits = orbits[: j + 1]
+            num_rel_orbits = len(rel_orbits)
+            transversals = [None]*num_rel_orbits
+            for j in range(num_rel_orbits):
+                rep = orbit_reps[j]
+                transversals[j] = dict(
+                    other.orbit_transversal(rep, pairs=True))
+            trivial_test = lambda x: True
+            tests = [None]*base_len
+            for l in range(base_len):
+                if base[l] in orbit_reps:
+                    tests[l] = trivial_test
+                else:
+                    def test(computed_words, l=l):
+                        g = computed_words[l]
+                        rep_orb_index = orbit_descr[base[l]]
+                        rep = orbit_reps[rep_orb_index]
+                        im = g._array_form[base[l]]
+                        im_rep = g._array_form[rep]
+                        tr_el = transversals[rep_orb_index][base[l]]
+                        # using the definition of transversal,
+                        # base[l]^g = rep^(tr_el*g);
+                        # if g belongs to the centralizer, then
+                        # base[l]^g = (rep^g)^tr_el
+                        return im == tr_el._array_form[im_rep]
+                    tests[l] = test
+
+            def prop(g):
+                return [rmul(g, gen) for gen in other.generators] == \
+                       [rmul(gen, g) for gen in other.generators]
+            return self.subgroup_search(prop, base=base,
+                                        strong_gens=strong_gens, tests=tests)
+        elif hasattr(other, '__getitem__'):
+            gens = list(other)
+            return self.centralizer(PermutationGroup(gens))
+        elif hasattr(other, 'array_form'):
+            return self.centralizer(PermutationGroup([other]))
+
+    def commutator(self, G, H):
+        """
+        Return the commutator of two subgroups.
+
+        Explanation
+        ===========
+
+        For a permutation group ``K`` and subgroups ``G``, ``H``, the
+        commutator of ``G`` and ``H`` is defined as the group generated
+        by all the commutators `[g, h] = hgh^{-1}g^{-1}` for ``g`` in ``G`` and
+        ``h`` in ``H``. It is naturally a subgroup of ``K`` ([1], p.27).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... AlternatingGroup)
+        >>> S = SymmetricGroup(5)
+        >>> A = AlternatingGroup(5)
+        >>> G = S.commutator(S, A)
+        >>> G.is_subgroup(A)
+        True
+
+        See Also
+        ========
+
+        derived_subgroup
+
+        Notes
+        =====
+
+        The commutator of two subgroups `H, G` is equal to the normal closure
+        of the commutators of all the generators, i.e. `hgh^{-1}g^{-1}` for `h`
+        a generator of `H` and `g` a generator of `G` ([1], p.28)
+
+        """
+        ggens = G.generators
+        hgens = H.generators
+        commutators = []
+        for ggen in ggens:
+            for hgen in hgens:
+                commutator = rmul(hgen, ggen, ~hgen, ~ggen)
+                if commutator not in commutators:
+                    commutators.append(commutator)
+        res = self.normal_closure(commutators)
+        return res
+
+    def coset_factor(self, g, factor_index=False):
+        """Return ``G``'s (self's) coset factorization of ``g``
+
+        Explanation
+        ===========
+
+        If ``g`` is an element of ``G`` then it can be written as the product
+        of permutations drawn from the Schreier-Sims coset decomposition,
+
+        The permutations returned in ``f`` are those for which
+        the product gives ``g``: ``g = f[n]*...f[1]*f[0]`` where ``n = len(B)``
+        and ``B = G.base``. f[i] is one of the permutations in
+        ``self._basic_orbits[i]``.
+
+        If factor_index==True,
+        returns a tuple ``[b[0],..,b[n]]``, where ``b[i]``
+        belongs to ``self._basic_orbits[i]``
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation(0, 1, 3, 7, 6, 4)(2, 5)
+        >>> b = Permutation(0, 1, 3, 2)(4, 5, 7, 6)
+        >>> G = PermutationGroup([a, b])
+
+        Define g:
+
+        >>> g = Permutation(7)(1, 2, 4)(3, 6, 5)
+
+        Confirm that it is an element of G:
+
+        >>> G.contains(g)
+        True
+
+        Thus, it can be written as a product of factors (up to
+        3) drawn from u. See below that a factor from u1 and u2
+        and the Identity permutation have been used:
+
+        >>> f = G.coset_factor(g)
+        >>> f[2]*f[1]*f[0] == g
+        True
+        >>> f1 = G.coset_factor(g, True); f1
+        [0, 4, 4]
+        >>> tr = G.basic_transversals
+        >>> f[0] == tr[0][f1[0]]
+        True
+
+        If g is not an element of G then [] is returned:
+
+        >>> c = Permutation(5, 6, 7)
+        >>> G.coset_factor(c)
+        []
+
+        See Also
+        ========
+
+        sympy.combinatorics.util._strip
+
+        """
+        if isinstance(g, (Cycle, Permutation)):
+            g = g.list()
+        if len(g) != self._degree:
+            # this could either adjust the size or return [] immediately
+            # but we don't choose between the two and just signal a possible
+            # error
+            raise ValueError('g should be the same size as permutations of G')
+        I = list(range(self._degree))
+        basic_orbits = self.basic_orbits
+        transversals = self._transversals
+        factors = []
+        base = self.base
+        h = g
+        for i in range(len(base)):
+            beta = h[base[i]]
+            if beta == base[i]:
+                factors.append(beta)
+                continue
+            if beta not in basic_orbits[i]:
+                return []
+            u = transversals[i][beta]._array_form
+            h = _af_rmul(_af_invert(u), h)
+            factors.append(beta)
+        if h != I:
+            return []
+        if factor_index:
+            return factors
+        tr = self.basic_transversals
+        factors = [tr[i][factors[i]] for i in range(len(base))]
+        return factors
+
+    def generator_product(self, g, original=False):
+        r'''
+        Return a list of strong generators `[s1, \dots, sn]`
+        s.t `g = sn \times \dots \times s1`. If ``original=True``, make the
+        list contain only the original group generators
+
+        '''
+        product = []
+        if g.is_identity:
+            return []
+        if g in self.strong_gens:
+            if not original or g in self.generators:
+                return [g]
+            else:
+                slp = self._strong_gens_slp[g]
+                for s in slp:
+                    product.extend(self.generator_product(s, original=True))
+                return product
+        elif g**-1 in self.strong_gens:
+            g = g**-1
+            if not original or g in self.generators:
+                return [g**-1]
+            else:
+                slp = self._strong_gens_slp[g]
+                for s in slp:
+                    product.extend(self.generator_product(s, original=True))
+                l = len(product)
+                product = [product[l-i-1]**-1 for i in range(l)]
+                return product
+
+        f = self.coset_factor(g, True)
+        for i, j in enumerate(f):
+            slp = self._transversal_slp[i][j]
+            for s in slp:
+                if not original:
+                    product.append(self.strong_gens[s])
+                else:
+                    s = self.strong_gens[s]
+                    product.extend(self.generator_product(s, original=True))
+        return product
+
+    def coset_rank(self, g):
+        """rank using Schreier-Sims representation.
+
+        Explanation
+        ===========
+
+        The coset rank of ``g`` is the ordering number in which
+        it appears in the lexicographic listing according to the
+        coset decomposition
+
+        The ordering is the same as in G.generate(method='coset').
+        If ``g`` does not belong to the group it returns None.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation(0, 1, 3, 7, 6, 4)(2, 5)
+        >>> b = Permutation(0, 1, 3, 2)(4, 5, 7, 6)
+        >>> G = PermutationGroup([a, b])
+        >>> c = Permutation(7)(2, 4)(3, 5)
+        >>> G.coset_rank(c)
+        16
+        >>> G.coset_unrank(16)
+        (7)(2 4)(3 5)
+
+        See Also
+        ========
+
+        coset_factor
+
+        """
+        factors = self.coset_factor(g, True)
+        if not factors:
+            return None
+        rank = 0
+        b = 1
+        transversals = self._transversals
+        base = self._base
+        basic_orbits = self._basic_orbits
+        for i in range(len(base)):
+            k = factors[i]
+            j = basic_orbits[i].index(k)
+            rank += b*j
+            b = b*len(transversals[i])
+        return rank
+
+    def coset_unrank(self, rank, af=False):
+        """unrank using Schreier-Sims representation
+
+        coset_unrank is the inverse operation of coset_rank
+        if 0 <= rank < order; otherwise it returns None.
+
+        """
+        if rank < 0 or rank >= self.order():
+            return None
+        base = self.base
+        transversals = self.basic_transversals
+        basic_orbits = self.basic_orbits
+        m = len(base)
+        v = [0]*m
+        for i in range(m):
+            rank, c = divmod(rank, len(transversals[i]))
+            v[i] = basic_orbits[i][c]
+        a = [transversals[i][v[i]]._array_form for i in range(m)]
+        h = _af_rmuln(*a)
+        if af:
+            return h
+        else:
+            return _af_new(h)
+
+    @property
+    def degree(self):
+        """Returns the size of the permutations in the group.
+
+        Explanation
+        ===========
+
+        The number of permutations comprising the group is given by
+        ``len(group)``; the number of permutations that can be generated
+        by the group is given by ``group.order()``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a])
+        >>> G.degree
+        3
+        >>> len(G)
+        1
+        >>> G.order()
+        2
+        >>> list(G.generate())
+        [(2), (2)(0 1)]
+
+        See Also
+        ========
+
+        order
+        """
+        return self._degree
+
+    @property
+    def identity(self):
+        '''
+        Return the identity element of the permutation group.
+
+        '''
+        return _af_new(list(range(self.degree)))
+
+    @property
+    def elements(self):
+        """Returns all the elements of the permutation group as a list
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> p = PermutationGroup(Permutation(1, 3), Permutation(1, 2))
+        >>> p.elements
+        [(3), (3)(1 2), (1 3), (2 3), (1 2 3), (1 3 2)]
+
+        """
+        if not self._elements:
+            self._elements = list(self.generate())
+
+        return self._elements
+
+    def derived_series(self):
+        r"""Return the derived series for the group.
+
+        Explanation
+        ===========
+
+        The derived series for a group `G` is defined as
+        `G = G_0 > G_1 > G_2 > \ldots` where `G_i = [G_{i-1}, G_{i-1}]`,
+        i.e. `G_i` is the derived subgroup of `G_{i-1}`, for
+        `i\in\mathbb{N}`. When we have `G_k = G_{k-1}` for some
+        `k\in\mathbb{N}`, the series terminates.
+
+        Returns
+        =======
+
+        A list of permutation groups containing the members of the derived
+        series in the order `G = G_0, G_1, G_2, \ldots`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... AlternatingGroup, DihedralGroup)
+        >>> A = AlternatingGroup(5)
+        >>> len(A.derived_series())
+        1
+        >>> S = SymmetricGroup(4)
+        >>> len(S.derived_series())
+        4
+        >>> S.derived_series()[1].is_subgroup(AlternatingGroup(4))
+        True
+        >>> S.derived_series()[2].is_subgroup(DihedralGroup(2))
+        True
+
+        See Also
+        ========
+
+        derived_subgroup
+
+        """
+        res = [self]
+        current = self
+        nxt = self.derived_subgroup()
+        while not current.is_subgroup(nxt):
+            res.append(nxt)
+            current = nxt
+            nxt = nxt.derived_subgroup()
+        return res
+
+    def derived_subgroup(self):
+        r"""Compute the derived subgroup.
+
+        Explanation
+        ===========
+
+        The derived subgroup, or commutator subgroup is the subgroup generated
+        by all commutators `[g, h] = hgh^{-1}g^{-1}` for `g, h\in G` ; it is
+        equal to the normal closure of the set of commutators of the generators
+        ([1], p.28, [11]).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([1, 0, 2, 4, 3])
+        >>> b = Permutation([0, 1, 3, 2, 4])
+        >>> G = PermutationGroup([a, b])
+        >>> C = G.derived_subgroup()
+        >>> list(C.generate(af=True))
+        [[0, 1, 2, 3, 4], [0, 1, 3, 4, 2], [0, 1, 4, 2, 3]]
+
+        See Also
+        ========
+
+        derived_series
+
+        """
+        r = self._r
+        gens = [p._array_form for p in self.generators]
+        set_commutators = set()
+        degree = self._degree
+        rng = list(range(degree))
+        for i in range(r):
+            for j in range(r):
+                p1 = gens[i]
+                p2 = gens[j]
+                c = list(range(degree))
+                for k in rng:
+                    c[p2[p1[k]]] = p1[p2[k]]
+                ct = tuple(c)
+                if ct not in set_commutators:
+                    set_commutators.add(ct)
+        cms = [_af_new(p) for p in set_commutators]
+        G2 = self.normal_closure(cms)
+        return G2
+
+    def generate(self, method="coset", af=False):
+        """Return iterator to generate the elements of the group.
+
+        Explanation
+        ===========
+
+        Iteration is done with one of these methods::
+
+          method='coset'  using the Schreier-Sims coset representation
+          method='dimino' using the Dimino method
+
+        If ``af = True`` it yields the array form of the permutations
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import PermutationGroup
+        >>> from sympy.combinatorics.polyhedron import tetrahedron
+
+        The permutation group given in the tetrahedron object is also
+        true groups:
+
+        >>> G = tetrahedron.pgroup
+        >>> G.is_group
+        True
+
+        Also the group generated by the permutations in the tetrahedron
+        pgroup -- even the first two -- is a proper group:
+
+        >>> H = PermutationGroup(G[0], G[1])
+        >>> J = PermutationGroup(list(H.generate())); J
+        PermutationGroup([
+            (0 1)(2 3),
+            (1 2 3),
+            (1 3 2),
+            (0 3 1),
+            (0 2 3),
+            (0 3)(1 2),
+            (0 1 3),
+            (3)(0 2 1),
+            (0 3 2),
+            (3)(0 1 2),
+            (0 2)(1 3)])
+        >>> _.is_group
+        True
+        """
+        if method == "coset":
+            return self.generate_schreier_sims(af)
+        elif method == "dimino":
+            return self.generate_dimino(af)
+        else:
+            raise NotImplementedError('No generation defined for %s' % method)
+
+    def generate_dimino(self, af=False):
+        """Yield group elements using Dimino's algorithm.
+
+        If ``af == True`` it yields the array form of the permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1, 3])
+        >>> b = Permutation([0, 2, 3, 1])
+        >>> g = PermutationGroup([a, b])
+        >>> list(g.generate_dimino(af=True))
+        [[0, 1, 2, 3], [0, 2, 1, 3], [0, 2, 3, 1],
+         [0, 1, 3, 2], [0, 3, 2, 1], [0, 3, 1, 2]]
+
+        References
+        ==========
+
+        .. [1] The Implementation of Various Algorithms for Permutation Groups in
+               the Computer Algebra System: AXIOM, N.J. Doye, M.Sc. Thesis
+
+        """
+        idn = list(range(self.degree))
+        order = 0
+        element_list = [idn]
+        set_element_list = {tuple(idn)}
+        if af:
+            yield idn
+        else:
+            yield _af_new(idn)
+        gens = [p._array_form for p in self.generators]
+
+        for i in range(len(gens)):
+            # D elements of the subgroup G_i generated by gens[:i]
+            D = element_list.copy()
+            N = [idn]
+            while N:
+                A = N
+                N = []
+                for a in A:
+                    for g in gens[:i + 1]:
+                        ag = _af_rmul(a, g)
+                        if tuple(ag) not in set_element_list:
+                            # produce G_i*g
+                            for d in D:
+                                order += 1
+                                ap = _af_rmul(d, ag)
+                                if af:
+                                    yield ap
+                                else:
+                                    p = _af_new(ap)
+                                    yield p
+                                element_list.append(ap)
+                                set_element_list.add(tuple(ap))
+                                N.append(ap)
+        self._order = len(element_list)
+
+    def generate_schreier_sims(self, af=False):
+        """Yield group elements using the Schreier-Sims representation
+        in coset_rank order
+
+        If ``af = True`` it yields the array form of the permutations
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1, 3])
+        >>> b = Permutation([0, 2, 3, 1])
+        >>> g = PermutationGroup([a, b])
+        >>> list(g.generate_schreier_sims(af=True))
+        [[0, 1, 2, 3], [0, 2, 1, 3], [0, 3, 2, 1],
+         [0, 1, 3, 2], [0, 2, 3, 1], [0, 3, 1, 2]]
+        """
+
+        n = self._degree
+        u = self.basic_transversals
+        basic_orbits = self._basic_orbits
+        if len(u) == 0:
+            for x in self.generators:
+                if af:
+                    yield x._array_form
+                else:
+                    yield x
+            return
+        if len(u) == 1:
+            for i in basic_orbits[0]:
+                if af:
+                    yield u[0][i]._array_form
+                else:
+                    yield u[0][i]
+            return
+
+        u = list(reversed(u))
+        basic_orbits = basic_orbits[::-1]
+        # stg stack of group elements
+        stg = [list(range(n))]
+        posmax = [len(x) for x in u]
+        n1 = len(posmax) - 1
+        pos = [0]*n1
+        h = 0
+        while 1:
+            # backtrack when finished iterating over coset
+            if pos[h] >= posmax[h]:
+                if h == 0:
+                    return
+                pos[h] = 0
+                h -= 1
+                stg.pop()
+                continue
+            p = _af_rmul(u[h][basic_orbits[h][pos[h]]]._array_form, stg[-1])
+            pos[h] += 1
+            stg.append(p)
+            h += 1
+            if h == n1:
+                if af:
+                    for i in basic_orbits[-1]:
+                        p = _af_rmul(u[-1][i]._array_form, stg[-1])
+                        yield p
+                else:
+                    for i in basic_orbits[-1]:
+                        p = _af_rmul(u[-1][i]._array_form, stg[-1])
+                        p1 = _af_new(p)
+                        yield p1
+                stg.pop()
+                h -= 1
+
+    @property
+    def generators(self):
+        """Returns the generators of the group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.generators
+        [(1 2), (2)(0 1)]
+
+        """
+        return self._generators
+
+    def contains(self, g, strict=True):
+        """Test if permutation ``g`` belong to self, ``G``.
+
+        Explanation
+        ===========
+
+        If ``g`` is an element of ``G`` it can be written as a product
+        of factors drawn from the cosets of ``G``'s stabilizers. To see
+        if ``g`` is one of the actual generators defining the group use
+        ``G.has(g)``.
+
+        If ``strict`` is not ``True``, ``g`` will be resized, if necessary,
+        to match the size of permutations in ``self``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+
+        >>> a = Permutation(1, 2)
+        >>> b = Permutation(2, 3, 1)
+        >>> G = PermutationGroup(a, b, degree=5)
+        >>> G.contains(G[0]) # trivial check
+        True
+        >>> elem = Permutation([[2, 3]], size=5)
+        >>> G.contains(elem)
+        True
+        >>> G.contains(Permutation(4)(0, 1, 2, 3))
+        False
+
+        If strict is False, a permutation will be resized, if
+        necessary:
+
+        >>> H = PermutationGroup(Permutation(5))
+        >>> H.contains(Permutation(3))
+        False
+        >>> H.contains(Permutation(3), strict=False)
+        True
+
+        To test if a given permutation is present in the group:
+
+        >>> elem in G.generators
+        False
+        >>> G.has(elem)
+        False
+
+        See Also
+        ========
+
+        coset_factor, sympy.core.basic.Basic.has, __contains__
+
+        """
+        if not isinstance(g, Permutation):
+            return False
+        if g.size != self.degree:
+            if strict:
+                return False
+            g = Permutation(g, size=self.degree)
+        if g in self.generators:
+            return True
+        return bool(self.coset_factor(g.array_form, True))
+
+    @property
+    def is_perfect(self):
+        """Return ``True`` if the group is perfect.
+        A group is perfect if it equals to its derived subgroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation(1,2,3)(4,5)
+        >>> b = Permutation(1,2,3,4,5)
+        >>> G = PermutationGroup([a, b])
+        >>> G.is_perfect
+        False
+
+        """
+        if self._is_perfect is None:
+            self._is_perfect = self.equals(self.derived_subgroup())
+        return self._is_perfect
+
+    @property
+    def is_abelian(self):
+        """Test if the group is Abelian.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.is_abelian
+        False
+        >>> a = Permutation([0, 2, 1])
+        >>> G = PermutationGroup([a])
+        >>> G.is_abelian
+        True
+
+        """
+        if self._is_abelian is not None:
+            return self._is_abelian
+
+        self._is_abelian = True
+        gens = [p._array_form for p in self.generators]
+        for x in gens:
+            for y in gens:
+                if y <= x:
+                    continue
+                if not _af_commutes_with(x, y):
+                    self._is_abelian = False
+                    return False
+        return True
+
+    def abelian_invariants(self):
+        """
+        Returns the abelian invariants for the given group.
+        Let ``G`` be a nontrivial finite abelian group. Then G is isomorphic to
+        the direct product of finitely many nontrivial cyclic groups of
+        prime-power order.
+
+        Explanation
+        ===========
+
+        The prime-powers that occur as the orders of the factors are uniquely
+        determined by G. More precisely, the primes that occur in the orders of the
+        factors in any such decomposition of ``G`` are exactly the primes that divide
+        ``|G|`` and for any such prime ``p``, if the orders of the factors that are
+        p-groups in one such decomposition of ``G`` are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``,
+        then the orders of the factors that are p-groups in any such decomposition of ``G``
+        are ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``.
+
+        The uniquely determined integers ``p^{t_1} >= p^{t_2} >= ... p^{t_r}``, taken
+        for all primes that divide ``|G|`` are called the invariants of the nontrivial
+        group ``G`` as suggested in ([14], p. 542).
+
+        Notes
+        =====
+
+        We adopt the convention that the invariants of a trivial group are [].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.abelian_invariants()
+        [2]
+        >>> from sympy.combinatorics import CyclicGroup
+        >>> G = CyclicGroup(7)
+        >>> G.abelian_invariants()
+        [7]
+
+        """
+        if self.is_trivial:
+            return []
+        gns = self.generators
+        inv = []
+        G = self
+        H = G.derived_subgroup()
+        Hgens = H.generators
+        for p in primefactors(G.order()):
+            ranks = []
+            while True:
+                pows = []
+                for g in gns:
+                    elm = g**p
+                    if not H.contains(elm):
+                        pows.append(elm)
+                K = PermutationGroup(Hgens + pows) if pows else H
+                r = G.order()//K.order()
+                G = K
+                gns = pows
+                if r == 1:
+                    break
+                ranks.append(multiplicity(p, r))
+
+            if ranks:
+                pows = [1]*ranks[0]
+                for i in ranks:
+                    for j in range(i):
+                        pows[j] = pows[j]*p
+                inv.extend(pows)
+        inv.sort()
+        return inv
+
+    def is_elementary(self, p):
+        """Return ``True`` if the group is elementary abelian. An elementary
+        abelian group is a finite abelian group, where every nontrivial
+        element has order `p`, where `p` is a prime.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> G = PermutationGroup([a])
+        >>> G.is_elementary(2)
+        True
+        >>> a = Permutation([0, 2, 1, 3])
+        >>> b = Permutation([3, 1, 2, 0])
+        >>> G = PermutationGroup([a, b])
+        >>> G.is_elementary(2)
+        True
+        >>> G.is_elementary(3)
+        False
+
+        """
+        return self.is_abelian and all(g.order() == p for g in self.generators)
+
+    def _eval_is_alt_sym_naive(self, only_sym=False, only_alt=False):
+        """A naive test using the group order."""
+        if only_sym and only_alt:
+            raise ValueError(
+                "Both {} and {} cannot be set to True"
+                .format(only_sym, only_alt))
+
+        n = self.degree
+        sym_order = _factorial(n)
+        order = self.order()
+
+        if order == sym_order:
+            self._is_sym = True
+            self._is_alt = False
+            return not only_alt
+
+        if 2*order == sym_order:
+            self._is_sym = False
+            self._is_alt = True
+            return not only_sym
+
+        return False
+
+    def _eval_is_alt_sym_monte_carlo(self, eps=0.05, perms=None):
+        """A test using monte-carlo algorithm.
+
+        Parameters
+        ==========
+
+        eps : float, optional
+            The criterion for the incorrect ``False`` return.
+
+        perms : list[Permutation], optional
+            If explicitly given, it tests over the given candidates
+            for testing.
+
+            If ``None``, it randomly computes ``N_eps`` and chooses
+            ``N_eps`` sample of the permutation from the group.
+
+        See Also
+        ========
+
+        _check_cycles_alt_sym
+        """
+        if perms is None:
+            n = self.degree
+            if n < 17:
+                c_n = 0.34
+            else:
+                c_n = 0.57
+            d_n = (c_n*log(2))/log(n)
+            N_eps = int(-log(eps)/d_n)
+
+            perms = (self.random_pr() for i in range(N_eps))
+            return self._eval_is_alt_sym_monte_carlo(perms=perms)
+
+        for perm in perms:
+            if _check_cycles_alt_sym(perm):
+                return True
+        return False
+
+    def is_alt_sym(self, eps=0.05, _random_prec=None):
+        r"""Monte Carlo test for the symmetric/alternating group for degrees
+        >= 8.
+
+        Explanation
+        ===========
+
+        More specifically, it is one-sided Monte Carlo with the
+        answer True (i.e., G is symmetric/alternating) guaranteed to be
+        correct, and the answer False being incorrect with probability eps.
+
+        For degree < 8, the order of the group is checked so the test
+        is deterministic.
+
+        Notes
+        =====
+
+        The algorithm itself uses some nontrivial results from group theory and
+        number theory:
+        1) If a transitive group ``G`` of degree ``n`` contains an element
+        with a cycle of length ``n/2 < p < n-2`` for ``p`` a prime, ``G`` is the
+        symmetric or alternating group ([1], pp. 81-82)
+        2) The proportion of elements in the symmetric/alternating group having
+        the property described in 1) is approximately `\log(2)/\log(n)`
+        ([1], p.82; [2], pp. 226-227).
+        The helper function ``_check_cycles_alt_sym`` is used to
+        go over the cycles in a permutation and look for ones satisfying 1).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> D = DihedralGroup(10)
+        >>> D.is_alt_sym()
+        False
+
+        See Also
+        ========
+
+        _check_cycles_alt_sym
+
+        """
+        if _random_prec is not None:
+            N_eps = _random_prec['N_eps']
+            perms= (_random_prec[i] for i in range(N_eps))
+            return self._eval_is_alt_sym_monte_carlo(perms=perms)
+
+        if self._is_sym or self._is_alt:
+            return True
+        if self._is_sym is False and self._is_alt is False:
+            return False
+
+        n = self.degree
+        if n < 8:
+            return self._eval_is_alt_sym_naive()
+        elif self.is_transitive():
+            return self._eval_is_alt_sym_monte_carlo(eps=eps)
+
+        self._is_sym, self._is_alt = False, False
+        return False
+
+    @property
+    def is_nilpotent(self):
+        """Test if the group is nilpotent.
+
+        Explanation
+        ===========
+
+        A group `G` is nilpotent if it has a central series of finite length.
+        Alternatively, `G` is nilpotent if its lower central series terminates
+        with the trivial group. Every nilpotent group is also solvable
+        ([1], p.29, [12]).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... CyclicGroup)
+        >>> C = CyclicGroup(6)
+        >>> C.is_nilpotent
+        True
+        >>> S = SymmetricGroup(5)
+        >>> S.is_nilpotent
+        False
+
+        See Also
+        ========
+
+        lower_central_series, is_solvable
+
+        """
+        if self._is_nilpotent is None:
+            lcs = self.lower_central_series()
+            terminator = lcs[len(lcs) - 1]
+            gens = terminator.generators
+            degree = self.degree
+            identity = _af_new(list(range(degree)))
+            if all(g == identity for g in gens):
+                self._is_solvable = True
+                self._is_nilpotent = True
+                return True
+            else:
+                self._is_nilpotent = False
+                return False
+        else:
+            return self._is_nilpotent
+
+    def is_normal(self, gr, strict=True):
+        """Test if ``G=self`` is a normal subgroup of ``gr``.
+
+        Explanation
+        ===========
+
+        G is normal in gr if
+        for each g2 in G, g1 in gr, ``g = g1*g2*g1**-1`` belongs to G
+        It is sufficient to check this for each g1 in gr.generators and
+        g2 in G.generators.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([1, 2, 0])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G1 = PermutationGroup([a, Permutation([2, 0, 1])])
+        >>> G1.is_normal(G)
+        True
+
+        """
+        if not self.is_subgroup(gr, strict=strict):
+            return False
+        d_self = self.degree
+        d_gr = gr.degree
+        if self.is_trivial and (d_self == d_gr or not strict):
+            return True
+        if self._is_abelian:
+            return True
+        new_self = self.copy()
+        if not strict and d_self != d_gr:
+            if d_self < d_gr:
+                new_self = PermGroup(new_self.generators + [Permutation(d_gr - 1)])
+            else:
+                gr = PermGroup(gr.generators + [Permutation(d_self - 1)])
+        gens2 = [p._array_form for p in new_self.generators]
+        gens1 = [p._array_form for p in gr.generators]
+        for g1 in gens1:
+            for g2 in gens2:
+                p = _af_rmuln(g1, g2, _af_invert(g1))
+                if not new_self.coset_factor(p, True):
+                    return False
+        return True
+
+    def is_primitive(self, randomized=True):
+        r"""Test if a group is primitive.
+
+        Explanation
+        ===========
+
+        A permutation group ``G`` acting on a set ``S`` is called primitive if
+        ``S`` contains no nontrivial block under the action of ``G``
+        (a block is nontrivial if its cardinality is more than ``1``).
+
+        Notes
+        =====
+
+        The algorithm is described in [1], p.83, and uses the function
+        minimal_block to search for blocks of the form `\{0, k\}` for ``k``
+        ranging over representatives for the orbits of `G_0`, the stabilizer of
+        ``0``. This algorithm has complexity `O(n^2)` where ``n`` is the degree
+        of the group, and will perform badly if `G_0` is small.
+
+        There are two implementations offered: one finds `G_0`
+        deterministically using the function ``stabilizer``, and the other
+        (default) produces random elements of `G_0` using ``random_stab``,
+        hoping that they generate a subgroup of `G_0` with not too many more
+        orbits than `G_0` (this is suggested in [1], p.83). Behavior is changed
+        by the ``randomized`` flag.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> D = DihedralGroup(10)
+        >>> D.is_primitive()
+        False
+
+        See Also
+        ========
+
+        minimal_block, random_stab
+
+        """
+        if self._is_primitive is not None:
+            return self._is_primitive
+
+        if self.is_transitive() is False:
+            return False
+
+        if randomized:
+            random_stab_gens = []
+            v = self.schreier_vector(0)
+            for _ in range(len(self)):
+                random_stab_gens.append(self.random_stab(0, v))
+            stab = PermutationGroup(random_stab_gens)
+        else:
+            stab = self.stabilizer(0)
+        orbits = stab.orbits()
+        for orb in orbits:
+            x = orb.pop()
+            if x != 0 and any(e != 0 for e in self.minimal_block([0, x])):
+                self._is_primitive = False
+                return False
+        self._is_primitive = True
+        return True
+
+    def minimal_blocks(self, randomized=True):
+        '''
+        For a transitive group, return the list of all minimal
+        block systems. If a group is intransitive, return `False`.
+
+        Examples
+        ========
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> DihedralGroup(6).minimal_blocks()
+        [[0, 1, 0, 1, 0, 1], [0, 1, 2, 0, 1, 2]]
+        >>> G = PermutationGroup(Permutation(1,2,5))
+        >>> G.minimal_blocks()
+        False
+
+        See Also
+        ========
+
+        minimal_block, is_transitive, is_primitive
+
+        '''
+        def _number_blocks(blocks):
+            # number the blocks of a block system
+            # in order and return the number of
+            # blocks and the tuple with the
+            # reordering
+            n = len(blocks)
+            appeared = {}
+            m = 0
+            b = [None]*n
+            for i in range(n):
+                if blocks[i] not in appeared:
+                    appeared[blocks[i]] = m
+                    b[i] = m
+                    m += 1
+                else:
+                    b[i] = appeared[blocks[i]]
+            return tuple(b), m
+
+        if not self.is_transitive():
+            return False
+        blocks = []
+        num_blocks = []
+        rep_blocks = []
+        if randomized:
+            random_stab_gens = []
+            v = self.schreier_vector(0)
+            for i in range(len(self)):
+                random_stab_gens.append(self.random_stab(0, v))
+            stab = PermutationGroup(random_stab_gens)
+        else:
+            stab = self.stabilizer(0)
+        orbits = stab.orbits()
+        for orb in orbits:
+            x = orb.pop()
+            if x != 0:
+                block = self.minimal_block([0, x])
+                num_block, _ = _number_blocks(block)
+                # a representative block (containing 0)
+                rep = {j for j in range(self.degree) if num_block[j] == 0}
+                # check if the system is minimal with
+                # respect to the already discovere ones
+                minimal = True
+                blocks_remove_mask = [False] * len(blocks)
+                for i, r in enumerate(rep_blocks):
+                    if len(r) > len(rep) and rep.issubset(r):
+                        # i-th block system is not minimal
+                        blocks_remove_mask[i] = True
+                    elif len(r) < len(rep) and r.issubset(rep):
+                        # the system being checked is not minimal
+                        minimal = False
+                        break
+                # remove non-minimal representative blocks
+                blocks = [b for i, b in enumerate(blocks) if not blocks_remove_mask[i]]
+                num_blocks = [n for i, n in enumerate(num_blocks) if not blocks_remove_mask[i]]
+                rep_blocks = [r for i, r in enumerate(rep_blocks) if not blocks_remove_mask[i]]
+
+                if minimal and num_block not in num_blocks:
+                    blocks.append(block)
+                    num_blocks.append(num_block)
+                    rep_blocks.append(rep)
+        return blocks
+
+    @property
+    def is_solvable(self):
+        """Test if the group is solvable.
+
+        ``G`` is solvable if its derived series terminates with the trivial
+        group ([1], p.29).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> S = SymmetricGroup(3)
+        >>> S.is_solvable
+        True
+
+        See Also
+        ========
+
+        is_nilpotent, derived_series
+
+        """
+        if self._is_solvable is None:
+            if self.order() % 2 != 0:
+                return True
+            ds = self.derived_series()
+            terminator = ds[len(ds) - 1]
+            gens = terminator.generators
+            degree = self.degree
+            identity = _af_new(list(range(degree)))
+            if all(g == identity for g in gens):
+                self._is_solvable = True
+                return True
+            else:
+                self._is_solvable = False
+                return False
+        else:
+            return self._is_solvable
+
+    def is_subgroup(self, G, strict=True):
+        """Return ``True`` if all elements of ``self`` belong to ``G``.
+
+        If ``strict`` is ``False`` then if ``self``'s degree is smaller
+        than ``G``'s, the elements will be resized to have the same degree.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> from sympy.combinatorics import SymmetricGroup, CyclicGroup
+
+        Testing is strict by default: the degree of each group must be the
+        same:
+
+        >>> p = Permutation(0, 1, 2, 3, 4, 5)
+        >>> G1 = PermutationGroup([Permutation(0, 1, 2), Permutation(0, 1)])
+        >>> G2 = PermutationGroup([Permutation(0, 2), Permutation(0, 1, 2)])
+        >>> G3 = PermutationGroup([p, p**2])
+        >>> assert G1.order() == G2.order() == G3.order() == 6
+        >>> G1.is_subgroup(G2)
+        True
+        >>> G1.is_subgroup(G3)
+        False
+        >>> G3.is_subgroup(PermutationGroup(G3[1]))
+        False
+        >>> G3.is_subgroup(PermutationGroup(G3[0]))
+        True
+
+        To ignore the size, set ``strict`` to ``False``:
+
+        >>> S3 = SymmetricGroup(3)
+        >>> S5 = SymmetricGroup(5)
+        >>> S3.is_subgroup(S5, strict=False)
+        True
+        >>> C7 = CyclicGroup(7)
+        >>> G = S5*C7
+        >>> S5.is_subgroup(G, False)
+        True
+        >>> C7.is_subgroup(G, 0)
+        False
+
+        """
+        if isinstance(G, SymmetricPermutationGroup):
+            if self.degree != G.degree:
+                return False
+            return True
+        if not isinstance(G, PermutationGroup):
+            return False
+        if self == G or self.generators[0]==Permutation():
+            return True
+        if G.order() % self.order() != 0:
+            return False
+        if self.degree == G.degree or \
+                (self.degree < G.degree and not strict):
+            gens = self.generators
+        else:
+            return False
+        return all(G.contains(g, strict=strict) for g in gens)
+
+    @property
+    def is_polycyclic(self):
+        """Return ``True`` if a group is polycyclic. A group is polycyclic if
+        it has a subnormal series with cyclic factors. For finite groups,
+        this is the same as if the group is solvable.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1, 3])
+        >>> b = Permutation([2, 0, 1, 3])
+        >>> G = PermutationGroup([a, b])
+        >>> G.is_polycyclic
+        True
+
+        """
+        return self.is_solvable
+
+    def is_transitive(self, strict=True):
+        """Test if the group is transitive.
+
+        Explanation
+        ===========
+
+        A group is transitive if it has a single orbit.
+
+        If ``strict`` is ``False`` the group is transitive if it has
+        a single orbit of length different from 1.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1, 3])
+        >>> b = Permutation([2, 0, 1, 3])
+        >>> G1 = PermutationGroup([a, b])
+        >>> G1.is_transitive()
+        False
+        >>> G1.is_transitive(strict=False)
+        True
+        >>> c = Permutation([2, 3, 0, 1])
+        >>> G2 = PermutationGroup([a, c])
+        >>> G2.is_transitive()
+        True
+        >>> d = Permutation([1, 0, 2, 3])
+        >>> e = Permutation([0, 1, 3, 2])
+        >>> G3 = PermutationGroup([d, e])
+        >>> G3.is_transitive() or G3.is_transitive(strict=False)
+        False
+
+        """
+        if self._is_transitive:  # strict or not, if True then True
+            return self._is_transitive
+        if strict:
+            if self._is_transitive is not None:  # we only store strict=True
+                return self._is_transitive
+
+            ans = len(self.orbit(0)) == self.degree
+            self._is_transitive = ans
+            return ans
+
+        got_orb = False
+        for x in self.orbits():
+            if len(x) > 1:
+                if got_orb:
+                    return False
+                got_orb = True
+        return got_orb
+
+    @property
+    def is_trivial(self):
+        """Test if the group is the trivial group.
+
+        This is true if the group contains only the identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> G = PermutationGroup([Permutation([0, 1, 2])])
+        >>> G.is_trivial
+        True
+
+        """
+        if self._is_trivial is None:
+            self._is_trivial = len(self) == 1 and self[0].is_Identity
+        return self._is_trivial
+
+    def lower_central_series(self):
+        r"""Return the lower central series for the group.
+
+        The lower central series for a group `G` is the series
+        `G = G_0 > G_1 > G_2 > \ldots` where
+        `G_k = [G, G_{k-1}]`, i.e. every term after the first is equal to the
+        commutator of `G` and the previous term in `G1` ([1], p.29).
+
+        Returns
+        =======
+
+        A list of permutation groups in the order `G = G_0, G_1, G_2, \ldots`
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (AlternatingGroup,
+        ... DihedralGroup)
+        >>> A = AlternatingGroup(4)
+        >>> len(A.lower_central_series())
+        2
+        >>> A.lower_central_series()[1].is_subgroup(DihedralGroup(2))
+        True
+
+        See Also
+        ========
+
+        commutator, derived_series
+
+        """
+        res = [self]
+        current = self
+        nxt = self.commutator(self, current)
+        while not current.is_subgroup(nxt):
+            res.append(nxt)
+            current = nxt
+            nxt = self.commutator(self, current)
+        return res
+
+    @property
+    def max_div(self):
+        """Maximum proper divisor of the degree of a permutation group.
+
+        Explanation
+        ===========
+
+        Obviously, this is the degree divided by its minimal proper divisor
+        (larger than ``1``, if one exists). As it is guaranteed to be prime,
+        the ``sieve`` from ``sympy.ntheory`` is used.
+        This function is also used as an optimization tool for the functions
+        ``minimal_block`` and ``_union_find_merge``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> G = PermutationGroup([Permutation([0, 2, 1, 3])])
+        >>> G.max_div
+        2
+
+        See Also
+        ========
+
+        minimal_block, _union_find_merge
+
+        """
+        if self._max_div is not None:
+            return self._max_div
+        n = self.degree
+        if n == 1:
+            return 1
+        for x in sieve:
+            if n % x == 0:
+                d = n//x
+                self._max_div = d
+                return d
+
+    def minimal_block(self, points):
+        r"""For a transitive group, finds the block system generated by
+        ``points``.
+
+        Explanation
+        ===========
+
+        If a group ``G`` acts on a set ``S``, a nonempty subset ``B`` of ``S``
+        is called a block under the action of ``G`` if for all ``g`` in ``G``
+        we have ``gB = B`` (``g`` fixes ``B``) or ``gB`` and ``B`` have no
+        common points (``g`` moves ``B`` entirely). ([1], p.23; [6]).
+
+        The distinct translates ``gB`` of a block ``B`` for ``g`` in ``G``
+        partition the set ``S`` and this set of translates is known as a block
+        system. Moreover, we obviously have that all blocks in the partition
+        have the same size, hence the block size divides ``|S|`` ([1], p.23).
+        A ``G``-congruence is an equivalence relation ``~`` on the set ``S``
+        such that ``a ~ b`` implies ``g(a) ~ g(b)`` for all ``g`` in ``G``.
+        For a transitive group, the equivalence classes of a ``G``-congruence
+        and the blocks of a block system are the same thing ([1], p.23).
+
+        The algorithm below checks the group for transitivity, and then finds
+        the ``G``-congruence generated by the pairs ``(p_0, p_1), (p_0, p_2),
+        ..., (p_0,p_{k-1})`` which is the same as finding the maximal block
+        system (i.e., the one with minimum block size) such that
+        ``p_0, ..., p_{k-1}`` are in the same block ([1], p.83).
+
+        It is an implementation of Atkinson's algorithm, as suggested in [1],
+        and manipulates an equivalence relation on the set ``S`` using a
+        union-find data structure. The running time is just above
+        `O(|points||S|)`. ([1], pp. 83-87; [7]).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> D = DihedralGroup(10)
+        >>> D.minimal_block([0, 5])
+        [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
+        >>> D.minimal_block([0, 1])
+        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
+
+        See Also
+        ========
+
+        _union_find_rep, _union_find_merge, is_transitive, is_primitive
+
+        """
+        if not self.is_transitive():
+            return False
+        n = self.degree
+        gens = self.generators
+        # initialize the list of equivalence class representatives
+        parents = list(range(n))
+        ranks = [1]*n
+        not_rep = []
+        k = len(points)
+        # the block size must divide the degree of the group
+        if k > self.max_div:
+            return [0]*n
+        for i in range(k - 1):
+            parents[points[i + 1]] = points[0]
+            not_rep.append(points[i + 1])
+        ranks[points[0]] = k
+        i = 0
+        len_not_rep = k - 1
+        while i < len_not_rep:
+            gamma = not_rep[i]
+            i += 1
+            for gen in gens:
+                # find has side effects: performs path compression on the list
+                # of representatives
+                delta = self._union_find_rep(gamma, parents)
+                # union has side effects: performs union by rank on the list
+                # of representatives
+                temp = self._union_find_merge(gen(gamma), gen(delta), ranks,
+                                              parents, not_rep)
+                if temp == -1:
+                    return [0]*n
+                len_not_rep += temp
+        for i in range(n):
+            # force path compression to get the final state of the equivalence
+            # relation
+            self._union_find_rep(i, parents)
+
+        # rewrite result so that block representatives are minimal
+        new_reps = {}
+        return [new_reps.setdefault(r, i) for i, r in enumerate(parents)]
+
+    def conjugacy_class(self, x):
+        r"""Return the conjugacy class of an element in the group.
+
+        Explanation
+        ===========
+
+        The conjugacy class of an element ``g`` in a group ``G`` is the set of
+        elements ``x`` in ``G`` that are conjugate with ``g``, i.e. for which
+
+            ``g = xax^{-1}``
+
+        for some ``a`` in ``G``.
+
+        Note that conjugacy is an equivalence relation, and therefore that
+        conjugacy classes are partitions of ``G``. For a list of all the
+        conjugacy classes of the group, use the conjugacy_classes() method.
+
+        In a permutation group, each conjugacy class corresponds to a particular
+        `cycle structure': for example, in ``S_3``, the conjugacy classes are:
+
+            * the identity class, ``{()}``
+            * all transpositions, ``{(1 2), (1 3), (2 3)}``
+            * all 3-cycles, ``{(1 2 3), (1 3 2)}``
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, SymmetricGroup
+        >>> S3 = SymmetricGroup(3)
+        >>> S3.conjugacy_class(Permutation(0, 1, 2))
+        {(0 1 2), (0 2 1)}
+
+        Notes
+        =====
+
+        This procedure computes the conjugacy class directly by finding the
+        orbit of the element under conjugation in G. This algorithm is only
+        feasible for permutation groups of relatively small order, but is like
+        the orbit() function itself in that respect.
+        """
+        # Ref: "Computing the conjugacy classes of finite groups"; Butler, G.
+        # Groups '93 Galway/St Andrews; edited by Campbell, C. M.
+        new_class = {x}
+        last_iteration = new_class
+
+        while len(last_iteration) > 0:
+            this_iteration = set()
+
+            for y in last_iteration:
+                for s in self.generators:
+                    conjugated = s * y * (~s)
+                    if conjugated not in new_class:
+                        this_iteration.add(conjugated)
+
+            new_class.update(last_iteration)
+            last_iteration = this_iteration
+
+        return new_class
+
+
+    def conjugacy_classes(self):
+        r"""Return the conjugacy classes of the group.
+
+        Explanation
+        ===========
+
+        As described in the documentation for the .conjugacy_class() function,
+        conjugacy is an equivalence relation on a group G which partitions the
+        set of elements. This method returns a list of all these conjugacy
+        classes of G.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import SymmetricGroup
+        >>> SymmetricGroup(3).conjugacy_classes()
+        [{(2)}, {(0 1 2), (0 2 1)}, {(0 2), (1 2), (2)(0 1)}]
+
+        """
+        identity = _af_new(list(range(self.degree)))
+        known_elements = {identity}
+        classes = [known_elements.copy()]
+
+        for x in self.generate():
+            if x not in known_elements:
+                new_class = self.conjugacy_class(x)
+                classes.append(new_class)
+                known_elements.update(new_class)
+
+        return classes
+
+    def normal_closure(self, other, k=10):
+        r"""Return the normal closure of a subgroup/set of permutations.
+
+        Explanation
+        ===========
+
+        If ``S`` is a subset of a group ``G``, the normal closure of ``A`` in ``G``
+        is defined as the intersection of all normal subgroups of ``G`` that
+        contain ``A`` ([1], p.14). Alternatively, it is the group generated by
+        the conjugates ``x^{-1}yx`` for ``x`` a generator of ``G`` and ``y`` a
+        generator of the subgroup ``\left\langle S\right\rangle`` generated by
+        ``S`` (for some chosen generating set for ``\left\langle S\right\rangle``)
+        ([1], p.73).
+
+        Parameters
+        ==========
+
+        other
+            a subgroup/list of permutations/single permutation
+        k
+            an implementation-specific parameter that determines the number
+            of conjugates that are adjoined to ``other`` at once
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... CyclicGroup, AlternatingGroup)
+        >>> S = SymmetricGroup(5)
+        >>> C = CyclicGroup(5)
+        >>> G = S.normal_closure(C)
+        >>> G.order()
+        60
+        >>> G.is_subgroup(AlternatingGroup(5))
+        True
+
+        See Also
+        ========
+
+        commutator, derived_subgroup, random_pr
+
+        Notes
+        =====
+
+        The algorithm is described in [1], pp. 73-74; it makes use of the
+        generation of random elements for permutation groups by the product
+        replacement algorithm.
+
+        """
+        if hasattr(other, 'generators'):
+            degree = self.degree
+            identity = _af_new(list(range(degree)))
+
+            if all(g == identity for g in other.generators):
+                return other
+            Z = PermutationGroup(other.generators[:])
+            base, strong_gens = Z.schreier_sims_incremental()
+            strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+            basic_orbits, basic_transversals = \
+                _orbits_transversals_from_bsgs(base, strong_gens_distr)
+
+            self._random_pr_init(r=10, n=20)
+
+            _loop = True
+            while _loop:
+                Z._random_pr_init(r=10, n=10)
+                for _ in range(k):
+                    g = self.random_pr()
+                    h = Z.random_pr()
+                    conj = h^g
+                    res = _strip(conj, base, basic_orbits, basic_transversals)
+                    if res[0] != identity or res[1] != len(base) + 1:
+                        gens = Z.generators
+                        gens.append(conj)
+                        Z = PermutationGroup(gens)
+                        strong_gens.append(conj)
+                        temp_base, temp_strong_gens = \
+                            Z.schreier_sims_incremental(base, strong_gens)
+                        base, strong_gens = temp_base, temp_strong_gens
+                        strong_gens_distr = \
+                            _distribute_gens_by_base(base, strong_gens)
+                        basic_orbits, basic_transversals = \
+                            _orbits_transversals_from_bsgs(base,
+                                strong_gens_distr)
+                _loop = False
+                for g in self.generators:
+                    for h in Z.generators:
+                        conj = h^g
+                        res = _strip(conj, base, basic_orbits,
+                                     basic_transversals)
+                        if res[0] != identity or res[1] != len(base) + 1:
+                            _loop = True
+                            break
+                    if _loop:
+                        break
+            return Z
+        elif hasattr(other, '__getitem__'):
+            return self.normal_closure(PermutationGroup(other))
+        elif hasattr(other, 'array_form'):
+            return self.normal_closure(PermutationGroup([other]))
+
+    def orbit(self, alpha, action='tuples'):
+        r"""Compute the orbit of alpha `\{g(\alpha) | g \in G\}` as a set.
+
+        Explanation
+        ===========
+
+        The time complexity of the algorithm used here is `O(|Orb|*r)` where
+        `|Orb|` is the size of the orbit and ``r`` is the number of generators of
+        the group. For a more detailed analysis, see [1], p.78, [2], pp. 19-21.
+        Here alpha can be a single point, or a list of points.
+
+        If alpha is a single point, the ordinary orbit is computed.
+        if alpha is a list of points, there are three available options:
+
+        'union' - computes the union of the orbits of the points in the list
+        'tuples' - computes the orbit of the list interpreted as an ordered
+        tuple under the group action ( i.e., g((1,2,3)) = (g(1), g(2), g(3)) )
+        'sets' - computes the orbit of the list interpreted as a sets
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([1, 2, 0, 4, 5, 6, 3])
+        >>> G = PermutationGroup([a])
+        >>> G.orbit(0)
+        {0, 1, 2}
+        >>> G.orbit([0, 4], 'union')
+        {0, 1, 2, 3, 4, 5, 6}
+
+        See Also
+        ========
+
+        orbit_transversal
+
+        """
+        return _orbit(self.degree, self.generators, alpha, action)
+
+    def orbit_rep(self, alpha, beta, schreier_vector=None):
+        """Return a group element which sends ``alpha`` to ``beta``.
+
+        Explanation
+        ===========
+
+        If ``beta`` is not in the orbit of ``alpha``, the function returns
+        ``False``. This implementation makes use of the schreier vector.
+        For a proof of correctness, see [1], p.80
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import AlternatingGroup
+        >>> G = AlternatingGroup(5)
+        >>> G.orbit_rep(0, 4)
+        (0 4 1 2 3)
+
+        See Also
+        ========
+
+        schreier_vector
+
+        """
+        if schreier_vector is None:
+            schreier_vector = self.schreier_vector(alpha)
+        if schreier_vector[beta] is None:
+            return False
+        k = schreier_vector[beta]
+        gens = [x._array_form for x in self.generators]
+        a = []
+        while k != -1:
+            a.append(gens[k])
+            beta = gens[k].index(beta) # beta = (~gens[k])(beta)
+            k = schreier_vector[beta]
+        if a:
+            return _af_new(_af_rmuln(*a))
+        else:
+            return _af_new(list(range(self._degree)))
+
+    def orbit_transversal(self, alpha, pairs=False):
+        r"""Computes a transversal for the orbit of ``alpha`` as a set.
+
+        Explanation
+        ===========
+
+        For a permutation group `G`, a transversal for the orbit
+        `Orb = \{g(\alpha) | g \in G\}` is a set
+        `\{g_\beta | g_\beta(\alpha) = \beta\}` for `\beta \in Orb`.
+        Note that there may be more than one possible transversal.
+        If ``pairs`` is set to ``True``, it returns the list of pairs
+        `(\beta, g_\beta)`. For a proof of correctness, see [1], p.79
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> G = DihedralGroup(6)
+        >>> G.orbit_transversal(0)
+        [(5), (0 1 2 3 4 5), (0 5)(1 4)(2 3), (0 2 4)(1 3 5), (5)(0 4)(1 3), (0 3)(1 4)(2 5)]
+
+        See Also
+        ========
+
+        orbit
+
+        """
+        return _orbit_transversal(self._degree, self.generators, alpha, pairs)
+
+    def orbits(self, rep=False):
+        """Return the orbits of ``self``, ordered according to lowest element
+        in each orbit.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation(1, 5)(2, 3)(4, 0, 6)
+        >>> b = Permutation(1, 5)(3, 4)(2, 6, 0)
+        >>> G = PermutationGroup([a, b])
+        >>> G.orbits()
+        [{0, 2, 3, 4, 6}, {1, 5}]
+        """
+        return _orbits(self._degree, self._generators)
+
+    def order(self):
+        """Return the order of the group: the number of permutations that
+        can be generated from elements of the group.
+
+        The number of permutations comprising the group is given by
+        ``len(group)``; the length of each permutation in the group is
+        given by ``group.size``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+
+        >>> a = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a])
+        >>> G.degree
+        3
+        >>> len(G)
+        1
+        >>> G.order()
+        2
+        >>> list(G.generate())
+        [(2), (2)(0 1)]
+
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.order()
+        6
+
+        See Also
+        ========
+
+        degree
+
+        """
+        if self._order is not None:
+            return self._order
+        if self._is_sym:
+            n = self._degree
+            self._order = factorial(n)
+            return self._order
+        if self._is_alt:
+            n = self._degree
+            self._order = factorial(n)/2
+            return self._order
+
+        m = prod([len(x) for x in self.basic_transversals])
+        self._order = m
+        return m
+
+    def index(self, H):
+        """
+        Returns the index of a permutation group.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation(1,2,3)
+        >>> b =Permutation(3)
+        >>> G = PermutationGroup([a])
+        >>> H = PermutationGroup([b])
+        >>> G.index(H)
+        3
+
+        """
+        if H.is_subgroup(self):
+            return self.order()//H.order()
+
+    @property
+    def is_symmetric(self):
+        """Return ``True`` if the group is symmetric.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import SymmetricGroup
+        >>> g = SymmetricGroup(5)
+        >>> g.is_symmetric
+        True
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> g = PermutationGroup(
+        ...     Permutation(0, 1, 2, 3, 4),
+        ...     Permutation(2, 3))
+        >>> g.is_symmetric
+        True
+
+        Notes
+        =====
+
+        This uses a naive test involving the computation of the full
+        group order.
+        If you need more quicker taxonomy for large groups, you can use
+        :meth:`PermutationGroup.is_alt_sym`.
+        However, :meth:`PermutationGroup.is_alt_sym` may not be accurate
+        and is not able to distinguish between an alternating group and
+        a symmetric group.
+
+        See Also
+        ========
+
+        is_alt_sym
+        """
+        _is_sym = self._is_sym
+        if _is_sym is not None:
+            return _is_sym
+
+        n = self.degree
+        if n >= 8:
+            if self.is_transitive():
+                _is_alt_sym = self._eval_is_alt_sym_monte_carlo()
+                if _is_alt_sym:
+                    if any(g.is_odd for g in self.generators):
+                        self._is_sym, self._is_alt = True, False
+                        return True
+
+                    self._is_sym, self._is_alt = False, True
+                    return False
+
+                return self._eval_is_alt_sym_naive(only_sym=True)
+
+            self._is_sym, self._is_alt = False, False
+            return False
+
+        return self._eval_is_alt_sym_naive(only_sym=True)
+
+
+    @property
+    def is_alternating(self):
+        """Return ``True`` if the group is alternating.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import AlternatingGroup
+        >>> g = AlternatingGroup(5)
+        >>> g.is_alternating
+        True
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> g = PermutationGroup(
+        ...     Permutation(0, 1, 2, 3, 4),
+        ...     Permutation(2, 3, 4))
+        >>> g.is_alternating
+        True
+
+        Notes
+        =====
+
+        This uses a naive test involving the computation of the full
+        group order.
+        If you need more quicker taxonomy for large groups, you can use
+        :meth:`PermutationGroup.is_alt_sym`.
+        However, :meth:`PermutationGroup.is_alt_sym` may not be accurate
+        and is not able to distinguish between an alternating group and
+        a symmetric group.
+
+        See Also
+        ========
+
+        is_alt_sym
+        """
+        _is_alt = self._is_alt
+        if _is_alt is not None:
+            return _is_alt
+
+        n = self.degree
+        if n >= 8:
+            if self.is_transitive():
+                _is_alt_sym = self._eval_is_alt_sym_monte_carlo()
+                if _is_alt_sym:
+                    if all(g.is_even for g in self.generators):
+                        self._is_sym, self._is_alt = False, True
+                        return True
+
+                    self._is_sym, self._is_alt = True, False
+                    return False
+
+                return self._eval_is_alt_sym_naive(only_alt=True)
+
+            self._is_sym, self._is_alt = False, False
+            return False
+
+        return self._eval_is_alt_sym_naive(only_alt=True)
+
+    @classmethod
+    def _distinct_primes_lemma(cls, primes):
+        """Subroutine to test if there is only one cyclic group for the
+        order."""
+        primes = sorted(primes)
+        l = len(primes)
+        for i in range(l):
+            for j in range(i+1, l):
+                if primes[j] % primes[i] == 1:
+                    return None
+        return True
+
+    @property
+    def is_cyclic(self):
+        r"""
+        Return ``True`` if the group is Cyclic.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import AbelianGroup
+        >>> G = AbelianGroup(3, 4)
+        >>> G.is_cyclic
+        True
+        >>> G = AbelianGroup(4, 4)
+        >>> G.is_cyclic
+        False
+
+        Notes
+        =====
+
+        If the order of a group $n$ can be factored into the distinct
+        primes $p_1, p_2, \dots , p_s$ and if
+
+        .. math::
+            \forall i, j \in \{1, 2, \dots, s \}:
+            p_i \not \equiv 1 \pmod {p_j}
+
+        holds true, there is only one group of the order $n$ which
+        is a cyclic group [1]_. This is a generalization of the lemma
+        that the group of order $15, 35, \dots$ are cyclic.
+
+        And also, these additional lemmas can be used to test if a
+        group is cyclic if the order of the group is already found.
+
+        - If the group is abelian and the order of the group is
+          square-free, the group is cyclic.
+        - If the order of the group is less than $6$ and is not $4$, the
+          group is cyclic.
+        - If the order of the group is prime, the group is cyclic.
+
+        References
+        ==========
+
+        .. [1] 1978: John S. Rose: A Course on Group Theory,
+            Introduction to Finite Group Theory: 1.4
+        """
+        if self._is_cyclic is not None:
+            return self._is_cyclic
+
+        if len(self.generators) == 1:
+            self._is_cyclic = True
+            self._is_abelian = True
+            return True
+
+        if self._is_abelian is False:
+            self._is_cyclic = False
+            return False
+
+        order = self.order()
+
+        if order < 6:
+            self._is_abelian = True
+            if order != 4:
+                self._is_cyclic = True
+                return True
+
+        factors = factorint(order)
+        if all(v == 1 for v in factors.values()):
+            if self._is_abelian:
+                self._is_cyclic = True
+                return True
+
+            primes = list(factors.keys())
+            if PermutationGroup._distinct_primes_lemma(primes) is True:
+                self._is_cyclic = True
+                self._is_abelian = True
+                return True
+
+        if not self.is_abelian:
+            self._is_cyclic = False
+            return False
+
+        self._is_cyclic = all(
+            any(g**(order//p) != self.identity for g in self.generators)
+            for p, e in factors.items() if e > 1
+        )
+        return self._is_cyclic
+
+    @property
+    def is_dihedral(self):
+        r"""
+        Return ``True`` if the group is dihedral.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.perm_groups import PermutationGroup
+        >>> from sympy.combinatorics.permutations import Permutation
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup, CyclicGroup
+        >>> G = PermutationGroup(Permutation(1, 6)(2, 5)(3, 4), Permutation(0, 1, 2, 3, 4, 5, 6))
+        >>> G.is_dihedral
+        True
+        >>> G = SymmetricGroup(3)
+        >>> G.is_dihedral
+        True
+        >>> G = CyclicGroup(6)
+        >>> G.is_dihedral
+        False
+
+        References
+        ==========
+
+        .. [Di1] https://math.stackexchange.com/questions/827230/given-a-cayley-table-is-there-an-algorithm-to-determine-if-it-is-a-dihedral-gro/827273#827273
+        .. [Di2] https://kconrad.math.uconn.edu/blurbs/grouptheory/dihedral.pdf
+        .. [Di3] https://kconrad.math.uconn.edu/blurbs/grouptheory/dihedral2.pdf
+        .. [Di4] https://en.wikipedia.org/wiki/Dihedral_group
+        """
+        if self._is_dihedral is not None:
+            return self._is_dihedral
+
+        order = self.order()
+
+        if order % 2 == 1:
+            self._is_dihedral = False
+            return False
+        if order == 2:
+            self._is_dihedral = True
+            return True
+        if order == 4:
+            # The dihedral group of order 4 is the Klein 4-group.
+            self._is_dihedral = not self.is_cyclic
+            return self._is_dihedral
+        if self.is_abelian:
+            # The only abelian dihedral groups are the ones of orders 2 and 4.
+            self._is_dihedral = False
+            return False
+
+        # Now we know the group is of even order >= 6, and nonabelian.
+        n = order // 2
+
+        # Handle special cases where there are exactly two generators.
+        gens = self.generators
+        if len(gens) == 2:
+            x, y = gens
+            a, b = x.order(), y.order()
+            # Make a >= b
+            if a < b:
+                x, y, a, b = y, x, b, a
+            # Using Theorem 2.1 of [Di3]:
+            if a == 2 == b:
+                self._is_dihedral = True
+                return True
+            # Using Theorem 1.1 of [Di3]:
+            if a == n and b == 2 and y*x*y == ~x:
+                self._is_dihedral = True
+                return True
+
+        # Proceed with algorithm of [Di1]
+        # Find elements of orders 2 and n
+        order_2, order_n = [], []
+        for p in self.elements:
+            k = p.order()
+            if k == 2:
+                order_2.append(p)
+            elif k == n:
+                order_n.append(p)
+
+        if len(order_2) != n + 1 - (n % 2):
+            self._is_dihedral = False
+            return False
+
+        if not order_n:
+            self._is_dihedral = False
+            return False
+
+        x = order_n[0]
+        # Want an element y of order 2 that is not a power of x
+        # (i.e. that is not the 180-deg rotation, when n is even).
+        y = order_2[0]
+        if n % 2 == 0 and y == x**(n//2):
+            y = order_2[1]
+
+        self._is_dihedral = (y*x*y == ~x)
+        return self._is_dihedral
+
+    def pointwise_stabilizer(self, points, incremental=True):
+        r"""Return the pointwise stabilizer for a set of points.
+
+        Explanation
+        ===========
+
+        For a permutation group `G` and a set of points
+        `\{p_1, p_2,\ldots, p_k\}`, the pointwise stabilizer of
+        `p_1, p_2, \ldots, p_k` is defined as
+        `G_{p_1,\ldots, p_k} =
+        \{g\in G | g(p_i) = p_i \forall i\in\{1, 2,\ldots,k\}\}` ([1],p20).
+        It is a subgroup of `G`.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> S = SymmetricGroup(7)
+        >>> Stab = S.pointwise_stabilizer([2, 3, 5])
+        >>> Stab.is_subgroup(S.stabilizer(2).stabilizer(3).stabilizer(5))
+        True
+
+        See Also
+        ========
+
+        stabilizer, schreier_sims_incremental
+
+        Notes
+        =====
+
+        When incremental == True,
+        rather than the obvious implementation using successive calls to
+        ``.stabilizer()``, this uses the incremental Schreier-Sims algorithm
+        to obtain a base with starting segment - the given points.
+
+        """
+        if incremental:
+            base, strong_gens = self.schreier_sims_incremental(base=points)
+            stab_gens = []
+            degree = self.degree
+            for gen in strong_gens:
+                if [gen(point) for point in points] == points:
+                    stab_gens.append(gen)
+            if not stab_gens:
+                stab_gens = _af_new(list(range(degree)))
+            return PermutationGroup(stab_gens)
+        else:
+            gens = self._generators
+            degree = self.degree
+            for x in points:
+                gens = _stabilizer(degree, gens, x)
+        return PermutationGroup(gens)
+
+    def make_perm(self, n, seed=None):
+        """
+        Multiply ``n`` randomly selected permutations from
+        pgroup together, starting with the identity
+        permutation. If ``n`` is a list of integers, those
+        integers will be used to select the permutations and they
+        will be applied in L to R order: make_perm((A, B, C)) will
+        give CBA(I) where I is the identity permutation.
+
+        ``seed`` is used to set the seed for the random selection
+        of permutations from pgroup. If this is a list of integers,
+        the corresponding permutations from pgroup will be selected
+        in the order give. This is mainly used for testing purposes.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a, b = [Permutation([1, 0, 3, 2]), Permutation([1, 3, 0, 2])]
+        >>> G = PermutationGroup([a, b])
+        >>> G.make_perm(1, [0])
+        (0 1)(2 3)
+        >>> G.make_perm(3, [0, 1, 0])
+        (0 2 3 1)
+        >>> G.make_perm([0, 1, 0])
+        (0 2 3 1)
+
+        See Also
+        ========
+
+        random
+        """
+        if is_sequence(n):
+            if seed is not None:
+                raise ValueError('If n is a sequence, seed should be None')
+            n, seed = len(n), n
+        else:
+            try:
+                n = int(n)
+            except TypeError:
+                raise ValueError('n must be an integer or a sequence.')
+        randomrange = _randrange(seed)
+
+        # start with the identity permutation
+        result = Permutation(list(range(self.degree)))
+        m = len(self)
+        for _ in range(n):
+            p = self[randomrange(m)]
+            result = rmul(result, p)
+        return result
+
+    def random(self, af=False):
+        """Return a random group element
+        """
+        rank = randrange(self.order())
+        return self.coset_unrank(rank, af)
+
+    def random_pr(self, gen_count=11, iterations=50, _random_prec=None):
+        """Return a random group element using product replacement.
+
+        Explanation
+        ===========
+
+        For the details of the product replacement algorithm, see
+        ``_random_pr_init`` In ``random_pr`` the actual 'product replacement'
+        is performed. Notice that if the attribute ``_random_gens``
+        is empty, it needs to be initialized by ``_random_pr_init``.
+
+        See Also
+        ========
+
+        _random_pr_init
+
+        """
+        if self._random_gens == []:
+            self._random_pr_init(gen_count, iterations)
+        random_gens = self._random_gens
+        r = len(random_gens) - 1
+
+        # handle randomized input for testing purposes
+        if _random_prec is None:
+            s = randrange(r)
+            t = randrange(r - 1)
+            if t == s:
+                t = r - 1
+            x = choice([1, 2])
+            e = choice([-1, 1])
+        else:
+            s = _random_prec['s']
+            t = _random_prec['t']
+            if t == s:
+                t = r - 1
+            x = _random_prec['x']
+            e = _random_prec['e']
+
+        if x == 1:
+            random_gens[s] = _af_rmul(random_gens[s], _af_pow(random_gens[t], e))
+            random_gens[r] = _af_rmul(random_gens[r], random_gens[s])
+        else:
+            random_gens[s] = _af_rmul(_af_pow(random_gens[t], e), random_gens[s])
+            random_gens[r] = _af_rmul(random_gens[s], random_gens[r])
+        return _af_new(random_gens[r])
+
+    def random_stab(self, alpha, schreier_vector=None, _random_prec=None):
+        """Random element from the stabilizer of ``alpha``.
+
+        The schreier vector for ``alpha`` is an optional argument used
+        for speeding up repeated calls. The algorithm is described in [1], p.81
+
+        See Also
+        ========
+
+        random_pr, orbit_rep
+
+        """
+        if schreier_vector is None:
+            schreier_vector = self.schreier_vector(alpha)
+        if _random_prec is None:
+            rand = self.random_pr()
+        else:
+            rand = _random_prec['rand']
+        beta = rand(alpha)
+        h = self.orbit_rep(alpha, beta, schreier_vector)
+        return rmul(~h, rand)
+
+    def schreier_sims(self):
+        """Schreier-Sims algorithm.
+
+        Explanation
+        ===========
+
+        It computes the generators of the chain of stabilizers
+        `G > G_{b_1} > .. > G_{b1,..,b_r} > 1`
+        in which `G_{b_1,..,b_i}` stabilizes `b_1,..,b_i`,
+        and the corresponding ``s`` cosets.
+        An element of the group can be written as the product
+        `h_1*..*h_s`.
+
+        We use the incremental Schreier-Sims algorithm.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([0, 2, 1])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.schreier_sims()
+        >>> G.basic_transversals
+        [{0: (2)(0 1), 1: (2), 2: (1 2)},
+         {0: (2), 2: (0 2)}]
+        """
+        if self._transversals:
+            return
+        self._schreier_sims()
+        return
+
+    def _schreier_sims(self, base=None):
+        schreier = self.schreier_sims_incremental(base=base, slp_dict=True)
+        base, strong_gens = schreier[:2]
+        self._base = base
+        self._strong_gens = strong_gens
+        self._strong_gens_slp = schreier[2]
+        if not base:
+            self._transversals = []
+            self._basic_orbits = []
+            return
+
+        strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+        basic_orbits, transversals, slps = _orbits_transversals_from_bsgs(base,\
+                strong_gens_distr, slp=True)
+
+        # rewrite the indices stored in slps in terms of strong_gens
+        for i, slp in enumerate(slps):
+            gens = strong_gens_distr[i]
+            for k in slp:
+                slp[k] = [strong_gens.index(gens[s]) for s in slp[k]]
+
+        self._transversals = transversals
+        self._basic_orbits = [sorted(x) for x in basic_orbits]
+        self._transversal_slp = slps
+
+    def schreier_sims_incremental(self, base=None, gens=None, slp_dict=False):
+        """Extend a sequence of points and generating set to a base and strong
+        generating set.
+
+        Parameters
+        ==========
+
+        base
+            The sequence of points to be extended to a base. Optional
+            parameter with default value ``[]``.
+        gens
+            The generating set to be extended to a strong generating set
+            relative to the base obtained. Optional parameter with default
+            value ``self.generators``.
+
+        slp_dict
+            If `True`, return a dictionary `{g: gens}` for each strong
+            generator `g` where `gens` is a list of strong generators
+            coming before `g` in `strong_gens`, such that the product
+            of the elements of `gens` is equal to `g`.
+
+        Returns
+        =======
+
+        (base, strong_gens)
+            ``base`` is the base obtained, and ``strong_gens`` is the strong
+            generating set relative to it. The original parameters ``base``,
+            ``gens`` remain unchanged.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import AlternatingGroup
+        >>> from sympy.combinatorics.testutil import _verify_bsgs
+        >>> A = AlternatingGroup(7)
+        >>> base = [2, 3]
+        >>> seq = [2, 3]
+        >>> base, strong_gens = A.schreier_sims_incremental(base=seq)
+        >>> _verify_bsgs(A, base, strong_gens)
+        True
+        >>> base[:2]
+        [2, 3]
+
+        Notes
+        =====
+
+        This version of the Schreier-Sims algorithm runs in polynomial time.
+        There are certain assumptions in the implementation - if the trivial
+        group is provided, ``base`` and ``gens`` are returned immediately,
+        as any sequence of points is a base for the trivial group. If the
+        identity is present in the generators ``gens``, it is removed as
+        it is a redundant generator.
+        The implementation is described in [1], pp. 90-93.
+
+        See Also
+        ========
+
+        schreier_sims, schreier_sims_random
+
+        """
+        if base is None:
+            base = []
+        if gens is None:
+            gens = self.generators[:]
+        degree = self.degree
+        id_af = list(range(degree))
+        # handle the trivial group
+        if len(gens) == 1 and gens[0].is_Identity:
+            if slp_dict:
+                return base, gens, {gens[0]: [gens[0]]}
+            return base, gens
+        # prevent side effects
+        _base, _gens = base[:], gens[:]
+        # remove the identity as a generator
+        _gens = [x for x in _gens if not x.is_Identity]
+        # make sure no generator fixes all base points
+        for gen in _gens:
+            if all(x == gen._array_form[x] for x in _base):
+                for new in id_af:
+                    if gen._array_form[new] != new:
+                        break
+                else:
+                    assert None  # can this ever happen?
+                _base.append(new)
+        # distribute generators according to basic stabilizers
+        strong_gens_distr = _distribute_gens_by_base(_base, _gens)
+        strong_gens_slp = []
+        # initialize the basic stabilizers, basic orbits and basic transversals
+        orbs = {}
+        transversals = {}
+        slps = {}
+        base_len = len(_base)
+        for i in range(base_len):
+            transversals[i], slps[i] = _orbit_transversal(degree, strong_gens_distr[i],
+                _base[i], pairs=True, af=True, slp=True)
+            transversals[i] = dict(transversals[i])
+            orbs[i] = list(transversals[i].keys())
+        # main loop: amend the stabilizer chain until we have generators
+        # for all stabilizers
+        i = base_len - 1
+        while i >= 0:
+            # this flag is used to continue with the main loop from inside
+            # a nested loop
+            continue_i = False
+            # test the generators for being a strong generating set
+            db = {}
+            for beta, u_beta in list(transversals[i].items()):
+                for j, gen in enumerate(strong_gens_distr[i]):
+                    gb = gen._array_form[beta]
+                    u1 = transversals[i][gb]
+                    g1 = _af_rmul(gen._array_form, u_beta)
+                    slp = [(i, g) for g in slps[i][beta]]
+                    slp = [(i, j)] + slp
+                    if g1 != u1:
+                        # test if the schreier generator is in the i+1-th
+                        # would-be basic stabilizer
+                        y = True
+                        try:
+                            u1_inv = db[gb]
+                        except KeyError:
+                            u1_inv = db[gb] = _af_invert(u1)
+                        schreier_gen = _af_rmul(u1_inv, g1)
+                        u1_inv_slp = slps[i][gb][:]
+                        u1_inv_slp.reverse()
+                        u1_inv_slp = [(i, (g,)) for g in u1_inv_slp]
+                        slp = u1_inv_slp + slp
+                        h, j, slp = _strip_af(schreier_gen, _base, orbs, transversals, i, slp=slp, slps=slps)
+                        if j <= base_len:
+                            # new strong generator h at level j
+                            y = False
+                        elif h:
+                            # h fixes all base points
+                            y = False
+                            moved = 0
+                            while h[moved] == moved:
+                                moved += 1
+                            _base.append(moved)
+                            base_len += 1
+                            strong_gens_distr.append([])
+                        if y is False:
+                            # if a new strong generator is found, update the
+                            # data structures and start over
+                            h = _af_new(h)
+                            strong_gens_slp.append((h, slp))
+                            for l in range(i + 1, j):
+                                strong_gens_distr[l].append(h)
+                                transversals[l], slps[l] =\
+                                _orbit_transversal(degree, strong_gens_distr[l],
+                                    _base[l], pairs=True, af=True, slp=True)
+                                transversals[l] = dict(transversals[l])
+                                orbs[l] = list(transversals[l].keys())
+                            i = j - 1
+                            # continue main loop using the flag
+                            continue_i = True
+                    if continue_i is True:
+                        break
+                if continue_i is True:
+                    break
+            if continue_i is True:
+                continue
+            i -= 1
+
+        strong_gens = _gens[:]
+
+        if slp_dict:
+            # create the list of the strong generators strong_gens and
+            # rewrite the indices of strong_gens_slp in terms of the
+            # elements of strong_gens
+            for k, slp in strong_gens_slp:
+                strong_gens.append(k)
+                for i in range(len(slp)):
+                    s = slp[i]
+                    if isinstance(s[1], tuple):
+                        slp[i] = strong_gens_distr[s[0]][s[1][0]]**-1
+                    else:
+                        slp[i] = strong_gens_distr[s[0]][s[1]]
+            strong_gens_slp = dict(strong_gens_slp)
+            # add the original generators
+            for g in _gens:
+                strong_gens_slp[g] = [g]
+            return (_base, strong_gens, strong_gens_slp)
+
+        strong_gens.extend([k for k, _ in strong_gens_slp])
+        return _base, strong_gens
+
+    def schreier_sims_random(self, base=None, gens=None, consec_succ=10,
+                             _random_prec=None):
+        r"""Randomized Schreier-Sims algorithm.
+
+        Explanation
+        ===========
+
+        The randomized Schreier-Sims algorithm takes the sequence ``base``
+        and the generating set ``gens``, and extends ``base`` to a base, and
+        ``gens`` to a strong generating set relative to that base with
+        probability of a wrong answer at most `2^{-consec\_succ}`,
+        provided the random generators are sufficiently random.
+
+        Parameters
+        ==========
+
+        base
+            The sequence to be extended to a base.
+        gens
+            The generating set to be extended to a strong generating set.
+        consec_succ
+            The parameter defining the probability of a wrong answer.
+        _random_prec
+            An internal parameter used for testing purposes.
+
+        Returns
+        =======
+
+        (base, strong_gens)
+            ``base`` is the base and ``strong_gens`` is the strong generating
+            set relative to it.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.testutil import _verify_bsgs
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> S = SymmetricGroup(5)
+        >>> base, strong_gens = S.schreier_sims_random(consec_succ=5)
+        >>> _verify_bsgs(S, base, strong_gens) #doctest: +SKIP
+        True
+
+        Notes
+        =====
+
+        The algorithm is described in detail in [1], pp. 97-98. It extends
+        the orbits ``orbs`` and the permutation groups ``stabs`` to
+        basic orbits and basic stabilizers for the base and strong generating
+        set produced in the end.
+        The idea of the extension process
+        is to "sift" random group elements through the stabilizer chain
+        and amend the stabilizers/orbits along the way when a sift
+        is not successful.
+        The helper function ``_strip`` is used to attempt
+        to decompose a random group element according to the current
+        state of the stabilizer chain and report whether the element was
+        fully decomposed (successful sift) or not (unsuccessful sift). In
+        the latter case, the level at which the sift failed is reported and
+        used to amend ``stabs``, ``base``, ``gens`` and ``orbs`` accordingly.
+        The halting condition is for ``consec_succ`` consecutive successful
+        sifts to pass. This makes sure that the current ``base`` and ``gens``
+        form a BSGS with probability at least `1 - 1/\text{consec\_succ}`.
+
+        See Also
+        ========
+
+        schreier_sims
+
+        """
+        if base is None:
+            base = []
+        if gens is None:
+            gens = self.generators
+        base_len = len(base)
+        n = self.degree
+        # make sure no generator fixes all base points
+        for gen in gens:
+            if all(gen(x) == x for x in base):
+                new = 0
+                while gen._array_form[new] == new:
+                    new += 1
+                base.append(new)
+                base_len += 1
+        # distribute generators according to basic stabilizers
+        strong_gens_distr = _distribute_gens_by_base(base, gens)
+        # initialize the basic stabilizers, basic transversals and basic orbits
+        transversals = {}
+        orbs = {}
+        for i in range(base_len):
+            transversals[i] = dict(_orbit_transversal(n, strong_gens_distr[i],
+                base[i], pairs=True))
+            orbs[i] = list(transversals[i].keys())
+        # initialize the number of consecutive elements sifted
+        c = 0
+        # start sifting random elements while the number of consecutive sifts
+        # is less than consec_succ
+        while c < consec_succ:
+            if _random_prec is None:
+                g = self.random_pr()
+            else:
+                g = _random_prec['g'].pop()
+            h, j = _strip(g, base, orbs, transversals)
+            y = True
+            # determine whether a new base point is needed
+            if j <= base_len:
+                y = False
+            elif not h.is_Identity:
+                y = False
+                moved = 0
+                while h(moved) == moved:
+                    moved += 1
+                base.append(moved)
+                base_len += 1
+                strong_gens_distr.append([])
+            # if the element doesn't sift, amend the strong generators and
+            # associated stabilizers and orbits
+            if y is False:
+                for l in range(1, j):
+                    strong_gens_distr[l].append(h)
+                    transversals[l] = dict(_orbit_transversal(n,
+                        strong_gens_distr[l], base[l], pairs=True))
+                    orbs[l] = list(transversals[l].keys())
+                c = 0
+            else:
+                c += 1
+        # build the strong generating set
+        strong_gens = strong_gens_distr[0][:]
+        for gen in strong_gens_distr[1]:
+            if gen not in strong_gens:
+                strong_gens.append(gen)
+        return base, strong_gens
+
+    def schreier_vector(self, alpha):
+        """Computes the schreier vector for ``alpha``.
+
+        Explanation
+        ===========
+
+        The Schreier vector efficiently stores information
+        about the orbit of ``alpha``. It can later be used to quickly obtain
+        elements of the group that send ``alpha`` to a particular element
+        in the orbit. Notice that the Schreier vector depends on the order
+        in which the group generators are listed. For a definition, see [3].
+        Since list indices start from zero, we adopt the convention to use
+        "None" instead of 0 to signify that an element does not belong
+        to the orbit.
+        For the algorithm and its correctness, see [2], pp.78-80.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([2, 4, 6, 3, 1, 5, 0])
+        >>> b = Permutation([0, 1, 3, 5, 4, 6, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.schreier_vector(0)
+        [-1, None, 0, 1, None, 1, 0]
+
+        See Also
+        ========
+
+        orbit
+
+        """
+        n = self.degree
+        v = [None]*n
+        v[alpha] = -1
+        orb = [alpha]
+        used = [False]*n
+        used[alpha] = True
+        gens = self.generators
+        r = len(gens)
+        for b in orb:
+            for i in range(r):
+                temp = gens[i]._array_form[b]
+                if used[temp] is False:
+                    orb.append(temp)
+                    used[temp] = True
+                    v[temp] = i
+        return v
+
+    def stabilizer(self, alpha):
+        r"""Return the stabilizer subgroup of ``alpha``.
+
+        Explanation
+        ===========
+
+        The stabilizer of `\alpha` is the group `G_\alpha =
+        \{g \in G | g(\alpha) = \alpha\}`.
+        For a proof of correctness, see [1], p.79.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> G = DihedralGroup(6)
+        >>> G.stabilizer(5)
+        PermutationGroup([
+            (5)(0 4)(1 3)])
+
+        See Also
+        ========
+
+        orbit
+
+        """
+        return PermGroup(_stabilizer(self._degree, self._generators, alpha))
+
+    @property
+    def strong_gens(self):
+        r"""Return a strong generating set from the Schreier-Sims algorithm.
+
+        Explanation
+        ===========
+
+        A generating set `S = \{g_1, g_2, \dots, g_t\}` for a permutation group
+        `G` is a strong generating set relative to the sequence of points
+        (referred to as a "base") `(b_1, b_2, \dots, b_k)` if, for
+        `1 \leq i \leq k` we have that the intersection of the pointwise
+        stabilizer `G^{(i+1)} := G_{b_1, b_2, \dots, b_i}` with `S` generates
+        the pointwise stabilizer `G^{(i+1)}`. The concepts of a base and
+        strong generating set and their applications are discussed in depth
+        in [1], pp. 87-89 and [2], pp. 55-57.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> D = DihedralGroup(4)
+        >>> D.strong_gens
+        [(0 1 2 3), (0 3)(1 2), (1 3)]
+        >>> D.base
+        [0, 1]
+
+        See Also
+        ========
+
+        base, basic_transversals, basic_orbits, basic_stabilizers
+
+        """
+        if self._strong_gens == []:
+            self.schreier_sims()
+        return self._strong_gens
+
+    def subgroup(self, gens):
+        """
+           Return the subgroup generated by `gens` which is a list of
+           elements of the group
+        """
+
+        if not all(g in self for g in gens):
+            raise ValueError("The group does not contain the supplied generators")
+
+        G = PermutationGroup(gens)
+        return G
+
+    def subgroup_search(self, prop, base=None, strong_gens=None, tests=None,
+                        init_subgroup=None):
+        """Find the subgroup of all elements satisfying the property ``prop``.
+
+        Explanation
+        ===========
+
+        This is done by a depth-first search with respect to base images that
+        uses several tests to prune the search tree.
+
+        Parameters
+        ==========
+
+        prop
+            The property to be used. Has to be callable on group elements
+            and always return ``True`` or ``False``. It is assumed that
+            all group elements satisfying ``prop`` indeed form a subgroup.
+        base
+            A base for the supergroup.
+        strong_gens
+            A strong generating set for the supergroup.
+        tests
+            A list of callables of length equal to the length of ``base``.
+            These are used to rule out group elements by partial base images,
+            so that ``tests[l](g)`` returns False if the element ``g`` is known
+            not to satisfy prop base on where g sends the first ``l + 1`` base
+            points.
+        init_subgroup
+            if a subgroup of the sought group is
+            known in advance, it can be passed to the function as this
+            parameter.
+
+        Returns
+        =======
+
+        res
+            The subgroup of all elements satisfying ``prop``. The generating
+            set for this group is guaranteed to be a strong generating set
+            relative to the base ``base``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+        ... AlternatingGroup)
+        >>> from sympy.combinatorics.testutil import _verify_bsgs
+        >>> S = SymmetricGroup(7)
+        >>> prop_even = lambda x: x.is_even
+        >>> base, strong_gens = S.schreier_sims_incremental()
+        >>> G = S.subgroup_search(prop_even, base=base, strong_gens=strong_gens)
+        >>> G.is_subgroup(AlternatingGroup(7))
+        True
+        >>> _verify_bsgs(G, base, G.generators)
+        True
+
+        Notes
+        =====
+
+        This function is extremely lengthy and complicated and will require
+        some careful attention. The implementation is described in
+        [1], pp. 114-117, and the comments for the code here follow the lines
+        of the pseudocode in the book for clarity.
+
+        The complexity is exponential in general, since the search process by
+        itself visits all members of the supergroup. However, there are a lot
+        of tests which are used to prune the search tree, and users can define
+        their own tests via the ``tests`` parameter, so in practice, and for
+        some computations, it's not terrible.
+
+        A crucial part in the procedure is the frequent base change performed
+        (this is line 11 in the pseudocode) in order to obtain a new basic
+        stabilizer. The book mentiones that this can be done by using
+        ``.baseswap(...)``, however the current implementation uses a more
+        straightforward way to find the next basic stabilizer - calling the
+        function ``.stabilizer(...)`` on the previous basic stabilizer.
+
+        """
+        # initialize BSGS and basic group properties
+        def get_reps(orbits):
+            # get the minimal element in the base ordering
+            return [min(orbit, key = lambda x: base_ordering[x]) \
+              for orbit in orbits]
+
+        def update_nu(l):
+            temp_index = len(basic_orbits[l]) + 1 -\
+                         len(res_basic_orbits_init_base[l])
+            # this corresponds to the element larger than all points
+            if temp_index >= len(sorted_orbits[l]):
+                nu[l] = base_ordering[degree]
+            else:
+                nu[l] = sorted_orbits[l][temp_index]
+
+        if base is None:
+            base, strong_gens = self.schreier_sims_incremental()
+        base_len = len(base)
+        degree = self.degree
+        identity = _af_new(list(range(degree)))
+        base_ordering = _base_ordering(base, degree)
+        # add an element larger than all points
+        base_ordering.append(degree)
+        # add an element smaller than all points
+        base_ordering.append(-1)
+        # compute BSGS-related structures
+        strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+        basic_orbits, transversals = _orbits_transversals_from_bsgs(base,
+                                     strong_gens_distr)
+        # handle subgroup initialization and tests
+        if init_subgroup is None:
+            init_subgroup = PermutationGroup([identity])
+        if tests is None:
+            trivial_test = lambda x: True
+            tests = []
+            for i in range(base_len):
+                tests.append(trivial_test)
+        # line 1: more initializations.
+        res = init_subgroup
+        f = base_len - 1
+        l = base_len - 1
+        # line 2: set the base for K to the base for G
+        res_base = base[:]
+        # line 3: compute BSGS and related structures for K
+        res_base, res_strong_gens = res.schreier_sims_incremental(
+            base=res_base)
+        res_strong_gens_distr = _distribute_gens_by_base(res_base,
+                                res_strong_gens)
+        res_generators = res.generators
+        res_basic_orbits_init_base = \
+        [_orbit(degree, res_strong_gens_distr[i], res_base[i])\
+         for i in range(base_len)]
+        # initialize orbit representatives
+        orbit_reps = [None]*base_len
+        # line 4: orbit representatives for f-th basic stabilizer of K
+        orbits = _orbits(degree, res_strong_gens_distr[f])
+        orbit_reps[f] = get_reps(orbits)
+        # line 5: remove the base point from the representatives to avoid
+        # getting the identity element as a generator for K
+        orbit_reps[f].remove(base[f])
+        # line 6: more initializations
+        c = [0]*base_len
+        u = [identity]*base_len
+        sorted_orbits = [None]*base_len
+        for i in range(base_len):
+            sorted_orbits[i] = basic_orbits[i][:]
+            sorted_orbits[i].sort(key=lambda point: base_ordering[point])
+        # line 7: initializations
+        mu = [None]*base_len
+        nu = [None]*base_len
+        # this corresponds to the element smaller than all points
+        mu[l] = degree + 1
+        update_nu(l)
+        # initialize computed words
+        computed_words = [identity]*base_len
+        # line 8: main loop
+        while True:
+            # apply all the tests
+            while l < base_len - 1 and \
+                computed_words[l](base[l]) in orbit_reps[l] and \
+                base_ordering[mu[l]] < \
+                base_ordering[computed_words[l](base[l])] < \
+                base_ordering[nu[l]] and \
+                    tests[l](computed_words):
+                # line 11: change the (partial) base of K
+                new_point = computed_words[l](base[l])
+                res_base[l] = new_point
+                new_stab_gens = _stabilizer(degree, res_strong_gens_distr[l],
+                        new_point)
+                res_strong_gens_distr[l + 1] = new_stab_gens
+                # line 12: calculate minimal orbit representatives for the
+                # l+1-th basic stabilizer
+                orbits = _orbits(degree, new_stab_gens)
+                orbit_reps[l + 1] = get_reps(orbits)
+                # line 13: amend sorted orbits
+                l += 1
+                temp_orbit = [computed_words[l - 1](point) for point
+                             in basic_orbits[l]]
+                temp_orbit.sort(key=lambda point: base_ordering[point])
+                sorted_orbits[l] = temp_orbit
+                # lines 14 and 15: update variables used minimality tests
+                new_mu = degree + 1
+                for i in range(l):
+                    if base[l] in res_basic_orbits_init_base[i]:
+                        candidate = computed_words[i](base[i])
+                        if base_ordering[candidate] > base_ordering[new_mu]:
+                            new_mu = candidate
+                mu[l] = new_mu
+                update_nu(l)
+                # line 16: determine the new transversal element
+                c[l] = 0
+                temp_point = sorted_orbits[l][c[l]]
+                gamma = computed_words[l - 1]._array_form.index(temp_point)
+                u[l] = transversals[l][gamma]
+                # update computed words
+                computed_words[l] = rmul(computed_words[l - 1], u[l])
+            # lines 17 & 18: apply the tests to the group element found
+            g = computed_words[l]
+            temp_point = g(base[l])
+            if l == base_len - 1 and \
+                base_ordering[mu[l]] < \
+                base_ordering[temp_point] < base_ordering[nu[l]] and \
+                temp_point in orbit_reps[l] and \
+                tests[l](computed_words) and \
+                    prop(g):
+                # line 19: reset the base of K
+                res_generators.append(g)
+                res_base = base[:]
+                # line 20: recalculate basic orbits (and transversals)
+                res_strong_gens.append(g)
+                res_strong_gens_distr = _distribute_gens_by_base(res_base,
+                                                          res_strong_gens)
+                res_basic_orbits_init_base = \
+                [_orbit(degree, res_strong_gens_distr[i], res_base[i]) \
+                 for i in range(base_len)]
+                # line 21: recalculate orbit representatives
+                # line 22: reset the search depth
+                orbit_reps[f] = get_reps(orbits)
+                l = f
+            # line 23: go up the tree until in the first branch not fully
+            # searched
+            while l >= 0 and c[l] == len(basic_orbits[l]) - 1:
+                l = l - 1
+            # line 24: if the entire tree is traversed, return K
+            if l == -1:
+                return PermutationGroup(res_generators)
+            # lines 25-27: update orbit representatives
+            if l < f:
+                # line 26
+                f = l
+                c[l] = 0
+                # line 27
+                temp_orbits = _orbits(degree, res_strong_gens_distr[f])
+                orbit_reps[f] = get_reps(temp_orbits)
+                # line 28: update variables used for minimality testing
+                mu[l] = degree + 1
+                temp_index = len(basic_orbits[l]) + 1 - \
+                    len(res_basic_orbits_init_base[l])
+                if temp_index >= len(sorted_orbits[l]):
+                    nu[l] = base_ordering[degree]
+                else:
+                    nu[l] = sorted_orbits[l][temp_index]
+            # line 29: set the next element from the current branch and update
+            # accordingly
+            c[l] += 1
+            if l == 0:
+                gamma  = sorted_orbits[l][c[l]]
+            else:
+                gamma = computed_words[l - 1]._array_form.index(sorted_orbits[l][c[l]])
+
+            u[l] = transversals[l][gamma]
+            if l == 0:
+                computed_words[l] = u[l]
+            else:
+                computed_words[l] = rmul(computed_words[l - 1], u[l])
+
+    @property
+    def transitivity_degree(self):
+        r"""Compute the degree of transitivity of the group.
+
+        Explanation
+        ===========
+
+        A permutation group `G` acting on `\Omega = \{0, 1, \dots, n-1\}` is
+        ``k``-fold transitive, if, for any `k` points
+        `(a_1, a_2, \dots, a_k) \in \Omega` and any `k` points
+        `(b_1, b_2, \dots, b_k) \in \Omega` there exists `g \in  G` such that
+        `g(a_1) = b_1, g(a_2) = b_2, \dots, g(a_k) = b_k`
+        The degree of transitivity of `G` is the maximum ``k`` such that
+        `G` is ``k``-fold transitive. ([8])
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup
+        >>> a = Permutation([1, 2, 0])
+        >>> b = Permutation([1, 0, 2])
+        >>> G = PermutationGroup([a, b])
+        >>> G.transitivity_degree
+        3
+
+        See Also
+        ========
+
+        is_transitive, orbit
+
+        """
+        if self._transitivity_degree is None:
+            n = self.degree
+            G = self
+            # if G is k-transitive, a tuple (a_0,..,a_k)
+            # can be brought to (b_0,...,b_(k-1), b_k)
+            # where b_0,...,b_(k-1) are fixed points;
+            # consider the group G_k which stabilizes b_0,...,b_(k-1)
+            # if G_k is transitive on the subset excluding b_0,...,b_(k-1)
+            # then G is (k+1)-transitive
+            for i in range(n):
+                orb = G.orbit(i)
+                if len(orb) != n - i:
+                    self._transitivity_degree = i
+                    return i
+                G = G.stabilizer(i)
+            self._transitivity_degree = n
+            return n
+        else:
+            return self._transitivity_degree
+
+    def _p_elements_group(self, p):
+        '''
+        For an abelian p-group, return the subgroup consisting of
+        all elements of order p (and the identity)
+
+        '''
+        gens = self.generators[:]
+        gens = sorted(gens, key=lambda x: x.order(), reverse=True)
+        gens_p = [g**(g.order()/p) for g in gens]
+        gens_r = []
+        for i in range(len(gens)):
+            x = gens[i]
+            x_order = x.order()
+            # x_p has order p
+            x_p = x**(x_order/p)
+            if i > 0:
+                P = PermutationGroup(gens_p[:i])
+            else:
+                P = PermutationGroup(self.identity)
+            if x**(x_order/p) not in P:
+                gens_r.append(x**(x_order/p))
+            else:
+                # replace x by an element of order (x.order()/p)
+                # so that gens still generates G
+                g = P.generator_product(x_p, original=True)
+                for s in g:
+                    x = x*s**-1
+                x_order = x_order/p
+                # insert x to gens so that the sorting is preserved
+                del gens[i]
+                del gens_p[i]
+                j = i - 1
+                while j < len(gens) and gens[j].order() >= x_order:
+                    j += 1
+                gens = gens[:j] + [x] + gens[j:]
+                gens_p = gens_p[:j] + [x] + gens_p[j:]
+        return PermutationGroup(gens_r)
+
+    def _sylow_alt_sym(self, p):
+        '''
+        Return a p-Sylow subgroup of a symmetric or an
+        alternating group.
+
+        Explanation
+        ===========
+
+        The algorithm for this is hinted at in [1], Chapter 4,
+        Exercise 4.
+
+        For Sym(n) with n = p^i, the idea is as follows. Partition
+        the interval [0..n-1] into p equal parts, each of length p^(i-1):
+        [0..p^(i-1)-1], [p^(i-1)..2*p^(i-1)-1]...[(p-1)*p^(i-1)..p^i-1].
+        Find a p-Sylow subgroup of Sym(p^(i-1)) (treated as a subgroup
+        of ``self``) acting on each of the parts. Call the subgroups
+        P_1, P_2...P_p. The generators for the subgroups P_2...P_p
+        can be obtained from those of P_1 by applying a "shifting"
+        permutation to them, that is, a permutation mapping [0..p^(i-1)-1]
+        to the second part (the other parts are obtained by using the shift
+        multiple times). The union of this permutation and the generators
+        of P_1 is a p-Sylow subgroup of ``self``.
+
+        For n not equal to a power of p, partition
+        [0..n-1] in accordance with how n would be written in base p.
+        E.g. for p=2 and n=11, 11 = 2^3 + 2^2 + 1 so the partition
+        is [[0..7], [8..9], {10}]. To generate a p-Sylow subgroup,
+        take the union of the generators for each of the parts.
+        For the above example, {(0 1), (0 2)(1 3), (0 4), (1 5)(2 7)}
+        from the first part, {(8 9)} from the second part and
+        nothing from the third. This gives 4 generators in total, and
+        the subgroup they generate is p-Sylow.
+
+        Alternating groups are treated the same except when p=2. In this
+        case, (0 1)(s s+1) should be added for an appropriate s (the start
+        of a part) for each part in the partitions.
+
+        See Also
+        ========
+
+        sylow_subgroup, is_alt_sym
+
+        '''
+        n = self.degree
+        gens = []
+        identity = Permutation(n-1)
+        # the case of 2-sylow subgroups of alternating groups
+        # needs special treatment
+        alt = p == 2 and all(g.is_even for g in self.generators)
+
+        # find the presentation of n in base p
+        coeffs = []
+        m = n
+        while m > 0:
+            coeffs.append(m % p)
+            m = m // p
+
+        power = len(coeffs)-1
+        # for a symmetric group, gens[:i] is the generating
+        # set for a p-Sylow subgroup on [0..p**(i-1)-1]. For
+        # alternating groups, the same is given by gens[:2*(i-1)]
+        for i in range(1, power+1):
+            if i == 1 and alt:
+                # (0 1) shouldn't be added for alternating groups
+                continue
+            gen = Permutation([(j + p**(i-1)) % p**i for j in range(p**i)])
+            gens.append(identity*gen)
+            if alt:
+                gen = Permutation(0, 1)*gen*Permutation(0, 1)*gen
+                gens.append(gen)
+
+        # the first point in the current part (see the algorithm
+        # description in the docstring)
+        start = 0
+
+        while power > 0:
+            a = coeffs[power]
+
+            # make the permutation shifting the start of the first
+            # part ([0..p^i-1] for some i) to the current one
+            for _ in range(a):
+                shift = Permutation()
+                if start > 0:
+                    for i in range(p**power):
+                        shift = shift(i, start + i)
+
+                    if alt:
+                        gen = Permutation(0, 1)*shift*Permutation(0, 1)*shift
+                        gens.append(gen)
+                        j = 2*(power - 1)
+                    else:
+                        j = power
+
+                    for i, gen in enumerate(gens[:j]):
+                        if alt and i % 2 == 1:
+                            continue
+                        # shift the generator to the start of the
+                        # partition part
+                        gen = shift*gen*shift
+                        gens.append(gen)
+
+                start += p**power
+            power = power-1
+
+        return gens
+
+    def sylow_subgroup(self, p):
+        '''
+        Return a p-Sylow subgroup of the group.
+
+        The algorithm is described in [1], Chapter 4, Section 7
+
+        Examples
+        ========
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> from sympy.combinatorics.named_groups import SymmetricGroup
+        >>> from sympy.combinatorics.named_groups import AlternatingGroup
+
+        >>> D = DihedralGroup(6)
+        >>> S = D.sylow_subgroup(2)
+        >>> S.order()
+        4
+        >>> G = SymmetricGroup(6)
+        >>> S = G.sylow_subgroup(5)
+        >>> S.order()
+        5
+
+        >>> G1 = AlternatingGroup(3)
+        >>> G2 = AlternatingGroup(5)
+        >>> G3 = AlternatingGroup(9)
+
+        >>> S1 = G1.sylow_subgroup(3)
+        >>> S2 = G2.sylow_subgroup(3)
+        >>> S3 = G3.sylow_subgroup(3)
+
+        >>> len1 = len(S1.lower_central_series())
+        >>> len2 = len(S2.lower_central_series())
+        >>> len3 = len(S3.lower_central_series())
+
+        >>> len1 == len2
+        True
+        >>> len1 < len3
+        True
+
+        '''
+        from sympy.combinatorics.homomorphisms import (
+                orbit_homomorphism, block_homomorphism)
+
+        if not isprime(p):
+            raise ValueError("p must be a prime")
+
+        def is_p_group(G):
+            # check if the order of G is a power of p
+            # and return the power
+            m = G.order()
+            n = 0
+            while m % p == 0:
+                m = m/p
+                n += 1
+                if m == 1:
+                    return True, n
+            return False, n
+
+        def _sylow_reduce(mu, nu):
+            # reduction based on two homomorphisms
+            # mu and nu with trivially intersecting
+            # kernels
+            Q = mu.image().sylow_subgroup(p)
+            Q = mu.invert_subgroup(Q)
+            nu = nu.restrict_to(Q)
+            R = nu.image().sylow_subgroup(p)
+            return nu.invert_subgroup(R)
+
+        order = self.order()
+        if order % p != 0:
+            return PermutationGroup([self.identity])
+        p_group, n = is_p_group(self)
+        if p_group:
+            return self
+
+        if self.is_alt_sym():
+            return PermutationGroup(self._sylow_alt_sym(p))
+
+        # if there is a non-trivial orbit with size not divisible
+        # by p, the sylow subgroup is contained in its stabilizer
+        # (by orbit-stabilizer theorem)
+        orbits = self.orbits()
+        non_p_orbits = [o for o in orbits if len(o) % p != 0 and len(o) != 1]
+        if non_p_orbits:
+            G = self.stabilizer(list(non_p_orbits[0]).pop())
+            return G.sylow_subgroup(p)
+
+        if not self.is_transitive():
+            # apply _sylow_reduce to orbit actions
+            orbits = sorted(orbits, key=len)
+            omega1 = orbits.pop()
+            omega2 = orbits[0].union(*orbits)
+            mu = orbit_homomorphism(self, omega1)
+            nu = orbit_homomorphism(self, omega2)
+            return _sylow_reduce(mu, nu)
+
+        blocks = self.minimal_blocks()
+        if len(blocks) > 1:
+            # apply _sylow_reduce to block system actions
+            mu = block_homomorphism(self, blocks[0])
+            nu = block_homomorphism(self, blocks[1])
+            return _sylow_reduce(mu, nu)
+        elif len(blocks) == 1:
+            block = list(blocks)[0]
+            if any(e != 0 for e in block):
+                # self is imprimitive
+                mu = block_homomorphism(self, block)
+                if not is_p_group(mu.image())[0]:
+                    S = mu.image().sylow_subgroup(p)
+                    return mu.invert_subgroup(S).sylow_subgroup(p)
+
+        # find an element of order p
+        g = self.random()
+        g_order = g.order()
+        while g_order % p != 0 or g_order == 0:
+            g = self.random()
+            g_order = g.order()
+        g = g**(g_order // p)
+        if order % p**2 != 0:
+            return PermutationGroup(g)
+
+        C = self.centralizer(g)
+        while C.order() % p**n != 0:
+            S = C.sylow_subgroup(p)
+            s_order = S.order()
+            Z = S.center()
+            P = Z._p_elements_group(p)
+            h = P.random()
+            C_h = self.centralizer(h)
+            while C_h.order() % p*s_order != 0:
+                h = P.random()
+                C_h = self.centralizer(h)
+            C = C_h
+
+        return C.sylow_subgroup(p)
+
+    def _block_verify(self, L, alpha):
+        delta = sorted(self.orbit(alpha))
+        # p[i] will be the number of the block
+        # delta[i] belongs to
+        p = [-1]*len(delta)
+        blocks = [-1]*len(delta)
+
+        B = [[]] # future list of blocks
+        u = [0]*len(delta) # u[i] in L s.t. alpha^u[i] = B[0][i]
+
+        t = L.orbit_transversal(alpha, pairs=True)
+        for a, beta in t:
+            B[0].append(a)
+            i_a = delta.index(a)
+            p[i_a] = 0
+            blocks[i_a] = alpha
+            u[i_a] = beta
+
+        rho = 0
+        m = 0 # number of blocks - 1
+
+        while rho <= m:
+            beta = B[rho][0]
+            for g in self.generators:
+                d = beta^g
+                i_d = delta.index(d)
+                sigma = p[i_d]
+                if sigma < 0:
+                    # define a new block
+                    m += 1
+                    sigma = m
+                    u[i_d] = u[delta.index(beta)]*g
+                    p[i_d] = sigma
+                    rep = d
+                    blocks[i_d] = rep
+                    newb = [rep]
+                    for gamma in B[rho][1:]:
+                        i_gamma = delta.index(gamma)
+                        d = gamma^g
+                        i_d = delta.index(d)
+                        if p[i_d] < 0:
+                            u[i_d] = u[i_gamma]*g
+                            p[i_d] = sigma
+                            blocks[i_d] = rep
+                            newb.append(d)
+                        else:
+                            # B[rho] is not a block
+                            s = u[i_gamma]*g*u[i_d]**(-1)
+                            return False, s
+
+                    B.append(newb)
+                else:
+                    for h in B[rho][1:]:
+                        if h^g not in B[sigma]:
+                            # B[rho] is not a block
+                            s = u[delta.index(beta)]*g*u[i_d]**(-1)
+                            return False, s
+            rho += 1
+
+        return True, blocks
+
+    def _verify(H, K, phi, z, alpha):
+        '''
+        Return a list of relators ``rels`` in generators ``gens`_h` that
+        are mapped to ``H.generators`` by ``phi`` so that given a finite
+        presentation  of ``K`` on a subset of ``gens_h``
+         is a finite presentation of ``H``.
+
+        Explanation
+        ===========
+
+        ``H`` should be generated by the union of ``K.generators`` and ``z``
+        (a single generator), and ``H.stabilizer(alpha) == K``; ``phi`` is a
+        canonical injection from a free group into a permutation group
+        containing ``H``.
+
+        The algorithm is described in [1], Chapter 6.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import free_group, Permutation, PermutationGroup
+        >>> from sympy.combinatorics.homomorphisms import homomorphism
+        >>> from sympy.combinatorics.fp_groups import FpGroup
+
+        >>> H = PermutationGroup(Permutation(0, 2), Permutation (1, 5))
+        >>> K = PermutationGroup(Permutation(5)(0, 2))
+        >>> F = free_group("x_0 x_1")[0]
+        >>> gens = F.generators
+        >>> phi = homomorphism(F, H, F.generators, H.generators)
+        >>> rels_k = [gens[0]**2] # relators for presentation of K
+        >>> z= Permutation(1, 5)
+        >>> check, rels_h = H._verify(K, phi, z, 1)
+        >>> check
+        True
+        >>> rels = rels_k + rels_h
+        >>> G = FpGroup(F, rels) # presentation of H
+        >>> G.order() == H.order()
+        True
+
+        See also
+        ========
+
+        strong_presentation, presentation, stabilizer
+
+        '''
+
+        orbit = H.orbit(alpha)
+        beta = alpha^(z**-1)
+
+        K_beta = K.stabilizer(beta)
+
+        # orbit representatives of K_beta
+        gammas = [alpha, beta]
+        orbits = list({tuple(K_beta.orbit(o)) for o in orbit})
+        orbit_reps = [orb[0] for orb in orbits]
+        for rep in orbit_reps:
+            if rep not in gammas:
+                gammas.append(rep)
+
+        # orbit transversal of K
+        betas = [alpha, beta]
+        transversal = {alpha: phi.invert(H.identity), beta: phi.invert(z**-1)}
+
+        for s, g in K.orbit_transversal(beta, pairs=True):
+            if s not in transversal:
+                transversal[s] = transversal[beta]*phi.invert(g)
+
+
+        union = K.orbit(alpha).union(K.orbit(beta))
+        while (len(union) < len(orbit)):
+            for gamma in gammas:
+                if gamma in union:
+                    r = gamma^z
+                    if r not in union:
+                        betas.append(r)
+                        transversal[r] = transversal[gamma]*phi.invert(z)
+                        for s, g in K.orbit_transversal(r, pairs=True):
+                            if s not in transversal:
+                                transversal[s] = transversal[r]*phi.invert(g)
+                        union = union.union(K.orbit(r))
+                        break
+
+        # compute relators
+        rels = []
+
+        for b in betas:
+            k_gens = K.stabilizer(b).generators
+            for y in k_gens:
+                new_rel = transversal[b]
+                gens = K.generator_product(y, original=True)
+                for g in gens[::-1]:
+                    new_rel = new_rel*phi.invert(g)
+                new_rel = new_rel*transversal[b]**-1
+
+                perm = phi(new_rel)
+                try:
+                    gens = K.generator_product(perm, original=True)
+                except ValueError:
+                    return False, perm
+                for g in gens:
+                    new_rel = new_rel*phi.invert(g)**-1
+                if new_rel not in rels:
+                    rels.append(new_rel)
+
+        for gamma in gammas:
+            new_rel = transversal[gamma]*phi.invert(z)*transversal[gamma^z]**-1
+            perm = phi(new_rel)
+            try:
+                gens = K.generator_product(perm, original=True)
+            except ValueError:
+                return False, perm
+            for g in gens:
+                new_rel = new_rel*phi.invert(g)**-1
+            if new_rel not in rels:
+                rels.append(new_rel)
+
+        return True, rels
+
+    def strong_presentation(self):
+        '''
+        Return a strong finite presentation of group. The generators
+        of the returned group are in the same order as the strong
+        generators of group.
+
+        The algorithm is based on Sims' Verify algorithm described
+        in [1], Chapter 6.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.named_groups import DihedralGroup
+        >>> P = DihedralGroup(4)
+        >>> G = P.strong_presentation()
+        >>> P.order() == G.order()
+        True
+
+        See Also
+        ========
+
+        presentation, _verify
+
+        '''
+        from sympy.combinatorics.fp_groups import (FpGroup,
+                                            simplify_presentation)
+        from sympy.combinatorics.free_groups import free_group
+        from sympy.combinatorics.homomorphisms import (block_homomorphism,
+                                           homomorphism, GroupHomomorphism)
+
+        strong_gens = self.strong_gens[:]
+        stabs = self.basic_stabilizers[:]
+        base = self.base[:]
+
+        # injection from a free group on len(strong_gens)
+        # generators into G
+        gen_syms = [('x_%d'%i) for i in range(len(strong_gens))]
+        F = free_group(', '.join(gen_syms))[0]
+        phi = homomorphism(F, self, F.generators, strong_gens)
+
+        H = PermutationGroup(self.identity)
+        while stabs:
+            alpha = base.pop()
+            K = H
+            H = stabs.pop()
+            new_gens = [g for g in H.generators if g not in K]
+
+            if K.order() == 1:
+                z = new_gens.pop()
+                rels = [F.generators[-1]**z.order()]
+                intermediate_gens = [z]
+                K = PermutationGroup(intermediate_gens)
+
+            # add generators one at a time building up from K to H
+            while new_gens:
+                z = new_gens.pop()
+                intermediate_gens = [z] + intermediate_gens
+                K_s = PermutationGroup(intermediate_gens)
+                orbit = K_s.orbit(alpha)
+                orbit_k = K.orbit(alpha)
+
+                # split into cases based on the orbit of K_s
+                if orbit_k == orbit:
+                    if z in K:
+                        rel = phi.invert(z)
+                        perm = z
+                    else:
+                        t = K.orbit_rep(alpha, alpha^z)
+                        rel = phi.invert(z)*phi.invert(t)**-1
+                        perm = z*t**-1
+                    for g in K.generator_product(perm, original=True):
+                        rel = rel*phi.invert(g)**-1
+                    new_rels = [rel]
+                elif len(orbit_k) == 1:
+                    # `success` is always true because `strong_gens`
+                    # and `base` are already a verified BSGS. Later
+                    # this could be changed to start with a randomly
+                    # generated (potential) BSGS, and then new elements
+                    # would have to be appended to it when `success`
+                    # is false.
+                    success, new_rels = K_s._verify(K, phi, z, alpha)
+                else:
+                    # K.orbit(alpha) should be a block
+                    # under the action of K_s on K_s.orbit(alpha)
+                    check, block = K_s._block_verify(K, alpha)
+                    if check:
+                        # apply _verify to the action of K_s
+                        # on the block system; for convenience,
+                        # add the blocks as additional points
+                        # that K_s should act on
+                        t = block_homomorphism(K_s, block)
+                        m = t.codomain.degree # number of blocks
+                        d = K_s.degree
+
+                        # conjugating with p will shift
+                        # permutations in t.image() to
+                        # higher numbers, e.g.
+                        # p*(0 1)*p = (m m+1)
+                        p = Permutation()
+                        for i in range(m):
+                            p *= Permutation(i, i+d)
+
+                        t_img = t.images
+                        # combine generators of K_s with their
+                        # action on the block system
+                        images = {g: g*p*t_img[g]*p for g in t_img}
+                        for g in self.strong_gens[:-len(K_s.generators)]:
+                            images[g] = g
+                        K_s_act = PermutationGroup(list(images.values()))
+                        f = GroupHomomorphism(self, K_s_act, images)
+
+                        K_act = PermutationGroup([f(g) for g in K.generators])
+                        success, new_rels = K_s_act._verify(K_act, f.compose(phi), f(z), d)
+
+                for n in new_rels:
+                    if n not in rels:
+                        rels.append(n)
+                K = K_s
+
+        group = FpGroup(F, rels)
+        return simplify_presentation(group)
+
+    def presentation(self, eliminate_gens=True):
+        '''
+        Return an `FpGroup` presentation of the group.
+
+        The algorithm is described in [1], Chapter 6.1.
+
+        '''
+        from sympy.combinatorics.fp_groups import (FpGroup,
+                                            simplify_presentation)
+        from sympy.combinatorics.coset_table import CosetTable
+        from sympy.combinatorics.free_groups import free_group
+        from sympy.combinatorics.homomorphisms import homomorphism
+
+        if self._fp_presentation:
+            return self._fp_presentation
+
+        def _factor_group_by_rels(G, rels):
+            if isinstance(G, FpGroup):
+                rels.extend(G.relators)
+                return FpGroup(G.free_group, list(set(rels)))
+            return FpGroup(G, rels)
+
+        gens = self.generators
+        len_g = len(gens)
+
+        if len_g == 1:
+            order = gens[0].order()
+            # handle the trivial group
+            if order == 1:
+                return free_group([])[0]
+            F, x = free_group('x')
+            return FpGroup(F, [x**order])
+
+        if self.order() > 20:
+            half_gens = self.generators[0:(len_g+1)//2]
+        else:
+            half_gens = []
+        H = PermutationGroup(half_gens)
+        H_p = H.presentation()
+
+        len_h = len(H_p.generators)
+
+        C = self.coset_table(H)
+        n = len(C) # subgroup index
+
+        gen_syms = [('x_%d'%i) for i in range(len(gens))]
+        F = free_group(', '.join(gen_syms))[0]
+
+        # mapping generators of H_p to those of F
+        images = [F.generators[i] for i in range(len_h)]
+        R = homomorphism(H_p, F, H_p.generators, images, check=False)
+
+        # rewrite relators
+        rels = R(H_p.relators)
+        G_p = FpGroup(F, rels)
+
+        # injective homomorphism from G_p into self
+        T = homomorphism(G_p, self, G_p.generators, gens)
+
+        C_p = CosetTable(G_p, [])
+
+        C_p.table = [[None]*(2*len_g) for i in range(n)]
+
+        # initiate the coset transversal
+        transversal = [None]*n
+        transversal[0] = G_p.identity
+
+        # fill in the coset table as much as possible
+        for i in range(2*len_h):
+            C_p.table[0][i] = 0
+
+        gamma = 1
+        for alpha, x in product(range(n), range(2*len_g)):
+            beta = C[alpha][x]
+            if beta == gamma:
+                gen = G_p.generators[x//2]**((-1)**(x % 2))
+                transversal[beta] = transversal[alpha]*gen
+                C_p.table[alpha][x] = beta
+                C_p.table[beta][x + (-1)**(x % 2)] = alpha
+                gamma += 1
+                if gamma == n:
+                    break
+
+        C_p.p = list(range(n))
+        beta = x = 0
+
+        while not C_p.is_complete():
+            # find the first undefined entry
+            while C_p.table[beta][x] == C[beta][x]:
+                x = (x + 1) % (2*len_g)
+                if x == 0:
+                    beta = (beta + 1) % n
+
+            # define a new relator
+            gen = G_p.generators[x//2]**((-1)**(x % 2))
+            new_rel = transversal[beta]*gen*transversal[C[beta][x]]**-1
+            perm = T(new_rel)
+            nxt = G_p.identity
+            for s in H.generator_product(perm, original=True):
+                nxt = nxt*T.invert(s)**-1
+            new_rel = new_rel*nxt
+
+            # continue coset enumeration
+            G_p = _factor_group_by_rels(G_p, [new_rel])
+            C_p.scan_and_fill(0, new_rel)
+            C_p = G_p.coset_enumeration([], strategy="coset_table",
+                                draft=C_p, max_cosets=n, incomplete=True)
+
+        self._fp_presentation = simplify_presentation(G_p)
+        return self._fp_presentation
+
+    def polycyclic_group(self):
+        """
+        Return the PolycyclicGroup instance with below parameters:
+
+        Explanation
+        ===========
+
+        * pc_sequence : Polycyclic sequence is formed by collecting all
+          the missing generators between the adjacent groups in the
+          derived series of given permutation group.
+
+        * pc_series : Polycyclic series is formed by adding all the missing
+          generators of ``der[i+1]`` in ``der[i]``, where ``der`` represents
+          the derived series.
+
+        * relative_order : A list, computed by the ratio of adjacent groups in
+          pc_series.
+
+        """
+        from sympy.combinatorics.pc_groups import PolycyclicGroup
+        if not self.is_polycyclic:
+            raise ValueError("The group must be solvable")
+
+        der = self.derived_series()
+        pc_series = []
+        pc_sequence = []
+        relative_order = []
+        pc_series.append(der[-1])
+        der.reverse()
+
+        for i in range(len(der)-1):
+            H = der[i]
+            for g in der[i+1].generators:
+                if g not in H:
+                    H = PermutationGroup([g] + H.generators)
+                    pc_series.insert(0, H)
+                    pc_sequence.insert(0, g)
+
+                    G1 = pc_series[0].order()
+                    G2 = pc_series[1].order()
+                    relative_order.insert(0, G1 // G2)
+
+        return PolycyclicGroup(pc_sequence, pc_series, relative_order, collector=None)
+
+
+def _orbit(degree, generators, alpha, action='tuples'):
+    r"""Compute the orbit of alpha `\{g(\alpha) | g \in G\}` as a set.
+
+    Explanation
+    ===========
+
+    The time complexity of the algorithm used here is `O(|Orb|*r)` where
+    `|Orb|` is the size of the orbit and ``r`` is the number of generators of
+    the group. For a more detailed analysis, see [1], p.78, [2], pp. 19-21.
+    Here alpha can be a single point, or a list of points.
+
+    If alpha is a single point, the ordinary orbit is computed.
+    if alpha is a list of points, there are three available options:
+
+    'union' - computes the union of the orbits of the points in the list
+    'tuples' - computes the orbit of the list interpreted as an ordered
+    tuple under the group action ( i.e., g((1, 2, 3)) = (g(1), g(2), g(3)) )
+    'sets' - computes the orbit of the list interpreted as a sets
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation, PermutationGroup
+    >>> from sympy.combinatorics.perm_groups import _orbit
+    >>> a = Permutation([1, 2, 0, 4, 5, 6, 3])
+    >>> G = PermutationGroup([a])
+    >>> _orbit(G.degree, G.generators, 0)
+    {0, 1, 2}
+    >>> _orbit(G.degree, G.generators, [0, 4], 'union')
+    {0, 1, 2, 3, 4, 5, 6}
+
+    See Also
+    ========
+
+    orbit, orbit_transversal
+
+    """
+    if not hasattr(alpha, '__getitem__'):
+        alpha = [alpha]
+
+    gens = [x._array_form for x in generators]
+    if len(alpha) == 1 or action == 'union':
+        orb = alpha
+        used = [False]*degree
+        for el in alpha:
+            used[el] = True
+        for b in orb:
+            for gen in gens:
+                temp = gen[b]
+                if used[temp] == False:
+                    orb.append(temp)
+                    used[temp] = True
+        return set(orb)
+    elif action == 'tuples':
+        alpha = tuple(alpha)
+        orb = [alpha]
+        used = {alpha}
+        for b in orb:
+            for gen in gens:
+                temp = tuple([gen[x] for x in b])
+                if temp not in used:
+                    orb.append(temp)
+                    used.add(temp)
+        return set(orb)
+    elif action == 'sets':
+        alpha = frozenset(alpha)
+        orb = [alpha]
+        used = {alpha}
+        for b in orb:
+            for gen in gens:
+                temp = frozenset([gen[x] for x in b])
+                if temp not in used:
+                    orb.append(temp)
+                    used.add(temp)
+        return {tuple(x) for x in orb}
+
+
+def _orbits(degree, generators):
+    """Compute the orbits of G.
+
+    If ``rep=False`` it returns a list of sets else it returns a list of
+    representatives of the orbits
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.perm_groups import _orbits
+    >>> a = Permutation([0, 2, 1])
+    >>> b = Permutation([1, 0, 2])
+    >>> _orbits(a.size, [a, b])
+    [{0, 1, 2}]
+    """
+
+    orbs = []
+    sorted_I = list(range(degree))
+    I = set(sorted_I)
+    while I:
+        i = sorted_I[0]
+        orb = _orbit(degree, generators, i)
+        orbs.append(orb)
+        # remove all indices that are in this orbit
+        I -= orb
+        sorted_I = [i for i in sorted_I if i not in orb]
+    return orbs
+
+
+def _orbit_transversal(degree, generators, alpha, pairs, af=False, slp=False):
+    r"""Computes a transversal for the orbit of ``alpha`` as a set.
+
+    Explanation
+    ===========
+
+    generators   generators of the group ``G``
+
+    For a permutation group ``G``, a transversal for the orbit
+    `Orb = \{g(\alpha) | g \in G\}` is a set
+    `\{g_\beta | g_\beta(\alpha) = \beta\}` for `\beta \in Orb`.
+    Note that there may be more than one possible transversal.
+    If ``pairs`` is set to ``True``, it returns the list of pairs
+    `(\beta, g_\beta)`. For a proof of correctness, see [1], p.79
+
+    if ``af`` is ``True``, the transversal elements are given in
+    array form.
+
+    If `slp` is `True`, a dictionary `{beta: slp_beta}` is returned
+    for `\beta \in Orb` where `slp_beta` is a list of indices of the
+    generators in `generators` s.t. if `slp_beta = [i_1 \dots i_n]`
+    `g_\beta = generators[i_n] \times \dots \times generators[i_1]`.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> from sympy.combinatorics.perm_groups import _orbit_transversal
+    >>> G = DihedralGroup(6)
+    >>> _orbit_transversal(G.degree, G.generators, 0, False)
+    [(5), (0 1 2 3 4 5), (0 5)(1 4)(2 3), (0 2 4)(1 3 5), (5)(0 4)(1 3), (0 3)(1 4)(2 5)]
+    """
+
+    tr = [(alpha, list(range(degree)))]
+    slp_dict = {alpha: []}
+    used = [False]*degree
+    used[alpha] = True
+    gens = [x._array_form for x in generators]
+    for x, px in tr:
+        px_slp = slp_dict[x]
+        for gen in gens:
+            temp = gen[x]
+            if used[temp] == False:
+                slp_dict[temp] = [gens.index(gen)] + px_slp
+                tr.append((temp, _af_rmul(gen, px)))
+                used[temp] = True
+    if pairs:
+        if not af:
+            tr = [(x, _af_new(y)) for x, y in tr]
+        if not slp:
+            return tr
+        return tr, slp_dict
+
+    if af:
+        tr = [y for _, y in tr]
+        if not slp:
+            return tr
+        return tr, slp_dict
+
+    tr = [_af_new(y) for _, y in tr]
+    if not slp:
+        return tr
+    return tr, slp_dict
+
+
+def _stabilizer(degree, generators, alpha):
+    r"""Return the stabilizer subgroup of ``alpha``.
+
+    Explanation
+    ===========
+
+    The stabilizer of `\alpha` is the group `G_\alpha =
+    \{g \in G | g(\alpha) = \alpha\}`.
+    For a proof of correctness, see [1], p.79.
+
+    degree :       degree of G
+    generators :   generators of G
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.perm_groups import _stabilizer
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> G = DihedralGroup(6)
+    >>> _stabilizer(G.degree, G.generators, 5)
+    [(5)(0 4)(1 3), (5)]
+
+    See Also
+    ========
+
+    orbit
+
+    """
+    orb = [alpha]
+    table = {alpha: list(range(degree))}
+    table_inv = {alpha: list(range(degree))}
+    used = [False]*degree
+    used[alpha] = True
+    gens = [x._array_form for x in generators]
+    stab_gens = []
+    for b in orb:
+        for gen in gens:
+            temp = gen[b]
+            if used[temp] is False:
+                gen_temp = _af_rmul(gen, table[b])
+                orb.append(temp)
+                table[temp] = gen_temp
+                table_inv[temp] = _af_invert(gen_temp)
+                used[temp] = True
+            else:
+                schreier_gen = _af_rmuln(table_inv[temp], gen, table[b])
+                if schreier_gen not in stab_gens:
+                    stab_gens.append(schreier_gen)
+    return [_af_new(x) for x in stab_gens]
+
+
+PermGroup = PermutationGroup
+
+
+class SymmetricPermutationGroup(Basic):
+    """
+    The class defining the lazy form of SymmetricGroup.
+
+    deg : int
+
+    """
+    def __new__(cls, deg):
+        deg = _sympify(deg)
+        obj = Basic.__new__(cls, deg)
+        return obj
+
+    def __init__(self, *args, **kwargs):
+        self._deg = self.args[0]
+        self._order = None
+
+    def __contains__(self, i):
+        """Return ``True`` if *i* is contained in SymmetricPermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, SymmetricPermutationGroup
+        >>> G = SymmetricPermutationGroup(4)
+        >>> Permutation(1, 2, 3) in G
+        True
+
+        """
+        if not isinstance(i, Permutation):
+            raise TypeError("A SymmetricPermutationGroup contains only Permutations as "
+                            "elements, not elements of type %s" % type(i))
+        return i.size == self.degree
+
+    def order(self):
+        """
+        Return the order of the SymmetricPermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import SymmetricPermutationGroup
+        >>> G = SymmetricPermutationGroup(4)
+        >>> G.order()
+        24
+        """
+        if self._order is not None:
+            return self._order
+        n = self._deg
+        self._order = factorial(n)
+        return self._order
+
+    @property
+    def degree(self):
+        """
+        Return the degree of the SymmetricPermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import SymmetricPermutationGroup
+        >>> G = SymmetricPermutationGroup(4)
+        >>> G.degree
+        4
+
+        """
+        return self._deg
+
+    @property
+    def identity(self):
+        '''
+        Return the identity element of the SymmetricPermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import SymmetricPermutationGroup
+        >>> G = SymmetricPermutationGroup(4)
+        >>> G.identity()
+        (3)
+
+        '''
+        return _af_new(list(range(self._deg)))
+
+
+class Coset(Basic):
+    """A left coset of a permutation group with respect to an element.
+
+    Parameters
+    ==========
+
+    g : Permutation
+
+    H : PermutationGroup
+
+    dir : "+" or "-", If not specified by default it will be "+"
+        here ``dir`` specified the type of coset "+" represent the
+        right coset and "-" represent the left coset.
+
+    G : PermutationGroup, optional
+        The group which contains *H* as its subgroup and *g* as its
+        element.
+
+        If not specified, it would automatically become a symmetric
+        group ``SymmetricPermutationGroup(g.size)`` and
+        ``SymmetricPermutationGroup(H.degree)`` if ``g.size`` and ``H.degree``
+        are matching.``SymmetricPermutationGroup`` is a lazy form of SymmetricGroup
+        used for representation purpose.
+
+    """
+
+    def __new__(cls, g, H, G=None, dir="+"):
+        g = _sympify(g)
+        if not isinstance(g, Permutation):
+            raise NotImplementedError
+
+        H = _sympify(H)
+        if not isinstance(H, PermutationGroup):
+            raise NotImplementedError
+
+        if G is not None:
+            G = _sympify(G)
+            if not isinstance(G, (PermutationGroup, SymmetricPermutationGroup)):
+                raise NotImplementedError
+            if not H.is_subgroup(G):
+                raise ValueError("{} must be a subgroup of {}.".format(H, G))
+            if g not in G:
+                raise ValueError("{} must be an element of {}.".format(g, G))
+        else:
+            g_size = g.size
+            h_degree = H.degree
+            if g_size != h_degree:
+                raise ValueError(
+                    "The size of the permutation {} and the degree of "
+                    "the permutation group {} should be matching "
+                    .format(g, H))
+            G = SymmetricPermutationGroup(g.size)
+
+        if isinstance(dir, str):
+            dir = Symbol(dir)
+        elif not isinstance(dir, Symbol):
+            raise TypeError("dir must be of type basestring or "
+                    "Symbol, not %s" % type(dir))
+        if str(dir) not in ('+', '-'):
+            raise ValueError("dir must be one of '+' or '-' not %s" % dir)
+        obj = Basic.__new__(cls, g, H, G, dir)
+        return obj
+
+    def __init__(self, *args, **kwargs):
+        self._dir = self.args[3]
+
+    @property
+    def is_left_coset(self):
+        """
+        Check if the coset is left coset that is ``gH``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup, Coset
+        >>> a = Permutation(1, 2)
+        >>> b = Permutation(0, 1)
+        >>> G = PermutationGroup([a, b])
+        >>> cst = Coset(a, G, dir="-")
+        >>> cst.is_left_coset
+        True
+
+        """
+        return str(self._dir) == '-'
+
+    @property
+    def is_right_coset(self):
+        """
+        Check if the coset is right coset that is ``Hg``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation, PermutationGroup, Coset
+        >>> a = Permutation(1, 2)
+        >>> b = Permutation(0, 1)
+        >>> G = PermutationGroup([a, b])
+        >>> cst = Coset(a, G, dir="+")
+        >>> cst.is_right_coset
+        True
+
+        """
+        return str(self._dir) == '+'
+
+    def as_list(self):
+        """
+        Return all the elements of coset in the form of list.
+        """
+        g = self.args[0]
+        H = self.args[1]
+        cst = []
+        if str(self._dir) == '+':
+            for h in H.elements:
+                cst.append(h*g)
+        else:
+            for h in H.elements:
+                cst.append(g*h)
+        return cst
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/permutations.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/permutations.py
new file mode 100644
index 0000000000000000000000000000000000000000..3718467b69cbab2b9b0dd73e8fa160cceb0324bf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/permutations.py
@@ -0,0 +1,3114 @@
+import random
+from collections import defaultdict
+from collections.abc import Iterable
+from functools import reduce
+
+from sympy.core.parameters import global_parameters
+from sympy.core.basic import Atom
+from sympy.core.expr import Expr
+from sympy.core.numbers import int_valued
+from sympy.core.numbers import Integer
+from sympy.core.sympify import _sympify
+from sympy.matrices import zeros
+from sympy.polys.polytools import lcm
+from sympy.printing.repr import srepr
+from sympy.utilities.iterables import (flatten, has_variety, minlex,
+    has_dups, runs, is_sequence)
+from sympy.utilities.misc import as_int
+from mpmath.libmp.libintmath import ifac
+from sympy.multipledispatch import dispatch
+
+def _af_rmul(a, b):
+    """
+    Return the product b*a; input and output are array forms. The ith value
+    is a[b[i]].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+    >>> a, b = [1, 0, 2], [0, 2, 1]
+    >>> _af_rmul(a, b)
+    [1, 2, 0]
+    >>> [a[b[i]] for i in range(3)]
+    [1, 2, 0]
+
+    This handles the operands in reverse order compared to the ``*`` operator:
+
+    >>> a = Permutation(a)
+    >>> b = Permutation(b)
+    >>> list(a*b)
+    [2, 0, 1]
+    >>> [b(a(i)) for i in range(3)]
+    [2, 0, 1]
+
+    See Also
+    ========
+
+    rmul, _af_rmuln
+    """
+    return [a[i] for i in b]
+
+
+def _af_rmuln(*abc):
+    """
+    Given [a, b, c, ...] return the product of ...*c*b*a using array forms.
+    The ith value is a[b[c[i]]].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+    >>> a, b = [1, 0, 2], [0, 2, 1]
+    >>> _af_rmul(a, b)
+    [1, 2, 0]
+    >>> [a[b[i]] for i in range(3)]
+    [1, 2, 0]
+
+    This handles the operands in reverse order compared to the ``*`` operator:
+
+    >>> a = Permutation(a); b = Permutation(b)
+    >>> list(a*b)
+    [2, 0, 1]
+    >>> [b(a(i)) for i in range(3)]
+    [2, 0, 1]
+
+    See Also
+    ========
+
+    rmul, _af_rmul
+    """
+    a = abc
+    m = len(a)
+    if m == 3:
+        p0, p1, p2 = a
+        return [p0[p1[i]] for i in p2]
+    if m == 4:
+        p0, p1, p2, p3 = a
+        return [p0[p1[p2[i]]] for i in p3]
+    if m == 5:
+        p0, p1, p2, p3, p4 = a
+        return [p0[p1[p2[p3[i]]]] for i in p4]
+    if m == 6:
+        p0, p1, p2, p3, p4, p5 = a
+        return [p0[p1[p2[p3[p4[i]]]]] for i in p5]
+    if m == 7:
+        p0, p1, p2, p3, p4, p5, p6 = a
+        return [p0[p1[p2[p3[p4[p5[i]]]]]] for i in p6]
+    if m == 8:
+        p0, p1, p2, p3, p4, p5, p6, p7 = a
+        return [p0[p1[p2[p3[p4[p5[p6[i]]]]]]] for i in p7]
+    if m == 1:
+        return a[0][:]
+    if m == 2:
+        a, b = a
+        return [a[i] for i in b]
+    if m == 0:
+        raise ValueError("String must not be empty")
+    p0 = _af_rmuln(*a[:m//2])
+    p1 = _af_rmuln(*a[m//2:])
+    return [p0[i] for i in p1]
+
+
+def _af_parity(pi):
+    """
+    Computes the parity of a permutation in array form.
+
+    Explanation
+    ===========
+
+    The parity of a permutation reflects the parity of the
+    number of inversions in the permutation, i.e., the
+    number of pairs of x and y such that x > y but p[x] < p[y].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_parity
+    >>> _af_parity([0, 1, 2, 3])
+    0
+    >>> _af_parity([3, 2, 0, 1])
+    1
+
+    See Also
+    ========
+
+    Permutation
+    """
+    n = len(pi)
+    a = [0] * n
+    c = 0
+    for j in range(n):
+        if a[j] == 0:
+            c += 1
+            a[j] = 1
+            i = j
+            while pi[i] != j:
+                i = pi[i]
+                a[i] = 1
+    return (n - c) % 2
+
+
+def _af_invert(a):
+    """
+    Finds the inverse, ~A, of a permutation, A, given in array form.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_invert, _af_rmul
+    >>> A = [1, 2, 0, 3]
+    >>> _af_invert(A)
+    [2, 0, 1, 3]
+    >>> _af_rmul(_, A)
+    [0, 1, 2, 3]
+
+    See Also
+    ========
+
+    Permutation, __invert__
+    """
+    inv_form = [0] * len(a)
+    for i, ai in enumerate(a):
+        inv_form[ai] = i
+    return inv_form
+
+
+def _af_pow(a, n):
+    """
+    Routine for finding powers of a permutation.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.permutations import _af_pow
+    >>> p = Permutation([2, 0, 3, 1])
+    >>> p.order()
+    4
+    >>> _af_pow(p._array_form, 4)
+    [0, 1, 2, 3]
+    """
+    if n == 0:
+        return list(range(len(a)))
+    if n < 0:
+        return _af_pow(_af_invert(a), -n)
+    if n == 1:
+        return a[:]
+    elif n == 2:
+        b = [a[i] for i in a]
+    elif n == 3:
+        b = [a[a[i]] for i in a]
+    elif n == 4:
+        b = [a[a[a[i]]] for i in a]
+    else:
+        # use binary multiplication
+        b = list(range(len(a)))
+        while 1:
+            if n & 1:
+                b = [b[i] for i in a]
+                n -= 1
+                if not n:
+                    break
+            if n % 4 == 0:
+                a = [a[a[a[i]]] for i in a]
+                n = n // 4
+            elif n % 2 == 0:
+                a = [a[i] for i in a]
+                n = n // 2
+    return b
+
+
+def _af_commutes_with(a, b):
+    """
+    Checks if the two permutations with array forms
+    given by ``a`` and ``b`` commute.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import _af_commutes_with
+    >>> _af_commutes_with([1, 2, 0], [0, 2, 1])
+    False
+
+    See Also
+    ========
+
+    Permutation, commutes_with
+    """
+    return not any(a[b[i]] != b[a[i]] for i in range(len(a) - 1))
+
+
+class Cycle(dict):
+    """
+    Wrapper around dict which provides the functionality of a disjoint cycle.
+
+    Explanation
+    ===========
+
+    A cycle shows the rule to use to move subsets of elements to obtain
+    a permutation. The Cycle class is more flexible than Permutation in
+    that 1) all elements need not be present in order to investigate how
+    multiple cycles act in sequence and 2) it can contain singletons:
+
+    >>> from sympy.combinatorics.permutations import Perm, Cycle
+
+    A Cycle will automatically parse a cycle given as a tuple on the rhs:
+
+    >>> Cycle(1, 2)(2, 3)
+    (1 3 2)
+
+    The identity cycle, Cycle(), can be used to start a product:
+
+    >>> Cycle()(1, 2)(2, 3)
+    (1 3 2)
+
+    The array form of a Cycle can be obtained by calling the list
+    method (or passing it to the list function) and all elements from
+    0 will be shown:
+
+    >>> a = Cycle(1, 2)
+    >>> a.list()
+    [0, 2, 1]
+    >>> list(a)
+    [0, 2, 1]
+
+    If a larger (or smaller) range is desired use the list method and
+    provide the desired size -- but the Cycle cannot be truncated to
+    a size smaller than the largest element that is out of place:
+
+    >>> b = Cycle(2, 4)(1, 2)(3, 1, 4)(1, 3)
+    >>> b.list()
+    [0, 2, 1, 3, 4]
+    >>> b.list(b.size + 1)
+    [0, 2, 1, 3, 4, 5]
+    >>> b.list(-1)
+    [0, 2, 1]
+
+    Singletons are not shown when printing with one exception: the largest
+    element is always shown -- as a singleton if necessary:
+
+    >>> Cycle(1, 4, 10)(4, 5)
+    (1 5 4 10)
+    >>> Cycle(1, 2)(4)(5)(10)
+    (1 2)(10)
+
+    The array form can be used to instantiate a Permutation so other
+    properties of the permutation can be investigated:
+
+    >>> Perm(Cycle(1, 2)(3, 4).list()).transpositions()
+    [(1, 2), (3, 4)]
+
+    Notes
+    =====
+
+    The underlying structure of the Cycle is a dictionary and although
+    the __iter__ method has been redefined to give the array form of the
+    cycle, the underlying dictionary items are still available with the
+    such methods as items():
+
+    >>> list(Cycle(1, 2).items())
+    [(1, 2), (2, 1)]
+
+    See Also
+    ========
+
+    Permutation
+    """
+    def __missing__(self, arg):
+        """Enter arg into dictionary and return arg."""
+        return as_int(arg)
+
+    def __iter__(self):
+        yield from self.list()
+
+    def __call__(self, *other):
+        """Return product of cycles processed from R to L.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)(2, 3)
+        (1 3 2)
+
+        An instance of a Cycle will automatically parse list-like
+        objects and Permutations that are on the right. It is more
+        flexible than the Permutation in that all elements need not
+        be present:
+
+        >>> a = Cycle(1, 2)
+        >>> a(2, 3)
+        (1 3 2)
+        >>> a(2, 3)(4, 5)
+        (1 3 2)(4 5)
+
+        """
+        rv = Cycle(*other)
+        for k, v in zip(list(self.keys()), [rv[self[k]] for k in self.keys()]):
+            rv[k] = v
+        return rv
+
+    def list(self, size=None):
+        """Return the cycles as an explicit list starting from 0 up
+        to the greater of the largest value in the cycles and size.
+
+        Truncation of trailing unmoved items will occur when size
+        is less than the maximum element in the cycle; if this is
+        desired, setting ``size=-1`` will guarantee such trimming.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> p = Cycle(2, 3)(4, 5)
+        >>> p.list()
+        [0, 1, 3, 2, 5, 4]
+        >>> p.list(10)
+        [0, 1, 3, 2, 5, 4, 6, 7, 8, 9]
+
+        Passing a length too small will trim trailing, unchanged elements
+        in the permutation:
+
+        >>> Cycle(2, 4)(1, 2, 4).list(-1)
+        [0, 2, 1]
+        """
+        if not self and size is None:
+            raise ValueError('must give size for empty Cycle')
+        if size is not None:
+            big = max([i for i in self.keys() if self[i] != i] + [0])
+            size = max(size, big + 1)
+        else:
+            size = self.size
+        return [self[i] for i in range(size)]
+
+    def __repr__(self):
+        """We want it to print as a Cycle, not as a dict.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)
+        (1 2)
+        >>> print(_)
+        (1 2)
+        >>> list(Cycle(1, 2).items())
+        [(1, 2), (2, 1)]
+        """
+        if not self:
+            return 'Cycle()'
+        cycles = Permutation(self).cyclic_form
+        s = ''.join(str(tuple(c)) for c in cycles)
+        big = self.size - 1
+        if not any(i == big for c in cycles for i in c):
+            s += '(%s)' % big
+        return 'Cycle%s' % s
+
+    def __str__(self):
+        """We want it to be printed in a Cycle notation with no
+        comma in-between.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2)
+        (1 2)
+        >>> Cycle(1, 2, 4)(5, 6)
+        (1 2 4)(5 6)
+        """
+        if not self:
+            return '()'
+        cycles = Permutation(self).cyclic_form
+        s = ''.join(str(tuple(c)) for c in cycles)
+        big = self.size - 1
+        if not any(i == big for c in cycles for i in c):
+            s += '(%s)' % big
+        s = s.replace(',', '')
+        return s
+
+    def __init__(self, *args):
+        """Load up a Cycle instance with the values for the cycle.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Cycle
+        >>> Cycle(1, 2, 6)
+        (1 2 6)
+        """
+
+        if not args:
+            return
+        if len(args) == 1:
+            if isinstance(args[0], Permutation):
+                for c in args[0].cyclic_form:
+                    self.update(self(*c))
+                return
+            elif isinstance(args[0], Cycle):
+                for k, v in args[0].items():
+                    self[k] = v
+                return
+        args = [as_int(a) for a in args]
+        if any(i < 0 for i in args):
+            raise ValueError('negative integers are not allowed in a cycle.')
+        if has_dups(args):
+            raise ValueError('All elements must be unique in a cycle.')
+        for i in range(-len(args), 0):
+            self[args[i]] = args[i + 1]
+
+    @property
+    def size(self):
+        if not self:
+            return 0
+        return max(self.keys()) + 1
+
+    def copy(self):
+        return Cycle(self)
+
+
+class Permutation(Atom):
+    r"""
+    A permutation, alternatively known as an 'arrangement number' or 'ordering'
+    is an arrangement of the elements of an ordered list into a one-to-one
+    mapping with itself. The permutation of a given arrangement is given by
+    indicating the positions of the elements after re-arrangement [2]_. For
+    example, if one started with elements ``[x, y, a, b]`` (in that order) and
+    they were reordered as ``[x, y, b, a]`` then the permutation would be
+    ``[0, 1, 3, 2]``. Notice that (in SymPy) the first element is always referred
+    to as 0 and the permutation uses the indices of the elements in the
+    original ordering, not the elements ``(a, b, ...)`` themselves.
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy import init_printing
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+    Permutations Notation
+    =====================
+
+    Permutations are commonly represented in disjoint cycle or array forms.
+
+    Array Notation and 2-line Form
+    ------------------------------------
+
+    In the 2-line form, the elements and their final positions are shown
+    as a matrix with 2 rows:
+
+    [0    1    2     ... n-1]
+    [p(0) p(1) p(2)  ... p(n-1)]
+
+    Since the first line is always ``range(n)``, where n is the size of p,
+    it is sufficient to represent the permutation by the second line,
+    referred to as the "array form" of the permutation. This is entered
+    in brackets as the argument to the Permutation class:
+
+    >>> p = Permutation([0, 2, 1]); p
+    Permutation([0, 2, 1])
+
+    Given i in range(p.size), the permutation maps i to i^p
+
+    >>> [i^p for i in range(p.size)]
+    [0, 2, 1]
+
+    The composite of two permutations p*q means first apply p, then q, so
+    i^(p*q) = (i^p)^q which is i^p^q according to Python precedence rules:
+
+    >>> q = Permutation([2, 1, 0])
+    >>> [i^p^q for i in range(3)]
+    [2, 0, 1]
+    >>> [i^(p*q) for i in range(3)]
+    [2, 0, 1]
+
+    One can use also the notation p(i) = i^p, but then the composition
+    rule is (p*q)(i) = q(p(i)), not p(q(i)):
+
+    >>> [(p*q)(i) for i in range(p.size)]
+    [2, 0, 1]
+    >>> [q(p(i)) for i in range(p.size)]
+    [2, 0, 1]
+    >>> [p(q(i)) for i in range(p.size)]
+    [1, 2, 0]
+
+    Disjoint Cycle Notation
+    -----------------------
+
+    In disjoint cycle notation, only the elements that have shifted are
+    indicated.
+
+    For example, [1, 3, 2, 0] can be represented as (0, 1, 3)(2).
+    This can be understood from the 2 line format of the given permutation.
+    In the 2-line form,
+    [0    1    2   3]
+    [1    3    2   0]
+
+    The element in the 0th position is 1, so 0 -> 1. The element in the 1st
+    position is three, so 1 -> 3. And the element in the third position is again
+    0, so 3 -> 0. Thus, 0 -> 1 -> 3 -> 0, and 2 -> 2. Thus, this can be represented
+    as 2 cycles: (0, 1, 3)(2).
+    In common notation, singular cycles are not explicitly written as they can be
+    inferred implicitly.
+
+    Only the relative ordering of elements in a cycle matter:
+
+    >>> Permutation(1,2,3) == Permutation(2,3,1) == Permutation(3,1,2)
+    True
+
+    The disjoint cycle notation is convenient when representing
+    permutations that have several cycles in them:
+
+    >>> Permutation(1, 2)(3, 5) == Permutation([[1, 2], [3, 5]])
+    True
+
+    It also provides some economy in entry when computing products of
+    permutations that are written in disjoint cycle notation:
+
+    >>> Permutation(1, 2)(1, 3)(2, 3)
+    Permutation([0, 3, 2, 1])
+    >>> _ == Permutation([[1, 2]])*Permutation([[1, 3]])*Permutation([[2, 3]])
+    True
+
+        Caution: when the cycles have common elements between them then the order
+        in which the permutations are applied matters. This module applies
+        the permutations from *left to right*.
+
+        >>> Permutation(1, 2)(2, 3) == Permutation([(1, 2), (2, 3)])
+        True
+        >>> Permutation(1, 2)(2, 3).list()
+        [0, 3, 1, 2]
+
+        In the above case, (1,2) is computed before (2,3).
+        As 0 -> 0, 0 -> 0, element in position 0 is 0.
+        As 1 -> 2, 2 -> 3, element in position 1 is 3.
+        As 2 -> 1, 1 -> 1, element in position 2 is 1.
+        As 3 -> 3, 3 -> 2, element in position 3 is 2.
+
+        If the first and second elements had been
+        swapped first, followed by the swapping of the second
+        and third, the result would have been [0, 2, 3, 1].
+        If, you want to apply the cycles in the conventional
+        right to left order, call the function with arguments in reverse order
+        as demonstrated below:
+
+        >>> Permutation([(1, 2), (2, 3)][::-1]).list()
+        [0, 2, 3, 1]
+
+    Entering a singleton in a permutation is a way to indicate the size of the
+    permutation. The ``size`` keyword can also be used.
+
+    Array-form entry:
+
+    >>> Permutation([[1, 2], [9]])
+    Permutation([0, 2, 1], size=10)
+    >>> Permutation([[1, 2]], size=10)
+    Permutation([0, 2, 1], size=10)
+
+    Cyclic-form entry:
+
+    >>> Permutation(1, 2, size=10)
+    Permutation([0, 2, 1], size=10)
+    >>> Permutation(9)(1, 2)
+    Permutation([0, 2, 1], size=10)
+
+    Caution: no singleton containing an element larger than the largest
+    in any previous cycle can be entered. This is an important difference
+    in how Permutation and Cycle handle the ``__call__`` syntax. A singleton
+    argument at the start of a Permutation performs instantiation of the
+    Permutation and is permitted:
+
+    >>> Permutation(5)
+    Permutation([], size=6)
+
+    A singleton entered after instantiation is a call to the permutation
+    -- a function call -- and if the argument is out of range it will
+    trigger an error. For this reason, it is better to start the cycle
+    with the singleton:
+
+    The following fails because there is no element 3:
+
+    >>> Permutation(1, 2)(3)
+    Traceback (most recent call last):
+    ...
+    IndexError: list index out of range
+
+    This is ok: only the call to an out of range singleton is prohibited;
+    otherwise the permutation autosizes:
+
+    >>> Permutation(3)(1, 2)
+    Permutation([0, 2, 1, 3])
+    >>> Permutation(1, 2)(3, 4) == Permutation(3, 4)(1, 2)
+    True
+
+
+    Equality testing
+    ----------------
+
+    The array forms must be the same in order for permutations to be equal:
+
+    >>> Permutation([1, 0, 2, 3]) == Permutation([1, 0])
+    False
+
+
+    Identity Permutation
+    --------------------
+
+    The identity permutation is a permutation in which no element is out of
+    place. It can be entered in a variety of ways. All the following create
+    an identity permutation of size 4:
+
+    >>> I = Permutation([0, 1, 2, 3])
+    >>> all(p == I for p in [
+    ... Permutation(3),
+    ... Permutation(range(4)),
+    ... Permutation([], size=4),
+    ... Permutation(size=4)])
+    True
+
+    Watch out for entering the range *inside* a set of brackets (which is
+    cycle notation):
+
+    >>> I == Permutation([range(4)])
+    False
+
+
+    Permutation Printing
+    ====================
+
+    There are a few things to note about how Permutations are printed.
+
+    .. deprecated:: 1.6
+
+       Configuring Permutation printing by setting
+       ``Permutation.print_cyclic`` is deprecated. Users should use the
+       ``perm_cyclic`` flag to the printers, as described below.
+
+    1) If you prefer one form (array or cycle) over another, you can set
+    ``init_printing`` with the ``perm_cyclic`` flag.
+
+    >>> from sympy import init_printing
+    >>> p = Permutation(1, 2)(4, 5)(3, 4)
+    >>> p
+    Permutation([0, 2, 1, 4, 5, 3])
+
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> p
+    (1 2)(3 4 5)
+
+    2) Regardless of the setting, a list of elements in the array for cyclic
+    form can be obtained and either of those can be copied and supplied as
+    the argument to Permutation:
+
+    >>> p.array_form
+    [0, 2, 1, 4, 5, 3]
+    >>> p.cyclic_form
+    [[1, 2], [3, 4, 5]]
+    >>> Permutation(_) == p
+    True
+
+    3) Printing is economical in that as little as possible is printed while
+    retaining all information about the size of the permutation:
+
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+    >>> Permutation([1, 0, 2, 3])
+    Permutation([1, 0, 2, 3])
+    >>> Permutation([1, 0, 2, 3], size=20)
+    Permutation([1, 0], size=20)
+    >>> Permutation([1, 0, 2, 4, 3, 5, 6], size=20)
+    Permutation([1, 0, 2, 4, 3], size=20)
+
+    >>> p = Permutation([1, 0, 2, 3])
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> p
+    (3)(0 1)
+    >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+    The 2 was not printed but it is still there as can be seen with the
+    array_form and size methods:
+
+    >>> p.array_form
+    [1, 0, 2, 3]
+    >>> p.size
+    4
+
+    Short introduction to other methods
+    ===================================
+
+    The permutation can act as a bijective function, telling what element is
+    located at a given position
+
+    >>> q = Permutation([5, 2, 3, 4, 1, 0])
+    >>> q.array_form[1] # the hard way
+    2
+    >>> q(1) # the easy way
+    2
+    >>> {i: q(i) for i in range(q.size)} # showing the bijection
+    {0: 5, 1: 2, 2: 3, 3: 4, 4: 1, 5: 0}
+
+    The full cyclic form (including singletons) can be obtained:
+
+    >>> p.full_cyclic_form
+    [[0, 1], [2], [3]]
+
+    Any permutation can be factored into transpositions of pairs of elements:
+
+    >>> Permutation([[1, 2], [3, 4, 5]]).transpositions()
+    [(1, 2), (3, 5), (3, 4)]
+    >>> Permutation.rmul(*[Permutation([ti], size=6) for ti in _]).cyclic_form
+    [[1, 2], [3, 4, 5]]
+
+    The number of permutations on a set of n elements is given by n! and is
+    called the cardinality.
+
+    >>> p.size
+    4
+    >>> p.cardinality
+    24
+
+    A given permutation has a rank among all the possible permutations of the
+    same elements, but what that rank is depends on how the permutations are
+    enumerated. (There are a number of different methods of doing so.) The
+    lexicographic rank is given by the rank method and this rank is used to
+    increment a permutation with addition/subtraction:
+
+    >>> p.rank()
+    6
+    >>> p + 1
+    Permutation([1, 0, 3, 2])
+    >>> p.next_lex()
+    Permutation([1, 0, 3, 2])
+    >>> _.rank()
+    7
+    >>> p.unrank_lex(p.size, rank=7)
+    Permutation([1, 0, 3, 2])
+
+    The product of two permutations p and q is defined as their composition as
+    functions, (p*q)(i) = q(p(i)) [6]_.
+
+    >>> p = Permutation([1, 0, 2, 3])
+    >>> q = Permutation([2, 3, 1, 0])
+    >>> list(q*p)
+    [2, 3, 0, 1]
+    >>> list(p*q)
+    [3, 2, 1, 0]
+    >>> [q(p(i)) for i in range(p.size)]
+    [3, 2, 1, 0]
+
+    The permutation can be 'applied' to any list-like object, not only
+    Permutations:
+
+    >>> p(['zero', 'one', 'four', 'two'])
+    ['one', 'zero', 'four', 'two']
+    >>> p('zo42')
+    ['o', 'z', '4', '2']
+
+    If you have a list of arbitrary elements, the corresponding permutation
+    can be found with the from_sequence method:
+
+    >>> Permutation.from_sequence('SymPy')
+    Permutation([1, 3, 2, 0, 4])
+
+    Checking if a Permutation is contained in a Group
+    =================================================
+
+    Generally if you have a group of permutations G on n symbols, and
+    you're checking if a permutation on less than n symbols is part
+    of that group, the check will fail.
+
+    Here is an example for n=5 and we check if the cycle
+    (1,2,3) is in G:
+
+    >>> from sympy import init_printing
+    >>> init_printing(perm_cyclic=True, pretty_print=False)
+    >>> from sympy.combinatorics import Cycle, Permutation
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> G = PermutationGroup(Cycle(2, 3)(4, 5), Cycle(1, 2, 3, 4, 5))
+    >>> p1 = Permutation(Cycle(2, 5, 3))
+    >>> p2 = Permutation(Cycle(1, 2, 3))
+    >>> a1 = Permutation(Cycle(1, 2, 3).list(6))
+    >>> a2 = Permutation(Cycle(1, 2, 3)(5))
+    >>> a3 = Permutation(Cycle(1, 2, 3),size=6)
+    >>> for p in [p1,p2,a1,a2,a3]: p, G.contains(p)
+    ((2 5 3), True)
+    ((1 2 3), False)
+    ((5)(1 2 3), True)
+    ((5)(1 2 3), True)
+    ((5)(1 2 3), True)
+
+    The check for p2 above will fail.
+
+    Checking if p1 is in G works because SymPy knows
+    G is a group on 5 symbols, and p1 is also on 5 symbols
+    (its largest element is 5).
+
+    For ``a1``, the ``.list(6)`` call will extend the permutation to 5
+    symbols, so the test will work as well. In the case of ``a2`` the
+    permutation is being extended to 5 symbols by using a singleton,
+    and in the case of ``a3`` it's extended through the constructor
+    argument ``size=6``.
+
+    There is another way to do this, which is to tell the ``contains``
+    method that the number of symbols the group is on does not need to
+    match perfectly the number of symbols for the permutation:
+
+    >>> G.contains(p2,strict=False)
+    True
+
+    This can be via the ``strict`` argument to the ``contains`` method,
+    and SymPy will try to extend the permutation on its own and then
+    perform the containment check.
+
+    See Also
+    ========
+
+    Cycle
+
+    References
+    ==========
+
+    .. [1] Skiena, S. 'Permutations.' 1.1 in Implementing Discrete Mathematics
+           Combinatorics and Graph Theory with Mathematica.  Reading, MA:
+           Addison-Wesley, pp. 3-16, 1990.
+
+    .. [2] Knuth, D. E. The Art of Computer Programming, Vol. 4: Combinatorial
+           Algorithms, 1st ed. Reading, MA: Addison-Wesley, 2011.
+
+    .. [3] Wendy Myrvold and Frank Ruskey. 2001. Ranking and unranking
+           permutations in linear time. Inf. Process. Lett. 79, 6 (September 2001),
+           281-284. DOI=10.1016/S0020-0190(01)00141-7
+
+    .. [4] D. L. Kreher, D. R. Stinson 'Combinatorial Algorithms'
+           CRC Press, 1999
+
+    .. [5] Graham, R. L.; Knuth, D. E.; and Patashnik, O.
+           Concrete Mathematics: A Foundation for Computer Science, 2nd ed.
+           Reading, MA: Addison-Wesley, 1994.
+
+    .. [6] https://en.wikipedia.org/w/index.php?oldid=499948155#Product_and_inverse
+
+    .. [7] https://en.wikipedia.org/wiki/Lehmer_code
+
+    """
+
+    is_Permutation = True
+
+    _array_form = None
+    _cyclic_form = None
+    _cycle_structure = None
+    _size = None
+    _rank = None
+
+    def __new__(cls, *args, size=None, **kwargs):
+        """
+        Constructor for the Permutation object from a list or a
+        list of lists in which all elements of the permutation may
+        appear only once.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+
+        Permutations entered in array-form are left unaltered:
+
+        >>> Permutation([0, 2, 1])
+        Permutation([0, 2, 1])
+
+        Permutations entered in cyclic form are converted to array form;
+        singletons need not be entered, but can be entered to indicate the
+        largest element:
+
+        >>> Permutation([[4, 5, 6], [0, 1]])
+        Permutation([1, 0, 2, 3, 5, 6, 4])
+        >>> Permutation([[4, 5, 6], [0, 1], [19]])
+        Permutation([1, 0, 2, 3, 5, 6, 4], size=20)
+
+        All manipulation of permutations assumes that the smallest element
+        is 0 (in keeping with 0-based indexing in Python) so if the 0 is
+        missing when entering a permutation in array form, an error will be
+        raised:
+
+        >>> Permutation([2, 1])
+        Traceback (most recent call last):
+        ...
+        ValueError: Integers 0 through 2 must be present.
+
+        If a permutation is entered in cyclic form, it can be entered without
+        singletons and the ``size`` specified so those values can be filled
+        in, otherwise the array form will only extend to the maximum value
+        in the cycles:
+
+        >>> Permutation([[1, 4], [3, 5, 2]], size=10)
+        Permutation([0, 4, 3, 5, 1, 2], size=10)
+        >>> _.array_form
+        [0, 4, 3, 5, 1, 2, 6, 7, 8, 9]
+        """
+        if size is not None:
+            size = int(size)
+
+        #a) ()
+        #b) (1) = identity
+        #c) (1, 2) = cycle
+        #d) ([1, 2, 3]) = array form
+        #e) ([[1, 2]]) = cyclic form
+        #f) (Cycle) = conversion to permutation
+        #g) (Permutation) = adjust size or return copy
+        ok = True
+        if not args:  # a
+            return cls._af_new(list(range(size or 0)))
+        elif len(args) > 1:  # c
+            return cls._af_new(Cycle(*args).list(size))
+        if len(args) == 1:
+            a = args[0]
+            if isinstance(a, cls):  # g
+                if size is None or size == a.size:
+                    return a
+                return cls(a.array_form, size=size)
+            if isinstance(a, Cycle):  # f
+                return cls._af_new(a.list(size))
+            if not is_sequence(a):  # b
+                if size is not None and a + 1 > size:
+                    raise ValueError('size is too small when max is %s' % a)
+                return cls._af_new(list(range(a + 1)))
+            if has_variety(is_sequence(ai) for ai in a):
+                ok = False
+        else:
+            ok = False
+        if not ok:
+            raise ValueError("Permutation argument must be a list of ints, "
+                             "a list of lists, Permutation or Cycle.")
+
+        # safe to assume args are valid; this also makes a copy
+        # of the args
+        args = list(args[0])
+
+        is_cycle = args and is_sequence(args[0])
+        if is_cycle:  # e
+            args = [[int(i) for i in c] for c in args]
+        else:  # d
+            args = [int(i) for i in args]
+
+        # if there are n elements present, 0, 1, ..., n-1 should be present
+        # unless a cycle notation has been provided. A 0 will be added
+        # for convenience in case one wants to enter permutations where
+        # counting starts from 1.
+
+        temp = flatten(args)
+        if has_dups(temp) and not is_cycle:
+            raise ValueError('there were repeated elements.')
+        temp = set(temp)
+
+        if not is_cycle:
+            if temp != set(range(len(temp))):
+                raise ValueError('Integers 0 through %s must be present.' %
+                max(temp))
+            if size is not None and temp and max(temp) + 1 > size:
+                raise ValueError('max element should not exceed %s' % (size - 1))
+
+        if is_cycle:
+            # it's not necessarily canonical so we won't store
+            # it -- use the array form instead
+            c = Cycle()
+            for ci in args:
+                c = c(*ci)
+            aform = c.list()
+        else:
+            aform = list(args)
+        if size and size > len(aform):
+            # don't allow for truncation of permutation which
+            # might split a cycle and lead to an invalid aform
+            # but do allow the permutation size to be increased
+            aform.extend(list(range(len(aform), size)))
+
+        return cls._af_new(aform)
+
+    @classmethod
+    def _af_new(cls, perm):
+        """A method to produce a Permutation object from a list;
+        the list is bound to the _array_form attribute, so it must
+        not be modified; this method is meant for internal use only;
+        the list ``a`` is supposed to be generated as a temporary value
+        in a method, so p = Perm._af_new(a) is the only object
+        to hold a reference to ``a``::
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.permutations import Perm
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> a = [2, 1, 3, 0]
+        >>> p = Perm._af_new(a)
+        >>> p
+        Permutation([2, 1, 3, 0])
+
+        """
+        p = super().__new__(cls)
+        p._array_form = perm
+        p._size = len(perm)
+        return p
+
+    def copy(self):
+        return self.__class__(self.array_form)
+
+    def __getnewargs__(self):
+        return (self.array_form,)
+
+    def _hashable_content(self):
+        # the array_form (a list) is the Permutation arg, so we need to
+        # return a tuple, instead
+        return tuple(self.array_form)
+
+    @property
+    def array_form(self):
+        """
+        Return a copy of the attribute _array_form
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> p.array_form
+        [2, 3, 0, 1]
+        >>> Permutation([[2, 0, 3, 1]]).array_form
+        [3, 2, 0, 1]
+        >>> Permutation([2, 0, 3, 1]).array_form
+        [2, 0, 3, 1]
+        >>> Permutation([[1, 2], [4, 5]]).array_form
+        [0, 2, 1, 3, 5, 4]
+        """
+        return self._array_form[:]
+
+    def list(self, size=None):
+        """Return the permutation as an explicit list, possibly
+        trimming unmoved elements if size is less than the maximum
+        element in the permutation; if this is desired, setting
+        ``size=-1`` will guarantee such trimming.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(2, 3)(4, 5)
+        >>> p.list()
+        [0, 1, 3, 2, 5, 4]
+        >>> p.list(10)
+        [0, 1, 3, 2, 5, 4, 6, 7, 8, 9]
+
+        Passing a length too small will trim trailing, unchanged elements
+        in the permutation:
+
+        >>> Permutation(2, 4)(1, 2, 4).list(-1)
+        [0, 2, 1]
+        >>> Permutation(3).list(-1)
+        []
+        """
+        if not self and size is None:
+            raise ValueError('must give size for empty Cycle')
+        rv = self.array_form
+        if size is not None:
+            if size > self.size:
+                rv.extend(list(range(self.size, size)))
+            else:
+                # find first value from rhs where rv[i] != i
+                i = self.size - 1
+                while rv:
+                    if rv[-1] != i:
+                        break
+                    rv.pop()
+                    i -= 1
+        return rv
+
+    @property
+    def cyclic_form(self):
+        """
+        This is used to convert to the cyclic notation
+        from the canonical notation. Singletons are omitted.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2])
+        >>> p.cyclic_form
+        [[1, 3, 2]]
+        >>> Permutation([1, 0, 2, 4, 3, 5]).cyclic_form
+        [[0, 1], [3, 4]]
+
+        See Also
+        ========
+
+        array_form, full_cyclic_form
+        """
+        if self._cyclic_form is not None:
+            return list(self._cyclic_form)
+        array_form = self.array_form
+        unchecked = [True] * len(array_form)
+        cyclic_form = []
+        for i in range(len(array_form)):
+            if unchecked[i]:
+                cycle = []
+                cycle.append(i)
+                unchecked[i] = False
+                j = i
+                while unchecked[array_form[j]]:
+                    j = array_form[j]
+                    cycle.append(j)
+                    unchecked[j] = False
+                if len(cycle) > 1:
+                    cyclic_form.append(cycle)
+                    assert cycle == list(minlex(cycle))
+        cyclic_form.sort()
+        self._cyclic_form = cyclic_form.copy()
+        return cyclic_form
+
+    @property
+    def full_cyclic_form(self):
+        """Return permutation in cyclic form including singletons.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 2, 1]).full_cyclic_form
+        [[0], [1, 2]]
+        """
+        need = set(range(self.size)) - set(flatten(self.cyclic_form))
+        rv = self.cyclic_form + [[i] for i in need]
+        rv.sort()
+        return rv
+
+    @property
+    def size(self):
+        """
+        Returns the number of elements in the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([[3, 2], [0, 1]]).size
+        4
+
+        See Also
+        ========
+
+        cardinality, length, order, rank
+        """
+        return self._size
+
+    def support(self):
+        """Return the elements in permutation, P, for which P[i] != i.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[3, 2], [0, 1], [4]])
+        >>> p.array_form
+        [1, 0, 3, 2, 4]
+        >>> p.support()
+        [0, 1, 2, 3]
+        """
+        a = self.array_form
+        return [i for i, e in enumerate(a) if e != i]
+
+    def __add__(self, other):
+        """Return permutation that is other higher in rank than self.
+
+        The rank is the lexicographical rank, with the identity permutation
+        having rank of 0.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> I = Permutation([0, 1, 2, 3])
+        >>> a = Permutation([2, 1, 3, 0])
+        >>> I + a.rank() == a
+        True
+
+        See Also
+        ========
+
+        __sub__, inversion_vector
+
+        """
+        rank = (self.rank() + other) % self.cardinality
+        rv = self.unrank_lex(self.size, rank)
+        rv._rank = rank
+        return rv
+
+    def __sub__(self, other):
+        """Return the permutation that is other lower in rank than self.
+
+        See Also
+        ========
+
+        __add__
+        """
+        return self.__add__(-other)
+
+    @staticmethod
+    def rmul(*args):
+        """
+        Return product of Permutations [a, b, c, ...] as the Permutation whose
+        ith value is a(b(c(i))).
+
+        a, b, c, ... can be Permutation objects or tuples.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        >>> a, b = [1, 0, 2], [0, 2, 1]
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(Permutation.rmul(a, b))
+        [1, 2, 0]
+        >>> [a(b(i)) for i in range(3)]
+        [1, 2, 0]
+
+        This handles the operands in reverse order compared to the ``*`` operator:
+
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(a*b)
+        [2, 0, 1]
+        >>> [b(a(i)) for i in range(3)]
+        [2, 0, 1]
+
+        Notes
+        =====
+
+        All items in the sequence will be parsed by Permutation as
+        necessary as long as the first item is a Permutation:
+
+        >>> Permutation.rmul(a, [0, 2, 1]) == Permutation.rmul(a, b)
+        True
+
+        The reverse order of arguments will raise a TypeError.
+
+        """
+        rv = args[0]
+        for i in range(1, len(args)):
+            rv = args[i]*rv
+        return rv
+
+    @classmethod
+    def rmul_with_af(cls, *args):
+        """
+        same as rmul, but the elements of args are Permutation objects
+        which have _array_form
+        """
+        a = [x._array_form for x in args]
+        rv = cls._af_new(_af_rmuln(*a))
+        return rv
+
+    def mul_inv(self, other):
+        """
+        other*~self, self and other have _array_form
+        """
+        a = _af_invert(self._array_form)
+        b = other._array_form
+        return self._af_new(_af_rmul(a, b))
+
+    def __rmul__(self, other):
+        """This is needed to coerce other to Permutation in rmul."""
+        cls = type(self)
+        return cls(other)*self
+
+    def __mul__(self, other):
+        """
+        Return the product a*b as a Permutation; the ith value is b(a(i)).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.permutations import _af_rmul, Permutation
+
+        >>> a, b = [1, 0, 2], [0, 2, 1]
+        >>> a = Permutation(a); b = Permutation(b)
+        >>> list(a*b)
+        [2, 0, 1]
+        >>> [b(a(i)) for i in range(3)]
+        [2, 0, 1]
+
+        This handles operands in reverse order compared to _af_rmul and rmul:
+
+        >>> al = list(a); bl = list(b)
+        >>> _af_rmul(al, bl)
+        [1, 2, 0]
+        >>> [al[bl[i]] for i in range(3)]
+        [1, 2, 0]
+
+        It is acceptable for the arrays to have different lengths; the shorter
+        one will be padded to match the longer one:
+
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> b*Permutation([1, 0])
+        Permutation([1, 2, 0])
+        >>> Permutation([1, 0])*b
+        Permutation([2, 0, 1])
+
+        It is also acceptable to allow coercion to handle conversion of a
+        single list to the left of a Permutation:
+
+        >>> [0, 1]*a # no change: 2-element identity
+        Permutation([1, 0, 2])
+        >>> [[0, 1]]*a # exchange first two elements
+        Permutation([0, 1, 2])
+
+        You cannot use more than 1 cycle notation in a product of cycles
+        since coercion can only handle one argument to the left. To handle
+        multiple cycles it is convenient to use Cycle instead of Permutation:
+
+        >>> [[1, 2]]*[[2, 3]]*Permutation([]) # doctest: +SKIP
+        >>> from sympy.combinatorics.permutations import Cycle
+        >>> Cycle(1, 2)(2, 3)
+        (1 3 2)
+
+        """
+        from sympy.combinatorics.perm_groups import PermutationGroup, Coset
+        if isinstance(other, PermutationGroup):
+            return Coset(self, other, dir='-')
+        a = self.array_form
+        # __rmul__ makes sure the other is a Permutation
+        b = other.array_form
+        if not b:
+            perm = a
+        else:
+            b.extend(list(range(len(b), len(a))))
+            perm = [b[i] for i in a] + b[len(a):]
+        return self._af_new(perm)
+
+    def commutes_with(self, other):
+        """
+        Checks if the elements are commuting.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> a = Permutation([1, 4, 3, 0, 2, 5])
+        >>> b = Permutation([0, 1, 2, 3, 4, 5])
+        >>> a.commutes_with(b)
+        True
+        >>> b = Permutation([2, 3, 5, 4, 1, 0])
+        >>> a.commutes_with(b)
+        False
+        """
+        a = self.array_form
+        b = other.array_form
+        return _af_commutes_with(a, b)
+
+    def __pow__(self, n):
+        """
+        Routine for finding powers of a permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([2, 0, 3, 1])
+        >>> p.order()
+        4
+        >>> p**4
+        Permutation([0, 1, 2, 3])
+        """
+        if isinstance(n, Permutation):
+            raise NotImplementedError(
+                'p**p is not defined; do you mean p^p (conjugate)?')
+        n = int(n)
+        return self._af_new(_af_pow(self.array_form, n))
+
+    def __rxor__(self, i):
+        """Return self(i) when ``i`` is an int.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(1, 2, 9)
+        >>> 2^p == p(2) == 9
+        True
+        """
+        if int_valued(i):
+            return self(i)
+        else:
+            raise NotImplementedError(
+                "i^p = p(i) when i is an integer, not %s." % i)
+
+    def __xor__(self, h):
+        """Return the conjugate permutation ``~h*self*h` `.
+
+        Explanation
+        ===========
+
+        If ``a`` and ``b`` are conjugates, ``a = h*b*~h`` and
+        ``b = ~h*a*h`` and both have the same cycle structure.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation(1, 2, 9)
+        >>> q = Permutation(6, 9, 8)
+        >>> p*q != q*p
+        True
+
+        Calculate and check properties of the conjugate:
+
+        >>> c = p^q
+        >>> c == ~q*p*q and p == q*c*~q
+        True
+
+        The expression q^p^r is equivalent to q^(p*r):
+
+        >>> r = Permutation(9)(4, 6, 8)
+        >>> q^p^r == q^(p*r)
+        True
+
+        If the term to the left of the conjugate operator, i, is an integer
+        then this is interpreted as selecting the ith element from the
+        permutation to the right:
+
+        >>> all(i^p == p(i) for i in range(p.size))
+        True
+
+        Note that the * operator as higher precedence than the ^ operator:
+
+        >>> q^r*p^r == q^(r*p)^r == Permutation(9)(1, 6, 4)
+        True
+
+        Notes
+        =====
+
+        In Python the precedence rule is p^q^r = (p^q)^r which differs
+        in general from p^(q^r)
+
+        >>> q^p^r
+        (9)(1 4 8)
+        >>> q^(p^r)
+        (9)(1 8 6)
+
+        For a given r and p, both of the following are conjugates of p:
+        ~r*p*r and r*p*~r. But these are not necessarily the same:
+
+        >>> ~r*p*r == r*p*~r
+        True
+
+        >>> p = Permutation(1, 2, 9)(5, 6)
+        >>> ~r*p*r == r*p*~r
+        False
+
+        The conjugate ~r*p*r was chosen so that ``p^q^r`` would be equivalent
+        to ``p^(q*r)`` rather than ``p^(r*q)``. To obtain r*p*~r, pass ~r to
+        this method:
+
+        >>> p^~r == r*p*~r
+        True
+        """
+
+        if self.size != h.size:
+            raise ValueError("The permutations must be of equal size.")
+        a = [None]*self.size
+        h = h._array_form
+        p = self._array_form
+        for i in range(self.size):
+            a[h[i]] = h[p[i]]
+        return self._af_new(a)
+
+    def transpositions(self):
+        """
+        Return the permutation decomposed into a list of transpositions.
+
+        Explanation
+        ===========
+
+        It is always possible to express a permutation as the product of
+        transpositions, see [1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[1, 2, 3], [0, 4, 5, 6, 7]])
+        >>> t = p.transpositions()
+        >>> t
+        [(0, 7), (0, 6), (0, 5), (0, 4), (1, 3), (1, 2)]
+        >>> print(''.join(str(c) for c in t))
+        (0, 7)(0, 6)(0, 5)(0, 4)(1, 3)(1, 2)
+        >>> Permutation.rmul(*[Permutation([ti], size=p.size) for ti in t]) == p
+        True
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Transposition_%28mathematics%29#Properties
+
+        """
+        a = self.cyclic_form
+        res = []
+        for x in a:
+            nx = len(x)
+            if nx == 2:
+                res.append(tuple(x))
+            elif nx > 2:
+                first = x[0]
+                res.extend((first, y) for y in x[nx - 1:0:-1])
+        return res
+
+    @classmethod
+    def from_sequence(self, i, key=None):
+        """Return the permutation needed to obtain ``i`` from the sorted
+        elements of ``i``. If custom sorting is desired, a key can be given.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        >>> Permutation.from_sequence('SymPy')
+        (4)(0 1 3)
+        >>> _(sorted("SymPy"))
+        ['S', 'y', 'm', 'P', 'y']
+        >>> Permutation.from_sequence('SymPy', key=lambda x: x.lower())
+        (4)(0 2)(1 3)
+        """
+        ic = list(zip(i, list(range(len(i)))))
+        if key:
+            ic.sort(key=lambda x: key(x[0]))
+        else:
+            ic.sort()
+        return ~Permutation([i[1] for i in ic])
+
+    def __invert__(self):
+        """
+        Return the inverse of the permutation.
+
+        A permutation multiplied by its inverse is the identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> ~p
+        Permutation([2, 3, 0, 1])
+        >>> _ == p**-1
+        True
+        >>> p*~p == ~p*p == Permutation([0, 1, 2, 3])
+        True
+        """
+        return self._af_new(_af_invert(self._array_form))
+
+    def __iter__(self):
+        """Yield elements from array form.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> list(Permutation(range(3)))
+        [0, 1, 2]
+        """
+        yield from self.array_form
+
+    def __repr__(self):
+        return srepr(self)
+
+    def __call__(self, *i):
+        """
+        Allows applying a permutation instance as a bijective function.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([[2, 0], [3, 1]])
+        >>> p.array_form
+        [2, 3, 0, 1]
+        >>> [p(i) for i in range(4)]
+        [2, 3, 0, 1]
+
+        If an array is given then the permutation selects the items
+        from the array (i.e. the permutation is applied to the array):
+
+        >>> from sympy.abc import x
+        >>> p([x, 1, 0, x**2])
+        [0, x**2, x, 1]
+        """
+        # list indices can be Integer or int; leave this
+        # as it is (don't test or convert it) because this
+        # gets called a lot and should be fast
+        if len(i) == 1:
+            i = i[0]
+            if not isinstance(i, Iterable):
+                i = as_int(i)
+                if i < 0 or i > self.size:
+                    raise TypeError(
+                        "{} should be an integer between 0 and {}"
+                        .format(i, self.size-1))
+                return self._array_form[i]
+            # P([a, b, c])
+            if len(i) != self.size:
+                raise TypeError(
+                    "{} should have the length {}.".format(i, self.size))
+            return [i[j] for j in self._array_form]
+        # P(1, 2, 3)
+        return self*Permutation(Cycle(*i), size=self.size)
+
+    def atoms(self):
+        """
+        Returns all the elements of a permutation
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 1, 2, 3, 4, 5]).atoms()
+        {0, 1, 2, 3, 4, 5}
+        >>> Permutation([[0, 1], [2, 3], [4, 5]]).atoms()
+        {0, 1, 2, 3, 4, 5}
+        """
+        return set(self.array_form)
+
+    def apply(self, i):
+        r"""Apply the permutation to an expression.
+
+        Parameters
+        ==========
+
+        i : Expr
+            It should be an integer between $0$ and $n-1$ where $n$
+            is the size of the permutation.
+
+            If it is a symbol or a symbolic expression that can
+            have integer values, an ``AppliedPermutation`` object
+            will be returned which can represent an unevaluated
+            function.
+
+        Notes
+        =====
+
+        Any permutation can be defined as a bijective function
+        $\sigma : \{ 0, 1, \dots, n-1 \} \rightarrow \{ 0, 1, \dots, n-1 \}$
+        where $n$ denotes the size of the permutation.
+
+        The definition may even be extended for any set with distinctive
+        elements, such that the permutation can even be applied for
+        real numbers or such, however, it is not implemented for now for
+        computational reasons and the integrity with the group theory
+        module.
+
+        This function is similar to the ``__call__`` magic, however,
+        ``__call__`` magic already has some other applications like
+        permuting an array or attaching new cycles, which would
+        not always be mathematically consistent.
+
+        This also guarantees that the return type is a SymPy integer,
+        which guarantees the safety to use assumptions.
+        """
+        i = _sympify(i)
+        if i.is_integer is False:
+            raise NotImplementedError("{} should be an integer.".format(i))
+
+        n = self.size
+        if (i < 0) == True or (i >= n) == True:
+            raise NotImplementedError(
+                "{} should be an integer between 0 and {}".format(i, n-1))
+
+        if i.is_Integer:
+            return Integer(self._array_form[i])
+        return AppliedPermutation(self, i)
+
+    def next_lex(self):
+        """
+        Returns the next permutation in lexicographical order.
+        If self is the last permutation in lexicographical order
+        it returns None.
+        See [4] section 2.4.
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 3, 1, 0])
+        >>> p = Permutation([2, 3, 1, 0]); p.rank()
+        17
+        >>> p = p.next_lex(); p.rank()
+        18
+
+        See Also
+        ========
+
+        rank, unrank_lex
+        """
+        perm = self.array_form[:]
+        n = len(perm)
+        i = n - 2
+        while perm[i + 1] < perm[i]:
+            i -= 1
+        if i == -1:
+            return None
+        else:
+            j = n - 1
+            while perm[j] < perm[i]:
+                j -= 1
+            perm[j], perm[i] = perm[i], perm[j]
+            i += 1
+            j = n - 1
+            while i < j:
+                perm[j], perm[i] = perm[i], perm[j]
+                i += 1
+                j -= 1
+        return self._af_new(perm)
+
+    @classmethod
+    def unrank_nonlex(self, n, r):
+        """
+        This is a linear time unranking algorithm that does not
+        respect lexicographic order [3].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.unrank_nonlex(4, 5)
+        Permutation([2, 0, 3, 1])
+        >>> Permutation.unrank_nonlex(4, -1)
+        Permutation([0, 1, 2, 3])
+
+        See Also
+        ========
+
+        next_nonlex, rank_nonlex
+        """
+        def _unrank1(n, r, a):
+            if n > 0:
+                a[n - 1], a[r % n] = a[r % n], a[n - 1]
+                _unrank1(n - 1, r//n, a)
+
+        id_perm = list(range(n))
+        n = int(n)
+        r = r % ifac(n)
+        _unrank1(n, r, id_perm)
+        return self._af_new(id_perm)
+
+    def rank_nonlex(self, inv_perm=None):
+        """
+        This is a linear time ranking algorithm that does not
+        enforce lexicographic order [3].
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank_nonlex()
+        23
+
+        See Also
+        ========
+
+        next_nonlex, unrank_nonlex
+        """
+        def _rank1(n, perm, inv_perm):
+            if n == 1:
+                return 0
+            s = perm[n - 1]
+            t = inv_perm[n - 1]
+            perm[n - 1], perm[t] = perm[t], s
+            inv_perm[n - 1], inv_perm[s] = inv_perm[s], t
+            return s + n*_rank1(n - 1, perm, inv_perm)
+
+        if inv_perm is None:
+            inv_perm = (~self).array_form
+        if not inv_perm:
+            return 0
+        perm = self.array_form[:]
+        r = _rank1(len(perm), perm, inv_perm)
+        return r
+
+    def next_nonlex(self):
+        """
+        Returns the next permutation in nonlex order [3].
+        If self is the last permutation in this order it returns None.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([2, 0, 3, 1]); p.rank_nonlex()
+        5
+        >>> p = p.next_nonlex(); p
+        Permutation([3, 0, 1, 2])
+        >>> p.rank_nonlex()
+        6
+
+        See Also
+        ========
+
+        rank_nonlex, unrank_nonlex
+        """
+        r = self.rank_nonlex()
+        if r == ifac(self.size) - 1:
+            return None
+        return self.unrank_nonlex(self.size, r + 1)
+
+    def rank(self):
+        """
+        Returns the lexicographic rank of the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank()
+        0
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.rank()
+        23
+
+        See Also
+        ========
+
+        next_lex, unrank_lex, cardinality, length, order, size
+        """
+        if self._rank is not None:
+            return self._rank
+        rank = 0
+        rho = self.array_form[:]
+        n = self.size - 1
+        size = n + 1
+        psize = int(ifac(n))
+        for j in range(size - 1):
+            rank += rho[j]*psize
+            for i in range(j + 1, size):
+                if rho[i] > rho[j]:
+                    rho[i] -= 1
+            psize //= n
+            n -= 1
+        self._rank = rank
+        return rank
+
+    @property
+    def cardinality(self):
+        """
+        Returns the number of all possible permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.cardinality
+        24
+
+        See Also
+        ========
+
+        length, order, rank, size
+        """
+        return int(ifac(self.size))
+
+    def parity(self):
+        """
+        Computes the parity of a permutation.
+
+        Explanation
+        ===========
+
+        The parity of a permutation reflects the parity of the
+        number of inversions in the permutation, i.e., the
+        number of pairs of x and y such that ``x > y`` but ``p[x] < p[y]``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.parity()
+        0
+        >>> p = Permutation([3, 2, 0, 1])
+        >>> p.parity()
+        1
+
+        See Also
+        ========
+
+        _af_parity
+        """
+        if self._cyclic_form is not None:
+            return (self.size - self.cycles) % 2
+
+        return _af_parity(self.array_form)
+
+    @property
+    def is_even(self):
+        """
+        Checks if a permutation is even.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.is_even
+        True
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.is_even
+        True
+
+        See Also
+        ========
+
+        is_odd
+        """
+        return not self.is_odd
+
+    @property
+    def is_odd(self):
+        """
+        Checks if a permutation is odd.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.is_odd
+        False
+        >>> p = Permutation([3, 2, 0, 1])
+        >>> p.is_odd
+        True
+
+        See Also
+        ========
+
+        is_even
+        """
+        return bool(self.parity() % 2)
+
+    @property
+    def is_Singleton(self):
+        """
+        Checks to see if the permutation contains only one number and is
+        thus the only possible permutation of this set of numbers
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0]).is_Singleton
+        True
+        >>> Permutation([0, 1]).is_Singleton
+        False
+
+        See Also
+        ========
+
+        is_Empty
+        """
+        return self.size == 1
+
+    @property
+    def is_Empty(self):
+        """
+        Checks to see if the permutation is a set with zero elements
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([]).is_Empty
+        True
+        >>> Permutation([0]).is_Empty
+        False
+
+        See Also
+        ========
+
+        is_Singleton
+        """
+        return self.size == 0
+
+    @property
+    def is_identity(self):
+        return self.is_Identity
+
+    @property
+    def is_Identity(self):
+        """
+        Returns True if the Permutation is an identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([[0], [1], [2]])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([0, 1, 2])
+        >>> p.is_Identity
+        True
+        >>> p = Permutation([0, 2, 1])
+        >>> p.is_Identity
+        False
+
+        See Also
+        ========
+
+        order
+        """
+        af = self.array_form
+        return not af or all(i == af[i] for i in range(self.size))
+
+    def ascents(self):
+        """
+        Returns the positions of ascents in a permutation, ie, the location
+        where p[i] < p[i+1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 0, 1, 3, 2])
+        >>> p.ascents()
+        [1, 2]
+
+        See Also
+        ========
+
+        descents, inversions, min, max
+        """
+        a = self.array_form
+        pos = [i for i in range(len(a) - 1) if a[i] < a[i + 1]]
+        return pos
+
+    def descents(self):
+        """
+        Returns the positions of descents in a permutation, ie, the location
+        where p[i] > p[i+1]
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 0, 1, 3, 2])
+        >>> p.descents()
+        [0, 3]
+
+        See Also
+        ========
+
+        ascents, inversions, min, max
+        """
+        a = self.array_form
+        pos = [i for i in range(len(a) - 1) if a[i] > a[i + 1]]
+        return pos
+
+    def max(self) -> int:
+        """
+        The maximum element moved by the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([1, 0, 2, 3, 4])
+        >>> p.max()
+        1
+
+        See Also
+        ========
+
+        min, descents, ascents, inversions
+        """
+        a = self.array_form
+        if not a:
+            return 0
+        return max(_a for i, _a in enumerate(a) if _a != i)
+
+    def min(self) -> int:
+        """
+        The minimum element moved by the permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 4, 3, 2])
+        >>> p.min()
+        2
+
+        See Also
+        ========
+
+        max, descents, ascents, inversions
+        """
+        a = self.array_form
+        if not a:
+            return 0
+        return min(_a for i, _a in enumerate(a) if _a != i)
+
+    def inversions(self):
+        """
+        Computes the number of inversions of a permutation.
+
+        Explanation
+        ===========
+
+        An inversion is where i > j but p[i] < p[j].
+
+        For small length of p, it iterates over all i and j
+        values and calculates the number of inversions.
+        For large length of p, it uses a variation of merge
+        sort to calculate the number of inversions.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3, 4, 5])
+        >>> p.inversions()
+        0
+        >>> Permutation([3, 2, 1, 0]).inversions()
+        6
+
+        See Also
+        ========
+
+        descents, ascents, min, max
+
+        References
+        ==========
+
+        .. [1] https://www.cp.eng.chula.ac.th/~prabhas//teaching/algo/algo2008/count-inv.htm
+
+        """
+        inversions = 0
+        a = self.array_form
+        n = len(a)
+        if n < 130:
+            for i in range(n - 1):
+                b = a[i]
+                for c in a[i + 1:]:
+                    if b > c:
+                        inversions += 1
+        else:
+            k = 1
+            right = 0
+            arr = a[:]
+            temp = a[:]
+            while k < n:
+                i = 0
+                while i + k < n:
+                    right = i + k * 2 - 1
+                    if right >= n:
+                        right = n - 1
+                    inversions += _merge(arr, temp, i, i + k, right)
+                    i = i + k * 2
+                k = k * 2
+        return inversions
+
+    def commutator(self, x):
+        """Return the commutator of ``self`` and ``x``: ``~x*~self*x*self``
+
+        If f and g are part of a group, G, then the commutator of f and g
+        is the group identity iff f and g commute, i.e. fg == gf.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([0, 2, 3, 1])
+        >>> x = Permutation([2, 0, 3, 1])
+        >>> c = p.commutator(x); c
+        Permutation([2, 1, 3, 0])
+        >>> c == ~x*~p*x*p
+        True
+
+        >>> I = Permutation(3)
+        >>> p = [I + i for i in range(6)]
+        >>> for i in range(len(p)):
+        ...     for j in range(len(p)):
+        ...         c = p[i].commutator(p[j])
+        ...         if p[i]*p[j] == p[j]*p[i]:
+        ...             assert c == I
+        ...         else:
+        ...             assert c != I
+        ...
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Commutator
+        """
+
+        a = self.array_form
+        b = x.array_form
+        n = len(a)
+        if len(b) != n:
+            raise ValueError("The permutations must be of equal size.")
+        inva = [None]*n
+        for i in range(n):
+            inva[a[i]] = i
+        invb = [None]*n
+        for i in range(n):
+            invb[b[i]] = i
+        return self._af_new([a[b[inva[i]]] for i in invb])
+
+    def signature(self):
+        """
+        Gives the signature of the permutation needed to place the
+        elements of the permutation in canonical order.
+
+        The signature is calculated as (-1)^
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2])
+        >>> p.inversions()
+        0
+        >>> p.signature()
+        1
+        >>> q = Permutation([0,2,1])
+        >>> q.inversions()
+        1
+        >>> q.signature()
+        -1
+
+        See Also
+        ========
+
+        inversions
+        """
+        if self.is_even:
+            return 1
+        return -1
+
+    def order(self):
+        """
+        Computes the order of a permutation.
+
+        When the permutation is raised to the power of its
+        order it equals the identity permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([3, 1, 5, 2, 4, 0])
+        >>> p.order()
+        4
+        >>> (p**(p.order()))
+        Permutation([], size=6)
+
+        See Also
+        ========
+
+        identity, cardinality, length, rank, size
+        """
+
+        return reduce(lcm, [len(cycle) for cycle in self.cyclic_form], 1)
+
+    def length(self):
+        """
+        Returns the number of integers moved by a permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 3, 2, 1]).length()
+        2
+        >>> Permutation([[0, 1], [2, 3]]).length()
+        4
+
+        See Also
+        ========
+
+        min, max, support, cardinality, order, rank, size
+        """
+
+        return len(self.support())
+
+    @property
+    def cycle_structure(self):
+        """Return the cycle structure of the permutation as a dictionary
+        indicating the multiplicity of each cycle length.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation(3).cycle_structure
+        {1: 4}
+        >>> Permutation(0, 4, 3)(1, 2)(5, 6).cycle_structure
+        {2: 2, 3: 1}
+        """
+        if self._cycle_structure:
+            rv = self._cycle_structure
+        else:
+            rv = defaultdict(int)
+            singletons = self.size
+            for c in self.cyclic_form:
+                rv[len(c)] += 1
+                singletons -= len(c)
+            if singletons:
+                rv[1] = singletons
+            self._cycle_structure = rv
+        return dict(rv)  # make a copy
+
+    @property
+    def cycles(self):
+        """
+        Returns the number of cycles contained in the permutation
+        (including singletons).
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation([0, 1, 2]).cycles
+        3
+        >>> Permutation([0, 1, 2]).full_cyclic_form
+        [[0], [1], [2]]
+        >>> Permutation(0, 1)(2, 3).cycles
+        2
+
+        See Also
+        ========
+        sympy.functions.combinatorial.numbers.stirling
+        """
+        return len(self.full_cyclic_form)
+
+    def index(self):
+        """
+        Returns the index of a permutation.
+
+        The index of a permutation is the sum of all subscripts j such
+        that p[j] is greater than p[j+1].
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([3, 0, 2, 1, 4])
+        >>> p.index()
+        2
+        """
+        a = self.array_form
+
+        return sum(j for j in range(len(a) - 1) if a[j] > a[j + 1])
+
+    def runs(self):
+        """
+        Returns the runs of a permutation.
+
+        An ascending sequence in a permutation is called a run [5].
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 5, 7, 3, 6, 0, 1, 4, 8])
+        >>> p.runs()
+        [[2, 5, 7], [3, 6], [0, 1, 4, 8]]
+        >>> q = Permutation([1,3,2,0])
+        >>> q.runs()
+        [[1, 3], [2], [0]]
+        """
+        return runs(self.array_form)
+
+    def inversion_vector(self):
+        """Return the inversion vector of the permutation.
+
+        The inversion vector consists of elements whose value
+        indicates the number of elements in the permutation
+        that are lesser than it and lie on its right hand side.
+
+        The inversion vector is the same as the Lehmer encoding of a
+        permutation.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([4, 8, 0, 7, 1, 5, 3, 6, 2])
+        >>> p.inversion_vector()
+        [4, 7, 0, 5, 0, 2, 1, 1]
+        >>> p = Permutation([3, 2, 1, 0])
+        >>> p.inversion_vector()
+        [3, 2, 1]
+
+        The inversion vector increases lexicographically with the rank
+        of the permutation, the -ith element cycling through 0..i.
+
+        >>> p = Permutation(2)
+        >>> while p:
+        ...     print('%s %s %s' % (p, p.inversion_vector(), p.rank()))
+        ...     p = p.next_lex()
+        (2) [0, 0] 0
+        (1 2) [0, 1] 1
+        (2)(0 1) [1, 0] 2
+        (0 1 2) [1, 1] 3
+        (0 2 1) [2, 0] 4
+        (0 2) [2, 1] 5
+
+        See Also
+        ========
+
+        from_inversion_vector
+        """
+        self_array_form = self.array_form
+        n = len(self_array_form)
+        inversion_vector = [0] * (n - 1)
+
+        for i in range(n - 1):
+            val = 0
+            for j in range(i + 1, n):
+                if self_array_form[j] < self_array_form[i]:
+                    val += 1
+            inversion_vector[i] = val
+        return inversion_vector
+
+    def rank_trotterjohnson(self):
+        """
+        Returns the Trotter Johnson rank, which we get from the minimal
+        change algorithm. See [4] section 2.4.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 1, 2, 3])
+        >>> p.rank_trotterjohnson()
+        0
+        >>> p = Permutation([0, 2, 1, 3])
+        >>> p.rank_trotterjohnson()
+        7
+
+        See Also
+        ========
+
+        unrank_trotterjohnson, next_trotterjohnson
+        """
+        if self.array_form == [] or self.is_Identity:
+            return 0
+        if self.array_form == [1, 0]:
+            return 1
+        perm = self.array_form
+        n = self.size
+        rank = 0
+        for j in range(1, n):
+            k = 1
+            i = 0
+            while perm[i] != j:
+                if perm[i] < j:
+                    k += 1
+                i += 1
+            j1 = j + 1
+            if rank % 2 == 0:
+                rank = j1*rank + j1 - k
+            else:
+                rank = j1*rank + k - 1
+        return rank
+
+    @classmethod
+    def unrank_trotterjohnson(cls, size, rank):
+        """
+        Trotter Johnson permutation unranking. See [4] section 2.4.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.unrank_trotterjohnson(5, 10)
+        Permutation([0, 3, 1, 2, 4])
+
+        See Also
+        ========
+
+        rank_trotterjohnson, next_trotterjohnson
+        """
+        perm = [0]*size
+        r2 = 0
+        n = ifac(size)
+        pj = 1
+        for j in range(2, size + 1):
+            pj *= j
+            r1 = (rank * pj) // n
+            k = r1 - j*r2
+            if r2 % 2 == 0:
+                for i in range(j - 1, j - k - 1, -1):
+                    perm[i] = perm[i - 1]
+                perm[j - k - 1] = j - 1
+            else:
+                for i in range(j - 1, k, -1):
+                    perm[i] = perm[i - 1]
+                perm[k] = j - 1
+            r2 = r1
+        return cls._af_new(perm)
+
+    def next_trotterjohnson(self):
+        """
+        Returns the next permutation in Trotter-Johnson order.
+        If self is the last permutation it returns None.
+        See [4] section 2.4. If it is desired to generate all such
+        permutations, they can be generated in order more quickly
+        with the ``generate_bell`` function.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation([3, 0, 2, 1])
+        >>> p.rank_trotterjohnson()
+        4
+        >>> p = p.next_trotterjohnson(); p
+        Permutation([0, 3, 2, 1])
+        >>> p.rank_trotterjohnson()
+        5
+
+        See Also
+        ========
+
+        rank_trotterjohnson, unrank_trotterjohnson, sympy.utilities.iterables.generate_bell
+        """
+        pi = self.array_form[:]
+        n = len(pi)
+        st = 0
+        rho = pi[:]
+        done = False
+        m = n-1
+        while m > 0 and not done:
+            d = rho.index(m)
+            for i in range(d, m):
+                rho[i] = rho[i + 1]
+            par = _af_parity(rho[:m])
+            if par == 1:
+                if d == m:
+                    m -= 1
+                else:
+                    pi[st + d], pi[st + d + 1] = pi[st + d + 1], pi[st + d]
+                    done = True
+            else:
+                if d == 0:
+                    m -= 1
+                    st += 1
+                else:
+                    pi[st + d], pi[st + d - 1] = pi[st + d - 1], pi[st + d]
+                    done = True
+        if m == 0:
+            return None
+        return self._af_new(pi)
+
+    def get_precedence_matrix(self):
+        """
+        Gets the precedence matrix. This is used for computing the
+        distance between two permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> p = Permutation.josephus(3, 6, 1)
+        >>> p
+        Permutation([2, 5, 3, 1, 4, 0])
+        >>> p.get_precedence_matrix()
+        Matrix([
+        [0, 0, 0, 0, 0, 0],
+        [1, 0, 0, 0, 1, 0],
+        [1, 1, 0, 1, 1, 1],
+        [1, 1, 0, 0, 1, 0],
+        [1, 0, 0, 0, 0, 0],
+        [1, 1, 0, 1, 1, 0]])
+
+        See Also
+        ========
+
+        get_precedence_distance, get_adjacency_matrix, get_adjacency_distance
+        """
+        m = zeros(self.size)
+        perm = self.array_form
+        for i in range(m.rows):
+            for j in range(i + 1, m.cols):
+                m[perm[i], perm[j]] = 1
+        return m
+
+    def get_precedence_distance(self, other):
+        """
+        Computes the precedence distance between two permutations.
+
+        Explanation
+        ===========
+
+        Suppose p and p' represent n jobs. The precedence metric
+        counts the number of times a job j is preceded by job i
+        in both p and p'. This metric is commutative.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([2, 0, 4, 3, 1])
+        >>> q = Permutation([3, 1, 2, 4, 0])
+        >>> p.get_precedence_distance(q)
+        7
+        >>> q.get_precedence_distance(p)
+        7
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_adjacency_matrix, get_adjacency_distance
+        """
+        if self.size != other.size:
+            raise ValueError("The permutations must be of equal size.")
+        self_prec_mat = self.get_precedence_matrix()
+        other_prec_mat = other.get_precedence_matrix()
+        n_prec = 0
+        for i in range(self.size):
+            for j in range(self.size):
+                if i == j:
+                    continue
+                if self_prec_mat[i, j] * other_prec_mat[i, j] == 1:
+                    n_prec += 1
+        d = self.size * (self.size - 1)//2 - n_prec
+        return d
+
+    def get_adjacency_matrix(self):
+        """
+        Computes the adjacency matrix of a permutation.
+
+        Explanation
+        ===========
+
+        If job i is adjacent to job j in a permutation p
+        then we set m[i, j] = 1 where m is the adjacency
+        matrix of p.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation.josephus(3, 6, 1)
+        >>> p.get_adjacency_matrix()
+        Matrix([
+        [0, 0, 0, 0, 0, 0],
+        [0, 0, 0, 0, 1, 0],
+        [0, 0, 0, 0, 0, 1],
+        [0, 1, 0, 0, 0, 0],
+        [1, 0, 0, 0, 0, 0],
+        [0, 0, 0, 1, 0, 0]])
+        >>> q = Permutation([0, 1, 2, 3])
+        >>> q.get_adjacency_matrix()
+        Matrix([
+        [0, 1, 0, 0],
+        [0, 0, 1, 0],
+        [0, 0, 0, 1],
+        [0, 0, 0, 0]])
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_precedence_distance, get_adjacency_distance
+        """
+        m = zeros(self.size)
+        perm = self.array_form
+        for i in range(self.size - 1):
+            m[perm[i], perm[i + 1]] = 1
+        return m
+
+    def get_adjacency_distance(self, other):
+        """
+        Computes the adjacency distance between two permutations.
+
+        Explanation
+        ===========
+
+        This metric counts the number of times a pair i,j of jobs is
+        adjacent in both p and p'. If n_adj is this quantity then
+        the adjacency distance is n - n_adj - 1 [1]
+
+        [1] Reeves, Colin R. Landscapes, Operators and Heuristic search, Annals
+        of Operational Research, 86, pp 473-490. (1999)
+
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2, 4])
+        >>> q = Permutation.josephus(4, 5, 2)
+        >>> p.get_adjacency_distance(q)
+        3
+        >>> r = Permutation([0, 2, 1, 4, 3])
+        >>> p.get_adjacency_distance(r)
+        4
+
+        See Also
+        ========
+
+        get_precedence_matrix, get_precedence_distance, get_adjacency_matrix
+        """
+        if self.size != other.size:
+            raise ValueError("The permutations must be of the same size.")
+        self_adj_mat = self.get_adjacency_matrix()
+        other_adj_mat = other.get_adjacency_matrix()
+        n_adj = 0
+        for i in range(self.size):
+            for j in range(self.size):
+                if i == j:
+                    continue
+                if self_adj_mat[i, j] * other_adj_mat[i, j] == 1:
+                    n_adj += 1
+        d = self.size - n_adj - 1
+        return d
+
+    def get_positional_distance(self, other):
+        """
+        Computes the positional distance between two permutations.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> p = Permutation([0, 3, 1, 2, 4])
+        >>> q = Permutation.josephus(4, 5, 2)
+        >>> r = Permutation([3, 1, 4, 0, 2])
+        >>> p.get_positional_distance(q)
+        12
+        >>> p.get_positional_distance(r)
+        12
+
+        See Also
+        ========
+
+        get_precedence_distance, get_adjacency_distance
+        """
+        a = self.array_form
+        b = other.array_form
+        if len(a) != len(b):
+            raise ValueError("The permutations must be of the same size.")
+        return sum(abs(a[i] - b[i]) for i in range(len(a)))
+
+    @classmethod
+    def josephus(cls, m, n, s=1):
+        """Return as a permutation the shuffling of range(n) using the Josephus
+        scheme in which every m-th item is selected until all have been chosen.
+        The returned permutation has elements listed by the order in which they
+        were selected.
+
+        The parameter ``s`` stops the selection process when there are ``s``
+        items remaining and these are selected by continuing the selection,
+        counting by 1 rather than by ``m``.
+
+        Consider selecting every 3rd item from 6 until only 2 remain::
+
+            choices    chosen
+            ========   ======
+              012345
+              01 345   2
+              01 34    25
+              01  4    253
+              0   4    2531
+              0        25314
+                       253140
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation.josephus(3, 6, 2).array_form
+        [2, 5, 3, 1, 4, 0]
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Flavius_Josephus
+        .. [2] https://en.wikipedia.org/wiki/Josephus_problem
+        .. [3] https://web.archive.org/web/20171008094331/http://www.wou.edu/~burtonl/josephus.html
+
+        """
+        from collections import deque
+        m -= 1
+        Q = deque(list(range(n)))
+        perm = []
+        while len(Q) > max(s, 1):
+            for dp in range(m):
+                Q.append(Q.popleft())
+            perm.append(Q.popleft())
+        perm.extend(list(Q))
+        return cls(perm)
+
+    @classmethod
+    def from_inversion_vector(cls, inversion):
+        """
+        Calculates the permutation from the inversion vector.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> Permutation.from_inversion_vector([3, 2, 1, 0, 0])
+        Permutation([3, 2, 1, 0, 4, 5])
+
+        """
+        size = len(inversion)
+        N = list(range(size + 1))
+        perm = []
+        try:
+            for k in range(size):
+                val = N[inversion[k]]
+                perm.append(val)
+                N.remove(val)
+        except IndexError:
+            raise ValueError("The inversion vector is not valid.")
+        perm.extend(N)
+        return cls._af_new(perm)
+
+    @classmethod
+    def random(cls, n):
+        """
+        Generates a random permutation of length ``n``.
+
+        Uses the underlying Python pseudo-random number generator.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
+        True
+
+        """
+        perm_array = list(range(n))
+        random.shuffle(perm_array)
+        return cls._af_new(perm_array)
+
+    @classmethod
+    def unrank_lex(cls, size, rank):
+        """
+        Lexicographic permutation unranking.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+        >>> from sympy import init_printing
+        >>> init_printing(perm_cyclic=False, pretty_print=False)
+        >>> a = Permutation.unrank_lex(5, 10)
+        >>> a.rank()
+        10
+        >>> a
+        Permutation([0, 2, 4, 1, 3])
+
+        See Also
+        ========
+
+        rank, next_lex
+        """
+        perm_array = [0] * size
+        psize = 1
+        for i in range(size):
+            new_psize = psize*(i + 1)
+            d = (rank % new_psize) // psize
+            rank -= d*psize
+            perm_array[size - i - 1] = d
+            for j in range(size - i, size):
+                if perm_array[j] > d - 1:
+                    perm_array[j] += 1
+            psize = new_psize
+        return cls._af_new(perm_array)
+
+    def resize(self, n):
+        """Resize the permutation to the new size ``n``.
+
+        Parameters
+        ==========
+
+        n : int
+            The new size of the permutation.
+
+        Raises
+        ======
+
+        ValueError
+            If the permutation cannot be resized to the given size.
+            This may only happen when resized to a smaller size than
+            the original.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Permutation
+
+        Increasing the size of a permutation:
+
+        >>> p = Permutation(0, 1, 2)
+        >>> p = p.resize(5)
+        >>> p
+        (4)(0 1 2)
+
+        Decreasing the size of the permutation:
+
+        >>> p = p.resize(4)
+        >>> p
+        (3)(0 1 2)
+
+        If resizing to the specific size breaks the cycles:
+
+        >>> p.resize(2)
+        Traceback (most recent call last):
+        ...
+        ValueError: The permutation cannot be resized to 2 because the
+        cycle (0, 1, 2) may break.
+        """
+        aform = self.array_form
+        l = len(aform)
+        if n > l:
+            aform += list(range(l, n))
+            return Permutation._af_new(aform)
+
+        elif n < l:
+            cyclic_form = self.full_cyclic_form
+            new_cyclic_form = []
+            for cycle in cyclic_form:
+                cycle_min = min(cycle)
+                cycle_max = max(cycle)
+                if cycle_min <= n-1:
+                    if cycle_max > n-1:
+                        raise ValueError(
+                            "The permutation cannot be resized to {} "
+                            "because the cycle {} may break."
+                            .format(n, tuple(cycle)))
+
+                    new_cyclic_form.append(cycle)
+            return Permutation(new_cyclic_form)
+
+        return self
+
+    # XXX Deprecated flag
+    print_cyclic = None
+
+
+def _merge(arr, temp, left, mid, right):
+    """
+    Merges two sorted arrays and calculates the inversion count.
+
+    Helper function for calculating inversions. This method is
+    for internal use only.
+    """
+    i = k = left
+    j = mid
+    inv_count = 0
+    while i < mid and j <= right:
+        if arr[i] < arr[j]:
+            temp[k] = arr[i]
+            k += 1
+            i += 1
+        else:
+            temp[k] = arr[j]
+            k += 1
+            j += 1
+            inv_count += (mid -i)
+    while i < mid:
+        temp[k] = arr[i]
+        k += 1
+        i += 1
+    if j <= right:
+        k += right - j + 1
+        j += right - j + 1
+        arr[left:k + 1] = temp[left:k + 1]
+    else:
+        arr[left:right + 1] = temp[left:right + 1]
+    return inv_count
+
+Perm = Permutation
+_af_new = Perm._af_new
+
+
+class AppliedPermutation(Expr):
+    """A permutation applied to a symbolic variable.
+
+    Parameters
+    ==========
+
+    perm : Permutation
+    x : Expr
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.combinatorics import Permutation
+
+    Creating a symbolic permutation function application:
+
+    >>> x = Symbol('x')
+    >>> p = Permutation(0, 1, 2)
+    >>> p.apply(x)
+    AppliedPermutation((0 1 2), x)
+    >>> _.subs(x, 1)
+    2
+    """
+    def __new__(cls, perm, x, evaluate=None):
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+
+        perm = _sympify(perm)
+        x = _sympify(x)
+
+        if not isinstance(perm, Permutation):
+            raise ValueError("{} must be a Permutation instance."
+                .format(perm))
+
+        if evaluate:
+            if x.is_Integer:
+                return perm.apply(x)
+
+        obj = super().__new__(cls, perm, x)
+        return obj
+
+
+@dispatch(Permutation, Permutation)
+def _eval_is_eq(lhs, rhs):
+    if lhs._size != rhs._size:
+        return None
+    return lhs._array_form == rhs._array_form
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/polyhedron.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/polyhedron.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bc05d7d97c840649661f3290442499c841ca7c1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/polyhedron.py
@@ -0,0 +1,1019 @@
+from sympy.combinatorics import Permutation as Perm
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.core import Basic, Tuple, default_sort_key
+from sympy.sets import FiniteSet
+from sympy.utilities.iterables import (minlex, unflatten, flatten)
+from sympy.utilities.misc import as_int
+
+rmul = Perm.rmul
+
+
+class Polyhedron(Basic):
+    """
+    Represents the polyhedral symmetry group (PSG).
+
+    Explanation
+    ===========
+
+    The PSG is one of the symmetry groups of the Platonic solids.
+    There are three polyhedral groups: the tetrahedral group
+    of order 12, the octahedral group of order 24, and the
+    icosahedral group of order 60.
+
+    All doctests have been given in the docstring of the
+    constructor of the object.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/PolyhedralGroup.html
+
+    """
+    _edges = None
+
+    def __new__(cls, corners, faces=(), pgroup=()):
+        """
+        The constructor of the Polyhedron group object.
+
+        Explanation
+        ===========
+
+        It takes up to three parameters: the corners, faces, and
+        allowed transformations.
+
+        The corners/vertices are entered as a list of arbitrary
+        expressions that are used to identify each vertex.
+
+        The faces are entered as a list of tuples of indices; a tuple
+        of indices identifies the vertices which define the face. They
+        should be entered in a cw or ccw order; they will be standardized
+        by reversal and rotation to be give the lowest lexical ordering.
+        If no faces are given then no edges will be computed.
+
+            >>> from sympy.combinatorics.polyhedron import Polyhedron
+            >>> Polyhedron(list('abc'), [(1, 2, 0)]).faces
+            {(0, 1, 2)}
+            >>> Polyhedron(list('abc'), [(1, 0, 2)]).faces
+            {(0, 1, 2)}
+
+        The allowed transformations are entered as allowable permutations
+        of the vertices for the polyhedron. Instance of Permutations
+        (as with faces) should refer to the supplied vertices by index.
+        These permutation are stored as a PermutationGroup.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.permutations import Permutation
+        >>> from sympy import init_printing
+        >>> from sympy.abc import w, x, y, z
+        >>> init_printing(pretty_print=False, perm_cyclic=False)
+
+        Here we construct the Polyhedron object for a tetrahedron.
+
+        >>> corners = [w, x, y, z]
+        >>> faces = [(0, 1, 2), (0, 2, 3), (0, 3, 1), (1, 2, 3)]
+
+        Next, allowed transformations of the polyhedron must be given. This
+        is given as permutations of vertices.
+
+        Although the vertices of a tetrahedron can be numbered in 24 (4!)
+        different ways, there are only 12 different orientations for a
+        physical tetrahedron. The following permutations, applied once or
+        twice, will generate all 12 of the orientations. (The identity
+        permutation, Permutation(range(4)), is not included since it does
+        not change the orientation of the vertices.)
+
+        >>> pgroup = [Permutation([[0, 1, 2], [3]]), \
+                      Permutation([[0, 1, 3], [2]]), \
+                      Permutation([[0, 2, 3], [1]]), \
+                      Permutation([[1, 2, 3], [0]]), \
+                      Permutation([[0, 1], [2, 3]]), \
+                      Permutation([[0, 2], [1, 3]]), \
+                      Permutation([[0, 3], [1, 2]])]
+
+        The Polyhedron is now constructed and demonstrated:
+
+        >>> tetra = Polyhedron(corners, faces, pgroup)
+        >>> tetra.size
+        4
+        >>> tetra.edges
+        {(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)}
+        >>> tetra.corners
+        (w, x, y, z)
+
+        It can be rotated with an arbitrary permutation of vertices, e.g.
+        the following permutation is not in the pgroup:
+
+        >>> tetra.rotate(Permutation([0, 1, 3, 2]))
+        >>> tetra.corners
+        (w, x, z, y)
+
+        An allowed permutation of the vertices can be constructed by
+        repeatedly applying permutations from the pgroup to the vertices.
+        Here is a demonstration that applying p and p**2 for every p in
+        pgroup generates all the orientations of a tetrahedron and no others:
+
+        >>> all = ( (w, x, y, z), \
+                    (x, y, w, z), \
+                    (y, w, x, z), \
+                    (w, z, x, y), \
+                    (z, w, y, x), \
+                    (w, y, z, x), \
+                    (y, z, w, x), \
+                    (x, z, y, w), \
+                    (z, y, x, w), \
+                    (y, x, z, w), \
+                    (x, w, z, y), \
+                    (z, x, w, y) )
+
+        >>> got = []
+        >>> for p in (pgroup + [p**2 for p in pgroup]):
+        ...     h = Polyhedron(corners)
+        ...     h.rotate(p)
+        ...     got.append(h.corners)
+        ...
+        >>> set(got) == set(all)
+        True
+
+        The make_perm method of a PermutationGroup will randomly pick
+        permutations, multiply them together, and return the permutation that
+        can be applied to the polyhedron to give the orientation produced
+        by those individual permutations.
+
+        Here, 3 permutations are used:
+
+        >>> tetra.pgroup.make_perm(3) # doctest: +SKIP
+        Permutation([0, 3, 1, 2])
+
+        To select the permutations that should be used, supply a list
+        of indices to the permutations in pgroup in the order they should
+        be applied:
+
+        >>> use = [0, 0, 2]
+        >>> p002 = tetra.pgroup.make_perm(3, use)
+        >>> p002
+        Permutation([1, 0, 3, 2])
+
+
+        Apply them one at a time:
+
+        >>> tetra.reset()
+        >>> for i in use:
+        ...     tetra.rotate(pgroup[i])
+        ...
+        >>> tetra.vertices
+        (x, w, z, y)
+        >>> sequentially = tetra.vertices
+
+        Apply the composite permutation:
+
+        >>> tetra.reset()
+        >>> tetra.rotate(p002)
+        >>> tetra.corners
+        (x, w, z, y)
+        >>> tetra.corners in all and tetra.corners == sequentially
+        True
+
+        Notes
+        =====
+
+        Defining permutation groups
+        ---------------------------
+
+        It is not necessary to enter any permutations, nor is necessary to
+        enter a complete set of transformations. In fact, for a polyhedron,
+        all configurations can be constructed from just two permutations.
+        For example, the orientations of a tetrahedron can be generated from
+        an axis passing through a vertex and face and another axis passing
+        through a different vertex or from an axis passing through the
+        midpoints of two edges opposite of each other.
+
+        For simplicity of presentation, consider a square --
+        not a cube -- with vertices 1, 2, 3, and 4:
+
+        1-----2  We could think of axes of rotation being:
+        |     |  1) through the face
+        |     |  2) from midpoint 1-2 to 3-4 or 1-3 to 2-4
+        3-----4  3) lines 1-4 or 2-3
+
+
+        To determine how to write the permutations, imagine 4 cameras,
+        one at each corner, labeled A-D:
+
+        A       B          A       B
+         1-----2            1-----3             vertex index:
+         |     |            |     |                 1   0
+         |     |            |     |                 2   1
+         3-----4            2-----4                 3   2
+        C       D          C       D                4   3
+
+        original           after rotation
+                           along 1-4
+
+        A diagonal and a face axis will be chosen for the "permutation group"
+        from which any orientation can be constructed.
+
+        >>> pgroup = []
+
+        Imagine a clockwise rotation when viewing 1-4 from camera A. The new
+        orientation is (in camera-order): 1, 3, 2, 4 so the permutation is
+        given using the *indices* of the vertices as:
+
+        >>> pgroup.append(Permutation((0, 2, 1, 3)))
+
+        Now imagine rotating clockwise when looking down an axis entering the
+        center of the square as viewed. The new camera-order would be
+        3, 1, 4, 2 so the permutation is (using indices):
+
+        >>> pgroup.append(Permutation((2, 0, 3, 1)))
+
+        The square can now be constructed:
+            ** use real-world labels for the vertices, entering them in
+               camera order
+            ** for the faces we use zero-based indices of the vertices
+               in *edge-order* as the face is traversed; neither the
+               direction nor the starting point matter -- the faces are
+               only used to define edges (if so desired).
+
+        >>> square = Polyhedron((1, 2, 3, 4), [(0, 1, 3, 2)], pgroup)
+
+        To rotate the square with a single permutation we can do:
+
+        >>> square.rotate(square.pgroup[0])
+        >>> square.corners
+        (1, 3, 2, 4)
+
+        To use more than one permutation (or to use one permutation more
+        than once) it is more convenient to use the make_perm method:
+
+        >>> p011 = square.pgroup.make_perm([0, 1, 1]) # diag flip + 2 rotations
+        >>> square.reset() # return to initial orientation
+        >>> square.rotate(p011)
+        >>> square.corners
+        (4, 2, 3, 1)
+
+        Thinking outside the box
+        ------------------------
+
+        Although the Polyhedron object has a direct physical meaning, it
+        actually has broader application. In the most general sense it is
+        just a decorated PermutationGroup, allowing one to connect the
+        permutations to something physical. For example, a Rubik's cube is
+        not a proper polyhedron, but the Polyhedron class can be used to
+        represent it in a way that helps to visualize the Rubik's cube.
+
+        >>> from sympy import flatten, unflatten, symbols
+        >>> from sympy.combinatorics import RubikGroup
+        >>> facelets = flatten([symbols(s+'1:5') for s in 'UFRBLD'])
+        >>> def show():
+        ...     pairs = unflatten(r2.corners, 2)
+        ...     print(pairs[::2])
+        ...     print(pairs[1::2])
+        ...
+        >>> r2 = Polyhedron(facelets, pgroup=RubikGroup(2))
+        >>> show()
+        [(U1, U2), (F1, F2), (R1, R2), (B1, B2), (L1, L2), (D1, D2)]
+        [(U3, U4), (F3, F4), (R3, R4), (B3, B4), (L3, L4), (D3, D4)]
+        >>> r2.rotate(0) # cw rotation of F
+        >>> show()
+        [(U1, U2), (F3, F1), (U3, R2), (B1, B2), (L1, D1), (R3, R1)]
+        [(L4, L2), (F4, F2), (U4, R4), (B3, B4), (L3, D2), (D3, D4)]
+
+        Predefined Polyhedra
+        ====================
+
+        For convenience, the vertices and faces are defined for the following
+        standard solids along with a permutation group for transformations.
+        When the polyhedron is oriented as indicated below, the vertices in
+        a given horizontal plane are numbered in ccw direction, starting from
+        the vertex that will give the lowest indices in a given face. (In the
+        net of the vertices, indices preceded by "-" indicate replication of
+        the lhs index in the net.)
+
+        tetrahedron, tetrahedron_faces
+        ------------------------------
+
+            4 vertices (vertex up) net:
+
+                 0 0-0
+                1 2 3-1
+
+            4 faces:
+
+            (0, 1, 2) (0, 2, 3) (0, 3, 1) (1, 2, 3)
+
+        cube, cube_faces
+        ----------------
+
+            8 vertices (face up) net:
+
+                0 1 2 3-0
+                4 5 6 7-4
+
+            6 faces:
+
+            (0, 1, 2, 3)
+            (0, 1, 5, 4) (1, 2, 6, 5) (2, 3, 7, 6) (0, 3, 7, 4)
+            (4, 5, 6, 7)
+
+        octahedron, octahedron_faces
+        ----------------------------
+
+            6 vertices (vertex up) net:
+
+                 0 0 0-0
+                1 2 3 4-1
+                 5 5 5-5
+
+            8 faces:
+
+            (0, 1, 2) (0, 2, 3) (0, 3, 4) (0, 1, 4)
+            (1, 2, 5) (2, 3, 5) (3, 4, 5) (1, 4, 5)
+
+        dodecahedron, dodecahedron_faces
+        --------------------------------
+
+            20 vertices (vertex up) net:
+
+                  0  1  2  3  4 -0
+                  5  6  7  8  9 -5
+                14 10 11 12 13-14
+                15 16 17 18 19-15
+
+            12 faces:
+
+            (0, 1, 2, 3, 4) (0, 1, 6, 10, 5) (1, 2, 7, 11, 6)
+            (2, 3, 8, 12, 7) (3, 4, 9, 13, 8) (0, 4, 9, 14, 5)
+            (5, 10, 16, 15, 14) (6, 10, 16, 17, 11) (7, 11, 17, 18, 12)
+            (8, 12, 18, 19, 13) (9, 13, 19, 15, 14)(15, 16, 17, 18, 19)
+
+        icosahedron, icosahedron_faces
+        ------------------------------
+
+            12 vertices (face up) net:
+
+                 0  0  0  0 -0
+                1  2  3  4  5 -1
+                 6  7  8  9  10 -6
+                  11 11 11 11 -11
+
+            20 faces:
+
+            (0, 1, 2) (0, 2, 3) (0, 3, 4)
+            (0, 4, 5) (0, 1, 5) (1, 2, 6)
+            (2, 3, 7) (3, 4, 8) (4, 5, 9)
+            (1, 5, 10) (2, 6, 7) (3, 7, 8)
+            (4, 8, 9) (5, 9, 10) (1, 6, 10)
+            (6, 7, 11) (7, 8, 11) (8, 9, 11)
+            (9, 10, 11) (6, 10, 11)
+
+        >>> from sympy.combinatorics.polyhedron import cube
+        >>> cube.edges
+        {(0, 1), (0, 3), (0, 4), (1, 2), (1, 5), (2, 3), (2, 6), (3, 7), (4, 5), (4, 7), (5, 6), (6, 7)}
+
+        If you want to use letters or other names for the corners you
+        can still use the pre-calculated faces:
+
+        >>> corners = list('abcdefgh')
+        >>> Polyhedron(corners, cube.faces).corners
+        (a, b, c, d, e, f, g, h)
+
+        References
+        ==========
+
+        .. [1] www.ocf.berkeley.edu/~wwu/articles/platonicsolids.pdf
+
+        """
+        faces = [minlex(f, directed=False, key=default_sort_key) for f in faces]
+        corners, faces, pgroup = args = \
+            [Tuple(*a) for a in (corners, faces, pgroup)]
+        obj = Basic.__new__(cls, *args)
+        obj._corners = tuple(corners)  # in order given
+        obj._faces = FiniteSet(*faces)
+        if pgroup and pgroup[0].size != len(corners):
+            raise ValueError("Permutation size unequal to number of corners.")
+        # use the identity permutation if none are given
+        obj._pgroup = PermutationGroup(
+            pgroup or [Perm(range(len(corners)))] )
+        return obj
+
+    @property
+    def corners(self):
+        """
+        Get the corners of the Polyhedron.
+
+        The method ``vertices`` is an alias for ``corners``.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Polyhedron
+        >>> from sympy.abc import a, b, c, d
+        >>> p = Polyhedron(list('abcd'))
+        >>> p.corners == p.vertices == (a, b, c, d)
+        True
+
+        See Also
+        ========
+
+        array_form, cyclic_form
+        """
+        return self._corners
+    vertices = corners
+
+    @property
+    def array_form(self):
+        """Return the indices of the corners.
+
+        The indices are given relative to the original position of corners.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.polyhedron import tetrahedron
+        >>> tetrahedron = tetrahedron.copy()
+        >>> tetrahedron.array_form
+        [0, 1, 2, 3]
+
+        >>> tetrahedron.rotate(0)
+        >>> tetrahedron.array_form
+        [0, 2, 3, 1]
+        >>> tetrahedron.pgroup[0].array_form
+        [0, 2, 3, 1]
+
+        See Also
+        ========
+
+        corners, cyclic_form
+        """
+        corners = list(self.args[0])
+        return [corners.index(c) for c in self.corners]
+
+    @property
+    def cyclic_form(self):
+        """Return the indices of the corners in cyclic notation.
+
+        The indices are given relative to the original position of corners.
+
+        See Also
+        ========
+
+        corners, array_form
+        """
+        return Perm._af_new(self.array_form).cyclic_form
+
+    @property
+    def size(self):
+        """
+        Get the number of corners of the Polyhedron.
+        """
+        return len(self._corners)
+
+    @property
+    def faces(self):
+        """
+        Get the faces of the Polyhedron.
+        """
+        return self._faces
+
+    @property
+    def pgroup(self):
+        """
+        Get the permutations of the Polyhedron.
+        """
+        return self._pgroup
+
+    @property
+    def edges(self):
+        """
+        Given the faces of the polyhedra we can get the edges.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Polyhedron
+        >>> from sympy.abc import a, b, c
+        >>> corners = (a, b, c)
+        >>> faces = [(0, 1, 2)]
+        >>> Polyhedron(corners, faces).edges
+        {(0, 1), (0, 2), (1, 2)}
+
+        """
+        if self._edges is None:
+            output = set()
+            for face in self.faces:
+                for i in range(len(face)):
+                    edge = tuple(sorted([face[i], face[i - 1]]))
+                    output.add(edge)
+            self._edges = FiniteSet(*output)
+        return self._edges
+
+    def rotate(self, perm):
+        """
+        Apply a permutation to the polyhedron *in place*. The permutation
+        may be given as a Permutation instance or an integer indicating
+        which permutation from pgroup of the Polyhedron should be
+        applied.
+
+        This is an operation that is analogous to rotation about
+        an axis by a fixed increment.
+
+        Notes
+        =====
+
+        When a Permutation is applied, no check is done to see if that
+        is a valid permutation for the Polyhedron. For example, a cube
+        could be given a permutation which effectively swaps only 2
+        vertices. A valid permutation (that rotates the object in a
+        physical way) will be obtained if one only uses
+        permutations from the ``pgroup`` of the Polyhedron. On the other
+        hand, allowing arbitrary rotations (applications of permutations)
+        gives a way to follow named elements rather than indices since
+        Polyhedron allows vertices to be named while Permutation works
+        only with indices.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Polyhedron, Permutation
+        >>> from sympy.combinatorics.polyhedron import cube
+        >>> cube = cube.copy()
+        >>> cube.corners
+        (0, 1, 2, 3, 4, 5, 6, 7)
+        >>> cube.rotate(0)
+        >>> cube.corners
+        (1, 2, 3, 0, 5, 6, 7, 4)
+
+        A non-physical "rotation" that is not prohibited by this method:
+
+        >>> cube.reset()
+        >>> cube.rotate(Permutation([[1, 2]], size=8))
+        >>> cube.corners
+        (0, 2, 1, 3, 4, 5, 6, 7)
+
+        Polyhedron can be used to follow elements of set that are
+        identified by letters instead of integers:
+
+        >>> shadow = h5 = Polyhedron(list('abcde'))
+        >>> p = Permutation([3, 0, 1, 2, 4])
+        >>> h5.rotate(p)
+        >>> h5.corners
+        (d, a, b, c, e)
+        >>> _ == shadow.corners
+        True
+        >>> copy = h5.copy()
+        >>> h5.rotate(p)
+        >>> h5.corners == copy.corners
+        False
+        """
+        if not isinstance(perm, Perm):
+            perm = self.pgroup[perm]
+            # and we know it's valid
+        else:
+            if perm.size != self.size:
+                raise ValueError('Polyhedron and Permutation sizes differ.')
+        a = perm.array_form
+        corners = [self.corners[a[i]] for i in range(len(self.corners))]
+        self._corners = tuple(corners)
+
+    def reset(self):
+        """Return corners to their original positions.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.polyhedron import tetrahedron as T
+        >>> T = T.copy()
+        >>> T.corners
+        (0, 1, 2, 3)
+        >>> T.rotate(0)
+        >>> T.corners
+        (0, 2, 3, 1)
+        >>> T.reset()
+        >>> T.corners
+        (0, 1, 2, 3)
+        """
+        self._corners = self.args[0]
+
+
+def _pgroup_calcs():
+    """Return the permutation groups for each of the polyhedra and the face
+    definitions: tetrahedron, cube, octahedron, dodecahedron, icosahedron,
+    tetrahedron_faces, cube_faces, octahedron_faces, dodecahedron_faces,
+    icosahedron_faces
+
+    Explanation
+    ===========
+
+    (This author did not find and did not know of a better way to do it though
+    there likely is such a way.)
+
+    Although only 2 permutations are needed for a polyhedron in order to
+    generate all the possible orientations, a group of permutations is
+    provided instead. A set of permutations is called a "group" if::
+
+    a*b = c (for any pair of permutations in the group, a and b, their
+    product, c, is in the group)
+
+    a*(b*c) = (a*b)*c (for any 3 permutations in the group associativity holds)
+
+    there is an identity permutation, I, such that I*a = a*I for all elements
+    in the group
+
+    a*b = I (the inverse of each permutation is also in the group)
+
+    None of the polyhedron groups defined follow these definitions of a group.
+    Instead, they are selected to contain those permutations whose powers
+    alone will construct all orientations of the polyhedron, i.e. for
+    permutations ``a``, ``b``, etc... in the group, ``a, a**2, ..., a**o_a``,
+    ``b, b**2, ..., b**o_b``, etc... (where ``o_i`` is the order of
+    permutation ``i``) generate all permutations of the polyhedron instead of
+    mixed products like ``a*b``, ``a*b**2``, etc....
+
+    Note that for a polyhedron with n vertices, the valid permutations of the
+    vertices exclude those that do not maintain its faces. e.g. the
+    permutation BCDE of a square's four corners, ABCD, is a valid
+    permutation while CBDE is not (because this would twist the square).
+
+    Examples
+    ========
+
+    The is_group checks for: closure, the presence of the Identity permutation,
+    and the presence of the inverse for each of the elements in the group. This
+    confirms that none of the polyhedra are true groups:
+
+    >>> from sympy.combinatorics.polyhedron import (
+    ... tetrahedron, cube, octahedron, dodecahedron, icosahedron)
+    ...
+    >>> polyhedra = (tetrahedron, cube, octahedron, dodecahedron, icosahedron)
+    >>> [h.pgroup.is_group for h in polyhedra]
+    ...
+    [True, True, True, True, True]
+
+    Although tests in polyhedron's test suite check that powers of the
+    permutations in the groups generate all permutations of the vertices
+    of the polyhedron, here we also demonstrate the powers of the given
+    permutations create a complete group for the tetrahedron:
+
+    >>> from sympy.combinatorics import Permutation, PermutationGroup
+    >>> for h in polyhedra[:1]:
+    ...     G = h.pgroup
+    ...     perms = set()
+    ...     for g in G:
+    ...         for e in range(g.order()):
+    ...             p = tuple((g**e).array_form)
+    ...             perms.add(p)
+    ...
+    ...     perms = [Permutation(p) for p in perms]
+    ...     assert PermutationGroup(perms).is_group
+
+    In addition to doing the above, the tests in the suite confirm that the
+    faces are all present after the application of each permutation.
+
+    References
+    ==========
+
+    .. [1] https://dogschool.tripod.com/trianglegroup.html
+
+    """
+    def _pgroup_of_double(polyh, ordered_faces, pgroup):
+        n = len(ordered_faces[0])
+        # the vertices of the double which sits inside a give polyhedron
+        # can be found by tracking the faces of the outer polyhedron.
+        # A map between face and the vertex of the double is made so that
+        # after rotation the position of the vertices can be located
+        fmap = dict(zip(ordered_faces,
+                        range(len(ordered_faces))))
+        flat_faces = flatten(ordered_faces)
+        new_pgroup = []
+        for p in pgroup:
+            h = polyh.copy()
+            h.rotate(p)
+            c = h.corners
+            # reorder corners in the order they should appear when
+            # enumerating the faces
+            reorder = unflatten([c[j] for j in flat_faces], n)
+            # make them canonical
+            reorder = [tuple(map(as_int,
+                       minlex(f, directed=False)))
+                       for f in reorder]
+            # map face to vertex: the resulting list of vertices are the
+            # permutation that we seek for the double
+            new_pgroup.append(Perm([fmap[f] for f in reorder]))
+        return new_pgroup
+
+    tetrahedron_faces = [
+        (0, 1, 2), (0, 2, 3), (0, 3, 1),  # upper 3
+        (1, 2, 3),  # bottom
+    ]
+
+    # cw from top
+    #
+    _t_pgroup = [
+        Perm([[1, 2, 3], [0]]),  # cw from top
+        Perm([[0, 1, 2], [3]]),  # cw from front face
+        Perm([[0, 3, 2], [1]]),  # cw from back right face
+        Perm([[0, 3, 1], [2]]),  # cw from back left face
+        Perm([[0, 1], [2, 3]]),  # through front left edge
+        Perm([[0, 2], [1, 3]]),  # through front right edge
+        Perm([[0, 3], [1, 2]]),  # through back edge
+    ]
+
+    tetrahedron = Polyhedron(
+        range(4),
+        tetrahedron_faces,
+        _t_pgroup)
+
+    cube_faces = [
+        (0, 1, 2, 3),  # upper
+        (0, 1, 5, 4), (1, 2, 6, 5), (2, 3, 7, 6), (0, 3, 7, 4),  # middle 4
+        (4, 5, 6, 7),  # lower
+    ]
+
+    # U, D, F, B, L, R = up, down, front, back, left, right
+    _c_pgroup = [Perm(p) for p in
+        [
+        [1, 2, 3, 0, 5, 6, 7, 4],  # cw from top, U
+        [4, 0, 3, 7, 5, 1, 2, 6],  # cw from F face
+        [4, 5, 1, 0, 7, 6, 2, 3],  # cw from R face
+
+        [1, 0, 4, 5, 2, 3, 7, 6],  # cw through UF edge
+        [6, 2, 1, 5, 7, 3, 0, 4],  # cw through UR edge
+        [6, 7, 3, 2, 5, 4, 0, 1],  # cw through UB edge
+        [3, 7, 4, 0, 2, 6, 5, 1],  # cw through UL edge
+        [4, 7, 6, 5, 0, 3, 2, 1],  # cw through FL edge
+        [6, 5, 4, 7, 2, 1, 0, 3],  # cw through FR edge
+
+        [0, 3, 7, 4, 1, 2, 6, 5],  # cw through UFL vertex
+        [5, 1, 0, 4, 6, 2, 3, 7],  # cw through UFR vertex
+        [5, 6, 2, 1, 4, 7, 3, 0],  # cw through UBR vertex
+        [7, 4, 0, 3, 6, 5, 1, 2],  # cw through UBL
+        ]]
+
+    cube = Polyhedron(
+        range(8),
+        cube_faces,
+        _c_pgroup)
+
+    octahedron_faces = [
+        (0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 1, 4),  # top 4
+        (1, 2, 5), (2, 3, 5), (3, 4, 5), (1, 4, 5),  # bottom 4
+    ]
+
+    octahedron = Polyhedron(
+        range(6),
+        octahedron_faces,
+        _pgroup_of_double(cube, cube_faces, _c_pgroup))
+
+    dodecahedron_faces = [
+        (0, 1, 2, 3, 4),  # top
+        (0, 1, 6, 10, 5), (1, 2, 7, 11, 6), (2, 3, 8, 12, 7),  # upper 5
+        (3, 4, 9, 13, 8), (0, 4, 9, 14, 5),
+        (5, 10, 16, 15, 14), (6, 10, 16, 17, 11), (7, 11, 17, 18,
+          12),  # lower 5
+        (8, 12, 18, 19, 13), (9, 13, 19, 15, 14),
+        (15, 16, 17, 18, 19)  # bottom
+    ]
+
+    def _string_to_perm(s):
+        rv = [Perm(range(20))]
+        p = None
+        for si in s:
+            if si not in '01':
+                count = int(si) - 1
+            else:
+                count = 1
+                if si == '0':
+                    p = _f0
+                elif si == '1':
+                    p = _f1
+            rv.extend([p]*count)
+        return Perm.rmul(*rv)
+
+    # top face cw
+    _f0 = Perm([
+        1, 2, 3, 4, 0, 6, 7, 8, 9, 5, 11,
+        12, 13, 14, 10, 16, 17, 18, 19, 15])
+    # front face cw
+    _f1 = Perm([
+        5, 0, 4, 9, 14, 10, 1, 3, 13, 15,
+        6, 2, 8, 19, 16, 17, 11, 7, 12, 18])
+    # the strings below, like 0104 are shorthand for F0*F1*F0**4 and are
+    # the remaining 4 face rotations, 15 edge permutations, and the
+    # 10 vertex rotations.
+    _dodeca_pgroup = [_f0, _f1] + [_string_to_perm(s) for s in '''
+    0104 140 014 0410
+    010 1403 03104 04103 102
+    120 1304 01303 021302 03130
+    0412041 041204103 04120410 041204104 041204102
+    10 01 1402 0140 04102 0412 1204 1302 0130 03120'''.strip().split()]
+
+    dodecahedron = Polyhedron(
+        range(20),
+        dodecahedron_faces,
+        _dodeca_pgroup)
+
+    icosahedron_faces = [
+        (0, 1, 2), (0, 2, 3), (0, 3, 4), (0, 4, 5), (0, 1, 5),
+        (1, 6, 7), (1, 2, 7), (2, 7, 8), (2, 3, 8), (3, 8, 9),
+        (3, 4, 9), (4, 9, 10), (4, 5, 10), (5, 6, 10), (1, 5, 6),
+        (6, 7, 11), (7, 8, 11), (8, 9, 11), (9, 10, 11), (6, 10, 11)]
+
+    icosahedron = Polyhedron(
+        range(12),
+        icosahedron_faces,
+        _pgroup_of_double(
+            dodecahedron, dodecahedron_faces, _dodeca_pgroup))
+
+    return (tetrahedron, cube, octahedron, dodecahedron, icosahedron,
+        tetrahedron_faces, cube_faces, octahedron_faces,
+        dodecahedron_faces, icosahedron_faces)
+
+# -----------------------------------------------------------------------
+#   Standard Polyhedron groups
+#
+#   These are generated using _pgroup_calcs() above. However to save
+#   import time we encode them explicitly here.
+# -----------------------------------------------------------------------
+
+tetrahedron = Polyhedron(
+    Tuple(0, 1, 2, 3),
+    Tuple(
+        Tuple(0, 1, 2),
+        Tuple(0, 2, 3),
+        Tuple(0, 1, 3),
+        Tuple(1, 2, 3)),
+    Tuple(
+        Perm(1, 2, 3),
+        Perm(3)(0, 1, 2),
+        Perm(0, 3, 2),
+        Perm(0, 3, 1),
+        Perm(0, 1)(2, 3),
+        Perm(0, 2)(1, 3),
+        Perm(0, 3)(1, 2)
+    ))
+
+cube = Polyhedron(
+    Tuple(0, 1, 2, 3, 4, 5, 6, 7),
+    Tuple(
+        Tuple(0, 1, 2, 3),
+        Tuple(0, 1, 5, 4),
+        Tuple(1, 2, 6, 5),
+        Tuple(2, 3, 7, 6),
+        Tuple(0, 3, 7, 4),
+        Tuple(4, 5, 6, 7)),
+    Tuple(
+        Perm(0, 1, 2, 3)(4, 5, 6, 7),
+        Perm(0, 4, 5, 1)(2, 3, 7, 6),
+        Perm(0, 4, 7, 3)(1, 5, 6, 2),
+        Perm(0, 1)(2, 4)(3, 5)(6, 7),
+        Perm(0, 6)(1, 2)(3, 5)(4, 7),
+        Perm(0, 6)(1, 7)(2, 3)(4, 5),
+        Perm(0, 3)(1, 7)(2, 4)(5, 6),
+        Perm(0, 4)(1, 7)(2, 6)(3, 5),
+        Perm(0, 6)(1, 5)(2, 4)(3, 7),
+        Perm(1, 3, 4)(2, 7, 5),
+        Perm(7)(0, 5, 2)(3, 4, 6),
+        Perm(0, 5, 7)(1, 6, 3),
+        Perm(0, 7, 2)(1, 4, 6)))
+
+octahedron = Polyhedron(
+    Tuple(0, 1, 2, 3, 4, 5),
+    Tuple(
+        Tuple(0, 1, 2),
+        Tuple(0, 2, 3),
+        Tuple(0, 3, 4),
+        Tuple(0, 1, 4),
+        Tuple(1, 2, 5),
+        Tuple(2, 3, 5),
+        Tuple(3, 4, 5),
+        Tuple(1, 4, 5)),
+    Tuple(
+        Perm(5)(1, 2, 3, 4),
+        Perm(0, 4, 5, 2),
+        Perm(0, 1, 5, 3),
+        Perm(0, 1)(2, 4)(3, 5),
+        Perm(0, 2)(1, 3)(4, 5),
+        Perm(0, 3)(1, 5)(2, 4),
+        Perm(0, 4)(1, 3)(2, 5),
+        Perm(0, 5)(1, 4)(2, 3),
+        Perm(0, 5)(1, 2)(3, 4),
+        Perm(0, 4, 1)(2, 3, 5),
+        Perm(0, 1, 2)(3, 4, 5),
+        Perm(0, 2, 3)(1, 5, 4),
+        Perm(0, 4, 3)(1, 5, 2)))
+
+dodecahedron = Polyhedron(
+    Tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+    Tuple(
+        Tuple(0, 1, 2, 3, 4),
+        Tuple(0, 1, 6, 10, 5),
+        Tuple(1, 2, 7, 11, 6),
+        Tuple(2, 3, 8, 12, 7),
+        Tuple(3, 4, 9, 13, 8),
+        Tuple(0, 4, 9, 14, 5),
+        Tuple(5, 10, 16, 15, 14),
+        Tuple(6, 10, 16, 17, 11),
+        Tuple(7, 11, 17, 18, 12),
+        Tuple(8, 12, 18, 19, 13),
+        Tuple(9, 13, 19, 15, 14),
+        Tuple(15, 16, 17, 18, 19)),
+    Tuple(
+        Perm(0, 1, 2, 3, 4)(5, 6, 7, 8, 9)(10, 11, 12, 13, 14)(15, 16, 17, 18, 19),
+        Perm(0, 5, 10, 6, 1)(2, 4, 14, 16, 11)(3, 9, 15, 17, 7)(8, 13, 19, 18, 12),
+        Perm(0, 10, 17, 12, 3)(1, 6, 11, 7, 2)(4, 5, 16, 18, 8)(9, 14, 15, 19, 13),
+        Perm(0, 6, 17, 19, 9)(1, 11, 18, 13, 4)(2, 7, 12, 8, 3)(5, 10, 16, 15, 14),
+        Perm(0, 2, 12, 19, 14)(1, 7, 18, 15, 5)(3, 8, 13, 9, 4)(6, 11, 17, 16, 10),
+        Perm(0, 4, 9, 14, 5)(1, 3, 13, 15, 10)(2, 8, 19, 16, 6)(7, 12, 18, 17, 11),
+        Perm(0, 1)(2, 5)(3, 10)(4, 6)(7, 14)(8, 16)(9, 11)(12, 15)(13, 17)(18, 19),
+        Perm(0, 7)(1, 2)(3, 6)(4, 11)(5, 12)(8, 10)(9, 17)(13, 16)(14, 18)(15, 19),
+        Perm(0, 12)(1, 8)(2, 3)(4, 7)(5, 18)(6, 13)(9, 11)(10, 19)(14, 17)(15, 16),
+        Perm(0, 8)(1, 13)(2, 9)(3, 4)(5, 12)(6, 19)(7, 14)(10, 18)(11, 15)(16, 17),
+        Perm(0, 4)(1, 9)(2, 14)(3, 5)(6, 13)(7, 15)(8, 10)(11, 19)(12, 16)(17, 18),
+        Perm(0, 5)(1, 14)(2, 15)(3, 16)(4, 10)(6, 9)(7, 19)(8, 17)(11, 13)(12, 18),
+        Perm(0, 11)(1, 6)(2, 10)(3, 16)(4, 17)(5, 7)(8, 15)(9, 18)(12, 14)(13, 19),
+        Perm(0, 18)(1, 12)(2, 7)(3, 11)(4, 17)(5, 19)(6, 8)(9, 16)(10, 13)(14, 15),
+        Perm(0, 18)(1, 19)(2, 13)(3, 8)(4, 12)(5, 17)(6, 15)(7, 9)(10, 16)(11, 14),
+        Perm(0, 13)(1, 19)(2, 15)(3, 14)(4, 9)(5, 8)(6, 18)(7, 16)(10, 12)(11, 17),
+        Perm(0, 16)(1, 15)(2, 19)(3, 18)(4, 17)(5, 10)(6, 14)(7, 13)(8, 12)(9, 11),
+        Perm(0, 18)(1, 17)(2, 16)(3, 15)(4, 19)(5, 12)(6, 11)(7, 10)(8, 14)(9, 13),
+        Perm(0, 15)(1, 19)(2, 18)(3, 17)(4, 16)(5, 14)(6, 13)(7, 12)(8, 11)(9, 10),
+        Perm(0, 17)(1, 16)(2, 15)(3, 19)(4, 18)(5, 11)(6, 10)(7, 14)(8, 13)(9, 12),
+        Perm(0, 19)(1, 18)(2, 17)(3, 16)(4, 15)(5, 13)(6, 12)(7, 11)(8, 10)(9, 14),
+        Perm(1, 4, 5)(2, 9, 10)(3, 14, 6)(7, 13, 16)(8, 15, 11)(12, 19, 17),
+        Perm(19)(0, 6, 2)(3, 5, 11)(4, 10, 7)(8, 14, 17)(9, 16, 12)(13, 15, 18),
+        Perm(0, 11, 8)(1, 7, 3)(4, 6, 12)(5, 17, 13)(9, 10, 18)(14, 16, 19),
+        Perm(0, 7, 13)(1, 12, 9)(2, 8, 4)(5, 11, 19)(6, 18, 14)(10, 17, 15),
+        Perm(0, 3, 9)(1, 8, 14)(2, 13, 5)(6, 12, 15)(7, 19, 10)(11, 18, 16),
+        Perm(0, 14, 10)(1, 9, 16)(2, 13, 17)(3, 19, 11)(4, 15, 6)(7, 8, 18),
+        Perm(0, 16, 7)(1, 10, 11)(2, 5, 17)(3, 14, 18)(4, 15, 12)(8, 9, 19),
+        Perm(0, 16, 13)(1, 17, 8)(2, 11, 12)(3, 6, 18)(4, 10, 19)(5, 15, 9),
+        Perm(0, 11, 15)(1, 17, 14)(2, 18, 9)(3, 12, 13)(4, 7, 19)(5, 6, 16),
+        Perm(0, 8, 15)(1, 12, 16)(2, 18, 10)(3, 19, 5)(4, 13, 14)(6, 7, 17)))
+
+icosahedron = Polyhedron(
+    Tuple(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11),
+    Tuple(
+        Tuple(0, 1, 2),
+        Tuple(0, 2, 3),
+        Tuple(0, 3, 4),
+        Tuple(0, 4, 5),
+        Tuple(0, 1, 5),
+        Tuple(1, 6, 7),
+        Tuple(1, 2, 7),
+        Tuple(2, 7, 8),
+        Tuple(2, 3, 8),
+        Tuple(3, 8, 9),
+        Tuple(3, 4, 9),
+        Tuple(4, 9, 10),
+        Tuple(4, 5, 10),
+        Tuple(5, 6, 10),
+        Tuple(1, 5, 6),
+        Tuple(6, 7, 11),
+        Tuple(7, 8, 11),
+        Tuple(8, 9, 11),
+        Tuple(9, 10, 11),
+        Tuple(6, 10, 11)),
+    Tuple(
+        Perm(11)(1, 2, 3, 4, 5)(6, 7, 8, 9, 10),
+        Perm(0, 5, 6, 7, 2)(3, 4, 10, 11, 8),
+        Perm(0, 1, 7, 8, 3)(4, 5, 6, 11, 9),
+        Perm(0, 2, 8, 9, 4)(1, 7, 11, 10, 5),
+        Perm(0, 3, 9, 10, 5)(1, 2, 8, 11, 6),
+        Perm(0, 4, 10, 6, 1)(2, 3, 9, 11, 7),
+        Perm(0, 1)(2, 5)(3, 6)(4, 7)(8, 10)(9, 11),
+        Perm(0, 2)(1, 3)(4, 7)(5, 8)(6, 9)(10, 11),
+        Perm(0, 3)(1, 9)(2, 4)(5, 8)(6, 11)(7, 10),
+        Perm(0, 4)(1, 9)(2, 10)(3, 5)(6, 8)(7, 11),
+        Perm(0, 5)(1, 4)(2, 10)(3, 6)(7, 9)(8, 11),
+        Perm(0, 6)(1, 5)(2, 10)(3, 11)(4, 7)(8, 9),
+        Perm(0, 7)(1, 2)(3, 6)(4, 11)(5, 8)(9, 10),
+        Perm(0, 8)(1, 9)(2, 3)(4, 7)(5, 11)(6, 10),
+        Perm(0, 9)(1, 11)(2, 10)(3, 4)(5, 8)(6, 7),
+        Perm(0, 10)(1, 9)(2, 11)(3, 6)(4, 5)(7, 8),
+        Perm(0, 11)(1, 6)(2, 10)(3, 9)(4, 8)(5, 7),
+        Perm(0, 11)(1, 8)(2, 7)(3, 6)(4, 10)(5, 9),
+        Perm(0, 11)(1, 10)(2, 9)(3, 8)(4, 7)(5, 6),
+        Perm(0, 11)(1, 7)(2, 6)(3, 10)(4, 9)(5, 8),
+        Perm(0, 11)(1, 9)(2, 8)(3, 7)(4, 6)(5, 10),
+        Perm(0, 5, 1)(2, 4, 6)(3, 10, 7)(8, 9, 11),
+        Perm(0, 1, 2)(3, 5, 7)(4, 6, 8)(9, 10, 11),
+        Perm(0, 2, 3)(1, 8, 4)(5, 7, 9)(6, 11, 10),
+        Perm(0, 3, 4)(1, 8, 10)(2, 9, 5)(6, 7, 11),
+        Perm(0, 4, 5)(1, 3, 10)(2, 9, 6)(7, 8, 11),
+        Perm(0, 10, 7)(1, 5, 6)(2, 4, 11)(3, 9, 8),
+        Perm(0, 6, 8)(1, 7, 2)(3, 5, 11)(4, 10, 9),
+        Perm(0, 7, 9)(1, 11, 4)(2, 8, 3)(5, 6, 10),
+        Perm(0, 8, 10)(1, 7, 6)(2, 11, 5)(3, 9, 4),
+        Perm(0, 9, 6)(1, 3, 11)(2, 8, 7)(4, 10, 5)))
+
+tetrahedron_faces = [tuple(arg) for arg in tetrahedron.faces]
+
+cube_faces = [tuple(arg) for arg in cube.faces]
+
+octahedron_faces = [tuple(arg) for arg in octahedron.faces]
+
+dodecahedron_faces = [tuple(arg) for arg in dodecahedron.faces]
+
+icosahedron_faces = [tuple(arg) for arg in icosahedron.faces]
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/prufer.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/prufer.py
new file mode 100644
index 0000000000000000000000000000000000000000..e389df87cddc0152b2376e18b9f3df2e94d3d2fb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/prufer.py
@@ -0,0 +1,435 @@
+from sympy.core import Basic
+from sympy.core.containers import Tuple
+from sympy.tensor.array import Array
+from sympy.core.sympify import _sympify
+from sympy.utilities.iterables import flatten, iterable
+from sympy.utilities.misc import as_int
+
+from collections import defaultdict
+
+
+class Prufer(Basic):
+    """
+    The Prufer correspondence is an algorithm that describes the
+    bijection between labeled trees and the Prufer code. A Prufer
+    code of a labeled tree is unique up to isomorphism and has
+    a length of n - 2.
+
+    Prufer sequences were first used by Heinz Prufer to give a
+    proof of Cayley's formula.
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/LabeledTree.html
+
+    """
+    _prufer_repr = None
+    _tree_repr = None
+    _nodes = None
+    _rank = None
+
+    @property
+    def prufer_repr(self):
+        """Returns Prufer sequence for the Prufer object.
+
+        This sequence is found by removing the highest numbered vertex,
+        recording the node it was attached to, and continuing until only
+        two vertices remain. The Prufer sequence is the list of recorded nodes.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).prufer_repr
+        [3, 3, 3, 4]
+        >>> Prufer([1, 0, 0]).prufer_repr
+        [1, 0, 0]
+
+        See Also
+        ========
+
+        to_prufer
+
+        """
+        if self._prufer_repr is None:
+            self._prufer_repr = self.to_prufer(self._tree_repr[:], self.nodes)
+        return self._prufer_repr
+
+    @property
+    def tree_repr(self):
+        """Returns the tree representation of the Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).tree_repr
+        [[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]
+        >>> Prufer([1, 0, 0]).tree_repr
+        [[1, 2], [0, 1], [0, 3], [0, 4]]
+
+        See Also
+        ========
+
+        to_tree
+
+        """
+        if self._tree_repr is None:
+            self._tree_repr = self.to_tree(self._prufer_repr[:])
+        return self._tree_repr
+
+    @property
+    def nodes(self):
+        """Returns the number of nodes in the tree.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]]).nodes
+        6
+        >>> Prufer([1, 0, 0]).nodes
+        5
+
+        """
+        return self._nodes
+
+    @property
+    def rank(self):
+        """Returns the rank of the Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> p = Prufer([[0, 3], [1, 3], [2, 3], [3, 4], [4, 5]])
+        >>> p.rank
+        778
+        >>> p.next(1).rank
+        779
+        >>> p.prev().rank
+        777
+
+        See Also
+        ========
+
+        prufer_rank, next, prev, size
+
+        """
+        if self._rank is None:
+            self._rank = self.prufer_rank()
+        return self._rank
+
+    @property
+    def size(self):
+        """Return the number of possible trees of this Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer([0]*4).size == Prufer([6]*4).size == 1296
+        True
+
+        See Also
+        ========
+
+        prufer_rank, rank, next, prev
+
+        """
+        return self.prev(self.rank).prev().rank + 1
+
+    @staticmethod
+    def to_prufer(tree, n):
+        """Return the Prufer sequence for a tree given as a list of edges where
+        ``n`` is the number of nodes in the tree.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_repr
+        [0, 0]
+        >>> Prufer.to_prufer([[0, 1], [0, 2], [0, 3]], 4)
+        [0, 0]
+
+        See Also
+        ========
+        prufer_repr: returns Prufer sequence of a Prufer object.
+
+        """
+        d = defaultdict(int)
+        L = []
+        for edge in tree:
+            # Increment the value of the corresponding
+            # node in the degree list as we encounter an
+            # edge involving it.
+            d[edge[0]] += 1
+            d[edge[1]] += 1
+        for i in range(n - 2):
+            # find the smallest leaf
+            for x in range(n):
+                if d[x] == 1:
+                    break
+            # find the node it was connected to
+            y = None
+            for edge in tree:
+                if x == edge[0]:
+                    y = edge[1]
+                elif x == edge[1]:
+                    y = edge[0]
+                if y is not None:
+                    break
+            # record and update
+            L.append(y)
+            for j in (x, y):
+                d[j] -= 1
+                if not d[j]:
+                    d.pop(j)
+            tree.remove(edge)
+        return L
+
+    @staticmethod
+    def to_tree(prufer):
+        """Return the tree (as a list of edges) of the given Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([0, 2], 4)
+        >>> a.tree_repr
+        [[0, 1], [0, 2], [2, 3]]
+        >>> Prufer.to_tree([0, 2])
+        [[0, 1], [0, 2], [2, 3]]
+
+        References
+        ==========
+
+        .. [1] https://hamberg.no/erlend/posts/2010-11-06-prufer-sequence-compact-tree-representation.html
+
+        See Also
+        ========
+        tree_repr: returns tree representation of a Prufer object.
+
+        """
+        tree = []
+        last = []
+        n = len(prufer) + 2
+        d = defaultdict(lambda: 1)
+        for p in prufer:
+            d[p] += 1
+        for i in prufer:
+            for j in range(n):
+            # find the smallest leaf (degree = 1)
+                if d[j] == 1:
+                    break
+            # (i, j) is the new edge that we append to the tree
+            # and remove from the degree dictionary
+            d[i] -= 1
+            d[j] -= 1
+            tree.append(sorted([i, j]))
+        last = [i for i in range(n) if d[i] == 1] or [0, 1]
+        tree.append(last)
+
+        return tree
+
+    @staticmethod
+    def edges(*runs):
+        """Return a list of edges and the number of nodes from the given runs
+        that connect nodes in an integer-labelled tree.
+
+        All node numbers will be shifted so that the minimum node is 0. It is
+        not a problem if edges are repeated in the runs; only unique edges are
+        returned. There is no assumption made about what the range of the node
+        labels should be, but all nodes from the smallest through the largest
+        must be present.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer.edges([1, 2, 3], [2, 4, 5]) # a T
+        ([[0, 1], [1, 2], [1, 3], [3, 4]], 5)
+
+        Duplicate edges are removed:
+
+        >>> Prufer.edges([0, 1, 2, 3], [1, 4, 5], [1, 4, 6]) # a K
+        ([[0, 1], [1, 2], [1, 4], [2, 3], [4, 5], [4, 6]], 7)
+
+        """
+        e = set()
+        nmin = runs[0][0]
+        for r in runs:
+            for i in range(len(r) - 1):
+                a, b = r[i: i + 2]
+                if b < a:
+                    a, b = b, a
+                e.add((a, b))
+        rv = []
+        got = set()
+        nmin = nmax = None
+        for ei in e:
+            got.update(ei)
+            nmin = min(ei[0], nmin) if nmin is not None else ei[0]
+            nmax = max(ei[1], nmax) if nmax is not None else ei[1]
+            rv.append(list(ei))
+        missing = set(range(nmin, nmax + 1)) - got
+        if missing:
+            missing = [i + nmin for i in missing]
+            if len(missing) == 1:
+                msg = 'Node %s is missing.' % missing.pop()
+            else:
+                msg = 'Nodes %s are missing.' % sorted(missing)
+            raise ValueError(msg)
+        if nmin != 0:
+            for i, ei in enumerate(rv):
+                rv[i] = [n - nmin for n in ei]
+            nmax -= nmin
+        return sorted(rv), nmax + 1
+
+    def prufer_rank(self):
+        """Computes the rank of a Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_rank()
+        0
+
+        See Also
+        ========
+
+        rank, next, prev, size
+
+        """
+        r = 0
+        p = 1
+        for i in range(self.nodes - 3, -1, -1):
+            r += p*self.prufer_repr[i]
+            p *= self.nodes
+        return r
+
+    @classmethod
+    def unrank(self, rank, n):
+        """Finds the unranked Prufer sequence.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> Prufer.unrank(0, 4)
+        Prufer([0, 0])
+
+        """
+        n, rank = as_int(n), as_int(rank)
+        L = defaultdict(int)
+        for i in range(n - 3, -1, -1):
+            L[i] = rank % n
+            rank = (rank - L[i])//n
+        return Prufer([L[i] for i in range(len(L))])
+
+    def __new__(cls, *args, **kw_args):
+        """The constructor for the Prufer object.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+
+        A Prufer object can be constructed from a list of edges:
+
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> a.prufer_repr
+        [0, 0]
+
+        If the number of nodes is given, no checking of the nodes will
+        be performed; it will be assumed that nodes 0 through n - 1 are
+        present:
+
+        >>> Prufer([[0, 1], [0, 2], [0, 3]], 4)
+        Prufer([[0, 1], [0, 2], [0, 3]], 4)
+
+        A Prufer object can be constructed from a Prufer sequence:
+
+        >>> b = Prufer([1, 3])
+        >>> b.tree_repr
+        [[0, 1], [1, 3], [2, 3]]
+
+        """
+        arg0 = Array(args[0]) if args[0] else Tuple()
+        args = (arg0,) + tuple(_sympify(arg) for arg in args[1:])
+        ret_obj = Basic.__new__(cls, *args, **kw_args)
+        args = [list(args[0])]
+        if args[0] and iterable(args[0][0]):
+            if not args[0][0]:
+                raise ValueError(
+                    'Prufer expects at least one edge in the tree.')
+            if len(args) > 1:
+                nnodes = args[1]
+            else:
+                nodes = set(flatten(args[0]))
+                nnodes = max(nodes) + 1
+                if nnodes != len(nodes):
+                    missing = set(range(nnodes)) - nodes
+                    if len(missing) == 1:
+                        msg = 'Node %s is missing.' % missing.pop()
+                    else:
+                        msg = 'Nodes %s are missing.' % sorted(missing)
+                    raise ValueError(msg)
+            ret_obj._tree_repr = [list(i) for i in args[0]]
+            ret_obj._nodes = nnodes
+        else:
+            ret_obj._prufer_repr = args[0]
+            ret_obj._nodes = len(ret_obj._prufer_repr) + 2
+        return ret_obj
+
+    def next(self, delta=1):
+        """Generates the Prufer sequence that is delta beyond the current one.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [0, 2], [0, 3]])
+        >>> b = a.next(1) # == a.next()
+        >>> b.tree_repr
+        [[0, 2], [0, 1], [1, 3]]
+        >>> b.rank
+        1
+
+        See Also
+        ========
+
+        prufer_rank, rank, prev, size
+
+        """
+        return Prufer.unrank(self.rank + delta, self.nodes)
+
+    def prev(self, delta=1):
+        """Generates the Prufer sequence that is -delta before the current one.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics.prufer import Prufer
+        >>> a = Prufer([[0, 1], [1, 2], [2, 3], [1, 4]])
+        >>> a.rank
+        36
+        >>> b = a.prev()
+        >>> b
+        Prufer([1, 2, 0])
+        >>> b.rank
+        35
+
+        See Also
+        ========
+
+        prufer_rank, rank, next, size
+
+        """
+        return Prufer.unrank(self.rank -delta, self.nodes)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9e8dfe4c831db6490c987c85a57d0d1a939de61
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem.py
@@ -0,0 +1,453 @@
+from collections import deque
+from sympy.combinatorics.rewritingsystem_fsm import StateMachine
+
+class RewritingSystem:
+    '''
+    A class implementing rewriting systems for `FpGroup`s.
+
+    References
+    ==========
+    .. [1] Epstein, D., Holt, D. and Rees, S. (1991).
+           The use of Knuth-Bendix methods to solve the word problem in automatic groups.
+           Journal of Symbolic Computation, 12(4-5), pp.397-414.
+
+    .. [2] GAP's Manual on its KBMAG package
+           https://www.gap-system.org/Manuals/pkg/kbmag-1.5.3/doc/manual.pdf
+
+    '''
+    def __init__(self, group):
+        self.group = group
+        self.alphabet = group.generators
+        self._is_confluent = None
+
+        # these values are taken from [2]
+        self.maxeqns = 32767 # max rules
+        self.tidyint = 100 # rules before tidying
+
+        # _max_exceeded is True if maxeqns is exceeded
+        # at any point
+        self._max_exceeded = False
+
+        # Reduction automaton
+        self.reduction_automaton = None
+        self._new_rules = {}
+
+        # dictionary of reductions
+        self.rules = {}
+        self.rules_cache = deque([], 50)
+        self._init_rules()
+
+
+        # All the transition symbols in the automaton
+        generators = list(self.alphabet)
+        generators += [gen**-1 for gen in generators]
+        # Create a finite state machine as an instance of the StateMachine object
+        self.reduction_automaton = StateMachine('Reduction automaton for '+ repr(self.group), generators)
+        self.construct_automaton()
+
+    def set_max(self, n):
+        '''
+        Set the maximum number of rules that can be defined
+
+        '''
+        if n > self.maxeqns:
+            self._max_exceeded = False
+        self.maxeqns = n
+        return
+
+    @property
+    def is_confluent(self):
+        '''
+        Return `True` if the system is confluent
+
+        '''
+        if self._is_confluent is None:
+            self._is_confluent = self._check_confluence()
+        return self._is_confluent
+
+    def _init_rules(self):
+        identity = self.group.free_group.identity
+        for r in self.group.relators:
+            self.add_rule(r, identity)
+        self._remove_redundancies()
+        return
+
+    def _add_rule(self, r1, r2):
+        '''
+        Add the rule r1 -> r2 with no checking or further
+        deductions
+
+        '''
+        if len(self.rules) + 1 > self.maxeqns:
+            self._is_confluent = self._check_confluence()
+            self._max_exceeded = True
+            raise RuntimeError("Too many rules were defined.")
+        self.rules[r1] = r2
+        # Add the newly added rule to the `new_rules` dictionary.
+        if self.reduction_automaton:
+            self._new_rules[r1] = r2
+
+    def add_rule(self, w1, w2, check=False):
+        new_keys = set()
+
+        if w1 == w2:
+            return new_keys
+
+        if w1 < w2:
+            w1, w2 = w2, w1
+
+        if (w1, w2) in self.rules_cache:
+            return new_keys
+        self.rules_cache.append((w1, w2))
+
+        s1, s2 = w1, w2
+
+        # The following is the equivalent of checking
+        # s1 for overlaps with the implicit reductions
+        # {g*g**-1 -> } and {g**-1*g -> }
+        # for any generator g without installing the
+        # redundant rules that would result from processing
+        # the overlaps. See [1], Section 3 for details.
+
+        if len(s1) - len(s2) < 3:
+            if s1 not in self.rules:
+                new_keys.add(s1)
+                if not check:
+                    self._add_rule(s1, s2)
+            if s2**-1 > s1**-1 and s2**-1 not in self.rules:
+                new_keys.add(s2**-1)
+                if not check:
+                    self._add_rule(s2**-1, s1**-1)
+
+        # overlaps on the right
+        while len(s1) - len(s2) > -1:
+            g = s1[len(s1)-1]
+            s1 = s1.subword(0, len(s1)-1)
+            s2 = s2*g**-1
+            if len(s1) - len(s2) < 0:
+                if s2 not in self.rules:
+                    if not check:
+                        self._add_rule(s2, s1)
+                    new_keys.add(s2)
+            elif len(s1) - len(s2) < 3:
+                new = self.add_rule(s1, s2, check)
+                new_keys.update(new)
+
+        # overlaps on the left
+        while len(w1) - len(w2) > -1:
+            g = w1[0]
+            w1 = w1.subword(1, len(w1))
+            w2 = g**-1*w2
+            if len(w1) - len(w2) < 0:
+                if w2 not in self.rules:
+                    if not check:
+                        self._add_rule(w2, w1)
+                    new_keys.add(w2)
+            elif len(w1) - len(w2) < 3:
+                new = self.add_rule(w1, w2, check)
+                new_keys.update(new)
+
+        return new_keys
+
+    def _remove_redundancies(self, changes=False):
+        '''
+        Reduce left- and right-hand sides of reduction rules
+        and remove redundant equations (i.e. those for which
+        lhs == rhs). If `changes` is `True`, return a set
+        containing the removed keys and a set containing the
+        added keys
+
+        '''
+        removed = set()
+        added = set()
+        rules = self.rules.copy()
+        for r in rules:
+            v = self.reduce(r, exclude=r)
+            w = self.reduce(rules[r])
+            if v != r:
+                del self.rules[r]
+                removed.add(r)
+                if v > w:
+                    added.add(v)
+                    self.rules[v] = w
+                elif v < w:
+                    added.add(w)
+                    self.rules[w] = v
+            else:
+                self.rules[v] = w
+        if changes:
+            return removed, added
+        return
+
+    def make_confluent(self, check=False):
+        '''
+        Try to make the system confluent using the Knuth-Bendix
+        completion algorithm
+
+        '''
+        if self._max_exceeded:
+            return self._is_confluent
+        lhs = list(self.rules.keys())
+
+        def _overlaps(r1, r2):
+            len1 = len(r1)
+            len2 = len(r2)
+            result = []
+            for j in range(1, len1 + len2):
+                if (r1.subword(len1 - j, len1 + len2 - j, strict=False)
+                       == r2.subword(j - len1, j, strict=False)):
+                    a = r1.subword(0, len1-j, strict=False)
+                    a = a*r2.subword(0, j-len1, strict=False)
+                    b = r2.subword(j-len1, j, strict=False)
+                    c = r2.subword(j, len2, strict=False)
+                    c = c*r1.subword(len1 + len2 - j, len1, strict=False)
+                    result.append(a*b*c)
+            return result
+
+        def _process_overlap(w, r1, r2, check):
+                s = w.eliminate_word(r1, self.rules[r1])
+                s = self.reduce(s)
+                t = w.eliminate_word(r2, self.rules[r2])
+                t = self.reduce(t)
+                if s != t:
+                    if check:
+                        # system not confluent
+                        return [0]
+                    try:
+                        new_keys = self.add_rule(t, s, check)
+                        return new_keys
+                    except RuntimeError:
+                        return False
+                return
+
+        added = 0
+        i = 0
+        while i < len(lhs):
+            r1 = lhs[i]
+            i += 1
+            # j could be i+1 to not
+            # check each pair twice but lhs
+            # is extended in the loop and the new
+            # elements have to be checked with the
+            # preceding ones. there is probably a better way
+            # to handle this
+            j = 0
+            while j < len(lhs):
+                r2 = lhs[j]
+                j += 1
+                if r1 == r2:
+                    continue
+                overlaps = _overlaps(r1, r2)
+                overlaps.extend(_overlaps(r1**-1, r2))
+                if not overlaps:
+                    continue
+                for w in overlaps:
+                    new_keys = _process_overlap(w, r1, r2, check)
+                    if new_keys:
+                        if check:
+                            return False
+                        lhs.extend(new_keys)
+                        added += len(new_keys)
+                    elif new_keys == False:
+                        # too many rules were added so the process
+                        # couldn't complete
+                        return self._is_confluent
+
+                if added > self.tidyint and not check:
+                    # tidy up
+                    r, a = self._remove_redundancies(changes=True)
+                    added = 0
+                    if r:
+                        # reset i since some elements were removed
+                        i = min(lhs.index(s) for s in r)
+                    lhs = [l for l in lhs if l not in r]
+                    lhs.extend(a)
+                    if r1 in r:
+                        # r1 was removed as redundant
+                        break
+
+        self._is_confluent = True
+        if not check:
+            self._remove_redundancies()
+        return True
+
+    def _check_confluence(self):
+        return self.make_confluent(check=True)
+
+    def reduce(self, word, exclude=None):
+        '''
+        Apply reduction rules to `word` excluding the reduction rule
+        for the lhs equal to `exclude`
+
+        '''
+        rules = {r: self.rules[r] for r in self.rules if r != exclude}
+        # the following is essentially `eliminate_words()` code from the
+        # `FreeGroupElement` class, the only difference being the first
+        # "if" statement
+        again = True
+        new = word
+        while again:
+            again = False
+            for r in rules:
+                prev = new
+                if rules[r]**-1 > r**-1:
+                    new = new.eliminate_word(r, rules[r], _all=True, inverse=False)
+                else:
+                    new = new.eliminate_word(r, rules[r], _all=True)
+                if new != prev:
+                    again = True
+        return new
+
+    def _compute_inverse_rules(self, rules):
+        '''
+        Compute the inverse rules for a given set of rules.
+        The inverse rules are used in the automaton for word reduction.
+
+        Arguments:
+            rules (dictionary): Rules for which the inverse rules are to computed.
+
+        Returns:
+            Dictionary of inverse_rules.
+
+        '''
+        inverse_rules = {}
+        for r in rules:
+            rule_key_inverse = r**-1
+            rule_value_inverse = (rules[r])**-1
+            if (rule_value_inverse < rule_key_inverse):
+                inverse_rules[rule_key_inverse] = rule_value_inverse
+            else:
+                inverse_rules[rule_value_inverse] = rule_key_inverse
+        return inverse_rules
+
+    def construct_automaton(self):
+        '''
+        Construct the automaton based on the set of reduction rules of the system.
+
+        Automata Design:
+        The accept states of the automaton are the proper prefixes of the left hand side of the rules.
+        The complete left hand side of the rules are the dead states of the automaton.
+
+        '''
+        self._add_to_automaton(self.rules)
+
+    def _add_to_automaton(self, rules):
+        '''
+        Add new states and transitions to the automaton.
+
+        Summary:
+        States corresponding to the new rules added to the system are computed and added to the automaton.
+        Transitions in the previously added states are also modified if necessary.
+
+        Arguments:
+            rules (dictionary) -- Dictionary of the newly added rules.
+
+        '''
+        # Automaton variables
+        automaton_alphabet = []
+        proper_prefixes = {}
+
+        # compute the inverses of all the new rules added
+        all_rules = rules
+        inverse_rules = self._compute_inverse_rules(all_rules)
+        all_rules.update(inverse_rules)
+
+        # Keep track of the accept_states.
+        accept_states = []
+
+        for rule in all_rules:
+            # The symbols present in the new rules are the symbols to be verified at each state.
+            # computes the automaton_alphabet, as the transitions solely depend upon the new states.
+            automaton_alphabet += rule.letter_form_elm
+            # Compute the proper prefixes for every rule.
+            proper_prefixes[rule] = []
+            letter_word_array = list(rule.letter_form_elm)
+            len_letter_word_array = len(letter_word_array)
+            for i in range (1, len_letter_word_array):
+                letter_word_array[i] = letter_word_array[i-1]*letter_word_array[i]
+                # Add accept states.
+                elem = letter_word_array[i-1]
+                if elem not in self.reduction_automaton.states:
+                    self.reduction_automaton.add_state(elem, state_type='a')
+                    accept_states.append(elem)
+            proper_prefixes[rule] = letter_word_array
+            # Check for overlaps between dead and accept states.
+            if rule in accept_states:
+                self.reduction_automaton.states[rule].state_type = 'd'
+                self.reduction_automaton.states[rule].rh_rule = all_rules[rule]
+                accept_states.remove(rule)
+            # Add dead states
+            if rule not in self.reduction_automaton.states:
+                self.reduction_automaton.add_state(rule, state_type='d', rh_rule=all_rules[rule])
+
+        automaton_alphabet = set(automaton_alphabet)
+
+        # Add new transitions for every state.
+        for state in self.reduction_automaton.states:
+            current_state_name = state
+            current_state_type = self.reduction_automaton.states[state].state_type
+            # Transitions will be modified only when suffixes of the current_state
+            # belongs to the proper_prefixes of the new rules.
+            # The rest are ignored if they cannot lead to a dead state after a finite number of transisitons.
+            if current_state_type == 's':
+                for letter in automaton_alphabet:
+                    if letter in self.reduction_automaton.states:
+                        self.reduction_automaton.states[state].add_transition(letter, letter)
+                    else:
+                        self.reduction_automaton.states[state].add_transition(letter, current_state_name)
+            elif current_state_type == 'a':
+                # Check if the transition to any new state in possible.
+                for letter in automaton_alphabet:
+                    _next = current_state_name*letter
+                    while len(_next) and _next not in self.reduction_automaton.states:
+                        _next = _next.subword(1, len(_next))
+                    if not len(_next):
+                        _next = 'start'
+                    self.reduction_automaton.states[state].add_transition(letter, _next)
+
+        # Add transitions for new states. All symbols used in the automaton are considered here.
+        # Ignore this if `reduction_automaton.automaton_alphabet` = `automaton_alphabet`.
+        if len(self.reduction_automaton.automaton_alphabet) != len(automaton_alphabet):
+            for state in accept_states:
+                current_state_name = state
+                for letter in self.reduction_automaton.automaton_alphabet:
+                    _next = current_state_name*letter
+                    while len(_next) and _next not in self.reduction_automaton.states:
+                        _next = _next.subword(1, len(_next))
+                    if not len(_next):
+                        _next = 'start'
+                    self.reduction_automaton.states[state].add_transition(letter, _next)
+
+    def reduce_using_automaton(self, word):
+        '''
+        Reduce a word using an automaton.
+
+        Summary:
+        All the symbols of the word are stored in an array and are given as the input to the automaton.
+        If the automaton reaches a dead state that subword is replaced and the automaton is run from the beginning.
+        The complete word has to be replaced when the word is read and the automaton reaches a dead state.
+        So, this process is repeated until the word is read completely and the automaton reaches the accept state.
+
+        Arguments:
+            word (instance of FreeGroupElement) -- Word that needs to be reduced.
+
+        '''
+        # Modify the automaton if new rules are found.
+        if self._new_rules:
+            self._add_to_automaton(self._new_rules)
+            self._new_rules = {}
+
+        flag = 1
+        while flag:
+            flag = 0
+            current_state = self.reduction_automaton.states['start']
+            for i, s in enumerate(word.letter_form_elm):
+                next_state_name = current_state.transitions[s]
+                next_state = self.reduction_automaton.states[next_state_name]
+                if next_state.state_type == 'd':
+                    subst = next_state.rh_rule
+                    word = word.substituted_word(i - len(next_state_name) + 1, i+1, subst)
+                    flag = 1
+                    break
+                current_state = next_state
+        return word
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem_fsm.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem_fsm.py
new file mode 100644
index 0000000000000000000000000000000000000000..21916530040ac321180692d1a0811da4ae36a056
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/rewritingsystem_fsm.py
@@ -0,0 +1,60 @@
+class State:
+    '''
+    A representation of a state managed by a ``StateMachine``.
+
+    Attributes:
+        name (instance of FreeGroupElement or string) -- State name which is also assigned to the Machine.
+        transisitons (OrderedDict) -- Represents all the transitions of the state object.
+        state_type (string) -- Denotes the type (accept/start/dead) of the state.
+        rh_rule (instance of FreeGroupElement) -- right hand rule for dead state.
+        state_machine (instance of StateMachine object) -- The finite state machine that the state belongs to.
+    '''
+
+    def __init__(self, name, state_machine, state_type=None, rh_rule=None):
+        self.name = name
+        self.transitions = {}
+        self.state_machine = state_machine
+        self.state_type = state_type[0]
+        self.rh_rule = rh_rule
+
+    def add_transition(self, letter, state):
+        '''
+        Add a transition from the current state to a new state.
+
+        Keyword Arguments:
+            letter -- The alphabet element the current state reads to make the state transition.
+            state -- This will be an instance of the State object which represents a new state after in the transition after the alphabet is read.
+
+        '''
+        self.transitions[letter] = state
+
+class StateMachine:
+    '''
+    Representation of a finite state machine the manages the states and the transitions of the automaton.
+
+    Attributes:
+        states (dictionary) -- Collection of all registered `State` objects.
+        name (str) -- Name of the state machine.
+    '''
+
+    def __init__(self, name, automaton_alphabet):
+        self.name = name
+        self.automaton_alphabet = automaton_alphabet
+        self.states = {} # Contains all the states in the machine.
+        self.add_state('start', state_type='s')
+
+    def add_state(self, state_name, state_type=None, rh_rule=None):
+        '''
+        Instantiate a state object and stores it in the 'states' dictionary.
+
+        Arguments:
+            state_name (instance of FreeGroupElement or string) -- name of the new states.
+            state_type (string) -- Denotes the type (accept/start/dead) of the state added.
+            rh_rule (instance of FreeGroupElement) -- right hand rule for dead state.
+
+        '''
+        new_state = State(state_name, self, state_type, rh_rule)
+        self.states[state_name] = new_state
+
+    def __repr__(self):
+        return "%s" % (self.name)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/schur_number.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/schur_number.py
new file mode 100644
index 0000000000000000000000000000000000000000..83aac98e543d4b54d4e6af17adca6e4f4de1b9ac
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/schur_number.py
@@ -0,0 +1,160 @@
+"""
+The Schur number S(k) is the largest integer n for which the interval [1,n]
+can be partitioned into k sum-free sets.(https://mathworld.wolfram.com/SchurNumber.html)
+"""
+import math
+from sympy.core import S
+from sympy.core.basic import Basic
+from sympy.core.function import Function
+from sympy.core.numbers import Integer
+
+
+class SchurNumber(Function):
+    r"""
+    This function creates a SchurNumber object
+    which is evaluated for `k \le 5` otherwise only
+    the lower bound information can be retrieved.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.schur_number import SchurNumber
+
+    Since S(3) = 13, hence the output is a number
+    >>> SchurNumber(3)
+    13
+
+    We do not know the Schur number for values greater than 5, hence
+    only the object is returned
+    >>> SchurNumber(6)
+    SchurNumber(6)
+
+    Now, the lower bound information can be retrieved using lower_bound()
+    method
+    >>> SchurNumber(6).lower_bound()
+    536
+
+    """
+
+    @classmethod
+    def eval(cls, k):
+        if k.is_Number:
+            if k is S.Infinity:
+                return S.Infinity
+            if k.is_zero:
+                return S.Zero
+            if not k.is_integer or k.is_negative:
+                raise ValueError("k should be a positive integer")
+            first_known_schur_numbers = {1: 1, 2: 4, 3: 13, 4: 44, 5: 160}
+            if k <= 5:
+                return Integer(first_known_schur_numbers[k])
+
+    def lower_bound(self):
+        f_ = self.args[0]
+        # Improved lower bounds known for S(6) and S(7)
+        if f_ == 6:
+            return Integer(536)
+        if f_ == 7:
+            return Integer(1680)
+        # For other cases, use general expression
+        if f_.is_Integer:
+            return 3*self.func(f_ - 1).lower_bound() - 1
+        return (3**f_ - 1)/2
+
+
+def _schur_subsets_number(n):
+
+    if n is S.Infinity:
+        raise ValueError("Input must be finite")
+    if n <= 0:
+        raise ValueError("n must be a non-zero positive integer.")
+    elif n <= 3:
+        min_k = 1
+    else:
+        min_k = math.ceil(math.log(2*n + 1, 3))
+
+    return Integer(min_k)
+
+
+def schur_partition(n):
+    """
+
+    This function returns the partition in the minimum number of sum-free subsets
+    according to the lower bound given by the Schur Number.
+
+    Parameters
+    ==========
+
+    n: a number
+        n is the upper limit of the range [1, n] for which we need to find and
+        return the minimum number of free subsets according to the lower bound
+        of schur number
+
+    Returns
+    =======
+
+    List of lists
+        List of the minimum number of sum-free subsets
+
+    Notes
+    =====
+
+    It is possible for some n to make the partition into less
+    subsets since the only known Schur numbers are:
+    S(1) = 1, S(2) = 4, S(3) = 13, S(4) = 44.
+    e.g for n = 44 the lower bound from the function above is 5 subsets but it has been proven
+    that can be done with 4 subsets.
+
+    Examples
+    ========
+
+    For n = 1, 2, 3 the answer is the set itself
+
+    >>> from sympy.combinatorics.schur_number import schur_partition
+    >>> schur_partition(2)
+    [[1, 2]]
+
+    For n > 3, the answer is the minimum number of sum-free subsets:
+
+    >>> schur_partition(5)
+    [[3, 2], [5], [1, 4]]
+
+    >>> schur_partition(8)
+    [[3, 2], [6, 5, 8], [1, 4, 7]]
+    """
+
+    if isinstance(n, Basic) and not n.is_Number:
+        raise ValueError("Input value must be a number")
+
+    number_of_subsets = _schur_subsets_number(n)
+    if n == 1:
+        sum_free_subsets = [[1]]
+    elif n == 2:
+        sum_free_subsets = [[1, 2]]
+    elif n == 3:
+        sum_free_subsets = [[1, 2, 3]]
+    else:
+        sum_free_subsets = [[1, 4], [2, 3]]
+
+    while len(sum_free_subsets) < number_of_subsets:
+        sum_free_subsets = _generate_next_list(sum_free_subsets, n)
+        missed_elements = [3*k + 1 for k in range(len(sum_free_subsets), (n-1)//3 + 1)]
+        sum_free_subsets[-1] += missed_elements
+
+    return sum_free_subsets
+
+
+def _generate_next_list(current_list, n):
+    new_list = []
+
+    for item in current_list:
+        temp_1 = [number*3 for number in item if number*3 <= n]
+        temp_2 = [number*3 - 1 for number in item if number*3 - 1 <= n]
+        new_item = temp_1 + temp_2
+        new_list.append(new_item)
+
+    last_list = [3*k + 1 for k in range(len(current_list)+1) if 3*k + 1 <= n]
+    new_list.append(last_list)
+    current_list = new_list
+
+    return current_list
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/subsets.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/subsets.py
new file mode 100644
index 0000000000000000000000000000000000000000..e540cb2395cb27e04c9d513831cb834a05ec2abd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/subsets.py
@@ -0,0 +1,619 @@
+from itertools import combinations
+
+from sympy.combinatorics.graycode import GrayCode
+
+
+class Subset():
+    """
+    Represents a basic subset object.
+
+    Explanation
+    ===========
+
+    We generate subsets using essentially two techniques,
+    binary enumeration and lexicographic enumeration.
+    The Subset class takes two arguments, the first one
+    describes the initial subset to consider and the second
+    describes the superset.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Subset
+    >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+    >>> a.next_binary().subset
+    ['b']
+    >>> a.prev_binary().subset
+    ['c']
+    """
+
+    _rank_binary = None
+    _rank_lex = None
+    _rank_graycode = None
+    _subset = None
+    _superset = None
+
+    def __new__(cls, subset, superset):
+        """
+        Default constructor.
+
+        It takes the ``subset`` and its ``superset`` as its parameters.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.subset
+        ['c', 'd']
+        >>> a.superset
+        ['a', 'b', 'c', 'd']
+        >>> a.size
+        2
+        """
+        if len(subset) > len(superset):
+            raise ValueError('Invalid arguments have been provided. The '
+                             'superset must be larger than the subset.')
+        for elem in subset:
+            if elem not in superset:
+                raise ValueError('The superset provided is invalid as it does '
+                                 'not contain the element {}'.format(elem))
+        obj = object.__new__(cls)
+        obj._subset = subset
+        obj._superset = superset
+        return obj
+
+    def __eq__(self, other):
+        """Return a boolean indicating whether a == b on the basis of
+        whether both objects are of the class Subset and if the values
+        of the subset and superset attributes are the same.
+        """
+        if not isinstance(other, Subset):
+            return NotImplemented
+        return self.subset == other.subset and self.superset == other.superset
+
+    def iterate_binary(self, k):
+        """
+        This is a helper function. It iterates over the
+        binary subsets by ``k`` steps. This variable can be
+        both positive or negative.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.iterate_binary(-2).subset
+        ['d']
+        >>> a = Subset(['a', 'b', 'c'], ['a', 'b', 'c', 'd'])
+        >>> a.iterate_binary(2).subset
+        []
+
+        See Also
+        ========
+
+        next_binary, prev_binary
+        """
+        bin_list = Subset.bitlist_from_subset(self.subset, self.superset)
+        n = (int(''.join(bin_list), 2) + k) % 2**self.superset_size
+        bits = bin(n)[2:].rjust(self.superset_size, '0')
+        return Subset.subset_from_bitlist(self.superset, bits)
+
+    def next_binary(self):
+        """
+        Generates the next binary ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.next_binary().subset
+        ['b']
+        >>> a = Subset(['a', 'b', 'c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.next_binary().subset
+        []
+
+        See Also
+        ========
+
+        prev_binary, iterate_binary
+        """
+        return self.iterate_binary(1)
+
+    def prev_binary(self):
+        """
+        Generates the previous binary ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([], ['a', 'b', 'c', 'd'])
+        >>> a.prev_binary().subset
+        ['a', 'b', 'c', 'd']
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.prev_binary().subset
+        ['c']
+
+        See Also
+        ========
+
+        next_binary, iterate_binary
+        """
+        return self.iterate_binary(-1)
+
+    def next_lexicographic(self):
+        """
+        Generates the next lexicographically ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.next_lexicographic().subset
+        ['d']
+        >>> a = Subset(['d'], ['a', 'b', 'c', 'd'])
+        >>> a.next_lexicographic().subset
+        []
+
+        See Also
+        ========
+
+        prev_lexicographic
+        """
+        i = self.superset_size - 1
+        indices = Subset.subset_indices(self.subset, self.superset)
+
+        if i in indices:
+            if i - 1 in indices:
+                indices.remove(i - 1)
+            else:
+                indices.remove(i)
+                i = i - 1
+                while i >= 0 and i not in indices:
+                    i = i - 1
+                if i >= 0:
+                    indices.remove(i)
+                    indices.append(i+1)
+        else:
+            while i not in indices and i >= 0:
+                i = i - 1
+            indices.append(i + 1)
+
+        ret_set = []
+        super_set = self.superset
+        for i in indices:
+            ret_set.append(super_set[i])
+        return Subset(ret_set, super_set)
+
+    def prev_lexicographic(self):
+        """
+        Generates the previous lexicographically ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([], ['a', 'b', 'c', 'd'])
+        >>> a.prev_lexicographic().subset
+        ['d']
+        >>> a = Subset(['c','d'], ['a', 'b', 'c', 'd'])
+        >>> a.prev_lexicographic().subset
+        ['c']
+
+        See Also
+        ========
+
+        next_lexicographic
+        """
+        i = self.superset_size - 1
+        indices = Subset.subset_indices(self.subset, self.superset)
+
+        while i >= 0 and i not in indices:
+            i = i - 1
+
+        if i == 0 or i - 1 in indices:
+            indices.remove(i)
+        else:
+            if i >= 0:
+                indices.remove(i)
+                indices.append(i - 1)
+            indices.append(self.superset_size - 1)
+
+        ret_set = []
+        super_set = self.superset
+        for i in indices:
+            ret_set.append(super_set[i])
+        return Subset(ret_set, super_set)
+
+    def iterate_graycode(self, k):
+        """
+        Helper function used for prev_gray and next_gray.
+        It performs ``k`` step overs to get the respective Gray codes.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([1, 2, 3], [1, 2, 3, 4])
+        >>> a.iterate_graycode(3).subset
+        [1, 4]
+        >>> a.iterate_graycode(-2).subset
+        [1, 2, 4]
+
+        See Also
+        ========
+
+        next_gray, prev_gray
+        """
+        unranked_code = GrayCode.unrank(self.superset_size,
+                                       (self.rank_gray + k) % self.cardinality)
+        return Subset.subset_from_bitlist(self.superset,
+                                          unranked_code)
+
+    def next_gray(self):
+        """
+        Generates the next Gray code ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([1, 2, 3], [1, 2, 3, 4])
+        >>> a.next_gray().subset
+        [1, 3]
+
+        See Also
+        ========
+
+        iterate_graycode, prev_gray
+        """
+        return self.iterate_graycode(1)
+
+    def prev_gray(self):
+        """
+        Generates the previous Gray code ordered subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([2, 3, 4], [1, 2, 3, 4, 5])
+        >>> a.prev_gray().subset
+        [2, 3, 4, 5]
+
+        See Also
+        ========
+
+        iterate_graycode, next_gray
+        """
+        return self.iterate_graycode(-1)
+
+    @property
+    def rank_binary(self):
+        """
+        Computes the binary ordered rank.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset([], ['a','b','c','d'])
+        >>> a.rank_binary
+        0
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.rank_binary
+        3
+
+        See Also
+        ========
+
+        iterate_binary, unrank_binary
+        """
+        if self._rank_binary is None:
+            self._rank_binary = int("".join(
+                Subset.bitlist_from_subset(self.subset,
+                                           self.superset)), 2)
+        return self._rank_binary
+
+    @property
+    def rank_lexicographic(self):
+        """
+        Computes the lexicographic ranking of the subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.rank_lexicographic
+        14
+        >>> a = Subset([2, 4, 5], [1, 2, 3, 4, 5, 6])
+        >>> a.rank_lexicographic
+        43
+        """
+        if self._rank_lex is None:
+            def _ranklex(self, subset_index, i, n):
+                if subset_index == [] or i > n:
+                    return 0
+                if i in subset_index:
+                    subset_index.remove(i)
+                    return 1 + _ranklex(self, subset_index, i + 1, n)
+                return 2**(n - i - 1) + _ranklex(self, subset_index, i + 1, n)
+            indices = Subset.subset_indices(self.subset, self.superset)
+            self._rank_lex = _ranklex(self, indices, 0, self.superset_size)
+        return self._rank_lex
+
+    @property
+    def rank_gray(self):
+        """
+        Computes the Gray code ranking of the subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c','d'], ['a','b','c','d'])
+        >>> a.rank_gray
+        2
+        >>> a = Subset([2, 4, 5], [1, 2, 3, 4, 5, 6])
+        >>> a.rank_gray
+        27
+
+        See Also
+        ========
+
+        iterate_graycode, unrank_gray
+        """
+        if self._rank_graycode is None:
+            bits = Subset.bitlist_from_subset(self.subset, self.superset)
+            self._rank_graycode = GrayCode(len(bits), start=bits).rank
+        return self._rank_graycode
+
+    @property
+    def subset(self):
+        """
+        Gets the subset represented by the current instance.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.subset
+        ['c', 'd']
+
+        See Also
+        ========
+
+        superset, size, superset_size, cardinality
+        """
+        return self._subset
+
+    @property
+    def size(self):
+        """
+        Gets the size of the subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.size
+        2
+
+        See Also
+        ========
+
+        subset, superset, superset_size, cardinality
+        """
+        return len(self.subset)
+
+    @property
+    def superset(self):
+        """
+        Gets the superset of the subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.superset
+        ['a', 'b', 'c', 'd']
+
+        See Also
+        ========
+
+        subset, size, superset_size, cardinality
+        """
+        return self._superset
+
+    @property
+    def superset_size(self):
+        """
+        Returns the size of the superset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.superset_size
+        4
+
+        See Also
+        ========
+
+        subset, superset, size, cardinality
+        """
+        return len(self.superset)
+
+    @property
+    def cardinality(self):
+        """
+        Returns the number of all possible subsets.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        >>> a.cardinality
+        16
+
+        See Also
+        ========
+
+        subset, superset, size, superset_size
+        """
+        return 2**(self.superset_size)
+
+    @classmethod
+    def subset_from_bitlist(self, super_set, bitlist):
+        """
+        Gets the subset defined by the bitlist.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> Subset.subset_from_bitlist(['a', 'b', 'c', 'd'], '0011').subset
+        ['c', 'd']
+
+        See Also
+        ========
+
+        bitlist_from_subset
+        """
+        if len(super_set) != len(bitlist):
+            raise ValueError("The sizes of the lists are not equal")
+        ret_set = []
+        for i in range(len(bitlist)):
+            if bitlist[i] == '1':
+                ret_set.append(super_set[i])
+        return Subset(ret_set, super_set)
+
+    @classmethod
+    def bitlist_from_subset(self, subset, superset):
+        """
+        Gets the bitlist corresponding to a subset.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> Subset.bitlist_from_subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+        '0011'
+
+        See Also
+        ========
+
+        subset_from_bitlist
+        """
+        bitlist = ['0'] * len(superset)
+        if isinstance(subset, Subset):
+            subset = subset.subset
+        for i in Subset.subset_indices(subset, superset):
+            bitlist[i] = '1'
+        return ''.join(bitlist)
+
+    @classmethod
+    def unrank_binary(self, rank, superset):
+        """
+        Gets the binary ordered subset of the specified rank.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> Subset.unrank_binary(4, ['a', 'b', 'c', 'd']).subset
+        ['b']
+
+        See Also
+        ========
+
+        iterate_binary, rank_binary
+        """
+        bits = bin(rank)[2:].rjust(len(superset), '0')
+        return Subset.subset_from_bitlist(superset, bits)
+
+    @classmethod
+    def unrank_gray(self, rank, superset):
+        """
+        Gets the Gray code ordered subset of the specified rank.
+
+        Examples
+        ========
+
+        >>> from sympy.combinatorics import Subset
+        >>> Subset.unrank_gray(4, ['a', 'b', 'c']).subset
+        ['a', 'b']
+        >>> Subset.unrank_gray(0, ['a', 'b', 'c']).subset
+        []
+
+        See Also
+        ========
+
+        iterate_graycode, rank_gray
+        """
+        graycode_bitlist = GrayCode.unrank(len(superset), rank)
+        return Subset.subset_from_bitlist(superset, graycode_bitlist)
+
+    @classmethod
+    def subset_indices(self, subset, superset):
+        """Return indices of subset in superset in a list; the list is empty
+        if all elements of ``subset`` are not in ``superset``.
+
+        Examples
+        ========
+
+            >>> from sympy.combinatorics import Subset
+            >>> superset = [1, 3, 2, 5, 4]
+            >>> Subset.subset_indices([3, 2, 1], superset)
+            [1, 2, 0]
+            >>> Subset.subset_indices([1, 6], superset)
+            []
+            >>> Subset.subset_indices([], superset)
+            []
+
+        """
+        a, b = superset, subset
+        sb = set(b)
+        d = {}
+        for i, ai in enumerate(a):
+            if ai in sb:
+                d[ai] = i
+                sb.remove(ai)
+                if not sb:
+                    break
+        else:
+            return []
+        return [d[bi] for bi in b]
+
+
+def ksubsets(superset, k):
+    """
+    Finds the subsets of size ``k`` in lexicographic order.
+
+    This uses the itertools generator.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.subsets import ksubsets
+    >>> list(ksubsets([1, 2, 3], 2))
+    [(1, 2), (1, 3), (2, 3)]
+    >>> list(ksubsets([1, 2, 3, 4, 5], 2))
+    [(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), \
+    (2, 5), (3, 4), (3, 5), (4, 5)]
+
+    See Also
+    ========
+
+    Subset
+    """
+    return combinations(superset, k)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tensor_can.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tensor_can.py
new file mode 100644
index 0000000000000000000000000000000000000000..d43e96ed27a21f988aaaa8fd16827987541f7373
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tensor_can.py
@@ -0,0 +1,1189 @@
+from sympy.combinatorics.permutations import Permutation, _af_rmul, \
+    _af_invert, _af_new
+from sympy.combinatorics.perm_groups import PermutationGroup, _orbit, \
+    _orbit_transversal
+from sympy.combinatorics.util import _distribute_gens_by_base, \
+    _orbits_transversals_from_bsgs
+
+"""
+    References for tensor canonicalization:
+
+    [1] R. Portugal "Algorithmic simplification of tensor expressions",
+        J. Phys. A 32 (1999) 7779-7789
+
+    [2] R. Portugal, B.F. Svaiter "Group-theoretic Approach for Symbolic
+        Tensor Manipulation: I. Free Indices"
+        arXiv:math-ph/0107031v1
+
+    [3] L.R.U. Manssur, R. Portugal "Group-theoretic Approach for Symbolic
+        Tensor Manipulation: II. Dummy Indices"
+        arXiv:math-ph/0107032v1
+
+    [4] xperm.c part of XPerm written by J. M. Martin-Garcia
+        http://www.xact.es/index.html
+"""
+
+
+def dummy_sgs(dummies, sym, n):
+    """
+    Return the strong generators for dummy indices.
+
+    Parameters
+    ==========
+
+    dummies : List of dummy indices.
+        `dummies[2k], dummies[2k+1]` are paired indices.
+        In base form, the dummy indices are always in
+        consecutive positions.
+    sym : symmetry under interchange of contracted dummies::
+        * None  no symmetry
+        * 0     commuting
+        * 1     anticommuting
+
+    n : number of indices
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import dummy_sgs
+    >>> dummy_sgs(list(range(2, 8)), 0, 8)
+    [[0, 1, 3, 2, 4, 5, 6, 7, 8, 9], [0, 1, 2, 3, 5, 4, 6, 7, 8, 9],
+     [0, 1, 2, 3, 4, 5, 7, 6, 8, 9], [0, 1, 4, 5, 2, 3, 6, 7, 8, 9],
+     [0, 1, 2, 3, 6, 7, 4, 5, 8, 9]]
+    """
+    if len(dummies) > n:
+        raise ValueError("List too large")
+    res = []
+    # exchange of contravariant and covariant indices
+    if sym is not None:
+        for j in dummies[::2]:
+            a = list(range(n + 2))
+            if sym == 1:
+                a[n] = n + 1
+                a[n + 1] = n
+            a[j], a[j + 1] = a[j + 1], a[j]
+            res.append(a)
+    # rename dummy indices
+    for j in dummies[:-3:2]:
+        a = list(range(n + 2))
+        a[j:j + 4] = a[j + 2], a[j + 3], a[j], a[j + 1]
+        res.append(a)
+    return res
+
+
+def _min_dummies(dummies, sym, indices):
+    """
+    Return list of minima of the orbits of indices in group of dummies.
+    See ``double_coset_can_rep`` for the description of ``dummies`` and ``sym``.
+    ``indices`` is the initial list of dummy indices.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import _min_dummies
+    >>> _min_dummies([list(range(2, 8))], [0], list(range(10)))
+    [0, 1, 2, 2, 2, 2, 2, 2, 8, 9]
+    """
+    num_types = len(sym)
+    m = [min(dx) if dx else None for dx in dummies]
+    res = indices[:]
+    for i in range(num_types):
+        for c, i in enumerate(indices):
+            for j in range(num_types):
+                if i in dummies[j]:
+                    res[c] = m[j]
+                    break
+    return res
+
+
+def _trace_S(s, j, b, S_cosets):
+    """
+    Return the representative h satisfying s[h[b]] == j
+
+    If there is not such a representative return None
+    """
+    for h in S_cosets[b]:
+        if s[h[b]] == j:
+            return h
+    return None
+
+
+def _trace_D(gj, p_i, Dxtrav):
+    """
+    Return the representative h satisfying h[gj] == p_i
+
+    If there is not such a representative return None
+    """
+    for h in Dxtrav:
+        if h[gj] == p_i:
+            return h
+    return None
+
+
+def _dumx_remove(dumx, dumx_flat, p0):
+    """
+    remove p0 from dumx
+    """
+    res = []
+    for dx in dumx:
+        if p0 not in dx:
+            res.append(dx)
+            continue
+        k = dx.index(p0)
+        if k % 2 == 0:
+            p0_paired = dx[k + 1]
+        else:
+            p0_paired = dx[k - 1]
+        dx.remove(p0)
+        dx.remove(p0_paired)
+        dumx_flat.remove(p0)
+        dumx_flat.remove(p0_paired)
+        res.append(dx)
+
+
+def transversal2coset(size, base, transversal):
+    a = []
+    j = 0
+    for i in range(size):
+        if i in base:
+            a.append(sorted(transversal[j].values()))
+            j += 1
+        else:
+            a.append([list(range(size))])
+    j = len(a) - 1
+    while a[j] == [list(range(size))]:
+        j -= 1
+    return a[:j + 1]
+
+
+def double_coset_can_rep(dummies, sym, b_S, sgens, S_transversals, g):
+    r"""
+    Butler-Portugal algorithm for tensor canonicalization with dummy indices.
+
+    Parameters
+    ==========
+
+      dummies
+        list of lists of dummy indices,
+        one list for each type of index;
+        the dummy indices are put in order contravariant, covariant
+        [d0, -d0, d1, -d1, ...].
+
+      sym
+        list of the symmetries of the index metric for each type.
+
+      possible symmetries of the metrics
+              * 0     symmetric
+              * 1     antisymmetric
+              * None  no symmetry
+
+      b_S
+        base of a minimal slot symmetry BSGS.
+
+      sgens
+        generators of the slot symmetry BSGS.
+
+      S_transversals
+        transversals for the slot BSGS.
+
+      g
+        permutation representing the tensor.
+
+    Returns
+    =======
+
+    Return 0 if the tensor is zero, else return the array form of
+    the permutation representing the canonical form of the tensor.
+
+    Notes
+    =====
+
+    A tensor with dummy indices can be represented in a number
+    of equivalent ways which typically grows exponentially with
+    the number of indices. To be able to establish if two tensors
+    with many indices are equal becomes computationally very slow
+    in absence of an efficient algorithm.
+
+    The Butler-Portugal algorithm [3] is an efficient algorithm to
+    put tensors in canonical form, solving the above problem.
+
+    Portugal observed that a tensor can be represented by a permutation,
+    and that the class of tensors equivalent to it under slot and dummy
+    symmetries is equivalent to the double coset `D*g*S`
+    (Note: in this documentation we use the conventions for multiplication
+    of permutations p, q with (p*q)(i) = p[q[i]] which is opposite
+    to the one used in the Permutation class)
+
+    Using the algorithm by Butler to find a representative of the
+    double coset one can find a canonical form for the tensor.
+
+    To see this correspondence,
+    let `g` be a permutation in array form; a tensor with indices `ind`
+    (the indices including both the contravariant and the covariant ones)
+    can be written as
+
+    `t = T(ind[g[0]], \dots, ind[g[n-1]])`,
+
+    where `n = len(ind)`;
+    `g` has size `n + 2`, the last two indices for the sign of the tensor
+    (trick introduced in [4]).
+
+    A slot symmetry transformation `s` is a permutation acting on the slots
+    `t \rightarrow T(ind[(g*s)[0]], \dots, ind[(g*s)[n-1]])`
+
+    A dummy symmetry transformation acts on `ind`
+    `t \rightarrow T(ind[(d*g)[0]], \dots, ind[(d*g)[n-1]])`
+
+    Being interested only in the transformations of the tensor under
+    these symmetries, one can represent the tensor by `g`, which transforms
+    as
+
+    `g -> d*g*s`, so it belongs to the coset `D*g*S`, or in other words
+    to the set of all permutations allowed by the slot and dummy symmetries.
+
+    Let us explain the conventions by an example.
+
+    Given a tensor `T^{d3 d2 d1}{}_{d1 d2 d3}` with the slot symmetries
+          `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}`
+
+          `T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5}`
+
+    and symmetric metric, find the tensor equivalent to it which
+    is the lowest under the ordering of indices:
+    lexicographic ordering `d1, d2, d3` and then contravariant
+    before covariant index; that is the canonical form of the tensor.
+
+    The canonical form is `-T^{d1 d2 d3}{}_{d1 d2 d3}`
+    obtained using `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}`.
+
+    To convert this problem in the input for this function,
+    use the following ordering of the index names
+    (- for covariant for short) `d1, -d1, d2, -d2, d3, -d3`
+
+    `T^{d3 d2 d1}{}_{d1 d2 d3}` corresponds to `g = [4, 2, 0, 1, 3, 5, 6, 7]`
+    where the last two indices are for the sign
+
+    `sgens = [Permutation(0, 2)(6, 7), Permutation(0, 4)(6, 7)]`
+
+    sgens[0] is the slot symmetry `-(0, 2)`
+    `T^{a0 a1 a2 a3 a4 a5} = -T^{a2 a1 a0 a3 a4 a5}`
+
+    sgens[1] is the slot symmetry `-(0, 4)`
+    `T^{a0 a1 a2 a3 a4 a5} = -T^{a4 a1 a2 a3 a0 a5}`
+
+    The dummy symmetry group D is generated by the strong base generators
+    `[(0, 1), (2, 3), (4, 5), (0, 2)(1, 3), (0, 4)(1, 5)]`
+    where the first three interchange covariant and contravariant
+    positions of the same index (d1 <-> -d1) and the last two interchange
+    the dummy indices themselves (d1 <-> d2).
+
+    The dummy symmetry acts from the left
+    `d = [1, 0, 2, 3, 4, 5, 6, 7]`  exchange `d1 \leftrightarrow -d1`
+    `T^{d3 d2 d1}{}_{d1 d2 d3} == T^{d3 d2}{}_{d1}{}^{d1}{}_{d2 d3}`
+
+    `g=[4, 2, 0, 1, 3, 5, 6, 7]  -> [4, 2, 1, 0, 3, 5, 6, 7] = _af_rmul(d, g)`
+    which differs from `_af_rmul(g, d)`.
+
+    The slot symmetry acts from the right
+    `s = [2, 1, 0, 3, 4, 5, 7, 6]`  exchanges slots 0 and 2 and changes sign
+    `T^{d3 d2 d1}{}_{d1 d2 d3} == -T^{d1 d2 d3}{}_{d1 d2 d3}`
+
+    `g=[4,2,0,1,3,5,6,7]  -> [0, 2, 4, 1, 3, 5, 7, 6] = _af_rmul(g, s)`
+
+    Example in which the tensor is zero, same slot symmetries as above:
+    `T^{d2}{}_{d1 d3}{}^{d1 d3}{}_{d2}`
+
+    `= -T^{d3}{}_{d1 d3}{}^{d1 d2}{}_{d2}`   under slot symmetry `-(0,4)`;
+
+    `= T_{d3 d1}{}^{d3}{}^{d1 d2}{}_{d2}`    under slot symmetry `-(0,2)`;
+
+    `= T^{d3}{}_{d1 d3}{}^{d1 d2}{}_{d2}`    symmetric metric;
+
+    `= 0`  since two of these lines have tensors differ only for the sign.
+
+    The double coset D*g*S consists of permutations `h = d*g*s` corresponding
+    to equivalent tensors; if there are two `h` which are the same apart
+    from the sign, return zero; otherwise
+    choose as representative the tensor with indices
+    ordered lexicographically according to `[d1, -d1, d2, -d2, d3, -d3]`
+    that is ``rep = min(D*g*S) = min([d*g*s for d in D for s in S])``
+
+    The indices are fixed one by one; first choose the lowest index
+    for slot 0, then the lowest remaining index for slot 1, etc.
+    Doing this one obtains a chain of stabilizers
+
+    `S \rightarrow S_{b0} \rightarrow S_{b0,b1} \rightarrow \dots` and
+    `D \rightarrow D_{p0} \rightarrow D_{p0,p1} \rightarrow \dots`
+
+    where ``[b0, b1, ...] = range(b)`` is a base of the symmetric group;
+    the strong base `b_S` of S is an ordered sublist of it;
+    therefore it is sufficient to compute once the
+    strong base generators of S using the Schreier-Sims algorithm;
+    the stabilizers of the strong base generators are the
+    strong base generators of the stabilizer subgroup.
+
+    ``dbase = [p0, p1, ...]`` is not in general in lexicographic order,
+    so that one must recompute the strong base generators each time;
+    however this is trivial, there is no need to use the Schreier-Sims
+    algorithm for D.
+
+    The algorithm keeps a TAB of elements `(s_i, d_i, h_i)`
+    where `h_i = d_i \times g \times s_i` satisfying `h_i[j] = p_j` for `0 \le j < i`
+    starting from `s_0 = id, d_0 = id, h_0 = g`.
+
+    The equations `h_0[0] = p_0, h_1[1] = p_1, \dots` are solved in this order,
+    choosing each time the lowest possible value of p_i
+
+    For `j < i`
+    `d_i*g*s_i*S_{b_0, \dots, b_{i-1}}*b_j = D_{p_0, \dots, p_{i-1}}*p_j`
+    so that for dx in `D_{p_0,\dots,p_{i-1}}` and sx in
+    `S_{base[0], \dots, base[i-1]}` one has `dx*d_i*g*s_i*sx*b_j = p_j`
+
+    Search for dx, sx such that this equation holds for `j = i`;
+    it can be written as `s_i*sx*b_j = J, dx*d_i*g*J = p_j`
+    `sx*b_j = s_i**-1*J; sx = trace(s_i**-1, S_{b_0,...,b_{i-1}})`
+    `dx**-1*p_j = d_i*g*J; dx = trace(d_i*g*J, D_{p_0,...,p_{i-1}})`
+
+    `s_{i+1} = s_i*trace(s_i**-1*J, S_{b_0,...,b_{i-1}})`
+    `d_{i+1} = trace(d_i*g*J, D_{p_0,...,p_{i-1}})**-1*d_i`
+    `h_{i+1}*b_i = d_{i+1}*g*s_{i+1}*b_i = p_i`
+
+    `h_n*b_j = p_j` for all j, so that `h_n` is the solution.
+
+    Add the found `(s, d, h)` to TAB1.
+
+    At the end of the iteration sort TAB1 with respect to the `h`;
+    if there are two consecutive `h` in TAB1 which differ only for the
+    sign, the tensor is zero, so return 0;
+    if there are two consecutive `h` which are equal, keep only one.
+
+    Then stabilize the slot generators under `i` and the dummy generators
+    under `p_i`.
+
+    Assign `TAB = TAB1` at the end of the iteration step.
+
+    At the end `TAB` contains a unique `(s, d, h)`, since all the slots
+    of the tensor `h` have been fixed to have the minimum value according
+    to the symmetries. The algorithm returns `h`.
+
+    It is important that the slot BSGS has lexicographic minimal base,
+    otherwise there is an `i` which does not belong to the slot base
+    for which `p_i` is fixed by the dummy symmetry only, while `i`
+    is not invariant from the slot stabilizer, so `p_i` is not in
+    general the minimal value.
+
+    This algorithm differs slightly from the original algorithm [3]:
+      the canonical form is minimal lexicographically, and
+      the BSGS has minimal base under lexicographic order.
+      Equal tensors `h` are eliminated from TAB.
+
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.combinatorics.tensor_can import double_coset_can_rep, get_transversals
+    >>> gens = [Permutation(x) for x in [[2, 1, 0, 3, 4, 5, 7, 6], [4, 1, 2, 3, 0, 5, 7, 6]]]
+    >>> base = [0, 2]
+    >>> g = Permutation([4, 2, 0, 1, 3, 5, 6, 7])
+    >>> transversals = get_transversals(base, gens)
+    >>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g)
+    [0, 1, 2, 3, 4, 5, 7, 6]
+
+    >>> g = Permutation([4, 1, 3, 0, 5, 2, 6, 7])
+    >>> double_coset_can_rep([list(range(6))], [0], base, gens, transversals, g)
+    0
+    """
+    size = g.size
+    g = g.array_form
+    num_dummies = size - 2
+    indices = list(range(num_dummies))
+    all_metrics_with_sym = not any(_ is None for _ in sym)
+    num_types = len(sym)
+    dumx = dummies[:]
+    dumx_flat = []
+    for dx in dumx:
+        dumx_flat.extend(dx)
+    b_S = b_S[:]
+    sgensx = [h._array_form for h in sgens]
+    if b_S:
+        S_transversals = transversal2coset(size, b_S, S_transversals)
+    # strong generating set for D
+    dsgsx = []
+    for i in range(num_types):
+        dsgsx.extend(dummy_sgs(dumx[i], sym[i], num_dummies))
+    idn = list(range(size))
+    # TAB = list of entries (s, d, h) where h = _af_rmuln(d,g,s)
+    # for short, in the following d*g*s means _af_rmuln(d,g,s)
+    TAB = [(idn, idn, g)]
+    for i in range(size - 2):
+        b = i
+        testb = b in b_S and sgensx
+        if testb:
+            sgensx1 = [_af_new(_) for _ in sgensx]
+            deltab = _orbit(size, sgensx1, b)
+        else:
+            deltab = {b}
+        # p1 = min(IMAGES) = min(Union D_p*h*deltab for h in TAB)
+        if all_metrics_with_sym:
+            md = _min_dummies(dumx, sym, indices)
+        else:
+            md = [min(_orbit(size, [_af_new(
+                ddx) for ddx in dsgsx], ii)) for ii in range(size - 2)]
+
+        p_i = min(min(md[h[x]] for x in deltab) for s, d, h in TAB)
+        dsgsx1 = [_af_new(_) for _ in dsgsx]
+        Dxtrav = _orbit_transversal(size, dsgsx1, p_i, False, af=True) \
+            if dsgsx else None
+        if Dxtrav:
+            Dxtrav = [_af_invert(x) for x in Dxtrav]
+        # compute the orbit of p_i
+        for ii in range(num_types):
+            if p_i in dumx[ii]:
+                # the orbit is made by all the indices in dum[ii]
+                if sym[ii] is not None:
+                    deltap = dumx[ii]
+                else:
+                    # the orbit is made by all the even indices if p_i
+                    # is even, by all the odd indices if p_i is odd
+                    p_i_index = dumx[ii].index(p_i) % 2
+                    deltap = dumx[ii][p_i_index::2]
+                break
+        else:
+            deltap = [p_i]
+        TAB1 = []
+        while TAB:
+            s, d, h = TAB.pop()
+            if min(md[h[x]] for x in deltab) != p_i:
+                continue
+            deltab1 = [x for x in deltab if md[h[x]] == p_i]
+            # NEXT = s*deltab1 intersection (d*g)**-1*deltap
+            dg = _af_rmul(d, g)
+            dginv = _af_invert(dg)
+            sdeltab = [s[x] for x in deltab1]
+            gdeltap = [dginv[x] for x in deltap]
+            NEXT = [x for x in sdeltab if x in gdeltap]
+            # d, s satisfy
+            # d*g*s*base[i-1] = p_{i-1}; using the stabilizers
+            # d*g*s*S_{base[0],...,base[i-1]}*base[i-1] =
+            # D_{p_0,...,p_{i-1}}*p_{i-1}
+            # so that to find d1, s1 satisfying d1*g*s1*b = p_i
+            # one can look for dx in D_{p_0,...,p_{i-1}} and
+            # sx in S_{base[0],...,base[i-1]}
+            # d1 = dx*d; s1 = s*sx
+            # d1*g*s1*b = dx*d*g*s*sx*b = p_i
+            for j in NEXT:
+                if testb:
+                    # solve s1*b = j with s1 = s*sx for some element sx
+                    # of the stabilizer of ..., base[i-1]
+                    # sx*b = s**-1*j; sx = _trace_S(s, j,...)
+                    # s1 = s*trace_S(s**-1*j,...)
+                    s1 = _trace_S(s, j, b, S_transversals)
+                    if not s1:
+                        continue
+                    else:
+                        s1 = [s[ix] for ix in s1]
+                else:
+                    s1 = s
+                # assert s1[b] == j  # invariant
+                # solve d1*g*j = p_i with d1 = dx*d for some element dg
+                # of the stabilizer of ..., p_{i-1}
+                # dx**-1*p_i = d*g*j; dx**-1 = trace_D(d*g*j,...)
+                # d1 = trace_D(d*g*j,...)**-1*d
+                # to save an inversion in the inner loop; notice we did
+                # Dxtrav = [perm_af_invert(x) for x in Dxtrav] out of the loop
+                if Dxtrav:
+                    d1 = _trace_D(dg[j], p_i, Dxtrav)
+                    if not d1:
+                        continue
+                else:
+                    if p_i != dg[j]:
+                        continue
+                    d1 = idn
+                assert d1[dg[j]] == p_i  # invariant
+                d1 = [d1[ix] for ix in d]
+                h1 = [d1[g[ix]] for ix in s1]
+                # assert h1[b] == p_i  # invariant
+                TAB1.append((s1, d1, h1))
+
+        # if TAB contains equal permutations, keep only one of them;
+        # if TAB contains equal permutations up to the sign, return 0
+        TAB1.sort(key=lambda x: x[-1])
+        prev = [0] * size
+        while TAB1:
+            s, d, h = TAB1.pop()
+            if h[:-2] == prev[:-2]:
+                if h[-1] != prev[-1]:
+                    return 0
+            else:
+                TAB.append((s, d, h))
+            prev = h
+
+        # stabilize the SGS
+        sgensx = [h for h in sgensx if h[b] == b]
+        if b in b_S:
+            b_S.remove(b)
+        _dumx_remove(dumx, dumx_flat, p_i)
+        dsgsx = []
+        for i in range(num_types):
+            dsgsx.extend(dummy_sgs(dumx[i], sym[i], num_dummies))
+    return TAB[0][-1]
+
+
+def canonical_free(base, gens, g, num_free):
+    """
+    Canonicalization of a tensor with respect to free indices
+    choosing the minimum with respect to lexicographical ordering
+    in the free indices.
+
+    Explanation
+    ===========
+
+    ``base``, ``gens``  BSGS for slot permutation group
+    ``g``               permutation representing the tensor
+    ``num_free``        number of free indices
+    The indices must be ordered with first the free indices
+
+    See explanation in double_coset_can_rep
+    The algorithm is a variation of the one given in [2].
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.tensor_can import canonical_free
+    >>> gens = [[1, 0, 2, 3, 5, 4], [2, 3, 0, 1, 4, 5],[0, 1, 3, 2, 5, 4]]
+    >>> gens = [Permutation(h) for h in gens]
+    >>> base = [0, 2]
+    >>> g = Permutation([2, 1, 0, 3, 4, 5])
+    >>> canonical_free(base, gens, g, 4)
+    [0, 3, 1, 2, 5, 4]
+
+    Consider the product of Riemann tensors
+    ``T = R^{a}_{d0}^{d1,d2}*R_{d2,d1}^{d0,b}``
+    The order of the indices is ``[a, b, d0, -d0, d1, -d1, d2, -d2]``
+    The permutation corresponding to the tensor is
+    ``g = [0, 3, 4, 6, 7, 5, 2, 1, 8, 9]``
+
+    In particular ``a`` is position ``0``, ``b`` is in position ``9``.
+    Use the slot symmetries to get `T` is a form which is the minimal
+    in lexicographic order in the free indices ``a`` and ``b``, e.g.
+    ``-R^{a}_{d0}^{d1,d2}*R^{b,d0}_{d2,d1}`` corresponding to
+    ``[0, 3, 4, 6, 1, 2, 7, 5, 9, 8]``
+
+    >>> from sympy.combinatorics.tensor_can import riemann_bsgs, tensor_gens
+    >>> base, gens = riemann_bsgs
+    >>> size, sbase, sgens = tensor_gens(base, gens, [[], []], 0)
+    >>> g = Permutation([0, 3, 4, 6, 7, 5, 2, 1, 8, 9])
+    >>> canonical_free(sbase, [Permutation(h) for h in sgens], g, 2)
+    [0, 3, 4, 6, 1, 2, 7, 5, 9, 8]
+    """
+    g = g.array_form
+    size = len(g)
+    if not base:
+        return g[:]
+
+    transversals = get_transversals(base, gens)
+    for x in sorted(g[:-2]):
+        if x not in base:
+            base.append(x)
+    h = g
+    for transv in transversals:
+        h_i = [size]*num_free
+        # find the element s in transversals[i] such that
+        # _af_rmul(h, s) has its free elements with the lowest position in h
+        s = None
+        for sk in transv.values():
+            h1 = _af_rmul(h, sk)
+            hi = [h1.index(ix) for ix in range(num_free)]
+            if hi < h_i:
+                h_i = hi
+                s = sk
+        if s:
+            h = _af_rmul(h, s)
+    return h
+
+
+def _get_map_slots(size, fixed_slots):
+    res = list(range(size))
+    pos = 0
+    for i in range(size):
+        if i in fixed_slots:
+            continue
+        res[i] = pos
+        pos += 1
+    return res
+
+
+def _lift_sgens(size, fixed_slots, free, s):
+    a = []
+    j = k = 0
+    fd = [y for _, y in sorted(zip(fixed_slots, free))]
+    num_free = len(free)
+    for i in range(size):
+        if i in fixed_slots:
+            a.append(fd[k])
+            k += 1
+        else:
+            a.append(s[j] + num_free)
+            j += 1
+    return a
+
+
+def canonicalize(g, dummies, msym, *v):
+    """
+    canonicalize tensor formed by tensors
+
+    Parameters
+    ==========
+
+    g : permutation representing the tensor
+
+    dummies : list representing the dummy indices
+      it can be a list of dummy indices of the same type
+      or a list of lists of dummy indices, one list for each
+      type of index;
+      the dummy indices must come after the free indices,
+      and put in order contravariant, covariant
+      [d0, -d0, d1,-d1,...]
+
+    msym :  symmetry of the metric(s)
+        it can be an integer or a list;
+        in the first case it is the symmetry of the dummy index metric;
+        in the second case it is the list of the symmetries of the
+        index metric for each type
+
+    v : list, (base_i, gens_i, n_i, sym_i) for tensors of type `i`
+
+    base_i, gens_i : BSGS for tensors of this type.
+        The BSGS should have minimal base under lexicographic ordering;
+        if not, an attempt is made do get the minimal BSGS;
+        in case of failure,
+        canonicalize_naive is used, which is much slower.
+
+    n_i :    number of tensors of type `i`.
+
+    sym_i :  symmetry under exchange of component tensors of type `i`.
+
+        Both for msym and sym_i the cases are
+            * None  no symmetry
+            * 0     commuting
+            * 1     anticommuting
+
+    Returns
+    =======
+
+    0 if the tensor is zero, else return the array form of
+    the permutation representing the canonical form of the tensor.
+
+    Algorithm
+    =========
+
+    First one uses canonical_free to get the minimum tensor under
+    lexicographic order, using only the slot symmetries.
+    If the component tensors have not minimal BSGS, it is attempted
+    to find it; if the attempt fails canonicalize_naive
+    is used instead.
+
+    Compute the residual slot symmetry keeping fixed the free indices
+    using tensor_gens(base, gens, list_free_indices, sym).
+
+    Reduce the problem eliminating the free indices.
+
+    Then use double_coset_can_rep and lift back the result reintroducing
+    the free indices.
+
+    Examples
+    ========
+
+    one type of index with commuting metric;
+
+    `A_{a b}` and `B_{a b}` antisymmetric and commuting
+
+    `T = A_{d0 d1} * B^{d0}{}_{d2} * B^{d2 d1}`
+
+    `ord = [d0,-d0,d1,-d1,d2,-d2]` order of the indices
+
+    g = [1, 3, 0, 5, 4, 2, 6, 7]
+
+    `T_c = 0`
+
+    >>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, canonicalize, bsgs_direct_product
+    >>> from sympy.combinatorics import Permutation
+    >>> base2a, gens2a = get_symmetric_group_sgs(2, 1)
+    >>> t0 = (base2a, gens2a, 1, 0)
+    >>> t1 = (base2a, gens2a, 2, 0)
+    >>> g = Permutation([1, 3, 0, 5, 4, 2, 6, 7])
+    >>> canonicalize(g, range(6), 0, t0, t1)
+    0
+
+    same as above, but with `B_{a b}` anticommuting
+
+    `T_c = -A^{d0 d1} * B_{d0}{}^{d2} * B_{d1 d2}`
+
+    can = [0,2,1,4,3,5,7,6]
+
+    >>> t1 = (base2a, gens2a, 2, 1)
+    >>> canonicalize(g, range(6), 0, t0, t1)
+    [0, 2, 1, 4, 3, 5, 7, 6]
+
+    two types of indices `[a,b,c,d,e,f]` and `[m,n]`, in this order,
+    both with commuting metric
+
+    `f^{a b c}` antisymmetric, commuting
+
+    `A_{m a}` no symmetry, commuting
+
+    `T = f^c{}_{d a} * f^f{}_{e b} * A_m{}^d * A^{m b} * A_n{}^a * A^{n e}`
+
+    ord = [c,f,a,-a,b,-b,d,-d,e,-e,m,-m,n,-n]
+
+    g = [0,7,3, 1,9,5, 11,6, 10,4, 13,2, 12,8, 14,15]
+
+    The canonical tensor is
+    `T_c = -f^{c a b} * f^{f d e} * A^m{}_a * A_{m d} * A^n{}_b * A_{n e}`
+
+    can = [0,2,4, 1,6,8, 10,3, 11,7, 12,5, 13,9, 15,14]
+
+    >>> base_f, gens_f = get_symmetric_group_sgs(3, 1)
+    >>> base1, gens1 = get_symmetric_group_sgs(1)
+    >>> base_A, gens_A = bsgs_direct_product(base1, gens1, base1, gens1)
+    >>> t0 = (base_f, gens_f, 2, 0)
+    >>> t1 = (base_A, gens_A, 4, 0)
+    >>> dummies = [range(2, 10), range(10, 14)]
+    >>> g = Permutation([0, 7, 3, 1, 9, 5, 11, 6, 10, 4, 13, 2, 12, 8, 14, 15])
+    >>> canonicalize(g, dummies, [0, 0], t0, t1)
+    [0, 2, 4, 1, 6, 8, 10, 3, 11, 7, 12, 5, 13, 9, 15, 14]
+    """
+    from sympy.combinatorics.testutil import canonicalize_naive
+    if not isinstance(msym, list):
+        if msym not in (0, 1, None):
+            raise ValueError('msym must be 0, 1 or None')
+        num_types = 1
+    else:
+        num_types = len(msym)
+        if not all(msymx in (0, 1, None) for msymx in msym):
+            raise ValueError('msym entries must be 0, 1 or None')
+        if len(dummies) != num_types:
+            raise ValueError(
+                'dummies and msym must have the same number of elements')
+    size = g.size
+    num_tensors = 0
+    v1 = []
+    for base_i, gens_i, n_i, sym_i in v:
+        # check that the BSGS is minimal;
+        # this property is used in double_coset_can_rep;
+        # if it is not minimal use canonicalize_naive
+        if not _is_minimal_bsgs(base_i, gens_i):
+            mbsgs = get_minimal_bsgs(base_i, gens_i)
+            if not mbsgs:
+                can = canonicalize_naive(g, dummies, msym, *v)
+                return can
+            base_i, gens_i = mbsgs
+        v1.append((base_i, gens_i, [[]] * n_i, sym_i))
+        num_tensors += n_i
+
+    if num_types == 1 and not isinstance(msym, list):
+        dummies = [dummies]
+        msym = [msym]
+    flat_dummies = []
+    for dumx in dummies:
+        flat_dummies.extend(dumx)
+
+    if flat_dummies and flat_dummies != list(range(flat_dummies[0], flat_dummies[-1] + 1)):
+        raise ValueError('dummies is not valid')
+
+    # slot symmetry of the tensor
+    size1, sbase, sgens = gens_products(*v1)
+    if size != size1:
+        raise ValueError(
+            'g has size %d, generators have size %d' % (size, size1))
+    free = [i for i in range(size - 2) if i not in flat_dummies]
+    num_free = len(free)
+
+    # g1 minimal tensor under slot symmetry
+    g1 = canonical_free(sbase, sgens, g, num_free)
+    if not flat_dummies:
+        return g1
+    # save the sign of g1
+    sign = 0 if g1[-1] == size - 1 else 1
+
+    # the free indices are kept fixed.
+    # Determine free_i, the list of slots of tensors which are fixed
+    # since they are occupied by free indices, which are fixed.
+    start = 0
+    for i, (base_i, gens_i, n_i, sym_i) in enumerate(v):
+        free_i = []
+        len_tens = gens_i[0].size - 2
+        # for each component tensor get a list od fixed islots
+        for j in range(n_i):
+            # get the elements corresponding to the component tensor
+            h = g1[start:(start + len_tens)]
+            fr = []
+            # get the positions of the fixed elements in h
+            for k in free:
+                if k in h:
+                    fr.append(h.index(k))
+            free_i.append(fr)
+            start += len_tens
+        v1[i] = (base_i, gens_i, free_i, sym_i)
+    # BSGS of the tensor with fixed free indices
+    # if tensor_gens fails in gens_product, use canonicalize_naive
+    size, sbase, sgens = gens_products(*v1)
+
+    # reduce the permutations getting rid of the free indices
+    pos_free = [g1.index(x) for x in range(num_free)]
+    size_red = size - num_free
+    g1_red = [x - num_free for x in g1 if x in flat_dummies]
+    if sign:
+        g1_red.extend([size_red - 1, size_red - 2])
+    else:
+        g1_red.extend([size_red - 2, size_red - 1])
+    map_slots = _get_map_slots(size, pos_free)
+    sbase_red = [map_slots[i] for i in sbase if i not in pos_free]
+    sgens_red = [_af_new([map_slots[i] for i in y._array_form if i not in pos_free]) for y in sgens]
+    dummies_red = [[x - num_free for x in y] for y in dummies]
+    transv_red = get_transversals(sbase_red, sgens_red)
+    g1_red = _af_new(g1_red)
+    g2 = double_coset_can_rep(
+        dummies_red, msym, sbase_red, sgens_red, transv_red, g1_red)
+    if g2 == 0:
+        return 0
+    # lift to the case with the free indices
+    g3 = _lift_sgens(size, pos_free, free, g2)
+    return g3
+
+
+def perm_af_direct_product(gens1, gens2, signed=True):
+    """
+    Direct products of the generators gens1 and gens2.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import perm_af_direct_product
+    >>> gens1 = [[1, 0, 2, 3], [0, 1, 3, 2]]
+    >>> gens2 = [[1, 0]]
+    >>> perm_af_direct_product(gens1, gens2, False)
+    [[1, 0, 2, 3, 4, 5], [0, 1, 3, 2, 4, 5], [0, 1, 2, 3, 5, 4]]
+    >>> gens1 = [[1, 0, 2, 3, 5, 4], [0, 1, 3, 2, 4, 5]]
+    >>> gens2 = [[1, 0, 2, 3]]
+    >>> perm_af_direct_product(gens1, gens2, True)
+    [[1, 0, 2, 3, 4, 5, 7, 6], [0, 1, 3, 2, 4, 5, 6, 7], [0, 1, 2, 3, 5, 4, 6, 7]]
+    """
+    gens1 = [list(x) for x in gens1]
+    gens2 = [list(x) for x in gens2]
+    s = 2 if signed else 0
+    n1 = len(gens1[0]) - s
+    n2 = len(gens2[0]) - s
+    start = list(range(n1))
+    end = list(range(n1, n1 + n2))
+    if signed:
+        gens1 = [gen[:-2] + end + [gen[-2] + n2, gen[-1] + n2]
+                 for gen in gens1]
+        gens2 = [start + [x + n1 for x in gen] for gen in gens2]
+    else:
+        gens1 = [gen + end for gen in gens1]
+        gens2 = [start + [x + n1 for x in gen] for gen in gens2]
+
+    res = gens1 + gens2
+
+    return res
+
+
+def bsgs_direct_product(base1, gens1, base2, gens2, signed=True):
+    """
+    Direct product of two BSGS.
+
+    Parameters
+    ==========
+
+    base1 : base of the first BSGS.
+
+    gens1 : strong generating sequence of the first BSGS.
+
+    base2, gens2 : similarly for the second BSGS.
+
+    signed : flag for signed permutations.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import (get_symmetric_group_sgs, bsgs_direct_product)
+    >>> base1, gens1 = get_symmetric_group_sgs(1)
+    >>> base2, gens2 = get_symmetric_group_sgs(2)
+    >>> bsgs_direct_product(base1, gens1, base2, gens2)
+    ([1], [(4)(1 2)])
+    """
+    s = 2 if signed else 0
+    n1 = gens1[0].size - s
+    base = list(base1)
+    base += [x + n1 for x in base2]
+    gens1 = [h._array_form for h in gens1]
+    gens2 = [h._array_form for h in gens2]
+    gens = perm_af_direct_product(gens1, gens2, signed)
+    size = len(gens[0])
+    id_af = list(range(size))
+    gens = [h for h in gens if h != id_af]
+    if not gens:
+        gens = [id_af]
+    return base, [_af_new(h) for h in gens]
+
+
+def get_symmetric_group_sgs(n, antisym=False):
+    """
+    Return base, gens of the minimal BSGS for (anti)symmetric tensor
+
+    Parameters
+    ==========
+
+    n : rank of the tensor
+    antisym : bool
+        ``antisym = False`` symmetric tensor
+        ``antisym = True``  antisymmetric tensor
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs
+    >>> get_symmetric_group_sgs(3)
+    ([0, 1], [(4)(0 1), (4)(1 2)])
+    """
+    if n == 1:
+        return [], [_af_new(list(range(3)))]
+    gens = [Permutation(n - 1)(i, i + 1)._array_form for i in range(n - 1)]
+    if antisym == 0:
+        gens = [x + [n, n + 1] for x in gens]
+    else:
+        gens = [x + [n + 1, n] for x in gens]
+    base = list(range(n - 1))
+    return base, [_af_new(h) for h in gens]
+
+riemann_bsgs = [0, 2], [Permutation(0, 1)(4, 5), Permutation(2, 3)(4, 5),
+                        Permutation(5)(0, 2)(1, 3)]
+
+
+def get_transversals(base, gens):
+    """
+    Return transversals for the group with BSGS base, gens
+    """
+    if not base:
+        return []
+    stabs = _distribute_gens_by_base(base, gens)
+    orbits, transversals = _orbits_transversals_from_bsgs(base, stabs)
+    transversals = [{x: h._array_form for x, h in y.items()} for y in
+                    transversals]
+    return transversals
+
+
+def _is_minimal_bsgs(base, gens):
+    """
+    Check if the BSGS has minimal base under lexigographic order.
+
+    base, gens BSGS
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.tensor_can import riemann_bsgs, _is_minimal_bsgs
+    >>> _is_minimal_bsgs(*riemann_bsgs)
+    True
+    >>> riemann_bsgs1 = ([2, 0], ([Permutation(5)(0, 1)(4, 5), Permutation(5)(0, 2)(1, 3)]))
+    >>> _is_minimal_bsgs(*riemann_bsgs1)
+    False
+    """
+    base1 = []
+    sgs1 = gens[:]
+    size = gens[0].size
+    for i in range(size):
+        if not all(h._array_form[i] == i for h in sgs1):
+            base1.append(i)
+            sgs1 = [h for h in sgs1 if h._array_form[i] == i]
+    return base1 == base
+
+
+def get_minimal_bsgs(base, gens):
+    """
+    Compute a minimal GSGS
+
+    base, gens BSGS
+
+    If base, gens is a minimal BSGS return it; else return a minimal BSGS
+    if it fails in finding one, it returns None
+
+    TODO: use baseswap in the case in which if it fails in finding a
+    minimal BSGS
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.combinatorics.tensor_can import get_minimal_bsgs
+    >>> riemann_bsgs1 = ([2, 0], ([Permutation(5)(0, 1)(4, 5), Permutation(5)(0, 2)(1, 3)]))
+    >>> get_minimal_bsgs(*riemann_bsgs1)
+    ([0, 2], [(0 1)(4 5), (5)(0 2)(1 3), (2 3)(4 5)])
+    """
+    G = PermutationGroup(gens)
+    base, gens = G.schreier_sims_incremental()
+    if not _is_minimal_bsgs(base, gens):
+        return None
+    return base, gens
+
+
+def tensor_gens(base, gens, list_free_indices, sym=0):
+    """
+    Returns size, res_base, res_gens BSGS for n tensors of the
+    same type.
+
+    Explanation
+    ===========
+
+    base, gens BSGS for tensors of this type
+    list_free_indices  list of the slots occupied by fixed indices
+                       for each of the tensors
+
+    sym symmetry under commutation of two tensors
+    sym   None  no symmetry
+    sym   0     commuting
+    sym   1     anticommuting
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import tensor_gens, get_symmetric_group_sgs
+
+    two symmetric tensors with 3 indices without free indices
+
+    >>> base, gens = get_symmetric_group_sgs(3)
+    >>> tensor_gens(base, gens, [[], []])
+    (8, [0, 1, 3, 4], [(7)(0 1), (7)(1 2), (7)(3 4), (7)(4 5), (7)(0 3)(1 4)(2 5)])
+
+    two symmetric tensors with 3 indices with free indices in slot 1 and 0
+
+    >>> tensor_gens(base, gens, [[1], [0]])
+    (8, [0, 4], [(7)(0 2), (7)(4 5)])
+
+    four symmetric tensors with 3 indices, two of which with free indices
+
+    """
+    def _get_bsgs(G, base, gens, free_indices):
+        """
+        return the BSGS for G.pointwise_stabilizer(free_indices)
+        """
+        if not free_indices:
+            return base[:], gens[:]
+        else:
+            H = G.pointwise_stabilizer(free_indices)
+            base, sgs = H.schreier_sims_incremental()
+            return base, sgs
+
+    # if not base there is no slot symmetry for the component tensors
+    # if list_free_indices.count([]) < 2 there is no commutation symmetry
+    # so there is no resulting slot symmetry
+    if not base and list_free_indices.count([]) < 2:
+        n = len(list_free_indices)
+        size = gens[0].size
+        size = n * (size - 2) + 2
+        return size, [], [_af_new(list(range(size)))]
+
+    # if any(list_free_indices) one needs to compute the pointwise
+    # stabilizer, so G is needed
+    if any(list_free_indices):
+        G = PermutationGroup(gens)
+    else:
+        G = None
+
+    # no_free list of lists of indices for component tensors without fixed
+    # indices
+    no_free = []
+    size = gens[0].size
+    id_af = list(range(size))
+    num_indices = size - 2
+    if not list_free_indices[0]:
+        no_free.append(list(range(num_indices)))
+    res_base, res_gens = _get_bsgs(G, base, gens, list_free_indices[0])
+    for i in range(1, len(list_free_indices)):
+        base1, gens1 = _get_bsgs(G, base, gens, list_free_indices[i])
+        res_base, res_gens = bsgs_direct_product(res_base, res_gens,
+                                                 base1, gens1, 1)
+        if not list_free_indices[i]:
+            no_free.append(list(range(size - 2, size - 2 + num_indices)))
+        size += num_indices
+    nr = size - 2
+    res_gens = [h for h in res_gens if h._array_form != id_af]
+    # if sym there are no commuting tensors stop here
+    if sym is None or not no_free:
+        if not res_gens:
+            res_gens = [_af_new(id_af)]
+        return size, res_base, res_gens
+
+    # if the component tensors have moinimal BSGS, so is their direct
+    # product P; the slot symmetry group is S = P*C, where C is the group
+    # to (anti)commute the component tensors with no free indices
+    # a stabilizer has the property S_i = P_i*C_i;
+    # the BSGS of P*C has SGS_P + SGS_C and the base is
+    # the ordered union of the bases of P and C.
+    # If P has minimal BSGS, so has S with this base.
+    base_comm = []
+    for i in range(len(no_free) - 1):
+        ind1 = no_free[i]
+        ind2 = no_free[i + 1]
+        a = list(range(ind1[0]))
+        a.extend(ind2)
+        a.extend(ind1)
+        base_comm.append(ind1[0])
+        a.extend(list(range(ind2[-1] + 1, nr)))
+        if sym == 0:
+            a.extend([nr, nr + 1])
+        else:
+            a.extend([nr + 1, nr])
+        res_gens.append(_af_new(a))
+    res_base = list(res_base)
+    # each base is ordered; order the union of the two bases
+    for i in base_comm:
+        if i not in res_base:
+            res_base.append(i)
+    res_base.sort()
+    if not res_gens:
+        res_gens = [_af_new(id_af)]
+
+    return size, res_base, res_gens
+
+
+def gens_products(*v):
+    """
+    Returns size, res_base, res_gens BSGS for n tensors of different types.
+
+    Explanation
+    ===========
+
+    v is a sequence of (base_i, gens_i, free_i, sym_i)
+    where
+    base_i, gens_i  BSGS of tensor of type `i`
+    free_i          list of the fixed slots for each of the tensors
+                    of type `i`; if there are `n_i` tensors of type `i`
+                    and none of them have fixed slots, `free = [[]]*n_i`
+    sym   0 (1) if the tensors of type `i` (anti)commute among themselves
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, gens_products
+    >>> base, gens = get_symmetric_group_sgs(2)
+    >>> gens_products((base, gens, [[], []], 0))
+    (6, [0, 2], [(5)(0 1), (5)(2 3), (5)(0 2)(1 3)])
+    >>> gens_products((base, gens, [[1], []], 0))
+    (6, [2], [(5)(2 3)])
+    """
+    res_size, res_base, res_gens = tensor_gens(*v[0])
+    for i in range(1, len(v)):
+        size, base, gens = tensor_gens(*v[i])
+        res_base, res_gens = bsgs_direct_product(res_base, res_gens, base,
+                                                 gens, 1)
+    res_size = res_gens[0].size
+    id_af = list(range(res_size))
+    res_gens = [h for h in res_gens if h != id_af]
+    if not res_gens:
+        res_gens = [id_af]
+    return res_size, res_base, res_gens
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3cee7e97c716b2d41c64c8985dd8f8584d9ac87c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73dd9a4d43f84a615e14baf7e6725594f02b733a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_coset_table.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_fp_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_fp_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9cba46d109f812af771ca3662785a00073a8c4e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_fp_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_free_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_free_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c393c76c9fe17000b70e4b41e11a45ab0c9bc94
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_free_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_galois.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_galois.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65d7729a7f22c5fefa280ef27bc4e1eccdb8ba8b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_galois.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_generators.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_generators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f8e530f6839dfe2addac631d873d008da649bfe
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_generators.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fef0a9a8232e0ae451274d6c2c0549e576c94ccd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_graycode.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3c5354340d86509a1b2479fe342fd8ce0cae321
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_constructs.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6036266ed33f6c8bc163e35c11dc0464f65fefc3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_group_numbers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45baa35cfe82b6925fd9dac8470d50bdf54fd362
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_homomorphisms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_named_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_named_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a6103a3431979754041b4adf6a7d6b494fa8904
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_named_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_partitions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_partitions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc79ce40b5cb7540288e8c3dbb23a6356e984417
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_partitions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_pc_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_pc_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ae06da399918fa438bb013a49a2b76a3aab0459
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_pc_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..941dff61a0a2d2b6d38b444e4eda50bcc71259ec
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_perm_groups.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_permutations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_permutations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..76abe5a0b08e019f1f37bc6e77c49484aab46046
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_permutations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_polyhedron.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_polyhedron.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94778f8b651300fbd200dc8fc3cc26522a01bed3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_polyhedron.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e93022b1881ce800b7fdc9315c089b2853184ddf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_prufer.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_rewriting.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_rewriting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa12dc0f5b767e10ff605a6577e71fd786d086e1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_rewriting.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_schur_number.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_schur_number.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f390a91f825b17e2d5df05001ce10c18da1a9925
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_schur_number.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_subsets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_subsets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f03cfa9a68bf4bda10a6aa3082c234d4e6a1173
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_subsets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_tensor_can.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_tensor_can.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7146a8ba76c4ab484e6bdb6c3ed5382b09156e5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_tensor_can.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_testutil.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_testutil.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54803becf231d3b1da9eaeedce2e2fd14a386cb3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_testutil.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a730412948bc9d3c397dc41839774677a1b52fac
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/__pycache__/test_util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_coset_table.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_coset_table.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab3f62880445c5deb526797ee0623fe3510bcbc3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_coset_table.py
@@ -0,0 +1,825 @@
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.coset_table import (CosetTable,
+                    coset_enumeration_r, coset_enumeration_c)
+from sympy.combinatorics.coset_table import modified_coset_enumeration_r
+from sympy.combinatorics.free_groups import free_group
+
+from sympy.testing.pytest import slow
+
+"""
+References
+==========
+
+[1] Holt, D., Eick, B., O'Brien, E.
+"Handbook of Computational Group Theory"
+
+[2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+"Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+"""
+
+def test_scan_1():
+    # Example 5.1 from [1]
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    c = CosetTable(f, [x])
+
+    c.scan_and_fill(0, x)
+    assert c.table == [[0, 0, None, None]]
+    assert c.p == [0]
+    assert c.n == 1
+    assert c.omega == [0]
+
+    c.scan_and_fill(0, x**3)
+    assert c.table == [[0, 0, None, None]]
+    assert c.p == [0]
+    assert c.n == 1
+    assert c.omega == [0]
+
+    c.scan_and_fill(0, y**3)
+    assert c.table == [[0, 0, 1, 2], [None, None, 2, 0], [None, None, 0, 1]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(0, x**-1*y**-1*x*y)
+    assert c.table == [[0, 0, 1, 2], [None, None, 2, 0], [2, 2, 0, 1]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, x**3)
+    assert c.table == [[0, 0, 1, 2], [3, 4, 2, 0], [2, 2, 0, 1], \
+            [4, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(1, y**3)
+    assert c.table == [[0, 0, 1, 2], [3, 4, 2, 0], [2, 2, 0, 1], \
+            [4, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(1, x**-1*y**-1*x*y)
+    assert c.table == [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1], \
+            [None, 1, None, None], [1, 3, None, None]]
+    assert c.p == [0, 1, 2, 1, 1]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    # Example 5.2 from [1]
+    f = FpGroup(F, [x**2, y**3, (x*y)**3])
+    c = CosetTable(f, [x*y])
+
+    c.scan_and_fill(0, x*y)
+    assert c.table == [[1, None, None, 1], [None, 0, 0, None]]
+    assert c.p == [0, 1]
+    assert c.n == 2
+    assert c.omega == [0, 1]
+
+    c.scan_and_fill(0, x**2)
+    assert c.table == [[1, 1, None, 1], [0, 0, 0, None]]
+    assert c.p == [0, 1]
+    assert c.n == 2
+    assert c.omega == [0, 1]
+
+    c.scan_and_fill(0, y**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(0, (x*y)**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, x**2)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, y**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [None, None, 1, 0]]
+    assert c.p == [0, 1, 2]
+    assert c.n == 3
+    assert c.omega == [0, 1, 2]
+
+    c.scan_and_fill(1, (x*y)**3)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [3, 4, 1, 0], [None, 2, 4, None], [2, None, None, 3]]
+    assert c.p == [0, 1, 2, 3, 4]
+    assert c.n == 5
+    assert c.omega == [0, 1, 2, 3, 4]
+
+    c.scan_and_fill(2, x**2)
+    assert c.table == [[1, 1, 2, 1], [0, 0, 0, 2], [3, 3, 1, 0], [2, 2, 3, 3], [2, None, None, 3]]
+    assert c.p == [0, 1, 2, 3, 3]
+    assert c.n == 4
+    assert c.omega == [0, 1, 2, 3]
+
+
+@slow
+def test_coset_enumeration():
+    # this test function contains the combined tests for the two strategies
+    # i.e. HLT and Felsch strategies.
+
+    # Example 5.1 from [1]
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    C_r = coset_enumeration_r(f, [x])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(f, [x])
+    C_c.compress(); C_c.standardize()
+    table1 = [[0, 0, 1, 2], [1, 1, 2, 0], [2, 2, 0, 1]]
+    assert C_r.table == table1
+    assert C_c.table == table1
+
+    # E1 from [2] Pg. 474
+    F, r, s, t = free_group("r, s, t")
+    E1 = FpGroup(F, [t**-1*r*t*r**-2, r**-1*s*r*s**-2, s**-1*t*s*t**-2])
+    C_r = coset_enumeration_r(E1, [])
+    C_r.compress()
+    C_c = coset_enumeration_c(E1, [])
+    C_c.compress()
+    table2 = [[0, 0, 0, 0, 0, 0]]
+    assert C_r.table == table2
+    # test for issue #11449
+    assert C_c.table == table2
+
+    # Cox group from [2] Pg. 474
+    F, a, b = free_group("a, b")
+    Cox = FpGroup(F, [a**6, b**6, (a*b)**2, (a**2*b**2)**2, (a**3*b**3)**5])
+    C_r = coset_enumeration_r(Cox, [a])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(Cox, [a])
+    C_c.compress(); C_c.standardize()
+    table3 = [[0, 0, 1, 2],
+             [2, 3, 4, 0],
+             [5, 1, 0, 6],
+             [1, 7, 8, 9],
+             [9, 10, 11, 1],
+             [12, 2, 9, 13],
+             [14, 9, 2, 11],
+             [3, 12, 15, 16],
+             [16, 17, 18, 3],
+             [6, 4, 3, 5],
+             [4, 19, 20, 21],
+             [21, 22, 6, 4],
+             [7, 5, 23, 24],
+             [25, 23, 5, 18],
+             [19, 6, 22, 26],
+             [24, 27, 28, 7],
+             [29, 8, 7, 30],
+             [8, 31, 32, 33],
+             [33, 34, 13, 8],
+             [10, 14, 35, 35],
+             [35, 36, 37, 10],
+             [30, 11, 10, 29],
+             [11, 38, 39, 14],
+             [13, 39, 38, 12],
+             [40, 15, 12, 41],
+             [42, 13, 34, 43],
+             [44, 35, 14, 45],
+             [15, 46, 47, 34],
+             [34, 48, 49, 15],
+             [50, 16, 21, 51],
+             [52, 21, 16, 49],
+             [17, 50, 53, 54],
+             [54, 55, 56, 17],
+             [41, 18, 17, 40],
+             [18, 28, 27, 25],
+             [26, 20, 19, 19],
+             [20, 57, 58, 59],
+             [59, 60, 51, 20],
+             [22, 52, 61, 23],
+             [23, 62, 63, 22],
+             [64, 24, 33, 65],
+             [48, 33, 24, 61],
+             [62, 25, 54, 66],
+             [67, 54, 25, 68],
+             [57, 26, 59, 69],
+             [70, 59, 26, 63],
+             [27, 64, 71, 72],
+             [72, 73, 68, 27],
+             [28, 41, 74, 75],
+             [75, 76, 30, 28],
+             [31, 29, 77, 78],
+             [79, 77, 29, 37],
+             [38, 30, 76, 80],
+             [78, 81, 82, 31],
+             [43, 32, 31, 42],
+             [32, 83, 84, 85],
+             [85, 86, 65, 32],
+             [36, 44, 87, 88],
+             [88, 89, 90, 36],
+             [45, 37, 36, 44],
+             [37, 82, 81, 79],
+             [80, 74, 41, 38],
+             [39, 42, 91, 92],
+             [92, 93, 45, 39],
+             [46, 40, 94, 95],
+             [96, 94, 40, 56],
+             [97, 91, 42, 82],
+             [83, 43, 98, 99],
+             [100, 98, 43, 47],
+             [101, 87, 44, 90],
+             [82, 45, 93, 97],
+             [95, 102, 103, 46],
+             [104, 47, 46, 105],
+             [47, 106, 107, 100],
+             [61, 108, 109, 48],
+             [105, 49, 48, 104],
+             [49, 110, 111, 52],
+             [51, 111, 110, 50],
+             [112, 53, 50, 113],
+             [114, 51, 60, 115],
+             [116, 61, 52, 117],
+             [53, 118, 119, 60],
+             [60, 70, 66, 53],
+             [55, 67, 120, 121],
+             [121, 122, 123, 55],
+             [113, 56, 55, 112],
+             [56, 103, 102, 96],
+             [69, 124, 125, 57],
+             [115, 58, 57, 114],
+             [58, 126, 127, 128],
+             [128, 128, 69, 58],
+             [66, 129, 130, 62],
+             [117, 63, 62, 116],
+             [63, 125, 124, 70],
+             [65, 109, 108, 64],
+             [131, 71, 64, 132],
+             [133, 65, 86, 134],
+             [135, 66, 70, 136],
+             [68, 130, 129, 67],
+             [137, 120, 67, 138],
+             [132, 68, 73, 131],
+             [139, 69, 128, 140],
+             [71, 141, 142, 86],
+             [86, 143, 144, 71],
+             [145, 72, 75, 146],
+             [147, 75, 72, 144],
+             [73, 145, 148, 120],
+             [120, 149, 150, 73],
+             [74, 151, 152, 94],
+             [94, 153, 146, 74],
+             [76, 147, 154, 77],
+             [77, 155, 156, 76],
+             [157, 78, 85, 158],
+             [143, 85, 78, 154],
+             [155, 79, 88, 159],
+             [160, 88, 79, 161],
+             [151, 80, 92, 162],
+             [163, 92, 80, 156],
+             [81, 157, 164, 165],
+             [165, 166, 161, 81],
+             [99, 107, 106, 83],
+             [134, 84, 83, 133],
+             [84, 167, 168, 169],
+             [169, 170, 158, 84],
+             [87, 171, 172, 93],
+             [93, 163, 159, 87],
+             [89, 160, 173, 174],
+             [174, 175, 176, 89],
+             [90, 90, 89, 101],
+             [91, 177, 178, 98],
+             [98, 179, 162, 91],
+             [180, 95, 100, 181],
+             [179, 100, 95, 152],
+             [153, 96, 121, 148],
+             [182, 121, 96, 183],
+             [177, 97, 165, 184],
+             [185, 165, 97, 172],
+             [186, 99, 169, 187],
+             [188, 169, 99, 178],
+             [171, 101, 174, 189],
+             [190, 174, 101, 176],
+             [102, 180, 191, 192],
+             [192, 193, 183, 102],
+             [103, 113, 194, 195],
+             [195, 196, 105, 103],
+             [106, 104, 197, 198],
+             [199, 197, 104, 109],
+             [110, 105, 196, 200],
+             [198, 201, 133, 106],
+             [107, 186, 202, 203],
+             [203, 204, 181, 107],
+             [108, 116, 205, 206],
+             [206, 207, 132, 108],
+             [109, 133, 201, 199],
+             [200, 194, 113, 110],
+             [111, 114, 208, 209],
+             [209, 210, 117, 111],
+             [118, 112, 211, 212],
+             [213, 211, 112, 123],
+             [214, 208, 114, 125],
+             [126, 115, 215, 216],
+             [217, 215, 115, 119],
+             [218, 205, 116, 130],
+             [125, 117, 210, 214],
+             [212, 219, 220, 118],
+             [136, 119, 118, 135],
+             [119, 221, 222, 217],
+             [122, 182, 223, 224],
+             [224, 225, 226, 122],
+             [138, 123, 122, 137],
+             [123, 220, 219, 213],
+             [124, 139, 227, 228],
+             [228, 229, 136, 124],
+             [216, 222, 221, 126],
+             [140, 127, 126, 139],
+             [127, 230, 231, 232],
+             [232, 233, 140, 127],
+             [129, 135, 234, 235],
+             [235, 236, 138, 129],
+             [130, 132, 207, 218],
+             [141, 131, 237, 238],
+             [239, 237, 131, 150],
+             [167, 134, 240, 241],
+             [242, 240, 134, 142],
+             [243, 234, 135, 220],
+             [221, 136, 229, 244],
+             [149, 137, 245, 246],
+             [247, 245, 137, 226],
+             [220, 138, 236, 243],
+             [244, 227, 139, 221],
+             [230, 140, 233, 248],
+             [238, 249, 250, 141],
+             [251, 142, 141, 252],
+             [142, 253, 254, 242],
+             [154, 255, 256, 143],
+             [252, 144, 143, 251],
+             [144, 257, 258, 147],
+             [146, 258, 257, 145],
+             [259, 148, 145, 260],
+             [261, 146, 153, 262],
+             [263, 154, 147, 264],
+             [148, 265, 266, 153],
+             [246, 267, 268, 149],
+             [260, 150, 149, 259],
+             [150, 250, 249, 239],
+             [162, 269, 270, 151],
+             [262, 152, 151, 261],
+             [152, 271, 272, 179],
+             [159, 273, 274, 155],
+             [264, 156, 155, 263],
+             [156, 270, 269, 163],
+             [158, 256, 255, 157],
+             [275, 164, 157, 276],
+             [277, 158, 170, 278],
+             [279, 159, 163, 280],
+             [161, 274, 273, 160],
+             [281, 173, 160, 282],
+             [276, 161, 166, 275],
+             [283, 162, 179, 284],
+             [164, 285, 286, 170],
+             [170, 188, 184, 164],
+             [166, 185, 189, 173],
+             [173, 287, 288, 166],
+             [241, 254, 253, 167],
+             [278, 168, 167, 277],
+             [168, 289, 290, 291],
+             [291, 292, 187, 168],
+             [189, 293, 294, 171],
+             [280, 172, 171, 279],
+             [172, 295, 296, 185],
+             [175, 190, 297, 297],
+             [297, 298, 299, 175],
+             [282, 176, 175, 281],
+             [176, 294, 293, 190],
+             [184, 296, 295, 177],
+             [284, 178, 177, 283],
+             [178, 300, 301, 188],
+             [181, 272, 271, 180],
+             [302, 191, 180, 303],
+             [304, 181, 204, 305],
+             [183, 266, 265, 182],
+             [306, 223, 182, 307],
+             [303, 183, 193, 302],
+             [308, 184, 188, 309],
+             [310, 189, 185, 311],
+             [187, 301, 300, 186],
+             [305, 202, 186, 304],
+             [312, 187, 292, 313],
+             [314, 297, 190, 315],
+             [191, 316, 317, 204],
+             [204, 318, 319, 191],
+             [320, 192, 195, 321],
+             [322, 195, 192, 319],
+             [193, 320, 323, 223],
+             [223, 324, 325, 193],
+             [194, 326, 327, 211],
+             [211, 328, 321, 194],
+             [196, 322, 329, 197],
+             [197, 330, 331, 196],
+             [332, 198, 203, 333],
+             [318, 203, 198, 329],
+             [330, 199, 206, 334],
+             [335, 206, 199, 336],
+             [326, 200, 209, 337],
+             [338, 209, 200, 331],
+             [201, 332, 339, 240],
+             [240, 340, 336, 201],
+             [202, 341, 342, 292],
+             [292, 343, 333, 202],
+             [205, 344, 345, 210],
+             [210, 338, 334, 205],
+             [207, 335, 346, 237],
+             [237, 347, 348, 207],
+             [208, 349, 350, 215],
+             [215, 351, 337, 208],
+             [352, 212, 217, 353],
+             [351, 217, 212, 327],
+             [328, 213, 224, 323],
+             [354, 224, 213, 355],
+             [349, 214, 228, 356],
+             [357, 228, 214, 345],
+             [358, 216, 232, 359],
+             [360, 232, 216, 350],
+             [344, 218, 235, 361],
+             [362, 235, 218, 348],
+             [219, 352, 363, 364],
+             [364, 365, 355, 219],
+             [222, 358, 366, 367],
+             [367, 368, 353, 222],
+             [225, 354, 369, 370],
+             [370, 371, 372, 225],
+             [307, 226, 225, 306],
+             [226, 268, 267, 247],
+             [227, 373, 374, 233],
+             [233, 360, 356, 227],
+             [229, 357, 361, 234],
+             [234, 375, 376, 229],
+             [248, 231, 230, 230],
+             [231, 377, 378, 379],
+             [379, 380, 359, 231],
+             [236, 362, 381, 245],
+             [245, 382, 383, 236],
+             [384, 238, 242, 385],
+             [340, 242, 238, 346],
+             [347, 239, 246, 381],
+             [386, 246, 239, 387],
+             [388, 241, 291, 389],
+             [343, 291, 241, 339],
+             [375, 243, 364, 390],
+             [391, 364, 243, 383],
+             [373, 244, 367, 392],
+             [393, 367, 244, 376],
+             [382, 247, 370, 394],
+             [395, 370, 247, 396],
+             [377, 248, 379, 397],
+             [398, 379, 248, 374],
+             [249, 384, 399, 400],
+             [400, 401, 387, 249],
+             [250, 260, 402, 403],
+             [403, 404, 252, 250],
+             [253, 251, 405, 406],
+             [407, 405, 251, 256],
+             [257, 252, 404, 408],
+             [406, 409, 277, 253],
+             [254, 388, 410, 411],
+             [411, 412, 385, 254],
+             [255, 263, 413, 414],
+             [414, 415, 276, 255],
+             [256, 277, 409, 407],
+             [408, 402, 260, 257],
+             [258, 261, 416, 417],
+             [417, 418, 264, 258],
+             [265, 259, 419, 420],
+             [421, 419, 259, 268],
+             [422, 416, 261, 270],
+             [271, 262, 423, 424],
+             [425, 423, 262, 266],
+             [426, 413, 263, 274],
+             [270, 264, 418, 422],
+             [420, 427, 307, 265],
+             [266, 303, 428, 425],
+             [267, 386, 429, 430],
+             [430, 431, 396, 267],
+             [268, 307, 427, 421],
+             [269, 283, 432, 433],
+             [433, 434, 280, 269],
+             [424, 428, 303, 271],
+             [272, 304, 435, 436],
+             [436, 437, 284, 272],
+             [273, 279, 438, 439],
+             [439, 440, 282, 273],
+             [274, 276, 415, 426],
+             [285, 275, 441, 442],
+             [443, 441, 275, 288],
+             [289, 278, 444, 445],
+             [446, 444, 278, 286],
+             [447, 438, 279, 294],
+             [295, 280, 434, 448],
+             [287, 281, 449, 450],
+             [451, 449, 281, 299],
+             [294, 282, 440, 447],
+             [448, 432, 283, 295],
+             [300, 284, 437, 452],
+             [442, 453, 454, 285],
+             [309, 286, 285, 308],
+             [286, 455, 456, 446],
+             [450, 457, 458, 287],
+             [311, 288, 287, 310],
+             [288, 454, 453, 443],
+             [445, 456, 455, 289],
+             [313, 290, 289, 312],
+             [290, 459, 460, 461],
+             [461, 462, 389, 290],
+             [293, 310, 463, 464],
+             [464, 465, 315, 293],
+             [296, 308, 466, 467],
+             [467, 468, 311, 296],
+             [298, 314, 469, 470],
+             [470, 471, 472, 298],
+             [315, 299, 298, 314],
+             [299, 458, 457, 451],
+             [452, 435, 304, 300],
+             [301, 312, 473, 474],
+             [474, 475, 309, 301],
+             [316, 302, 476, 477],
+             [478, 476, 302, 325],
+             [341, 305, 479, 480],
+             [481, 479, 305, 317],
+             [324, 306, 482, 483],
+             [484, 482, 306, 372],
+             [485, 466, 308, 454],
+             [455, 309, 475, 486],
+             [487, 463, 310, 458],
+             [454, 311, 468, 485],
+             [486, 473, 312, 455],
+             [459, 313, 488, 489],
+             [490, 488, 313, 342],
+             [491, 469, 314, 472],
+             [458, 315, 465, 487],
+             [477, 492, 485, 316],
+             [463, 317, 316, 468],
+             [317, 487, 493, 481],
+             [329, 447, 464, 318],
+             [468, 319, 318, 463],
+             [319, 467, 448, 322],
+             [321, 448, 467, 320],
+             [475, 323, 320, 466],
+             [432, 321, 328, 437],
+             [438, 329, 322, 434],
+             [323, 474, 452, 328],
+             [483, 494, 486, 324],
+             [466, 325, 324, 475],
+             [325, 485, 492, 478],
+             [337, 422, 433, 326],
+             [437, 327, 326, 432],
+             [327, 436, 424, 351],
+             [334, 426, 439, 330],
+             [434, 331, 330, 438],
+             [331, 433, 422, 338],
+             [333, 464, 447, 332],
+             [449, 339, 332, 440],
+             [465, 333, 343, 469],
+             [413, 334, 338, 418],
+             [336, 439, 426, 335],
+             [441, 346, 335, 415],
+             [440, 336, 340, 449],
+             [416, 337, 351, 423],
+             [339, 451, 470, 343],
+             [346, 443, 450, 340],
+             [480, 493, 487, 341],
+             [469, 342, 341, 465],
+             [342, 491, 495, 490],
+             [361, 407, 414, 344],
+             [418, 345, 344, 413],
+             [345, 417, 408, 357],
+             [381, 446, 442, 347],
+             [415, 348, 347, 441],
+             [348, 414, 407, 362],
+             [356, 408, 417, 349],
+             [423, 350, 349, 416],
+             [350, 425, 420, 360],
+             [353, 424, 436, 352],
+             [479, 363, 352, 435],
+             [428, 353, 368, 476],
+             [355, 452, 474, 354],
+             [488, 369, 354, 473],
+             [435, 355, 365, 479],
+             [402, 356, 360, 419],
+             [405, 361, 357, 404],
+             [359, 420, 425, 358],
+             [476, 366, 358, 428],
+             [427, 359, 380, 482],
+             [444, 381, 362, 409],
+             [363, 481, 477, 368],
+             [368, 393, 390, 363],
+             [365, 391, 394, 369],
+             [369, 490, 480, 365],
+             [366, 478, 483, 380],
+             [380, 398, 392, 366],
+             [371, 395, 496, 497],
+             [497, 498, 489, 371],
+             [473, 372, 371, 488],
+             [372, 486, 494, 484],
+             [392, 400, 403, 373],
+             [419, 374, 373, 402],
+             [374, 421, 430, 398],
+             [390, 411, 406, 375],
+             [404, 376, 375, 405],
+             [376, 403, 400, 393],
+             [397, 430, 421, 377],
+             [482, 378, 377, 427],
+             [378, 484, 497, 499],
+             [499, 499, 397, 378],
+             [394, 461, 445, 382],
+             [409, 383, 382, 444],
+             [383, 406, 411, 391],
+             [385, 450, 443, 384],
+             [492, 399, 384, 453],
+             [457, 385, 412, 493],
+             [387, 442, 446, 386],
+             [494, 429, 386, 456],
+             [453, 387, 401, 492],
+             [389, 470, 451, 388],
+             [493, 410, 388, 457],
+             [471, 389, 462, 495],
+             [412, 390, 393, 399],
+             [462, 394, 391, 410],
+             [401, 392, 398, 429],
+             [396, 445, 461, 395],
+             [498, 496, 395, 460],
+             [456, 396, 431, 494],
+             [431, 397, 499, 496],
+             [399, 477, 481, 412],
+             [429, 483, 478, 401],
+             [410, 480, 490, 462],
+             [496, 497, 484, 431],
+             [489, 495, 491, 459],
+             [495, 460, 459, 471],
+             [460, 489, 498, 498],
+             [472, 472, 471, 491]]
+
+    assert C_r.table == table3
+    assert C_c.table == table3
+
+    # Group denoted by B2,4 from [2] Pg. 474
+    F, a, b = free_group("a, b")
+    B_2_4 = FpGroup(F, [a**4, b**4, (a*b)**4, (a**-1*b)**4, (a**2*b)**4, \
+            (a*b**2)**4, (a**2*b**2)**4, (a**-1*b*a*b)**4, (a*b**-1*a*b)**4])
+    C_r = coset_enumeration_r(B_2_4, [a])
+    C_c = coset_enumeration_c(B_2_4, [a])
+    index_r = 0
+    for i in range(len(C_r.p)):
+        if C_r.p[i] == i:
+            index_r += 1
+    assert index_r == 1024
+
+    index_c = 0
+    for i in range(len(C_c.p)):
+        if C_c.p[i] == i:
+            index_c += 1
+    assert index_c == 1024
+
+    # trivial Macdonald group G(2,2) from [2] Pg. 480
+    M = FpGroup(F, [b**-1*a**-1*b*a*b**-1*a*b*a**-2, a**-1*b**-1*a*b*a**-1*b*a*b**-2])
+    C_r = coset_enumeration_r(M, [a])
+    C_r.compress(); C_r.standardize()
+    C_c = coset_enumeration_c(M, [a])
+    C_c.compress(); C_c.standardize()
+    table4 = [[0, 0, 0, 0]]
+    assert C_r.table == table4
+    assert C_c.table == table4
+
+
+def test_look_ahead():
+    # Section 3.2 [Test Example] Example (d) from [2]
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**11, b**5, c**4, (a*c)**3, b**2*c**-1*b**-1*c, a**4*b**-1*a**-1*b])
+    H = [c, b, c**2]
+    table0 = [[1, 2, 0, 0, 0, 0],
+              [3, 0, 4, 5, 6, 7],
+              [0, 8, 9, 10, 11, 12],
+              [5, 1, 10, 13, 14, 15],
+              [16, 5, 16, 1, 17, 18],
+              [4, 3, 1, 8, 19, 20],
+              [12, 21, 22, 23, 24, 1],
+              [25, 26, 27, 28, 1, 24],
+              [2, 10, 5, 16, 22, 28],
+              [10, 13, 13, 2, 29, 30]]
+    CosetTable.max_stack_size = 10
+    C_c = coset_enumeration_c(f, H)
+    C_c.compress(); C_c.standardize()
+    assert C_c.table[: 10] == table0
+
+def test_modified_methods():
+    '''
+    Tests for modified coset table methods.
+    Example 5.7 from [1] Holt, D., Eick, B., O'Brien
+    "Handbook of Computational Group Theory".
+
+    '''
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    C = CosetTable(f, H)
+    C.modified_define(0, x)
+    identity = C._grp.identity
+    a_0 = C._grp.generators[0]
+    a_1 = C._grp.generators[1]
+
+    assert C.P == [[identity, None, None, None],
+                    [None, identity, None, None]]
+    assert C.table == [[1, None, None, None],
+                        [None, 0, None, None]]
+
+    C.modified_define(1, x)
+    assert C.table == [[1, None, None, None],
+                        [2, 0, None, None],
+                        [None, 1, None, None]]
+    assert C.P == [[identity, None, None, None],
+                    [identity, identity, None, None],
+                    [None, identity, None, None]]
+
+    C.modified_scan(0, x**3, C._grp.identity, fill=False)
+    assert C.P == [[identity, identity, None, None],
+                     [identity, identity, None, None],
+                     [identity, identity, None, None]]
+    assert C.table == [[1, 2, None, None],
+                        [2, 0, None, None],
+                        [0, 1, None, None]]
+
+    C.modified_scan(0, x*y, C._grp.generators[0], fill=False)
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, None]]
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, None]]
+
+    C.modified_define(2, y**-1)
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [None, None, 2, None]]
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [None, None, identity, None]]
+
+    C.modified_scan(0, x**-1*y**-1*x*y*x, C._grp.generators[1])
+    assert C.table == [[1, 2, None, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [3, 3, 2, None]]
+    assert C.P == [[identity, identity, None, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [a_1, a_1**-1, identity, None]]
+
+    C.modified_scan(2, (x*y)**2, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, None],
+                        [0, 1, None, 3],
+                        [3, 3, 2, 0]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, None, identity],
+                    [a_1, a_1**-1, identity, a_1]]
+
+    C.modified_define(2, y)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, None],
+                        [0, 1, 4, 3],
+                        [3, 3, 2, 0],
+                        [None, None, None, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, None],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [None, None, None, identity]]
+
+    C.modified_scan(0, y**5, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1], [2, 0, 0, 4], [0, 1, 4, 3], [3, 3, 2, 0], [None, None, 1, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, a_0*a_1**-1],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [None, None, a_1*a_0**-1, identity]]
+
+    C.modified_scan(1, (x*y)**2, C._grp.identity)
+    assert C.table == [[1, 2, 3, 1],
+                        [2, 0, 0, 4],
+                        [0, 1, 4, 3],
+                        [3, 3, 2, 0],
+                        [4, 4, 1, 2]]
+    assert C.P == [[identity, identity, a_1**-1, a_0**-1],
+                    [identity, identity, a_0, a_0*a_1**-1],
+                    [identity, identity, identity, identity],
+                    [a_1, a_1**-1, identity, a_1],
+                    [a_0*a_1**-1, a_1*a_0**-1, a_1*a_0**-1, identity]]
+
+    # Modified coset enumeration test
+    f = FpGroup(F, [x**3, y**3, x**-1*y**-1*x*y])
+    C = coset_enumeration_r(f, [x])
+    C_m = modified_coset_enumeration_r(f, [x])
+    assert C_m.table == C.table
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_fp_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_fp_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f57bdf8eff92a3022d8e01cd74ce98575987929
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_fp_groups.py
@@ -0,0 +1,257 @@
+from sympy.core.singleton import S
+from sympy.combinatorics.fp_groups import (FpGroup, low_index_subgroups,
+                                   reidemeister_presentation, FpSubgroup,
+                                           simplify_presentation)
+from sympy.combinatorics.free_groups import (free_group, FreeGroup)
+
+from sympy.testing.pytest import slow
+
+"""
+References
+==========
+
+[1] Holt, D., Eick, B., O'Brien, E.
+"Handbook of Computational Group Theory"
+
+[2] John J. Cannon; Lucien A. Dimino; George Havas; Jane M. Watson
+Mathematics of Computation, Vol. 27, No. 123. (Jul., 1973), pp. 463-490.
+"Implementation and Analysis of the Todd-Coxeter Algorithm"
+
+[3] PROC. SECOND  INTERNAT. CONF. THEORY OF GROUPS, CANBERRA 1973,
+pp. 347-356. "A Reidemeister-Schreier program" by George Havas.
+http://staff.itee.uq.edu.au/havas/1973cdhw.pdf
+
+"""
+
+def test_low_index_subgroups():
+    F, x, y = free_group("x, y")
+
+    # Example 5.10 from [1] Pg. 194
+    f = FpGroup(F, [x**2, y**3, (x*y)**4])
+    L = low_index_subgroups(f, 4)
+    t1 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 3, 3]],
+          [[0, 0, 1, 2], [2, 2, 2, 0], [1, 1, 0, 1]],
+          [[1, 1, 0, 0], [0, 0, 1, 1]]]
+    for i in range(len(t1)):
+        assert L[i].table == t1[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 15)
+    t2 = [[[0, 0, 0, 0]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [4, 4, 5, 3], [6, 6, 3, 4], [5, 5, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [5, 5, 3, 4], [4, 4, 6, 6]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [9, 9, 6, 8], [12, 12, 11, 7], [8, 8, 7, 10],
+            [10, 10, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [10, 10, 11, 7], [8, 8, 7, 10],
+            [9, 9, 13, 14], [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5],
+            [6, 6, 5, 3], [7, 7, 3, 4], [4, 4, 8, 9], [5, 5, 10, 11],
+            [11, 11, 9, 6], [12, 12, 6, 8], [13, 13, 11, 7], [8, 8, 7, 10],
+            [9, 9, 12, 12], [10, 10, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [11, 11, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 3, 3], [2, 2, 5, 6]
+            , [7, 7, 6, 4], [8, 8, 4, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 4, 4]
+            , [7, 7, 6, 3], [8, 8, 3, 5], [5, 5, 8, 9], [6, 6, 9, 7],
+            [10, 10, 7, 8], [9, 9, 11, 12], [13, 13, 12, 10], [12, 12, 10, 11],
+            [11, 11, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [5, 5, 6, 3], [9, 9, 3, 5], [10, 10, 8, 4], [8, 8, 4, 7],
+            [6, 6, 10, 11], [7, 7, 11, 9], [12, 12, 9, 10], [11, 11, 13, 14],
+            [14, 14, 14, 12], [13, 13, 12, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 10, 12], [7, 7, 12, 9], [8, 8, 11, 11], [13, 13, 9, 10],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [6, 6, 3, 5], [10, 10, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [7, 7, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 9, 9], [6, 6, 11, 12], [8, 8, 12, 10], [13, 13, 10, 11],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [7, 7, 8, 4], [11, 11, 4, 7],
+            [5, 5, 12, 11], [6, 6, 10, 10], [8, 8, 9, 12], [13, 13, 11, 9],
+            [12, 12, 13, 13]],
+           [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8]
+            , [9, 9, 6, 3], [10, 10, 3, 5], [11, 11, 8, 4], [12, 12, 4, 7],
+            [5, 5, 9, 9], [6, 6, 12, 13], [7, 7, 11, 11], [8, 8, 13, 10],
+            [13, 13, 10, 12]],
+           [[1, 1, 0, 0], [0, 0, 2, 3], [4, 4, 3, 1], [5, 5, 1, 2], [2, 2, 4, 4]
+            , [3, 3, 6, 7], [7, 7, 7, 5], [6, 6, 5, 6]]]
+    for i  in range(len(t2)):
+        assert L[i].table == t2[i]
+
+    f = FpGroup(F, [x**2, y**3, (x*y)**7])
+    L = low_index_subgroups(f, 10, [x])
+    t3 = [[[0, 0, 0, 0]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [4, 4, 5, 3],
+           [6, 6, 3, 4], [5, 5, 6, 6]],
+          [[0, 0, 1, 2], [1, 1, 2, 0], [3, 3, 0, 1], [2, 2, 4, 5], [6, 6, 5, 3],
+           [5, 5, 3, 4], [4, 4, 6, 6]],
+          [[0, 0, 1, 2], [3, 3, 2, 0], [4, 4, 0, 1], [1, 1, 5, 6], [2, 2, 7, 8],
+           [6, 6, 6, 3], [5, 5, 3, 5], [8, 8, 8, 4], [7, 7, 4, 7]]]
+    for i in range(len(t3)):
+        assert L[i].table == t3[i]
+
+
+def test_subgroup_presentations():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    p1 = reidemeister_presentation(f, H)
+    assert str(p1) == "((y_1, y_2), (y_1**2, y_2**3, y_2*y_1*y_2*y_1*y_2*y_1))"
+
+    H = f.subgroup(H)
+    assert (H.generators, H.relators) == p1
+
+    f = FpGroup(F, [x**3, y**3, (x*y)**3])
+    H = [x*y, x*y**-1]
+    p2 = reidemeister_presentation(f, H)
+    assert str(p2) == "((x_0, y_0), (x_0**3, y_0**3, x_0*y_0*x_0*y_0*x_0*y_0))"
+
+    f = FpGroup(F, [x**2*y**2, y**-1*x*y*x**-3])
+    H = [x]
+    p3 = reidemeister_presentation(f, H)
+    assert str(p3) == "((x_0,), (x_0**4,))"
+
+    f = FpGroup(F, [x**3*y**-3, (x*y)**3, (x*y**-1)**2])
+    H = [x]
+    p4 = reidemeister_presentation(f, H)
+    assert str(p4) == "((x_0,), (x_0**6,))"
+
+    # this presentation can be improved, the most simplified form
+    # of presentation is 
+    # See [2] Pg 474 group PSL_2(11)
+    # This is the group PSL_2(11)
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**11, b**5, c**4, (b*c**2)**2, (a*b*c)**3, (a**4*c**2)**3, b**2*c**-1*b**-1*c, a**4*b**-1*a**-1*b])
+    H = [a, b, c**2]
+    gens, rels = reidemeister_presentation(f, H)
+    assert str(gens) == "(b_1, c_3)"
+    assert len(rels) == 18
+
+
+@slow
+def test_order():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.order() == 8
+
+    f = FpGroup(F, [x*y*x**-1*y**-1, y**2])
+    assert f.order() is S.Infinity
+
+    F, a, b, c = free_group("a, b, c")
+    f = FpGroup(F, [a**250, b**2, c*b*c**-1*b, c**4, c**-1*a**-1*c*a, a**-1*b**-1*a*b])
+    assert f.order() == 2000
+
+    F, x = free_group("x")
+    f = FpGroup(F, [])
+    assert f.order() is S.Infinity
+
+    f = FpGroup(free_group('')[0], [])
+    assert f.order() == 1
+
+def test_fp_subgroup():
+    def _test_subgroup(K, T, S):
+        _gens = T(K.generators)
+        assert all(elem in S for elem in _gens)
+        assert T.is_injective()
+        assert T.image().order() == S.order()
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    S = FpSubgroup(f, [x*y])
+    assert (x*y)**-3 in S
+    K, T = f.subgroup([x*y], homomorphism=True)
+    assert T(K.generators) == [y*x**-1]
+    _test_subgroup(K, T, S)
+
+    S = FpSubgroup(f, [x**-1*y*x])
+    assert x**-1*y**4*x in S
+    assert x**-1*y**4*x**2 not in S
+    K, T = f.subgroup([x**-1*y*x], homomorphism=True)
+    assert T(K.generators[0]**3) == y**3
+    _test_subgroup(K, T, S)
+
+    f = FpGroup(F, [x**3, y**5, (x*y)**2])
+    H = [x*y, x**-1*y**-1*x*y*x]
+    K, T = f.subgroup(H, homomorphism=True)
+    S = FpSubgroup(f, H)
+    _test_subgroup(K, T, S)
+
+def test_permutation_methods():
+    F, x, y = free_group("x, y")
+    # DihedralGroup(8)
+    G = FpGroup(F, [x**2, y**8, x*y*x**-1*y])
+    T = G._to_perm_group()[1]
+    assert T.is_isomorphism()
+    assert G.center() == [y**4]
+
+    # DiheadralGroup(4)
+    G = FpGroup(F, [x**2, y**4, x*y*x**-1*y])
+    S = FpSubgroup(G, G.normal_closure([x]))
+    assert x in S
+    assert y**-1*x*y in S
+
+    # Z_5xZ_4
+    G = FpGroup(F, [x*y*x**-1*y**-1, y**5, x**4])
+    assert G.is_abelian
+    assert G.is_solvable
+
+    # AlternatingGroup(5)
+    G = FpGroup(F, [x**3, y**2, (x*y)**5])
+    assert not G.is_solvable
+
+    # AlternatingGroup(4)
+    G = FpGroup(F, [x**3, y**2, (x*y)**3])
+    assert len(G.derived_series()) == 3
+    S = FpSubgroup(G, G.derived_subgroup())
+    assert S.order() == 4
+
+
+def test_simplify_presentation():
+    # ref #16083
+    G = simplify_presentation(FpGroup(FreeGroup([]), []))
+    assert not G.generators
+    assert not G.relators
+
+    # CyclicGroup(3)
+    # The second generator in  is trivial due to relators {x^2, x^5}
+    F, x, y = free_group("x, y")
+    G = simplify_presentation(FpGroup(F, [x**2, x**5, y**3]))
+    assert x in G.relators
+
+def test_cyclic():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.is_cyclic
+    f = FpGroup(F, [x*y, x*y**-1])
+    assert f.is_cyclic
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert not f.is_cyclic
+
+
+def test_abelian_invariants():
+    F, x, y = free_group("x, y")
+    f = FpGroup(F, [x*y, x**-1*y**-1*x*y*x])
+    assert f.abelian_invariants() == []
+    f = FpGroup(F, [x*y, x*y**-1])
+    assert f.abelian_invariants() == [2]
+    f = FpGroup(F, [x**4, y**2, x*y*x**-1*y])
+    assert f.abelian_invariants() == [2, 4]
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_free_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_free_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..439be4b7c5e8bb5ff592c9b7f07773e82952b3d5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_free_groups.py
@@ -0,0 +1,226 @@
+from sympy.combinatorics.free_groups import free_group, FreeGroup
+from sympy.core import Symbol
+from sympy.testing.pytest import raises
+from sympy.core.numbers import oo
+
+F, x, y, z = free_group("x, y, z")
+
+
+def test_FreeGroup__init__():
+    x, y, z = map(Symbol, "xyz")
+
+    assert len(FreeGroup("x, y, z").generators) == 3
+    assert len(FreeGroup(x).generators) == 1
+    assert len(FreeGroup(("x", "y", "z"))) == 3
+    assert len(FreeGroup((x, y, z)).generators) == 3
+
+
+def test_FreeGroup__getnewargs__():
+    x, y, z = map(Symbol, "xyz")
+    assert FreeGroup("x, y, z").__getnewargs__() == ((x, y, z),)
+
+
+def test_free_group():
+    G, a, b, c = free_group("a, b, c")
+    assert F.generators == (x, y, z)
+    assert x*z**2 in F
+    assert x in F
+    assert y*z**-1 in F
+    assert (y*z)**0 in F
+    assert a not in F
+    assert a**0 not in F
+    assert len(F) == 3
+    assert str(F) == ''
+    assert not F == G
+    assert F.order() is oo
+    assert F.is_abelian == False
+    assert F.center() == {F.identity}
+
+    (e,) = free_group("")
+    assert e.order() == 1
+    assert e.generators == ()
+    assert e.elements == {e.identity}
+    assert e.is_abelian == True
+
+
+def test_FreeGroup__hash__():
+    assert hash(F)
+
+
+def test_FreeGroup__eq__():
+    assert free_group("x, y, z")[0] == free_group("x, y, z")[0]
+    assert free_group("x, y, z")[0] is free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("a, x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("a, x, y")[0]
+
+    assert free_group("x, y")[0] != free_group("x, y, z")[0]
+    assert free_group("x, y")[0] is not free_group("x, y, z")[0]
+
+    assert free_group("x, y, z")[0] != free_group("x, y")[0]
+    assert free_group("x, y, z")[0] is not free_group("x, y")[0]
+
+
+def test_FreeGroup__getitem__():
+    assert F[0:] == FreeGroup("x, y, z")
+    assert F[1:] == FreeGroup("y, z")
+    assert F[2:] == FreeGroup("z")
+
+
+def test_FreeGroupElm__hash__():
+    assert hash(x*y*z)
+
+
+def test_FreeGroupElm_copy():
+    f = x*y*z**3
+    g = f.copy()
+    h = x*y*z**7
+
+    assert f == g
+    assert f != h
+
+
+def test_FreeGroupElm_inverse():
+    assert x.inverse() == x**-1
+    assert (x*y).inverse() == y**-1*x**-1
+    assert (y*x*y**-1).inverse() == y*x**-1*y**-1
+    assert (y**2*x**-1).inverse() == x*y**-2
+
+
+def test_FreeGroupElm_type_error():
+    raises(TypeError, lambda: 2/x)
+    raises(TypeError, lambda: x**2 + y**2)
+    raises(TypeError, lambda: x/2)
+
+
+def test_FreeGroupElm_methods():
+    assert (x**0).order() == 1
+    assert (y**2).order() is oo
+    assert (x**-1*y).commutator(x) == y**-1*x**-1*y*x
+    assert len(x**2*y**-1) == 3
+    assert len(x**-1*y**3*z) == 5
+
+
+def test_FreeGroupElm_eliminate_word():
+    w = x**5*y*x**2*y**-4*x
+    assert w.eliminate_word( x, x**2 ) == x**10*y*x**4*y**-4*x**2
+    w3 = x**2*y**3*x**-1*y
+    assert w3.eliminate_word(x, x**2) == x**4*y**3*x**-2*y
+    assert w3.eliminate_word(x, y) == y**5
+    assert w3.eliminate_word(x, y**4) == y**8
+    assert w3.eliminate_word(y, x**-1) == x**-3
+    assert w3.eliminate_word(x, y*z) == y*z*y*z*y**3*z**-1
+    assert (y**-3).eliminate_word(y, x**-1*z**-1) == z*x*z*x*z*x
+    #assert w3.eliminate_word(x, y*x) == y*x*y*x**2*y*x*y*x*y*x*z**3
+    #assert w3.eliminate_word(x, x*y) == x*y*x**2*y*x*y*x*y*x*y*z**3
+
+
+def test_FreeGroupElm_array_form():
+    assert (x*z).array_form == ((Symbol('x'), 1), (Symbol('z'), 1))
+    assert (x**2*z*y*x**-2).array_form == \
+        ((Symbol('x'), 2), (Symbol('z'), 1), (Symbol('y'), 1), (Symbol('x'), -2))
+    assert (x**-2*y**-1).array_form == ((Symbol('x'), -2), (Symbol('y'), -1))
+
+
+def test_FreeGroupElm_letter_form():
+    assert (x**3).letter_form == (Symbol('x'), Symbol('x'), Symbol('x'))
+    assert (x**2*z**-2*x).letter_form == \
+        (Symbol('x'), Symbol('x'), -Symbol('z'), -Symbol('z'), Symbol('x'))
+
+
+def test_FreeGroupElm_ext_rep():
+    assert (x**2*z**-2*x).ext_rep == \
+        (Symbol('x'), 2, Symbol('z'), -2, Symbol('x'), 1)
+    assert (x**-2*y**-1).ext_rep == (Symbol('x'), -2, Symbol('y'), -1)
+    assert (x*z).ext_rep == (Symbol('x'), 1, Symbol('z'), 1)
+
+
+def test_FreeGroupElm__mul__pow__():
+    x1 = x.group.dtype(((Symbol('x'), 1),))
+    assert x**2 == x1*x
+
+    assert (x**2*y*x**-2)**4 == x**2*y**4*x**-2
+    assert (x**2)**2 == x**4
+    assert (x**-1)**-1 == x
+    assert (x**-1)**0 == F.identity
+    assert (y**2)**-2 == y**-4
+
+    assert x**2*x**-1 == x
+    assert x**2*y**2*y**-1 == x**2*y
+    assert x*x**-1 == F.identity
+
+    assert x/x == F.identity
+    assert x/x**2 == x**-1
+    assert (x**2*y)/(x**2*y**-1) == x**2*y**2*x**-2
+    assert (x**2*y)/(y**-1*x**2) == x**2*y*x**-2*y
+
+    assert x*(x**-1*y*z*y**-1) == y*z*y**-1
+    assert x**2*(x**-2*y**-1*z**2*y) == y**-1*z**2*y
+
+    a = F.identity
+    for n in range(10):
+        assert a == x**n
+        assert a**-1 == x**-n
+        a *= x
+
+
+def test_FreeGroupElm__len__():
+    assert len(x**5*y*x**2*y**-4*x) == 13
+    assert len(x**17) == 17
+    assert len(y**0) == 0
+
+
+def test_FreeGroupElm_comparison():
+    assert not (x*y == y*x)
+    assert x**0 == y**0
+
+    assert x**2 < y**3
+    assert not x**3 < y**2
+    assert x*y < x**2*y
+    assert x**2*y**2 < y**4
+    assert not y**4 < y**-4
+    assert not y**4 < x**-4
+    assert y**-2 < y**2
+
+    assert x**2 <= y**2
+    assert x**2 <= x**2
+
+    assert not y*z > z*y
+    assert x > x**-1
+
+    assert not x**2 >= y**2
+
+
+def test_FreeGroupElm_syllables():
+    w = x**5*y*x**2*y**-4*x
+    assert w.number_syllables() == 5
+    assert w.exponent_syllable(2) == 2
+    assert w.generator_syllable(3) == Symbol('y')
+    assert w.sub_syllables(1, 2) == y
+    assert w.sub_syllables(3, 3) == F.identity
+
+
+def test_FreeGroup_exponents():
+    w1 = x**2*y**3
+    assert w1.exponent_sum(x) == 2
+    assert w1.exponent_sum(x**-1) == -2
+    assert w1.generator_count(x) == 2
+
+    w2 = x**2*y**4*x**-3
+    assert w2.exponent_sum(x) == -1
+    assert w2.generator_count(x) == 5
+
+
+def test_FreeGroup_generators():
+    assert (x**2*y**4*z**-1).contains_generators() == {x, y, z}
+    assert (x**-1*y**3).contains_generators() == {x, y}
+
+
+def test_FreeGroupElm_words():
+    w = x**5*y*x**2*y**-4*x
+    assert w.subword(2, 6) == x**3*y
+    assert w.subword(3, 2) == F.identity
+    assert w.subword(6, 10) == x**2*y**-2
+
+    assert w.substituted_word(0, 7, y**-1) == y**-1*x*y**-4*x
+    assert w.substituted_word(0, 7, y**2*x) == y**2*x**2*y**-4*x
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_galois.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_galois.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d2ac29a846db88444d275b72a85ce3debaeaf05
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_galois.py
@@ -0,0 +1,82 @@
+"""Test groups defined by the galois module. """
+
+from sympy.combinatorics.galois import (
+    S4TransitiveSubgroups, S5TransitiveSubgroups, S6TransitiveSubgroups,
+    find_transitive_subgroups_of_S6,
+)
+from sympy.combinatorics.homomorphisms import is_isomorphic
+from sympy.combinatorics.named_groups import (
+    SymmetricGroup, AlternatingGroup, CyclicGroup,
+)
+
+
+def test_four_group():
+    G = S4TransitiveSubgroups.V.get_perm_group()
+    A4 = AlternatingGroup(4)
+    assert G.is_subgroup(A4)
+    assert G.degree == 4
+    assert G.is_transitive()
+    assert G.order() == 4
+    assert not G.is_cyclic
+
+
+def test_M20():
+    G = S5TransitiveSubgroups.M20.get_perm_group()
+    S5 = SymmetricGroup(5)
+    A5 = AlternatingGroup(5)
+    assert G.is_subgroup(S5)
+    assert not G.is_subgroup(A5)
+    assert G.degree == 5
+    assert G.is_transitive()
+    assert G.order() == 20
+
+
+# Setting this True means that for each of the transitive subgroups of S6,
+# we run a test not only on the fixed representation, but also on one freshly
+# generated by the search procedure.
+INCLUDE_SEARCH_REPS = False
+S6_randomized = {}
+if INCLUDE_SEARCH_REPS:
+    S6_randomized = find_transitive_subgroups_of_S6(*list(S6TransitiveSubgroups))
+
+
+def get_versions_of_S6_subgroup(name):
+    vers = [name.get_perm_group()]
+    if INCLUDE_SEARCH_REPS:
+        vers.append(S6_randomized[name])
+    return vers
+
+
+def test_S6_transitive_subgroups():
+    """
+    Test enough characteristics to distinguish all 16 transitive subgroups.
+    """
+    ts = S6TransitiveSubgroups
+    A6 = AlternatingGroup(6)
+    for name, alt, order, is_isom, not_isom in [
+        (ts.C6,     False,    6, CyclicGroup(6), None),
+        (ts.S3,     False,    6, SymmetricGroup(3), None),
+        (ts.D6,     False,   12, None, None),
+        (ts.A4,     True,    12, None, None),
+        (ts.G18,    False,   18, None, None),
+        (ts.A4xC2,  False,   24, None, SymmetricGroup(4)),
+        (ts.S4m,    False,   24, SymmetricGroup(4), None),
+        (ts.S4p,    True,    24, None, None),
+        (ts.G36m,   False,   36, None, None),
+        (ts.G36p,   True,    36, None, None),
+        (ts.S4xC2,  False,   48, None, None),
+        (ts.PSL2F5, True,    60, None, None),
+        (ts.G72,    False,   72, None, None),
+        (ts.PGL2F5, False,  120, None, None),
+        (ts.A6,     True,   360, None, None),
+        (ts.S6,     False,  720, None, None),
+    ]:
+        for G in get_versions_of_S6_subgroup(name):
+            assert G.is_transitive()
+            assert G.degree == 6
+            assert G.is_subgroup(A6) is alt
+            assert G.order() == order
+            if is_isom:
+                assert is_isomorphic(G, is_isom)
+            if not_isom:
+                assert not is_isomorphic(G, not_isom)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_generators.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_generators.py
new file mode 100644
index 0000000000000000000000000000000000000000..795ef8f08f6ec212879f528c6a0c2f0bd73037f0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_generators.py
@@ -0,0 +1,105 @@
+from sympy.combinatorics.generators import symmetric, cyclic, alternating, \
+    dihedral, rubik
+from sympy.combinatorics.permutations import Permutation
+from sympy.testing.pytest import raises
+
+def test_generators():
+
+    assert list(cyclic(6)) == [
+        Permutation([0, 1, 2, 3, 4, 5]),
+        Permutation([1, 2, 3, 4, 5, 0]),
+        Permutation([2, 3, 4, 5, 0, 1]),
+        Permutation([3, 4, 5, 0, 1, 2]),
+        Permutation([4, 5, 0, 1, 2, 3]),
+        Permutation([5, 0, 1, 2, 3, 4])]
+
+    assert list(cyclic(10)) == [
+        Permutation([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
+        Permutation([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]),
+        Permutation([2, 3, 4, 5, 6, 7, 8, 9, 0, 1]),
+        Permutation([3, 4, 5, 6, 7, 8, 9, 0, 1, 2]),
+        Permutation([4, 5, 6, 7, 8, 9, 0, 1, 2, 3]),
+        Permutation([5, 6, 7, 8, 9, 0, 1, 2, 3, 4]),
+        Permutation([6, 7, 8, 9, 0, 1, 2, 3, 4, 5]),
+        Permutation([7, 8, 9, 0, 1, 2, 3, 4, 5, 6]),
+        Permutation([8, 9, 0, 1, 2, 3, 4, 5, 6, 7]),
+        Permutation([9, 0, 1, 2, 3, 4, 5, 6, 7, 8])]
+
+    assert list(alternating(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(symmetric(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([0, 2, 1]),
+        Permutation([1, 0, 2]),
+        Permutation([1, 2, 0]),
+        Permutation([2, 0, 1]),
+        Permutation([2, 1, 0])]
+
+    assert list(symmetric(4)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([0, 1, 3, 2]),
+        Permutation([0, 2, 1, 3]),
+        Permutation([0, 2, 3, 1]),
+        Permutation([0, 3, 1, 2]),
+        Permutation([0, 3, 2, 1]),
+        Permutation([1, 0, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([1, 2, 0, 3]),
+        Permutation([1, 2, 3, 0]),
+        Permutation([1, 3, 0, 2]),
+        Permutation([1, 3, 2, 0]),
+        Permutation([2, 0, 1, 3]),
+        Permutation([2, 0, 3, 1]),
+        Permutation([2, 1, 0, 3]),
+        Permutation([2, 1, 3, 0]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([2, 3, 1, 0]),
+        Permutation([3, 0, 1, 2]),
+        Permutation([3, 0, 2, 1]),
+        Permutation([3, 1, 0, 2]),
+        Permutation([3, 1, 2, 0]),
+        Permutation([3, 2, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(1)) == [
+        Permutation([0, 1]), Permutation([1, 0])]
+
+    assert list(dihedral(2)) == [
+        Permutation([0, 1, 2, 3]),
+        Permutation([1, 0, 3, 2]),
+        Permutation([2, 3, 0, 1]),
+        Permutation([3, 2, 1, 0])]
+
+    assert list(dihedral(3)) == [
+        Permutation([0, 1, 2]),
+        Permutation([2, 1, 0]),
+        Permutation([1, 2, 0]),
+        Permutation([0, 2, 1]),
+        Permutation([2, 0, 1]),
+        Permutation([1, 0, 2])]
+
+    assert list(dihedral(5)) == [
+        Permutation([0, 1, 2, 3, 4]),
+        Permutation([4, 3, 2, 1, 0]),
+        Permutation([1, 2, 3, 4, 0]),
+        Permutation([0, 4, 3, 2, 1]),
+        Permutation([2, 3, 4, 0, 1]),
+        Permutation([1, 0, 4, 3, 2]),
+        Permutation([3, 4, 0, 1, 2]),
+        Permutation([2, 1, 0, 4, 3]),
+        Permutation([4, 0, 1, 2, 3]),
+        Permutation([3, 2, 1, 0, 4])]
+
+    raises(ValueError, lambda: rubik(1))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_graycode.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_graycode.py
new file mode 100644
index 0000000000000000000000000000000000000000..a754a3c401b07c9c12cb9bdeeefdfc94f6cb8b5c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_graycode.py
@@ -0,0 +1,72 @@
+from sympy.combinatorics.graycode import (GrayCode, bin_to_gray,
+    random_bitstring, get_subset_from_bitstring, graycode_subsets,
+    gray_to_bin)
+from sympy.testing.pytest import raises
+
+def test_graycode():
+    g = GrayCode(2)
+    got = []
+    for i in g.generate_gray():
+        if i.startswith('0'):
+            g.skip()
+        got.append(i)
+    assert got == '00 11 10'.split()
+    a = GrayCode(6)
+    assert a.current == '0'*6
+    assert a.rank == 0
+    assert len(list(a.generate_gray())) == 64
+    codes = ['011001', '011011', '011010',
+    '011110', '011111', '011101', '011100', '010100', '010101', '010111',
+    '010110', '010010', '010011', '010001', '010000', '110000', '110001',
+    '110011', '110010', '110110', '110111', '110101', '110100', '111100',
+    '111101', '111111', '111110', '111010', '111011', '111001', '111000',
+    '101000', '101001', '101011', '101010', '101110', '101111', '101101',
+    '101100', '100100', '100101', '100111', '100110', '100010', '100011',
+    '100001', '100000']
+    assert list(a.generate_gray(start='011001')) == codes
+    assert list(
+        a.generate_gray(rank=GrayCode(6, start='011001').rank)) == codes
+    assert a.next().current == '000001'
+    assert a.next(2).current == '000011'
+    assert a.next(-1).current == '100000'
+
+    a = GrayCode(5, start='10010')
+    assert a.rank == 28
+    a = GrayCode(6, start='101000')
+    assert a.rank == 48
+
+    assert GrayCode(6, rank=4).current == '000110'
+    assert GrayCode(6, rank=4).rank == 4
+    assert [GrayCode(4, start=s).rank for s in
+            GrayCode(4).generate_gray()] == [0, 1, 2, 3, 4, 5, 6, 7, 8,
+                                             9, 10, 11, 12, 13, 14, 15]
+    a = GrayCode(15, rank=15)
+    assert a.current == '000000000001000'
+
+    assert bin_to_gray('111') == '100'
+
+    a = random_bitstring(5)
+    assert type(a) is str
+    assert len(a) == 5
+    assert all(i in ['0', '1'] for i in a)
+
+    assert get_subset_from_bitstring(
+        ['a', 'b', 'c', 'd'], '0011') == ['c', 'd']
+    assert get_subset_from_bitstring('abcd', '1001') == ['a', 'd']
+    assert list(graycode_subsets(['a', 'b', 'c'])) == \
+        [[], ['c'], ['b', 'c'], ['b'], ['a', 'b'], ['a', 'b', 'c'],
+         ['a', 'c'], ['a']]
+
+    raises(ValueError, lambda: GrayCode(0))
+    raises(ValueError, lambda: GrayCode(2.2))
+    raises(ValueError, lambda: GrayCode(2, start=[1, 1, 0]))
+    raises(ValueError, lambda: GrayCode(2, rank=2.5))
+    raises(ValueError, lambda: get_subset_from_bitstring(['c', 'a', 'c'], '1100'))
+    raises(ValueError, lambda: list(GrayCode(3).generate_gray(start="1111")))
+
+
+def test_live_issue_117():
+    assert bin_to_gray('0100') == '0110'
+    assert bin_to_gray('0101') == '0111'
+    for bits in ('0100', '0101'):
+        assert gray_to_bin(bin_to_gray(bits)) == bits
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_constructs.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_constructs.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0f7d6394bbc2e285650ea95d36be8e2ed5ea69e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_constructs.py
@@ -0,0 +1,15 @@
+from sympy.combinatorics.group_constructs import DirectProduct
+from sympy.combinatorics.named_groups import CyclicGroup, DihedralGroup
+
+
+def test_direct_product_n():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = DirectProduct(C, C, C)
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = DirectProduct(D, C)
+    assert H.order() == 32
+    assert H.is_abelian is False
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_numbers.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..743f1dcc8b642c19706687eeeddf6c9070b59166
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_group_numbers.py
@@ -0,0 +1,110 @@
+from sympy.combinatorics.group_numbers import (is_nilpotent_number,
+    is_abelian_number, is_cyclic_number, _holder_formula, groups_count)
+from sympy.ntheory.factor_ import factorint
+from sympy.ntheory.generate import prime
+from sympy.testing.pytest import raises
+from sympy import randprime
+
+
+def test_is_nilpotent_number():
+    assert is_nilpotent_number(21) == False
+    assert is_nilpotent_number(randprime(1, 30)**12) == True
+    raises(ValueError, lambda: is_nilpotent_number(-5))
+
+    A056867	= [1, 2, 3, 4, 5, 7, 8, 9, 11, 13, 15, 16, 17, 19,
+               23, 25, 27, 29, 31, 32, 33, 35, 37, 41, 43, 45,
+               47, 49, 51, 53, 59, 61, 64, 65, 67, 69, 71, 73,
+               77, 79, 81, 83, 85, 87, 89, 91, 95, 97, 99]
+    for n in range(1, 100):
+        assert is_nilpotent_number(n) == (n in A056867)
+
+
+def test_is_abelian_number():
+    assert is_abelian_number(4) == True
+    assert is_abelian_number(randprime(1, 2000)**2) == True
+    assert is_abelian_number(randprime(1000, 100000)) == True
+    assert is_abelian_number(60) == False
+    assert is_abelian_number(24) == False
+    raises(ValueError, lambda: is_abelian_number(-5))
+
+    A051532 = [1, 2, 3, 4, 5, 7, 9, 11, 13, 15, 17, 19, 23, 25,
+               29, 31, 33, 35, 37, 41, 43, 45, 47, 49, 51, 53,
+               59, 61, 65, 67, 69, 71, 73, 77, 79, 83, 85, 87,
+               89, 91, 95, 97, 99]
+    for n in range(1, 100):
+        assert is_abelian_number(n) == (n in A051532)
+
+
+A003277 = [1, 2, 3, 5, 7, 11, 13, 15, 17, 19, 23, 29,
+           31, 33, 35, 37, 41, 43, 47, 51, 53, 59, 61,
+           65, 67, 69, 71, 73, 77, 79, 83, 85, 87, 89,
+           91, 95, 97]
+
+
+def test_is_cyclic_number():
+    assert is_cyclic_number(15) == True
+    assert is_cyclic_number(randprime(1, 2000)**2) == False
+    assert is_cyclic_number(randprime(1000, 100000)) == True
+    assert is_cyclic_number(4) == False
+    raises(ValueError, lambda: is_cyclic_number(-5))
+
+    for n in range(1, 100):
+        assert is_cyclic_number(n) == (n in A003277)
+
+
+def test_holder_formula():
+    # semiprime
+    assert _holder_formula({3, 5}) == 1
+    assert _holder_formula({5, 11}) == 2
+    # n in A003277 is always 1
+    for n in A003277:
+        assert _holder_formula(set(factorint(n).keys())) == 1
+    # otherwise
+    assert _holder_formula({2, 3, 5, 7}) == 12
+
+
+def test_groups_count():
+    A000001 = [0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1,
+               2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2,
+               5, 4, 1, 4, 1, 51, 1, 2, 1, 14, 1, 2, 2,
+               14, 1, 6, 1, 4, 2, 2, 1, 52, 2, 5, 1, 5,
+               1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267,
+               1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1,
+               6, 1, 52, 15, 2, 1, 15, 1, 2, 1, 12, 1,
+               10, 1, 4, 2]
+    for n in range(1, len(A000001)):
+        try:
+            assert groups_count(n) == A000001[n]
+        except ValueError:
+            pass
+
+    A000679 = [1, 1, 2, 5, 14, 51, 267, 2328, 56092, 10494213, 49487367289]
+    for e in range(1, len(A000679)):
+        assert groups_count(2**e) == A000679[e]
+
+    A090091 = [1, 1, 2, 5, 15, 67, 504, 9310, 1396077, 5937876645]
+    for e in range(1, len(A090091)):
+        assert groups_count(3**e) == A090091[e]
+
+    A090130 = [1, 1, 2, 5, 15, 77, 684, 34297]
+    for e in range(1, len(A090130)):
+        assert groups_count(5**e) == A090130[e]
+
+    A090140 = [1, 1, 2, 5, 15, 83, 860, 113147]
+    for e in range(1, len(A090140)):
+        assert groups_count(7**e) == A090140[e]
+
+    A232105 = [51, 67, 77, 83, 87, 97, 101, 107, 111, 125, 131,
+               145, 149, 155, 159, 173, 183, 193, 203, 207, 217]
+    for i in range(len(A232105)):
+        assert groups_count(prime(i+1)**5) == A232105[i]
+
+    A232106 = [267, 504, 684, 860, 1192, 1476, 1944, 2264, 2876,
+               4068, 4540, 6012, 7064, 7664, 8852, 10908, 13136]
+    for i in range(len(A232106)):
+        assert groups_count(prime(i+1)**6) == A232106[i]
+
+    A232107 = [2328, 9310, 34297, 113147, 750735, 1600573,
+               5546909, 9380741, 23316851, 71271069, 98488755]
+    for i in range(len(A232107)):
+        assert groups_count(prime(i+1)**7) == A232107[i]
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_homomorphisms.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_homomorphisms.py
new file mode 100644
index 0000000000000000000000000000000000000000..0936bbddf46a16dccdfbaebda8d1c675c131f05a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_homomorphisms.py
@@ -0,0 +1,114 @@
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.combinatorics.homomorphisms import homomorphism, group_isomorphism, is_isomorphic
+from sympy.combinatorics.free_groups import free_group
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.named_groups import AlternatingGroup, DihedralGroup, CyclicGroup
+from sympy.testing.pytest import raises
+
+def test_homomorphism():
+    # FpGroup -> PermutationGroup
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+
+    c = Permutation(3)(0, 1, 2)
+    d = Permutation(3)(1, 2, 3)
+    A = AlternatingGroup(4)
+    T = homomorphism(G, A, [a, b], [c, d])
+    assert T(a*b**2*a**-1) == c*d**2*c**-1
+    assert T.is_isomorphism()
+    assert T(T.invert(Permutation(3)(0, 2, 3))) == Permutation(3)(0, 2, 3)
+
+    T = homomorphism(G, AlternatingGroup(4), G.generators)
+    assert T.is_trivial()
+    assert T.kernel().order() == G.order()
+
+    E, e = free_group("e")
+    G = FpGroup(E, [e**8])
+    P = PermutationGroup([Permutation(0, 1, 2, 3), Permutation(0, 2)])
+    T = homomorphism(G, P, [e], [Permutation(0, 1, 2, 3)])
+    assert T.image().order() == 4
+    assert T(T.invert(Permutation(0, 2)(1, 3))) == Permutation(0, 2)(1, 3)
+
+    T = homomorphism(E, AlternatingGroup(4), E.generators, [c])
+    assert T.invert(c**2) == e**-1 #order(c) == 3 so c**2 == c**-1
+
+    # FreeGroup -> FreeGroup
+    T = homomorphism(F, E, [a], [e])
+    assert T(a**-2*b**4*a**2).is_identity
+
+    # FreeGroup -> FpGroup
+    G = FpGroup(F, [a*b*a**-1*b**-1])
+    T = homomorphism(F, G, F.generators, G.generators)
+    assert T.invert(a**-1*b**-1*a**2) == a*b**-1
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    T = homomorphism(P, D, [p], [p])
+    assert T.is_injective()
+    assert not T.is_isomorphism()
+    assert T.invert(p**3) == p**3
+
+    T2 = homomorphism(F, P, [F.generators[0]], P.generators)
+    T = T.compose(T2)
+    assert T.domain == F
+    assert T.codomain == D
+    assert T(a*b) == p
+
+    D3 = DihedralGroup(3)
+    T = homomorphism(D3, D3, D3.generators, D3.generators)
+    assert T.is_isomorphism()
+
+
+def test_isomorphisms():
+
+    F, a, b = free_group("a, b")
+    E, c, d = free_group("c, d")
+    # Infinite groups with differently ordered relators.
+    G = FpGroup(F, [a**2, b**3])
+    H = FpGroup(F, [b**3, a**2])
+    assert is_isomorphic(G, H)
+
+    # Trivial Case
+    # FpGroup -> FpGroup
+    H = FpGroup(F, [a**3, b**3, (a*b)**2])
+    F, c, d = free_group("c, d")
+    G = FpGroup(F, [c**3, d**3, (c*d)**2])
+    check, T =  group_isomorphism(G, H)
+    assert check
+    assert T(c**3*d**2) == a**3*b**2
+
+    # FpGroup -> PermutationGroup
+    # FpGroup is converted to the equivalent isomorphic group.
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    H = AlternatingGroup(4)
+    check, T = group_isomorphism(G, H)
+    assert check
+    assert T(b*a*b**-1*a**-1*b**-1) == Permutation(0, 2, 3)
+    assert T(b*a*b*a**-1*b**-1) == Permutation(0, 3, 2)
+
+    # PermutationGroup -> PermutationGroup
+    D = DihedralGroup(8)
+    p = Permutation(0, 1, 2, 3, 4, 5, 6, 7)
+    P = PermutationGroup(p)
+    assert not is_isomorphic(D, P)
+
+    A = CyclicGroup(5)
+    B = CyclicGroup(7)
+    assert not is_isomorphic(A, B)
+
+    # Two groups of the same prime order are isomorphic to each other.
+    G = FpGroup(F, [a, b**5])
+    H = CyclicGroup(5)
+    assert G.order() == H.order()
+    assert is_isomorphic(G, H)
+
+
+def test_check_homomorphism():
+    a = Permutation(1,2,3,4)
+    b = Permutation(1,3)
+    G = PermutationGroup([a, b])
+    raises(ValueError, lambda: homomorphism(G, G, [a], [a]))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_named_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_named_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..59bcb6ef3f020335de76d7a72152a0b58cbc6976
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_named_groups.py
@@ -0,0 +1,70 @@
+from sympy.combinatorics.named_groups import (SymmetricGroup, CyclicGroup,
+                                              DihedralGroup, AlternatingGroup,
+                                              AbelianGroup, RubikGroup)
+from sympy.testing.pytest import raises
+
+
+def test_SymmetricGroup():
+    G = SymmetricGroup(5)
+    elements = list(G.generate())
+    assert (G.generators[0]).size == 5
+    assert len(elements) == 120
+    assert G.is_solvable is False
+    assert G.is_abelian is False
+    assert G.is_nilpotent is False
+    assert G.is_transitive() is True
+    H = SymmetricGroup(1)
+    assert H.order() == 1
+    L = SymmetricGroup(2)
+    assert L.order() == 2
+
+
+def test_CyclicGroup():
+    G = CyclicGroup(10)
+    elements = list(G.generate())
+    assert len(elements) == 10
+    assert (G.derived_subgroup()).order() == 1
+    assert G.is_abelian is True
+    assert G.is_solvable is True
+    assert G.is_nilpotent is True
+    H = CyclicGroup(1)
+    assert H.order() == 1
+    L = CyclicGroup(2)
+    assert L.order() == 2
+
+
+def test_DihedralGroup():
+    G = DihedralGroup(6)
+    elements = list(G.generate())
+    assert len(elements) == 12
+    assert G.is_transitive() is True
+    assert G.is_abelian is False
+    assert G.is_solvable is True
+    assert G.is_nilpotent is False
+    H = DihedralGroup(1)
+    assert H.order() == 2
+    L = DihedralGroup(2)
+    assert L.order() == 4
+    assert L.is_abelian is True
+    assert L.is_nilpotent is True
+
+
+def test_AlternatingGroup():
+    G = AlternatingGroup(5)
+    elements = list(G.generate())
+    assert len(elements) == 60
+    assert [perm.is_even for perm in elements] == [True]*60
+    H = AlternatingGroup(1)
+    assert H.order() == 1
+    L = AlternatingGroup(2)
+    assert L.order() == 1
+
+
+def test_AbelianGroup():
+    A = AbelianGroup(3, 3, 3)
+    assert A.order() == 27
+    assert A.is_abelian is True
+
+
+def test_RubikGroup():
+    raises(ValueError, lambda: RubikGroup(1))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_partitions.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_partitions.py
new file mode 100644
index 0000000000000000000000000000000000000000..32e70e53a53aadbb17c8292bbef8f52d1144d6e0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_partitions.py
@@ -0,0 +1,118 @@
+from sympy.core.sorting import ordered, default_sort_key
+from sympy.combinatorics.partitions import (Partition, IntegerPartition,
+                                            RGS_enum, RGS_unrank, RGS_rank,
+                                            random_integer_partition)
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import partitions
+from sympy.sets.sets import Set, FiniteSet
+
+
+def test_partition_constructor():
+    raises(ValueError, lambda: Partition([1, 1, 2]))
+    raises(ValueError, lambda: Partition([1, 2, 3], [2, 3, 4]))
+    raises(ValueError, lambda: Partition(1, 2, 3))
+    raises(ValueError, lambda: Partition(*list(range(3))))
+
+    assert Partition([1, 2, 3], [4, 5]) == Partition([4, 5], [1, 2, 3])
+    assert Partition({1, 2, 3}, {4, 5}) == Partition([1, 2, 3], [4, 5])
+
+    a = FiniteSet(1, 2, 3)
+    b = FiniteSet(4, 5)
+    assert Partition(a, b) == Partition([1, 2, 3], [4, 5])
+    assert Partition({a, b}) == Partition(FiniteSet(a, b))
+    assert Partition({a, b}) != Partition(a, b)
+
+def test_partition():
+    from sympy.abc import x
+
+    a = Partition([1, 2, 3], [4])
+    b = Partition([1, 2], [3, 4])
+    c = Partition([x])
+    l = [a, b, c]
+    l.sort(key=default_sort_key)
+    assert l == [c, a, b]
+    l.sort(key=lambda w: default_sort_key(w, order='rev-lex'))
+    assert l == [c, a, b]
+
+    assert (a == b) is False
+    assert a <= b
+    assert (a > b) is False
+    assert a != b
+    assert a < b
+
+    assert (a + 2).partition == [[1, 2], [3, 4]]
+    assert (b - 1).partition == [[1, 2, 4], [3]]
+
+    assert (a - 1).partition == [[1, 2, 3, 4]]
+    assert (a + 1).partition == [[1, 2, 4], [3]]
+    assert (b + 1).partition == [[1, 2], [3], [4]]
+
+    assert a.rank == 1
+    assert b.rank == 3
+
+    assert a.RGS == (0, 0, 0, 1)
+    assert b.RGS == (0, 0, 1, 1)
+
+
+def test_integer_partition():
+    # no zeros in partition
+    raises(ValueError, lambda: IntegerPartition(list(range(3))))
+    # check fails since 1 + 2 != 100
+    raises(ValueError, lambda: IntegerPartition(100, list(range(1, 3))))
+    a = IntegerPartition(8, [1, 3, 4])
+    b = a.next_lex()
+    c = IntegerPartition([1, 3, 4])
+    d = IntegerPartition(8, {1: 3, 3: 1, 2: 1})
+    assert a == c
+    assert a.integer == d.integer
+    assert a.conjugate == [3, 2, 2, 1]
+    assert (a == b) is False
+    assert a <= b
+    assert (a > b) is False
+    assert a != b
+
+    for i in range(1, 11):
+        next = set()
+        prev = set()
+        a = IntegerPartition([i])
+        ans = {IntegerPartition(p) for p in partitions(i)}
+        n = len(ans)
+        for j in range(n):
+            next.add(a)
+            a = a.next_lex()
+            IntegerPartition(i, a.partition)  # check it by giving i
+        for j in range(n):
+            prev.add(a)
+            a = a.prev_lex()
+            IntegerPartition(i, a.partition)  # check it by giving i
+        assert next == ans
+        assert prev == ans
+
+    assert IntegerPartition([1, 2, 3]).as_ferrers() == '###\n##\n#'
+    assert IntegerPartition([1, 1, 3]).as_ferrers('o') == 'ooo\no\no'
+    assert str(IntegerPartition([1, 1, 3])) == '[3, 1, 1]'
+    assert IntegerPartition([1, 1, 3]).partition == [3, 1, 1]
+
+    raises(ValueError, lambda: random_integer_partition(-1))
+    assert random_integer_partition(1) == [1]
+    assert random_integer_partition(10, seed=[1, 3, 2, 1, 5, 1]
+            ) == [5, 2, 1, 1, 1]
+
+
+def test_rgs():
+    raises(ValueError, lambda: RGS_unrank(-1, 3))
+    raises(ValueError, lambda: RGS_unrank(3, 0))
+    raises(ValueError, lambda: RGS_unrank(10, 1))
+
+    raises(ValueError, lambda: Partition.from_rgs(list(range(3)), list(range(2))))
+    raises(ValueError, lambda: Partition.from_rgs(list(range(1, 3)), list(range(2))))
+    assert RGS_enum(-1) == 0
+    assert RGS_enum(1) == 1
+    assert RGS_unrank(7, 5) == [0, 0, 1, 0, 2]
+    assert RGS_unrank(23, 14) == [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 2]
+    assert RGS_rank(RGS_unrank(40, 100)) == 40
+
+def test_ordered_partition_9608():
+    a = Partition([1, 2, 3], [4])
+    b = Partition([1, 2], [3, 4])
+    assert list(ordered([a,b], Set._infimum_key))
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_pc_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_pc_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0c146279921e1e6499534fe9e33b993348d1503
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_pc_groups.py
@@ -0,0 +1,87 @@
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.named_groups import SymmetricGroup, AlternatingGroup, DihedralGroup
+from sympy.matrices import Matrix
+
+def test_pc_presentation():
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2), DihedralGroup(10)]
+
+    S = SymmetricGroup(125).sylow_subgroup(5)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    G = SymmetricGroup(25).sylow_subgroup(5)
+    Groups.append(G)
+
+    S = SymmetricGroup(11**2).sylow_subgroup(11)
+    G = S.derived_series()[2]
+    Groups.append(G)
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+        pc_presentation = collector.pc_presentation
+
+        pcgs = PcGroup.pcgs
+        free_group = collector.free_group
+        free_to_perm = {}
+        for s, g in zip(free_group.symbols, pcgs):
+            free_to_perm[s] = g
+
+        for k, v in pc_presentation.items():
+            k_array = k.array_form
+            if v != ():
+                v_array = v.array_form
+
+            lhs = Permutation()
+            for gen in k_array:
+                s = gen[0]
+                e = gen[1]
+                lhs = lhs*free_to_perm[s]**e
+
+            if v == ():
+                assert lhs.is_identity
+                continue
+
+            rhs = Permutation()
+            for gen in v_array:
+                s = gen[0]
+                e = gen[1]
+                rhs = rhs*free_to_perm[s]**e
+
+            assert lhs == rhs
+
+
+def test_exponent_vector():
+
+    Groups = [SymmetricGroup(3), SymmetricGroup(4), SymmetricGroup(9).sylow_subgroup(3),
+         SymmetricGroup(9).sylow_subgroup(2), SymmetricGroup(8).sylow_subgroup(2)]
+
+    for G in Groups:
+        PcGroup = G.polycyclic_group()
+        collector = PcGroup.collector
+
+        pcgs = PcGroup.pcgs
+        # free_group = collector.free_group
+
+        for gen in G.generators:
+            exp = collector.exponent_vector(gen)
+            g = Permutation()
+            for i in range(len(exp)):
+                g = g*pcgs[i]**exp[i] if exp[i] else g
+            assert g == gen
+
+
+def test_induced_pcgs():
+    G = [SymmetricGroup(9).sylow_subgroup(3), SymmetricGroup(20).sylow_subgroup(2), AlternatingGroup(4),
+    DihedralGroup(4), DihedralGroup(10), DihedralGroup(9), SymmetricGroup(3), SymmetricGroup(4)]
+
+    for g in G:
+        PcGroup = g.polycyclic_group()
+        collector = PcGroup.collector
+        gens = list(g.generators)
+        ipcgs = collector.induced_pcgs(gens)
+        m = []
+        for i in ipcgs:
+            m.append(collector.exponent_vector(i))
+        assert Matrix(m).is_upper
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_perm_groups.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_perm_groups.py
new file mode 100644
index 0000000000000000000000000000000000000000..763b8fb0ae357500d68c29fe1c9e6b156e224949
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_perm_groups.py
@@ -0,0 +1,1243 @@
+from sympy.core.containers import Tuple
+from sympy.combinatorics.generators import rubik_cube_generators
+from sympy.combinatorics.homomorphisms import is_isomorphic
+from sympy.combinatorics.named_groups import SymmetricGroup, CyclicGroup,\
+    DihedralGroup, AlternatingGroup, AbelianGroup, RubikGroup
+from sympy.combinatorics.perm_groups import (PermutationGroup,
+    _orbit_transversal, Coset, SymmetricPermutationGroup)
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.polyhedron import tetrahedron as Tetra, cube
+from sympy.combinatorics.testutil import _verify_bsgs, _verify_centralizer,\
+    _verify_normal_closure
+from sympy.testing.pytest import skip, XFAIL, slow
+
+rmul = Permutation.rmul
+
+
+def test_has():
+    a = Permutation([1, 0])
+    G = PermutationGroup([a])
+    assert G.is_abelian
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert not G.is_abelian
+
+    G = PermutationGroup([a])
+    assert G.has(a)
+    assert not G.has(b)
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([0, 2, 1, 3, 4])
+    assert PermutationGroup(a, b).degree == \
+        PermutationGroup(a, b).degree == 6
+
+    g = PermutationGroup(Permutation(0, 2, 1))
+    assert Tuple(1, g).has(g)
+
+
+def test_generate():
+    a = Permutation([1, 0])
+    g = list(PermutationGroup([a]).generate())
+    assert g == [Permutation([0, 1]), Permutation([1, 0])]
+    assert len(list(PermutationGroup(Permutation((0, 1))).generate())) == 1
+    g = PermutationGroup([a]).generate(method='dimino')
+    assert list(g) == [Permutation([0, 1]), Permutation([1, 0])]
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    g = G.generate()
+    v1 = [p.array_form for p in list(g)]
+    v1.sort()
+    assert v1 == [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0,
+        1], [2, 1, 0]]
+    v2 = list(G.generate(method='dimino', af=True))
+    assert v1 == sorted(v2)
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b]).generate(af=True)
+    assert len(list(g)) == 360
+
+
+def test_order():
+    a = Permutation([2, 0, 1, 3, 4, 5, 6, 7, 8, 9])
+    b = Permutation([2, 1, 3, 4, 5, 6, 7, 8, 9, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 1814400
+    assert PermutationGroup().order() == 1
+
+
+def test_equality():
+    p_1 = Permutation(0, 1, 3)
+    p_2 = Permutation(0, 2, 3)
+    p_3 = Permutation(0, 1, 2)
+    p_4 = Permutation(0, 1, 3)
+    g_1 = PermutationGroup(p_1, p_2)
+    g_2 = PermutationGroup(p_3, p_4)
+    g_3 = PermutationGroup(p_2, p_1)
+    g_4 = PermutationGroup(p_1, p_2)
+
+    assert g_1 != g_2
+    assert g_1.generators != g_2.generators
+    assert g_1.equals(g_2)
+    assert g_1 != g_3
+    assert g_1.equals(g_3)
+    assert g_1 == g_4
+
+
+def test_stabilizer():
+    S = SymmetricGroup(2)
+    H = S.stabilizer(0)
+    assert H.generators == [Permutation(1)]
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    G = PermutationGroup([a, b])
+    G0 = G.stabilizer(0)
+    assert G0.order() == 60
+
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 6
+    G2_1 = G2.stabilizer(1)
+    v = list(G2_1.generate(af=True))
+    assert v == [[0, 1, 2, 3, 4, 5, 6, 7], [3, 1, 2, 0, 7, 5, 6, 4]]
+
+    gens = (
+        (1, 2, 0, 4, 5, 3, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19),
+        (0, 1, 2, 3, 4, 5, 19, 6, 8, 9, 10, 11, 12, 13, 14,
+         15, 16, 7, 17, 18),
+        (0, 1, 2, 3, 4, 5, 6, 7, 9, 18, 16, 11, 12, 13, 14, 15, 8, 17, 10, 19))
+    gens = [Permutation(p) for p in gens]
+    G = PermutationGroup(gens)
+    G2 = G.stabilizer(2)
+    assert G2.order() == 181440
+    S = SymmetricGroup(3)
+    assert [G.order() for G in S.basic_stabilizers] == [6, 2]
+
+
+def test_center():
+    # the center of the dihedral group D_n is of order 2 for even n
+    for i in (4, 6, 10):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 2
+    # the center of the dihedral group D_n is of order 1 for odd n>2
+    for i in (3, 5, 7):
+        D = DihedralGroup(i)
+        assert (D.center()).order() == 1
+    # the center of an abelian group is the group itself
+    for i in (2, 3, 5):
+        for j in (1, 5, 7):
+            for k in (1, 1, 11):
+                G = AbelianGroup(i, j, k)
+                assert G.center().is_subgroup(G)
+    # the center of a nonabelian simple group is trivial
+    for i in(1, 5, 9):
+        A = AlternatingGroup(i)
+        assert (A.center()).order() == 1
+    # brute-force verifications
+    D = DihedralGroup(5)
+    A = AlternatingGroup(3)
+    C = CyclicGroup(4)
+    G.is_subgroup(D*A*C)
+    assert _verify_centralizer(G, G)
+
+
+def test_centralizer():
+    # the centralizer of the trivial group is the entire group
+    S = SymmetricGroup(2)
+    assert S.centralizer(Permutation(list(range(2)))).is_subgroup(S)
+    A = AlternatingGroup(5)
+    assert A.centralizer(Permutation(list(range(5)))).is_subgroup(A)
+    # a centralizer in the trivial group is the trivial group itself
+    triv = PermutationGroup([Permutation([0, 1, 2, 3])])
+    D = DihedralGroup(4)
+    assert triv.centralizer(D).is_subgroup(triv)
+    # brute-force verifications for centralizers of groups
+    for i in (4, 5, 6):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        D = DihedralGroup(i)
+        for gp in (S, A, C, D):
+            for gp2 in (S, A, C, D):
+                if not gp2.is_subgroup(gp):
+                    assert _verify_centralizer(gp, gp2)
+    # verify the centralizer for all elements of several groups
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(S, element)
+    A = AlternatingGroup(5)
+    elements = list(A.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(A, element)
+    D = DihedralGroup(7)
+    elements = list(D.generate_dimino())
+    for element in elements:
+        assert _verify_centralizer(D, element)
+    # verify centralizers of small groups within small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp.degree == gp2.degree:
+                assert _verify_centralizer(gp, gp2)
+
+
+def test_coset_rank():
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    i = 0
+    for h in G.generate(af=True):
+        rk = G.coset_rank(h)
+        assert rk == i
+        h1 = G.coset_unrank(rk, af=True)
+        assert h == h1
+        i += 1
+    assert G.coset_unrank(48) is None
+    assert G.coset_unrank(G.coset_rank(gens[0])) == gens[0]
+
+
+def test_coset_factor():
+    a = Permutation([0, 2, 1])
+    G = PermutationGroup([a])
+    c = Permutation([2, 1, 0])
+    assert not G.coset_factor(c)
+    assert G.coset_rank(c) is None
+
+    a = Permutation([2, 0, 1, 3, 4, 5])
+    b = Permutation([2, 1, 3, 4, 5, 0])
+    g = PermutationGroup([a, b])
+    assert g.order() == 360
+    d = Permutation([1, 0, 2, 3, 4, 5])
+    assert not g.coset_factor(d.array_form)
+    assert not g.contains(d)
+    assert Permutation(2) in G
+    c = Permutation([1, 0, 2, 3, 5, 4])
+    v = g.coset_factor(c, True)
+    tr = g.basic_transversals
+    p = Permutation.rmul(*[tr[i][v[i]] for i in range(len(g.base))])
+    assert p == c
+    v = g.coset_factor(c)
+    p = Permutation.rmul(*v)
+    assert p == c
+    assert g.contains(c)
+    G = PermutationGroup([Permutation([2, 1, 0])])
+    p = Permutation([1, 0, 2])
+    assert G.coset_factor(p) == []
+
+
+def test_orbits():
+    a = Permutation([2, 0, 1])
+    b = Permutation([2, 1, 0])
+    g = PermutationGroup([a, b])
+    assert g.orbit(0) == {0, 1, 2}
+    assert g.orbits() == [{0, 1, 2}]
+    assert g.is_transitive() and g.is_transitive(strict=False)
+    assert g.orbit_transversal(0) == \
+        [Permutation(
+            [0, 1, 2]), Permutation([2, 0, 1]), Permutation([1, 2, 0])]
+    assert g.orbit_transversal(0, True) == \
+        [(0, Permutation([0, 1, 2])), (2, Permutation([2, 0, 1])),
+        (1, Permutation([1, 2, 0]))]
+
+    G = DihedralGroup(6)
+    transversal, slps = _orbit_transversal(G.degree, G.generators, 0, True, slp=True)
+    for i, t in transversal:
+        slp = slps[i]
+        w = G.identity
+        for s in slp:
+            w = G.generators[s]*w
+        assert w == t
+
+    a = Permutation(list(range(1, 100)) + [0])
+    G = PermutationGroup([a])
+    assert [min(o) for o in G.orbits()] == [0]
+    G = PermutationGroup(rubik_cube_generators())
+    assert [min(o) for o in G.orbits()] == [0, 1]
+    assert not G.is_transitive() and not G.is_transitive(strict=False)
+    G = PermutationGroup([Permutation(0, 1, 3), Permutation(3)(0, 1)])
+    assert not G.is_transitive() and G.is_transitive(strict=False)
+    assert PermutationGroup(
+        Permutation(3)).is_transitive(strict=False) is False
+
+
+def test_is_normal():
+    gens_s5 = [Permutation(p) for p in [[1, 2, 3, 4, 0], [2, 1, 4, 0, 3]]]
+    G1 = PermutationGroup(gens_s5)
+    assert G1.order() == 120
+    gens_a5 = [Permutation(p) for p in [[1, 0, 3, 2, 4], [2, 1, 4, 3, 0]]]
+    G2 = PermutationGroup(gens_a5)
+    assert G2.order() == 60
+    assert G2.is_normal(G1)
+    gens3 = [Permutation(p) for p in [[2, 1, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G3 = PermutationGroup(gens3)
+    assert not G3.is_normal(G1)
+    assert G3.order() == 12
+    G4 = G1.normal_closure(G3.generators)
+    assert G4.order() == 60
+    gens5 = [Permutation(p) for p in [[1, 2, 3, 0, 4], [1, 2, 0, 3, 4]]]
+    G5 = PermutationGroup(gens5)
+    assert G5.order() == 24
+    G6 = G1.normal_closure(G5.generators)
+    assert G6.order() == 120
+    assert G1.is_subgroup(G6)
+    assert not G1.is_subgroup(G4)
+    assert G2.is_subgroup(G4)
+    I5 = PermutationGroup(Permutation(4))
+    assert I5.is_normal(G5)
+    assert I5.is_normal(G6, strict=False)
+    p1 = Permutation([1, 0, 2, 3, 4])
+    p2 = Permutation([0, 1, 2, 4, 3])
+    p3 = Permutation([3, 4, 2, 1, 0])
+    id_ = Permutation([0, 1, 2, 3, 4])
+    H = PermutationGroup([p1, p3])
+    H_n1 = PermutationGroup([p1, p2])
+    H_n2_1 = PermutationGroup(p1)
+    H_n2_2 = PermutationGroup(p2)
+    H_id = PermutationGroup(id_)
+    assert H_n1.is_normal(H)
+    assert H_n2_1.is_normal(H_n1)
+    assert H_n2_2.is_normal(H_n1)
+    assert H_id.is_normal(H_n2_1)
+    assert H_id.is_normal(H_n1)
+    assert H_id.is_normal(H)
+    assert not H_n2_1.is_normal(H)
+    assert not H_n2_2.is_normal(H)
+
+
+def test_eq():
+    a = [[1, 2, 0, 3, 4, 5], [1, 0, 2, 3, 4, 5], [2, 1, 0, 3, 4, 5], [
+        1, 2, 0, 3, 4, 5]]
+    a = [Permutation(p) for p in a + [[1, 2, 3, 4, 5, 0]]]
+    g = Permutation([1, 2, 3, 4, 5, 0])
+    G1, G2, G3 = [PermutationGroup(x) for x in [a[:2], a[2:4], [g, g**2]]]
+    assert G1.order() == G2.order() == G3.order() == 6
+    assert G1.is_subgroup(G2)
+    assert not G1.is_subgroup(G3)
+    G4 = PermutationGroup([Permutation([0, 1])])
+    assert not G1.is_subgroup(G4)
+    assert G4.is_subgroup(G1, 0)
+    assert PermutationGroup(g, g).is_subgroup(PermutationGroup(g))
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(4), 0)
+    assert SymmetricGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert not CyclicGroup(5).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+    assert CyclicGroup(3).is_subgroup(SymmetricGroup(3)*CyclicGroup(5), 0)
+
+
+def test_derived_subgroup():
+    a = Permutation([1, 0, 2, 4, 3])
+    b = Permutation([0, 1, 3, 2, 4])
+    G = PermutationGroup([a, b])
+    C = G.derived_subgroup()
+    assert C.order() == 3
+    assert C.is_normal(G)
+    assert C.is_subgroup(G, 0)
+    assert not G.is_subgroup(C, 0)
+    gens_cube = [[1, 3, 5, 7, 0, 2, 4, 6], [1, 3, 0, 2, 5, 7, 4, 6]]
+    gens = [Permutation(p) for p in gens_cube]
+    G = PermutationGroup(gens)
+    C = G.derived_subgroup()
+    assert C.order() == 12
+
+
+def test_is_solvable():
+    a = Permutation([1, 2, 0])
+    b = Permutation([1, 0, 2])
+    G = PermutationGroup([a, b])
+    assert G.is_solvable
+    G = PermutationGroup([a])
+    assert G.is_solvable
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert not G.is_solvable
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(3)
+    assert S.is_solvable
+
+def test_rubik1():
+    gens = rubik_cube_generators()
+    gens1 = [gens[-1]] + [p**2 for p in gens[1:]]
+    G1 = PermutationGroup(gens1)
+    assert G1.order() == 19508428800
+    gens2 = [p**2 for p in gens]
+    G2 = PermutationGroup(gens2)
+    assert G2.order() == 663552
+    assert G2.is_subgroup(G1, 0)
+    C1 = G1.derived_subgroup()
+    assert C1.order() == 4877107200
+    assert C1.is_subgroup(G1, 0)
+    assert not G2.is_subgroup(C1, 0)
+
+    G = RubikGroup(2)
+    assert G.order() == 3674160
+
+
+@XFAIL
+def test_rubik():
+    skip('takes too much time')
+    G = PermutationGroup(rubik_cube_generators())
+    assert G.order() == 43252003274489856000
+    G1 = PermutationGroup(G[:3])
+    assert G1.order() == 170659735142400
+    assert not G1.is_normal(G)
+    G2 = G.normal_closure(G1.generators)
+    assert G2.is_subgroup(G)
+
+
+def test_direct_product():
+    C = CyclicGroup(4)
+    D = DihedralGroup(4)
+    G = C*C*C
+    assert G.order() == 64
+    assert G.degree == 12
+    assert len(G.orbits()) == 3
+    assert G.is_abelian is True
+    H = D*C
+    assert H.order() == 32
+    assert H.is_abelian is False
+
+
+def test_orbit_rep():
+    G = DihedralGroup(6)
+    assert G.orbit_rep(1, 3) in [Permutation([2, 3, 4, 5, 0, 1]),
+    Permutation([4, 3, 2, 1, 0, 5])]
+    H = CyclicGroup(4)*G
+    assert H.orbit_rep(1, 5) is False
+
+
+def test_schreier_vector():
+    G = CyclicGroup(50)
+    v = [0]*50
+    v[23] = -1
+    assert G.schreier_vector(23) == v
+    H = DihedralGroup(8)
+    assert H.schreier_vector(2) == [0, 1, -1, 0, 0, 1, 0, 0]
+    L = SymmetricGroup(4)
+    assert L.schreier_vector(1) == [1, -1, 0, 0]
+
+
+def test_random_pr():
+    D = DihedralGroup(6)
+    r = 11
+    n = 3
+    _random_prec_n = {}
+    _random_prec_n[0] = {'s': 7, 't': 3, 'x': 2, 'e': -1}
+    _random_prec_n[1] = {'s': 5, 't': 5, 'x': 1, 'e': -1}
+    _random_prec_n[2] = {'s': 3, 't': 4, 'x': 2, 'e': 1}
+    D._random_pr_init(r, n, _random_prec_n=_random_prec_n)
+    assert D._random_gens[11] == [0, 1, 2, 3, 4, 5]
+    _random_prec = {'s': 2, 't': 9, 'x': 1, 'e': -1}
+    assert D.random_pr(_random_prec=_random_prec) == \
+        Permutation([0, 5, 4, 3, 2, 1])
+
+
+def test_is_alt_sym():
+    G = DihedralGroup(10)
+    assert G.is_alt_sym() is False
+    assert G._eval_is_alt_sym_naive() is False
+    assert G._eval_is_alt_sym_naive(only_alt=True) is False
+    assert G._eval_is_alt_sym_naive(only_sym=True) is False
+
+    S = SymmetricGroup(10)
+    assert S._eval_is_alt_sym_naive() is True
+    assert S._eval_is_alt_sym_naive(only_alt=True) is False
+    assert S._eval_is_alt_sym_naive(only_sym=True) is True
+
+    N_eps = 10
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[2], [1, 4], [0, 6, 7, 8, 9, 3, 5]]),
+        1: Permutation([[1, 8, 7, 6, 3, 5, 2, 9], [0, 4]]),
+        2: Permutation([[5, 8], [4, 7], [0, 1, 2, 3, 6, 9]]),
+        3: Permutation([[3], [0, 8, 2, 7, 4, 1, 6, 9, 5]]),
+        4: Permutation([[8], [4, 7, 9], [3, 6], [0, 5, 1, 2]]),
+        5: Permutation([[6], [0, 2, 4, 5, 1, 8, 3, 9, 7]]),
+        6: Permutation([[6, 9, 8], [4, 5], [1, 3, 7], [0, 2]]),
+        7: Permutation([[4], [0, 2, 9, 1, 3, 8, 6, 5, 7]]),
+        8: Permutation([[1, 5, 6, 3], [0, 2, 7, 8, 4, 9]]),
+        9: Permutation([[8], [6, 7], [2, 3, 4, 5], [0, 1, 9]])}
+    assert S.is_alt_sym(_random_prec=_random_prec) is True
+
+    A = AlternatingGroup(10)
+    assert A._eval_is_alt_sym_naive() is True
+    assert A._eval_is_alt_sym_naive(only_alt=True) is True
+    assert A._eval_is_alt_sym_naive(only_sym=True) is False
+
+    _random_prec = {'N_eps': N_eps,
+        0: Permutation([[1, 6, 4, 2, 7, 8, 5, 9, 3], [0]]),
+        1: Permutation([[1], [0, 5, 8, 4, 9, 2, 3, 6, 7]]),
+        2: Permutation([[1, 9, 8, 3, 2, 5], [0, 6, 7, 4]]),
+        3: Permutation([[6, 8, 9], [4, 5], [1, 3, 7, 2], [0]]),
+        4: Permutation([[8], [5], [4], [2, 6, 9, 3], [1], [0, 7]]),
+        5: Permutation([[3, 6], [0, 8, 1, 7, 5, 9, 4, 2]]),
+        6: Permutation([[5], [2, 9], [1, 8, 3], [0, 4, 7, 6]]),
+        7: Permutation([[1, 8, 4, 7, 2, 3], [0, 6, 9, 5]]),
+        8: Permutation([[5, 8, 7], [3], [1, 4, 2, 6], [0, 9]]),
+        9: Permutation([[4, 9, 6], [3, 8], [1, 2], [0, 5, 7]])}
+    assert A.is_alt_sym(_random_prec=_random_prec) is False
+
+    G = PermutationGroup(
+        Permutation(1, 3, size=8)(0, 2, 4, 6),
+        Permutation(5, 7, size=8)(0, 2, 4, 6))
+    assert G.is_alt_sym() is False
+
+    # Tests for monte-carlo c_n parameter setting, and which guarantees
+    # to give False.
+    G = DihedralGroup(10)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+    G = DihedralGroup(20)
+    assert G._eval_is_alt_sym_monte_carlo() is False
+
+    # A dry-running test to check if it looks up for the updated cache.
+    G = DihedralGroup(6)
+    G.is_alt_sym()
+    assert G.is_alt_sym() is False
+
+
+def test_minimal_block():
+    D = DihedralGroup(6)
+    block_system = D.minimal_block([0, 3])
+    for i in range(3):
+        assert block_system[i] == block_system[i + 3]
+    S = SymmetricGroup(6)
+    assert S.minimal_block([0, 1]) == [0, 0, 0, 0, 0, 0]
+
+    assert Tetra.pgroup.minimal_block([0, 1]) == [0, 0, 0, 0]
+
+    P1 = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    P2 = PermutationGroup(Permutation(0, 1, 2, 3, 4, 5), Permutation(1, 5)(2, 4))
+    assert P1.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+    assert P2.minimal_block([0, 2]) == [0, 1, 0, 1, 0, 1]
+
+
+def test_minimal_blocks():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    assert P.minimal_blocks() == [[0, 1, 0, 1, 0, 1], [0, 1, 2, 0, 1, 2]]
+
+    P = SymmetricGroup(5)
+    assert P.minimal_blocks() == [[0]*5]
+
+    P = PermutationGroup(Permutation(0, 3))
+    assert P.minimal_blocks() is False
+
+
+def test_max_div():
+    S = SymmetricGroup(10)
+    assert S.max_div == 5
+
+
+def test_is_primitive():
+    S = SymmetricGroup(5)
+    assert S.is_primitive() is True
+    C = CyclicGroup(7)
+    assert C.is_primitive() is True
+
+    a = Permutation(0, 1, 2, size=6)
+    b = Permutation(3, 4, 5, size=6)
+    G = PermutationGroup(a, b)
+    assert G.is_primitive() is False
+
+
+def test_random_stab():
+    S = SymmetricGroup(5)
+    _random_el = Permutation([1, 3, 2, 0, 4])
+    _random_prec = {'rand': _random_el}
+    g = S.random_stab(2, _random_prec=_random_prec)
+    assert g == Permutation([1, 3, 2, 0, 4])
+    h = S.random_stab(1)
+    assert h(1) == 1
+
+
+def test_transitivity_degree():
+    perm = Permutation([1, 2, 0])
+    C = PermutationGroup([perm])
+    assert C.transitivity_degree == 1
+    gen1 = Permutation([1, 2, 0, 3, 4])
+    gen2 = Permutation([1, 2, 3, 4, 0])
+    # alternating group of degree 5
+    Alt = PermutationGroup([gen1, gen2])
+    assert Alt.transitivity_degree == 3
+
+
+def test_schreier_sims_random():
+    assert sorted(Tetra.pgroup.base) == [0, 1]
+
+    S = SymmetricGroup(3)
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([1, 0, 2]),
+                  Permutation([0, 2, 1])]
+    assert S.schreier_sims_random(base, strong_gens, 5) == (base, strong_gens)
+    D = DihedralGroup(3)
+    _random_prec = {'g': [Permutation([2, 0, 1]), Permutation([1, 2, 0]),
+                         Permutation([1, 0, 2])]}
+    base = [0, 1]
+    strong_gens = [Permutation([1, 2, 0]), Permutation([2, 1, 0]),
+                  Permutation([0, 2, 1])]
+    assert D.schreier_sims_random([], D.generators, 2,
+           _random_prec=_random_prec) == (base, strong_gens)
+
+
+def test_baseswap():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    assert base == [0, 1, 2]
+    deterministic = S.baseswap(base, strong_gens, 1, randomized=False)
+    randomized = S.baseswap(base, strong_gens, 1)
+    assert deterministic[0] == [0, 2, 1]
+    assert _verify_bsgs(S, deterministic[0], deterministic[1]) is True
+    assert randomized[0] == [0, 2, 1]
+    assert _verify_bsgs(S, randomized[0], randomized[1]) is True
+
+
+def test_schreier_sims_incremental():
+    identity = Permutation([0, 1, 2, 3, 4])
+    TrivialGroup = PermutationGroup([identity])
+    base, strong_gens = TrivialGroup.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(TrivialGroup, base, strong_gens) is True
+    S = SymmetricGroup(5)
+    base, strong_gens = S.schreier_sims_incremental(base=[0, 1, 2])
+    assert _verify_bsgs(S, base, strong_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental(base=[1])
+    assert _verify_bsgs(D, base, strong_gens) is True
+    A = AlternatingGroup(7)
+    gens = A.generators[:]
+    gen0 = gens[0]
+    gen1 = gens[1]
+    gen1 = rmul(gen1, ~gen0)
+    gen0 = rmul(gen0, gen1)
+    gen1 = rmul(gen0, gen1)
+    base, strong_gens = A.schreier_sims_incremental(base=[0, 1], gens=gens)
+    assert _verify_bsgs(A, base, strong_gens) is True
+    C = CyclicGroup(11)
+    gen = C.generators[0]
+    base, strong_gens = C.schreier_sims_incremental(gens=[gen**3])
+    assert _verify_bsgs(C, base, strong_gens) is True
+
+
+def _subgroup_search(i, j, k):
+    prop_true = lambda x: True
+    prop_fix_points = lambda x: [x(point) for point in points] == points
+    prop_comm_g = lambda x: rmul(x, g) == rmul(g, x)
+    prop_even = lambda x: x.is_even
+    for i in range(i, j, k):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        C = CyclicGroup(i)
+        Sym = S.subgroup_search(prop_true)
+        assert Sym.is_subgroup(S)
+        Alt = S.subgroup_search(prop_even)
+        assert Alt.is_subgroup(A)
+        Sym = S.subgroup_search(prop_true, init_subgroup=C)
+        assert Sym.is_subgroup(S)
+        points = [7]
+        assert S.stabilizer(7).is_subgroup(S.subgroup_search(prop_fix_points))
+        points = [3, 4]
+        assert S.stabilizer(3).stabilizer(4).is_subgroup(
+            S.subgroup_search(prop_fix_points))
+        points = [3, 5]
+        fix35 = A.subgroup_search(prop_fix_points)
+        points = [5]
+        fix5 = A.subgroup_search(prop_fix_points)
+        assert A.subgroup_search(prop_fix_points, init_subgroup=fix35
+            ).is_subgroup(fix5)
+        base, strong_gens = A.schreier_sims_incremental()
+        g = A.generators[0]
+        comm_g = \
+            A.subgroup_search(prop_comm_g, base=base, strong_gens=strong_gens)
+        assert _verify_bsgs(comm_g, base, comm_g.generators) is True
+        assert [prop_comm_g(gen) is True for gen in comm_g.generators]
+
+
+def test_subgroup_search():
+    _subgroup_search(10, 15, 2)
+
+
+@XFAIL
+def test_subgroup_search2():
+    skip('takes too much time')
+    _subgroup_search(16, 17, 1)
+
+
+def test_normal_closure():
+    # the normal closure of the trivial group is trivial
+    S = SymmetricGroup(3)
+    identity = Permutation([0, 1, 2])
+    closure = S.normal_closure(identity)
+    assert closure.is_trivial
+    # the normal closure of the entire group is the entire group
+    A = AlternatingGroup(4)
+    assert A.normal_closure(A).is_subgroup(A)
+    # brute-force verifications for subgroups
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        C = CyclicGroup(i)
+        for gp in (A, D, C):
+            assert _verify_normal_closure(S, gp)
+    # brute-force verifications for all elements of a group
+    S = SymmetricGroup(5)
+    elements = list(S.generate_dimino())
+    for element in elements:
+        assert _verify_normal_closure(S, element)
+    # small groups
+    small = []
+    for i in (1, 2, 3):
+        small.append(SymmetricGroup(i))
+        small.append(AlternatingGroup(i))
+        small.append(DihedralGroup(i))
+        small.append(CyclicGroup(i))
+    for gp in small:
+        for gp2 in small:
+            if gp2.is_subgroup(gp, 0) and gp2.degree == gp.degree:
+                assert _verify_normal_closure(gp, gp2)
+
+
+def test_derived_series():
+    # the derived series of the trivial group consists only of the trivial group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.derived_series()[0].is_subgroup(triv)
+    # the derived series for a simple group consists only of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.derived_series()[0].is_subgroup(A)
+    # the derived series for S_4 is S_4 > A_4 > K_4 > triv
+    S = SymmetricGroup(4)
+    series = S.derived_series()
+    assert series[1].is_subgroup(AlternatingGroup(4))
+    assert series[2].is_subgroup(DihedralGroup(2))
+    assert series[3].is_trivial
+
+
+def test_lower_central_series():
+    # the lower central series of the trivial group consists of the trivial
+    # group
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert triv.lower_central_series()[0].is_subgroup(triv)
+    # the lower central series of a simple group consists of the group itself
+    for i in (5, 6, 7):
+        A = AlternatingGroup(i)
+        assert A.lower_central_series()[0].is_subgroup(A)
+    # GAP-verified example
+    S = SymmetricGroup(6)
+    series = S.lower_central_series()
+    assert len(series) == 2
+    assert series[1].is_subgroup(AlternatingGroup(6))
+
+
+def test_commutator():
+    # the commutator of the trivial group and the trivial group is trivial
+    S = SymmetricGroup(3)
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert S.commutator(triv, triv).is_subgroup(triv)
+    # the commutator of the trivial group and any other group is again trivial
+    A = AlternatingGroup(3)
+    assert S.commutator(triv, A).is_subgroup(triv)
+    # the commutator is commutative
+    for i in (3, 4, 5):
+        S = SymmetricGroup(i)
+        A = AlternatingGroup(i)
+        D = DihedralGroup(i)
+        assert S.commutator(A, D).is_subgroup(S.commutator(D, A))
+    # the commutator of an abelian group is trivial
+    S = SymmetricGroup(7)
+    A1 = AbelianGroup(2, 5)
+    A2 = AbelianGroup(3, 4)
+    triv = PermutationGroup([Permutation([0, 1, 2, 3, 4, 5, 6])])
+    assert S.commutator(A1, A1).is_subgroup(triv)
+    assert S.commutator(A2, A2).is_subgroup(triv)
+    # examples calculated by hand
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert S.commutator(A, S).is_subgroup(A)
+
+
+def test_is_nilpotent():
+    # every abelian group is nilpotent
+    for i in (1, 2, 3):
+        C = CyclicGroup(i)
+        Ab = AbelianGroup(i, i + 2)
+        assert C.is_nilpotent
+        assert Ab.is_nilpotent
+    Ab = AbelianGroup(5, 7, 10)
+    assert Ab.is_nilpotent
+    # A_5 is not solvable and thus not nilpotent
+    assert AlternatingGroup(5).is_nilpotent is False
+
+
+def test_is_trivial():
+    for i in range(5):
+        triv = PermutationGroup([Permutation(list(range(i)))])
+        assert triv.is_trivial
+
+
+def test_pointwise_stabilizer():
+    S = SymmetricGroup(2)
+    stab = S.pointwise_stabilizer([0])
+    assert stab.generators == [Permutation(1)]
+    S = SymmetricGroup(5)
+    points = []
+    stab = S
+    for point in (2, 0, 3, 4, 1):
+        stab = stab.stabilizer(point)
+        points.append(point)
+        assert S.pointwise_stabilizer(points).is_subgroup(stab)
+
+
+def test_make_perm():
+    assert cube.pgroup.make_perm(5, seed=list(range(5))) == \
+        Permutation([4, 7, 6, 5, 0, 3, 2, 1])
+    assert cube.pgroup.make_perm(7, seed=list(range(7))) == \
+        Permutation([6, 7, 3, 2, 5, 4, 0, 1])
+
+
+def test_elements():
+    from sympy.sets.sets import FiniteSet
+
+    p = Permutation(2, 3)
+    assert set(PermutationGroup(p).elements) == {Permutation(3), Permutation(2, 3)}
+    assert FiniteSet(*PermutationGroup(p).elements) \
+        == FiniteSet(Permutation(2, 3), Permutation(3))
+
+
+def test_is_group():
+    assert PermutationGroup(Permutation(1,2), Permutation(2,4)).is_group is True
+    assert SymmetricGroup(4).is_group is True
+
+
+def test_PermutationGroup():
+    assert PermutationGroup() == PermutationGroup(Permutation())
+    assert (PermutationGroup() == 0) is False
+
+
+def test_coset_transvesal():
+    G = AlternatingGroup(5)
+    H = PermutationGroup(Permutation(0,1,2),Permutation(1,2)(3,4))
+    assert G.coset_transversal(H) == \
+        [Permutation(4), Permutation(2, 3, 4), Permutation(2, 4, 3),
+         Permutation(1, 2, 4), Permutation(4)(1, 2, 3), Permutation(1, 3)(2, 4),
+         Permutation(0, 1, 2, 3, 4), Permutation(0, 1, 2, 4, 3),
+         Permutation(0, 1, 3, 2, 4), Permutation(0, 2, 4, 1, 3)]
+
+
+def test_coset_table():
+    G = PermutationGroup(Permutation(0,1,2,3), Permutation(0,1,2),
+         Permutation(0,4,2,7), Permutation(5,6), Permutation(0,7))
+    H = PermutationGroup(Permutation(0,1,2,3), Permutation(0,7))
+    assert G.coset_table(H) == \
+        [[0, 0, 0, 0, 1, 2, 3, 3, 0, 0], [4, 5, 2, 5, 6, 0, 7, 7, 1, 1],
+         [5, 4, 5, 1, 0, 6, 8, 8, 6, 6], [3, 3, 3, 3, 7, 8, 0, 0, 3, 3],
+         [2, 1, 4, 4, 4, 4, 9, 9, 4, 4], [1, 2, 1, 2, 5, 5, 10, 10, 5, 5],
+         [6, 6, 6, 6, 2, 1, 11, 11, 2, 2], [9, 10, 8, 10, 11, 3, 1, 1, 7, 7],
+         [10, 9, 10, 7, 3, 11, 2, 2, 11, 11], [8, 7, 9, 9, 9, 9, 4, 4, 9, 9],
+         [7, 8, 7, 8, 10, 10, 5, 5, 10, 10], [11, 11, 11, 11, 8, 7, 6, 6, 8, 8]]
+
+
+def test_subgroup():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert H.is_subgroup(G)
+
+
+def test_generator_product():
+    G = SymmetricGroup(5)
+    p = Permutation(0, 2, 3)(1, 4)
+    gens = G.generator_product(p)
+    assert all(g in G.strong_gens for g in gens)
+    w = G.identity
+    for g in gens:
+        w = g*w
+    assert w == p
+
+
+def test_sylow_subgroup():
+    P = PermutationGroup(Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5))
+    S = P.sylow_subgroup(2)
+    assert S.order() == 4
+
+    P = DihedralGroup(12)
+    S = P.sylow_subgroup(3)
+    assert S.order() == 3
+
+    P = PermutationGroup(
+        Permutation(1, 5)(2, 4), Permutation(0, 1, 2, 3, 4, 5), Permutation(0, 2))
+    S = P.sylow_subgroup(3)
+    assert S.order() == 9
+    S = P.sylow_subgroup(2)
+    assert S.order() == 8
+
+    P = SymmetricGroup(10)
+    S = P.sylow_subgroup(2)
+    assert S.order() == 256
+    S = P.sylow_subgroup(3)
+    assert S.order() == 81
+    S = P.sylow_subgroup(5)
+    assert S.order() == 25
+
+    # the length of the lower central series
+    # of a p-Sylow subgroup of Sym(n) grows with
+    # the highest exponent exp of p such
+    # that n >= p**exp
+    exp = 1
+    length = 0
+    for i in range(2, 9):
+        P = SymmetricGroup(i)
+        S = P.sylow_subgroup(2)
+        ls = S.lower_central_series()
+        if i // 2**exp > 0:
+            # length increases with exponent
+            assert len(ls) > length
+            length = len(ls)
+            exp += 1
+        else:
+            assert len(ls) == length
+
+    G = SymmetricGroup(100)
+    S = G.sylow_subgroup(3)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 3 > 0
+
+    G = AlternatingGroup(100)
+    S = G.sylow_subgroup(2)
+    assert G.order() % S.order() == 0
+    assert G.order()/S.order() % 2 > 0
+
+    G = DihedralGroup(18)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+    G = DihedralGroup(50)
+    S = G.sylow_subgroup(p=2)
+    assert S.order() == 4
+
+
+@slow
+def test_presentation():
+    def _test(P):
+        G = P.presentation()
+        return G.order() == P.order()
+
+    def _strong_test(P):
+        G = P.strong_presentation()
+        chk = len(G.generators) == len(P.strong_gens)
+        return chk and G.order() == P.order()
+
+    P = PermutationGroup(Permutation(0,1,5,2)(3,7,4,6), Permutation(0,3,5,4)(1,6,2,7))
+    assert _test(P)
+
+    P = AlternatingGroup(5)
+    assert _test(P)
+
+    P = SymmetricGroup(5)
+    assert _test(P)
+
+    P = PermutationGroup(
+        [Permutation(0,3,1,2), Permutation(3)(0,1), Permutation(0,1)(2,3)])
+    assert _strong_test(P)
+
+    P = DihedralGroup(6)
+    assert _strong_test(P)
+
+    a = Permutation(0,1)(2,3)
+    b = Permutation(0,2)(3,1)
+    c = Permutation(4,5)
+    P = PermutationGroup(c, a, b)
+    assert _strong_test(P)
+
+
+def test_polycyclic():
+    a = Permutation([0, 1, 2])
+    b = Permutation([2, 1, 0])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is True
+
+    a = Permutation([1, 2, 3, 4, 0])
+    b = Permutation([1, 0, 2, 3, 4])
+    G = PermutationGroup([a, b])
+    assert G.is_polycyclic is False
+
+
+def test_elementary():
+    a = Permutation([1, 5, 2, 0, 3, 6, 4])
+    G = PermutationGroup([a])
+    assert G.is_elementary(7) is False
+
+    a = Permutation(0, 1)(2, 3)
+    b = Permutation(0, 2)(3, 1)
+    G = PermutationGroup([a, b])
+    assert G.is_elementary(2) is True
+    c = Permutation(4, 5, 6)
+    G = PermutationGroup([a, b, c])
+    assert G.is_elementary(2) is False
+
+    G = SymmetricGroup(4).sylow_subgroup(2)
+    assert G.is_elementary(2) is False
+    H = AlternatingGroup(4).sylow_subgroup(2)
+    assert H.is_elementary(2) is True
+
+
+def test_perfect():
+    G = AlternatingGroup(3)
+    assert G.is_perfect is False
+    G = AlternatingGroup(5)
+    assert G.is_perfect is True
+
+
+def test_index():
+    G = PermutationGroup(Permutation(0,1,2), Permutation(0,2,3))
+    H = G.subgroup([Permutation(0,1,3)])
+    assert G.index(H) == 4
+
+
+def test_cyclic():
+    G = SymmetricGroup(2)
+    assert G.is_cyclic
+    G = AbelianGroup(3, 7)
+    assert G.is_cyclic
+    G = AbelianGroup(7, 7)
+    assert not G.is_cyclic
+    G = AlternatingGroup(3)
+    assert G.is_cyclic
+    G = AlternatingGroup(4)
+    assert not G.is_cyclic
+
+    # Order less than 6
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 1))
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3)
+    )
+    assert G.is_cyclic
+    G = PermutationGroup(
+        Permutation(3),
+        Permutation(0, 1)(2, 3),
+        Permutation(0, 2)(1, 3),
+        Permutation(0, 3)(1, 2)
+    )
+    assert G.is_cyclic is False
+
+    # Order 15
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14),
+        Permutation(0, 2, 4, 6, 8, 10, 12, 14, 1, 3, 5, 7, 9, 11, 13)
+    )
+    assert G.is_cyclic
+
+    # Distinct prime orders
+    assert PermutationGroup._distinct_primes_lemma([3, 5]) is True
+    assert PermutationGroup._distinct_primes_lemma([5, 7]) is True
+    assert PermutationGroup._distinct_primes_lemma([2, 3]) is None
+    assert PermutationGroup._distinct_primes_lemma([3, 5, 7]) is None
+    assert PermutationGroup._distinct_primes_lemma([5, 7, 13]) is True
+
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(0, 2)(1, 3))
+    assert G.is_cyclic
+    assert G._is_abelian
+
+    # Non-abelian and therefore not cyclic
+    G = PermutationGroup(*SymmetricGroup(3).generators)
+    assert G.is_cyclic is False
+
+    # Abelian and cyclic
+    G = PermutationGroup(
+        Permutation(0, 1, 2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic
+
+    # Abelian but not cyclic
+    G = PermutationGroup(
+        Permutation(0, 1),
+        Permutation(2, 3),
+        Permutation(4, 5, 6)
+    )
+    assert G.is_cyclic is False
+
+
+def test_dihedral():
+    G = SymmetricGroup(2)
+    assert G.is_dihedral
+    G = SymmetricGroup(3)
+    assert G.is_dihedral
+
+    G = AbelianGroup(2, 2)
+    assert G.is_dihedral
+    G = CyclicGroup(4)
+    assert not G.is_dihedral
+
+    G = AbelianGroup(3, 5)
+    assert not G.is_dihedral
+    G = AbelianGroup(2)
+    assert G.is_dihedral
+    G = AbelianGroup(6)
+    assert not G.is_dihedral
+
+    # D6, generated by two adjacent flips
+    G = PermutationGroup(
+        Permutation(1, 5)(2, 4),
+        Permutation(0, 1)(3, 4)(2, 5))
+    assert G.is_dihedral
+
+    # D7, generated by a flip and a rotation
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+    # S4, presented by three generators, fails due to having exactly 9
+    # elements of order 2:
+    G = PermutationGroup(
+        Permutation(0, 1), Permutation(0, 2),
+        Permutation(0, 3))
+    assert not G.is_dihedral
+
+    # D7, given by three generators
+    G = PermutationGroup(
+        Permutation(1, 6)(2, 5)(3, 4),
+        Permutation(2, 0)(3, 6)(4, 5),
+        Permutation(0, 1, 2, 3, 4, 5, 6))
+    assert G.is_dihedral
+
+
+def test_abelian_invariants():
+    G = AbelianGroup(2, 3, 4)
+    assert G.abelian_invariants() == [2, 3, 4]
+    G=PermutationGroup([Permutation(1, 2, 3, 4), Permutation(1, 2), Permutation(5, 6)])
+    assert G.abelian_invariants() == [2, 2]
+    G = AlternatingGroup(7)
+    assert G.abelian_invariants() == []
+    G = AlternatingGroup(4)
+    assert G.abelian_invariants() == [3]
+    G = DihedralGroup(4)
+    assert G.abelian_invariants() == [2, 2]
+
+    G = PermutationGroup([Permutation(1, 2, 3, 4, 5, 6, 7)])
+    assert G.abelian_invariants() == [7]
+    G = DihedralGroup(12)
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3]
+    G = PermutationGroup(Permutation(0, 1, 2), Permutation(0, 2, 3))
+    assert G.abelian_invariants() == [3]
+    G = PermutationGroup([Permutation(0, 1), Permutation(0, 2, 4, 6)(1, 3, 5, 7)])
+    assert G.abelian_invariants() == [2, 4]
+    G = SymmetricGroup(30)
+    S = G.sylow_subgroup(2)
+    assert S.abelian_invariants() == [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
+    S = G.sylow_subgroup(3)
+    assert S.abelian_invariants() == [3, 3, 3, 3]
+    S = G.sylow_subgroup(5)
+    assert S.abelian_invariants() == [5, 5, 5]
+
+
+def test_composition_series():
+    a = Permutation(1, 2, 3)
+    b = Permutation(1, 2)
+    G = PermutationGroup([a, b])
+    comp_series = G.composition_series()
+    assert comp_series == G.derived_series()
+    # The first group in the composition series is always the group itself and
+    # the last group in the series is the trivial group.
+    S = SymmetricGroup(4)
+    assert S.composition_series()[0] == S
+    assert len(S.composition_series()) == 5
+    A = AlternatingGroup(4)
+    assert A.composition_series()[0] == A
+    assert len(A.composition_series()) == 4
+
+    # the composition series for C_8 is C_8 > C_4 > C_2 > triv
+    G = CyclicGroup(8)
+    series = G.composition_series()
+    assert is_isomorphic(series[1], CyclicGroup(4))
+    assert is_isomorphic(series[2], CyclicGroup(2))
+    assert series[3].is_trivial
+
+
+def test_is_symmetric():
+    a = Permutation(0, 1, 2)
+    b = Permutation(0, 1, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 2, 1)
+    b = Permutation(1, 2, size=3)
+    assert PermutationGroup(a, b).is_symmetric is True
+
+    a = Permutation(0, 1, 2, 3)
+    b = Permutation(0, 3)(1, 2)
+    assert PermutationGroup(a, b).is_symmetric is False
+
+def test_conjugacy_class():
+    S = SymmetricGroup(4)
+    x = Permutation(1, 2, 3)
+    C = {Permutation(0, 1, 2, size = 4), Permutation(0, 1, 3),
+             Permutation(0, 2, 1, size = 4), Permutation(0, 2, 3),
+             Permutation(0, 3, 1), Permutation(0, 3, 2),
+             Permutation(1, 2, 3), Permutation(1, 3, 2)}
+    assert S.conjugacy_class(x) == C
+
+def test_conjugacy_classes():
+    S = SymmetricGroup(3)
+    expected = [{Permutation(size = 3)},
+         {Permutation(0, 1, size = 3), Permutation(0, 2), Permutation(1, 2)},
+         {Permutation(0, 1, 2), Permutation(0, 2, 1)}]
+    computed = S.conjugacy_classes()
+
+    assert len(expected) == len(computed)
+    assert all(e in computed for e in expected)
+
+def test_coset_class():
+    a = Permutation(1, 2)
+    b = Permutation(0, 1)
+    G = PermutationGroup([a, b])
+    #Creating right coset
+    rht_coset = G*a
+    #Checking whether it is left coset or right coset
+    assert rht_coset.is_right_coset
+    assert not rht_coset.is_left_coset
+    #Creating list representation of coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(0, 2), Permutation(0, 2, 1), Permutation(1, 2),
+                Permutation(2), Permutation(2)(0, 1), Permutation(0, 1, 2)]
+    for ele in list_repr:
+        assert ele in expected
+    #Creating left coset
+    left_coset = a*G
+    #Checking whether it is left coset or right coset
+    assert not left_coset.is_right_coset
+    assert left_coset.is_left_coset
+    #Creating list representation of Coset
+    list_repr = left_coset.as_list()
+    expected = [Permutation(2)(0, 1), Permutation(0, 1, 2), Permutation(1, 2),
+    Permutation(2), Permutation(0, 2), Permutation(0, 2, 1)]
+    for ele in list_repr:
+        assert ele in expected
+
+    G = PermutationGroup(Permutation(1, 2, 3, 4), Permutation(2, 3, 4))
+    H = PermutationGroup(Permutation(1, 2, 3, 4))
+    g = Permutation(1, 3)(2, 4)
+    rht_coset = Coset(g, H, G, dir='+')
+    assert rht_coset.is_right_coset
+    list_repr = rht_coset.as_list()
+    expected = [Permutation(1, 2, 3, 4), Permutation(4), Permutation(1, 3)(2, 4),
+    Permutation(1, 4, 3, 2)]
+    for ele in list_repr:
+        assert ele in expected
+
+def test_symmetricpermutationgroup():
+    a = SymmetricPermutationGroup(5)
+    assert a.degree == 5
+    assert a.order() == 120
+    assert a.identity() == Permutation(4)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_permutations.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_permutations.py
new file mode 100644
index 0000000000000000000000000000000000000000..b52fcfec0e2fb3be872efaa814077760e121c748
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_permutations.py
@@ -0,0 +1,564 @@
+from itertools import permutations
+from copy import copy
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import Integer
+from sympy.core.relational import Eq
+from sympy.core.symbol import Symbol
+from sympy.core.singleton import S
+from sympy.combinatorics.permutations import \
+    Permutation, _af_parity, _af_rmul, _af_rmuln, AppliedPermutation, Cycle
+from sympy.printing import sstr, srepr, pretty, latex
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+
+
+rmul = Permutation.rmul
+a = Symbol('a', integer=True)
+
+
+def test_Permutation():
+    # don't auto fill 0
+    raises(ValueError, lambda: Permutation([1]))
+    p = Permutation([0, 1, 2, 3])
+    # call as bijective
+    assert [p(i) for i in range(p.size)] == list(p)
+    # call as operator
+    assert p(list(range(p.size))) == list(p)
+    # call as function
+    assert list(p(1, 2)) == [0, 2, 1, 3]
+    raises(TypeError, lambda: p(-1))
+    raises(TypeError, lambda: p(5))
+    # conversion to list
+    assert list(p) == list(range(4))
+    assert p.copy() == p
+    assert copy(p) == p
+    assert Permutation(size=4) == Permutation(3)
+    assert Permutation(Permutation(3), size=5) == Permutation(4)
+    # cycle form with size
+    assert Permutation([[1, 2]], size=4) == Permutation([[1, 2], [0], [3]])
+    # random generation
+    assert Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
+
+    p = Permutation([2, 5, 1, 6, 3, 0, 4])
+    q = Permutation([[1], [0, 3, 5, 6, 2, 4]])
+    assert len({p, p}) == 1
+    r = Permutation([1, 3, 2, 0, 4, 6, 5])
+    ans = Permutation(_af_rmuln(*[w.array_form for w in (p, q, r)])).array_form
+    assert rmul(p, q, r).array_form == ans
+    # make sure no other permutation of p, q, r could have given
+    # that answer
+    for a, b, c in permutations((p, q, r)):
+        if (a, b, c) == (p, q, r):
+            continue
+        assert rmul(a, b, c).array_form != ans
+
+    assert p.support() == list(range(7))
+    assert q.support() == [0, 2, 3, 4, 5, 6]
+    assert Permutation(p.cyclic_form).array_form == p.array_form
+    assert p.cardinality == 5040
+    assert q.cardinality == 5040
+    assert q.cycles == 2
+    assert rmul(q, p) == Permutation([4, 6, 1, 2, 5, 3, 0])
+    assert rmul(p, q) == Permutation([6, 5, 3, 0, 2, 4, 1])
+    assert _af_rmul(p.array_form, q.array_form) == \
+        [6, 5, 3, 0, 2, 4, 1]
+
+    assert rmul(Permutation([[1, 2, 3], [0, 4]]),
+                Permutation([[1, 2, 4], [0], [3]])).cyclic_form == \
+        [[0, 4, 2], [1, 3]]
+    assert q.array_form == [3, 1, 4, 5, 0, 6, 2]
+    assert q.cyclic_form == [[0, 3, 5, 6, 2, 4]]
+    assert q.full_cyclic_form == [[0, 3, 5, 6, 2, 4], [1]]
+    assert p.cyclic_form == [[0, 2, 1, 5], [3, 6, 4]]
+    t = p.transpositions()
+    assert t == [(0, 5), (0, 1), (0, 2), (3, 4), (3, 6)]
+    assert Permutation.rmul(*[Permutation(Cycle(*ti)) for ti in (t)])
+    assert Permutation([1, 0]).transpositions() == [(0, 1)]
+
+    assert p**13 == p
+    assert q**0 == Permutation(list(range(q.size)))
+    assert q**-2 == ~q**2
+    assert q**2 == Permutation([5, 1, 0, 6, 3, 2, 4])
+    assert q**3 == q**2*q
+    assert q**4 == q**2*q**2
+
+    a = Permutation(1, 3)
+    b = Permutation(2, 0, 3)
+    I = Permutation(3)
+    assert ~a == a**-1
+    assert a*~a == I
+    assert a*b**-1 == a*~b
+
+    ans = Permutation(0, 5, 3, 1, 6)(2, 4)
+    assert (p + q.rank()).rank() == ans.rank()
+    assert (p + q.rank())._rank == ans.rank()
+    assert (q + p.rank()).rank() == ans.rank()
+    raises(TypeError, lambda: p + Permutation(list(range(10))))
+
+    assert (p - q.rank()).rank() == Permutation(0, 6, 3, 1, 2, 5, 4).rank()
+    assert p.rank() - q.rank() < 0  # for coverage: make sure mod is used
+    assert (q - p.rank()).rank() == Permutation(1, 4, 6, 2)(3, 5).rank()
+
+    assert p*q == Permutation(_af_rmuln(*[list(w) for w in (q, p)]))
+    assert p*Permutation([]) == p
+    assert Permutation([])*p == p
+    assert p*Permutation([[0, 1]]) == Permutation([2, 5, 0, 6, 3, 1, 4])
+    assert Permutation([[0, 1]])*p == Permutation([5, 2, 1, 6, 3, 0, 4])
+
+    pq = p ^ q
+    assert pq == Permutation([5, 6, 0, 4, 1, 2, 3])
+    assert pq == rmul(q, p, ~q)
+    qp = q ^ p
+    assert qp == Permutation([4, 3, 6, 2, 1, 5, 0])
+    assert qp == rmul(p, q, ~p)
+    raises(ValueError, lambda: p ^ Permutation([]))
+
+    assert p.commutator(q) == Permutation(0, 1, 3, 4, 6, 5, 2)
+    assert q.commutator(p) == Permutation(0, 2, 5, 6, 4, 3, 1)
+    assert p.commutator(q) == ~q.commutator(p)
+    raises(ValueError, lambda: p.commutator(Permutation([])))
+
+    assert len(p.atoms()) == 7
+    assert q.atoms() == {0, 1, 2, 3, 4, 5, 6}
+
+    assert p.inversion_vector() == [2, 4, 1, 3, 1, 0]
+    assert q.inversion_vector() == [3, 1, 2, 2, 0, 1]
+
+    assert Permutation.from_inversion_vector(p.inversion_vector()) == p
+    assert Permutation.from_inversion_vector(q.inversion_vector()).array_form\
+        == q.array_form
+    raises(ValueError, lambda: Permutation.from_inversion_vector([0, 2]))
+    assert Permutation(list(range(500, -1, -1))).inversions() == 125250
+
+    s = Permutation([0, 4, 1, 3, 2])
+    assert s.parity() == 0
+    _ = s.cyclic_form  # needed to create a value for _cyclic_form
+    assert len(s._cyclic_form) != s.size and s.parity() == 0
+    assert not s.is_odd
+    assert s.is_even
+    assert Permutation([0, 1, 4, 3, 2]).parity() == 1
+    assert _af_parity([0, 4, 1, 3, 2]) == 0
+    assert _af_parity([0, 1, 4, 3, 2]) == 1
+
+    s = Permutation([0])
+
+    assert s.is_Singleton
+    assert Permutation([]).is_Empty
+
+    r = Permutation([3, 2, 1, 0])
+    assert (r**2).is_Identity
+
+    assert rmul(~p, p).is_Identity
+    assert (~p)**13 == Permutation([5, 2, 0, 4, 6, 1, 3])
+    assert p.max() == 6
+    assert p.min() == 0
+
+    q = Permutation([[6], [5], [0, 1, 2, 3, 4]])
+
+    assert q.max() == 4
+    assert q.min() == 0
+
+    p = Permutation([1, 5, 2, 0, 3, 6, 4])
+    q = Permutation([[1, 2, 3, 5, 6], [0, 4]])
+
+    assert p.ascents() == [0, 3, 4]
+    assert q.ascents() == [1, 2, 4]
+    assert r.ascents() == []
+
+    assert p.descents() == [1, 2, 5]
+    assert q.descents() == [0, 3, 5]
+    assert Permutation(r.descents()).is_Identity
+
+    assert p.inversions() == 7
+    # test the merge-sort with a longer permutation
+    big = list(p) + list(range(p.max() + 1, p.max() + 130))
+    assert Permutation(big).inversions() == 7
+    assert p.signature() == -1
+    assert q.inversions() == 11
+    assert q.signature() == -1
+    assert rmul(p, ~p).inversions() == 0
+    assert rmul(p, ~p).signature() == 1
+
+    assert p.order() == 6
+    assert q.order() == 10
+    assert (p**(p.order())).is_Identity
+
+    assert p.length() == 6
+    assert q.length() == 7
+    assert r.length() == 4
+
+    assert p.runs() == [[1, 5], [2], [0, 3, 6], [4]]
+    assert q.runs() == [[4], [2, 3, 5], [0, 6], [1]]
+    assert r.runs() == [[3], [2], [1], [0]]
+
+    assert p.index() == 8
+    assert q.index() == 8
+    assert r.index() == 3
+
+    assert p.get_precedence_distance(q) == q.get_precedence_distance(p)
+    assert p.get_adjacency_distance(q) == p.get_adjacency_distance(q)
+    assert p.get_positional_distance(q) == p.get_positional_distance(q)
+    p = Permutation([0, 1, 2, 3])
+    q = Permutation([3, 2, 1, 0])
+    assert p.get_precedence_distance(q) == 6
+    assert p.get_adjacency_distance(q) == 3
+    assert p.get_positional_distance(q) == 8
+    p = Permutation([0, 3, 1, 2, 4])
+    q = Permutation.josephus(4, 5, 2)
+    assert p.get_adjacency_distance(q) == 3
+    raises(ValueError, lambda: p.get_adjacency_distance(Permutation([])))
+    raises(ValueError, lambda: p.get_positional_distance(Permutation([])))
+    raises(ValueError, lambda: p.get_precedence_distance(Permutation([])))
+
+    a = [Permutation.unrank_nonlex(4, i) for i in range(5)]
+    iden = Permutation([0, 1, 2, 3])
+    for i in range(5):
+        for j in range(i + 1, 5):
+            assert a[i].commutes_with(a[j]) == \
+                (rmul(a[i], a[j]) == rmul(a[j], a[i]))
+            if a[i].commutes_with(a[j]):
+                assert a[i].commutator(a[j]) == iden
+                assert a[j].commutator(a[i]) == iden
+
+    a = Permutation(3)
+    b = Permutation(0, 6, 3)(1, 2)
+    assert a.cycle_structure == {1: 4}
+    assert b.cycle_structure == {2: 1, 3: 1, 1: 2}
+    # issue 11130
+    raises(ValueError, lambda: Permutation(3, size=3))
+    raises(ValueError, lambda: Permutation([1, 2, 0, 3], size=3))
+
+
+def test_Permutation_subclassing():
+    # Subclass that adds permutation application on iterables
+    class CustomPermutation(Permutation):
+        def __call__(self, *i):
+            try:
+                return super().__call__(*i)
+            except TypeError:
+                pass
+
+            try:
+                perm_obj = i[0]
+                return [self._array_form[j] for j in perm_obj]
+            except TypeError:
+                raise TypeError('unrecognized argument')
+
+        def __eq__(self, other):
+            if isinstance(other, Permutation):
+                return self._hashable_content() == other._hashable_content()
+            else:
+                return super().__eq__(other)
+
+        def __hash__(self):
+            return super().__hash__()
+
+    p = CustomPermutation([1, 2, 3, 0])
+    q = Permutation([1, 2, 3, 0])
+
+    assert p == q
+    raises(TypeError, lambda: q([1, 2]))
+    assert [2, 3] == p([1, 2])
+
+    assert type(p * q) == CustomPermutation
+    assert type(q * p) == Permutation  # True because q.__mul__(p) is called!
+
+    # Run all tests for the Permutation class also on the subclass
+    def wrapped_test_Permutation():
+        # Monkeypatch the class definition in the globals
+        globals()['__Perm'] = globals()['Permutation']
+        globals()['Permutation'] = CustomPermutation
+        test_Permutation()
+        globals()['Permutation'] = globals()['__Perm']  # Restore
+        del globals()['__Perm']
+
+    wrapped_test_Permutation()
+
+
+def test_josephus():
+    assert Permutation.josephus(4, 6, 1) == Permutation([3, 1, 0, 2, 5, 4])
+    assert Permutation.josephus(1, 5, 1).is_Identity
+
+
+def test_ranking():
+    assert Permutation.unrank_lex(5, 10).rank() == 10
+    p = Permutation.unrank_lex(15, 225)
+    assert p.rank() == 225
+    p1 = p.next_lex()
+    assert p1.rank() == 226
+    assert Permutation.unrank_lex(15, 225).rank() == 225
+    assert Permutation.unrank_lex(10, 0).is_Identity
+    p = Permutation.unrank_lex(4, 23)
+    assert p.rank() == 23
+    assert p.array_form == [3, 2, 1, 0]
+    assert p.next_lex() is None
+
+    p = Permutation([1, 5, 2, 0, 3, 6, 4])
+    q = Permutation([[1, 2, 3, 5, 6], [0, 4]])
+    a = [Permutation.unrank_trotterjohnson(4, i).array_form for i in range(5)]
+    assert a == [[0, 1, 2, 3], [0, 1, 3, 2], [0, 3, 1, 2], [3, 0, 1,
+        2], [3, 0, 2, 1] ]
+    assert [Permutation(pa).rank_trotterjohnson() for pa in a] == list(range(5))
+    assert Permutation([0, 1, 2, 3]).next_trotterjohnson() == \
+        Permutation([0, 1, 3, 2])
+
+    assert q.rank_trotterjohnson() == 2283
+    assert p.rank_trotterjohnson() == 3389
+    assert Permutation([1, 0]).rank_trotterjohnson() == 1
+    a = Permutation(list(range(3)))
+    b = a
+    l = []
+    tj = []
+    for i in range(6):
+        l.append(a)
+        tj.append(b)
+        a = a.next_lex()
+        b = b.next_trotterjohnson()
+    assert a == b is None
+    assert {tuple(a) for a in l} == {tuple(a) for a in tj}
+
+    p = Permutation([2, 5, 1, 6, 3, 0, 4])
+    q = Permutation([[6], [5], [0, 1, 2, 3, 4]])
+    assert p.rank() == 1964
+    assert q.rank() == 870
+    assert Permutation([]).rank_nonlex() == 0
+    prank = p.rank_nonlex()
+    assert prank == 1600
+    assert Permutation.unrank_nonlex(7, 1600) == p
+    qrank = q.rank_nonlex()
+    assert qrank == 41
+    assert Permutation.unrank_nonlex(7, 41) == Permutation(q.array_form)
+
+    a = [Permutation.unrank_nonlex(4, i).array_form for i in range(24)]
+    assert a == [
+        [1, 2, 3, 0], [3, 2, 0, 1], [1, 3, 0, 2], [1, 2, 0, 3], [2, 3, 1, 0],
+        [2, 0, 3, 1], [3, 0, 1, 2], [2, 0, 1, 3], [1, 3, 2, 0], [3, 0, 2, 1],
+        [1, 0, 3, 2], [1, 0, 2, 3], [2, 1, 3, 0], [2, 3, 0, 1], [3, 1, 0, 2],
+        [2, 1, 0, 3], [3, 2, 1, 0], [0, 2, 3, 1], [0, 3, 1, 2], [0, 2, 1, 3],
+        [3, 1, 2, 0], [0, 3, 2, 1], [0, 1, 3, 2], [0, 1, 2, 3]]
+
+    N = 10
+    p1 = Permutation(a[0])
+    for i in range(1, N+1):
+        p1 = p1*Permutation(a[i])
+    p2 = Permutation.rmul_with_af(*[Permutation(h) for h in a[N::-1]])
+    assert p1 == p2
+
+    ok = []
+    p = Permutation([1, 0])
+    for i in range(3):
+        ok.append(p.array_form)
+        p = p.next_nonlex()
+        if p is None:
+            ok.append(None)
+            break
+    assert ok == [[1, 0], [0, 1], None]
+    assert Permutation([3, 2, 0, 1]).next_nonlex() == Permutation([1, 3, 0, 2])
+    assert [Permutation(pa).rank_nonlex() for pa in a] == list(range(24))
+
+
+def test_mul():
+    a, b = [0, 2, 1, 3], [0, 1, 3, 2]
+    assert _af_rmul(a, b) == [0, 2, 3, 1]
+    assert _af_rmuln(a, b, list(range(4))) == [0, 2, 3, 1]
+    assert rmul(Permutation(a), Permutation(b)).array_form == [0, 2, 3, 1]
+
+    a = Permutation([0, 2, 1, 3])
+    b = (0, 1, 3, 2)
+    c = (3, 1, 2, 0)
+    assert Permutation.rmul(a, b, c) == Permutation([1, 2, 3, 0])
+    assert Permutation.rmul(a, c) == Permutation([3, 2, 1, 0])
+    raises(TypeError, lambda: Permutation.rmul(b, c))
+
+    n = 6
+    m = 8
+    a = [Permutation.unrank_nonlex(n, i).array_form for i in range(m)]
+    h = list(range(n))
+    for i in range(m):
+        h = _af_rmul(h, a[i])
+        h2 = _af_rmuln(*a[:i + 1])
+        assert h == h2
+
+
+def test_args():
+    p = Permutation([(0, 3, 1, 2), (4, 5)])
+    assert p._cyclic_form is None
+    assert Permutation(p) == p
+    assert p.cyclic_form == [[0, 3, 1, 2], [4, 5]]
+    assert p._array_form == [3, 2, 0, 1, 5, 4]
+    p = Permutation((0, 3, 1, 2))
+    assert p._cyclic_form is None
+    assert p._array_form == [0, 3, 1, 2]
+    assert Permutation([0]) == Permutation((0, ))
+    assert Permutation([[0], [1]]) == Permutation(((0, ), (1, ))) == \
+        Permutation(((0, ), [1]))
+    assert Permutation([[1, 2]]) == Permutation([0, 2, 1])
+    assert Permutation([[1], [4, 2]]) == Permutation([0, 1, 4, 3, 2])
+    assert Permutation([[1], [4, 2]], size=1) == Permutation([0, 1, 4, 3, 2])
+    assert Permutation(
+        [[1], [4, 2]], size=6) == Permutation([0, 1, 4, 3, 2, 5])
+    assert Permutation([[0, 1], [0, 2]]) == Permutation(0, 1, 2)
+    assert Permutation([], size=3) == Permutation([0, 1, 2])
+    assert Permutation(3).list(5) == [0, 1, 2, 3, 4]
+    assert Permutation(3).list(-1) == []
+    assert Permutation(5)(1, 2).list(-1) == [0, 2, 1]
+    assert Permutation(5)(1, 2).list() == [0, 2, 1, 3, 4, 5]
+    raises(ValueError, lambda: Permutation([1, 2], [0]))
+           # enclosing brackets needed
+    raises(ValueError, lambda: Permutation([[1, 2], 0]))
+           # enclosing brackets needed on 0
+    raises(ValueError, lambda: Permutation([1, 1, 0]))
+    raises(ValueError, lambda: Permutation([4, 5], size=10))  # where are 0-3?
+    # but this is ok because cycles imply that only those listed moved
+    assert Permutation(4, 5) == Permutation([0, 1, 2, 3, 5, 4])
+
+
+def test_Cycle():
+    assert str(Cycle()) == '()'
+    assert Cycle(Cycle(1,2)) == Cycle(1, 2)
+    assert Cycle(1,2).copy() == Cycle(1,2)
+    assert list(Cycle(1, 3, 2)) == [0, 3, 1, 2]
+    assert Cycle(1, 2)(2, 3) == Cycle(1, 3, 2)
+    assert Cycle(1, 2)(2, 3)(4, 5) == Cycle(1, 3, 2)(4, 5)
+    assert Permutation(Cycle(1, 2)(2, 1, 0, 3)).cyclic_form, Cycle(0, 2, 1)
+    raises(ValueError, lambda: Cycle().list())
+    assert Cycle(1, 2).list() == [0, 2, 1]
+    assert Cycle(1, 2).list(4) == [0, 2, 1, 3]
+    assert Cycle(3).list(2) == [0, 1]
+    assert Cycle(3).list(6) == [0, 1, 2, 3, 4, 5]
+    assert Permutation(Cycle(1, 2), size=4) == \
+        Permutation([0, 2, 1, 3])
+    assert str(Cycle(1, 2)(4, 5)) == '(1 2)(4 5)'
+    assert str(Cycle(1, 2)) == '(1 2)'
+    assert Cycle(Permutation(list(range(3)))) == Cycle()
+    assert Cycle(1, 2).list() == [0, 2, 1]
+    assert Cycle(1, 2).list(4) == [0, 2, 1, 3]
+    assert Cycle().size == 0
+    raises(ValueError, lambda: Cycle((1, 2)))
+    raises(ValueError, lambda: Cycle(1, 2, 1))
+    raises(TypeError, lambda: Cycle(1, 2)*{})
+    raises(ValueError, lambda: Cycle(4)[a])
+    raises(ValueError, lambda: Cycle(2, -4, 3))
+
+    # check round-trip
+    p = Permutation([[1, 2], [4, 3]], size=5)
+    assert Permutation(Cycle(p)) == p
+
+
+def test_from_sequence():
+    assert Permutation.from_sequence('SymPy') == Permutation(4)(0, 1, 3)
+    assert Permutation.from_sequence('SymPy', key=lambda x: x.lower()) == \
+        Permutation(4)(0, 2)(1, 3)
+
+
+def test_resize():
+    p = Permutation(0, 1, 2)
+    assert p.resize(5) == Permutation(0, 1, 2, size=5)
+    assert p.resize(4) == Permutation(0, 1, 2, size=4)
+    assert p.resize(3) == p
+    raises(ValueError, lambda: p.resize(2))
+
+    p = Permutation(0, 1, 2)(3, 4)(5, 6)
+    assert p.resize(3) == Permutation(0, 1, 2)
+    raises(ValueError, lambda: p.resize(4))
+
+
+def test_printing_cyclic():
+    p1 = Permutation([0, 2, 1])
+    assert repr(p1) == 'Permutation(1, 2)'
+    assert str(p1) == '(1 2)'
+    p2 = Permutation()
+    assert repr(p2) == 'Permutation()'
+    assert str(p2) == '()'
+    p3 = Permutation([1, 2, 0, 3])
+    assert repr(p3) == 'Permutation(3)(0, 1, 2)'
+
+
+def test_printing_non_cyclic():
+    p1 = Permutation([0, 1, 2, 3, 4, 5])
+    assert srepr(p1, perm_cyclic=False) == 'Permutation([], size=6)'
+    assert sstr(p1, perm_cyclic=False) == 'Permutation([], size=6)'
+    p2 = Permutation([0, 1, 2])
+    assert srepr(p2, perm_cyclic=False) == 'Permutation([0, 1, 2])'
+    assert sstr(p2, perm_cyclic=False) == 'Permutation([0, 1, 2])'
+
+    p3 = Permutation([0, 2, 1])
+    assert srepr(p3, perm_cyclic=False) == 'Permutation([0, 2, 1])'
+    assert sstr(p3, perm_cyclic=False) == 'Permutation([0, 2, 1])'
+    p4 = Permutation([0, 1, 3, 2, 4, 5, 6, 7])
+    assert srepr(p4, perm_cyclic=False) == 'Permutation([0, 1, 3, 2], size=8)'
+
+
+def test_deprecated_print_cyclic():
+    p = Permutation(0, 1, 2)
+    try:
+        Permutation.print_cyclic = True
+        with warns_deprecated_sympy():
+            assert sstr(p) == '(0 1 2)'
+        with warns_deprecated_sympy():
+            assert srepr(p) == 'Permutation(0, 1, 2)'
+        with warns_deprecated_sympy():
+            assert pretty(p) == '(0 1 2)'
+        with warns_deprecated_sympy():
+            assert latex(p) == r'\left( 0\; 1\; 2\right)'
+
+        Permutation.print_cyclic = False
+        with warns_deprecated_sympy():
+            assert sstr(p) == 'Permutation([1, 2, 0])'
+        with warns_deprecated_sympy():
+            assert srepr(p) == 'Permutation([1, 2, 0])'
+        with warns_deprecated_sympy():
+            assert pretty(p, use_unicode=False) == '/0 1 2\\\n\\1 2 0/'
+        with warns_deprecated_sympy():
+            assert latex(p) == \
+                r'\begin{pmatrix} 0 & 1 & 2 \\ 1 & 2 & 0 \end{pmatrix}'
+    finally:
+        Permutation.print_cyclic = None
+
+
+def test_permutation_equality():
+    a = Permutation(0, 1, 2)
+    b = Permutation(0, 1, 2)
+    assert Eq(a, b) is S.true
+    c = Permutation(0, 2, 1)
+    assert Eq(a, c) is S.false
+
+    d = Permutation(0, 1, 2, size=4)
+    assert unchanged(Eq, a, d)
+    e = Permutation(0, 2, 1, size=4)
+    assert unchanged(Eq, a, e)
+
+    i = Permutation()
+    assert unchanged(Eq, i, 0)
+    assert unchanged(Eq, 0, i)
+
+
+def test_issue_17661():
+    c1 = Cycle(1,2)
+    c2 = Cycle(1,2)
+    assert c1 == c2
+    assert repr(c1) == 'Cycle(1, 2)'
+    assert c1 == c2
+
+
+def test_permutation_apply():
+    x = Symbol('x')
+    p = Permutation(0, 1, 2)
+    assert p.apply(0) == 1
+    assert isinstance(p.apply(0), Integer)
+    assert p.apply(x) == AppliedPermutation(p, x)
+    assert AppliedPermutation(p, x).subs(x, 0) == 1
+
+    x = Symbol('x', integer=False)
+    raises(NotImplementedError, lambda: p.apply(x))
+    x = Symbol('x', negative=True)
+    raises(NotImplementedError, lambda: p.apply(x))
+
+
+def test_AppliedPermutation():
+    x = Symbol('x')
+    p = Permutation(0, 1, 2)
+    raises(ValueError, lambda: AppliedPermutation((0, 1, 2), x))
+    assert AppliedPermutation(p, 1, evaluate=True) == 2
+    assert AppliedPermutation(p, 1, evaluate=False).__class__ == \
+        AppliedPermutation
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_polyhedron.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_polyhedron.py
new file mode 100644
index 0000000000000000000000000000000000000000..abf469bb560eef1f378eff4740a84b80b696035f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_polyhedron.py
@@ -0,0 +1,105 @@
+from sympy.core.symbol import symbols
+from sympy.sets.sets import FiniteSet
+from sympy.combinatorics.polyhedron import (Polyhedron,
+    tetrahedron, cube as square, octahedron, dodecahedron, icosahedron,
+    cube_faces)
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.testing.pytest import raises
+
+rmul = Permutation.rmul
+
+
+def test_polyhedron():
+    raises(ValueError, lambda: Polyhedron(list('ab'),
+        pgroup=[Permutation([0])]))
+    pgroup = [Permutation([[0, 7, 2, 5], [6, 1, 4, 3]]),
+              Permutation([[0, 7, 1, 6], [5, 2, 4, 3]]),
+              Permutation([[3, 6, 0, 5], [4, 1, 7, 2]]),
+              Permutation([[7, 4, 5], [1, 3, 0], [2], [6]]),
+              Permutation([[1, 3, 2], [7, 6, 5], [4], [0]]),
+              Permutation([[4, 7, 6], [2, 0, 3], [1], [5]]),
+              Permutation([[1, 2, 0], [4, 5, 6], [3], [7]]),
+              Permutation([[4, 2], [0, 6], [3, 7], [1, 5]]),
+              Permutation([[3, 5], [7, 1], [2, 6], [0, 4]]),
+              Permutation([[2, 5], [1, 6], [0, 4], [3, 7]]),
+              Permutation([[4, 3], [7, 0], [5, 1], [6, 2]]),
+              Permutation([[4, 1], [0, 5], [6, 2], [7, 3]]),
+              Permutation([[7, 2], [3, 6], [0, 4], [1, 5]]),
+              Permutation([0, 1, 2, 3, 4, 5, 6, 7])]
+    corners = tuple(symbols('A:H'))
+    faces = cube_faces
+    cube = Polyhedron(corners, faces, pgroup)
+
+    assert cube.edges == FiniteSet(*(
+        (0, 1), (6, 7), (1, 2), (5, 6), (0, 3), (2, 3),
+        (4, 7), (4, 5), (3, 7), (1, 5), (0, 4), (2, 6)))
+
+    for i in range(3):  # add 180 degree face rotations
+        cube.rotate(cube.pgroup[i]**2)
+
+    assert cube.corners == corners
+
+    for i in range(3, 7):  # add 240 degree axial corner rotations
+        cube.rotate(cube.pgroup[i]**2)
+
+    assert cube.corners == corners
+    cube.rotate(1)
+    raises(ValueError, lambda: cube.rotate(Permutation([0, 1])))
+    assert cube.corners != corners
+    assert cube.array_form == [7, 6, 4, 5, 3, 2, 0, 1]
+    assert cube.cyclic_form == [[0, 7, 1, 6], [2, 4, 3, 5]]
+    cube.reset()
+    assert cube.corners == corners
+
+    def check(h, size, rpt, target):
+
+        assert len(h.faces) + len(h.vertices) - len(h.edges) == 2
+        assert h.size == size
+
+        got = set()
+        for p in h.pgroup:
+            # make sure it restores original
+            P = h.copy()
+            hit = P.corners
+            for i in range(rpt):
+                P.rotate(p)
+                if P.corners == hit:
+                    break
+            else:
+                print('error in permutation', p.array_form)
+            for i in range(rpt):
+                P.rotate(p)
+                got.add(tuple(P.corners))
+                c = P.corners
+                f = [[c[i] for i in f] for f in P.faces]
+                assert h.faces == Polyhedron(c, f).faces
+        assert len(got) == target
+        assert PermutationGroup([Permutation(g) for g in got]).is_group
+
+    for h, size, rpt, target in zip(
+        (tetrahedron, square, octahedron, dodecahedron, icosahedron),
+        (4, 8, 6, 20, 12),
+        (3, 4, 4, 5, 5),
+            (12, 24, 24, 60, 60)):
+        check(h, size, rpt, target)
+
+
+def test_pgroups():
+    from sympy.combinatorics.polyhedron import (cube, tetrahedron_faces,
+            octahedron_faces, dodecahedron_faces, icosahedron_faces)
+    from sympy.combinatorics.polyhedron import _pgroup_calcs
+    (tetrahedron2, cube2, octahedron2, dodecahedron2, icosahedron2,
+     tetrahedron_faces2, cube_faces2, octahedron_faces2,
+     dodecahedron_faces2, icosahedron_faces2) = _pgroup_calcs()
+
+    assert tetrahedron == tetrahedron2
+    assert cube == cube2
+    assert octahedron == octahedron2
+    assert dodecahedron == dodecahedron2
+    assert icosahedron == icosahedron2
+    assert sorted(map(sorted, tetrahedron_faces)) == sorted(map(sorted, tetrahedron_faces2))
+    assert sorted(cube_faces) == sorted(cube_faces2)
+    assert sorted(octahedron_faces) == sorted(octahedron_faces2)
+    assert sorted(dodecahedron_faces) == sorted(dodecahedron_faces2)
+    assert sorted(icosahedron_faces) == sorted(icosahedron_faces2)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_prufer.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_prufer.py
new file mode 100644
index 0000000000000000000000000000000000000000..b077c7cf3f023a4c36d7039505e6165ab29f275a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_prufer.py
@@ -0,0 +1,74 @@
+from sympy.combinatorics.prufer import Prufer
+from sympy.testing.pytest import raises
+
+
+def test_prufer():
+    # number of nodes is optional
+    assert Prufer([[0, 1], [0, 2], [0, 3], [0, 4]], 5).nodes == 5
+    assert Prufer([[0, 1], [0, 2], [0, 3], [0, 4]]).nodes == 5
+
+    a = Prufer([[0, 1], [0, 2], [0, 3], [0, 4]])
+    assert a.rank == 0
+    assert a.nodes == 5
+    assert a.prufer_repr == [0, 0, 0]
+
+    a = Prufer([[2, 4], [1, 4], [1, 3], [0, 5], [0, 4]])
+    assert a.rank == 924
+    assert a.nodes == 6
+    assert a.tree_repr == [[2, 4], [1, 4], [1, 3], [0, 5], [0, 4]]
+    assert a.prufer_repr == [4, 1, 4, 0]
+
+    assert Prufer.edges([0, 1, 2, 3], [1, 4, 5], [1, 4, 6]) == \
+        ([[0, 1], [1, 2], [1, 4], [2, 3], [4, 5], [4, 6]], 7)
+    assert Prufer([0]*4).size == Prufer([6]*4).size == 1296
+
+    # accept iterables but convert to list of lists
+    tree = [(0, 1), (1, 5), (0, 3), (0, 2), (2, 6), (4, 7), (2, 4)]
+    tree_lists = [list(t) for t in tree]
+    assert Prufer(tree).tree_repr == tree_lists
+    assert sorted(Prufer(set(tree)).tree_repr) == sorted(tree_lists)
+
+    raises(ValueError, lambda: Prufer([[1, 2], [3, 4]]))  # 0 is missing
+    raises(ValueError, lambda: Prufer([[2, 3], [3, 4]]))  # 0, 1 are missing
+    assert Prufer(*Prufer.edges([1, 2], [3, 4])).prufer_repr == [1, 3]
+    raises(ValueError, lambda: Prufer.edges(
+        [1, 3], [3, 4]))  # a broken tree but edges doesn't care
+    raises(ValueError, lambda: Prufer.edges([1, 2], [5, 6]))
+    raises(ValueError, lambda: Prufer([[]]))
+
+    a = Prufer([[0, 1], [0, 2], [0, 3]])
+    b = a.next()
+    assert b.tree_repr == [[0, 2], [0, 1], [1, 3]]
+    assert b.rank == 1
+
+
+def test_round_trip():
+    def doit(t, b):
+        e, n = Prufer.edges(*t)
+        t = Prufer(e, n)
+        a = sorted(t.tree_repr)
+        b = [i - 1 for i in b]
+        assert t.prufer_repr == b
+        assert sorted(Prufer(b).tree_repr) == a
+        assert Prufer.unrank(t.rank, n).prufer_repr == b
+
+    doit([[1, 2]], [])
+    doit([[2, 1, 3]], [1])
+    doit([[1, 3, 2]], [3])
+    doit([[1, 2, 3]], [2])
+    doit([[2, 1, 4], [1, 3]], [1, 1])
+    doit([[3, 2, 1, 4]], [2, 1])
+    doit([[3, 2, 1], [2, 4]], [2, 2])
+    doit([[1, 3, 2, 4]], [3, 2])
+    doit([[1, 4, 2, 3]], [4, 2])
+    doit([[3, 1, 4, 2]], [4, 1])
+    doit([[4, 2, 1, 3]], [1, 2])
+    doit([[1, 2, 4, 3]], [2, 4])
+    doit([[1, 3, 4, 2]], [3, 4])
+    doit([[2, 4, 1], [4, 3]], [4, 4])
+    doit([[1, 2, 3, 4]], [2, 3])
+    doit([[2, 3, 1], [3, 4]], [3, 3])
+    doit([[1, 4, 3, 2]], [4, 3])
+    doit([[2, 1, 4, 3]], [1, 4])
+    doit([[2, 1, 3, 4]], [1, 3])
+    doit([[6, 2, 1, 4], [1, 3, 5, 8], [3, 7]], [1, 2, 1, 3, 3, 5])
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_rewriting.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_rewriting.py
new file mode 100644
index 0000000000000000000000000000000000000000..97c562bd57a2cd6318fa1dcb13c6f6278c861cca
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_rewriting.py
@@ -0,0 +1,49 @@
+from sympy.combinatorics.fp_groups import FpGroup
+from sympy.combinatorics.free_groups import free_group
+from sympy.testing.pytest import raises
+
+
+def test_rewriting():
+    F, a, b = free_group("a, b")
+    G = FpGroup(F, [a*b*a**-1*b**-1])
+    a, b = G.generators
+    R = G._rewriting_system
+    assert R.is_confluent
+
+    assert G.reduce(b**-1*a) == a*b**-1
+    assert G.reduce(b**3*a**4*b**-2*a) == a**5*b
+    assert G.equals(b**2*a**-1*b, b**4*a**-1*b**-1)
+
+    assert R.reduce_using_automaton(b*a*a**2*b**-1) == a**3
+    assert R.reduce_using_automaton(b**3*a**4*b**-2*a) == a**5*b
+    assert R.reduce_using_automaton(b**-1*a) == a*b**-1
+
+    G = FpGroup(F, [a**3, b**3, (a*b)**2])
+    R = G._rewriting_system
+    R.make_confluent()
+    # R._is_confluent should be set to True after
+    # a successful run of make_confluent
+    assert R.is_confluent
+    # but also the system should actually be confluent
+    assert R._check_confluence()
+    assert G.reduce(b*a**-1*b**-1*a**3*b**4*a**-1*b**-15) == a**-1*b**-1
+    # check for automaton reduction
+    assert R.reduce_using_automaton(b*a**-1*b**-1*a**3*b**4*a**-1*b**-15) == a**-1*b**-1
+
+    G = FpGroup(F, [a**2, b**3, (a*b)**4])
+    R = G._rewriting_system
+    assert G.reduce(a**2*b**-2*a**2*b) == b**-1
+    assert R.reduce_using_automaton(a**2*b**-2*a**2*b) == b**-1
+    assert G.reduce(a**3*b**-2*a**2*b) == a**-1*b**-1
+    assert R.reduce_using_automaton(a**3*b**-2*a**2*b) == a**-1*b**-1
+    # Check after adding a rule
+    R.add_rule(a**2, b)
+    assert R.reduce_using_automaton(a**2*b**-2*a**2*b) == b**-1
+    assert R.reduce_using_automaton(a**4*b**-2*a**2*b**3) == b
+
+    R.set_max(15)
+    raises(RuntimeError, lambda:  R.add_rule(a**-3, b))
+    R.set_max(20)
+    R.add_rule(a**-3, b)
+
+    assert R.add_rule(a, a) == set()
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_schur_number.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_schur_number.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6beb9b11fa993a99b71d89b8485050fc3575b8e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_schur_number.py
@@ -0,0 +1,55 @@
+from sympy.core import S, Rational
+from sympy.combinatorics.schur_number import schur_partition, SchurNumber
+from sympy.core.random import _randint
+from sympy.testing.pytest import raises
+from sympy.core.symbol import symbols
+
+
+def _sum_free_test(subset):
+    """
+    Checks if subset is sum-free(There are no x,y,z in the subset such that
+    x + y = z)
+    """
+    for i in subset:
+        for j in subset:
+            assert (i + j in subset) is False
+
+
+def test_schur_partition():
+    raises(ValueError, lambda: schur_partition(S.Infinity))
+    raises(ValueError, lambda: schur_partition(-1))
+    raises(ValueError, lambda: schur_partition(0))
+    assert schur_partition(2) == [[1, 2]]
+
+    random_number_generator = _randint(1000)
+    for _ in range(5):
+        n = random_number_generator(1, 1000)
+        result = schur_partition(n)
+        t = 0
+        numbers = []
+        for item in result:
+            _sum_free_test(item)
+            """
+            Checks if the occurrence of all numbers is exactly one
+            """
+            t += len(item)
+            for l in item:
+                assert (l in numbers) is False
+                numbers.append(l)
+        assert n == t
+
+    x = symbols("x")
+    raises(ValueError, lambda: schur_partition(x))
+
+def test_schur_number():
+    first_known_schur_numbers = {1: 1, 2: 4, 3: 13, 4: 44, 5: 160}
+    for k in first_known_schur_numbers:
+        assert SchurNumber(k) == first_known_schur_numbers[k]
+
+    assert SchurNumber(S.Infinity) == S.Infinity
+    assert SchurNumber(0) == 0
+    raises(ValueError, lambda: SchurNumber(0.5))
+
+    n = symbols("n")
+    assert SchurNumber(n).lower_bound() == 3**n/2 - Rational(1, 2)
+    assert SchurNumber(8).lower_bound() == 5039
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_subsets.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_subsets.py
new file mode 100644
index 0000000000000000000000000000000000000000..1d50076da1c685294c2d2561dcc2a6af629eaf83
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_subsets.py
@@ -0,0 +1,63 @@
+from sympy.combinatorics.subsets import Subset, ksubsets
+from sympy.testing.pytest import raises
+
+
+def test_subset():
+    a = Subset(['c', 'd'], ['a', 'b', 'c', 'd'])
+    assert a.next_binary() == Subset(['b'], ['a', 'b', 'c', 'd'])
+    assert a.prev_binary() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.next_lexicographic() == Subset(['d'], ['a', 'b', 'c', 'd'])
+    assert a.prev_lexicographic() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.next_gray() == Subset(['c'], ['a', 'b', 'c', 'd'])
+    assert a.prev_gray() == Subset(['d'], ['a', 'b', 'c', 'd'])
+    assert a.rank_binary == 3
+    assert a.rank_lexicographic == 14
+    assert a.rank_gray == 2
+    assert a.cardinality == 16
+    assert a.size == 2
+    assert Subset.bitlist_from_subset(a, ['a', 'b', 'c', 'd']) == '0011'
+
+    a = Subset([2, 5, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_binary() == Subset([2, 5, 6], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_binary() == Subset([2, 5], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_lexicographic() == Subset([2, 6], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_lexicographic() == Subset([2, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.next_gray() == Subset([2, 5, 6, 7], [1, 2, 3, 4, 5, 6, 7])
+    assert a.prev_gray() == Subset([2, 5], [1, 2, 3, 4, 5, 6, 7])
+    assert a.rank_binary == 37
+    assert a.rank_lexicographic == 93
+    assert a.rank_gray == 57
+    assert a.cardinality == 128
+
+    superset = ['a', 'b', 'c', 'd']
+    assert Subset.unrank_binary(4, superset).rank_binary == 4
+    assert Subset.unrank_gray(10, superset).rank_gray == 10
+
+    superset = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    assert Subset.unrank_binary(33, superset).rank_binary == 33
+    assert Subset.unrank_gray(25, superset).rank_gray == 25
+
+    a = Subset([], ['a', 'b', 'c', 'd'])
+    i = 1
+    while a.subset != Subset(['d'], ['a', 'b', 'c', 'd']).subset:
+        a = a.next_lexicographic()
+        i = i + 1
+    assert i == 16
+
+    i = 1
+    while a.subset != Subset([], ['a', 'b', 'c', 'd']).subset:
+        a = a.prev_lexicographic()
+        i = i + 1
+    assert i == 16
+
+    raises(ValueError, lambda: Subset(['a', 'b'], ['a']))
+    raises(ValueError, lambda: Subset(['a'], ['b', 'c']))
+    raises(ValueError, lambda: Subset.subset_from_bitlist(['a', 'b'], '010'))
+
+    assert Subset(['a'], ['a', 'b']) != Subset(['b'], ['a', 'b'])
+    assert Subset(['a'], ['a', 'b']) != Subset(['a'], ['a', 'c'])
+
+def test_ksubsets():
+    assert list(ksubsets([1, 2, 3], 2)) == [(1, 2), (1, 3), (2, 3)]
+    assert list(ksubsets([1, 2, 3, 4, 5], 2)) == [(1, 2), (1, 3), (1, 4),
+               (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_tensor_can.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_tensor_can.py
new file mode 100644
index 0000000000000000000000000000000000000000..3922419f20b92536426bfaae4b7e94df5db671b5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_tensor_can.py
@@ -0,0 +1,560 @@
+from sympy.combinatorics.permutations import Permutation, Perm
+from sympy.combinatorics.tensor_can import (perm_af_direct_product, dummy_sgs,
+    riemann_bsgs, get_symmetric_group_sgs, canonicalize, bsgs_direct_product)
+from sympy.combinatorics.testutil import canonicalize_naive, graph_certificate
+from sympy.testing.pytest import skip, XFAIL
+
+def test_perm_af_direct_product():
+    gens1 = [[1,0,2,3], [0,1,3,2]]
+    gens2 = [[1,0]]
+    assert perm_af_direct_product(gens1, gens2, 0) == [[1, 0, 2, 3, 4, 5], [0, 1, 3, 2, 4, 5], [0, 1, 2, 3, 5, 4]]
+    gens1 = [[1,0,2,3,5,4], [0,1,3,2,4,5]]
+    gens2 = [[1,0,2,3]]
+    assert [[1, 0, 2, 3, 4, 5, 7, 6], [0, 1, 3, 2, 4, 5, 6, 7], [0, 1, 2, 3, 5, 4, 6, 7]]
+
+def test_dummy_sgs():
+    a = dummy_sgs([1,2], 0, 4)
+    assert a == [[0,2,1,3,4,5]]
+    a = dummy_sgs([2,3,4,5], 0, 8)
+    assert a == [x._array_form for x in [Perm(9)(2,3), Perm(9)(4,5),
+        Perm(9)(2,4)(3,5)]]
+
+    a = dummy_sgs([2,3,4,5], 1, 8)
+    assert a == [x._array_form for x in [Perm(2,3)(8,9), Perm(4,5)(8,9),
+        Perm(9)(2,4)(3,5)]]
+
+def test_get_symmetric_group_sgs():
+    assert get_symmetric_group_sgs(2) == ([0], [Permutation(3)(0,1)])
+    assert get_symmetric_group_sgs(2, 1) == ([0], [Permutation(0,1)(2,3)])
+    assert get_symmetric_group_sgs(3) == ([0,1], [Permutation(4)(0,1), Permutation(4)(1,2)])
+    assert get_symmetric_group_sgs(3, 1) == ([0,1], [Permutation(0,1)(3,4), Permutation(1,2)(3,4)])
+    assert get_symmetric_group_sgs(4) == ([0,1,2], [Permutation(5)(0,1), Permutation(5)(1,2), Permutation(5)(2,3)])
+    assert get_symmetric_group_sgs(4, 1) == ([0,1,2], [Permutation(0,1)(4,5), Permutation(1,2)(4,5), Permutation(2,3)(4,5)])
+
+
+def test_canonicalize_no_slot_sym():
+    # cases in which there is no slot symmetry after fixing the
+    # free indices; here and in the following if the symmetry of the
+    # metric is not specified, it is assumed to be symmetric.
+    # If it is not specified, tensors are commuting.
+
+    # A_d0 * B^d0; g = [1,0, 2,3]; T_c = A^d0*B_d0; can = [0,1,2,3]
+    base1, gens1 = get_symmetric_group_sgs(1)
+    dummies = [0, 1]
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, dummies, 0, (base1,gens1,1,0), (base1,gens1,1,0))
+    assert can == [0,1,2,3]
+    # equivalently
+    can = canonicalize(g, dummies, 0, (base1, gens1, 2, None))
+    assert can == [0,1,2,3]
+
+    # with antisymmetric metric; T_c = -A^d0*B_d0; can = [0,1,3,2]
+    can = canonicalize(g, dummies, 1, (base1,gens1,1,0), (base1,gens1,1,0))
+    assert can == [0,1,3,2]
+
+    # A^a * B^b; ord = [a,b]; g = [0,1,2,3]; can = g
+    g = Permutation([0,1,2,3])
+    dummies = []
+    t0 = t1 = (base1, gens1, 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0,1,2,3]
+    # B^b * A^a
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [1,0,2,3]
+
+    # A symmetric
+    # A^{b}_{d0}*A^{d0, a} order a,b,d0,-d0; T_c = A^{a d0}*A{b}_{d0}
+    # g = [1,3,2,0,4,5]; can = [0,2,1,3,4,5]
+    base2, gens2 = get_symmetric_group_sgs(2)
+    dummies = [2,3]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, dummies, 0, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 4, 5]
+    # with antisymmetric metric
+    can = canonicalize(g, dummies, 1, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 4, 5]
+    # A^{a}_{d0}*A^{d0, b}
+    g = Permutation([0,3,2,1,4,5])
+    can = canonicalize(g, dummies, 1, (base2, gens2, 2, 0))
+    assert can == [0, 2, 1, 3, 5, 4]
+
+    # A, B symmetric
+    # A^b_d0*B^{d0,a}; g=[1,3,2,0,4,5]
+    # T_c = A^{b,d0}*B_{a,d0}; can = [1,2,0,3,4,5]
+    dummies = [2,3]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, dummies, 0, (base2,gens2,1,0), (base2,gens2,1,0))
+    assert can == [1,2,0,3,4,5]
+    # same with antisymmetric metric
+    can = canonicalize(g, dummies, 1, (base2,gens2,1,0), (base2,gens2,1,0))
+    assert can == [1,2,0,3,5,4]
+
+    # A^{d1}_{d0}*B^d0*C_d1 ord=[d0,-d0,d1,-d1]; g = [2,1,0,3,4,5]
+    # T_c = A^{d0 d1}*B_d0*C_d1; can = [0,2,1,3,4,5]
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    g = Permutation([2,1,0,3,4,5])
+    dummies = [0,1,2,3]
+    t0 = (base2, gens2, 1, 0)
+    t1 = t2 = (base1, gens1, 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [0, 2, 1, 3, 4, 5]
+
+    # A without symmetry
+    # A^{d1}_{d0}*B^d0*C_d1 ord=[d0,-d0,d1,-d1]; g = [2,1,0,3,4,5]
+    # T_c = A^{d0 d1}*B_d1*C_d0; can = [0,2,3,1,4,5]
+    g = Permutation([2,1,0,3,4,5])
+    dummies = [0,1,2,3]
+    t0 = ([], [Permutation(list(range(4)))], 1, 0)
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [0,2,3,1,4,5]
+    # A, B without symmetry
+    # A^{d1}_{d0}*B_{d1}^{d0}; g = [2,1,3,0,4,5]
+    # T_c = A^{d0 d1}*B_{d0 d1}; can = [0,2,1,3,4,5]
+    t0 = t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [0,1,2,3]
+    g = Permutation([2,1,3,0,4,5])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0, 2, 1, 3, 4, 5]
+    # A_{d0}^{d1}*B_{d1}^{d0}; g = [1,2,3,0,4,5]
+    # T_c = A^{d0 d1}*B_{d1 d0}; can = [0,2,3,1,4,5]
+    g = Permutation([1,2,3,0,4,5])
+    can = canonicalize(g, dummies, 0, t0, t1)
+    assert can == [0,2,3,1,4,5]
+
+    # A, B, C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c=A^{d0 d1}*B_{a d1}*C_{d0 b}; can = [2,4,0,5,3,1,6,7]
+    t0 = t1 = t2 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,5,3,1,6,7]
+
+    # A symmetric, B and C without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = A^{d0 d1}*B_{a d0}*C_{d1 b}; can = [2,4,0,3,5,1,6,7]
+    t0 = (base2,gens2,1,0)
+    t1 = t2 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,5,1,6,7]
+
+    # A and C symmetric, B without symmetry
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = A^{d0 d1}*B_{a d0}*C_{b d1}; can = [2,4,0,3,1,5,6,7]
+    t0 = t2 = (base2,gens2,1,0)
+    t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,1,5,6,7]
+
+    # A symmetric, B without symmetry, C antisymmetric
+    # A^{d1 d0}*B_{a d0}*C_{d1 b} ord=[a,b,d0,-d0,d1,-d1]
+    # g=[4,2,0,3,5,1,6,7]
+    # T_c = -A^{d0 d1}*B_{a d0}*C_{b d1}; can = [2,4,0,3,1,5,7,6]
+    t0 = (base2,gens2, 1, 0)
+    t1 = ([], [Permutation(list(range(4)))], 1, 0)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+    t2 = (base2a, gens2a, 1, 0)
+    dummies = [2,3,4,5]
+    g = Permutation([4,2,0,3,5,1,6,7])
+    can = canonicalize(g, dummies, 0, t0, t1, t2)
+    assert can == [2,4,0,3,1,5,7,6]
+
+
+def test_canonicalize_no_dummies():
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+
+    # A commuting
+    # A^c A^b A^a; ord = [a,b,c]; g = [2,1,0,3,4]
+    # T_c = A^a A^b A^c; can = list(range(5))
+    g = Permutation([2,1,0,3,4])
+    can = canonicalize(g, [], 0, (base1, gens1, 3, 0))
+    assert can == list(range(5))
+
+    # A anticommuting
+    # A^c A^b A^a; ord = [a,b,c]; g = [2,1,0,3,4]
+    # T_c = -A^a A^b A^c; can = [0,1,2,4,3]
+    g = Permutation([2,1,0,3,4])
+    can = canonicalize(g, [], 0, (base1, gens1, 3, 1))
+    assert can == [0,1,2,4,3]
+
+    # A commuting and symmetric
+    # A^{b,d}*A^{c,a}; ord = [a,b,c,d]; g = [1,3,2,0,4,5]
+    # T_c = A^{a c}*A^{b d}; can = [0,2,1,3,4,5]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 0))
+    assert can == [0,2,1,3,4,5]
+
+    # A anticommuting and symmetric
+    # A^{b,d}*A^{c,a}; ord = [a,b,c,d]; g = [1,3,2,0,4,5]
+    # T_c = -A^{a c}*A^{b d}; can = [0,2,1,3,5,4]
+    g = Permutation([1,3,2,0,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 1))
+    assert can == [0,2,1,3,5,4]
+    # A^{c,a}*A^{b,d} ; g = [2,0,1,3,4,5]
+    # T_c = A^{a c}*A^{b d}; can = [0,2,1,3,4,5]
+    g = Permutation([2,0,1,3,4,5])
+    can = canonicalize(g, [], 0, (base2, gens2, 2, 1))
+    assert can == [0,2,1,3,4,5]
+
+def test_no_metric_symmetry():
+    # no metric symmetry
+    # A^d1_d0 * A^d0_d1; ord = [d0,-d0,d1,-d1]; g= [2,1,0,3,4,5]
+    # T_c = A^d0_d1 * A^d1_d0; can = [0,3,2,1,4,5]
+    g = Permutation([2,1,0,3,4,5])
+    can = canonicalize(g, list(range(4)), None, [[], [Permutation(list(range(4)))], 2, 0])
+    assert can == [0,3,2,1,4,5]
+
+    # A^d1_d2 * A^d0_d3 * A^d2_d1 * A^d3_d0
+    # ord = [d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    #        0    1  2  3  4   5   6   7
+    # g = [2,5,0,7,4,3,6,1,8,9]
+    # T_c = A^d0_d1 * A^d1_d0 * A^d2_d3 * A^d3_d2
+    # can = [0,3,2,1,4,7,6,5,8,9]
+    g = Permutation([2,5,0,7,4,3,6,1,8,9])
+    #can = canonicalize(g, list(range(8)), 0, [[], [list(range(4))], 4, 0])
+    #assert can == [0, 2, 3, 1, 4, 6, 7, 5, 8, 9]
+    can = canonicalize(g, list(range(8)), None, [[], [Permutation(list(range(4)))], 4, 0])
+    assert can == [0, 3, 2, 1, 4, 7, 6, 5, 8, 9]
+
+    # A^d0_d2 * A^d1_d3 * A^d3_d0 * A^d2_d1
+    # g = [0,5,2,7,6,1,4,3,8,9]
+    # T_c = A^d0_d1 * A^d1_d2 * A^d2_d3 * A^d3_d0
+    # can = [0,3,2,5,4,7,6,1,8,9]
+    g = Permutation([0,5,2,7,6,1,4,3,8,9])
+    can = canonicalize(g, list(range(8)), None, [[], [Permutation(list(range(4)))], 4, 0])
+    assert can == [0,3,2,5,4,7,6,1,8,9]
+
+    g = Permutation([12,7,10,3,14,13,4,11,6,1,2,9,0,15,8,5,16,17])
+    can = canonicalize(g, list(range(16)), None, [[], [Permutation(list(range(4)))], 8, 0])
+    assert can == [0,3,2,5,4,7,6,1,8,11,10,13,12,15,14,9,16,17]
+
+def test_canonical_free():
+    # t = A^{d0 a1}*A_d0^a0
+    # ord = [a0,a1,d0,-d0];  g = [2,1,3,0,4,5]; dummies = [[2,3]]
+    # t_c = A_d0^a0*A^{d0 a1}
+    # can = [3,0, 2,1, 4,5]
+    g = Permutation([2,1,3,0,4,5])
+    dummies = [[2,3]]
+    can = canonicalize(g, dummies, [None], ([], [Permutation(3)], 2, 0))
+    assert can == [3,0, 2,1, 4,5]
+
+def test_canonicalize1():
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base1a, gens1a = get_symmetric_group_sgs(1, 1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base3, gens3 = get_symmetric_group_sgs(3)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+    base3a, gens3a = get_symmetric_group_sgs(3, 1)
+
+    # A_d0*A^d0; ord = [d0,-d0]; g = [1,0,2,3]
+    # T_c = A^d0*A_d0; can = [0,1,2,3]
+    g = Permutation([1,0,2,3])
+    can = canonicalize(g, [0, 1], 0, (base1, gens1, 2, 0))
+    assert can == list(range(4))
+
+    # A commuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0; ord=[d0,-d0,d1,-d1,d2,-d2]
+    # g = [1,3,5,4,2,0,6,7]
+    # T_c = A^d0*A_d0*A^d1*A_d1*A^d2*A_d2; can = list(range(8))
+    g = Permutation([1,3,5,4,2,0,6,7])
+    can = canonicalize(g, list(range(6)), 0, (base1, gens1, 6, 0))
+    assert can == list(range(8))
+
+    # A anticommuting
+    # A_d0*A_d1*A_d2*A^d2*A^d1*A^d0; ord=[d0,-d0,d1,-d1,d2,-d2]
+    # g = [1,3,5,4,2,0,6,7]
+    # T_c 0;  can = 0
+    g = Permutation([1,3,5,4,2,0,6,7])
+    can = canonicalize(g, list(range(6)), 0, (base1, gens1, 6, 1))
+    assert can == 0
+    can1 = canonicalize_naive(g, list(range(6)), 0, (base1, gens1, 6, 1))
+    assert can1 == 0
+
+    # A commuting symmetric
+    # A^{d0 b}*A^a_d1*A^d1_d0; ord=[a,b,d0,-d0,d1,-d1]
+    # g = [2,1,0,5,4,3,6,7]
+    # T_c = A^{a d0}*A^{b d1}*A_{d0 d1}; can = [0,2,1,4,3,5,6,7]
+    g = Permutation([2,1,0,5,4,3,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base2, gens2, 3, 0))
+    assert can == [0,2,1,4,3,5,6,7]
+
+    # A, B commuting symmetric
+    # A^{d0 b}*A^d1_d0*B^a_d1; ord=[a,b,d0,-d0,d1,-d1]
+    # g = [2,1,4,3,0,5,6,7]
+    # T_c = A^{b d0}*A_d0^d1*B^a_d1; can = [1,2,3,4,0,5,6,7]
+    g = Permutation([2,1,4,3,0,5,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base2,gens2,2,0), (base2,gens2,1,0))
+    assert can == [1,2,3,4,0,5,6,7]
+
+    # A commuting symmetric
+    # A^{d1 d0 b}*A^{a}_{d1 d0}; ord=[a,b, d0,-d0,d1,-d1]
+    # g = [4,2,1,0,5,3,6,7]
+    # T_c = A^{a d0 d1}*A^{b}_{d0 d1}; can = [0,2,4,1,3,5,6,7]
+    g = Permutation([4,2,1,0,5,3,6,7])
+    can = canonicalize(g, list(range(2,6)), 0, (base3, gens3, 2, 0))
+    assert can == [0,2,4,1,3,5,6,7]
+
+
+    # A^{d3 d0 d2}*A^a0_{d1 d2}*A^d1_d3^a1*A^{a2 a3}_d0
+    # ord = [a0,a1,a2,a3,d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    #        0   1  2  3  4  5  6   7  8   9  10  11
+    # g = [10,4,8, 0,7,9, 6,11,1, 2,3,5, 12,13]
+    # T_c = A^{a0 d0 d1}*A^a1_d0^d2*A^{a2 a3 d3}*A_{d1 d2 d3}
+    # can = [0,4,6, 1,5,8, 2,3,10, 7,9,11, 12,13]
+    g = Permutation([10,4,8, 0,7,9, 6,11,1, 2,3,5, 12,13])
+    can = canonicalize(g, list(range(4,12)), 0, (base3, gens3, 4, 0))
+    assert can == [0,4,6, 1,5,8, 2,3,10, 7,9,11, 12,13]
+
+    # A commuting symmetric, B antisymmetric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # ord = [d0,-d0,d1,-d1,d2,-d2,d3,-d3]
+    # g = [0,2,4,5,7,3,1,6,8,9]
+    # in this esxample and in the next three,
+    # renaming dummy indices and using symmetry of A,
+    # T = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    # can = 0
+    g = Permutation([0,2,4,5,7,3,1,6,8,9])
+    can = canonicalize(g, list(range(8)), 0, (base3, gens3,2,0), (base2a,gens2a,1,0))
+    assert can == 0
+    # A anticommuting symmetric, B anticommuting
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    # can = [0,2,4, 1,3,6, 5,7, 8,9]
+    can = canonicalize(g, list(range(8)), 0, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4, 1,3,6, 5,7, 8,9]
+    # A anticommuting symmetric, B antisymmetric commuting, antisymmetric metric
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = -A^{d0 d1 d2} * A_{d0 d1}^d3 * B_{d2 d3}
+    # can = [0,2,4, 1,3,6, 5,7, 9,8]
+    can = canonicalize(g, list(range(8)), 1, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4, 1,3,6, 5,7, 9,8]
+
+    # A anticommuting symmetric, B anticommuting anticommuting,
+    # no metric symmetry
+    # A^{d0 d1 d2} * A_{d2 d3 d1} * B_d0^d3
+    # T_c = A^{d0 d1 d2} * A_{d0 d1 d3} * B_d2^d3
+    # can = [0,2,4, 1,3,7, 5,6, 8,9]
+    can = canonicalize(g, list(range(8)), None, (base3, gens3,2,1), (base2a,gens2a,1,0))
+    assert can == [0,2,4,1,3,7,5,6,8,9]
+
+    # Gamma anticommuting
+    # Gamma_{mu nu} * gamma^rho * Gamma^{nu mu alpha}
+    # ord = [alpha, rho, mu,-mu,nu,-nu]
+    # g = [3,5,1,4,2,0,6,7]
+    # T_c = -Gamma^{mu nu} * gamma^rho * Gamma_{alpha mu nu}
+    # can = [2,4,1,0,3,5,7,6]]
+    g = Permutation([3,5,1,4,2,0,6,7])
+    t0 = (base2a, gens2a, 1, None)
+    t1 = (base1, gens1, 1, None)
+    t2 = (base3a, gens3a, 1, None)
+    can = canonicalize(g, list(range(2, 6)), 0, t0, t1, t2)
+    assert can == [2,4,1,0,3,5,7,6]
+
+    # Gamma_{mu nu} * Gamma^{gamma beta} * gamma_rho * Gamma^{nu mu alpha}
+    # ord = [alpha, beta, gamma, -rho, mu,-mu,nu,-nu]
+    #         0      1      2     3    4   5   6  7
+    # g = [5,7,2,1,3,6,4,0,8,9]
+    # T_c = Gamma^{mu nu} * Gamma^{beta gamma} * gamma_rho * Gamma^alpha_{mu nu}    # can = [4,6,1,2,3,0,5,7,8,9]
+    t0 = (base2a, gens2a, 2, None)
+    g = Permutation([5,7,2,1,3,6,4,0,8,9])
+    can = canonicalize(g, list(range(4, 8)), 0, t0, t1, t2)
+    assert can == [4,6,1,2,3,0,5,7,8,9]
+
+    # f^a_{b,c} antisymmetric in b,c; A_mu^a no symmetry
+    # f^c_{d a} * f_{c e b} * A_mu^d * A_nu^a * A^{nu e} * A^{mu b}
+    # ord = [mu,-mu,nu,-nu,a,-a,b,-b,c,-c,d,-d, e, -e]
+    #         0  1  2   3  4  5 6  7 8  9 10 11 12 13
+    # g = [8,11,5, 9,13,7, 1,10, 3,4, 2,12, 0,6, 14,15]
+    # T_c = -f^{a b c} * f_a^{d e} * A^mu_b * A_{mu d} * A^nu_c * A_{nu e}
+    # can = [4,6,8,       5,10,12,   0,7,     1,11,       2,9,    3,13, 15,14]
+    g = Permutation([8,11,5, 9,13,7, 1,10, 3,4, 2,12, 0,6, 14,15])
+    base_f, gens_f = bsgs_direct_product(base1, gens1, base2a, gens2a)
+    base_A, gens_A = bsgs_direct_product(base1, gens1, base1, gens1)
+    t0 = (base_f, gens_f, 2, 0)
+    t1 = (base_A, gens_A, 4, 0)
+    can = canonicalize(g, [list(range(4)), list(range(4, 14))], [0, 0], t0, t1)
+    assert can == [4,6,8, 5,10,12, 0,7, 1,11, 2,9, 3,13, 15,14]
+
+
+def test_riemann_invariants():
+    baser, gensr = riemann_bsgs
+    # R^{d0 d1}_{d1 d0}; ord = [d0,-d0,d1,-d1]; g = [0,2,3,1,4,5]
+    # T_c = -R^{d0 d1}_{d0 d1}; can = [0,2,1,3,5,4]
+    g = Permutation([0,2,3,1,4,5])
+    can = canonicalize(g, list(range(2, 4)), 0, (baser, gensr, 1, 0))
+    assert can == [0,2,1,3,5,4]
+    # use a non minimal BSGS
+    can = canonicalize(g, list(range(2, 4)), 0, ([2, 0], [Permutation([1,0,2,3,5,4]), Permutation([2,3,0,1,4,5])], 1, 0))
+    assert can == [0,2,1,3,5,4]
+
+    """
+    The following tests in test_riemann_invariants and in
+    test_riemann_invariants1 have been checked using xperm.c from XPerm in
+    in [1] and with an older version contained in [2]
+
+    [1] xperm.c part of xPerm written by J. M. Martin-Garcia
+        http://www.xact.es/index.html
+    [2] test_xperm.cc in cadabra by Kasper Peeters, http://cadabra.phi-sci.com/
+    """
+    # R_d11^d1_d0^d5 * R^{d6 d4 d0}_d5 * R_{d7 d2 d8 d9} *
+    # R_{d10 d3 d6 d4} * R^{d2 d7 d11}_d1 * R^{d8 d9 d3 d10}
+    # ord: contravariant d_k ->2*k, covariant d_k -> 2*k+1
+    # T_c = R^{d0 d1 d2 d3} * R_{d0 d1}^{d4 d5} * R_{d2 d3}^{d6 d7} *
+    # R_{d4 d5}^{d8 d9} * R_{d6 d7}^{d10 d11} * R_{d8 d9 d10 d11}
+    g = Permutation([23,2,1,10,12,8,0,11,15,5,17,19,21,7,13,9,4,14,22,3,16,18,6,20,24,25])
+    can = canonicalize(g, list(range(24)), 0, (baser, gensr, 6, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,21,23,24,25]
+
+    # use a non minimal BSGS
+    can = canonicalize(g, list(range(24)), 0, ([2, 0], [Permutation([1,0,2,3,5,4]), Permutation([2,3,0,1,4,5])], 6, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,21,23,24,25]
+
+    g = Permutation([0,2,5,7,4,6,9,11,8,10,13,15,12,14,17,19,16,18,21,23,20,22,25,27,24,26,29,31,28,30,33,35,32,34,37,39,36,38,1,3,40,41])
+    can = canonicalize(g, list(range(40)), 0, (baser, gensr, 10, 0))
+    assert can == [0,2,4,6,1,3,8,10,5,7,12,14,9,11,16,18,13,15,20,22,17,19,24,26,21,23,28,30,25,27,32,34,29,31,36,38,33,35,37,39,40,41]
+
+
+@XFAIL
+def test_riemann_invariants1():
+    skip('takes too much time')
+    baser, gensr = riemann_bsgs
+    g = Permutation([17, 44, 11, 3, 0, 19, 23, 15, 38, 4, 25, 27, 43, 36, 22, 14, 8, 30, 41, 20, 2, 10, 12, 28, 18, 1, 29, 13, 37, 42, 33, 7, 9, 31, 24, 26, 39, 5, 34, 47, 32, 6, 21, 40, 35, 46, 45, 16, 48, 49])
+    can = canonicalize(g, list(range(48)), 0, (baser, gensr, 12, 0))
+    assert can == [0, 2, 4, 6, 1, 3, 8, 10, 5, 7, 12, 14, 9, 11, 16, 18, 13, 15, 20, 22, 17, 19, 24, 26, 21, 23, 28, 30, 25, 27, 32, 34, 29, 31, 36, 38, 33, 35, 40, 42, 37, 39, 44, 46, 41, 43, 45, 47, 48, 49]
+
+    g = Permutation([0,2,4,6, 7,8,10,12, 14,16,18,20, 19,22,24,26, 5,21,28,30, 32,34,36,38, 40,42,44,46, 13,48,50,52, 15,49,54,56, 17,33,41,58, 9,23,60,62, 29,35,63,64, 3,45,66,68, 25,37,47,57, 11,31,69,70, 27,39,53,72, 1,59,73,74, 55,61,67,76, 43,65,75,78, 51,71,77,79, 80,81])
+    can = canonicalize(g, list(range(80)), 0, (baser, gensr, 20, 0))
+    assert can == [0,2,4,6, 1,8,10,12, 3,14,16,18, 5,20,22,24, 7,26,28,30, 9,15,32,34, 11,36,23,38, 13,40,42,44, 17,39,29,46, 19,48,43,50, 21,45,52,54, 25,56,33,58, 27,60,53,62, 31,51,64,66, 35,65,47,68, 37,70,49,72, 41,74,57,76, 55,67,59,78, 61,69,71,75, 63,79,73,77, 80,81]
+
+
+def test_riemann_products():
+    baser, gensr = riemann_bsgs
+    base1, gens1 = get_symmetric_group_sgs(1)
+    base2, gens2 = get_symmetric_group_sgs(2)
+    base2a, gens2a = get_symmetric_group_sgs(2, 1)
+
+    # R^{a b d0}_d0 = 0
+    g = Permutation([0,1,2,3,4,5])
+    can = canonicalize(g, list(range(2,4)), 0, (baser, gensr, 1, 0))
+    assert can == 0
+
+    # R^{d0 b a}_d0 ; ord = [a,b,d0,-d0}; g = [2,1,0,3,4,5]
+    # T_c = -R^{a d0 b}_d0;  can = [0,2,1,3,5,4]
+    g = Permutation([2,1,0,3,4,5])
+    can = canonicalize(g, list(range(2, 4)), 0, (baser, gensr, 1, 0))
+    assert can == [0,2,1,3,5,4]
+
+    # R^d1_d2^b_d0 * R^{d0 a}_d1^d2; ord=[a,b,d0,-d0,d1,-d1,d2,-d2]
+    # g = [4,7,1,3,2,0,5,6,8,9]
+    # T_c = -R^{a d0 d1 d2}* R^b_{d0 d1 d2}
+    # can = [0,2,4,6,1,3,5,7,9,8]
+    g = Permutation([4,7,1,3,2,0,5,6,8,9])
+    can = canonicalize(g, list(range(2,8)), 0, (baser, gensr, 2, 0))
+    assert can == [0,2,4,6,1,3,5,7,9,8]
+    can1 = canonicalize_naive(g, list(range(2,8)), 0, (baser, gensr, 2, 0))
+    assert can == can1
+
+    # A symmetric commuting
+    # R^{d6 d5}_d2^d1 * R^{d4 d0 d2 d3} * A_{d6 d0} A_{d3 d1} * A_{d4 d5}
+    # g = [12,10,5,2, 8,0,4,6, 13,1, 7,3, 9,11,14,15]
+    # T_c = -R^{d0 d1 d2 d3} * R_d0^{d4 d5 d6} * A_{d1 d4}*A_{d2 d5}*A_{d3 d6}
+
+    g = Permutation([12,10,5,2,8,0,4,6,13,1,7,3,9,11,14,15])
+    can = canonicalize(g, list(range(14)), 0, ((baser,gensr,2,0)), (base2,gens2,3,0))
+    assert can == [0, 2, 4, 6, 1, 8, 10, 12, 3, 9, 5, 11, 7, 13, 15, 14]
+
+    # R^{d2 a0 a2 d0} * R^d1_d2^{a1 a3} * R^{a4 a5}_{d0 d1}
+    # ord = [a0,a1,a2,a3,a4,a5,d0,-d0,d1,-d1,d2,-d2]
+    #         0  1  2  3 4  5  6   7  8   9  10  11
+    # can = [0, 6, 2, 8, 1, 3, 7, 10, 4, 5, 9, 11, 12, 13]
+    # T_c = R^{a0 d0 a2 d1}*R^{a1 a3}_d0^d2*R^{a4 a5}_{d1 d2}
+    g = Permutation([10,0,2,6,8,11,1,3,4,5,7,9,12,13])
+    can = canonicalize(g, list(range(6,12)), 0, (baser, gensr, 3, 0))
+    assert can == [0, 6, 2, 8, 1, 3, 7, 10, 4, 5, 9, 11, 12, 13]
+    #can1 = canonicalize_naive(g, list(range(6,12)), 0, (baser, gensr, 3, 0))
+    #assert can == can1
+
+    # A^n_{i, j} antisymmetric in i,j
+    # A_m0^d0_a1 * A_m1^a0_d0; ord = [m0,m1,a0,a1,d0,-d0]
+    # g = [0,4,3,1,2,5,6,7]
+    # T_c = -A_{m a1}^d0 * A_m1^a0_d0
+    # can = [0,3,4,1,2,5,7,6]
+    base, gens = bsgs_direct_product(base1, gens1, base2a, gens2a)
+    dummies = list(range(4, 6))
+    g = Permutation([0,4,3,1,2,5,6,7])
+    can = canonicalize(g, dummies, 0, (base, gens, 2, 0))
+    assert can == [0, 3, 4, 1, 2, 5, 7, 6]
+
+
+    # A^n_{i, j} symmetric in i,j
+    # A^m0_a0^d2 * A^n0_d2^d1 * A^n1_d1^d0 * A_{m0 d0}^a1
+    # ordering: first the free indices; then first n, then d
+    # ord=[n0,n1,a0,a1, m0,-m0,d0,-d0,d1,-d1,d2,-d2]
+    #      0  1   2  3   4  5  6   7  8   9  10  11]
+    # g = [4,2,10, 0,11,8, 1,9,6, 5,7,3, 12,13]
+    # if the dummy indices m_i and d_i were separated,
+    # one gets
+    # T_c = A^{n0 d0 d1} * A^n1_d0^d2 * A^m0^a0_d1 * A_m0^a1_d2
+    # can = [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 12, 13]
+    # If they are not, so can is
+    # T_c = A^{n0 m0 d0} A^n1_m0^d1 A^{d2 a0}_d0 A_d2^a1_d1
+    # can = [0, 4, 6, 1, 5, 8, 10, 2, 7, 11, 3, 9, 12, 13]
+    # case with single type of indices
+
+    base, gens = bsgs_direct_product(base1, gens1, base2, gens2)
+    dummies = list(range(4, 12))
+    g = Permutation([4,2,10, 0,11,8, 1,9,6, 5,7,3, 12,13])
+    can = canonicalize(g, dummies, 0, (base, gens, 4, 0))
+    assert can == [0, 4, 6, 1, 5, 8, 10, 2, 7, 11, 3, 9, 12, 13]
+    # case with separated indices
+    dummies = [list(range(4, 6)), list(range(6,12))]
+    sym = [0, 0]
+    can = canonicalize(g, dummies, sym, (base, gens, 4, 0))
+    assert can == [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 12, 13]
+    # case with separated indices with the second type of index
+    # with antisymmetric metric: there is a sign change
+    sym = [0, 1]
+    can = canonicalize(g, dummies, sym, (base, gens, 4, 0))
+    assert can == [0, 6, 8, 1, 7, 10, 4, 2, 9, 5, 3, 11, 13, 12]
+
+def test_graph_certificate():
+    # test tensor invariants constructed from random regular graphs;
+    # checked graph isomorphism with networkx
+    import random
+    def randomize_graph(size, g):
+        p = list(range(size))
+        random.shuffle(p)
+        g1a = {}
+        for k, v in g1.items():
+            g1a[p[k]] = [p[i] for i in v]
+        return g1a
+
+    g1 = {0: [2, 3, 7], 1: [4, 5, 7], 2: [0, 4, 6], 3: [0, 6, 7], 4: [1, 2, 5], 5: [1, 4, 6], 6: [2, 3, 5], 7: [0, 1, 3]}
+    g2 = {0: [2, 3, 7], 1: [2, 4, 5], 2: [0, 1, 5], 3: [0, 6, 7], 4: [1, 5, 6], 5: [1, 2, 4], 6: [3, 4, 7], 7: [0, 3, 6]}
+
+    c1 = graph_certificate(g1)
+    c2 = graph_certificate(g2)
+    assert c1 != c2
+    g1a = randomize_graph(8, g1)
+    c1a = graph_certificate(g1a)
+    assert c1 == c1a
+
+    g1 = {0: [8, 1, 9, 7], 1: [0, 9, 3, 4], 2: [3, 4, 6, 7], 3: [1, 2, 5, 6], 4: [8, 1, 2, 5], 5: [9, 3, 4, 7], 6: [8, 2, 3, 7], 7: [0, 2, 5, 6], 8: [0, 9, 4, 6], 9: [8, 0, 5, 1]}
+    g2 = {0: [1, 2, 5, 6], 1: [0, 9, 5, 7], 2: [0, 4, 6, 7], 3: [8, 9, 6, 7], 4: [8, 2, 6, 7], 5: [0, 9, 8, 1], 6: [0, 2, 3, 4], 7: [1, 2, 3, 4], 8: [9, 3, 4, 5], 9: [8, 1, 3, 5]}
+    c1 = graph_certificate(g1)
+    c2 = graph_certificate(g2)
+    assert c1 != c2
+    g1a = randomize_graph(10, g1)
+    c1a = graph_certificate(g1a)
+    assert c1 == c1a
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_testutil.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_testutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..736e7a4ff86967e41dca71cf12de6c387a82d26d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_testutil.py
@@ -0,0 +1,55 @@
+from sympy.combinatorics.named_groups import SymmetricGroup, AlternatingGroup,\
+    CyclicGroup
+from sympy.combinatorics.testutil import _verify_bsgs, _cmp_perm_lists,\
+    _naive_list_centralizer, _verify_centralizer,\
+    _verify_normal_closure
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+from sympy.core.random import shuffle
+
+
+def test_cmp_perm_lists():
+    S = SymmetricGroup(4)
+    els = list(S.generate_dimino())
+    other = els.copy()
+    shuffle(other)
+    assert _cmp_perm_lists(els, other) is True
+
+
+def test_naive_list_centralizer():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert _naive_list_centralizer(S, S) == [Permutation([0, 1, 2])]
+    assert PermutationGroup(_naive_list_centralizer(S, A)).is_subgroup(A)
+
+
+def test_verify_bsgs():
+    S = SymmetricGroup(5)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    assert _verify_bsgs(S, base, strong_gens) is True
+    assert _verify_bsgs(S, base[:-1], strong_gens) is False
+    assert _verify_bsgs(S, base, S.generators) is False
+
+
+def test_verify_centralizer():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    triv = PermutationGroup([Permutation([0, 1, 2])])
+    assert _verify_centralizer(S, S, centr=triv)
+    assert _verify_centralizer(S, A, centr=A)
+
+
+def test_verify_normal_closure():
+    # verified by GAP
+    S = SymmetricGroup(3)
+    A = AlternatingGroup(3)
+    assert _verify_normal_closure(S, A, closure=A)
+    S = SymmetricGroup(5)
+    A = AlternatingGroup(5)
+    C = CyclicGroup(5)
+    assert _verify_normal_closure(S, A, closure=A)
+    assert _verify_normal_closure(S, C, closure=A)
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_util.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..bca183e81f354e398aee9ae809fe79b20c7f2468
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/tests/test_util.py
@@ -0,0 +1,120 @@
+from sympy.combinatorics.named_groups import SymmetricGroup, DihedralGroup,\
+    AlternatingGroup
+from sympy.combinatorics.permutations import Permutation
+from sympy.combinatorics.util import _check_cycles_alt_sym, _strip,\
+    _distribute_gens_by_base, _strong_gens_from_distr,\
+    _orbits_transversals_from_bsgs, _handle_precomputed_bsgs, _base_ordering,\
+    _remove_gens
+from sympy.combinatorics.testutil import _verify_bsgs
+
+
+def test_check_cycles_alt_sym():
+    perm1 = Permutation([[0, 1, 2, 3, 4, 5, 6], [7], [8], [9]])
+    perm2 = Permutation([[0, 1, 2, 3, 4, 5], [6, 7, 8, 9]])
+    perm3 = Permutation([[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
+    assert _check_cycles_alt_sym(perm1) is True
+    assert _check_cycles_alt_sym(perm2) is False
+    assert _check_cycles_alt_sym(perm3) is False
+
+
+def test_strip():
+    D = DihedralGroup(5)
+    D.schreier_sims()
+    member = Permutation([4, 0, 1, 2, 3])
+    not_member1 = Permutation([0, 1, 4, 3, 2])
+    not_member2 = Permutation([3, 1, 4, 2, 0])
+    identity = Permutation([0, 1, 2, 3, 4])
+    res1 = _strip(member, D.base, D.basic_orbits, D.basic_transversals)
+    res2 = _strip(not_member1, D.base, D.basic_orbits, D.basic_transversals)
+    res3 = _strip(not_member2, D.base, D.basic_orbits, D.basic_transversals)
+    assert res1[0] == identity
+    assert res1[1] == len(D.base) + 1
+    assert res2[0] == not_member1
+    assert res2[1] == len(D.base) + 1
+    assert res3[0] != identity
+    assert res3[1] == 2
+
+
+def test_distribute_gens_by_base():
+    base = [0, 1, 2]
+    gens = [Permutation([0, 1, 2, 3]), Permutation([0, 1, 3, 2]),
+           Permutation([0, 2, 3, 1]), Permutation([3, 2, 1, 0])]
+    assert _distribute_gens_by_base(base, gens) == [gens,
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2]),
+                                                   Permutation([0, 2, 3, 1])],
+                                                   [Permutation([0, 1, 2, 3]),
+                                                   Permutation([0, 1, 3, 2])]]
+
+
+def test_strong_gens_from_distr():
+    strong_gens_distr = [[Permutation([0, 2, 1]), Permutation([1, 2, 0]),
+                  Permutation([1, 0, 2])], [Permutation([0, 2, 1])]]
+    assert _strong_gens_from_distr(strong_gens_distr) == \
+        [Permutation([0, 2, 1]),
+         Permutation([1, 2, 0]),
+         Permutation([1, 0, 2])]
+
+
+def test_orbits_transversals_from_bsgs():
+    S = SymmetricGroup(4)
+    S.schreier_sims()
+    base = S.base
+    strong_gens = S.strong_gens
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    result = _orbits_transversals_from_bsgs(base, strong_gens_distr)
+    orbits = result[0]
+    transversals = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert S.order() == order
+
+
+def test_handle_precomputed_bsgs():
+    A = AlternatingGroup(5)
+    A.schreier_sims()
+    base = A.base
+    strong_gens = A.strong_gens
+    result = _handle_precomputed_bsgs(base, strong_gens)
+    strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    assert strong_gens_distr == result[2]
+    transversals = result[0]
+    orbits = result[1]
+    base_len = len(base)
+    for i in range(base_len):
+        for el in orbits[i]:
+            assert transversals[i][el](base[i]) == el
+            for j in range(i):
+                assert transversals[i][el](base[j]) == base[j]
+    order = 1
+    for i in range(base_len):
+        order *= len(orbits[i])
+    assert A.order() == order
+
+
+def test_base_ordering():
+    base = [2, 4, 5]
+    degree = 7
+    assert _base_ordering(base, degree) == [3, 4, 0, 5, 1, 2, 6]
+
+
+def test_remove_gens():
+    S = SymmetricGroup(10)
+    base, strong_gens = S.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(S, base, new_gens) is True
+    A = AlternatingGroup(7)
+    base, strong_gens = A.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(A, base, new_gens) is True
+    D = DihedralGroup(2)
+    base, strong_gens = D.schreier_sims_incremental()
+    new_gens = _remove_gens(base, strong_gens)
+    assert _verify_bsgs(D, base, new_gens) is True
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/testutil.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/testutil.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fe664ce9e7437b97feec90f2052eb2987c57a4e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/testutil.py
@@ -0,0 +1,357 @@
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.util import _distribute_gens_by_base
+
+rmul = Permutation.rmul
+
+
+def _cmp_perm_lists(first, second):
+    """
+    Compare two lists of permutations as sets.
+
+    Explanation
+    ===========
+
+    This is used for testing purposes. Since the array form of a
+    permutation is currently a list, Permutation is not hashable
+    and cannot be put into a set.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.combinatorics.testutil import _cmp_perm_lists
+    >>> a = Permutation([0, 2, 3, 4, 1])
+    >>> b = Permutation([1, 2, 0, 4, 3])
+    >>> c = Permutation([3, 4, 0, 1, 2])
+    >>> ls1 = [a, b, c]
+    >>> ls2 = [b, c, a]
+    >>> _cmp_perm_lists(ls1, ls2)
+    True
+
+    """
+    return {tuple(a) for a in first} == \
+           {tuple(a) for a in second}
+
+
+def _naive_list_centralizer(self, other, af=False):
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    """
+    Return a list of elements for the centralizer of a subgroup/set/element.
+
+    Explanation
+    ===========
+
+    This is a brute force implementation that goes over all elements of the
+    group and checks for membership in the centralizer. It is used to
+    test ``.centralizer()`` from ``sympy.combinatorics.perm_groups``.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import _naive_list_centralizer
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> D = DihedralGroup(4)
+    >>> _naive_list_centralizer(D, D)
+    [Permutation([0, 1, 2, 3]), Permutation([2, 3, 0, 1])]
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.centralizer
+
+    """
+    from sympy.combinatorics.permutations import _af_commutes_with
+    if hasattr(other, 'generators'):
+        elements = list(self.generate_dimino(af=True))
+        gens = [x._array_form for x in other.generators]
+        commutes_with_gens = lambda x: all(_af_commutes_with(x, gen) for gen in gens)
+        centralizer_list = []
+        if not af:
+            for element in elements:
+                if commutes_with_gens(element):
+                    centralizer_list.append(Permutation._af_new(element))
+        else:
+            for element in elements:
+                if commutes_with_gens(element):
+                    centralizer_list.append(element)
+        return centralizer_list
+    elif hasattr(other, 'getitem'):
+        return _naive_list_centralizer(self, PermutationGroup(other), af)
+    elif hasattr(other, 'array_form'):
+        return _naive_list_centralizer(self, PermutationGroup([other]), af)
+
+
+def _verify_bsgs(group, base, gens):
+    """
+    Verify the correctness of a base and strong generating set.
+
+    Explanation
+    ===========
+
+    This is a naive implementation using the definition of a base and a strong
+    generating set relative to it. There are other procedures for
+    verifying a base and strong generating set, but this one will
+    serve for more robust testing.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import AlternatingGroup
+    >>> from sympy.combinatorics.testutil import _verify_bsgs
+    >>> A = AlternatingGroup(4)
+    >>> A.schreier_sims()
+    >>> _verify_bsgs(A, A.base, A.strong_gens)
+    True
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.schreier_sims
+
+    """
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    strong_gens_distr = _distribute_gens_by_base(base, gens)
+    current_stabilizer = group
+    for i in range(len(base)):
+        candidate = PermutationGroup(strong_gens_distr[i])
+        if current_stabilizer.order() != candidate.order():
+            return False
+        current_stabilizer = current_stabilizer.stabilizer(base[i])
+    if current_stabilizer.order() != 1:
+        return False
+    return True
+
+
+def _verify_centralizer(group, arg, centr=None):
+    """
+    Verify the centralizer of a group/set/element inside another group.
+
+    This is used for testing ``.centralizer()`` from
+    ``sympy.combinatorics.perm_groups``
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+    ... AlternatingGroup)
+    >>> from sympy.combinatorics.perm_groups import PermutationGroup
+    >>> from sympy.combinatorics.permutations import Permutation
+    >>> from sympy.combinatorics.testutil import _verify_centralizer
+    >>> S = SymmetricGroup(5)
+    >>> A = AlternatingGroup(5)
+    >>> centr = PermutationGroup([Permutation([0, 1, 2, 3, 4])])
+    >>> _verify_centralizer(S, A, centr)
+    True
+
+    See Also
+    ========
+
+    _naive_list_centralizer,
+    sympy.combinatorics.perm_groups.PermutationGroup.centralizer,
+    _cmp_perm_lists
+
+    """
+    if centr is None:
+        centr = group.centralizer(arg)
+    centr_list = list(centr.generate_dimino(af=True))
+    centr_list_naive = _naive_list_centralizer(group, arg, af=True)
+    return _cmp_perm_lists(centr_list, centr_list_naive)
+
+
+def _verify_normal_closure(group, arg, closure=None):
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    """
+    Verify the normal closure of a subgroup/subset/element in a group.
+
+    This is used to test
+    sympy.combinatorics.perm_groups.PermutationGroup.normal_closure
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import (SymmetricGroup,
+    ... AlternatingGroup)
+    >>> from sympy.combinatorics.testutil import _verify_normal_closure
+    >>> S = SymmetricGroup(3)
+    >>> A = AlternatingGroup(3)
+    >>> _verify_normal_closure(S, A, closure=A)
+    True
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.normal_closure
+
+    """
+    if closure is None:
+        closure = group.normal_closure(arg)
+    conjugates = set()
+    if hasattr(arg, 'generators'):
+        subgr_gens = arg.generators
+    elif hasattr(arg, '__getitem__'):
+        subgr_gens = arg
+    elif hasattr(arg, 'array_form'):
+        subgr_gens = [arg]
+    for el in group.generate_dimino():
+        conjugates.update(gen ^ el for gen in subgr_gens)
+    naive_closure = PermutationGroup(list(conjugates))
+    return closure.is_subgroup(naive_closure)
+
+
+def canonicalize_naive(g, dummies, sym, *v):
+    """
+    Canonicalize tensor formed by tensors of the different types.
+
+    Explanation
+    ===========
+
+    sym_i symmetry under exchange of two component tensors of type `i`
+          None  no symmetry
+          0     commuting
+          1     anticommuting
+
+    Parameters
+    ==========
+
+    g : Permutation representing the tensor.
+    dummies : List of dummy indices.
+    msym : Symmetry of the metric.
+    v : A list of (base_i, gens_i, n_i, sym_i) for tensors of type `i`.
+        base_i, gens_i BSGS for tensors of this type
+        n_i  number of tensors of type `i`
+
+    Returns
+    =======
+
+    Returns 0 if the tensor is zero, else returns the array form of
+    the permutation representing the canonical form of the tensor.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import canonicalize_naive
+    >>> from sympy.combinatorics.tensor_can import get_symmetric_group_sgs
+    >>> from sympy.combinatorics import Permutation
+    >>> g = Permutation([1, 3, 2, 0, 4, 5])
+    >>> base2, gens2 = get_symmetric_group_sgs(2)
+    >>> canonicalize_naive(g, [2, 3], 0, (base2, gens2, 2, 0))
+    [0, 2, 1, 3, 4, 5]
+    """
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    from sympy.combinatorics.tensor_can import gens_products, dummy_sgs
+    from sympy.combinatorics.permutations import _af_rmul
+    v1 = []
+    for i in range(len(v)):
+        base_i, gens_i, n_i, sym_i = v[i]
+        v1.append((base_i, gens_i, [[]]*n_i, sym_i))
+    size, sbase, sgens = gens_products(*v1)
+    dgens = dummy_sgs(dummies, sym, size-2)
+    if isinstance(sym, int):
+        num_types = 1
+        dummies = [dummies]
+        sym = [sym]
+    else:
+        num_types = len(sym)
+    dgens = []
+    for i in range(num_types):
+        dgens.extend(dummy_sgs(dummies[i], sym[i], size - 2))
+    S = PermutationGroup(sgens)
+    D = PermutationGroup([Permutation(x) for x in dgens])
+    dlist = list(D.generate(af=True))
+    g = g.array_form
+    st = set()
+    for s in S.generate(af=True):
+        h = _af_rmul(g, s)
+        for d in dlist:
+            q = tuple(_af_rmul(d, h))
+            st.add(q)
+    a = list(st)
+    a.sort()
+    prev = (0,)*size
+    for h in a:
+        if h[:-2] == prev[:-2]:
+            if h[-1] != prev[-1]:
+                return 0
+        prev = h
+    return list(a[0])
+
+
+def graph_certificate(gr):
+    """
+    Return a certificate for the graph
+
+    Parameters
+    ==========
+
+    gr : adjacency list
+
+    Explanation
+    ===========
+
+    The graph is assumed to be unoriented and without
+    external lines.
+
+    Associate to each vertex of the graph a symmetric tensor with
+    number of indices equal to the degree of the vertex; indices
+    are contracted when they correspond to the same line of the graph.
+    The canonical form of the tensor gives a certificate for the graph.
+
+    This is not an efficient algorithm to get the certificate of a graph.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.testutil import graph_certificate
+    >>> gr1 = {0:[1, 2, 3, 5], 1:[0, 2, 4], 2:[0, 1, 3, 4], 3:[0, 2, 4], 4:[1, 2, 3, 5], 5:[0, 4]}
+    >>> gr2 = {0:[1, 5], 1:[0, 2, 3, 4], 2:[1, 3, 5], 3:[1, 2, 4, 5], 4:[1, 3, 5], 5:[0, 2, 3, 4]}
+    >>> c1 = graph_certificate(gr1)
+    >>> c2 = graph_certificate(gr2)
+    >>> c1
+    [0, 2, 4, 6, 1, 8, 10, 12, 3, 14, 16, 18, 5, 9, 15, 7, 11, 17, 13, 19, 20, 21]
+    >>> c1 == c2
+    True
+    """
+    from sympy.combinatorics.permutations import _af_invert
+    from sympy.combinatorics.tensor_can import get_symmetric_group_sgs, canonicalize
+    items = list(gr.items())
+    items.sort(key=lambda x: len(x[1]), reverse=True)
+    pvert = [x[0] for x in items]
+    pvert = _af_invert(pvert)
+
+    # the indices of the tensor are twice the number of lines of the graph
+    num_indices = 0
+    for v, neigh in items:
+        num_indices += len(neigh)
+    # associate to each vertex its indices; for each line
+    # between two vertices assign the
+    # even index to the vertex which comes first in items,
+    # the odd index to the other vertex
+    vertices = [[] for i in items]
+    i = 0
+    for v, neigh in items:
+        for v2 in neigh:
+            if pvert[v] < pvert[v2]:
+                vertices[pvert[v]].append(i)
+                vertices[pvert[v2]].append(i+1)
+                i += 2
+    g = []
+    for v in vertices:
+        g.extend(v)
+    assert len(g) == num_indices
+    g += [num_indices, num_indices + 1]
+    size = num_indices + 2
+    assert sorted(g) == list(range(size))
+    g = Permutation(g)
+    vlen = [0]*(len(vertices[0])+1)
+    for neigh in vertices:
+        vlen[len(neigh)] += 1
+    v = []
+    for i in range(len(vlen)):
+        n = vlen[i]
+        if n:
+            base, gens = get_symmetric_group_sgs(i)
+            v.append((base, gens, n, 0))
+    v.reverse()
+    dummies = list(range(num_indices))
+    can = canonicalize(g, dummies, 0, *v)
+    return can
diff --git a/.venv/lib/python3.12/site-packages/sympy/combinatorics/util.py b/.venv/lib/python3.12/site-packages/sympy/combinatorics/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc73b02f94f4aae6f1b98bb3f0c837fd5a1d1e6d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/combinatorics/util.py
@@ -0,0 +1,532 @@
+from sympy.combinatorics.permutations import Permutation, _af_invert, _af_rmul
+from sympy.ntheory import isprime
+
+rmul = Permutation.rmul
+_af_new = Permutation._af_new
+
+############################################
+#
+# Utilities for computational group theory
+#
+############################################
+
+
+def _base_ordering(base, degree):
+    r"""
+    Order `\{0, 1, \dots, n-1\}` so that base points come first and in order.
+
+    Parameters
+    ==========
+
+    base : the base
+    degree : the degree of the associated permutation group
+
+    Returns
+    =======
+
+    A list ``base_ordering`` such that ``base_ordering[point]`` is the
+    number of ``point`` in the ordering.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import SymmetricGroup
+    >>> from sympy.combinatorics.util import _base_ordering
+    >>> S = SymmetricGroup(4)
+    >>> S.schreier_sims()
+    >>> _base_ordering(S.base, S.degree)
+    [0, 1, 2, 3]
+
+    Notes
+    =====
+
+    This is used in backtrack searches, when we define a relation `\ll` on
+    the underlying set for a permutation group of degree `n`,
+    `\{0, 1, \dots, n-1\}`, so that if `(b_1, b_2, \dots, b_k)` is a base we
+    have `b_i \ll b_j` whenever `i>> from sympy.combinatorics.util import _check_cycles_alt_sym
+    >>> from sympy.combinatorics import Permutation
+    >>> a = Permutation([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [11, 12]])
+    >>> _check_cycles_alt_sym(a)
+    False
+    >>> b = Permutation([[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10]])
+    >>> _check_cycles_alt_sym(b)
+    True
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.is_alt_sym
+
+    """
+    n = perm.size
+    af = perm.array_form
+    current_len = 0
+    total_len = 0
+    used = set()
+    for i in range(n//2):
+        if i not in used and i < n//2 - total_len:
+            current_len = 1
+            used.add(i)
+            j = i
+            while af[j] != i:
+                current_len += 1
+                j = af[j]
+                used.add(j)
+            total_len += current_len
+            if current_len > n//2 and current_len < n - 2 and isprime(current_len):
+                return True
+    return False
+
+
+def _distribute_gens_by_base(base, gens):
+    r"""
+    Distribute the group elements ``gens`` by membership in basic stabilizers.
+
+    Explanation
+    ===========
+
+    Notice that for a base `(b_1, b_2, \dots, b_k)`, the basic stabilizers
+    are defined as `G^{(i)} = G_{b_1, \dots, b_{i-1}}` for
+    `i \in\{1, 2, \dots, k\}`.
+
+    Parameters
+    ==========
+
+    base : a sequence of points in `\{0, 1, \dots, n-1\}`
+    gens : a list of elements of a permutation group of degree `n`.
+
+    Returns
+    =======
+    list
+        List of length `k`, where `k` is the length of *base*. The `i`-th entry
+        contains those elements in *gens* which fix the first `i` elements of
+        *base* (so that the `0`-th entry is equal to *gens* itself). If no
+        element fixes the first `i` elements of *base*, the `i`-th element is
+        set to a list containing the identity element.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> from sympy.combinatorics.util import _distribute_gens_by_base
+    >>> D = DihedralGroup(3)
+    >>> D.schreier_sims()
+    >>> D.strong_gens
+    [(0 1 2), (0 2), (1 2)]
+    >>> D.base
+    [0, 1]
+    >>> _distribute_gens_by_base(D.base, D.strong_gens)
+    [[(0 1 2), (0 2), (1 2)],
+     [(1 2)]]
+
+    See Also
+    ========
+
+    _strong_gens_from_distr, _orbits_transversals_from_bsgs,
+    _handle_precomputed_bsgs
+
+    """
+    base_len = len(base)
+    degree = gens[0].size
+    stabs = [[] for _ in range(base_len)]
+    max_stab_index = 0
+    for gen in gens:
+        j = 0
+        while j < base_len - 1 and gen._array_form[base[j]] == base[j]:
+            j += 1
+        if j > max_stab_index:
+            max_stab_index = j
+        for k in range(j + 1):
+            stabs[k].append(gen)
+    for i in range(max_stab_index + 1, base_len):
+        stabs[i].append(_af_new(list(range(degree))))
+    return stabs
+
+
+def _handle_precomputed_bsgs(base, strong_gens, transversals=None,
+                             basic_orbits=None, strong_gens_distr=None):
+    """
+    Calculate BSGS-related structures from those present.
+
+    Explanation
+    ===========
+
+    The base and strong generating set must be provided; if any of the
+    transversals, basic orbits or distributed strong generators are not
+    provided, they will be calculated from the base and strong generating set.
+
+    Parameters
+    ==========
+
+    base : the base
+    strong_gens : the strong generators
+    transversals : basic transversals
+    basic_orbits : basic orbits
+    strong_gens_distr : strong generators distributed by membership in basic stabilizers
+
+    Returns
+    =======
+
+    (transversals, basic_orbits, strong_gens_distr)
+        where *transversals* are the basic transversals, *basic_orbits* are the
+        basic orbits, and *strong_gens_distr* are the strong generators distributed
+        by membership in basic stabilizers.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics.named_groups import DihedralGroup
+    >>> from sympy.combinatorics.util import _handle_precomputed_bsgs
+    >>> D = DihedralGroup(3)
+    >>> D.schreier_sims()
+    >>> _handle_precomputed_bsgs(D.base, D.strong_gens,
+    ... basic_orbits=D.basic_orbits)
+    ([{0: (2), 1: (0 1 2), 2: (0 2)}, {1: (2), 2: (1 2)}], [[0, 1, 2], [1, 2]], [[(0 1 2), (0 2), (1 2)], [(1 2)]])
+
+    See Also
+    ========
+
+    _orbits_transversals_from_bsgs, _distribute_gens_by_base
+
+    """
+    if strong_gens_distr is None:
+        strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    if transversals is None:
+        if basic_orbits is None:
+            basic_orbits, transversals = \
+                _orbits_transversals_from_bsgs(base, strong_gens_distr)
+        else:
+            transversals = \
+                _orbits_transversals_from_bsgs(base, strong_gens_distr,
+                                           transversals_only=True)
+    else:
+        if basic_orbits is None:
+            base_len = len(base)
+            basic_orbits = [None]*base_len
+            for i in range(base_len):
+                basic_orbits[i] = list(transversals[i].keys())
+    return transversals, basic_orbits, strong_gens_distr
+
+
+def _orbits_transversals_from_bsgs(base, strong_gens_distr,
+                                   transversals_only=False, slp=False):
+    """
+    Compute basic orbits and transversals from a base and strong generating set.
+
+    Explanation
+    ===========
+
+    The generators are provided as distributed across the basic stabilizers.
+    If the optional argument ``transversals_only`` is set to True, only the
+    transversals are returned.
+
+    Parameters
+    ==========
+
+    base : The base.
+    strong_gens_distr : Strong generators distributed by membership in basic stabilizers.
+    transversals_only : bool, default: False
+        A flag switching between returning only the
+        transversals and both orbits and transversals.
+    slp : bool, default: False
+        If ``True``, return a list of dictionaries containing the
+        generator presentations of the elements of the transversals,
+        i.e. the list of indices of generators from ``strong_gens_distr[i]``
+        such that their product is the relevant transversal element.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import SymmetricGroup
+    >>> from sympy.combinatorics.util import _distribute_gens_by_base
+    >>> S = SymmetricGroup(3)
+    >>> S.schreier_sims()
+    >>> strong_gens_distr = _distribute_gens_by_base(S.base, S.strong_gens)
+    >>> (S.base, strong_gens_distr)
+    ([0, 1], [[(0 1 2), (2)(0 1), (1 2)], [(1 2)]])
+
+    See Also
+    ========
+
+    _distribute_gens_by_base, _handle_precomputed_bsgs
+
+    """
+    from sympy.combinatorics.perm_groups import _orbit_transversal
+    base_len = len(base)
+    degree = strong_gens_distr[0][0].size
+    transversals = [None]*base_len
+    slps = [None]*base_len
+    if transversals_only is False:
+        basic_orbits = [None]*base_len
+    for i in range(base_len):
+        transversals[i], slps[i] = _orbit_transversal(degree, strong_gens_distr[i],
+                                 base[i], pairs=True, slp=True)
+        transversals[i] = dict(transversals[i])
+        if transversals_only is False:
+            basic_orbits[i] = list(transversals[i].keys())
+    if transversals_only:
+        return transversals
+    else:
+        if not slp:
+            return basic_orbits, transversals
+        return basic_orbits, transversals, slps
+
+
+def _remove_gens(base, strong_gens, basic_orbits=None, strong_gens_distr=None):
+    """
+    Remove redundant generators from a strong generating set.
+
+    Parameters
+    ==========
+
+    base : a base
+    strong_gens : a strong generating set relative to *base*
+    basic_orbits : basic orbits
+    strong_gens_distr : strong generators distributed by membership in basic stabilizers
+
+    Returns
+    =======
+
+    A strong generating set with respect to ``base`` which is a subset of
+    ``strong_gens``.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import SymmetricGroup
+    >>> from sympy.combinatorics.util import _remove_gens
+    >>> from sympy.combinatorics.testutil import _verify_bsgs
+    >>> S = SymmetricGroup(15)
+    >>> base, strong_gens = S.schreier_sims_incremental()
+    >>> new_gens = _remove_gens(base, strong_gens)
+    >>> len(new_gens)
+    14
+    >>> _verify_bsgs(S, base, new_gens)
+    True
+
+    Notes
+    =====
+
+    This procedure is outlined in [1],p.95.
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E.
+           "Handbook of computational group theory"
+
+    """
+    from sympy.combinatorics.perm_groups import _orbit
+    base_len = len(base)
+    degree = strong_gens[0].size
+    if strong_gens_distr is None:
+        strong_gens_distr = _distribute_gens_by_base(base, strong_gens)
+    if basic_orbits is None:
+        basic_orbits = []
+        for i in range(base_len):
+            basic_orbit = _orbit(degree, strong_gens_distr[i], base[i])
+            basic_orbits.append(basic_orbit)
+    strong_gens_distr.append([])
+    res = strong_gens[:]
+    for i in range(base_len - 1, -1, -1):
+        gens_copy = strong_gens_distr[i][:]
+        for gen in strong_gens_distr[i]:
+            if gen not in strong_gens_distr[i + 1]:
+                temp_gens = gens_copy[:]
+                temp_gens.remove(gen)
+                if temp_gens == []:
+                    continue
+                temp_orbit = _orbit(degree, temp_gens, base[i])
+                if temp_orbit == basic_orbits[i]:
+                    gens_copy.remove(gen)
+                    res.remove(gen)
+    return res
+
+
+def _strip(g, base, orbits, transversals):
+    """
+    Attempt to decompose a permutation using a (possibly partial) BSGS
+    structure.
+
+    Explanation
+    ===========
+
+    This is done by treating the sequence ``base`` as an actual base, and
+    the orbits ``orbits`` and transversals ``transversals`` as basic orbits and
+    transversals relative to it.
+
+    This process is called "sifting". A sift is unsuccessful when a certain
+    orbit element is not found or when after the sift the decomposition
+    does not end with the identity element.
+
+    The argument ``transversals`` is a list of dictionaries that provides
+    transversal elements for the orbits ``orbits``.
+
+    Parameters
+    ==========
+
+    g : permutation to be decomposed
+    base : sequence of points
+    orbits : list
+        A list in which the ``i``-th entry is an orbit of ``base[i]``
+        under some subgroup of the pointwise stabilizer of `
+        `base[0], base[1], ..., base[i - 1]``. The groups themselves are implicit
+        in this function since the only information we need is encoded in the orbits
+        and transversals
+    transversals : list
+        A list of orbit transversals associated with the orbits *orbits*.
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import Permutation, SymmetricGroup
+    >>> from sympy.combinatorics.util import _strip
+    >>> S = SymmetricGroup(5)
+    >>> S.schreier_sims()
+    >>> g = Permutation([0, 2, 3, 1, 4])
+    >>> _strip(g, S.base, S.basic_orbits, S.basic_transversals)
+    ((4), 5)
+
+    Notes
+    =====
+
+    The algorithm is described in [1],pp.89-90. The reason for returning
+    both the current state of the element being decomposed and the level
+    at which the sifting ends is that they provide important information for
+    the randomized version of the Schreier-Sims algorithm.
+
+    References
+    ==========
+
+    .. [1] Holt, D., Eick, B., O'Brien, E."Handbook of computational group theory"
+
+    See Also
+    ========
+
+    sympy.combinatorics.perm_groups.PermutationGroup.schreier_sims
+    sympy.combinatorics.perm_groups.PermutationGroup.schreier_sims_random
+
+    """
+    h = g._array_form
+    base_len = len(base)
+    for i in range(base_len):
+        beta = h[base[i]]
+        if beta == base[i]:
+            continue
+        if beta not in orbits[i]:
+            return _af_new(h), i + 1
+        u = transversals[i][beta]._array_form
+        h = _af_rmul(_af_invert(u), h)
+    return _af_new(h), base_len + 1
+
+
+def _strip_af(h, base, orbits, transversals, j, slp=[], slps={}):
+    """
+    optimized _strip, with h, transversals and result in array form
+    if the stripped elements is the identity, it returns False, base_len + 1
+
+    j    h[base[i]] == base[i] for i <= j
+
+    """
+    base_len = len(base)
+    for i in range(j+1, base_len):
+        beta = h[base[i]]
+        if beta == base[i]:
+            continue
+        if beta not in orbits[i]:
+            if not slp:
+                return h, i + 1
+            return h, i + 1, slp
+        u = transversals[i][beta]
+        if h == u:
+            if not slp:
+                return False, base_len + 1
+            return False, base_len + 1, slp
+        h = _af_rmul(_af_invert(u), h)
+        if slp:
+            u_slp = slps[i][beta][:]
+            u_slp.reverse()
+            u_slp = [(i, (g,)) for g in u_slp]
+            slp = u_slp + slp
+    if not slp:
+        return h, base_len + 1
+    return h, base_len + 1, slp
+
+
+def _strong_gens_from_distr(strong_gens_distr):
+    """
+    Retrieve strong generating set from generators of basic stabilizers.
+
+    This is just the union of the generators of the first and second basic
+    stabilizers.
+
+    Parameters
+    ==========
+
+    strong_gens_distr : strong generators distributed by membership in basic stabilizers
+
+    Examples
+    ========
+
+    >>> from sympy.combinatorics import SymmetricGroup
+    >>> from sympy.combinatorics.util import (_strong_gens_from_distr,
+    ... _distribute_gens_by_base)
+    >>> S = SymmetricGroup(3)
+    >>> S.schreier_sims()
+    >>> S.strong_gens
+    [(0 1 2), (2)(0 1), (1 2)]
+    >>> strong_gens_distr = _distribute_gens_by_base(S.base, S.strong_gens)
+    >>> _strong_gens_from_distr(strong_gens_distr)
+    [(0 1 2), (2)(0 1), (1 2)]
+
+    See Also
+    ========
+
+    _distribute_gens_by_base
+
+    """
+    if len(strong_gens_distr) == 1:
+        return strong_gens_distr[0][:]
+    else:
+        result = strong_gens_distr[0]
+        for gen in strong_gens_distr[1]:
+            if gen not in result:
+                result.append(gen)
+        return result
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__init__.py b/.venv/lib/python3.12/site-packages/sympy/concrete/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7048bd548cca04780479539339dd8cc49a21990f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/__init__.py
@@ -0,0 +1,8 @@
+from .products import product, Product
+from .summations import summation, Sum
+
+__all__ = [
+    'product', 'Product',
+
+    'summation', 'Sum',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a610b9f33f5c5e15cc5738499575f5f0ff905d3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/delta.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/delta.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81ba9960258f419b1d3dcffb0ef050abb5a2c923
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/delta.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_intlimits.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_intlimits.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29cd0121d397a353fa8519f7281caf0d87cdfea1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_intlimits.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_limits.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_limits.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..695a51eca14e92f37372618a60ed35aa6bd8d314
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/expr_with_limits.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/gosper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/gosper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..622bacc394ce3267ce49d4cac6bf1114fe31f30b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/gosper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/guess.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/guess.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f20443d4df9d21e8d5dcab4856e313bee25a1062
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/guess.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/products.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/products.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8dc9d810b9a9ff1fdcf6e91b4b2e219b28bc66a1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/products.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/summations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/summations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65cd93454dc88373bacd277b9ee12512982b8697
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/__pycache__/summations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/delta.py b/.venv/lib/python3.12/site-packages/sympy/concrete/delta.py
new file mode 100644
index 0000000000000000000000000000000000000000..0471d2b2891a66a1b97b7a3a37bbd31d7b173a81
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/delta.py
@@ -0,0 +1,327 @@
+"""
+This module implements sums and products containing the Kronecker Delta function.
+
+References
+==========
+
+.. [1] https://mathworld.wolfram.com/KroneckerDelta.html
+
+"""
+from .products import product
+from .summations import Sum, summation
+from sympy.core import Add, Mul, S, Dummy
+from sympy.core.cache import cacheit
+from sympy.core.sorting import default_sort_key
+from sympy.functions import KroneckerDelta, Piecewise, piecewise_fold
+from sympy.polys.polytools import factor
+from sympy.sets.sets import Interval
+from sympy.solvers.solvers import solve
+
+
+@cacheit
+def _expand_delta(expr, index):
+    """
+    Expand the first Add containing a simple KroneckerDelta.
+    """
+    if not expr.is_Mul:
+        return expr
+    delta = None
+    func = Add
+    terms = [S.One]
+    for h in expr.args:
+        if delta is None and h.is_Add and _has_simple_delta(h, index):
+            delta = True
+            func = h.func
+            terms = [terms[0]*t for t in h.args]
+        else:
+            terms = [t*h for t in terms]
+    return func(*terms)
+
+
+@cacheit
+def _extract_delta(expr, index):
+    """
+    Extract a simple KroneckerDelta from the expression.
+
+    Explanation
+    ===========
+
+    Returns the tuple ``(delta, newexpr)`` where:
+
+      - ``delta`` is a simple KroneckerDelta expression if one was found,
+        or ``None`` if no simple KroneckerDelta expression was found.
+
+      - ``newexpr`` is a Mul containing the remaining terms; ``expr`` is
+        returned unchanged if no simple KroneckerDelta expression was found.
+
+    Examples
+    ========
+
+    >>> from sympy import KroneckerDelta
+    >>> from sympy.concrete.delta import _extract_delta
+    >>> from sympy.abc import x, y, i, j, k
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), i)
+    (KroneckerDelta(i, j), 4*x*y)
+    >>> _extract_delta(4*x*y*KroneckerDelta(i, j), k)
+    (None, 4*x*y*KroneckerDelta(i, j))
+
+    See Also
+    ========
+
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    deltaproduct
+    deltasummation
+    """
+    if not _has_simple_delta(expr, index):
+        return (None, expr)
+    if isinstance(expr, KroneckerDelta):
+        return (expr, S.One)
+    if not expr.is_Mul:
+        raise ValueError("Incorrect expr")
+    delta = None
+    terms = []
+
+    for arg in expr.args:
+        if delta is None and _is_simple_delta(arg, index):
+            delta = arg
+        else:
+            terms.append(arg)
+    return (delta, expr.func(*terms))
+
+
+@cacheit
+def _has_simple_delta(expr, index):
+    """
+    Returns True if ``expr`` is an expression that contains a KroneckerDelta
+    that is simple in the index ``index``, meaning that this KroneckerDelta
+    is nonzero for a single value of the index ``index``.
+    """
+    if expr.has(KroneckerDelta):
+        if _is_simple_delta(expr, index):
+            return True
+        if expr.is_Add or expr.is_Mul:
+            return any(_has_simple_delta(arg, index) for arg in expr.args)
+    return False
+
+
+@cacheit
+def _is_simple_delta(delta, index):
+    """
+    Returns True if ``delta`` is a KroneckerDelta and is nonzero for a single
+    value of the index ``index``.
+    """
+    if isinstance(delta, KroneckerDelta) and delta.has(index):
+        p = (delta.args[0] - delta.args[1]).as_poly(index)
+        if p:
+            return p.degree() == 1
+    return False
+
+
+@cacheit
+def _remove_multiple_delta(expr):
+    """
+    Evaluate products of KroneckerDelta's.
+    """
+    if expr.is_Add:
+        return expr.func(*list(map(_remove_multiple_delta, expr.args)))
+    if not expr.is_Mul:
+        return expr
+    eqs = []
+    newargs = []
+    for arg in expr.args:
+        if isinstance(arg, KroneckerDelta):
+            eqs.append(arg.args[0] - arg.args[1])
+        else:
+            newargs.append(arg)
+    if not eqs:
+        return expr
+    solns = solve(eqs, dict=True)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) == 1:
+        newargs += [KroneckerDelta(k, v) for k, v in solns[0].items()]
+        expr2 = expr.func(*newargs)
+        if expr != expr2:
+            return _remove_multiple_delta(expr2)
+    return expr
+
+
+@cacheit
+def _simplify_delta(expr):
+    """
+    Rewrite a KroneckerDelta's indices in its simplest form.
+    """
+    if isinstance(expr, KroneckerDelta):
+        try:
+            slns = solve(expr.args[0] - expr.args[1], dict=True)
+            if slns and len(slns) == 1:
+                return Mul(*[KroneckerDelta(*(key, value))
+                            for key, value in slns[0].items()])
+        except NotImplementedError:
+            pass
+    return expr
+
+
+@cacheit
+def deltaproduct(f, limit):
+    """
+    Handle products containing a KroneckerDelta.
+
+    See Also
+    ========
+
+    deltasummation
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.products.product
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.One
+
+    if not f.has(KroneckerDelta):
+        return product(f, limit)
+
+    if f.is_Add:
+        # Identify the term in the Add that has a simple KroneckerDelta
+        delta = None
+        terms = []
+        for arg in sorted(f.args, key=default_sort_key):
+            if delta is None and _has_simple_delta(arg, limit[0]):
+                delta = arg
+            else:
+                terms.append(arg)
+        newexpr = f.func(*terms)
+        k = Dummy("kprime", integer=True)
+        if isinstance(limit[1], int) and isinstance(limit[2], int):
+            result = deltaproduct(newexpr, limit) + sum(deltaproduct(newexpr, (limit[0], limit[1], ik - 1)) *
+                delta.subs(limit[0], ik) *
+                deltaproduct(newexpr, (limit[0], ik + 1, limit[2])) for ik in range(int(limit[1]), int(limit[2] + 1))
+            )
+        else:
+            result = deltaproduct(newexpr, limit) + deltasummation(
+                deltaproduct(newexpr, (limit[0], limit[1], k - 1)) *
+                delta.subs(limit[0], k) *
+                deltaproduct(newexpr, (limit[0], k + 1, limit[2])),
+                (k, limit[1], limit[2]),
+                no_piecewise=_has_simple_delta(newexpr, limit[0])
+            )
+        return _remove_multiple_delta(result)
+
+    delta, _ = _extract_delta(f, limit[0])
+
+    if not delta:
+        g = _expand_delta(f, limit[0])
+        if f != g:
+            try:
+                return factor(deltaproduct(g, limit))
+            except AssertionError:
+                return deltaproduct(g, limit)
+        return product(f, limit)
+
+    return _remove_multiple_delta(f.subs(limit[0], limit[1])*KroneckerDelta(limit[2], limit[1])) + \
+        S.One*_simplify_delta(KroneckerDelta(limit[2], limit[1] - 1))
+
+
+@cacheit
+def deltasummation(f, limit, no_piecewise=False):
+    """
+    Handle summations containing a KroneckerDelta.
+
+    Explanation
+    ===========
+
+    The idea for summation is the following:
+
+    - If we are dealing with a KroneckerDelta expression, i.e. KroneckerDelta(g(x), j),
+      we try to simplify it.
+
+      If we could simplify it, then we sum the resulting expression.
+      We already know we can sum a simplified expression, because only
+      simple KroneckerDelta expressions are involved.
+
+      If we could not simplify it, there are two cases:
+
+      1) The expression is a simple expression: we return the summation,
+         taking care if we are dealing with a Derivative or with a proper
+         KroneckerDelta.
+
+      2) The expression is not simple (i.e. KroneckerDelta(cos(x))): we can do
+         nothing at all.
+
+    - If the expr is a multiplication expr having a KroneckerDelta term:
+
+      First we expand it.
+
+      If the expansion did work, then we try to sum the expansion.
+
+      If not, we try to extract a simple KroneckerDelta term, then we have two
+      cases:
+
+      1) We have a simple KroneckerDelta term, so we return the summation.
+
+      2) We did not have a simple term, but we do have an expression with
+         simplified KroneckerDelta terms, so we sum this expression.
+
+    Examples
+    ========
+
+    >>> from sympy import oo, symbols
+    >>> from sympy.abc import k
+    >>> i, j = symbols('i, j', integer=True, finite=True)
+    >>> from sympy.concrete.delta import deltasummation
+    >>> from sympy import KroneckerDelta
+    >>> deltasummation(KroneckerDelta(i, k), (k, -oo, oo))
+    1
+    >>> deltasummation(KroneckerDelta(i, k), (k, 0, oo))
+    Piecewise((1, i >= 0), (0, True))
+    >>> deltasummation(KroneckerDelta(i, k), (k, 1, 3))
+    Piecewise((1, (i >= 1) & (i <= 3)), (0, True))
+    >>> deltasummation(k*KroneckerDelta(i, j)*KroneckerDelta(j, k), (k, -oo, oo))
+    j*KroneckerDelta(i, j)
+    >>> deltasummation(j*KroneckerDelta(i, j), (j, -oo, oo))
+    i
+    >>> deltasummation(i*KroneckerDelta(i, j), (i, -oo, oo))
+    j
+
+    See Also
+    ========
+
+    deltaproduct
+    sympy.functions.special.tensor_functions.KroneckerDelta
+    sympy.concrete.sums.summation
+    """
+    if ((limit[2] - limit[1]) < 0) == True:
+        return S.Zero
+
+    if not f.has(KroneckerDelta):
+        return summation(f, limit)
+
+    x = limit[0]
+
+    g = _expand_delta(f, x)
+    if g.is_Add:
+        return piecewise_fold(
+            g.func(*[deltasummation(h, limit, no_piecewise) for h in g.args]))
+
+    # try to extract a simple KroneckerDelta term
+    delta, expr = _extract_delta(g, x)
+
+    if (delta is not None) and (delta.delta_range is not None):
+        dinf, dsup = delta.delta_range
+        if (limit[1] - dinf <= 0) == True and (limit[2] - dsup >= 0) == True:
+            no_piecewise = True
+
+    if not delta:
+        return summation(f, limit)
+
+    solns = solve(delta.args[0] - delta.args[1], x)
+    if len(solns) == 0:
+        return S.Zero
+    elif len(solns) != 1:
+        return Sum(f, limit)
+    value = solns[0]
+    if no_piecewise:
+        return expr.subs(x, value)
+    return Piecewise(
+        (expr.subs(x, value), Interval(*limit[1:3]).as_relational(value)),
+        (S.Zero, True)
+    )
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_intlimits.py b/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_intlimits.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e109913cdb2f3018096972b14651b990f4b985e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_intlimits.py
@@ -0,0 +1,354 @@
+from sympy.concrete.expr_with_limits import ExprWithLimits
+from sympy.core.singleton import S
+from sympy.core.relational import Eq
+
+class ReorderError(NotImplementedError):
+    """
+    Exception raised when trying to reorder dependent limits.
+    """
+    def __init__(self, expr, msg):
+        super().__init__(
+            "%s could not be reordered: %s." % (expr, msg))
+
+class ExprWithIntLimits(ExprWithLimits):
+    """
+    Superclass for Product and Sum.
+
+    See Also
+    ========
+
+    sympy.concrete.expr_with_limits.ExprWithLimits
+    sympy.concrete.products.Product
+    sympy.concrete.summations.Sum
+    """
+    __slots__ = ()
+
+    def change_index(self, var, trafo, newvar=None):
+        r"""
+        Change index of a Sum or Product.
+
+        Perform a linear transformation `x \mapsto a x + b` on the index variable
+        `x`. For `a` the only values allowed are `\pm 1`. A new variable to be used
+        after the change of index can also be specified.
+
+        Explanation
+        ===========
+
+        ``change_index(expr, var, trafo, newvar=None)`` where ``var`` specifies the
+        index variable `x` to transform. The transformation ``trafo`` must be linear
+        and given in terms of ``var``. If the optional argument ``newvar`` is
+        provided then ``var`` gets replaced by ``newvar`` in the final expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product, simplify
+        >>> from sympy.abc import x, y, a, b, c, d, u, v, i, j, k, l
+
+        >>> S = Sum(x, (x, a, b))
+        >>> S.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, x + 1, y)
+        >>> Sn
+        Sum(y - 1, (y, a + 1, b + 1))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, -x, y)
+        >>> Sn
+        Sum(-y, (y, -b, -a))
+        >>> Sn.doit()
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, x+u)
+        >>> Sn
+        Sum(-u + x, (x, a + u, b + u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> Sn = S.change_index(x, -x - u, y)
+        >>> Sn
+        Sum(-u - y, (y, -b - u, -a - u))
+        >>> Sn.doit()
+        -a**2/2 - a*u + a/2 + b**2/2 + b*u + b/2 - u*(-a + b + 1) + u
+        >>> simplify(Sn.doit())
+        -a**2/2 + a/2 + b**2/2 + b/2
+
+        >>> P = Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P
+        Product(i*j**2, (i, a, b), (j, c, d))
+        >>> P2 = P.change_index(i, i+3, k)
+        >>> P2
+        Product(j**2*(k - 3), (k, a + 3, b + 3), (j, c, d))
+        >>> P3 = P2.change_index(j, -j, l)
+        >>> P3
+        Product(l**2*(k - 3), (k, a + 3, b + 3), (l, -d, -c))
+
+        When dealing with symbols only, we can make a
+        general linear transformation:
+
+        >>> Sn = S.change_index(x, u*x+v, y)
+        >>> Sn
+        Sum((-v + y)/u, (y, b*u + v, a*u + v))
+        >>> Sn.doit()
+        -v*(a*u - b*u + 1)/u + (a**2*u**2/2 + a*u*v + a*u/2 - b**2*u**2/2 - b*u*v + b*u/2 + v)/u
+        >>> simplify(Sn.doit())
+        a**2*u/2 + a/2 - b**2*u/2 + b/2
+
+        However, the last result can be inconsistent with usual
+        summation where the index increment is always 1. This is
+        obvious as we get back the original value only for ``u``
+        equal +1 or -1.
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder,
+        sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        if newvar is None:
+            newvar = var
+
+        limits = []
+        for limit in self.limits:
+            if limit[0] == var:
+                p = trafo.as_poly(var)
+                if p.degree() != 1:
+                    raise ValueError("Index transformation is not linear")
+                alpha = p.coeff_monomial(var)
+                beta = p.coeff_monomial(S.One)
+                if alpha.is_number:
+                    if alpha == S.One:
+                        limits.append((newvar, alpha*limit[1] + beta, alpha*limit[2] + beta))
+                    elif alpha == S.NegativeOne:
+                        limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+                    else:
+                        raise ValueError("Linear transformation results in non-linear summation stepsize")
+                else:
+                    # Note that the case of alpha being symbolic can give issues if alpha < 0.
+                    limits.append((newvar, alpha*limit[2] + beta, alpha*limit[1] + beta))
+            else:
+                limits.append(limit)
+
+        function = self.function.subs(var, (var - beta)/alpha)
+        function = function.subs(var, newvar)
+
+        return self.func(function, *limits)
+
+
+    def index(expr, x):
+        """
+        Return the index of a dummy variable in the list of limits.
+
+        Explanation
+        ===========
+
+        ``index(expr, x)``  returns the index of the dummy variable ``x`` in the
+        limits of ``expr``. Note that we start counting with 0 at the inner-most
+        limits tuple.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> from sympy import Sum, Product
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Sum(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(x)
+        0
+        >>> Product(x*y, (x, a, b), (y, c, d)).index(y)
+        1
+
+        See Also
+        ========
+
+        reorder_limit, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        variables = [limit[0] for limit in expr.limits]
+
+        if variables.count(x) != 1:
+            raise ValueError(expr, "Number of instances of variable not equal to one")
+        else:
+            return variables.index(x)
+
+    def reorder(expr, *arg):
+        """
+        Reorder limits in a expression containing a Sum or a Product.
+
+        Explanation
+        ===========
+
+        ``expr.reorder(*arg)`` reorders the limits in the expression ``expr``
+        according to the list of tuples given by ``arg``. These tuples can
+        contain numerical indices or index variable names or involve both.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((x, y))
+        Sum(x*y, (y, c, d), (x, a, b))
+
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder((x, y), (x, z), (y, z))
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        >>> P = Product(x*y*z, (x, a, b), (y, c, d), (z, e, f))
+        >>> P.reorder((x, y), (x, z), (y, z))
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        We can also select the index variables by counting them, starting
+        with the inner-most one:
+
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder((0, 1))
+        Sum(x**2, (x, c, d), (x, a, b))
+
+        And of course we can mix both schemes:
+
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x))
+        Sum(x*y, (y, c, d), (x, a, b))
+        >>> Sum(x*y, (x, a, b), (y, c, d)).reorder((y, 0))
+        Sum(x*y, (y, c, d), (x, a, b))
+
+        See Also
+        ========
+
+        reorder_limit, index, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        new_expr = expr
+
+        for r in arg:
+            if len(r) != 2:
+                raise ValueError(r, "Invalid number of arguments")
+
+            index1 = r[0]
+            index2 = r[1]
+
+            if not isinstance(r[0], int):
+                index1 = expr.index(r[0])
+            if not isinstance(r[1], int):
+                index2 = expr.index(r[1])
+
+            new_expr = new_expr.reorder_limit(index1, index2)
+
+        return new_expr
+
+
+    def reorder_limit(expr, x, y):
+        """
+        Interchange two limit tuples of a Sum or Product expression.
+
+        Explanation
+        ===========
+
+        ``expr.reorder_limit(x, y)`` interchanges two limit tuples. The
+        arguments ``x`` and ``y`` are integers corresponding to the index
+        variables of the two limits which are to be interchanged. The
+        expression ``expr`` has to be either a Sum or a Product.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z, a, b, c, d, e, f
+        >>> from sympy import Sum, Product
+
+        >>> Sum(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Sum(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+        >>> Sum(x**2, (x, a, b), (x, c, d)).reorder_limit(1, 0)
+        Sum(x**2, (x, c, d), (x, a, b))
+
+        >>> Product(x*y*z, (x, a, b), (y, c, d), (z, e, f)).reorder_limit(0, 2)
+        Product(x*y*z, (z, e, f), (y, c, d), (x, a, b))
+
+        See Also
+        ========
+
+        index, reorder, sympy.concrete.summations.Sum.reverse_order,
+        sympy.concrete.products.Product.reverse_order
+        """
+        var = {limit[0] for limit in expr.limits}
+        limit_x = expr.limits[x]
+        limit_y = expr.limits[y]
+
+        if (len(set(limit_x[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_x[2].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[1].free_symbols).intersection(var)) == 0 and
+            len(set(limit_y[2].free_symbols).intersection(var)) == 0):
+
+            limits = []
+            for i, limit in enumerate(expr.limits):
+                if i == x:
+                    limits.append(limit_y)
+                elif i == y:
+                    limits.append(limit_x)
+                else:
+                    limits.append(limit)
+
+            return type(expr)(expr.function, *limits)
+        else:
+            raise ReorderError(expr, "could not interchange the two limits specified")
+
+    @property
+    def has_empty_sequence(self):
+        """
+        Returns True if the Sum or Product is computed for an empty sequence.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Product, Symbol
+        >>> m = Symbol('m')
+        >>> Sum(m, (m, 1, 0)).has_empty_sequence
+        True
+
+        >>> Sum(m, (m, 1, 1)).has_empty_sequence
+        False
+
+        >>> M = Symbol('M', integer=True, positive=True)
+        >>> Product(m, (m, 1, M)).has_empty_sequence
+        False
+
+        >>> Product(m, (m, 2, M)).has_empty_sequence
+
+        >>> Product(m, (m, M + 1, M)).has_empty_sequence
+        True
+
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+
+        >>> N = Symbol('N', integer=True, negative=True)
+        >>> Sum(m, (m, N, M)).has_empty_sequence
+        False
+
+        See Also
+        ========
+
+        has_reversed_limits
+        has_finite_limits
+
+        """
+        ret_None = False
+        for lim in self.limits:
+            dif = lim[1] - lim[2]
+            eq = Eq(dif, 1)
+            if eq == True:
+                return True
+            elif eq == False:
+                continue
+            else:
+                ret_None = True
+
+        if ret_None:
+            return None
+        return False
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_limits.py b/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_limits.py
new file mode 100644
index 0000000000000000000000000000000000000000..034e6ab0a7663525632abe0224fbac973c505c08
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/expr_with_limits.py
@@ -0,0 +1,603 @@
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.expr import Expr
+from sympy.core.function import AppliedUndef, UndefinedFunction
+from sympy.core.mul import Mul
+from sympy.core.relational import Equality, Relational
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import (piecewise_fold,
+    Piecewise)
+from sympy.logic.boolalg import BooleanFunction
+from sympy.matrices.matrixbase import MatrixBase
+from sympy.sets.sets import Interval, Set
+from sympy.sets.fancysets import Range
+from sympy.tensor.indexed import Idx
+from sympy.utilities import flatten
+from sympy.utilities.iterables import sift, is_sequence
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+def _common_new(cls, function, *symbols, discrete, **assumptions):
+    """Return either a special return value or the tuple,
+    (function, limits, orientation). This code is common to
+    both ExprWithLimits and AddWithLimits."""
+    function = sympify(function)
+
+    if isinstance(function, Equality):
+        # This transforms e.g. Integral(Eq(x, y)) to Eq(Integral(x), Integral(y))
+        # but that is only valid for definite integrals.
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        if not (limits and all(len(limit) == 3 for limit in limits)):
+            sympy_deprecation_warning(
+                """
+                Creating a indefinite integral with an Eq() argument is
+                deprecated.
+
+                This is because indefinite integrals do not preserve equality
+                due to the arbitrary constants. If you want an equality of
+                indefinite integrals, use Eq(Integral(a, x), Integral(b, x))
+                explicitly.
+                """,
+                deprecated_since_version="1.6",
+                active_deprecations_target="deprecated-indefinite-integral-eq",
+                stacklevel=5,
+            )
+
+        lhs = function.lhs
+        rhs = function.rhs
+        return Equality(cls(lhs, *symbols, **assumptions), \
+                        cls(rhs, *symbols, **assumptions))
+
+    if function is S.NaN:
+        return S.NaN
+
+    if symbols:
+        limits, orientation = _process_limits(*symbols, discrete=discrete)
+        for i, li in enumerate(limits):
+            if len(li) == 4:
+                function = function.subs(li[0], li[-1])
+                limits[i] = Tuple(*li[:-1])
+    else:
+        # symbol not provided -- we can still try to compute a general form
+        free = function.free_symbols
+        if len(free) != 1:
+            raise ValueError(
+                "specify dummy variables for %s" % function)
+        limits, orientation = [Tuple(s) for s in free], 1
+
+    # denest any nested calls
+    while cls == type(function):
+        limits = list(function.limits) + limits
+        function = function.function
+
+    # Any embedded piecewise functions need to be brought out to the
+    # top level. We only fold Piecewise that contain the integration
+    # variable.
+    reps = {}
+    symbols_of_integration = {i[0] for i in limits}
+    for p in function.atoms(Piecewise):
+        if not p.has(*symbols_of_integration):
+            reps[p] = Dummy()
+    # mask off those that don't
+    function = function.xreplace(reps)
+    # do the fold
+    function = piecewise_fold(function)
+    # remove the masking
+    function = function.xreplace({v: k for k, v in reps.items()})
+
+    return function, limits, orientation
+
+
+def _process_limits(*symbols, discrete=None):
+    """Process the list of symbols and convert them to canonical limits,
+    storing them as Tuple(symbol, lower, upper). The orientation of
+    the function is also returned when the upper limit is missing
+    so (x, 1, None) becomes (x, None, 1) and the orientation is changed.
+    In the case that a limit is specified as (symbol, Range), a list of
+    length 4 may be returned if a change of variables is needed; the
+    expression that should replace the symbol in the expression is
+    the fourth element in the list.
+    """
+    limits = []
+    orientation = 1
+    if discrete is None:
+        err_msg = 'discrete must be True or False'
+    elif discrete:
+        err_msg = 'use Range, not Interval or Relational'
+    else:
+        err_msg = 'use Interval or Relational, not Range'
+    for V in symbols:
+        if isinstance(V, (Relational, BooleanFunction)):
+            if discrete:
+                raise TypeError(err_msg)
+            variable = V.atoms(Symbol).pop()
+            V = (variable, V.as_set())
+        elif isinstance(V, Symbol) or getattr(V, '_diff_wrt', False):
+            if isinstance(V, Idx):
+                if V.lower is None or V.upper is None:
+                    limits.append(Tuple(V))
+                else:
+                    limits.append(Tuple(V, V.lower, V.upper))
+            else:
+                limits.append(Tuple(V))
+            continue
+        if is_sequence(V) and not isinstance(V, Set):
+            if len(V) == 2 and isinstance(V[1], Set):
+                V = list(V)
+                if isinstance(V[1], Interval):  # includes Reals
+                    if discrete:
+                        raise TypeError(err_msg)
+                    V[1:] = V[1].inf, V[1].sup
+                elif isinstance(V[1], Range):
+                    if not discrete:
+                        raise TypeError(err_msg)
+                    lo = V[1].inf
+                    hi = V[1].sup
+                    dx = abs(V[1].step)  # direction doesn't matter
+                    if dx == 1:
+                        V[1:] = [lo, hi]
+                    else:
+                        if lo is not S.NegativeInfinity:
+                            V = [V[0]] + [0, (hi - lo)//dx, dx*V[0] + lo]
+                        else:
+                            V = [V[0]] + [0, S.Infinity, -dx*V[0] + hi]
+                else:
+                    # more complicated sets would require splitting, e.g.
+                    # Union(Interval(1, 3), interval(6,10))
+                    raise NotImplementedError(
+                        'expecting Range' if discrete else
+                        'Relational or single Interval' )
+            V = sympify(flatten(V))  # list of sympified elements/None
+            if isinstance(V[0], (Symbol, Idx)) or getattr(V[0], '_diff_wrt', False):
+                newsymbol = V[0]
+                if len(V) == 3:
+                    # general case
+                    if V[2] is None and V[1] is not None:
+                        orientation *= -1
+                    V = [newsymbol] + [i for i in V[1:] if i is not None]
+
+                lenV = len(V)
+                if not isinstance(newsymbol, Idx) or lenV == 3:
+                    if lenV == 4:
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 3:
+                        if isinstance(newsymbol, Idx):
+                            # Idx represents an integer which may have
+                            # specified values it can take on; if it is
+                            # given such a value, an error is raised here
+                            # if the summation would try to give it a larger
+                            # or smaller value than permitted. None and Symbolic
+                            # values will not raise an error.
+                            lo, hi = newsymbol.lower, newsymbol.upper
+                            try:
+                                if lo is not None and not bool(V[1] >= lo):
+                                    raise ValueError("Summation will set Idx value too low.")
+                            except TypeError:
+                                pass
+                            try:
+                                if hi is not None and not bool(V[2] <= hi):
+                                    raise ValueError("Summation will set Idx value too high.")
+                            except TypeError:
+                                pass
+                        limits.append(Tuple(*V))
+                        continue
+                    if lenV == 1 or (lenV == 2 and V[1] is None):
+                        limits.append(Tuple(newsymbol))
+                        continue
+                    elif lenV == 2:
+                        limits.append(Tuple(newsymbol, V[1]))
+                        continue
+
+        raise ValueError('Invalid limits given: %s' % str(symbols))
+
+    return limits, orientation
+
+
+class ExprWithLimits(Expr):
+    __slots__ = ('is_commutative',)
+
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.products import Product
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Product), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, _ = pre
+        else:
+            return pre
+
+        # limits must have upper and lower bounds; the indefinite form
+        # is not supported. This restriction does not apply to AddWithLimits
+        if any(len(l) != 3 or None in l for l in limits):
+            raise ValueError('ExprWithLimits requires values for lower and upper bounds.')
+
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [function]
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+
+        return obj
+
+    @property
+    def function(self):
+        """Return the function applied across limits.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x
+        >>> Integral(x**2, (x,)).function
+        x**2
+
+        See Also
+        ========
+
+        limits, variables, free_symbols
+        """
+        return self._args[0]
+
+    @property
+    def kind(self):
+        return self.function.kind
+
+    @property
+    def limits(self):
+        """Return the limits of expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i
+        >>> Integral(x**i, (i, 1, 3)).limits
+        ((i, 1, 3),)
+
+        See Also
+        ========
+
+        function, variables, free_symbols
+        """
+        return self._args[1:]
+
+    @property
+    def variables(self):
+        """Return a list of the limit variables.
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, i
+        >>> Sum(x**i, (i, 1, 3)).variables
+        [i]
+
+        See Also
+        ========
+
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits]
+
+    @property
+    def bound_symbols(self):
+        """Return only variables that are dummy variables.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, i, j, k
+        >>> Integral(x**i, (i, 1, 3), (j, 2), k).bound_symbols
+        [i, j]
+
+        See Also
+        ========
+
+        function, limits, free_symbols
+        as_dummy : Rename dummy variables
+        sympy.integrals.integrals.Integral.transform : Perform mapping on the dummy variable
+        """
+        return [l[0] for l in self.limits if len(l) != 1]
+
+    @property
+    def free_symbols(self):
+        """
+        This method returns the symbols in the object, excluding those
+        that take on a specific value (i.e. the dummy symbols).
+
+        Examples
+        ========
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y
+        >>> Sum(x, (x, y, 1)).free_symbols
+        {y}
+        """
+        # don't test for any special values -- nominal free symbols
+        # should be returned, e.g. don't return set() if the
+        # function is zero -- treat it like an unevaluated expression.
+        function, limits = self.function, self.limits
+        # mask off non-symbol integration variables that have
+        # more than themself as a free symbol
+        reps = {i[0]: i[0] if i[0].free_symbols == {i[0]} else Dummy()
+            for i in self.limits}
+        function = function.xreplace(reps)
+        isyms = function.free_symbols
+        for xab in limits:
+            v = reps[xab[0]]
+            if len(xab) == 1:
+                isyms.add(v)
+                continue
+            # take out the target symbol
+            if v in isyms:
+                isyms.remove(v)
+            # add in the new symbols
+            for i in xab[1:]:
+                isyms.update(i.free_symbols)
+        reps = {v: k for k, v in reps.items()}
+        return {reps.get(_, _) for _ in isyms}
+
+    @property
+    def is_number(self):
+        """Return True if the Sum has no free symbols, else False."""
+        return not self.free_symbols
+
+    def _eval_interval(self, x, a, b):
+        limits = [(i if i[0] != x else (x, a, b)) for i in self.limits]
+        integrand = self.function
+        return self.func(integrand, *limits)
+
+    def _eval_subs(self, old, new):
+        """
+        Perform substitutions over non-dummy variables
+        of an expression with limits.  Also, can be used
+        to specify point-evaluation of an abstract antiderivative.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, oo
+        >>> from sympy.abc import s, n
+        >>> Sum(1/n**s, (n, 1, oo)).subs(s, 2)
+        Sum(n**(-2), (n, 1, oo))
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x, a
+        >>> Integral(a*x**2, x).subs(x, 4)
+        Integral(a*x**2, (x, 4))
+
+        See Also
+        ========
+
+        variables : Lists the integration variables
+        transform : Perform mapping on the dummy variable for integrals
+        change_index : Perform mapping on the sum and product dummy variables
+
+        """
+        func, limits = self.function, list(self.limits)
+
+        # If one of the expressions we are replacing is used as a func index
+        # one of two things happens.
+        #   - the old variable first appears as a free variable
+        #     so we perform all free substitutions before it becomes
+        #     a func index.
+        #   - the old variable first appears as a func index, in
+        #     which case we ignore.  See change_index.
+
+        # Reorder limits to match standard mathematical practice for scoping
+        limits.reverse()
+
+        if not isinstance(old, Symbol) or \
+                old.free_symbols.intersection(self.free_symbols):
+            sub_into_func = True
+            for i, xab in enumerate(limits):
+                if 1 == len(xab) and old == xab[0]:
+                    if new._diff_wrt:
+                        xab = (new,)
+                    else:
+                        xab = (old, old)
+                limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                if len(xab[0].free_symbols.intersection(old.free_symbols)) != 0:
+                    sub_into_func = False
+                    break
+            if isinstance(old, (AppliedUndef, UndefinedFunction)):
+                sy2 = set(self.variables).intersection(set(new.atoms(Symbol)))
+                sy1 = set(self.variables).intersection(set(old.args))
+                if not sy2.issubset(sy1):
+                    raise ValueError(
+                        "substitution cannot create dummy dependencies")
+                sub_into_func = True
+            if sub_into_func:
+                func = func.subs(old, new)
+        else:
+            # old is a Symbol and a dummy variable of some limit
+            for i, xab in enumerate(limits):
+                if len(xab) == 3:
+                    limits[i] = Tuple(xab[0], *[l._subs(old, new) for l in xab[1:]])
+                    if old == xab[0]:
+                        break
+        # simplify redundant limits (x, x)  to (x, )
+        for i, xab in enumerate(limits):
+            if len(xab) == 2 and (xab[0] - xab[1]).is_zero:
+                limits[i] = Tuple(xab[0], )
+
+        # Reorder limits back to representation-form
+        limits.reverse()
+
+        return self.func(func, *limits)
+
+    @property
+    def has_finite_limits(self):
+        """
+        Returns True if the limits are known to be finite, either by the
+        explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be infinite, based on the bounds.
+        None if not enough information is available to determine.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 1, 8)).has_finite_limits
+        True
+
+        >>> Integral(x, (x, 1, oo)).has_finite_limits
+        False
+
+        >>> M = Symbol('M')
+        >>> Sum(x, (x, 1, M)).has_finite_limits
+
+        >>> N = Symbol('N', integer=True)
+        >>> Product(x, (x, 1, N)).has_finite_limits
+        True
+
+        See Also
+        ========
+
+        has_reversed_limits
+
+        """
+
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                if any(l.is_infinite for l in lim[1:]):
+                    # Any of the bounds are +/-oo
+                    return False
+                elif any(l.is_infinite is None for l in lim[1:]):
+                    # Maybe there are assumptions on the variable?
+                    if lim[0].is_infinite is None:
+                        ret_None = True
+            else:
+                if lim[0].is_infinite is None:
+                    ret_None = True
+
+        if ret_None:
+            return None
+        return True
+
+    @property
+    def has_reversed_limits(self):
+        """
+        Returns True if the limits are known to be in reversed order, either
+        by the explicit bounds, assumptions on the bounds, or assumptions on the
+        variables.  False if known to be in normal order, based on the bounds.
+        None if not enough information is available to determine.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Integral, Product, oo, Symbol
+        >>> x = Symbol('x')
+        >>> Sum(x, (x, 8, 1)).has_reversed_limits
+        True
+
+        >>> Sum(x, (x, 1, oo)).has_reversed_limits
+        False
+
+        >>> M = Symbol('M')
+        >>> Integral(x, (x, 1, M)).has_reversed_limits
+
+        >>> N = Symbol('N', integer=True, positive=True)
+        >>> Sum(x, (x, 1, N)).has_reversed_limits
+        False
+
+        >>> Product(x, (x, 2, N)).has_reversed_limits
+
+        >>> Product(x, (x, 2, N)).subs(N, N + 2).has_reversed_limits
+        False
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.has_empty_sequence
+
+        """
+        ret_None = False
+        for lim in self.limits:
+            if len(lim) == 3:
+                var, a, b = lim
+                dif = b - a
+                if dif.is_extended_negative:
+                    return True
+                elif dif.is_extended_nonnegative:
+                    continue
+                else:
+                    ret_None = True
+            else:
+                return None
+        if ret_None:
+            return None
+        return False
+
+
+class AddWithLimits(ExprWithLimits):
+    r"""Represents unevaluated oriented additions.
+        Parent class for Integral and Sum.
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, function, *symbols, **assumptions):
+        from sympy.concrete.summations import Sum
+        pre = _common_new(cls, function, *symbols,
+            discrete=issubclass(cls, Sum), **assumptions)
+        if isinstance(pre, tuple):
+            function, limits, orientation = pre
+        else:
+            return pre
+
+        obj = Expr.__new__(cls, **assumptions)
+        arglist = [orientation*function]  # orientation not used in ExprWithLimits
+        arglist.extend(limits)
+        obj._args = tuple(arglist)
+        obj.is_commutative = function.is_commutative  # limits already checked
+
+        return obj
+
+    def _eval_adjoint(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.adjoint(), *self.limits)
+        return None
+
+    def _eval_conjugate(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.conjugate(), *self.limits)
+        return None
+
+    def _eval_transpose(self):
+        if all(x.is_real for x in flatten(self.limits)):
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+
+    def _eval_factor(self, **hints):
+        if 1 == len(self.limits):
+            summand = self.function.factor(**hints)
+            if summand.is_Mul:
+                out = sift(summand.args, lambda w: w.is_commutative \
+                    and not set(self.variables) & w.free_symbols)
+                return Mul(*out[True])*self.func(Mul(*out[False]), \
+                    *self.limits)
+        else:
+            summand = self.func(self.function, *self.limits[0:-1]).factor()
+            if not summand.has(self.variables[-1]):
+                return self.func(1, [self.limits[-1]]).doit()*summand
+            elif isinstance(summand, Mul):
+                return self.func(summand, self.limits[-1]).factor()
+        return self
+
+    def _eval_expand_basic(self, **hints):
+        summand = self.function.expand(**hints)
+        force = hints.get('force', False)
+        if (summand.is_Add and (force or summand.is_commutative and
+                 self.has_finite_limits is not False)):
+            return Add(*[self.func(i, *self.limits) for i in summand.args])
+        elif isinstance(summand, MatrixBase):
+            return summand.applyfunc(lambda x: self.func(x, *self.limits))
+        elif summand != self.function:
+            return self.func(summand, *self.limits)
+        return self
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/gosper.py b/.venv/lib/python3.12/site-packages/sympy/concrete/gosper.py
new file mode 100644
index 0000000000000000000000000000000000000000..76eb20ef4f94bc6bff6324a1dcc09f90e05274b3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/gosper.py
@@ -0,0 +1,222 @@
+"""Gosper's algorithm for hypergeometric summation. """
+
+from sympy.core import S, Dummy, symbols
+from sympy.polys import Poly, parallel_poly_from_expr, factor
+from sympy.utilities.iterables import is_sequence
+
+
+def gosper_normal(f, g, n, polys=True):
+    r"""
+    Compute the Gosper's normal form of ``f`` and ``g``.
+
+    Explanation
+    ===========
+
+    Given relatively prime univariate polynomials ``f`` and ``g``,
+    rewrite their quotient to a normal form defined as follows:
+
+    .. math::
+        \frac{f(n)}{g(n)} = Z \cdot \frac{A(n) C(n+1)}{B(n) C(n)}
+
+    where ``Z`` is an arbitrary constant and ``A``, ``B``, ``C`` are
+    monic polynomials in ``n`` with the following properties:
+
+    1. `\gcd(A(n), B(n+h)) = 1 \forall h \in \mathbb{N}`
+    2. `\gcd(B(n), C(n+1)) = 1`
+    3. `\gcd(A(n), C(n)) = 1`
+
+    This normal form, or rational factorization in other words, is a
+    crucial step in Gosper's algorithm and in solving of difference
+    equations. It can be also used to decide if two hypergeometric
+    terms are similar or not.
+
+    This procedure will return a tuple containing elements of this
+    factorization in the form ``(Z*A, B, C)``.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_normal
+    >>> from sympy.abc import n
+
+    >>> gosper_normal(4*n+5, 2*(4*n+1)*(2*n+3), n, polys=False)
+    (1/4, n + 3/2, n + 1/4)
+
+    """
+    (p, q), opt = parallel_poly_from_expr(
+        (f, g), n, field=True, extension=True)
+
+    a, A = p.LC(), p.monic()
+    b, B = q.LC(), q.monic()
+
+    C, Z = A.one, a/b
+    h = Dummy('h')
+
+    D = Poly(n + h, n, h, domain=opt.domain)
+
+    R = A.resultant(B.compose(D))
+    roots = {r for r in R.ground_roots().keys() if r.is_Integer and r >= 0}
+    for i in sorted(roots):
+        d = A.gcd(B.shift(+i))
+
+        A = A.quo(d)
+        B = B.quo(d.shift(-i))
+
+        for j in range(1, i + 1):
+            C *= d.shift(-j)
+
+    A = A.mul_ground(Z)
+
+    if not polys:
+        A = A.as_expr()
+        B = B.as_expr()
+        C = C.as_expr()
+
+    return A, B, C
+
+
+def gosper_term(f, n):
+    r"""
+    Compute Gosper's hypergeometric term for ``f``.
+
+    Explanation
+    ===========
+
+    Suppose ``f`` is a hypergeometric term such that:
+
+    .. math::
+        s_n = \sum_{k=0}^{n-1} f_k
+
+    and `f_k` does not depend on `n`. Returns a hypergeometric
+    term `g_n` such that `g_{n+1} - g_n = f_n`.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_term
+    >>> from sympy import factorial
+    >>> from sympy.abc import n
+
+    >>> gosper_term((4*n + 1)*factorial(n)/factorial(2*n + 1), n)
+    (-n - 1/2)/(n + 1/4)
+
+    """
+    from sympy.simplify import hypersimp
+    r = hypersimp(f, n)
+
+    if r is None:
+        return None    # 'f' is *not* a hypergeometric term
+
+    p, q = r.as_numer_denom()
+
+    A, B, C = gosper_normal(p, q, n)
+    B = B.shift(-1)
+
+    N = S(A.degree())
+    M = S(B.degree())
+    K = S(C.degree())
+
+    if (N != M) or (A.LC() != B.LC()):
+        D = {K - max(N, M)}
+    elif not N:
+        D = {K - N + 1, S.Zero}
+    else:
+        D = {K - N + 1, (B.nth(N - 1) - A.nth(N - 1))/A.LC()}
+
+    for d in set(D):
+        if not d.is_Integer or d < 0:
+            D.remove(d)
+
+    if not D:
+        return None    # 'f(n)' is *not* Gosper-summable
+
+    d = max(D)
+
+    coeffs = symbols('c:%s' % (d + 1), cls=Dummy)
+    domain = A.get_domain().inject(*coeffs)
+
+    x = Poly(coeffs, n, domain=domain)
+    H = A*x.shift(1) - B*x - C
+
+    from sympy.solvers.solvers import solve
+    solution = solve(H.coeffs(), coeffs)
+
+    if solution is None:
+        return None    # 'f(n)' is *not* Gosper-summable
+
+    x = x.as_expr().subs(solution)
+
+    for coeff in coeffs:
+        if coeff not in solution:
+            x = x.subs(coeff, 0)
+
+    if x.is_zero:
+        return None    # 'f(n)' is *not* Gosper-summable
+    else:
+        return B.as_expr()*x/C.as_expr()
+
+
+def gosper_sum(f, k):
+    r"""
+    Gosper's hypergeometric summation algorithm.
+
+    Explanation
+    ===========
+
+    Given a hypergeometric term ``f`` such that:
+
+    .. math ::
+        s_n = \sum_{k=0}^{n-1} f_k
+
+    and `f(n)` does not depend on `n`, returns `g_{n} - g(0)` where
+    `g_{n+1} - g_n = f_n`, or ``None`` if `s_n` cannot be expressed
+    in closed form as a sum of hypergeometric terms.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.gosper import gosper_sum
+    >>> from sympy import factorial
+    >>> from sympy.abc import n, k
+
+    >>> f = (4*k + 1)*factorial(k)/factorial(2*k + 1)
+    >>> gosper_sum(f, (k, 0, n))
+    (-factorial(n) + 2*factorial(2*n + 1))/factorial(2*n + 1)
+    >>> _.subs(n, 2) == sum(f.subs(k, i) for i in [0, 1, 2])
+    True
+    >>> gosper_sum(f, (k, 3, n))
+    (-60*factorial(n) + factorial(2*n + 1))/(60*factorial(2*n + 1))
+    >>> _.subs(n, 5) == sum(f.subs(k, i) for i in [3, 4, 5])
+    True
+
+    References
+    ==========
+
+    .. [1] Marko Petkovsek, Herbert S. Wilf, Doron Zeilberger, A = B,
+           AK Peters, Ltd., Wellesley, MA, USA, 1997, pp. 73--100
+
+    """
+    indefinite = False
+
+    if is_sequence(k):
+        k, a, b = k
+    else:
+        indefinite = True
+
+    g = gosper_term(f, k)
+
+    if g is None:
+        return None
+
+    if indefinite:
+        result = f*g
+    else:
+        result = (f*(g + 1)).subs(k, b) - (f*g).subs(k, a)
+
+        if result is S.NaN:
+            try:
+                result = (f*(g + 1)).limit(k, b) - (f*g).limit(k, a)
+            except NotImplementedError:
+                result = None
+
+    return factor(result)
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/guess.py b/.venv/lib/python3.12/site-packages/sympy/concrete/guess.py
new file mode 100644
index 0000000000000000000000000000000000000000..90aac54b442ce67c90cbb262e10d525e5f2ba316
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/guess.py
@@ -0,0 +1,473 @@
+"""Various algorithms for helping identifying numbers and sequences."""
+
+
+from sympy.concrete.products import (Product, product)
+from sympy.core import Function, S
+from sympy.core.add import Add
+from sympy.core.numbers import Integer, Rational
+from sympy.core.symbol import Symbol, symbols
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.integrals.integrals import integrate
+from sympy.polys.polyfuncs import rational_interpolate as rinterp
+from sympy.polys.polytools import lcm
+from sympy.simplify.radsimp import denom
+from sympy.utilities import public
+
+
+@public
+def find_simple_recurrence_vector(l):
+    """
+    This function is used internally by other functions from the
+    sympy.concrete.guess module. While most users may want to rather use the
+    function find_simple_recurrence when looking for recurrence relations
+    among rational numbers, the current function may still be useful when
+    some post-processing has to be done.
+
+    Explanation
+    ===========
+
+    The function returns a vector of length n when a recurrence relation of
+    order n is detected in the sequence of rational numbers v.
+
+    If the returned vector has a length 1, then the returned value is always
+    the list [0], which means that no relation has been found.
+
+    While the functions is intended to be used with rational numbers, it should
+    work for other kinds of real numbers except for some cases involving
+    quadratic numbers; for that reason it should be used with some caution when
+    the argument is not a list of rational numbers.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import find_simple_recurrence_vector
+    >>> from sympy import fibonacci
+    >>> find_simple_recurrence_vector([fibonacci(k) for k in range(12)])
+    [1, -1, -1]
+
+    See Also
+    ========
+
+    See the function sympy.concrete.guess.find_simple_recurrence which is more
+    user-friendly.
+
+    """
+    q1 = [0]
+    q2 = [1]
+    b, z = 0, len(l) >> 1
+    while len(q2) <= z:
+        while l[b]==0:
+            b += 1
+            if b == len(l):
+                c = 1
+                for x in q2:
+                    c = lcm(c, denom(x))
+                if q2[0]*c < 0: c = -c
+                for k in range(len(q2)):
+                    q2[k] = int(q2[k]*c)
+                return q2
+        a = S.One/l[b]
+        m = [a]
+        for k in range(b+1, len(l)):
+            m.append(-sum(l[j+1]*m[b-j-1] for j in range(b, k))*a)
+        l, m = m, [0] * max(len(q2), b+len(q1))
+        for k, q in enumerate(q2):
+            m[k] = a*q
+        for k, q in enumerate(q1):
+            m[k+b] += q
+        while m[-1]==0: m.pop() # because trailing zeros can occur
+        q1, q2, b = q2, m, 1
+    return [0]
+
+@public
+def find_simple_recurrence(v, A=Function('a'), N=Symbol('n')):
+    """
+    Detects and returns a recurrence relation from a sequence of several integer
+    (or rational) terms. The name of the function in the returned expression is
+    'a' by default; the main variable is 'n' by default. The smallest index in
+    the returned expression is always n (and never n-1, n-2, etc.).
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import find_simple_recurrence
+    >>> from sympy import fibonacci
+    >>> find_simple_recurrence([fibonacci(k) for k in range(12)])
+    -a(n) - a(n + 1) + a(n + 2)
+
+    >>> from sympy import Function, Symbol
+    >>> a = [1, 1, 1]
+    >>> for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
+    >>> find_simple_recurrence(a, A=Function('f'), N=Symbol('i'))
+    -8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3)
+
+    """
+    p = find_simple_recurrence_vector(v)
+    n = len(p)
+    if n <= 1: return S.Zero
+
+    return Add(*[A(N+n-1-k)*p[k] for k in range(n)])
+
+
+@public
+def rationalize(x, maxcoeff=10000):
+    """
+    Helps identifying a rational number from a float (or mpmath.mpf) value by
+    using a continued fraction. The algorithm stops as soon as a large partial
+    quotient is detected (greater than 10000 by default).
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import rationalize
+    >>> from mpmath import cos, pi
+    >>> rationalize(cos(pi/3))
+    1/2
+
+    >>> from mpmath import mpf
+    >>> rationalize(mpf("0.333333333333333"))
+    1/3
+
+    While the function is rather intended to help 'identifying' rational
+    values, it may be used in some cases for approximating real numbers.
+    (Though other functions may be more relevant in that case.)
+
+    >>> rationalize(pi, maxcoeff = 250)
+    355/113
+
+    See Also
+    ========
+
+    Several other methods can approximate a real number as a rational, like:
+
+      * fractions.Fraction.from_decimal
+      * fractions.Fraction.from_float
+      * mpmath.identify
+      * mpmath.pslq by using the following syntax: mpmath.pslq([x, 1])
+      * mpmath.findpoly by using the following syntax: mpmath.findpoly(x, 1)
+      * sympy.simplify.nsimplify (which is a more general function)
+
+    The main difference between the current function and all these variants is
+    that control focuses on magnitude of partial quotients here rather than on
+    global precision of the approximation. If the real is "known to be" a
+    rational number, the current function should be able to detect it correctly
+    with the default settings even when denominator is great (unless its
+    expansion contains unusually big partial quotients) which may occur
+    when studying sequences of increasing numbers. If the user cares more
+    on getting simple fractions, other methods may be more convenient.
+
+    """
+    p0, p1 = 0, 1
+    q0, q1 = 1, 0
+    a = floor(x)
+    while a < maxcoeff or q1==0:
+        p = a*p1 + p0
+        q = a*q1 + q0
+        p0, p1 = p1, p
+        q0, q1 = q1, q
+        if x==a: break
+        x = 1/(x-a)
+        a = floor(x)
+    return sympify(p) / q
+
+
+@public
+def guess_generating_function_rational(v, X=Symbol('x')):
+    """
+    Tries to "guess" a rational generating function for a sequence of rational
+    numbers v.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess_generating_function_rational
+    >>> from sympy import fibonacci
+    >>> l = [fibonacci(k) for k in range(5,15)]
+    >>> guess_generating_function_rational(l)
+    (3*x + 5)/(-x**2 - x + 1)
+
+    See Also
+    ========
+
+    sympy.series.approximants
+    mpmath.pade
+
+    """
+    #   a) compute the denominator as q
+    q = find_simple_recurrence_vector(v)
+    n = len(q)
+    if n <= 1: return None
+    #   b) compute the numerator as p
+    p = [sum(v[i-k]*q[k] for k in range(min(i+1, n)))
+            for i in range(len(v)>>1)]
+    return (sum(p[k]*X**k for k in range(len(p)))
+            / sum(q[k]*X**k for k in range(n)))
+
+
+@public
+def guess_generating_function(v, X=Symbol('x'), types=['all'], maxsqrtn=2):
+    """
+    Tries to "guess" a generating function for a sequence of rational numbers v.
+    Only a few patterns are implemented yet.
+
+    Explanation
+    ===========
+
+    The function returns a dictionary where keys are the name of a given type of
+    generating function. Six types are currently implemented:
+
+         type  |  formal definition
+        -------+----------------------------------------------------------------
+        ogf    | f(x) = Sum(            a_k * x^k       ,  k: 0..infinity )
+        egf    | f(x) = Sum(            a_k * x^k / k!  ,  k: 0..infinity )
+        lgf    | f(x) = Sum( (-1)^(k+1) a_k * x^k / k   ,  k: 1..infinity )
+               |        (with initial index being hold as 1 rather than 0)
+        hlgf   | f(x) = Sum(            a_k * x^k / k   ,  k: 1..infinity )
+               |        (with initial index being hold as 1 rather than 0)
+        lgdogf | f(x) = derivate( log(Sum( a_k * x^k, k: 0..infinity )), x)
+        lgdegf | f(x) = derivate( log(Sum( a_k * x^k / k!, k: 0..infinity )), x)
+
+    In order to spare time, the user can select only some types of generating
+    functions (default being ['all']). While forgetting to use a list in the
+    case of a single type may seem to work most of the time as in: types='ogf'
+    this (convenient) syntax may lead to unexpected extra results in some cases.
+
+    Discarding a type when calling the function does not mean that the type will
+    not be present in the returned dictionary; it only means that no extra
+    computation will be performed for that type, but the function may still add
+    it in the result when it can be easily converted from another type.
+
+    Two generating functions (lgdogf and lgdegf) are not even computed if the
+    initial term of the sequence is 0; it may be useful in that case to try
+    again after having removed the leading zeros.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess_generating_function as ggf
+    >>> ggf([k+1 for k in range(12)], types=['ogf', 'lgf', 'hlgf'])
+    {'hlgf': 1/(1 - x), 'lgf': 1/(x + 1), 'ogf': 1/(x**2 - 2*x + 1)}
+
+    >>> from sympy import sympify
+    >>> l = sympify("[3/2, 11/2, 0, -121/2, -363/2, 121]")
+    >>> ggf(l)
+    {'ogf': (x + 3/2)/(11*x**2 - 3*x + 1)}
+
+    >>> from sympy import fibonacci
+    >>> ggf([fibonacci(k) for k in range(5, 15)], types=['ogf'])
+    {'ogf': (3*x + 5)/(-x**2 - x + 1)}
+
+    >>> from sympy import factorial
+    >>> ggf([factorial(k) for k in range(12)], types=['ogf', 'egf', 'lgf'])
+    {'egf': 1/(1 - x)}
+
+    >>> ggf([k+1 for k in range(12)], types=['egf'])
+    {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
+
+    N-th root of a rational function can also be detected (below is an example
+    coming from the sequence A108626 from https://oeis.org).
+    The greatest n-th root to be tested is specified as maxsqrtn (default 2).
+
+    >>> ggf([1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf']
+    sqrt(1/(x**4 + 2*x**2 - 4*x + 1))
+
+    References
+    ==========
+
+    .. [1] "Concrete Mathematics", R.L. Graham, D.E. Knuth, O. Patashnik
+    .. [2] https://oeis.org/wiki/Generating_functions
+
+    """
+    # List of all types of all g.f. known by the algorithm
+    if 'all' in types:
+        types = ('ogf', 'egf', 'lgf', 'hlgf', 'lgdogf', 'lgdegf')
+
+    result = {}
+
+    # Ordinary Generating Function (ogf)
+    if 'ogf' in types:
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(v) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*v[i] for i in range(n+1)) for n in range(len(v))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['ogf'] = g**Rational(1, d+1)
+                break
+
+    # Exponential Generating Function (egf)
+    if 'egf' in types:
+        # Transform sequence (division by factorial)
+        w, f = [], S.One
+        for i, k in enumerate(v):
+            f *= i if i else 1
+            w.append(k/f)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['egf'] = g**Rational(1, d+1)
+                break
+
+    # Logarithmic Generating Function (lgf)
+    if 'lgf' in types:
+        # Transform sequence (multiplication by (-1)^(n+1) / n)
+        w, f = [], S.NegativeOne
+        for i, k in enumerate(v):
+            f = -f
+            w.append(f*k/Integer(i+1))
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgf'] = g**Rational(1, d+1)
+                break
+
+    # Hyperbolic logarithmic Generating Function (hlgf)
+    if 'hlgf' in types:
+        # Transform sequence (division by n+1)
+        w = []
+        for i, k in enumerate(v):
+            w.append(k/Integer(i+1))
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['hlgf'] = g**Rational(1, d+1)
+                break
+
+    # Logarithmic derivative of ordinary generating Function (lgdogf)
+    if v[0] != 0 and ('lgdogf' in types
+                       or ('ogf' in types and 'ogf' not in result)):
+        # Transform sequence by computing f'(x)/f(x)
+        # because log(f(x)) = integrate( f'(x)/f(x) )
+        a, w = sympify(v[0]), []
+        for n in range(len(v)-1):
+            w.append(
+               (v[n+1]*(n+1) - sum(w[-i-1]*v[i+1] for i in range(n)))/a)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgdogf'] = g**Rational(1, d+1)
+                if 'ogf' not in result:
+                    result['ogf'] = exp(integrate(result['lgdogf'], X))
+                break
+
+    # Logarithmic derivative of exponential generating Function (lgdegf)
+    if v[0] != 0 and ('lgdegf' in types
+                       or ('egf' in types and 'egf' not in result)):
+        # Transform sequence / step 1 (division by factorial)
+        z, f = [], S.One
+        for i, k in enumerate(v):
+            f *= i if i else 1
+            z.append(k/f)
+        # Transform sequence / step 2 by computing f'(x)/f(x)
+        # because log(f(x)) = integrate( f'(x)/f(x) )
+        a, w = z[0], []
+        for n in range(len(z)-1):
+            w.append(
+               (z[n+1]*(n+1) - sum(w[-i-1]*z[i+1] for i in range(n)))/a)
+        # Perform some convolutions of the sequence with itself
+        t = [1] + [0]*(len(w) - 1)
+        for d in range(max(1, maxsqrtn)):
+            t = [sum(t[n-i]*w[i] for i in range(n+1)) for n in range(len(w))]
+            g = guess_generating_function_rational(t, X=X)
+            if g:
+                result['lgdegf'] = g**Rational(1, d+1)
+                if 'egf' not in result:
+                    result['egf'] = exp(integrate(result['lgdegf'], X))
+                break
+
+    return result
+
+
+@public
+def guess(l, all=False, evaluate=True, niter=2, variables=None):
+    """
+    This function is adapted from the Rate.m package for Mathematica
+    written by Christian Krattenthaler.
+    It tries to guess a formula from a given sequence of rational numbers.
+
+    Explanation
+    ===========
+
+    In order to speed up the process, the 'all' variable is set to False by
+    default, stopping the computation as some results are returned during an
+    iteration; the variable can be set to True if more iterations are needed
+    (other formulas may be found; however they may be equivalent to the first
+    ones).
+
+    Another option is the 'evaluate' variable (default is True); setting it
+    to False will leave the involved products unevaluated.
+
+    By default, the number of iterations is set to 2 but a greater value (up
+    to len(l)-1) can be specified with the optional 'niter' variable.
+    More and more convoluted results are found when the order of the
+    iteration gets higher:
+
+      * first iteration returns polynomial or rational functions;
+      * second iteration returns products of rising factorials and their
+        inverses;
+      * third iteration returns products of products of rising factorials
+        and their inverses;
+      * etc.
+
+    The returned formulas contain symbols i0, i1, i2, ... where the main
+    variables is i0 (and auxiliary variables are i1, i2, ...). A list of
+    other symbols can be provided in the 'variables' option; the length of
+    the least should be the value of 'niter' (more is acceptable but only
+    the first symbols will be used); in this case, the main variable will be
+    the first symbol in the list.
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.guess import guess
+    >>> guess([1,2,6,24,120], evaluate=False)
+    [Product(i1 + 1, (i1, 1, i0 - 1))]
+
+    >>> from sympy import symbols
+    >>> r = guess([1,2,7,42,429,7436,218348,10850216], niter=4)
+    >>> i0 = symbols("i0")
+    >>> [r[0].subs(i0,n).doit() for n in range(1,10)]
+    [1, 2, 7, 42, 429, 7436, 218348, 10850216, 911835460]
+    """
+    if any(a==0 for a in l[:-1]):
+        return []
+    N = len(l)
+    niter = min(N-1, niter)
+    myprod = product if evaluate else Product
+    g = []
+    res = []
+    if variables is None:
+        symb = symbols('i:'+str(niter))
+    else:
+        symb = variables
+    for k, s in enumerate(symb):
+        g.append(l)
+        n, r = len(l), []
+        for i in range(n-2-1, -1, -1):
+            ri = rinterp(enumerate(g[k][:-1], start=1), i, X=s)
+            if ((denom(ri).subs({s:n}) != 0)
+                    and (ri.subs({s:n}) - g[k][-1] == 0)
+                    and ri not in r):
+                r.append(ri)
+        if r:
+            for i in range(k-1, -1, -1):
+                r = [g[i][0]
+                      * myprod(v, (symb[i+1], 1, symb[i]-1)) for v in r]
+            if not all: return r
+            res += r
+        l = [Rational(l[i+1], l[i]) for i in range(N-k-1)]
+    return res
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/products.py b/.venv/lib/python3.12/site-packages/sympy/concrete/products.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd035551683531f80b0e4467fe1cdfbb6ebbe9ad
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/products.py
@@ -0,0 +1,605 @@
+from __future__ import annotations
+
+from .expr_with_intlimits import ExprWithIntLimits
+from .summations import Sum, summation, _dummy_with_inherited_properties_concrete
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import Derivative
+from sympy.core.mul import Mul
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol
+from sympy.functions.combinatorial.factorials import RisingFactorial
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.polys import quo, roots
+
+
+class Product(ExprWithIntLimits):
+    r"""
+    Represents unevaluated products.
+
+    Explanation
+    ===========
+
+    ``Product`` represents a finite or infinite product, with the first
+    argument being the general form of terms in the series, and the second
+    argument being ``(dummy_variable, start, end)``, with ``dummy_variable``
+    taking all integer values from ``start`` through ``end``. In accordance
+    with long-standing mathematical convention, the end term is included in
+    the product.
+
+    Finite products
+    ===============
+
+    For finite products (and products with symbolic limits assumed to be finite)
+    we follow the analogue of the summation convention described by Karr [1],
+    especially definition 3 of section 1.4. The product:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i)
+
+    has *the obvious meaning* for `m < n`, namely:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = f(m) f(m+1) \cdot \ldots \cdot f(n-2) f(n-1)
+
+    with the upper limit value `f(n)` excluded. The product over an empty set is
+    one if and only if `m = n`:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = 1  \quad \mathrm{for} \quad  m = n
+
+    Finally, for all other products over empty sets we assume the following
+    definition:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = \frac{1}{\prod_{n \leq i < m} f(i)}  \quad \mathrm{for} \quad  m > n
+
+    It is important to note that above we define all products with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the product convention. Indeed we have:
+
+    .. math::
+
+        \prod_{m \leq i < n} f(i) = \prod_{i = m}^{n - 1} f(i)
+
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, i, k, m, n, x
+    >>> from sympy import Product, oo
+    >>> Product(k, (k, 1, m))
+    Product(k, (k, 1, m))
+    >>> Product(k, (k, 1, m)).doit()
+    factorial(m)
+    >>> Product(k**2,(k, 1, m))
+    Product(k**2, (k, 1, m))
+    >>> Product(k**2,(k, 1, m)).doit()
+    factorial(m)**2
+
+    Wallis' product for pi:
+
+    >>> W = Product(2*i/(2*i-1) * 2*i/(2*i+1), (i, 1, oo))
+    >>> W
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+
+    Direct computation currently fails:
+
+    >>> W.doit()
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, oo))
+
+    But we can approach the infinite product by a limit of finite products:
+
+    >>> from sympy import limit
+    >>> W2 = Product(2*i/(2*i-1)*2*i/(2*i+1), (i, 1, n))
+    >>> W2
+    Product(4*i**2/((2*i - 1)*(2*i + 1)), (i, 1, n))
+    >>> W2e = W2.doit()
+    >>> W2e
+    4**n*factorial(n)**2/(2**(2*n)*RisingFactorial(1/2, n)*RisingFactorial(3/2, n))
+    >>> limit(W2e, n, oo)
+    pi/2
+
+    By the same formula we can compute sin(pi/2):
+
+    >>> from sympy import combsimp, pi, gamma, simplify
+    >>> P = pi * x * Product(1 - x**2/k**2, (k, 1, n))
+    >>> P = P.subs(x, pi/2)
+    >>> P
+    pi**2*Product(1 - pi**2/(4*k**2), (k, 1, n))/2
+    >>> Pe = P.doit()
+    >>> Pe
+    pi**2*RisingFactorial(1 - pi/2, n)*RisingFactorial(1 + pi/2, n)/(2*factorial(n)**2)
+    >>> limit(Pe, n, oo).gammasimp()
+    sin(pi**2/2)
+    >>> Pe.rewrite(gamma)
+    (-1)**n*pi**2*gamma(pi/2)*gamma(n + 1 + pi/2)/(2*gamma(1 + pi/2)*gamma(-n + pi/2)*gamma(n + 1)**2)
+
+    Products with the lower limit being larger than the upper one:
+
+    >>> Product(1/i, (i, 6, 1)).doit()
+    120
+    >>> Product(i, (i, 2, 5)).doit()
+    120
+
+    The empty product:
+
+    >>> Product(i, (i, n, n-1)).doit()
+    1
+
+    An example showing that the symbolic result of a product is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those products by interchanging the limits according to the above rules:
+
+    >>> P = Product(2, (i, 10, n)).doit()
+    >>> P
+    2**(n - 9)
+    >>> P.subs(n, 5)
+    1/16
+    >>> Product(2, (i, 10, 5)).doit()
+    1/16
+    >>> 1/Product(2, (i, 6, 9)).doit()
+    1/16
+
+    An explicit example of the Karr summation convention applied to products:
+
+    >>> P1 = Product(x, (i, a, b)).doit()
+    >>> P1
+    x**(-a + b + 1)
+    >>> P2 = Product(x, (i, b+1, a-1)).doit()
+    >>> P2
+    x**(a - b - 1)
+    >>> simplify(P1 * P2)
+    1
+
+    And another one:
+
+    >>> P1 = Product(i, (i, b, a)).doit()
+    >>> P1
+    RisingFactorial(b, a - b + 1)
+    >>> P2 = Product(i, (i, a+1, b-1)).doit()
+    >>> P2
+    RisingFactorial(a + 1, -a + b - 1)
+    >>> P1 * P2
+    RisingFactorial(b, a - b + 1)*RisingFactorial(a + 1, -a + b - 1)
+    >>> combsimp(P1 * P2)
+    1
+
+    See Also
+    ========
+
+    Sum, summation
+    product
+
+    References
+    ==========
+
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Multiplication#Capital_Pi_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_product
+    """
+
+    __slots__ = ()
+
+    limits: tuple[tuple[Symbol, Expr, Expr]]
+
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = ExprWithIntLimits.__new__(cls, function, *symbols, **assumptions)
+        return obj
+
+    def _eval_rewrite_as_Sum(self, *args, **kwargs):
+        return exp(Sum(log(self.function), *self.limits))
+
+    @property
+    def term(self):
+        return self._args[0]
+    function = term
+
+    def _eval_is_zero(self):
+        if self.has_empty_sequence:
+            return False
+
+        z = self.term.is_zero
+        if z is True:
+            return True
+        if self.has_finite_limits:
+            # A Product is zero only if its term is zero assuming finite limits.
+            return z
+
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+
+        return self.function.is_extended_real
+
+    def _eval_is_positive(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_positive and self.has_finite_limits:
+            return True
+
+    def _eval_is_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_nonnegative and self.has_finite_limits:
+            return True
+
+    def _eval_is_extended_nonnegative(self):
+        if self.has_empty_sequence:
+            return True
+        if self.function.is_extended_nonnegative:
+            return True
+
+    def _eval_is_extended_nonpositive(self):
+        if self.has_empty_sequence:
+            return True
+
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+
+    def doit(self, **hints):
+        # first make sure any definite limits have product
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            else:
+                did = did.xreplace(undo)
+            return did
+
+        from sympy.simplify.powsimp import powsimp
+        f = self.function
+        for index, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = 1 / f
+
+            g = self._eval_product(f, (i, a, b))
+            if g in (None, S.NaN):
+                return self.func(powsimp(f), *self.limits[index:])
+            else:
+                f = g
+
+        if hints.get('deep', True):
+            return f.doit(**hints)
+        else:
+            return powsimp(f)
+
+    def _eval_conjugate(self):
+        return self.func(self.function.conjugate(), *self.limits)
+
+    def _eval_product(self, term, limits):
+
+        (k, a, n) = limits
+
+        if k not in term.free_symbols:
+            if (term - 1).is_zero:
+                return S.One
+            return term**(n - a + 1)
+
+        if a == n:
+            return term.subs(k, a)
+
+        from .delta import deltaproduct, _has_simple_delta
+        if term.has(KroneckerDelta) and _has_simple_delta(term, limits[0]):
+            return deltaproduct(term, limits)
+
+        dif = n - a
+        definite = dif.is_Integer
+        if definite and (dif < 100):
+            return self._eval_product_direct(term, limits)
+
+        elif term.is_polynomial(k):
+            poly = term.as_poly(k)
+
+            A = B = Q = S.One
+
+            all_roots = roots(poly)
+
+            M = 0
+            for r, m in all_roots.items():
+                M += m
+                A *= RisingFactorial(a - r, n - a + 1)**m
+                Q *= (n - r)**m
+
+            if M < poly.degree():
+                arg = quo(poly, Q.as_poly(k))
+                B = self.func(arg, (k, a, n)).doit()
+
+            return poly.LC()**(n - a + 1) * A * B
+
+        elif term.is_Add:
+            factored = factor_terms(term, fraction=True)
+            if factored.is_Mul:
+                return self._eval_product(factored, (k, a, n))
+
+        elif term.is_Mul:
+            # Factor in part without the summation variable and part with
+            without_k, with_k = term.as_coeff_mul(k)
+
+            if len(with_k) >= 2:
+                # More than one term including k, so still a multiplication
+                exclude, include = [], []
+                for t in with_k:
+                    p = self._eval_product(t, (k, a, n))
+
+                    if p is not None:
+                        exclude.append(p)
+                    else:
+                        include.append(t)
+
+                if not exclude:
+                    return None
+                else:
+                    arg = term._new_rawargs(*include)
+                    A = Mul(*exclude)
+                    B = self.func(arg, (k, a, n)).doit()
+                    return without_k**(n - a + 1)*A * B
+            else:
+                # Just a single term
+                p = self._eval_product(with_k[0], (k, a, n))
+                if p is None:
+                    p = self.func(with_k[0], (k, a, n)).doit()
+                return without_k**(n - a + 1)*p
+
+
+        elif term.is_Pow:
+            if not term.base.has(k):
+                s = summation(term.exp, (k, a, n))
+
+                return term.base**s
+            elif not term.exp.has(k):
+                p = self._eval_product(term.base, (k, a, n))
+
+                if p is not None:
+                    return p**term.exp
+
+        elif isinstance(term, Product):
+            evaluated = term.doit()
+            f = self._eval_product(evaluated, limits)
+            if f is None:
+                return self.func(evaluated, limits)
+            else:
+                return f
+
+        if definite:
+            return self._eval_product_direct(term, limits)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import product_simplify
+        rv = product_simplify(self, **kwargs)
+        return rv.doit() if kwargs['doit'] else rv
+
+    def _eval_transpose(self):
+        if self.is_commutative:
+            return self.func(self.function.transpose(), *self.limits)
+        return None
+
+    def _eval_product_direct(self, term, limits):
+        (k, a, n) = limits
+        return Mul(*[term.subs(k, a + i) for i in range(n - a + 1)])
+
+    def _eval_derivative(self, x):
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+        f, limits = self.function, list(self.limits)
+        limit = limits.pop(-1)
+        if limits:
+            f = self.func(f, *limits)
+        i, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        h = Dummy()
+        rv = Sum( Product(f, (i, a, h - 1)) * Product(f, (i, h + 1, b)) * Derivative(f, x, evaluate=True).subs(i, h), (h, a, b))
+        return rv
+
+    def is_convergent(self):
+        r"""
+        See docs of :obj:`.Sum.is_convergent()` for explanation of convergence
+        in SymPy.
+
+        Explanation
+        ===========
+
+        The infinite product:
+
+        .. math::
+
+            \prod_{1 \leq i < \infty} f(i)
+
+        is defined by the sequence of partial products:
+
+        .. math::
+
+            \prod_{i=1}^{n} f(i) = f(1) f(2) \cdots f(n)
+
+        as n increases without bound. The product converges to a non-zero
+        value if and only if the sum:
+
+        .. math::
+
+            \sum_{1 \leq i < \infty} \log{f(n)}
+
+        converges.
+
+        Examples
+        ========
+
+        >>> from sympy import Product, Symbol, cos, pi, exp, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Product(n/(n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Product(1/n**2, (n, 1, oo)).is_convergent()
+        False
+        >>> Product(cos(pi/n), (n, 1, oo)).is_convergent()
+        True
+        >>> Product(exp(-n**2), (n, 1, oo)).is_convergent()
+        False
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Infinite_product
+        """
+        sequence_term = self.function
+        log_sum = log(sequence_term)
+        lim = self.limits
+        try:
+            is_conv = Sum(log_sum, *lim).is_convergent()
+        except NotImplementedError:
+            if Sum(sequence_term - 1, *lim).is_absolutely_convergent() is S.true:
+                return S.true
+            raise NotImplementedError("The algorithm to find the product convergence of %s "
+                                        "is not yet implemented" % (sequence_term))
+        return is_conv
+
+    def reverse_order(expr, *indices):
+        """
+        Reverse the order of a limit in a Product.
+
+        Explanation
+        ===========
+
+        ``reverse_order(expr, *indices)`` reverses some limits in the expression
+        ``expr`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+
+        Examples
+        ========
+
+        >>> from sympy import gamma, Product, simplify, Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+        >>> P = Product(x, (x, a, b))
+        >>> Pr = P.reverse_order(x)
+        >>> Pr
+        Product(1/x, (x, b + 1, a - 1))
+        >>> Pr = Pr.doit()
+        >>> Pr
+        1/RisingFactorial(b + 1, a - b - 1)
+        >>> simplify(Pr.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), b > -1), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+        >>> P = P.doit()
+        >>> P
+        RisingFactorial(a, -a + b + 1)
+        >>> simplify(P.rewrite(gamma))
+        Piecewise((gamma(b + 1)/gamma(a), a > 0), ((-1)**(-a + b + 1)*gamma(1 - a)/gamma(-b), True))
+
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+
+        >>> S = Sum(x*y, (x, a, b), (y, c, d))
+        >>> S
+        Sum(x*y, (x, a, b), (y, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x*y, (x, b + 1, a - 1), (y, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x*y, (x, b + 1, a - 1), (y, d + 1, c - 1))
+
+        Of course we can mix both notations:
+
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index,
+        reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+
+        References
+        ==========
+
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+
+        """
+        l_indices = list(indices)
+
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = expr.index(indx)
+
+        e = 1
+        limits = []
+        for i, limit in enumerate(expr.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+
+        return Product(expr.function ** e, *limits)
+
+
+def product(*args, **kwargs):
+    r"""
+    Compute the product.
+
+    Explanation
+    ===========
+
+    The notation for symbols is similar to the notation used in Sum or
+    Integral. product(f, (i, a, b)) computes the product of f with
+    respect to i from a to b, i.e.,
+
+    ::
+
+                                     b
+                                   _____
+        product(f(n), (i, a, b)) = |   | f(n)
+                                   |   |
+                                   i = a
+
+    If it cannot compute the product, it returns an unevaluated Product object.
+    Repeated products can be computed by introducing additional symbols tuples::
+
+    Examples
+    ========
+
+    >>> from sympy import product, symbols
+    >>> i, n, m, k = symbols('i n m k', integer=True)
+
+    >>> product(i, (i, 1, k))
+    factorial(k)
+    >>> product(m, (i, 1, k))
+    m**k
+    >>> product(i, (i, 1, k), (k, 1, n))
+    Product(factorial(k), (k, 1, n))
+
+    """
+
+    prod = Product(*args, **kwargs)
+
+    if isinstance(prod, Product):
+        return prod.doit(deep=False)
+    else:
+        return prod
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/summations.py b/.venv/lib/python3.12/site-packages/sympy/concrete/summations.py
new file mode 100644
index 0000000000000000000000000000000000000000..96bdbd69b7820798fade4bc5ec145172b95947ef
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/summations.py
@@ -0,0 +1,1659 @@
+from __future__ import annotations
+
+from sympy.calculus.singularities import is_decreasing
+from sympy.calculus.accumulationbounds import AccumulationBounds
+from .expr_with_intlimits import ExprWithIntLimits
+from .expr_with_limits import AddWithLimits
+from .gosper import gosper_sum
+from sympy.core.expr import Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import Derivative, expand
+from sympy.core.mul import Mul
+from sympy.core.numbers import Float, _illegal
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, Wild, Symbol, symbols
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.elementary.complexes import re
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cot, csc
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And, Not
+from sympy.polys.partfrac import apart
+from sympy.polys.polyerrors import PolynomialError, PolificationFailed
+from sympy.polys.polytools import parallel_poly_from_expr, Poly, factor
+from sympy.polys.rationaltools import together
+from sympy.series.limitseq import limit_seq
+from sympy.series.order import O
+from sympy.series.residues import residue
+from sympy.sets.contains import Contains
+from sympy.sets.sets import FiniteSet, Interval
+from sympy.utilities.iterables import sift
+import itertools
+
+
+class Sum(AddWithLimits, ExprWithIntLimits):
+    r"""
+    Represents unevaluated summation.
+
+    Explanation
+    ===========
+
+    ``Sum`` represents a finite or infinite series, with the first argument
+    being the general form of terms in the series, and the second argument
+    being ``(dummy_variable, start, end)``, with ``dummy_variable`` taking
+    all integer values from ``start`` through ``end``. In accordance with
+    long-standing mathematical convention, the end term is included in the
+    summation.
+
+    Finite sums
+    ===========
+
+    For finite sums (and sums with symbolic limits assumed to be finite) we
+    follow the summation convention described by Karr [1], especially
+    definition 3 of section 1.4. The sum:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i)
+
+    has *the obvious meaning* for `m < n`, namely:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = f(m) + f(m+1) + \ldots + f(n-2) + f(n-1)
+
+    with the upper limit value `f(n)` excluded. The sum over an empty set is
+    zero if and only if `m = n`:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = 0  \quad \mathrm{for} \quad  m = n
+
+    Finally, for all other sums over empty sets we assume the following
+    definition:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = - \sum_{n \leq i < m} f(i)  \quad \mathrm{for} \quad  m > n
+
+    It is important to note that Karr defines all sums with the upper
+    limit being exclusive. This is in contrast to the usual mathematical notation,
+    but does not affect the summation convention. Indeed we have:
+
+    .. math::
+
+        \sum_{m \leq i < n} f(i) = \sum_{i = m}^{n - 1} f(i)
+
+    where the difference in notation is intentional to emphasize the meaning,
+    with limits typeset on the top being inclusive.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import i, k, m, n, x
+    >>> from sympy import Sum, factorial, oo, IndexedBase, Function
+    >>> Sum(k, (k, 1, m))
+    Sum(k, (k, 1, m))
+    >>> Sum(k, (k, 1, m)).doit()
+    m**2/2 + m/2
+    >>> Sum(k**2, (k, 1, m))
+    Sum(k**2, (k, 1, m))
+    >>> Sum(k**2, (k, 1, m)).doit()
+    m**3/3 + m**2/2 + m/6
+    >>> Sum(x**k, (k, 0, oo))
+    Sum(x**k, (k, 0, oo))
+    >>> Sum(x**k, (k, 0, oo)).doit()
+    Piecewise((1/(1 - x), Abs(x) < 1), (Sum(x**k, (k, 0, oo)), True))
+    >>> Sum(x**k/factorial(k), (k, 0, oo)).doit()
+    exp(x)
+
+    Here are examples to do summation with symbolic indices.  You
+    can use either Function of IndexedBase classes:
+
+    >>> f = Function('f')
+    >>> Sum(f(n), (n, 0, 3)).doit()
+    f(0) + f(1) + f(2) + f(3)
+    >>> Sum(f(n), (n, 0, oo)).doit()
+    Sum(f(n), (n, 0, oo))
+    >>> f = IndexedBase('f')
+    >>> Sum(f[n]**2, (n, 0, 3)).doit()
+    f[0]**2 + f[1]**2 + f[2]**2 + f[3]**2
+
+    An example showing that the symbolic result of a summation is still
+    valid for seemingly nonsensical values of the limits. Then the Karr
+    convention allows us to give a perfectly valid interpretation to
+    those sums by interchanging the limits according to the above rules:
+
+    >>> S = Sum(i, (i, 1, n)).doit()
+    >>> S
+    n**2/2 + n/2
+    >>> S.subs(n, -4)
+    6
+    >>> Sum(i, (i, 1, -4)).doit()
+    6
+    >>> Sum(-i, (i, -3, 0)).doit()
+    6
+
+    An explicit example of the Karr summation convention:
+
+    >>> S1 = Sum(i**2, (i, m, m+n-1)).doit()
+    >>> S1
+    m**2*n + m*n**2 - m*n + n**3/3 - n**2/2 + n/6
+    >>> S2 = Sum(i**2, (i, m+n, m-1)).doit()
+    >>> S2
+    -m**2*n - m*n**2 + m*n - n**3/3 + n**2/2 - n/6
+    >>> S1 + S2
+    0
+    >>> S3 = Sum(i, (i, m, m-1)).doit()
+    >>> S3
+    0
+
+    See Also
+    ========
+
+    summation
+    Product, sympy.concrete.products.product
+
+    References
+    ==========
+
+    .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+           Volume 28 Issue 2, April 1981, Pages 305-350
+           https://dl.acm.org/doi/10.1145/322248.322255
+    .. [2] https://en.wikipedia.org/wiki/Summation#Capital-sigma_notation
+    .. [3] https://en.wikipedia.org/wiki/Empty_sum
+    """
+
+    __slots__ = ()
+
+    limits: tuple[tuple[Symbol, Expr, Expr]]
+
+    def __new__(cls, function, *symbols, **assumptions):
+        obj = AddWithLimits.__new__(cls, function, *symbols, **assumptions)
+        if not hasattr(obj, 'limits'):
+            return obj
+        if any(len(l) != 3 or None in l for l in obj.limits):
+            raise ValueError('Sum requires values for lower and upper bounds.')
+
+        return obj
+
+    def _eval_is_zero(self):
+        # a Sum is only zero if its function is zero or if all terms
+        # cancel out. This only answers whether the summand is zero; if
+        # not then None is returned since we don't analyze whether all
+        # terms cancel out.
+        if self.function.is_zero or self.has_empty_sequence:
+            return True
+
+    def _eval_is_extended_real(self):
+        if self.has_empty_sequence:
+            return True
+        return self.function.is_extended_real
+
+    def _eval_is_positive(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_positive
+
+    def _eval_is_negative(self):
+        if self.has_finite_limits and self.has_reversed_limits is False:
+            return self.function.is_negative
+
+    def _eval_is_finite(self):
+        if self.has_finite_limits and self.function.is_finite:
+            return True
+
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            f = self.function.doit(**hints)
+        else:
+            f = self.function
+
+        # first make sure any definite limits have summation
+        # variables with matching assumptions
+        reps = {}
+        for xab in self.limits:
+            d = _dummy_with_inherited_properties_concrete(xab)
+            if d:
+                reps[xab[0]] = d
+        if reps:
+            undo = {v: k for k, v in reps.items()}
+            did = self.xreplace(reps).doit(**hints)
+            if isinstance(did, tuple):  # when separate=True
+                did = tuple([i.xreplace(undo) for i in did])
+            elif did is not None:
+                did = did.xreplace(undo)
+            else:
+                did = self
+            return did
+
+
+        if self.function.is_Matrix:
+            expanded = self.expand()
+            if self != expanded:
+                return expanded.doit()
+            return _eval_matrix_sum(self)
+
+        for n, limit in enumerate(self.limits):
+            i, a, b = limit
+            dif = b - a
+            if dif == -1:
+                # Any summation over an empty set is zero
+                return S.Zero
+            if dif.is_integer and dif.is_negative:
+                a, b = b + 1, a - 1
+                f = -f
+
+            newf = eval_sum(f, (i, a, b))
+            if newf is None:
+                if f == self.function:
+                    zeta_function = self.eval_zeta_function(f, (i, a, b))
+                    if zeta_function is not None:
+                        return zeta_function
+                    return self
+                else:
+                    return self.func(f, *self.limits[n:])
+            f = newf
+
+        if hints.get('deep', True):
+            # eval_sum could return partially unevaluated
+            # result with Piecewise.  In this case we won't
+            # doit() recursively.
+            if not isinstance(f, Piecewise):
+                return f.doit(**hints)
+
+        return f
+
+    def eval_zeta_function(self, f, limits):
+        """
+        Check whether the function matches with the zeta function.
+
+        If it matches, then return a `Piecewise` expression because
+        zeta function does not converge unless `s > 1` and `q > 0`
+        """
+        i, a, b = limits
+        if a.is_comparable and b.is_comparable and a > b:
+            return self.eval_zeta_function(f, (i, b + S.One, a - S.One))
+        if b is not S.Infinity:
+            return
+        w, y, z = Wild('w', exclude=[i]), Wild('y', exclude=[i]), Wild('z', exclude=[i])
+        if result := f.match((w * i + y) ** (-z)):
+            coeff = 1 / result[w] ** result[z]
+            s = result[z]
+            q = result[y] / result[w] + a
+            return Piecewise((coeff * zeta(s, q),
+                              And(Not(Contains(-q, S.Naturals0)), re(s) > S.One)),
+                             (self, True))
+
+    def _eval_derivative(self, x):
+        """
+        Differentiate wrt x as long as x is not in the free symbols of any of
+        the upper or lower limits.
+
+        Explanation
+        ===========
+
+        Sum(a*b*x, (x, 1, a)) can be differentiated wrt x or b but not `a`
+        since the value of the sum is discontinuous in `a`. In a case
+        involving a limit variable, the unevaluated derivative is returned.
+        """
+
+        # diff already confirmed that x is in the free symbols of self, but we
+        # don't want to differentiate wrt any free symbol in the upper or lower
+        # limits
+        # XXX remove this test for free_symbols when the default _eval_derivative is in
+        if isinstance(x, Symbol) and x not in self.free_symbols:
+            return S.Zero
+
+        # get limits and the function
+        f, limits = self.function, list(self.limits)
+
+        limit = limits.pop(-1)
+
+        if limits:  # f is the argument to a Sum
+            f = self.func(f, *limits)
+
+        _, a, b = limit
+        if x in a.free_symbols or x in b.free_symbols:
+            return None
+        df = Derivative(f, x, evaluate=True)
+        rv = self.func(df, limit)
+        return rv
+
+    def _eval_difference_delta(self, n, step):
+        k, _, upper = self.args[-1]
+        new_upper = upper.subs(n, n + step)
+
+        if len(self.args) == 2:
+            f = self.args[0]
+        else:
+            f = self.func(*self.args[:-1])
+
+        return Sum(f, (k, upper + 1, new_upper)).doit()
+
+    def _eval_simplify(self, **kwargs):
+
+        function = self.function
+
+        if kwargs.get('deep', True):
+            function = function.simplify(**kwargs)
+
+        # split the function into adds
+        terms = Add.make_args(expand(function))
+        s_t = [] # Sum Terms
+        o_t = [] # Other Terms
+
+        for term in terms:
+            if term.has(Sum):
+                # if there is an embedded sum here
+                # it is of the form x * (Sum(whatever))
+                # hence we make a Mul out of it, and simplify all interior sum terms
+                subterms = Mul.make_args(expand(term))
+                out_terms = []
+                for subterm in subterms:
+                    # go through each term
+                    if isinstance(subterm, Sum):
+                        # if it's a sum, simplify it
+                        out_terms.append(subterm._eval_simplify(**kwargs))
+                    else:
+                        # otherwise, add it as is
+                        out_terms.append(subterm)
+
+                # turn it back into a Mul
+                s_t.append(Mul(*out_terms))
+            else:
+                o_t.append(term)
+
+        # next try to combine any interior sums for further simplification
+        from sympy.simplify.simplify import factor_sum, sum_combine
+        result = Add(sum_combine(s_t), *o_t)
+
+        return factor_sum(result, limits=self.limits)
+
+    def is_convergent(self):
+        r"""
+        Checks for the convergence of a Sum.
+
+        Explanation
+        ===========
+
+        We divide the study of convergence of infinite sums and products in
+        two parts.
+
+        First Part:
+        One part is the question whether all the terms are well defined, i.e.,
+        they are finite in a sum and also non-zero in a product. Zero
+        is the analogy of (minus) infinity in products as
+        :math:`e^{-\infty} = 0`.
+
+        Second Part:
+        The second part is the question of convergence after infinities,
+        and zeros in products, have been omitted assuming that their number
+        is finite. This means that we only consider the tail of the sum or
+        product, starting from some point after which all terms are well
+        defined.
+
+        For example, in a sum of the form:
+
+        .. math::
+
+            \sum_{1 \leq i < \infty} \frac{1}{n^2 + an + b}
+
+        where a and b are numbers. The routine will return true, even if there
+        are infinities in the term sequence (at most two). An analogous
+        product would be:
+
+        .. math::
+
+            \prod_{1 \leq i < \infty} e^{\frac{1}{n^2 + an + b}}
+
+        This is how convergence is interpreted. It is concerned with what
+        happens at the limit. Finding the bad terms is another independent
+        matter.
+
+        Note: It is responsibility of user to see that the sum or product
+        is well defined.
+
+        There are various tests employed to check the convergence like
+        divergence test, root test, integral test, alternating series test,
+        comparison tests, Dirichlet tests. It returns true if Sum is convergent
+        and false if divergent and NotImplementedError if it cannot be checked.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Convergence_tests
+
+        Examples
+        ========
+
+        >>> from sympy import factorial, S, Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
+        True
+        >>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
+        False
+        >>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
+        True
+
+        See Also
+        ========
+
+        Sum.is_absolutely_convergent
+        sympy.concrete.products.Product.is_convergent
+        """
+        p, q, r = symbols('p q r', cls=Wild)
+
+        sym = self.limits[0][0]
+        lower_limit = self.limits[0][1]
+        upper_limit = self.limits[0][2]
+        sequence_term = self.function.simplify()
+
+        if len(sequence_term.free_symbols) > 1:
+            raise NotImplementedError("convergence checking for more than one symbol "
+                                      "containing series is not handled")
+
+        if lower_limit.is_finite and upper_limit.is_finite:
+            return S.true
+
+        # transform sym -> -sym and swap the upper_limit = S.Infinity
+        # and lower_limit = - upper_limit
+        if lower_limit is S.NegativeInfinity:
+            if upper_limit is S.Infinity:
+                return Sum(sequence_term, (sym, 0, S.Infinity)).is_convergent() and \
+                        Sum(sequence_term, (sym, S.NegativeInfinity, 0)).is_convergent()
+            from sympy.simplify.simplify import simplify
+            sequence_term = simplify(sequence_term.xreplace({sym: -sym}))
+            lower_limit = -upper_limit
+            upper_limit = S.Infinity
+
+        sym_ = Dummy(sym.name, integer=True, positive=True)
+        sequence_term = sequence_term.xreplace({sym: sym_})
+        sym = sym_
+
+        interval = Interval(lower_limit, upper_limit)
+
+        # Piecewise function handle
+        if sequence_term.is_Piecewise:
+            for func, cond in sequence_term.args:
+                # see if it represents something going to oo
+                if cond == True or cond.as_set().sup is S.Infinity:
+                    s = Sum(func, (sym, lower_limit, upper_limit))
+                    return s.is_convergent()
+            return S.true
+
+        ###  -------- Divergence test ----------- ###
+        try:
+            lim_val = limit_seq(sequence_term, sym)
+            if lim_val is not None and lim_val.is_zero is False:
+                return S.false
+        except NotImplementedError:
+            pass
+
+        try:
+            lim_val_abs = limit_seq(abs(sequence_term), sym)
+            if lim_val_abs is not None and lim_val_abs.is_zero is False:
+                return S.false
+        except NotImplementedError:
+            pass
+
+        order = O(sequence_term, (sym, S.Infinity))
+
+        ### --------- p-series test (1/n**p) ---------- ###
+        p_series_test = order.expr.match(sym**p)
+        if p_series_test is not None:
+            if p_series_test[p] < -1:
+                return S.true
+            if p_series_test[p] >= -1:
+                return S.false
+
+        ### ------------- comparison test ------------- ###
+        # 1/(n**p*log(n)**q*log(log(n))**r) comparison
+        n_log_test = (order.expr.match(1/(sym**p*log(1/sym)**q*log(-log(1/sym))**r)) or
+                      order.expr.match(1/(sym**p*(-log(1/sym))**q*log(-log(1/sym))**r)))
+        if n_log_test is not None:
+            if (n_log_test[p] > 1 or
+                (n_log_test[p] == 1 and n_log_test[q] > 1) or
+                (n_log_test[p] == n_log_test[q] == 1 and n_log_test[r] > 1)):
+                    return S.true
+            return S.false
+
+        ### ------------- Limit comparison test -----------###
+        # (1/n) comparison
+        try:
+            lim_comp = limit_seq(sym*sequence_term, sym)
+            if lim_comp is not None and lim_comp.is_number and lim_comp > 0:
+                return S.false
+        except NotImplementedError:
+            pass
+
+        ### ----------- ratio test ---------------- ###
+        next_sequence_term = sequence_term.xreplace({sym: sym + 1})
+        from sympy.simplify.combsimp import combsimp
+        from sympy.simplify.powsimp import powsimp
+        ratio = combsimp(powsimp(next_sequence_term/sequence_term))
+        try:
+            lim_ratio = limit_seq(ratio, sym)
+            if lim_ratio is not None and lim_ratio.is_number and lim_ratio is not S.NaN:
+                if abs(lim_ratio) > 1:
+                    return S.false
+                if abs(lim_ratio) < 1:
+                    return S.true
+        except NotImplementedError:
+            lim_ratio = None
+
+        ### ---------- Raabe's test -------------- ###
+        if lim_ratio == 1:  # ratio test inconclusive
+            test_val = sym*(sequence_term/
+                         sequence_term.subs(sym, sym + 1) - 1)
+            test_val = test_val.gammasimp()
+            try:
+                lim_val = limit_seq(test_val, sym)
+                if lim_val is not None and lim_val.is_number:
+                    if lim_val > 1:
+                        return S.true
+                    if lim_val < 1:
+                        return S.false
+            except NotImplementedError:
+                pass
+
+        ### ----------- root test ---------------- ###
+        # lim = Limit(abs(sequence_term)**(1/sym), sym, S.Infinity)
+        try:
+            lim_evaluated = limit_seq(abs(sequence_term)**(1/sym), sym)
+            if lim_evaluated is not None and lim_evaluated.is_number:
+                if lim_evaluated < 1:
+                    return S.true
+                if lim_evaluated > 1:
+                    return S.false
+        except NotImplementedError:
+            pass
+
+        ### ------------- alternating series test ----------- ###
+        dict_val = sequence_term.match(S.NegativeOne**(sym + p)*q)
+        if not dict_val[p].has(sym) and is_decreasing(dict_val[q], interval):
+            return S.true
+
+        ### ------------- integral test -------------- ###
+        check_interval = None
+        from sympy.solvers.solveset import solveset
+        maxima = solveset(sequence_term.diff(sym), sym, interval)
+        if not maxima:
+            check_interval = interval
+        elif isinstance(maxima, FiniteSet) and maxima.sup.is_number:
+            check_interval = Interval(maxima.sup, interval.sup)
+        if (check_interval is not None and
+            (is_decreasing(sequence_term, check_interval) or
+            is_decreasing(-sequence_term, check_interval))):
+                integral_val = Integral(
+                    sequence_term, (sym, lower_limit, upper_limit))
+                try:
+                    integral_val_evaluated = integral_val.doit()
+                    if integral_val_evaluated.is_number:
+                        return S(integral_val_evaluated.is_finite)
+                except NotImplementedError:
+                    pass
+
+        ### ----- Dirichlet and bounded times convergent tests ----- ###
+        # TODO
+        #
+        # Dirichlet_test
+        # https://en.wikipedia.org/wiki/Dirichlet%27s_test
+        #
+        # Bounded times convergent test
+        # It is based on comparison theorems for series.
+        # In particular, if the general term of a series can
+        # be written as a product of two terms a_n and b_n
+        # and if a_n is bounded and if Sum(b_n) is absolutely
+        # convergent, then the original series Sum(a_n * b_n)
+        # is absolutely convergent and so convergent.
+        #
+        # The following code can grows like 2**n where n is the
+        # number of args in order.expr
+        # Possibly combined with the potentially slow checks
+        # inside the loop, could make this test extremely slow
+        # for larger summation expressions.
+
+        if order.expr.is_Mul:
+            args = order.expr.args
+            argset = set(args)
+
+            ### -------------- Dirichlet tests -------------- ###
+            m = Dummy('m', integer=True)
+            def _dirichlet_test(g_n):
+                try:
+                    ing_val = limit_seq(Sum(g_n, (sym, interval.inf, m)).doit(), m)
+                    if ing_val is not None and ing_val.is_finite:
+                        return S.true
+                except NotImplementedError:
+                    pass
+
+            ### -------- bounded times convergent test ---------###
+            def _bounded_convergent_test(g1_n, g2_n):
+                try:
+                    lim_val = limit_seq(g1_n, sym)
+                    if lim_val is not None and (lim_val.is_finite or (
+                        isinstance(lim_val, AccumulationBounds)
+                        and (lim_val.max - lim_val.min).is_finite)):
+                            if Sum(g2_n, (sym, lower_limit, upper_limit)).is_absolutely_convergent():
+                                return S.true
+                except NotImplementedError:
+                    pass
+
+            for n in range(1, len(argset)):
+                for a_tuple in itertools.combinations(args, n):
+                    b_set = argset - set(a_tuple)
+                    a_n = Mul(*a_tuple)
+                    b_n = Mul(*b_set)
+
+                    if is_decreasing(a_n, interval):
+                        dirich = _dirichlet_test(b_n)
+                        if dirich is not None:
+                            return dirich
+
+                    bc_test = _bounded_convergent_test(a_n, b_n)
+                    if bc_test is not None:
+                        return bc_test
+
+        _sym = self.limits[0][0]
+        sequence_term = sequence_term.xreplace({sym: _sym})
+        raise NotImplementedError("The algorithm to find the Sum convergence of %s "
+                                  "is not yet implemented" % (sequence_term))
+
+    def is_absolutely_convergent(self):
+        """
+        Checks for the absolute convergence of an infinite series.
+
+        Same as checking convergence of absolute value of sequence_term of
+        an infinite series.
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Absolute_convergence
+
+        Examples
+        ========
+
+        >>> from sympy import Sum, Symbol, oo
+        >>> n = Symbol('n', integer=True)
+        >>> Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent()
+        False
+        >>> Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent()
+        True
+
+        See Also
+        ========
+
+        Sum.is_convergent
+        """
+        return Sum(abs(self.function), self.limits).is_convergent()
+
+    def euler_maclaurin(self, m=0, n=0, eps=0, eval_integral=True):
+        """
+        Return an Euler-Maclaurin approximation of self, where m is the
+        number of leading terms to sum directly and n is the number of
+        terms in the tail.
+
+        With m = n = 0, this is simply the corresponding integral
+        plus a first-order endpoint correction.
+
+        Returns (s, e) where s is the Euler-Maclaurin approximation
+        and e is the estimated error (taken to be the magnitude of
+        the first omitted term in the tail):
+
+            >>> from sympy.abc import k, a, b
+            >>> from sympy import Sum
+            >>> Sum(1/k, (k, 2, 5)).doit().evalf()
+            1.28333333333333
+            >>> s, e = Sum(1/k, (k, 2, 5)).euler_maclaurin()
+            >>> s
+            -log(2) + 7/20 + log(5)
+            >>> from sympy import sstr
+            >>> print(sstr((s.evalf(), e.evalf()), full_prec=True))
+            (1.26629073187415, 0.0175000000000000)
+
+        The endpoints may be symbolic:
+
+            >>> s, e = Sum(1/k, (k, a, b)).euler_maclaurin()
+            >>> s
+            -log(a) + log(b) + 1/(2*b) + 1/(2*a)
+            >>> e
+            Abs(1/(12*b**2) - 1/(12*a**2))
+
+        If the function is a polynomial of degree at most 2n+1, the
+        Euler-Maclaurin formula becomes exact (and e = 0 is returned):
+
+            >>> Sum(k, (k, 2, b)).euler_maclaurin()
+            (b**2/2 + b/2 - 1, 0)
+            >>> Sum(k, (k, 2, b)).doit()
+            b**2/2 + b/2 - 1
+
+        With a nonzero eps specified, the summation is ended
+        as soon as the remainder term is less than the epsilon.
+        """
+        m = int(m)
+        n = int(n)
+        f = self.function
+        if len(self.limits) != 1:
+            raise ValueError("More than 1 limit")
+        i, a, b = self.limits[0]
+        if (a > b) == True:
+            if a - b == 1:
+                return S.Zero, S.Zero
+            a, b = b + 1, a - 1
+            f = -f
+        s = S.Zero
+        if m:
+            if b.is_Integer and a.is_Integer:
+                m = min(m, b - a + 1)
+            if not eps or f.is_polynomial(i):
+                s = Add(*[f.subs(i, a + k) for k in range(m)])
+            else:
+                term = f.subs(i, a)
+                if term:
+                    test = abs(term.evalf(3)) < eps
+                    if test == True:
+                        return s, abs(term)
+                    elif not (test == False):
+                        # a symbolic Relational class, can't go further
+                        return term, S.Zero
+                s = term
+                for k in range(1, m):
+                    term = f.subs(i, a + k)
+                    if abs(term.evalf(3)) < eps and term != 0:
+                        return s, abs(term)
+                    s += term
+            if b - a + 1 == m:
+                return s, S.Zero
+            a += m
+        x = Dummy('x')
+        I = Integral(f.subs(i, x), (x, a, b))
+        if eval_integral:
+            I = I.doit()
+        s += I
+
+        def fpoint(expr):
+            if b is S.Infinity:
+                return expr.subs(i, a), 0
+            return expr.subs(i, a), expr.subs(i, b)
+        fa, fb = fpoint(f)
+        iterm = (fa + fb)/2
+        g = f.diff(i)
+        for k in range(1, n + 2):
+            ga, gb = fpoint(g)
+            term = bernoulli(2*k)/factorial(2*k)*(gb - ga)
+            if k > n:
+                break
+            if eps and term:
+                term_evalf = term.evalf(3)
+                if term_evalf is S.NaN:
+                    return S.NaN, S.NaN
+                if abs(term_evalf) < eps:
+                    break
+            s += term
+            g = g.diff(i, 2, simplify=False)
+        return s + iterm, abs(term)
+
+
+    def reverse_order(self, *indices):
+        """
+        Reverse the order of a limit in a Sum.
+
+        Explanation
+        ===========
+
+        ``reverse_order(self, *indices)`` reverses some limits in the expression
+        ``self`` which can be either a ``Sum`` or a ``Product``. The selectors in
+        the argument ``indices`` specify some indices whose limits get reversed.
+        These selectors are either variable names or numerical indices counted
+        starting from the inner-most limit tuple.
+
+        Examples
+        ========
+
+        >>> from sympy import Sum
+        >>> from sympy.abc import x, y, a, b, c, d
+
+        >>> Sum(x, (x, 0, 3)).reverse_order(x)
+        Sum(-x, (x, 4, -1))
+        >>> Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(x, y)
+        Sum(x*y, (x, 6, 0), (y, 7, -1))
+        >>> Sum(x, (x, a, b)).reverse_order(x)
+        Sum(-x, (x, b + 1, a - 1))
+        >>> Sum(x, (x, a, b)).reverse_order(0)
+        Sum(-x, (x, b + 1, a - 1))
+
+        While one should prefer variable names when specifying which limits
+        to reverse, the index counting notation comes in handy in case there
+        are several symbols with the same name.
+
+        >>> S = Sum(x**2, (x, a, b), (x, c, d))
+        >>> S
+        Sum(x**2, (x, a, b), (x, c, d))
+        >>> S0 = S.reverse_order(0)
+        >>> S0
+        Sum(-x**2, (x, b + 1, a - 1), (x, c, d))
+        >>> S1 = S0.reverse_order(1)
+        >>> S1
+        Sum(x**2, (x, b + 1, a - 1), (x, d + 1, c - 1))
+
+        Of course we can mix both notations:
+
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+        >>> Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x)
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+        See Also
+        ========
+
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.index, reorder_limit,
+        sympy.concrete.expr_with_intlimits.ExprWithIntLimits.reorder
+
+        References
+        ==========
+
+        .. [1] Michael Karr, "Summation in Finite Terms", Journal of the ACM,
+               Volume 28 Issue 2, April 1981, Pages 305-350
+               https://dl.acm.org/doi/10.1145/322248.322255
+        """
+        l_indices = list(indices)
+
+        for i, indx in enumerate(l_indices):
+            if not isinstance(indx, int):
+                l_indices[i] = self.index(indx)
+
+        e = 1
+        limits = []
+        for i, limit in enumerate(self.limits):
+            l = limit
+            if i in l_indices:
+                e = -e
+                l = (limit[0], limit[2] + 1, limit[1] - 1)
+            limits.append(l)
+
+        return Sum(e * self.function, *limits)
+
+    def _eval_rewrite_as_Product(self, *args, **kwargs):
+        from sympy.concrete.products import Product
+        if self.function.is_extended_real:
+            return log(Product(exp(self.function), *self.limits))
+
+
+def summation(f, *symbols, **kwargs):
+    r"""
+    Compute the summation of f with respect to symbols.
+
+    Explanation
+    ===========
+
+    The notation for symbols is similar to the notation used in Integral.
+    summation(f, (i, a, b)) computes the sum of f with respect to i from a to b,
+    i.e.,
+
+    ::
+
+                                    b
+                                  ____
+                                  \   `
+        summation(f, (i, a, b)) =  )    f
+                                  /___,
+                                  i = a
+
+    If it cannot compute the sum, it returns an unevaluated Sum object.
+    Repeated sums can be computed by introducing additional symbols tuples::
+
+    Examples
+    ========
+
+    >>> from sympy import summation, oo, symbols, log
+    >>> i, n, m = symbols('i n m', integer=True)
+
+    >>> summation(2*i - 1, (i, 1, n))
+    n**2
+    >>> summation(1/2**i, (i, 0, oo))
+    2
+    >>> summation(1/log(n)**n, (n, 2, oo))
+    Sum(log(n)**(-n), (n, 2, oo))
+    >>> summation(i, (i, 0, n), (n, 0, m))
+    m**3/6 + m**2/2 + m/3
+
+    >>> from sympy.abc import x
+    >>> from sympy import factorial
+    >>> summation(x**n/factorial(n), (n, 0, oo))
+    exp(x)
+
+    See Also
+    ========
+
+    Sum
+    Product, sympy.concrete.products.product
+
+    """
+    return Sum(f, *symbols, **kwargs).doit(deep=False)
+
+
+def telescopic_direct(L, R, n, limits):
+    """
+    Returns the direct summation of the terms of a telescopic sum
+
+    Explanation
+    ===========
+
+    L is the term with lower index
+    R is the term with higher index
+    n difference between the indexes of L and R
+
+    Examples
+    ========
+
+    >>> from sympy.concrete.summations import telescopic_direct
+    >>> from sympy.abc import k, a, b
+    >>> telescopic_direct(1/k, -1/(k+2), 2, (k, a, b))
+    -1/(b + 2) - 1/(b + 1) + 1/(a + 1) + 1/a
+
+    """
+    (i, a, b) = limits
+    return Add(*[L.subs(i, a + m) + R.subs(i, b - m) for m in range(n)])
+
+
+def telescopic(L, R, limits):
+    '''
+    Tries to perform the summation using the telescopic property.
+
+    Return None if not possible.
+    '''
+    (i, a, b) = limits
+    if L.is_Add or R.is_Add:
+        return None
+
+    # We want to solve(L.subs(i, i + m) + R, m)
+    # First we try a simple match since this does things that
+    # solve doesn't do, e.g. solve(cos(k+m)-cos(k), m) gives
+    # a more complicated solution than m == 0.
+
+    k = Wild("k")
+    sol = (-R).match(L.subs(i, i + k))
+    s = None
+    if sol and k in sol:
+        s = sol[k]
+        if not (s.is_Integer and L.subs(i, i + s) + R == 0):
+            # invalid match or match didn't work
+            s = None
+
+    # But there are things that match doesn't do that solve
+    # can do, e.g. determine that 1/(x + m) = 1/(1 - x) when m = 1
+
+    if s is None:
+        m = Dummy('m')
+        try:
+            from sympy.solvers.solvers import solve
+            sol = solve(L.subs(i, i + m) + R, m) or []
+        except NotImplementedError:
+            return None
+        sol = [si for si in sol if si.is_Integer and
+               (L.subs(i, i + si) + R).expand().is_zero]
+        if len(sol) != 1:
+            return None
+        s = sol[0]
+
+    if s < 0:
+        return telescopic_direct(R, L, abs(s), (i, a, b))
+    elif s > 0:
+        return telescopic_direct(L, R, s, (i, a, b))
+
+
+def eval_sum(f, limits):
+    (i, a, b) = limits
+    if f.is_zero:
+        return S.Zero
+    if i not in f.free_symbols:
+        return f*(b - a + 1)
+    if a == b:
+        return f.subs(i, a)
+    if a.is_comparable and b.is_comparable and a > b:
+        return eval_sum(f, (i, b + S.One, a - S.One))
+    if isinstance(f, Piecewise):
+        if not any(i in arg.args[1].free_symbols for arg in f.args):
+            # Piecewise conditions do not depend on the dummy summation variable,
+            # therefore we can fold:     Sum(Piecewise((e, c), ...), limits)
+            #                        --> Piecewise((Sum(e, limits), c), ...)
+            newargs = []
+            for arg in f.args:
+                newexpr = eval_sum(arg.expr, limits)
+                if newexpr is None:
+                    return None
+                newargs.append((newexpr, arg.cond))
+            return f.func(*newargs)
+
+    if f.has(KroneckerDelta):
+        from .delta import deltasummation, _has_simple_delta
+        f = f.replace(
+            lambda x: isinstance(x, Sum),
+            lambda x: x.factor()
+        )
+        if _has_simple_delta(f, limits[0]):
+            return deltasummation(f, limits)
+
+    dif = b - a
+    definite = dif.is_Integer
+    # Doing it directly may be faster if there are very few terms.
+    if definite and (dif < 100):
+        return eval_sum_direct(f, (i, a, b))
+    if isinstance(f, Piecewise):
+        return None
+    # Try to do it symbolically. Even when the number of terms is
+    # known, this can save time when b-a is big.
+    value = eval_sum_symbolic(f.expand(), (i, a, b))
+    if value is not None:
+        return value
+    # Do it directly
+    if definite:
+        return eval_sum_direct(f, (i, a, b))
+
+
+def eval_sum_direct(expr, limits):
+    """
+    Evaluate expression directly, but perform some simple checks first
+    to possibly result in a smaller expression and faster execution.
+    """
+    (i, a, b) = limits
+
+    dif = b - a
+    # Linearity
+    if expr.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+
+            if not L.has(i):
+                sR = eval_sum_direct(R, (i, a, b))
+                if sR:
+                    return L*sR
+
+            if not R.has(i):
+                sL = eval_sum_direct(L, (i, a, b))
+                if sL:
+                    return sL*R
+
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        expr = apart(expr, i)  # see if it becomes an Add
+    except PolynomialError:
+        pass
+
+    if expr.is_Add:
+        # Try factor out everything not including i
+        without_i, with_i = expr.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_direct(with_i, (i, a, b))
+            if s:
+                r = without_i*(dif + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = expr.as_two_terms()
+            lsum = eval_sum_direct(L, (i, a, b))
+            rsum = eval_sum_direct(R, (i, a, b))
+
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+
+    return Add(*[expr.subs(i, a + j) for j in range(dif + 1)])
+
+
+def eval_sum_symbolic(f, limits):
+    f_orig = f
+    (i, a, b) = limits
+    if not f.has(i):
+        return f*(b - a + 1)
+
+    # Linearity
+    if f.is_Mul:
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 1:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            L, R = f.as_two_terms()
+
+            if not L.has(i):
+                sR = eval_sum_symbolic(R, (i, a, b))
+                if sR:
+                    return L*sR
+
+            if not R.has(i):
+                sL = eval_sum_symbolic(L, (i, a, b))
+                if sL:
+                    return sL*R
+
+    # do this whether its an Add or Mul
+    # e.g. apart(1/(25*i**2 + 45*i + 14)) and
+    # apart(1/((5*i + 2)*(5*i + 7))) ->
+    # -1/(5*(5*i + 7)) + 1/(5*(5*i + 2))
+    try:
+        f = apart(f, i)
+    except PolynomialError:
+        pass
+
+    if f.is_Add:
+        L, R = f.as_two_terms()
+        lrsum = telescopic(L, R, (i, a, b))
+
+        if lrsum:
+            return lrsum
+
+        # Try factor out everything not including i
+        without_i, with_i = f.as_independent(i)
+        if without_i != 0:
+            s = eval_sum_symbolic(with_i, (i, a, b))
+            if s:
+                r = without_i*(b - a + 1) + s
+                if r is not S.NaN:
+                    return r
+        else:
+            # Try term by term
+            lsum = eval_sum_symbolic(L, (i, a, b))
+            rsum = eval_sum_symbolic(R, (i, a, b))
+
+            if None not in (lsum, rsum):
+                r = lsum + rsum
+                if r is not S.NaN:
+                    return r
+
+
+    # Polynomial terms with Faulhaber's formula
+    n = Wild('n')
+    result = f.match(i**n)
+
+    if result is not None:
+        n = result[n]
+
+        if n.is_Integer:
+            if n >= 0:
+                if (b is S.Infinity and a is not S.NegativeInfinity) or \
+                   (a is S.NegativeInfinity and b is not S.Infinity):
+                    return S.Infinity
+                return ((bernoulli(n + 1, b + 1) - bernoulli(n + 1, a))/(n + 1)).expand()
+            elif a.is_Integer and a >= 1:
+                if n == -1:
+                    return harmonic(b) - harmonic(a - 1)
+                else:
+                    return harmonic(b, abs(n)) - harmonic(a - 1, abs(n))
+
+    if not (a.has(S.Infinity, S.NegativeInfinity) or
+            b.has(S.Infinity, S.NegativeInfinity)):
+        # Geometric terms
+        c1 = Wild('c1', exclude=[i])
+        c2 = Wild('c2', exclude=[i])
+        c3 = Wild('c3', exclude=[i])
+        wexp = Wild('wexp')
+
+        # Here we first attempt powsimp on f for easier matching with the
+        # exponential pattern, and attempt expansion on the exponent for easier
+        # matching with the linear pattern.
+        e = f.powsimp().match(c1 ** wexp)
+        if e is not None:
+            e_exp = e.pop(wexp).expand().match(c2*i + c3)
+            if e_exp is not None:
+                e.update(e_exp)
+
+                p = (c1**c3).subs(e)
+                q = (c1**c2).subs(e)
+                r = p*(q**a - q**(b + 1))/(1 - q)
+                l = p*(b - a + 1)
+                return Piecewise((l, Eq(q, S.One)), (r, True))
+
+        r = gosper_sum(f, (i, a, b))
+
+        if isinstance(r, (Mul,Add)):
+            from sympy.simplify.radsimp import denom
+            from sympy.solvers.solvers import solve
+            non_limit = r.free_symbols - Tuple(*limits[1:]).free_symbols
+            den = denom(together(r))
+            den_sym = non_limit & den.free_symbols
+            args = []
+            for v in ordered(den_sym):
+                try:
+                    s = solve(den, v)
+                    m = Eq(v, s[0]) if s else S.false
+                    if m != False:
+                        args.append((Sum(f_orig.subs(*m.args), limits).doit(), m))
+                    break
+                except NotImplementedError:
+                    continue
+
+            args.append((r, True))
+            return Piecewise(*args)
+
+        if r not in (None, S.NaN):
+            return r
+
+    h = eval_sum_hyper(f_orig, (i, a, b))
+    if h is not None:
+        return h
+
+    r = eval_sum_residue(f_orig, (i, a, b))
+    if r is not None:
+        return r
+
+    factored = f_orig.factor()
+    if factored != f_orig:
+        return eval_sum_symbolic(factored, (i, a, b))
+
+
+def _eval_sum_hyper(f, i, a):
+    """ Returns (res, cond). Sums from a to oo. """
+    if a != 0:
+        return _eval_sum_hyper(f.subs(i, i + a), i, 0)
+
+    if f.subs(i, 0) == 0:
+        from sympy.simplify.simplify import simplify
+        if simplify(f.subs(i, Dummy('i', integer=True, positive=True))) == 0:
+            return S.Zero, True
+        return _eval_sum_hyper(f.subs(i, i + 1), i, 0)
+
+    from sympy.simplify.simplify import hypersimp
+    hs = hypersimp(f, i)
+    if hs is None:
+        return None
+
+    if isinstance(hs, Float):
+        from sympy.simplify.simplify import nsimplify
+        hs = nsimplify(hs)
+
+    from sympy.simplify.combsimp import combsimp
+    from sympy.simplify.hyperexpand import hyperexpand
+    from sympy.simplify.radsimp import fraction
+    numer, denom = fraction(factor(hs))
+    top, topl = numer.as_coeff_mul(i)
+    bot, botl = denom.as_coeff_mul(i)
+    ab = [top, bot]
+    factors = [topl, botl]
+    params = [[], []]
+    for k in range(2):
+        for fac in factors[k]:
+            mul = 1
+            if fac.is_Pow:
+                mul = fac.exp
+                fac = fac.base
+                if not mul.is_Integer:
+                    return None
+            p = Poly(fac, i)
+            if p.degree() != 1:
+                return None
+            m, n = p.all_coeffs()
+            ab[k] *= m**mul
+            params[k] += [n/m]*mul
+
+    # Add "1" to numerator parameters, to account for implicit n! in
+    # hypergeometric series.
+    ap = params[0] + [1]
+    bq = params[1]
+    x = ab[0]/ab[1]
+    h = hyper(ap, bq, x)
+    f = combsimp(f)
+    return f.subs(i, 0)*hyperexpand(h), h.convergence_statement
+
+
+def eval_sum_hyper(f, i_a_b):
+    i, a, b = i_a_b
+
+    if f.is_hypergeometric(i) is False:
+        return
+
+    if (b - a).is_Integer:
+        # We are never going to do better than doing the sum in the obvious way
+        return None
+
+    old_sum = Sum(f, (i, a, b))
+
+    if b != S.Infinity:
+        if a is S.NegativeInfinity:
+            res = _eval_sum_hyper(f.subs(i, -i), i, -b)
+            if res is not None:
+                return Piecewise(res, (old_sum, True))
+        else:
+            n_illegal = lambda x: sum(x.count(_) for _ in _illegal)
+            had = n_illegal(f)
+            # check that no extra illegals are introduced
+            res1 = _eval_sum_hyper(f, i, a)
+            if res1 is None or n_illegal(res1) > had:
+                return
+            res2 = _eval_sum_hyper(f, i, b + 1)
+            if res2 is None or n_illegal(res2) > had:
+                return
+            (res1, cond1), (res2, cond2) = res1, res2
+            cond = And(cond1, cond2)
+            if cond == False:
+                return None
+            return Piecewise((res1 - res2, cond), (old_sum, True))
+
+    if a is S.NegativeInfinity:
+        res1 = _eval_sum_hyper(f.subs(i, -i), i, 1)
+        res2 = _eval_sum_hyper(f, i, 0)
+        if res1 is None or res2 is None:
+            return None
+        res1, cond1 = res1
+        res2, cond2 = res2
+        cond = And(cond1, cond2)
+        if cond == False or cond.as_set() == S.EmptySet:
+            return None
+        return Piecewise((res1 + res2, cond), (old_sum, True))
+
+    # Now b == oo, a != -oo
+    res = _eval_sum_hyper(f, i, a)
+    if res is not None:
+        r, c = res
+        if c == False:
+            if r.is_number:
+                f = f.subs(i, Dummy('i', integer=True, positive=True) + a)
+                if f.is_positive or f.is_zero:
+                    return S.Infinity
+                elif f.is_negative:
+                    return S.NegativeInfinity
+            return None
+        return Piecewise(res, (old_sum, True))
+
+
+def eval_sum_residue(f, i_a_b):
+    r"""Compute the infinite summation with residues
+
+    Notes
+    =====
+
+    If $f(n), g(n)$ are polynomials with $\deg(g(n)) - \deg(f(n)) \ge 2$,
+    some infinite summations can be computed by the following residue
+    evaluations.
+
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\cot(\pi x) \frac{f(x)}{g(x)}, \alpha)
+
+    .. math::
+        \sum_{n=-\infty, g(n) \ne 0}^{\infty} (-1)^n \frac{f(n)}{g(n)} =
+        -\pi \sum_{\alpha|g(\alpha)=0}
+        \text{Res}(\csc(\pi x) \frac{f(x)}{g(x)}, \alpha)
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, oo, Symbol
+    >>> x = Symbol('x')
+
+    Doubly infinite series of rational functions.
+
+    >>> Sum(1 / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/tanh(pi)
+
+    Doubly infinite alternating series of rational functions.
+
+    >>> Sum((-1)**x / (x**2 + 1), (x, -oo, oo)).doit()
+    pi/sinh(pi)
+
+    Infinite series of even rational functions.
+
+    >>> Sum(1 / (x**2 + 1), (x, 0, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+
+    Infinite series of alternating even rational functions.
+
+    >>> Sum((-1)**x / (x**2 + 1), (x, 0, oo)).doit()
+    pi/(2*sinh(pi)) + 1/2
+
+    This also have heuristics to transform arbitrarily shifted summand or
+    arbitrarily shifted summation range to the canonical problem the
+    formula can handle.
+
+    >>> Sum(1 / (x**2 + 2*x + 2), (x, -1, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 4*x + 5), (x, -2, oo)).doit()
+    1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 1, oo)).doit()
+    -1/2 + pi/(2*tanh(pi))
+    >>> Sum(1 / (x**2 + 1), (x, 2, oo)).doit()
+    -1 + pi/(2*tanh(pi))
+
+    References
+    ==========
+
+    .. [#] http://www.supermath.info/InfiniteSeriesandtheResidueTheorem.pdf
+
+    .. [#] Asmar N.H., Grafakos L. (2018) Residue Theory.
+           In: Complex Analysis with Applications.
+           Undergraduate Texts in Mathematics. Springer, Cham.
+           https://doi.org/10.1007/978-3-319-94063-2_5
+    """
+    i, a, b = i_a_b
+
+    # If lower limit > upper limit: Karr Summation Convention
+    if a.is_comparable and b.is_comparable and a > b:
+        return eval_sum_residue(f, (i, b + S.One, a - S.One))
+
+    def is_even_function(numer, denom):
+        """Test if the rational function is an even function"""
+        numer_even = all(i % 2 == 0 for (i,) in numer.monoms())
+        denom_even = all(i % 2 == 0 for (i,) in denom.monoms())
+        numer_odd = all(i % 2 == 1 for (i,) in numer.monoms())
+        denom_odd = all(i % 2 == 1 for (i,) in denom.monoms())
+        return (numer_even and denom_even) or (numer_odd and denom_odd)
+
+    def match_rational(f, i):
+        numer, denom = f.as_numer_denom()
+        try:
+            (numer, denom), opt = parallel_poly_from_expr((numer, denom), i)
+        except (PolificationFailed, PolynomialError):
+            return None
+        return numer, denom
+
+    def get_poles(denom):
+        roots = denom.sqf_part().all_roots()
+        roots = sift(roots, lambda x: x.is_integer)
+        if None in roots:
+            return None
+        int_roots, nonint_roots = roots[True], roots[False]
+        return int_roots, nonint_roots
+
+    def get_shift(denom):
+        n = denom.degree(i)
+        a = denom.coeff_monomial(i**n)
+        b = denom.coeff_monomial(i**(n-1))
+        shift = - b / a / n
+        return shift
+
+    #Need a dummy symbol with no assumptions set for get_residue_factor
+    z = Dummy('z')
+
+    def get_residue_factor(numer, denom, alternating):
+        residue_factor = (numer.as_expr() / denom.as_expr()).subs(i, z)
+        if not alternating:
+            residue_factor *= cot(S.Pi * z)
+        else:
+            residue_factor *= csc(S.Pi * z)
+        return residue_factor
+
+    # We don't know how to deal with symbolic constants in summand
+    if f.free_symbols - {i}:
+        return None
+
+    if not (a.is_Integer or a in (S.Infinity, S.NegativeInfinity)):
+        return None
+    if not (b.is_Integer or b in (S.Infinity, S.NegativeInfinity)):
+        return None
+
+    # Quick exit heuristic for the sums which doesn't have infinite range
+    if a != S.NegativeInfinity and b != S.Infinity:
+        return None
+
+    match = match_rational(f, i)
+    if match:
+        alternating = False
+        numer, denom = match
+    else:
+        match = match_rational(f / S.NegativeOne**i, i)
+        if match:
+            alternating = True
+            numer, denom = match
+        else:
+            return None
+
+    if denom.degree(i) - numer.degree(i) < 2:
+        return None
+
+    if (a, b) == (S.NegativeInfinity, S.Infinity):
+        poles = get_poles(denom)
+        if poles is None:
+            return None
+        int_roots, nonint_roots = poles
+
+        if int_roots:
+            return None
+
+        residue_factor = get_residue_factor(numer, denom, alternating)
+        residues = [residue(residue_factor, z, root) for root in nonint_roots]
+        return -S.Pi * sum(residues)
+
+    if not (a.is_finite and b is S.Infinity):
+        return None
+
+    if not is_even_function(numer, denom):
+        # Try shifting summation and check if the summand can be made
+        # and even function from the origin.
+        # Sum(f(n), (n, a, b)) => Sum(f(n + s), (n, a - s, b - s))
+        shift = get_shift(denom)
+
+        if not shift.is_Integer:
+            return None
+        if shift == 0:
+            return None
+
+        numer = numer.shift(shift)
+        denom = denom.shift(shift)
+
+        if not is_even_function(numer, denom):
+            return None
+
+        if alternating:
+            f = S.NegativeOne**i * (S.NegativeOne**shift * numer.as_expr() / denom.as_expr())
+        else:
+            f = numer.as_expr() / denom.as_expr()
+        return eval_sum_residue(f, (i, a-shift, b-shift))
+
+    poles = get_poles(denom)
+    if poles is None:
+        return None
+    int_roots, nonint_roots = poles
+
+    if int_roots:
+        int_roots = [int(root) for root in int_roots]
+        int_roots_max = max(int_roots)
+        int_roots_min = min(int_roots)
+        # Integer valued poles must be next to each other
+        # and also symmetric from origin (Because the function is even)
+        if not len(int_roots) == int_roots_max - int_roots_min + 1:
+            return None
+
+        # Check whether the summation indices contain poles
+        if a <= max(int_roots):
+            return None
+
+    residue_factor = get_residue_factor(numer, denom, alternating)
+    residues = [residue(residue_factor, z, root) for root in int_roots + nonint_roots]
+    full_sum = -S.Pi * sum(residues)
+
+    if not int_roots:
+        # Compute Sum(f, (i, 0, oo)) by adding a extraneous evaluation
+        # at the origin.
+        half_sum = (full_sum + f.xreplace({i: 0})) / 2
+
+        # Add and subtract extraneous evaluations
+        extraneous_neg = [f.xreplace({i: i0}) for i0 in range(int(a), 0)]
+        extraneous_pos = [f.xreplace({i: i0}) for i0 in range(0, int(a))]
+        result = half_sum + sum(extraneous_neg) - sum(extraneous_pos)
+
+        return result
+
+    # Compute Sum(f, (i, min(poles) + 1, oo))
+    half_sum = full_sum / 2
+
+    # Subtract extraneous evaluations
+    extraneous = [f.xreplace({i: i0}) for i0 in range(max(int_roots) + 1, int(a))]
+    result = half_sum - sum(extraneous)
+
+    return result
+
+
+def _eval_matrix_sum(expression):
+    f = expression.function
+    for limit in expression.limits:
+        i, a, b = limit
+        dif = b - a
+        if dif.is_Integer:
+            if (dif < 0) == True:
+                a, b = b + 1, a - 1
+                f = -f
+
+            newf = eval_sum_direct(f, (i, a, b))
+            if newf is not None:
+                return newf.doit()
+
+
+def _dummy_with_inherited_properties_concrete(limits):
+    """
+    Return a Dummy symbol that inherits as many assumptions as possible
+    from the provided symbol and limits.
+
+    If the symbol already has all True assumption shared by the limits
+    then return None.
+    """
+    x, a, b = limits
+    l = [a, b]
+
+    assumptions_to_consider = ['extended_nonnegative', 'nonnegative',
+                               'extended_nonpositive', 'nonpositive',
+                               'extended_positive', 'positive',
+                               'extended_negative', 'negative',
+                               'integer', 'rational', 'finite',
+                               'zero', 'real', 'extended_real']
+
+    assumptions_to_keep = {}
+    assumptions_to_add = {}
+    for assum in assumptions_to_consider:
+        assum_true = x._assumptions.get(assum, None)
+        if assum_true:
+            assumptions_to_keep[assum] = True
+        elif all(getattr(i, 'is_' + assum) for i in l):
+            assumptions_to_add[assum] = True
+    if assumptions_to_add:
+        assumptions_to_keep.update(assumptions_to_add)
+        return Dummy('d', **assumptions_to_keep)
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ae729b2f4f60ad38e4c0bd11be351e194e5c9bf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_delta.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_delta.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d9e460b7ea1abca94410835a5df3101a5fd18e9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_delta.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_gosper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_gosper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..91e7a84babd3eeb6fc725e5050c8fd1f94904bad
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_gosper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_guess.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_guess.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..adc8ca780e802f5e608f33995f798c3dd097d132
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_guess.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_products.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_products.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..431976082979dac9907c227a4344a29dea6fd9ec
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_products.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_sums_products.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_sums_products.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d041f11b8e2e6dcf21ab378bee1b13ed81ae8197
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/__pycache__/test_sums_products.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95de5338ec55d0176b6a2a149a091cf1a4bd52152c537d2d96278375a4f3536c
+size 163215
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_delta.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_delta.py
new file mode 100644
index 0000000000000000000000000000000000000000..9dc6e88d16346acc7dc775446d7de3f3696d0e03
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_delta.py
@@ -0,0 +1,499 @@
+from sympy.concrete import Sum
+from sympy.concrete.delta import deltaproduct as dp, deltasummation as ds, _extract_delta
+from sympy.core import Eq, S, symbols, oo
+from sympy.functions import KroneckerDelta as KD, Piecewise, piecewise_fold
+from sympy.logic import And
+from sympy.testing.pytest import raises
+
+i, j, k, l, m = symbols("i j k l m", integer=True, finite=True)
+x, y = symbols("x y", commutative=False)
+
+
+def test_deltaproduct_trivial():
+    assert dp(x, (j, 1, 0)) == 1
+    assert dp(x, (j, 1, 3)) == x**3
+    assert dp(x + y, (j, 1, 3)) == (x + y)**3
+    assert dp(x*y, (j, 1, 3)) == (x*y)**3
+    assert dp(KD(i, j), (k, 1, 3)) == KD(i, j)
+    assert dp(x*KD(i, j), (k, 1, 3)) == x**3*KD(i, j)
+    assert dp(x*y*KD(i, j), (k, 1, 3)) == (x*y)**3*KD(i, j)
+
+
+def test_deltaproduct_basic():
+    assert dp(KD(i, j), (j, 1, 3)) == 0
+    assert dp(KD(i, j), (j, 1, 1)) == KD(i, 1)
+    assert dp(KD(i, j), (j, 2, 2)) == KD(i, 2)
+    assert dp(KD(i, j), (j, 3, 3)) == KD(i, 3)
+    assert dp(KD(i, j), (j, 1, k)) == KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(KD(i, j), (j, k, 3)) == KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(KD(i, j), (j, k, l)) == KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_x_kd():
+    assert dp(x*KD(i, j), (j, 1, 3)) == 0
+    assert dp(x*KD(i, j), (j, 1, 1)) == x*KD(i, 1)
+    assert dp(x*KD(i, j), (j, 2, 2)) == x*KD(i, 2)
+    assert dp(x*KD(i, j), (j, 3, 3)) == x*KD(i, 3)
+    assert dp(x*KD(i, j), (j, 1, k)) == x*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp(x*KD(i, j), (j, k, 3)) == x*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp(x*KD(i, j), (j, k, l)) == x*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_mul_add_x_y_kd():
+    assert dp((x + y)*KD(i, j), (j, 1, 3)) == 0
+    assert dp((x + y)*KD(i, j), (j, 1, 1)) == (x + y)*KD(i, 1)
+    assert dp((x + y)*KD(i, j), (j, 2, 2)) == (x + y)*KD(i, 2)
+    assert dp((x + y)*KD(i, j), (j, 3, 3)) == (x + y)*KD(i, 3)
+    assert dp((x + y)*KD(i, j), (j, 1, k)) == \
+        (x + y)*KD(i, 1)*KD(k, 1) + KD(k, 0)
+    assert dp((x + y)*KD(i, j), (j, k, 3)) == \
+        (x + y)*KD(i, 3)*KD(k, 3) + KD(k, 4)
+    assert dp((x + y)*KD(i, j), (j, k, l)) == \
+        (x + y)*KD(i, l)*KD(k, l) + KD(k, l + 1)
+
+
+def test_deltaproduct_add_kd_kd():
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 3)) == 0
+    assert dp(KD(i, k) + KD(j, k), (k, 1, 1)) == KD(i, 1) + KD(j, 1)
+    assert dp(KD(i, k) + KD(j, k), (k, 2, 2)) == KD(i, 2) + KD(j, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, 3, 3)) == KD(i, 3) + KD(j, 3)
+    assert dp(KD(i, k) + KD(j, k), (k, 1, l)) == KD(l, 0) + \
+        KD(i, 1)*KD(l, 1) + KD(j, 1)*KD(l, 1) + \
+        KD(i, 1)*KD(j, 2)*KD(l, 2) + KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, 3)) == KD(l, 4) + \
+        KD(i, 3)*KD(l, 3) + KD(j, 3)*KD(l, 3) + \
+        KD(i, 2)*KD(j, 3)*KD(l, 2) + KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(KD(i, k) + KD(j, k), (k, l, m)) == KD(l, m + 1) + \
+        KD(i, m)*KD(l, m) + KD(j, m)*KD(l, m) + \
+        KD(i, m)*KD(j, m - 1)*KD(l, m - 1) + KD(i, m - 1)*KD(j, m)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_x_add_kd_kd():
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == x*(KD(i, 1) + KD(j, 1))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == x*(KD(i, 2) + KD(j, 2))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == x*(KD(i, 3) + KD(j, 3))
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        x*KD(i, 1)*KD(l, 1) + x*KD(j, 1)*KD(l, 1) + \
+        x**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + x**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        x*KD(i, 3)*KD(l, 3) + x*KD(j, 3)*KD(l, 3) + \
+        x**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + x**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp(x*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        x*KD(i, m)*KD(l, m) + x*KD(j, m)*KD(l, m) + \
+        x**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        x**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_mul_add_x_y_add_kd_kd():
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == \
+        (x + y)*(KD(i, 1) + KD(j, 1))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == \
+        (x + y)*(KD(i, 2) + KD(j, 2))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == \
+        (x + y)*(KD(i, 3) + KD(j, 3))
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
+        (x + y)*KD(i, 1)*KD(l, 1) + (x + y)*KD(j, 1)*KD(l, 1) + \
+        (x + y)**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + \
+        (x + y)**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
+        (x + y)*KD(i, 3)*KD(l, 3) + (x + y)*KD(j, 3)*KD(l, 3) + \
+        (x + y)**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + \
+        (x + y)**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
+    assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
+        (x + y)*KD(i, m)*KD(l, m) + (x + y)*KD(j, m)*KD(l, m) + \
+        (x + y)**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
+        (x + y)**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
+
+
+def test_deltaproduct_add_mul_x_y_mul_x_kd():
+    assert dp(x*y + x*KD(i, j), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, 1)) == x*y + x*KD(i, 1)
+    assert dp(x*y + x*KD(i, j), (j, 2, 2)) == x*y + x*KD(i, 2)
+    assert dp(x*y + x*KD(i, j), (j, 3, 3)) == x*y + x*KD(i, 3)
+    assert dp(x*y + x*KD(i, j), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, 3)) == \
+        (x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )
+    assert dp(x*y + x*KD(i, j), (j, k, l)) == \
+        (x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )
+
+
+def test_deltaproduct_mul_x_add_y_kd():
+    assert dp(x*(y + KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + KD(i, j)), (j, 1, 1)) == x*(y + KD(i, 1))
+    assert dp(x*(y + KD(i, j)), (j, 2, 2)) == x*(y + KD(i, 2))
+    assert dp(x*(y + KD(i, j)), (j, 3, 3)) == x*(y + KD(i, 3))
+    assert dp(x*(y + KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            ((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            ((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_x_add_y_twokd():
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
+        2*x*(x*y)**2*KD(i, 1) + 2*x*y*x*x*y*KD(i, 2) + 2*(x*y)**2*x*KD(i, 3)
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, 1)) == x*(y + 2*KD(i, 1))
+    assert dp(x*(y + 2*KD(i, j)), (j, 2, 2)) == x*(y + 2*KD(i, 2))
+    assert dp(x*(y + 2*KD(i, j)), (j, 3, 3)) == x*(y + 2*KD(i, 3))
+    assert dp(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        (x*y)**k + Piecewise(
+            (2*(x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
+            (0, True)
+        ).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, 3)) == \
+        ((x*y)**(-k + 4) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
+            (0, True)
+        )).expand()
+    assert dp(x*(y + 2*KD(i, j)), (j, k, l)) == \
+        ((x*y)**(-k + l + 1) + Piecewise(
+            (2*(x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
+            (0, True)
+        )).expand()
+
+
+def test_deltaproduct_mul_add_x_y_add_y_kd():
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 3)) == ((x + y)*y)**3 + \
+        (x + y)*((x + y)*y)**2*KD(i, 1) + \
+        (x + y)*y*(x + y)**2*y*KD(i, 2) + \
+        ((x + y)*y)**2*(x + y)*KD(i, 3)
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, 1)) == (x + y)*(y + KD(i, 1))
+    assert dp((x + y)*(y + KD(i, j)), (j, 2, 2)) == (x + y)*(y + KD(i, 2))
+    assert dp((x + y)*(y + KD(i, j)), (j, 3, 3)) == (x + y)*(y + KD(i, 3))
+    assert dp((x + y)*(y + KD(i, j)), (j, 1, k)) == \
+        ((x + y)*y)**k + Piecewise(
+            (((x + y)*y)**(-1)*((x + y)*y)**i*(x + y)*((x + y)*y
+            )**k*((x + y)*y)**(-i), (i >= 1) & (i <= k)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, 3)) == (
+        (x + y)*y)**4*((x + y)*y)**(-k) + Piecewise((((x + y)*y)**i*(
+        (x + y)*y)**(-k)*(x + y)*((x + y)*y)**3*((x + y)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + y)*(y + KD(i, j)), (j, k, l)) == \
+        (x + y)*y*((x + y)*y)**l*((x + y)*y)**(-k) + Piecewise(
+        (((x + y)*y)**i*((x + y)*y)**(-k)*(x + y)*((x + y)*y
+        )**l*((x + y)*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltaproduct_mul_add_x_kd_add_y_kd():
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == \
+        KD(i, 1)*(KD(i, k) + x)*((KD(i, k) + x)*y)**2 + \
+        KD(i, 2)*(KD(i, k) + x)*y*(KD(i, k) + x)**2*y + \
+        KD(i, 3)*((KD(i, k) + x)*y)**2*(KD(i, k) + x) + \
+        ((KD(i, k) + x)*y)**3
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == \
+        (x + KD(i, k))*(y + KD(i, 1))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == \
+        (x + KD(i, k))*(y + KD(i, 2))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == \
+        (x + KD(i, k))*(y + KD(i, 3))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == \
+        ((KD(i, k) + x)*y)**k + Piecewise(
+        (((KD(i, k) + x)*y)**(-1)*((KD(i, k) + x)*y)**i*(KD(i, k) + x
+        )*((KD(i, k) + x)*y)**k*((KD(i, k) + x)*y)**(-i), (i >= 1
+        ) & (i <= k)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == (
+        (KD(i, k) + x)*y)**4*((KD(i, k) + x)*y)**(-k) + Piecewise(
+        (((KD(i, k) + x)*y)**i*((KD(i, k) + x)*y)**(-k)*(KD(i, k)
+        + x)*((KD(i, k) + x)*y)**3*((KD(i, k) + x)*y)**(-i),
+        (i >= k) & (i <= 3)), (0, True))
+    assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == (
+        KD(i, k) + x)*y*((KD(i, k) + x)*y)**l*((KD(i, k) + x)*y
+        )**(-k) + Piecewise((((KD(i, k) + x)*y)**i*((KD(i, k) + x
+        )*y)**(-k)*(KD(i, k) + x)*((KD(i, k) + x)*y)**l*((KD(i, k) + x
+        )*y)**(-i), (i >= k) & (i <= l)), (0, True))
+
+
+def test_deltasummation_trivial():
+    assert ds(x, (j, 1, 0)) == 0
+    assert ds(x, (j, 1, 3)) == 3*x
+    assert ds(x + y, (j, 1, 3)) == 3*(x + y)
+    assert ds(x*y, (j, 1, 3)) == 3*x*y
+    assert ds(KD(i, j), (k, 1, 3)) == 3*KD(i, j)
+    assert ds(x*KD(i, j), (k, 1, 3)) == 3*x*KD(i, j)
+    assert ds(x*y*KD(i, j), (k, 1, 3)) == 3*x*y*KD(i, j)
+
+
+def test_deltasummation_basic_numerical():
+    n = symbols('n', integer=True, nonzero=True)
+    assert ds(KD(n, 0), (n, 1, 3)) == 0
+
+    # return unevaluated, until it gets implemented
+    assert ds(KD(i**2, j**2), (j, -oo, oo)) == \
+        Sum(KD(i**2, j**2), (j, -oo, oo))
+
+    assert Piecewise((KD(i, k), And(1 <= i, i <= 3)), (0, True)) == \
+        ds(KD(i, j)*KD(j, k), (j, 1, 3)) == \
+        ds(KD(j, k)*KD(i, j), (j, 1, 3))
+
+    assert ds(KD(i, k), (k, -oo, oo)) == 1
+    assert ds(KD(i, k), (k, 0, oo)) == Piecewise((1, S.Zero <= i), (0, True))
+    assert ds(KD(i, k), (k, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(k*KD(i, j)*KD(j, k), (k, -oo, oo)) == j*KD(i, j)
+    assert ds(j*KD(i, j), (j, -oo, oo)) == i
+    assert ds(i*KD(i, j), (i, -oo, oo)) == j
+    assert ds(x, (i, 1, 3)) == 3*x
+    assert ds((i + j)*KD(i, j), (j, -oo, oo)) == 2*i
+
+
+def test_deltasummation_basic_symbolic():
+    assert ds(KD(i, j), (j, 1, 3)) == \
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, 1)) == Piecewise((1, Eq(i, 1)), (0, True))
+    assert ds(KD(i, j), (j, 2, 2)) == Piecewise((1, Eq(i, 2)), (0, True))
+    assert ds(KD(i, j), (j, 3, 3)) == Piecewise((1, Eq(i, 3)), (0, True))
+    assert ds(KD(i, j), (j, 1, k)) == \
+        Piecewise((1, And(1 <= i, i <= k)), (0, True))
+    assert ds(KD(i, j), (j, k, 3)) == \
+        Piecewise((1, And(k <= i, i <= 3)), (0, True))
+    assert ds(KD(i, j), (j, k, l)) == \
+        Piecewise((1, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_x_kd():
+    assert ds(x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, 1)) == Piecewise((x, Eq(i, 1)), (0, True))
+    assert ds(x*KD(i, j), (j, 2, 2)) == Piecewise((x, Eq(i, 2)), (0, True))
+    assert ds(x*KD(i, j), (j, 3, 3)) == Piecewise((x, Eq(i, 3)), (0, True))
+    assert ds(x*KD(i, j), (j, 1, k)) == \
+        Piecewise((x, And(1 <= i, i <= k)), (0, True))
+    assert ds(x*KD(i, j), (j, k, 3)) == \
+        Piecewise((x, And(k <= i, i <= 3)), (0, True))
+    assert ds(x*KD(i, j), (j, k, l)) == \
+        Piecewise((x, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_mul_add_x_y_kd():
+    assert ds((x + y)*KD(i, j), (j, 1, 3)) == \
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x + y, Eq(i, 1)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x + y, Eq(i, 2)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x + y, Eq(i, 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, 1, k)) == \
+        Piecewise((x + y, And(1 <= i, i <= k)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, 3)) == \
+        Piecewise((x + y, And(k <= i, i <= 3)), (0, True))
+    assert ds((x + y)*KD(i, j), (j, k, l)) == \
+        Piecewise((x + y, And(k <= i, i <= l)), (0, True))
+
+
+def test_deltasummation_add_kd_kd():
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((1, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((1, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((1, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((1, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((1, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_kd_kd():
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((1, Eq(j, 1)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((1, Eq(j, 2)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((1, Eq(j, 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((1, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((1, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_x_add_kd_kd():
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x, Eq(i, 1)), (0, True)) +
+        Piecewise((x, Eq(j, 1)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x, Eq(i, 2)), (0, True)) +
+        Piecewise((x, Eq(j, 2)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x, Eq(i, 3)), (0, True)) +
+        Piecewise((x, Eq(j, 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x, And(1 <= j, j <= l)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= 3)), (0, True)))
+    assert ds(x*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_mul_add_x_y_add_kd_kd():
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 1)), (0, True)) +
+        Piecewise((x + y, Eq(j, 1)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 2)), (0, True)) +
+        Piecewise((x + y, Eq(j, 2)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
+        Piecewise((x + y, Eq(i, 3)), (0, True)) +
+        Piecewise((x + y, Eq(j, 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
+        Piecewise((x + y, And(1 <= i, i <= l)), (0, True)) +
+        Piecewise((x + y, And(1 <= j, j <= l)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= 3)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= 3)), (0, True)))
+    assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
+        Piecewise((x + y, And(l <= i, i <= m)), (0, True)) +
+        Piecewise((x + y, And(l <= j, j <= m)), (0, True)))
+
+
+def test_deltasummation_add_mul_x_y_mul_x_kd():
+    assert ds(x*y + x*KD(i, j), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*y + x*KD(i, j), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_kd():
+    assert ds(x*(y + KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, 3)) == \
+        Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_x_add_y_twokd():
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 3)) == \
+        Piecewise((3*x*y + 2*x, And(1 <= i, i <= 3)), (3*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, 1)) == \
+        Piecewise((x*y + 2*x, Eq(i, 1)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 2, 2)) == \
+        Piecewise((x*y + 2*x, Eq(i, 2)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 3, 3)) == \
+        Piecewise((x*y + 2*x, Eq(i, 3)), (x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, 1, k)) == \
+        Piecewise((k*x*y + 2*x, And(1 <= i, i <= k)), (k*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*x*y + 2*x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
+    assert ds(x*(y + 2*KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*x*y + 2*x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
+
+
+def test_deltasummation_mul_add_x_y_add_y_kd():
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 3)) == Piecewise(
+        (3*(x + y)*y + x + y, And(1 <= i, i <= 3)), (3*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, 1)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 1)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 2, 2)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 2)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 3, 3)) == \
+        Piecewise(((x + y)*y + x + y, Eq(i, 3)), ((x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, 1, k)) == Piecewise(
+        (k*(x + y)*y + x + y, And(1 <= i, i <= k)), (k*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, 3)) == Piecewise(
+        ((4 - k)*(x + y)*y + x + y, And(k <= i, i <= 3)),
+        ((4 - k)*(x + y)*y, True))
+    assert ds((x + y)*(y + KD(i, j)), (j, k, l)) == Piecewise(
+        ((l - k + 1)*(x + y)*y + x + y, And(k <= i, i <= l)),
+        ((l - k + 1)*(x + y)*y, True))
+
+
+def test_deltasummation_mul_add_x_kd_add_y_kd():
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= 3)), (0, True)) +
+        3*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 1)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 2)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, Eq(i, 3)), (0, True)) +
+        (KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(1 <= i, i <= k)), (0, True)) +
+        k*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= 3)), (0, True)) +
+        (4 - k)*(KD(i, k) + x)*y)
+    assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == piecewise_fold(
+        Piecewise((KD(i, k) + x, And(k <= i, i <= l)), (0, True)) +
+        (l - k + 1)*(KD(i, k) + x)*y)
+
+
+def test_extract_delta():
+    raises(ValueError, lambda: _extract_delta(KD(i, j) + KD(k, l), i))
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_gosper.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_gosper.py
new file mode 100644
index 0000000000000000000000000000000000000000..77b642a9b7cd55f96840a8e20e517206b6a6f8f0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_gosper.py
@@ -0,0 +1,204 @@
+"""Tests for Gosper's algorithm for hypergeometric summation. """
+
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import (binomial, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.gamma_functions import gamma
+from sympy.polys.polytools import Poly
+from sympy.simplify.simplify import simplify
+from sympy.concrete.gosper import gosper_normal, gosper_sum, gosper_term
+from sympy.abc import a, b, j, k, m, n, r, x
+
+
+def test_gosper_normal():
+    eq = 4*n + 5, 2*(4*n + 1)*(2*n + 3), n
+    assert gosper_normal(*eq) == \
+        (Poly(Rational(1, 4), n), Poly(n + Rational(3, 2)), Poly(n + Rational(1, 4)))
+    assert gosper_normal(*eq, polys=False) == \
+        (Rational(1, 4), n + Rational(3, 2), n + Rational(1, 4))
+
+
+def test_gosper_term():
+    assert gosper_term((4*k + 1)*factorial(
+        k)/factorial(2*k + 1), k) == (-k - S.Half)/(k + Rational(1, 4))
+
+
+def test_gosper_sum():
+    assert gosper_sum(1, (k, 0, n)) == 1 + n
+    assert gosper_sum(k, (k, 0, n)) == n*(1 + n)/2
+    assert gosper_sum(k**2, (k, 0, n)) == n*(1 + n)*(1 + 2*n)/6
+    assert gosper_sum(k**3, (k, 0, n)) == n**2*(1 + n)**2/4
+
+    assert gosper_sum(2**k, (k, 0, n)) == 2*2**n - 1
+
+    assert gosper_sum(factorial(k), (k, 0, n)) is None
+    assert gosper_sum(binomial(n, k), (k, 0, n)) is None
+
+    assert gosper_sum(factorial(k)/k**2, (k, 0, n)) is None
+    assert gosper_sum((k - 3)*factorial(k), (k, 0, n)) is None
+
+    assert gosper_sum(k*factorial(k), k) == factorial(k)
+    assert gosper_sum(
+        k*factorial(k), (k, 0, n)) == n*factorial(n) + factorial(n) - 1
+
+    assert gosper_sum((-1)**k*binomial(n, k), (k, 0, n)) == 0
+    assert gosper_sum((
+        -1)**k*binomial(n, k), (k, 0, m)) == -(-1)**m*(m - n)*binomial(n, m)/n
+
+    assert gosper_sum((4*k + 1)*factorial(k)/factorial(2*k + 1), (k, 0, n)) == \
+        (2*factorial(2*n + 1) - factorial(n))/factorial(2*n + 1)
+
+    # issue 6033:
+    assert gosper_sum(
+        n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b)), \
+        (n, 0, m)).simplify() == -exp(m*log(a) + m*log(b))*gamma(a + 1) \
+        *gamma(b + 1)/(gamma(a)*gamma(b)*gamma(a + m + 1)*gamma(b + m + 1)) \
+        + 1/(gamma(a)*gamma(b))
+
+
+def test_gosper_sum_indefinite():
+    assert gosper_sum(k, k) == k*(k - 1)/2
+    assert gosper_sum(k**2, k) == k*(k - 1)*(2*k - 1)/6
+
+    assert gosper_sum(1/(k*(k + 1)), k) == -1/k
+    assert gosper_sum(-(27*k**4 + 158*k**3 + 430*k**2 + 678*k + 445)*gamma(2*k
+                      + 4)/(3*(3*k + 7)*gamma(3*k + 6)), k) == \
+        (3*k + 5)*(k**2 + 2*k + 5)*gamma(2*k + 4)/gamma(3*k + 6)
+
+
+def test_gosper_sum_parametric():
+    assert gosper_sum(binomial(S.Half, m - j + 1)*binomial(S.Half, m + j), (j, 1, n)) == \
+        n*(1 + m - n)*(-1 + 2*m + 2*n)*binomial(S.Half, 1 + m - n)* \
+        binomial(S.Half, m + n)/(m*(1 + 2*m))
+
+
+def test_gosper_sum_algebraic():
+    assert gosper_sum(
+        n**2 + sqrt(2), (n, 0, m)) == (m + 1)*(2*m**2 + m + 6*sqrt(2))/6
+
+
+def test_gosper_sum_iterated():
+    f1 = binomial(2*k, k)/4**k
+    f2 = (1 + 2*n)*binomial(2*n, n)/4**n
+    f3 = (1 + 2*n)*(3 + 2*n)*binomial(2*n, n)/(3*4**n)
+    f4 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*binomial(2*n, n)/(15*4**n)
+    f5 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*(7 + 2*n)*binomial(2*n, n)/(105*4**n)
+
+    assert gosper_sum(f1, (k, 0, n)) == f2
+    assert gosper_sum(f2, (n, 0, n)) == f3
+    assert gosper_sum(f3, (n, 0, n)) == f4
+    assert gosper_sum(f4, (n, 0, n)) == f5
+
+# the AeqB tests test expressions given in
+# www.math.upenn.edu/~wilf/AeqB.pdf
+
+
+def test_gosper_sum_AeqB_part1():
+    f1a = n**4
+    f1b = n**3*2**n
+    f1c = 1/(n**2 + sqrt(5)*n - 1)
+    f1d = n**4*4**n/binomial(2*n, n)
+    f1e = factorial(3*n)/(factorial(n)*factorial(n + 1)*factorial(n + 2)*27**n)
+    f1f = binomial(2*n, n)**2/((n + 1)*4**(2*n))
+    f1g = (4*n - 1)*binomial(2*n, n)**2/((2*n - 1)**2*4**(2*n))
+    f1h = n*factorial(n - S.Half)**2/factorial(n + 1)**2
+
+    g1a = m*(m + 1)*(2*m + 1)*(3*m**2 + 3*m - 1)/30
+    g1b = 26 + 2**(m + 1)*(m**3 - 3*m**2 + 9*m - 13)
+    g1c = (m + 1)*(m*(m**2 - 7*m + 3)*sqrt(5) - (
+        3*m**3 - 7*m**2 + 19*m - 6))/(2*m**3*sqrt(5) + m**4 + 5*m**2 - 1)/6
+    g1d = Rational(-2, 231) + 2*4**m*(m + 1)*(63*m**4 + 112*m**3 + 18*m**2 -
+             22*m + 3)/(693*binomial(2*m, m))
+    g1e = Rational(-9, 2) + (81*m**2 + 261*m + 200)*factorial(
+        3*m + 2)/(40*27**m*factorial(m)*factorial(m + 1)*factorial(m + 2))
+    g1f = (2*m + 1)**2*binomial(2*m, m)**2/(4**(2*m)*(m + 1))
+    g1g = -binomial(2*m, m)**2/4**(2*m)
+    g1h = 4*pi -(2*m + 1)**2*(3*m + 4)*factorial(m - S.Half)**2/factorial(m + 1)**2
+
+    g = gosper_sum(f1a, (n, 0, m))
+    assert g is not None and simplify(g - g1a) == 0
+    g = gosper_sum(f1b, (n, 0, m))
+    assert g is not None and simplify(g - g1b) == 0
+    g = gosper_sum(f1c, (n, 0, m))
+    assert g is not None and simplify(g - g1c) == 0
+    g = gosper_sum(f1d, (n, 0, m))
+    assert g is not None and simplify(g - g1d) == 0
+    g = gosper_sum(f1e, (n, 0, m))
+    assert g is not None and simplify(g - g1e) == 0
+    g = gosper_sum(f1f, (n, 0, m))
+    assert g is not None and simplify(g - g1f) == 0
+    g = gosper_sum(f1g, (n, 0, m))
+    assert g is not None and simplify(g - g1g) == 0
+    g = gosper_sum(f1h, (n, 0, m))
+    # need to call rewrite(gamma) here because we have terms involving
+    # factorial(1/2)
+    assert g is not None and simplify(g - g1h).rewrite(gamma) == 0
+
+
+def test_gosper_sum_AeqB_part2():
+    f2a = n**2*a**n
+    f2b = (n - r/2)*binomial(r, n)
+    f2c = factorial(n - 1)**2/(factorial(n - x)*factorial(n + x))
+
+    g2a = -a*(a + 1)/(a - 1)**3 + a**(
+        m + 1)*(a**2*m**2 - 2*a*m**2 + m**2 - 2*a*m + 2*m + a + 1)/(a - 1)**3
+    g2b = (m - r)*binomial(r, m)/2
+    ff = factorial(1 - x)*factorial(1 + x)
+    g2c = 1/ff*(
+        1 - 1/x**2) + factorial(m)**2/(x**2*factorial(m - x)*factorial(m + x))
+
+    g = gosper_sum(f2a, (n, 0, m))
+    assert g is not None and simplify(g - g2a) == 0
+    g = gosper_sum(f2b, (n, 0, m))
+    assert g is not None and simplify(g - g2b) == 0
+    g = gosper_sum(f2c, (n, 1, m))
+    assert g is not None and simplify(g - g2c) == 0
+
+
+def test_gosper_nan():
+    a = Symbol('a', positive=True)
+    b = Symbol('b', positive=True)
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True)
+    f2d = n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b))
+    g2d = 1/(factorial(a - 1)*factorial(
+        b - 1)) - a**(m + 1)*b**(m + 1)/(factorial(a + m)*factorial(b + m))
+    g = gosper_sum(f2d, (n, 0, m))
+    assert simplify(g - g2d) == 0
+
+
+def test_gosper_sum_AeqB_part3():
+    f3a = 1/n**4
+    f3b = (6*n + 3)/(4*n**4 + 8*n**3 + 8*n**2 + 4*n + 3)
+    f3c = 2**n*(n**2 - 2*n - 1)/(n**2*(n + 1)**2)
+    f3d = n**2*4**n/((n + 1)*(n + 2))
+    f3e = 2**n/(n + 1)
+    f3f = 4*(n - 1)*(n**2 - 2*n - 1)/(n**2*(n + 1)**2*(n - 2)**2*(n - 3)**2)
+    f3g = (n**4 - 14*n**2 - 24*n - 9)*2**n/(n**2*(n + 1)**2*(n + 2)**2*
+           (n + 3)**2)
+
+    # g3a -> no closed form
+    g3b = m*(m + 2)/(2*m**2 + 4*m + 3)
+    g3c = 2**m/m**2 - 2
+    g3d = Rational(2, 3) + 4**(m + 1)*(m - 1)/(m + 2)/3
+    # g3e -> no closed form
+    g3f = -(Rational(-1, 16) + 1/((m - 2)**2*(m + 1)**2))  # the AeqB key is wrong
+    g3g = Rational(-2, 9) + 2**(m + 1)/((m + 1)**2*(m + 3)**2)
+
+    g = gosper_sum(f3a, (n, 1, m))
+    assert g is None
+    g = gosper_sum(f3b, (n, 1, m))
+    assert g is not None and simplify(g - g3b) == 0
+    g = gosper_sum(f3c, (n, 1, m - 1))
+    assert g is not None and simplify(g - g3c) == 0
+    g = gosper_sum(f3d, (n, 1, m))
+    assert g is not None and simplify(g - g3d) == 0
+    g = gosper_sum(f3e, (n, 0, m - 1))
+    assert g is None
+    g = gosper_sum(f3f, (n, 4, m))
+    assert g is not None and simplify(g - g3f) == 0
+    g = gosper_sum(f3g, (n, 1, m))
+    assert g is not None and simplify(g - g3g) == 0
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_guess.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_guess.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ac5d02b89ad62a70a29bd450b71b284b6aea76d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_guess.py
@@ -0,0 +1,82 @@
+from sympy.concrete.guess import (
+            find_simple_recurrence_vector,
+            find_simple_recurrence,
+            rationalize,
+            guess_generating_function_rational,
+            guess_generating_function,
+            guess
+        )
+from sympy.concrete.products import Product
+from sympy.core.function import Function
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.exponential import exp
+
+
+def test_find_simple_recurrence_vector():
+    assert find_simple_recurrence_vector(
+            [fibonacci(k) for k in range(12)]) == [1, -1, -1]
+
+
+def test_find_simple_recurrence():
+    a = Function('a')
+    n = Symbol('n')
+    assert find_simple_recurrence([fibonacci(k) for k in range(12)]) == (
+        -a(n) - a(n + 1) + a(n + 2))
+
+    f = Function('a')
+    i = Symbol('n')
+    a = [1, 1, 1]
+    for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
+    assert find_simple_recurrence(a, A=f, N=i) == (
+        -8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3))
+    assert find_simple_recurrence([0, 2, 15, 74, 12, 3, 0,
+                                    1, 2, 85, 4, 5, 63]) == 0
+
+
+def test_rationalize():
+    from mpmath import cos, pi, mpf
+    assert rationalize(cos(pi/3)) == S.Half
+    assert rationalize(mpf("0.333333333333333")) == Rational(1, 3)
+    assert rationalize(mpf("-0.333333333333333")) == Rational(-1, 3)
+    assert rationalize(pi, maxcoeff = 250) == Rational(355, 113)
+
+
+def test_guess_generating_function_rational():
+    x = Symbol('x')
+    assert guess_generating_function_rational([fibonacci(k)
+        for k in range(5, 15)]) == ((3*x + 5)/(-x**2 - x + 1))
+
+
+def test_guess_generating_function():
+    x = Symbol('x')
+    assert guess_generating_function([fibonacci(k)
+        for k in range(5, 15)])['ogf'] == ((3*x + 5)/(-x**2 - x + 1))
+    assert guess_generating_function(
+        [1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf'] == (
+        (1/(x**4 + 2*x**2 - 4*x + 1))**S.Half)
+    assert guess_generating_function(sympify(
+       "[3/2, 11/2, 0, -121/2, -363/2, 121, 4719/2, 11495/2, -8712, -178717/2]")
+       )['ogf'] == (x + Rational(3, 2))/(11*x**2 - 3*x + 1)
+    assert guess_generating_function([factorial(k) for k in range(12)],
+       types=['egf'])['egf'] == 1/(-x + 1)
+    assert guess_generating_function([k+1 for k in range(12)],
+       types=['egf']) == {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
+
+
+def test_guess():
+    i0, i1 = symbols('i0 i1')
+    assert guess([1, 2, 6, 24, 120], evaluate=False) == [Product(i1 + 1, (i1, 1, i0 - 1))]
+    assert guess([1, 2, 6, 24, 120]) == [RisingFactorial(2, i0 - 1)]
+    assert guess([1, 2, 7, 42, 429, 7436, 218348, 10850216], niter=4) == [
+        2**(i0 - 1)*(Rational(27, 16))**(i0**2/2 - 3*i0/2 +
+        1)*Product(RisingFactorial(Rational(5, 3), i1 - 1)*RisingFactorial(Rational(7, 3), i1
+        - 1)/(RisingFactorial(Rational(3, 2), i1 - 1)*RisingFactorial(Rational(5, 2), i1 -
+        1)), (i1, 1, i0 - 1))]
+    assert guess([1, 0, 2]) == []
+    x, y = symbols('x y')
+    assert guess([1, 2, 6, 24, 120], variables=[x, y]) == [RisingFactorial(2, x - 1)]
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_products.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_products.py
new file mode 100644
index 0000000000000000000000000000000000000000..9be053a7040014c6ed38c1279a609fcb2426258e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_products.py
@@ -0,0 +1,410 @@
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.numbers import (Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (rf, factorial)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.simplify import simplify
+from sympy.testing.pytest import raises
+
+a, k, n, m, x = symbols('a,k,n,m,x', integer=True)
+f = Function('f')
+
+
+def test_karr_convention():
+    # Test the Karr product convention that we want to hold.
+    # See his paper "Summation in Finite Terms" for a detailed
+    # reasoning why we really want exactly this definition.
+    # The convention is described for sums on page 309 and
+    # essentially in section 1.4, definition 3. For products
+    # we can find in analogy:
+    #
+    # \prod_{m <= i < n} f(i) 'has the obvious meaning'      for m < n
+    # \prod_{m <= i < n} f(i) = 0                            for m = n
+    # \prod_{m <= i < n} f(i) = 1 / \prod_{n <= i < m} f(i)  for m > n
+    #
+    # It is important to note that he defines all products with
+    # the upper limit being *exclusive*.
+    # In contrast, SymPy and the usual mathematical notation has:
+    #
+    # prod_{i = a}^b f(i) = f(a) * f(a+1) * ... * f(b-1) * f(b)
+    #
+    # with the upper limit *inclusive*. So translating between
+    # the two we find that:
+    #
+    # \prod_{m <= i < n} f(i) = \prod_{i = m}^{n-1} f(i)
+    #
+    # where we intentionally used two different ways to typeset the
+    # products and its limits.
+
+    i = Symbol("i", integer=True)
+    k = Symbol("k", integer=True)
+    j = Symbol("j", integer=True, positive=True)
+
+    # A simple example with a concrete factors and symbolic limits.
+
+    # The normal product: m = k and n = k + j and therefore m < n:
+    m = k
+    n = k + j
+
+    a = m
+    b = n - 1
+    S1 = Product(i**2, (i, a, b)).doit()
+
+    # The reversed product: m = k + j and n = k and therefore m > n:
+    m = k + j
+    n = k
+
+    a = m
+    b = n - 1
+    S2 = Product(i**2, (i, a, b)).doit()
+
+    assert S1 * S2 == 1
+
+    # Test the empty product: m = k and n = k and therefore m = n:
+    m = k
+    n = k
+
+    a = m
+    b = n - 1
+    Sz = Product(i**2, (i, a, b)).doit()
+
+    assert Sz == 1
+
+    # Another example this time with an unspecified factor and
+    # numeric limits. (We can not do both tests in the same example.)
+    f = Function("f")
+
+    # The normal product with m < n:
+    m = 2
+    n = 11
+
+    a = m
+    b = n - 1
+    S1 = Product(f(i), (i, a, b)).doit()
+
+    # The reversed product with m > n:
+    m = 11
+    n = 2
+
+    a = m
+    b = n - 1
+    S2 = Product(f(i), (i, a, b)).doit()
+
+    assert simplify(S1 * S2) == 1
+
+    # Test the empty product with m = n:
+    m = 5
+    n = 5
+
+    a = m
+    b = n - 1
+    Sz = Product(f(i), (i, a, b)).doit()
+
+    assert Sz == 1
+
+
+def test_karr_proposition_2a():
+    # Test Karr, page 309, proposition 2, part a
+    i, u, v = symbols('i u v', integer=True)
+
+    def test_the_product(m, n):
+        # g
+        g = i**3 + 2*i**2 - 3*i
+        # f = Delta g
+        f = simplify(g.subs(i, i+1) / g)
+        # The product
+        a = m
+        b = n - 1
+        P = Product(f, (i, a, b)).doit()
+        # Test if Product_{m <= i < n} f(i) = g(n) / g(m)
+        assert combsimp(P / (g.subs(i, n) / g.subs(i, m))) == 1
+
+    # m < n
+    test_the_product(u, u + v)
+    # m = n
+    test_the_product(u, u)
+    # m > n
+    test_the_product(u + v, u)
+
+
+def test_karr_proposition_2b():
+    # Test Karr, page 309, proposition 2, part b
+    i, u, v, w = symbols('i u v w', integer=True)
+
+    def test_the_product(l, n, m):
+        # Productmand
+        s = i**3
+        # First product
+        a = l
+        b = n - 1
+        S1 = Product(s, (i, a, b)).doit()
+        # Second product
+        a = l
+        b = m - 1
+        S2 = Product(s, (i, a, b)).doit()
+        # Third product
+        a = m
+        b = n - 1
+        S3 = Product(s, (i, a, b)).doit()
+        # Test if S1 = S2 * S3 as required
+        assert combsimp(S1 / (S2 * S3)) == 1
+
+    # l < m < n
+    test_the_product(u, u + v, u + v + w)
+    # l < m = n
+    test_the_product(u, u + v, u + v)
+    # l < m > n
+    test_the_product(u, u + v + w, v)
+    # l = m < n
+    test_the_product(u, u, u + v)
+    # l = m = n
+    test_the_product(u, u, u)
+    # l = m > n
+    test_the_product(u + v, u + v, u)
+    # l > m < n
+    test_the_product(u + v, u, u + w)
+    # l > m = n
+    test_the_product(u + v, u, u)
+    # l > m > n
+    test_the_product(u + v + w, u + v, u)
+
+
+def test_simple_products():
+    assert product(2, (k, a, n)) == 2**(n - a + 1)
+    assert product(k, (k, 1, n)) == factorial(n)
+    assert product(k**3, (k, 1, n)) == factorial(n)**3
+
+    assert product(k + 1, (k, 0, n - 1)) == factorial(n)
+    assert product(k + 1, (k, a, n - 1)) == rf(1 + a, n - a)
+
+    assert product(cos(k), (k, 0, 5)) == cos(1)*cos(2)*cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 3, 5)) == cos(3)*cos(4)*cos(5)
+    assert product(cos(k), (k, 1, Rational(5, 2))) != cos(1)*cos(2)
+
+    assert isinstance(product(k**k, (k, 1, n)), Product)
+
+    assert Product(x**k, (k, 1, n)).variables == [k]
+
+    raises(ValueError, lambda: Product(n))
+    raises(ValueError, lambda: Product(n, k))
+    raises(ValueError, lambda: Product(n, k, 1))
+    raises(ValueError, lambda: Product(n, k, 1, 10))
+    raises(ValueError, lambda: Product(n, (k, 1)))
+
+    assert product(1, (n, 1, oo)) == 1  # issue 8301
+    assert product(2, (n, 1, oo)) is oo
+    assert product(-1, (n, 1, oo)).func is Product
+
+
+def test_multiple_products():
+    assert product(x, (n, 1, k), (k, 1, m)) == x**(m**2/2 + m/2)
+    assert product(f(n), (
+        n, 1, m), (m, 1, k)) == Product(f(n), (n, 1, m), (m, 1, k)).doit()
+    assert Product(f(n), (m, 1, k), (n, 1, k)).doit() == \
+        Product(Product(f(n), (m, 1, k)), (n, 1, k)).doit() == \
+        product(f(n), (m, 1, k), (n, 1, k)) == \
+        product(product(f(n), (m, 1, k)), (n, 1, k)) == \
+        Product(f(n)**k, (n, 1, k))
+    assert Product(
+        x, (x, 1, k), (k, 1, n)).doit() == Product(factorial(k), (k, 1, n))
+
+    assert Product(x**k, (n, 1, k), (k, 1, m)).variables == [n, k]
+
+
+def test_rational_products():
+    assert product(1 + 1/k, (k, 1, n)) == rf(2, n)/factorial(n)
+
+
+def test_special_products():
+    # Wallis product
+    assert product((4*k)**2 / (4*k**2 - 1), (k, 1, n)) == \
+        4**n*factorial(n)**2/rf(S.Half, n)/rf(Rational(3, 2), n)
+
+    # Euler's product formula for sin
+    assert product(1 + a/k**2, (k, 1, n)) == \
+        rf(1 - sqrt(-a), n)*rf(1 + sqrt(-a), n)/factorial(n)**2
+
+
+def test__eval_product():
+    from sympy.abc import i, n
+    # issue 4809
+    a = Function('a')
+    assert product(2*a(i), (i, 1, n)) == 2**n * Product(a(i), (i, 1, n))
+    # issue 4810
+    assert product(2**i, (i, 1, n)) == 2**(n*(n + 1)/2)
+    k, m = symbols('k m', integer=True)
+    assert product(2**i, (i, k, m)) == 2**(-k**2/2 + k/2 + m**2/2 + m/2)
+    n = Symbol('n', negative=True, integer=True)
+    p = Symbol('p', positive=True, integer=True)
+    assert product(2**i, (i, n, p)) == 2**(-n**2/2 + n/2 + p**2/2 + p/2)
+    assert product(2**i, (i, p, n)) == 2**(n**2/2 + n/2 - p**2/2 + p/2)
+
+
+def test_product_pow():
+    # issue 4817
+    assert product(2**f(k), (k, 1, n)) == 2**Sum(f(k), (k, 1, n))
+    assert product(2**(2*f(k)), (k, 1, n)) == 2**Sum(2*f(k), (k, 1, n))
+
+
+def test_infinite_product():
+    # issue 5737
+    assert isinstance(Product(2**(1/factorial(n)), (n, 0, oo)), Product)
+
+
+def test_conjugate_transpose():
+    p = Product(x**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    A, B = symbols("A B", commutative=False)
+    p = Product(A*B**k, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    p = Product(B**k*A, (k, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+
+def test_simplify_prod():
+    y, t, b, c, v, d = symbols('y, t, b, c, v, d', integer = True)
+
+    _simplify = lambda e: simplify(e, doit=False)
+    assert _simplify(Product(x*y, (x, n, m), (y, a, k)) * \
+        Product(y, (x, n, m), (y, a, k))) == \
+            Product(x*y**2, (x, n, m), (y, a, k))
+    assert _simplify(3 * y* Product(x, (x, n, m)) * Product(x, (x, m + 1, a))) \
+        == 3 * y * Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x, (x, n, k))) == \
+        Product(x, (x, n, a))
+    assert _simplify(Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))) == \
+        Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))
+    assert _simplify(Product(x, (t, a, b)) * Product(y, (t, a, b)) * \
+        Product(x, (t, b+1, c))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(x, (t, a, b)) * Product(x, (t, b+1, c)) * \
+        Product(y, (t, a, b))) == Product(x*y, (t, a, b)) * \
+            Product(x, (t, b+1, c))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
+        Product(2, (t, a, b))
+    assert _simplify(Product(sin(t)**2 + cos(t)**2 - 1, (t, a, b))) == \
+           Product(0, (t, a, b))
+    assert _simplify(Product(v*Product(sin(t)**2 + cos(t)**2, (t, a, b)),
+                             (v, c, d))) == Product(v*Product(1, (t, a, b)), (v, c, d))
+
+
+def test_change_index():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x, (x, a, b)).change_index(x, x + 1, y) == \
+        Product(y - 1, (y, a + 1, b + 1))
+    assert Product(x**2, (x, a, b)).change_index(x, x - 1) == \
+        Product((x + 1)**2, (x, a - 1, b - 1))
+    assert Product(x**2, (x, a, b)).change_index(x, -x, y) == \
+        Product((-y)**2, (y, -b, -a))
+    assert Product(x, (x, a, b)).change_index(x, -x - 1) == \
+        Product(-x - 1, (x, - b - 1, -a - 1))
+    assert Product(x*y, (x, a, b), (y, c, d)).change_index(x, x - 1, z) == \
+        Product((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
+
+
+def test_reorder():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
+        Product(x, (x, c, d), (x, a, b))
+    assert Product(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
+        (2, 0), (0, 1)) == Product(x*y + z, (z, m, n), (y, c, d), (x, a, b))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (0, 1), (1, 2), (0, 2)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (x, y), (y, z), (x, z)) == \
+        Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+    assert Product(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
+        Product(x*y, (y, c, d), (x, a, b))
+
+
+def test_Product_is_convergent():
+    assert Product(1/n**2, (n, 1, oo)).is_convergent() is S.false
+    assert Product(exp(1/n**2), (n, 1, oo)).is_convergent() is S.true
+    assert Product(1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n, (n, 1, oo)).is_convergent() is S.false
+    assert Product(1 + 1/n**2, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_reverse_order():
+    x, y, a, b, c, d= symbols('x, y, a, b, c, d', integer = True)
+
+    assert Product(x, (x, 0, 3)).reverse_order(0) == Product(1/x, (x, 4, -1))
+    assert Product(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
+           Product(x*y, (x, 6, 0), (y, 7, -1))
+    assert Product(x, (x, 1, 2)).reverse_order(0) == Product(1/x, (x, 3, 0))
+    assert Product(x, (x, 1, 3)).reverse_order(0) == Product(1/x, (x, 4, 0))
+    assert Product(x, (x, 1, a)).reverse_order(0) == Product(1/x, (x, a + 1, 0))
+    assert Product(x, (x, a, 5)).reverse_order(0) == Product(1/x, (x, 6, a - 1))
+    assert Product(x, (x, a + 1, a + 5)).reverse_order(0) == \
+           Product(1/x, (x, a + 6, a))
+    assert Product(x, (x, a + 1, a + 2)).reverse_order(0) == \
+           Product(1/x, (x, a + 3, a))
+    assert Product(x, (x, a + 1, a + 1)).reverse_order(0) == \
+           Product(1/x, (x, a + 2, a))
+    assert Product(x, (x, a, b)).reverse_order(0) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x, (x, a, b)).reverse_order(x) == Product(1/x, (x, b + 1, a - 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+    assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
+           Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+
+def test_issue_9983():
+    n = Symbol('n', integer=True, positive=True)
+    p = Product(1 + 1/n**Rational(2, 3), (n, 1, oo))
+    assert p.is_convergent() is S.false
+    assert product(1 + 1/n**Rational(2, 3), (n, 1, oo)) == p.doit()
+
+
+def test_issue_13546():
+    n = Symbol('n')
+    k = Symbol('k')
+    p = Product(n + 1 / 2**k, (k, 0, n-1)).doit()
+    assert p.subs(n, 2).doit() == Rational(15, 2)
+
+
+def test_issue_14036():
+    a, n = symbols('a n')
+    assert product(1 - a**2 / (n*pi)**2, [n, 1, oo]) != 0
+
+
+def test_rewrite_Sum():
+    assert Product(1 - S.Half**2/k**2, (k, 1, oo)).rewrite(Sum) == \
+        exp(Sum(log(1 - 1/(4*k**2)), (k, 1, oo)))
+
+
+def test_KroneckerDelta_Product():
+    y = Symbol('y')
+    assert Product(x*KroneckerDelta(x, y), (x, 0, 1)).doit() == 0
+
+
+def test_issue_20848():
+    _i = Dummy('i')
+    t, y, z = symbols('t y z')
+    assert diff(Product(x, (y, 1, z)), x).as_dummy() == Sum(Product(x, (y, 1, _i - 1))*Product(x, (y, _i + 1, z)), (_i, 1, z)).as_dummy()
+    assert diff(Product(x, (y, 1, z)), x).doit() == x**(z - 1)*z
+    assert diff(Product(x, (y, x, z)), x) == Derivative(Product(x, (y, x, z)), x)
+    assert diff(Product(t, (x, 1, z)), x) == S(0)
+    assert Product(sin(n*x), (n, -1, 1)).diff(x).doit() == S(0)
diff --git a/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_sums_products.py b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_sums_products.py
new file mode 100644
index 0000000000000000000000000000000000000000..b190afe0bd403819d3525453879d7d5d39e20a56
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/concrete/tests/test_sums_products.py
@@ -0,0 +1,1676 @@
+from math import prod
+
+from sympy.concrete.expr_with_intlimits import ReorderError
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import (Sum, summation, telescopic,
+     eval_sum_residue, _dummy_with_inherited_properties_concrete)
+from sympy.core.function import (Derivative, Function)
+from sympy.core import (Catalan, EulerGamma)
+from sympy.core.facts import InconsistentAssumptions
+from sympy.core.mod import Mod
+from sympy.core.numbers import (E, I, Rational, nan, oo, pi)
+from sympy.core.relational import Eq, Ne
+from sympy.core.numbers import Float
+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 (rf, binomial, factorial)
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.complexes import Abs, re
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (sinh, tanh)
+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 (cos, sin, atan)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.functions.special.zeta_functions import zeta
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import And, Or
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.expressions.special import Identity
+from sympy.matrices import (Matrix, SparseMatrix,
+    ImmutableDenseMatrix, ImmutableSparseMatrix, diag)
+from sympy.sets.contains import Contains
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import Interval
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.simplify import simplify
+from sympy.tensor.indexed import (Idx, Indexed, IndexedBase)
+from sympy.testing.pytest import XFAIL, raises, slow
+from sympy.abc import a, b, c, d, k, m, x, y, z
+
+n = Symbol('n', integer=True)
+f, g = symbols('f g', cls=Function)
+
+def test_karr_convention():
+    # Test the Karr summation convention that we want to hold.
+    # See his paper "Summation in Finite Terms" for a detailed
+    # reasoning why we really want exactly this definition.
+    # The convention is described on page 309 and essentially
+    # in section 1.4, definition 3:
+    #
+    # \sum_{m <= i < n} f(i) 'has the obvious meaning'   for m < n
+    # \sum_{m <= i < n} f(i) = 0                         for m = n
+    # \sum_{m <= i < n} f(i) = - \sum_{n <= i < m} f(i)  for m > n
+    #
+    # It is important to note that he defines all sums with
+    # the upper limit being *exclusive*.
+    # In contrast, SymPy and the usual mathematical notation has:
+    #
+    # sum_{i = a}^b f(i) = f(a) + f(a+1) + ... + f(b-1) + f(b)
+    #
+    # with the upper limit *inclusive*. So translating between
+    # the two we find that:
+    #
+    # \sum_{m <= i < n} f(i) = \sum_{i = m}^{n-1} f(i)
+    #
+    # where we intentionally used two different ways to typeset the
+    # sum and its limits.
+
+    i = Symbol("i", integer=True)
+    k = Symbol("k", integer=True)
+    j = Symbol("j", integer=True)
+
+    # A simple example with a concrete summand and symbolic limits.
+
+    # The normal sum: m = k and n = k + j and therefore m < n:
+    m = k
+    n = k + j
+
+    a = m
+    b = n - 1
+    S1 = Sum(i**2, (i, a, b)).doit()
+
+    # The reversed sum: m = k + j and n = k and therefore m > n:
+    m = k + j
+    n = k
+
+    a = m
+    b = n - 1
+    S2 = Sum(i**2, (i, a, b)).doit()
+
+    assert simplify(S1 + S2) == 0
+
+    # Test the empty sum: m = k and n = k and therefore m = n:
+    m = k
+    n = k
+
+    a = m
+    b = n - 1
+    Sz = Sum(i**2, (i, a, b)).doit()
+
+    assert Sz == 0
+
+    # Another example this time with an unspecified summand and
+    # numeric limits. (We can not do both tests in the same example.)
+
+    # The normal sum with m < n:
+    m = 2
+    n = 11
+
+    a = m
+    b = n - 1
+    S1 = Sum(f(i), (i, a, b)).doit()
+
+    # The reversed sum with m > n:
+    m = 11
+    n = 2
+
+    a = m
+    b = n - 1
+    S2 = Sum(f(i), (i, a, b)).doit()
+
+    assert simplify(S1 + S2) == 0
+
+    # Test the empty sum with m = n:
+    m = 5
+    n = 5
+
+    a = m
+    b = n - 1
+    Sz = Sum(f(i), (i, a, b)).doit()
+
+    assert Sz == 0
+
+    e = Piecewise((exp(-i), Mod(i, 2) > 0), (0, True))
+    s = Sum(e, (i, 0, 11))
+    assert s.n(3) == s.doit().n(3)
+
+    # issue #27893
+    n = Symbol('n', integer=True)
+    assert Sum(1/(x**2 + 1), (x, oo, 0)).doit(deep=False) == Rational(-1, 2) + pi / (2 * tanh(pi))
+    assert Sum(c**x/factorial(x), (x, oo, 0)).doit(deep=False).simplify() == exp(c) - 1 # exponential series
+    assert Sum((-1)**x/x, (x, oo,0)).doit() == -log(2) # alternating harmnic series
+    assert Sum((1/2)**x,(x, oo, -1)).doit() == S(2) # geometric series
+    assert Sum(1/x, (x, oo, 0)).doit() == oo # harmonic series, divergent
+    assert Sum((-1)**x/(2*x+1), (x, oo, -1)).doit() == pi/4 # leibniz series
+    assert Sum((((-1)**x) * c**(2*x+1)) / factorial(2*x+1), (x, oo, -1)).doit() == sin(c) # sinusoidal series
+    assert Sum((((-1)**x) * c**(2*x+1)) / (2*x+1), (x, 0, oo)).doit() \
+        == Piecewise((atan(c), Ne(c**2, -1) & (Abs(c**2) <= 1)), \
+                     (Sum((-1)**x*c**(2*x + 1)/(2*x + 1), (x, 0, oo)), True)) # arctangent series
+    assert Sum(binomial(n, x) * c**x, (x, 0, oo)).doit() \
+        == Piecewise(((c + 1)**n, \
+                     ((n <= -1) & (Abs(c) < 1)) \
+                        | ((n > 0) & (Abs(c) <= 1)) \
+                        | ((n <= 0) & (n > -1) & Ne(c, -1) & (Abs(c) <= 1))), \
+                     (Sum(c**x*binomial(n, x), (x, 0, oo)), True)) # binomial series
+    assert Sum(1/x**n, (x, oo, 0)).doit() \
+        == Piecewise((zeta(n), n > 1), (Sum(x**(-n), (x, oo, 0)), True)) # Euler's zeta function
+
+def test_karr_proposition_2a():
+    # Test Karr, page 309, proposition 2, part a
+    i = Symbol("i", integer=True)
+    u = Symbol("u", integer=True)
+    v = Symbol("v", integer=True)
+
+    def test_the_sum(m, n):
+        # g
+        g = i**3 + 2*i**2 - 3*i
+        # f = Delta g
+        f = simplify(g.subs(i, i+1) - g)
+        # The sum
+        a = m
+        b = n - 1
+        S = Sum(f, (i, a, b)).doit()
+        # Test if Sum_{m <= i < n} f(i) = g(n) - g(m)
+        assert simplify(S - (g.subs(i, n) - g.subs(i, m))) == 0
+
+    # m < n
+    test_the_sum(u,   u+v)
+    # m = n
+    test_the_sum(u,   u  )
+    # m > n
+    test_the_sum(u+v, u  )
+
+
+def test_karr_proposition_2b():
+    # Test Karr, page 309, proposition 2, part b
+    i = Symbol("i", integer=True)
+    u = Symbol("u", integer=True)
+    v = Symbol("v", integer=True)
+    w = Symbol("w", integer=True)
+
+    def test_the_sum(l, n, m):
+        # Summand
+        s = i**3
+        # First sum
+        a = l
+        b = n - 1
+        S1 = Sum(s, (i, a, b)).doit()
+        # Second sum
+        a = l
+        b = m - 1
+        S2 = Sum(s, (i, a, b)).doit()
+        # Third sum
+        a = m
+        b = n - 1
+        S3 = Sum(s, (i, a, b)).doit()
+        # Test if S1 = S2 + S3 as required
+        assert S1 - (S2 + S3) == 0
+
+    # l < m < n
+    test_the_sum(u,     u+v,   u+v+w)
+    # l < m = n
+    test_the_sum(u,     u+v,   u+v  )
+    # l < m > n
+    test_the_sum(u,     u+v+w, v    )
+    # l = m < n
+    test_the_sum(u,     u,     u+v  )
+    # l = m = n
+    test_the_sum(u,     u,     u    )
+    # l = m > n
+    test_the_sum(u+v,   u+v,   u    )
+    # l > m < n
+    test_the_sum(u+v,   u,     u+w  )
+    # l > m = n
+    test_the_sum(u+v,   u,     u    )
+    # l > m > n
+    test_the_sum(u+v+w, u+v,   u    )
+
+
+def test_arithmetic_sums():
+    assert summation(1, (n, a, b)) == b - a + 1
+    assert Sum(S.NaN, (n, a, b)) is S.NaN
+    assert Sum(x, (n, a, a)).doit() == x
+    assert Sum(x, (x, a, a)).doit() == a
+    assert Sum(x, (n, 1, a)).doit() == a*x
+    assert Sum(x, (x, Range(1, 11))).doit() == 55
+    assert Sum(x, (x, Range(1, 11, 2))).doit() == 25
+    assert Sum(x, (x, Range(1, 10, 2))) == Sum(x, (x, Range(9, 0, -2)))
+    lo, hi = 1, 2
+    s1 = Sum(n, (n, lo, hi))
+    s2 = Sum(n, (n, hi, lo))
+    assert s1 != s2
+    assert s1.doit() == 3 and s2.doit() == 0
+    lo, hi = x, x + 1
+    s1 = Sum(n, (n, lo, hi))
+    s2 = Sum(n, (n, hi, lo))
+    assert s1 != s2
+    assert s1.doit() == 2*x + 1 and s2.doit() == 0
+    assert Sum(Integral(x, (x, 1, y)) + x, (x, 1, 2)).doit() == \
+        y**2 + 2
+    assert summation(1, (n, 1, 10)) == 10
+    assert summation(2*n, (n, 0, 10**10)) == 100000000010000000000
+    assert summation(4*n*m, (n, a, 1), (m, 1, d)).expand() == \
+        2*d + 2*d**2 + a*d + a*d**2 - d*a**2 - a**2*d**2
+    assert summation(cos(n), (n, -2, 1)) == cos(-2) + cos(-1) + cos(0) + cos(1)
+    assert summation(cos(n), (n, x, x + 2)) == cos(x) + cos(x + 1) + cos(x + 2)
+    assert isinstance(summation(cos(n), (n, x, x + S.Half)), Sum)
+    assert summation(k, (k, 0, oo)) is oo
+    assert summation(k, (k, Range(1, 11))) == 55
+
+
+def test_polynomial_sums():
+    assert summation(n**2, (n, 3, 8)) == 199
+    assert summation(n, (n, a, b)) == \
+        ((a + b)*(b - a + 1)/2).expand()
+    assert summation(n**2, (n, 1, b)) == \
+        ((2*b**3 + 3*b**2 + b)/6).expand()
+    assert summation(n**3, (n, 1, b)) == \
+        ((b**4 + 2*b**3 + b**2)/4).expand()
+    assert summation(n**6, (n, 1, b)) == \
+        ((6*b**7 + 21*b**6 + 21*b**5 - 7*b**3 + b)/42).expand()
+
+
+def test_geometric_sums():
+    assert summation(pi**n, (n, 0, b)) == (1 - pi**(b + 1)) / (1 - pi)
+    assert summation(2 * 3**n, (n, 0, b)) == 3**(b + 1) - 1
+    assert summation(S.Half**n, (n, 1, oo)) == 1
+    assert summation(2**n, (n, 0, b)) == 2**(b + 1) - 1
+    assert summation(2**n, (n, 1, oo)) is oo
+    assert summation(2**(-n), (n, 1, oo)) == 1
+    assert summation(3**(-n), (n, 4, oo)) == Rational(1, 54)
+    assert summation(2**(-4*n + 3), (n, 1, oo)) == Rational(8, 15)
+    assert summation(2**(n + 1), (n, 1, b)).expand() == 4*(2**b - 1)
+
+    # issue 6664:
+    assert summation(x**n, (n, 0, oo)) == \
+        Piecewise((1/(-x + 1), Abs(x) < 1), (Sum(x**n, (n, 0, oo)), True))
+
+    assert summation(-2**n, (n, 0, oo)) is -oo
+    assert summation(I**n, (n, 0, oo)) == Sum(I**n, (n, 0, oo))
+
+    # issue 6802:
+    assert summation((-1)**(2*x + 2), (x, 0, n)) == n + 1
+    assert summation((-2)**(2*x + 2), (x, 0, n)) == 4*4**(n + 1)/S(3) - Rational(4, 3)
+    assert summation((-1)**x, (x, 0, n)) == -(-1)**(n + 1)/S(2) + S.Half
+    assert summation(y**x, (x, a, b)) == \
+        Piecewise((-a + b + 1, Eq(y, 1)), ((y**a - y**(b + 1))/(-y + 1), True))
+    assert summation((-2)**(y*x + 2), (x, 0, n)) == \
+        4*Piecewise((n + 1, Eq((-2)**y, 1)),
+                    ((-(-2)**(y*(n + 1)) + 1)/(-(-2)**y + 1), True))
+
+    # issue 8251:
+    assert summation((1/(n + 1)**2)*n**2, (n, 0, oo)) is oo
+
+    #issue 9908:
+    assert Sum(1/(n**3 - 1), (n, -oo, -2)).doit() == summation(1/(n**3 - 1), (n, -oo, -2))
+
+    #issue 11642:
+    result = Sum(0.5**n, (n, 1, oo)).doit()
+    assert result == 1.0
+    assert result.is_Float
+
+    result = Sum(0.25**n, (n, 1, oo)).doit()
+    assert result == 1/3.
+    assert result.is_Float
+
+    result = Sum(0.99999**n, (n, 1, oo)).doit()
+    assert result == 99999.0
+    assert result.is_Float
+
+    result = Sum(S.Half**n, (n, 1, oo)).doit()
+    assert result == 1
+    assert not result.is_Float
+
+    result = Sum(Rational(3, 5)**n, (n, 1, oo)).doit()
+    assert result == Rational(3, 2)
+    assert not result.is_Float
+
+    assert Sum(1.0**n, (n, 1, oo)).doit() is oo
+    assert Sum(2.43**n, (n, 1, oo)).doit() is oo
+
+    # Issue 13979
+    i, k, q = symbols('i k q', integer=True)
+    result = summation(
+        exp(-2*I*pi*k*i/n) * exp(2*I*pi*q*i/n) / n, (i, 0, n - 1)
+    )
+    assert result.simplify() == Piecewise(
+            (1, Eq(exp(-2*I*pi*(k - q)/n), 1)), (0, True)
+    )
+
+    #Issue 23491
+    assert Sum(1/(n**2 + 1), (n, 1, oo)).doit() == S(-1)/2 + pi/(2*tanh(pi))
+
+def test_harmonic_sums():
+    assert summation(1/k, (k, 0, n)) == Sum(1/k, (k, 0, n))
+    assert summation(1/k, (k, 1, n)) == harmonic(n)
+    assert summation(n/k, (k, 1, n)) == n*harmonic(n)
+    assert summation(1/k, (k, 5, n)) == harmonic(n) - harmonic(4)
+
+
+def test_composite_sums():
+    f = S.Half*(7 - 6*n + Rational(1, 7)*n**3)
+    s = summation(f, (n, a, b))
+    assert not isinstance(s, Sum)
+    A = 0
+    for i in range(-3, 5):
+        A += f.subs(n, i)
+    B = s.subs(a, -3).subs(b, 4)
+    assert A == B
+
+
+def test_hypergeometric_sums():
+    assert summation(
+        binomial(2*k, k)/4**k, (k, 0, n)) == (1 + 2*n)*binomial(2*n, n)/4**n
+    assert summation(binomial(2*k, k)/5**k, (k, -oo, oo)) == sqrt(5)
+
+
+def test_other_sums():
+    f = m**2 + m*exp(m)
+    g = 3*exp(Rational(3, 2))/2 + exp(S.Half)/2 - exp(Rational(-1, 2))/2 - 3*exp(Rational(-3, 2))/2 + 5
+
+    assert summation(f, (m, Rational(-3, 2), Rational(3, 2))) == g
+    assert summation(f, (m, -1.5, 1.5)).evalf().epsilon_eq(g.evalf(), 1e-10)
+
+fac = factorial
+
+
+def NS(e, n=15, **options):
+    return str(sympify(e).evalf(n, **options))
+
+
+def test_evalf_fast_series():
+    # Euler transformed series for sqrt(1+x)
+    assert NS(Sum(
+        fac(2*n + 1)/fac(n)**2/2**(3*n + 1), (n, 0, oo)), 100) == NS(sqrt(2), 100)
+
+    # Some series for exp(1)
+    estr = NS(E, 100)
+    assert NS(Sum(1/fac(n), (n, 0, oo)), 100) == estr
+    assert NS(1/Sum((1 - 2*n)/fac(2*n), (n, 0, oo)), 100) == estr
+    assert NS(Sum((2*n + 1)/fac(2*n), (n, 0, oo)), 100) == estr
+    assert NS(Sum((4*n + 3)/2**(2*n + 1)/fac(2*n + 1), (n, 0, oo))**2, 100) == estr
+
+    pistr = NS(pi, 100)
+    # Ramanujan series for pi
+    assert NS(9801/sqrt(8)/Sum(fac(
+        4*n)*(1103 + 26390*n)/fac(n)**4/396**(4*n), (n, 0, oo)), 100) == pistr
+    assert NS(1/Sum(
+        binomial(2*n, n)**3 * (42*n + 5)/2**(12*n + 4), (n, 0, oo)), 100) == pistr
+    # Machin's formula for pi
+    assert NS(16*Sum((-1)**n/(2*n + 1)/5**(2*n + 1), (n, 0, oo)) -
+        4*Sum((-1)**n/(2*n + 1)/239**(2*n + 1), (n, 0, oo)), 100) == pistr
+
+    # Apery's constant
+    astr = NS(zeta(3), 100)
+    P = 126392*n**5 + 412708*n**4 + 531578*n**3 + 336367*n**2 + 104000* \
+        n + 12463
+    assert NS(Sum((-1)**n * P / 24 * (fac(2*n + 1)*fac(2*n)*fac(
+        n))**3 / fac(3*n + 2) / fac(4*n + 3)**3, (n, 0, oo)), 100) == astr
+    assert NS(Sum((-1)**n * (205*n**2 + 250*n + 77)/64 * fac(n)**10 /
+              fac(2*n + 1)**5, (n, 0, oo)), 100) == astr
+
+
+def test_evalf_fast_series_issue_4021():
+    # Catalan's constant
+    assert NS(Sum((-1)**(n - 1)*2**(8*n)*(40*n**2 - 24*n + 3)*fac(2*n)**3*
+        fac(n)**2/n**3/(2*n - 1)/fac(4*n)**2, (n, 1, oo))/64, 100) == \
+        NS(Catalan, 100)
+    astr = NS(zeta(3), 100)
+    assert NS(5*Sum(
+        (-1)**(n - 1)*fac(n)**2 / n**3 / fac(2*n), (n, 1, oo))/2, 100) == astr
+    assert NS(Sum((-1)**(n - 1)*(56*n**2 - 32*n + 5) / (2*n - 1)**2 * fac(n - 1)
+              **3 / fac(3*n), (n, 1, oo))/4, 100) == astr
+
+
+def test_evalf_slow_series():
+    assert NS(Sum((-1)**n / n, (n, 1, oo)), 15) == NS(-log(2), 15)
+    assert NS(Sum((-1)**n / n, (n, 1, oo)), 50) == NS(-log(2), 50)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 15) == NS(pi**2/6, 15)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 100) == NS(pi**2/6, 100)
+    assert NS(Sum(1/n**2, (n, 1, oo)), 500) == NS(pi**2/6, 500)
+    assert NS(Sum((-1)**n / (2*n + 1)**3, (n, 0, oo)), 15) == NS(pi**3/32, 15)
+    assert NS(Sum((-1)**n / (2*n + 1)**3, (n, 0, oo)), 50) == NS(pi**3/32, 50)
+
+
+def test_evalf_oo_to_oo():
+    # There used to be an error in certain cases
+    # Does not evaluate, but at least do not throw an error
+    # Evaluates symbolically to 0, which is not correct
+    assert Sum(1/(n**2+1), (n, -oo, oo)).evalf() == Sum(1/(n**2+1), (n, -oo, oo))
+    # This evaluates if from 1 to oo and symbolically
+    assert Sum(1/(factorial(abs(n))), (n, -oo, -1)).evalf() == Sum(1/(factorial(abs(n))), (n, -oo, -1))
+
+
+def test_euler_maclaurin():
+    # Exact polynomial sums with E-M
+    def check_exact(f, a, b, m, n):
+        A = Sum(f, (k, a, b))
+        s, e = A.euler_maclaurin(m, n)
+        assert (e == 0) and (s.expand() == A.doit())
+    check_exact(k**4, a, b, 0, 2)
+    check_exact(k**4 + 2*k, a, b, 1, 2)
+    check_exact(k**4 + k**2, a, b, 1, 5)
+    check_exact(k**5, 2, 6, 1, 2)
+    check_exact(k**5, 2, 6, 1, 3)
+    assert Sum(x-1, (x, 0, 2)).euler_maclaurin(m=30, n=30, eps=2**-15) == (0, 0)
+    # Not exact
+    assert Sum(k**6, (k, a, b)).euler_maclaurin(0, 2)[1] != 0
+    # Numerical test
+    for mi, ni in [(2, 4), (2, 20), (10, 20), (18, 20)]:
+        A = Sum(1/k**3, (k, 1, oo))
+        s, e = A.euler_maclaurin(mi, ni)
+        assert abs((s - zeta(3)).evalf()) < e.evalf()
+
+    raises(ValueError, lambda: Sum(1, (x, 0, 1), (k, 0, 1)).euler_maclaurin())
+
+
+@slow
+def test_evalf_euler_maclaurin():
+    assert NS(Sum(1/k**k, (k, 1, oo)), 15) == '1.29128599706266'
+    assert NS(Sum(1/k**k, (k, 1, oo)),
+              50) == '1.2912859970626635404072825905956005414986193682745'
+    assert NS(Sum(1/k - log(1 + 1/k), (k, 1, oo)), 15) == NS(EulerGamma, 15)
+    assert NS(Sum(1/k - log(1 + 1/k), (k, 1, oo)), 50) == NS(EulerGamma, 50)
+    assert NS(Sum(log(k)/k**2, (k, 1, oo)), 15) == '0.937548254315844'
+    assert NS(Sum(log(k)/k**2, (k, 1, oo)),
+              50) == '0.93754825431584375370257409456786497789786028861483'
+    assert NS(Sum(1/k, (k, 1000000, 2000000)), 15) == '0.693147930560008'
+    assert NS(Sum(1/k, (k, 1000000, 2000000)),
+              50) == '0.69314793056000780941723211364567656807940638436025'
+
+
+def test_evalf_symbolic():
+    # issue 6328
+    expr = Sum(f(x), (x, 1, 3)) + Sum(g(x), (x, 1, 3))
+    assert expr.evalf() == expr
+
+
+def test_evalf_issue_3273():
+    assert Sum(0, (k, 1, oo)).evalf() == 0
+
+
+def test_simple_products():
+    assert Product(S.NaN, (x, 1, 3)) is S.NaN
+    assert product(S.NaN, (x, 1, 3)) is S.NaN
+    assert Product(x, (n, a, a)).doit() == x
+    assert Product(x, (x, a, a)).doit() == a
+    assert Product(x, (y, 1, a)).doit() == x**a
+
+    lo, hi = 1, 2
+    s1 = Product(n, (n, lo, hi))
+    s2 = Product(n, (n, hi, lo))
+    assert s1 != s2
+    # This IS correct according to Karr product convention
+    assert s1.doit() == 2
+    assert s2.doit() == 1
+
+    lo, hi = x, x + 1
+    s1 = Product(n, (n, lo, hi))
+    s2 = Product(n, (n, hi, lo))
+    s3 = 1 / Product(n, (n, hi + 1, lo - 1))
+    assert s1 != s2
+    # This IS correct according to Karr product convention
+    assert s1.doit() == x*(x + 1)
+    assert s2.doit() == 1
+    assert s3.doit() == x*(x + 1)
+
+    assert Product(Integral(2*x, (x, 1, y)) + 2*x, (x, 1, 2)).doit() == \
+        (y**2 + 1)*(y**2 + 3)
+    assert product(2, (n, a, b)) == 2**(b - a + 1)
+    assert product(n, (n, 1, b)) == factorial(b)
+    assert product(n**3, (n, 1, b)) == factorial(b)**3
+    assert product(3**(2 + n), (n, a, b)) \
+        == 3**(2*(1 - a + b) + b/2 + (b**2)/2 + a/2 - (a**2)/2)
+    assert product(cos(n), (n, 3, 5)) == cos(3)*cos(4)*cos(5)
+    assert product(cos(n), (n, x, x + 2)) == cos(x)*cos(x + 1)*cos(x + 2)
+    assert isinstance(product(cos(n), (n, x, x + S.Half)), Product)
+    # If Product managed to evaluate this one, it most likely got it wrong!
+    assert isinstance(Product(n**n, (n, 1, b)), Product)
+
+
+def test_rational_products():
+    assert combsimp(product(1 + 1/n, (n, a, b))) == (1 + b)/a
+    assert combsimp(product(n + 1, (n, a, b))) == gamma(2 + b)/gamma(1 + a)
+    assert combsimp(product((n + 1)/(n - 1), (n, a, b))) == b*(1 + b)/(a*(a - 1))
+    assert combsimp(product(n/(n + 1)/(n + 2), (n, a, b))) == \
+        a*gamma(a + 2)/(b + 1)/gamma(b + 3)
+    assert combsimp(product(n*(n + 1)/(n - 1)/(n - 2), (n, a, b))) == \
+        b**2*(b - 1)*(1 + b)/(a - 1)**2/(a*(a - 2))
+
+
+def test_wallis_product():
+    # Wallis product, given in two different forms to ensure that Product
+    # can factor simple rational expressions
+    A = Product(4*n**2 / (4*n**2 - 1), (n, 1, b))
+    B = Product((2*n)*(2*n)/(2*n - 1)/(2*n + 1), (n, 1, b))
+    R = pi*gamma(b + 1)**2/(2*gamma(b + S.Half)*gamma(b + Rational(3, 2)))
+    assert simplify(A.doit()) == R
+    assert simplify(B.doit()) == R
+    # This one should eventually also be doable (Euler's product formula for sin)
+    # assert Product(1+x/n**2, (n, 1, b)) == ...
+
+
+def test_telescopic_sums():
+    #checks also input 2 of comment 1 issue 4127
+    assert Sum(1/k - 1/(k + 1), (k, 1, n)).doit() == 1 - 1/(1 + n)
+    assert Sum(
+        f(k) - f(k + 2), (k, m, n)).doit() == -f(1 + n) - f(2 + n) + f(m) + f(1 + m)
+    assert Sum(cos(k) - cos(k + 3), (k, 1, n)).doit() == -cos(1 + n) - \
+        cos(2 + n) - cos(3 + n) + cos(1) + cos(2) + cos(3)
+
+    # dummy variable shouldn't matter
+    assert telescopic(1/m, -m/(1 + m), (m, n - 1, n)) == \
+        telescopic(1/k, -k/(1 + k), (k, n - 1, n))
+
+    assert Sum(1/x/(x - 1), (x, a, b)).doit() == 1/(a - 1) - 1/b
+    eq = 1/((5*n + 2)*(5*(n + 1) + 2))
+    assert Sum(eq, (n, 0, oo)).doit() == S(1)/10
+    nz = symbols('nz', nonzero=True)
+    v = Sum(eq.subs(5, nz), (n, 0, oo)).doit()
+    assert v.subs(nz, 5).simplify() == S(1)/10
+    # check that apart is being used in non-symbolic case
+    s = Sum(eq, (n, 0, k)).doit()
+    v = Sum(eq, (n, 0, 10**100)).doit()
+    assert v == s.subs(k, 10**100)
+
+
+def test_sum_reconstruct():
+    s = Sum(n**2, (n, -1, 1))
+    assert s == Sum(*s.args)
+    raises(ValueError, lambda: Sum(x, x))
+    raises(ValueError, lambda: Sum(x, (x, 1)))
+
+
+def test_limit_subs():
+    for F in (Sum, Product, Integral):
+        assert F(a*exp(a), (a, -2, 2)) == F(a*exp(a), (a, -b, b)).subs(b, 2)
+        assert F(a, (a, F(b, (b, 1, 2)), 4)).subs(F(b, (b, 1, 2)), c) == \
+            F(a, (a, c, 4))
+        assert F(x, (x, 1, x + y)).subs(x, 1) == F(x, (x, 1, y + 1))
+
+
+def test_function_subs():
+    S = Sum(x*f(y),(x,0,oo),(y,0,oo))
+    assert S.subs(f(y),y) == Sum(x*y,(x,0,oo),(y,0,oo))
+    assert S.subs(f(x),x) == S
+    raises(ValueError, lambda: S.subs(f(y),x+y) )
+    S = Sum(x*log(y),(x,0,oo),(y,0,oo))
+    assert S.subs(log(y),y) == S
+    S = Sum(x*f(y),(x,0,oo),(y,0,oo))
+    assert S.subs(f(y),y) == Sum(x*y,(x,0,oo),(y,0,oo))
+
+
+def test_equality():
+    # if this fails remove special handling below
+    raises(ValueError, lambda: Sum(x, x))
+    r = symbols('x', real=True)
+    for F in (Sum, Product, Integral):
+        try:
+            assert F(x, x) != F(y, y)
+            assert F(x, (x, 1, 2)) != F(x, x)
+            assert F(x, (x, x)) != F(x, x)  # or else they print the same
+            assert F(1, x) != F(1, y)
+        except ValueError:
+            pass
+        assert F(a, (x, 1, 2)) != F(a, (x, 1, 3))  # diff limit
+        assert F(a, (x, 1, x)) != F(a, (y, 1, y))
+        assert F(a, (x, 1, 2)) != F(b, (x, 1, 2))  # diff expression
+        assert F(x, (x, 1, 2)) != F(r, (r, 1, 2))  # diff assumptions
+        assert F(1, (x, 1, x)) != F(1, (y, 1, x))  # only dummy is diff
+        assert F(1, (x, 1, x)).dummy_eq(F(1, (y, 1, x)))
+
+    # issue 5265
+    assert Sum(x, (x, 1, x)).subs(x, a) == Sum(x, (x, 1, a))
+
+
+def test_Sum_doit():
+    assert Sum(n*Integral(a**2), (n, 0, 2)).doit() == a**3
+    assert Sum(n*Integral(a**2), (n, 0, 2)).doit(deep=False) == \
+        3*Integral(a**2)
+    assert summation(n*Integral(a**2), (n, 0, 2)) == 3*Integral(a**2)
+
+    # test nested sum evaluation
+    s = Sum( Sum( Sum(2,(z,1,n+1)), (y,x+1,n)), (x,1,n))
+    assert 0 == (s.doit() - n*(n+1)*(n-1)).factor()
+
+    # Integer assumes finite
+    assert Sum(KroneckerDelta(x, y), (x, -oo, oo)).doit() == Piecewise((1, And(-oo < y, y < oo)), (0, True))
+    assert Sum(KroneckerDelta(m, n), (m, -oo, oo)).doit() == 1
+    assert Sum(m*KroneckerDelta(x, y), (x, -oo, oo)).doit() == Piecewise((m, And(-oo < y, y < oo)), (0, True))
+    assert Sum(x*KroneckerDelta(m, n), (m, -oo, oo)).doit() == x
+    assert Sum(Sum(KroneckerDelta(m, n), (m, 1, 3)), (n, 1, 3)).doit() == 3
+    assert Sum(Sum(KroneckerDelta(k, m), (m, 1, 3)), (n, 1, 3)).doit() == \
+           3 * Piecewise((1, And(1 <= k, k <= 3)), (0, True))
+    assert Sum(f(n) * Sum(KroneckerDelta(m, n), (m, 0, oo)), (n, 1, 3)).doit() == \
+           f(1) + f(2) + f(3)
+    assert Sum(f(n) * Sum(KroneckerDelta(m, n), (m, 0, oo)), (n, 1, oo)).doit() == \
+           Sum(f(n), (n, 1, oo))
+
+    # issue 2597
+    nmax = symbols('N', integer=True, positive=True)
+    pw = Piecewise((1, And(1 <= n, n <= nmax)), (0, True))
+    assert Sum(pw, (n, 1, nmax)).doit() == Sum(Piecewise((1, nmax >= n),
+                    (0, True)), (n, 1, nmax))
+
+    q, s = symbols('q, s')
+    assert summation(1/n**(2*s), (n, 1, oo)) == Piecewise((zeta(2*s), 2*re(s) > 1),
+        (Sum(n**(-2*s), (n, 1, oo)), True))
+    assert summation(1/(n+1)**s, (n, 0, oo)) == Piecewise((zeta(s), re(s) > 1),
+        (Sum((n + 1)**(-s), (n, 0, oo)), True))
+    assert summation(1/(n+q)**s, (n, 0, oo)) == Piecewise(
+        (zeta(s, q), And(~Contains(-q, S.Naturals0), re(s) > 1)),
+        (Sum((n + q)**(-s), (n, 0, oo)), True))
+    assert summation(1/(n+q)**s, (n, q, oo)) == Piecewise(
+        (zeta(s, 2*q), And(~Contains(-2*q, S.Naturals0), re(s) > 1)),
+        (Sum((n + q)**(-s), (n, q, oo)), True))
+    assert summation(1/n**2, (n, 1, oo)) == zeta(2)
+    assert summation(1/n**s, (n, 0, oo)) == Sum(n**(-s), (n, 0, oo))
+    assert summation(1/(n+1)**(2+I), (n, 0, oo)) == zeta(2+I)
+    t = symbols('t', real=True, positive=True)
+    assert summation(1/(n+I)**(t+1), (n, 0, oo)) == zeta(t+1, I)
+
+
+def test_Product_doit():
+    assert Product(n*Integral(a**2), (n, 1, 3)).doit() == 2 * a**9 / 9
+    assert Product(n*Integral(a**2), (n, 1, 3)).doit(deep=False) == \
+        6*Integral(a**2)**3
+    assert product(n*Integral(a**2), (n, 1, 3)) == 6*Integral(a**2)**3
+
+
+def test_Sum_interface():
+    assert isinstance(Sum(0, (n, 0, 2)), Sum)
+    assert Sum(nan, (n, 0, 2)) is nan
+    assert Sum(nan, (n, 0, oo)) is nan
+    assert Sum(0, (n, 0, 2)).doit() == 0
+    assert isinstance(Sum(0, (n, 0, oo)), Sum)
+    assert Sum(0, (n, 0, oo)).doit() == 0
+    raises(ValueError, lambda: Sum(1))
+    raises(ValueError, lambda: summation(1))
+
+
+def test_diff():
+    assert Sum(x, (x, 1, 2)).diff(x) == 0
+    assert Sum(x*y, (x, 1, 2)).diff(x) == 0
+    assert Sum(x*y, (y, 1, 2)).diff(x) == Sum(y, (y, 1, 2))
+    e = Sum(x*y, (x, 1, a))
+    assert e.diff(a) == Derivative(e, a)
+    assert Sum(x*y, (x, 1, 3), (a, 2, 5)).diff(y).doit() == \
+        Sum(x*y, (x, 1, 3), (a, 2, 5)).doit().diff(y) == 24
+    assert Sum(x, (x, 1, 2)).diff(y) == 0
+
+
+def test_hypersum():
+    assert simplify(summation(x**n/fac(n), (n, 1, oo))) == -1 + exp(x)
+    assert summation((-1)**n * x**(2*n) / fac(2*n), (n, 0, oo)) == cos(x)
+    assert simplify(summation((-1)**n*x**(2*n + 1) /
+        factorial(2*n + 1), (n, 3, oo))) == -x + sin(x) + x**3/6 - x**5/120
+
+    assert summation(1/(n + 2)**3, (n, 1, oo)) == Rational(-9, 8) + zeta(3)
+    assert summation(1/n**4, (n, 1, oo)) == pi**4/90
+
+    s = summation(x**n*n, (n, -oo, 0))
+    assert s.is_Piecewise
+    assert s.args[0].args[0] == -1/(x*(1 - 1/x)**2)
+    assert s.args[0].args[1] == (abs(1/x) < 1)
+
+    m = Symbol('n', integer=True, positive=True)
+    assert summation(binomial(m, k), (k, 0, m)) == 2**m
+
+
+def test_issue_4170():
+    assert summation(1/factorial(k), (k, 0, oo)) == E
+
+
+def test_is_commutative():
+    from sympy.physics.secondquant import NO, F, Fd
+    m = Symbol('m', commutative=False)
+    for f in (Sum, Product, Integral):
+        assert f(z, (z, 1, 1)).is_commutative is True
+        assert f(z*y, (z, 1, 6)).is_commutative is True
+        assert f(m*x, (x, 1, 2)).is_commutative is False
+
+        assert f(NO(Fd(x)*F(y))*z, (z, 1, 2)).is_commutative is False
+
+
+def test_is_zero():
+    for func in [Sum, Product]:
+        assert func(0, (x, 1, 1)).is_zero is True
+        assert func(x, (x, 1, 1)).is_zero is None
+
+    assert Sum(0, (x, 1, 0)).is_zero is True
+    assert Product(0, (x, 1, 0)).is_zero is False
+
+
+def test_is_number():
+    # is number should not rely on evaluation or assumptions,
+    # it should be equivalent to `not foo.free_symbols`
+    assert Sum(1, (x, 1, 1)).is_number is True
+    assert Sum(1, (x, 1, x)).is_number is False
+    assert Sum(0, (x, y, z)).is_number is False
+    assert Sum(x, (y, 1, 2)).is_number is False
+    assert Sum(x, (y, 1, 1)).is_number is False
+    assert Sum(x, (x, 1, 2)).is_number is True
+    assert Sum(x*y, (x, 1, 2), (y, 1, 3)).is_number is True
+
+    assert Product(2, (x, 1, 1)).is_number is True
+    assert Product(2, (x, 1, y)).is_number is False
+    assert Product(0, (x, y, z)).is_number is False
+    assert Product(1, (x, y, z)).is_number is False
+    assert Product(x, (y, 1, x)).is_number is False
+    assert Product(x, (y, 1, 2)).is_number is False
+    assert Product(x, (y, 1, 1)).is_number is False
+    assert Product(x, (x, 1, 2)).is_number is True
+
+
+def test_free_symbols():
+    for func in [Sum, Product]:
+        assert func(1, (x, 1, 2)).free_symbols == set()
+        assert func(0, (x, 1, y)).free_symbols == {y}
+        assert func(2, (x, 1, y)).free_symbols == {y}
+        assert func(x, (x, 1, 2)).free_symbols == set()
+        assert func(x, (x, 1, y)).free_symbols == {y}
+        assert func(x, (y, 1, y)).free_symbols == {x, y}
+        assert func(x, (y, 1, 2)).free_symbols == {x}
+        assert func(x, (y, 1, 1)).free_symbols == {x}
+        assert func(x, (y, 1, z)).free_symbols == {x, z}
+        assert func(x, (x, 1, y), (y, 1, 2)).free_symbols == set()
+        assert func(x, (x, 1, y), (y, 1, z)).free_symbols == {z}
+        assert func(x, (x, 1, y), (y, 1, y)).free_symbols == {y}
+        assert func(x, (y, 1, y), (y, 1, z)).free_symbols == {x, z}
+    assert Sum(1, (x, 1, y)).free_symbols == {y}
+    # free_symbols answers whether the object *as written* has free symbols,
+    # not whether the evaluated expression has free symbols
+    assert Product(1, (x, 1, y)).free_symbols == {y}
+    # don't count free symbols that are not independent of integration
+    # variable(s)
+    assert func(f(x), (f(x), 1, 2)).free_symbols == set()
+    assert func(f(x), (f(x), 1, x)).free_symbols == {x}
+    assert func(f(x), (f(x), 1, y)).free_symbols == {y}
+    assert func(f(x), (z, 1, y)).free_symbols == {x, y}
+
+
+def test_conjugate_transpose():
+    A, B = symbols("A B", commutative=False)
+    p = Sum(A*B**n, (n, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+    p = Sum(B**n*A, (n, 1, 3))
+    assert p.adjoint().doit() == p.doit().adjoint()
+    assert p.conjugate().doit() == p.doit().conjugate()
+    assert p.transpose().doit() == p.doit().transpose()
+
+
+def test_noncommutativity_honoured():
+    A, B = symbols("A B", commutative=False)
+    M = symbols('M', integer=True, positive=True)
+    p = Sum(A*B**n, (n, 1, M))
+    assert p.doit() == A*Piecewise((M, Eq(B, 1)),
+                                   ((B - B**(M + 1))*(1 - B)**(-1), True))
+
+    p = Sum(B**n*A, (n, 1, M))
+    assert p.doit() == Piecewise((M, Eq(B, 1)),
+                                 ((B - B**(M + 1))*(1 - B)**(-1), True))*A
+
+    p = Sum(B**n*A*B**n, (n, 1, M))
+    assert p.doit() == p
+
+
+def test_issue_4171():
+    assert summation(factorial(2*k + 1)/factorial(2*k), (k, 0, oo)) is oo
+    assert summation(2*k + 1, (k, 0, oo)) is oo
+
+
+def test_issue_6273():
+    assert Sum(x, (x, 1, n)).n(2, subs={n: 1}) == Float(1, 2)
+
+
+def test_issue_6274():
+    assert Sum(x, (x, 1, 0)).doit() == 0
+    assert NS(Sum(x, (x, 1, 0))) == '0'
+    assert Sum(n, (n, 10, 5)).doit() == -30
+    assert NS(Sum(n, (n, 10, 5))) == '-30.0000000000000'
+
+
+def test_simplify_sum():
+    y, t, v = symbols('y, t, v')
+
+    _simplify = lambda e: simplify(e, doit=False)
+    assert _simplify(Sum(x*y, (x, n, m), (y, a, k)) + \
+        Sum(y, (x, n, m), (y, a, k))) == Sum(y * (x + 1), (x, n, m), (y, a, k))
+    assert _simplify(Sum(x, (x, n, m)) + Sum(x, (x, m + 1, a))) == \
+        Sum(x, (x, n, a))
+    assert _simplify(Sum(x, (x, k + 1, a)) + Sum(x, (x, n, k))) == \
+        Sum(x, (x, n, a))
+    assert _simplify(Sum(x, (x, k + 1, a)) + Sum(x + 1, (x, n, k))) == \
+        Sum(x, (x, n, a)) + Sum(1, (x, n, k))
+    assert _simplify(Sum(x, (x, 0, 3)) * 3 + 3 * Sum(x, (x, 4, 6)) + \
+        4 * Sum(z, (z, 0, 1))) == 4*Sum(z, (z, 0, 1)) + 3*Sum(x, (x, 0, 6))
+    assert _simplify(3*Sum(x**2, (x, a, b)) + Sum(x, (x, a, b))) == \
+        Sum(x*(3*x + 1), (x, a, b))
+    assert _simplify(Sum(x**3, (x, n, k)) * 3 + 3 * Sum(x, (x, n, k)) + \
+        4 * y * Sum(z, (z, n, k))) + 1 == \
+            4*y*Sum(z, (z, n, k)) + 3*Sum(x**3 + x, (x, n, k)) + 1
+    assert _simplify(Sum(x, (x, a, b)) + 1 + Sum(x, (x, b + 1, c))) == \
+        1 + Sum(x, (x, a, c))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + \
+        Sum(x, (t, b+1, c))) == x * Sum(1, (t, a, c)) + y * Sum(1, (t, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(x, (t, b+1, c)) + \
+        Sum(y, (t, a, b))) == x * Sum(1, (t, a, c)) + y * Sum(1, (t, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + 2 * Sum(x, (t, b+1, c))) == \
+        _simplify(Sum(x, (t, a, b)) + Sum(x, (t, b+1, c)) + Sum(x, (t, b+1, c)))
+    assert _simplify(Sum(x, (x, a, b))*Sum(x**2, (x, a, b))) == \
+        Sum(x, (x, a, b)) * Sum(x**2, (x, a, b))
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + Sum(z, (t, a, b))) \
+        == (x + y + z) * Sum(1, (t, a, b))          # issue 8596
+    assert _simplify(Sum(x, (t, a, b)) + Sum(y, (t, a, b)) + Sum(z, (t, a, b)) + \
+        Sum(v, (t, a, b))) == (x + y + z + v) * Sum(1, (t, a, b))  # issue 8596
+    assert _simplify(Sum(x * y, (x, a, b)) / (3 * y)) == \
+        (Sum(x, (x, a, b)) / 3)
+    assert _simplify(Sum(f(x) * y * z, (x, a, b)) / (y * z)) \
+        == Sum(f(x), (x, a, b))
+    assert _simplify(Sum(c * x, (x, a, b)) - c * Sum(x, (x, a, b))) == 0
+    assert _simplify(c * (Sum(x, (x, a, b))  + y)) == c * (y + Sum(x, (x, a, b)))
+    assert _simplify(c * (Sum(x, (x, a, b)) + y * Sum(x, (x, a, b)))) == \
+        c * (y + 1) * Sum(x, (x, a, b))
+    assert _simplify(Sum(Sum(c * x, (x, a, b)), (y, a, b))) == \
+                c * Sum(x, (x, a, b), (y, a, b))
+    assert _simplify(Sum((3 + y) * Sum(c * x, (x, a, b)), (y, a, b))) == \
+                c * Sum((3 + y), (y, a, b)) * Sum(x, (x, a, b))
+    assert _simplify(Sum((3 + t) * Sum(c * t, (x, a, b)), (y, a, b))) == \
+                c*t*(t + 3)*Sum(1, (x, a, b))*Sum(1, (y, a, b))
+    assert _simplify(Sum(Sum(d * t, (x, a, b - 1)) + \
+                Sum(d * t, (x, b, c)), (t, a, b))) == \
+                    d * Sum(1, (x, a, c)) * Sum(t, (t, a, b))
+    assert _simplify(Sum(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
+        2 * Sum(1, (t, a, b))
+
+
+def test_change_index():
+    b, v, w = symbols('b, v, w', integer = True)
+
+    assert Sum(x, (x, a, b)).change_index(x, x + 1, y) == \
+        Sum(y - 1, (y, a + 1, b + 1))
+    assert Sum(x**2, (x, a, b)).change_index( x, x - 1) == \
+        Sum((x+1)**2, (x, a - 1, b - 1))
+    assert Sum(x**2, (x, a, b)).change_index( x, -x, y) == \
+        Sum((-y)**2, (y, -b, -a))
+    assert Sum(x, (x, a, b)).change_index( x, -x - 1) == \
+        Sum(-x - 1, (x, -b - 1, -a - 1))
+    assert Sum(x*y, (x, a, b), (y, c, d)).change_index( x, x - 1, z) == \
+        Sum((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
+    assert Sum(x, (x, a, b)).change_index( x, x + v) == \
+        Sum(-v + x, (x, a + v, b + v))
+    assert Sum(x, (x, a, b)).change_index( x, -x - v) == \
+        Sum(-v - x, (x, -b - v, -a - v))
+    assert Sum(x, (x, a, b)).change_index(x, w*x, v) == \
+        Sum(v/w, (v, b*w, a*w))
+    raises(ValueError, lambda: Sum(x, (x, a, b)).change_index(x, 2*x))
+
+
+def test_reorder():
+    b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
+
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+    assert Sum(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
+        Sum(x, (x, c, d), (x, a, b))
+    assert Sum(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
+        (2, 0), (0, 1)) == Sum(x*y + z, (z, m, n), (y, c, d), (x, a, b))
+    assert Sum(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (0, 1), (1, 2), (0, 2)) == Sum(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Sum(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
+        (x, y), (y, z), (x, z)) == Sum(x*y*z, (x, a, b), (z, m, n), (y, c, d))
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+    assert Sum(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
+        Sum(x*y, (y, c, d), (x, a, b))
+
+
+def test_reverse_order():
+    assert Sum(x, (x, 0, 3)).reverse_order(0) == Sum(-x, (x, 4, -1))
+    assert Sum(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
+           Sum(x*y, (x, 6, 0), (y, 7, -1))
+    assert Sum(x, (x, 1, 2)).reverse_order(0) == Sum(-x, (x, 3, 0))
+    assert Sum(x, (x, 1, 3)).reverse_order(0) == Sum(-x, (x, 4, 0))
+    assert Sum(x, (x, 1, a)).reverse_order(0) == Sum(-x, (x, a + 1, 0))
+    assert Sum(x, (x, a, 5)).reverse_order(0) == Sum(-x, (x, 6, a - 1))
+    assert Sum(x, (x, a + 1, a + 5)).reverse_order(0) == \
+                         Sum(-x, (x, a + 6, a))
+    assert Sum(x, (x, a + 1, a + 2)).reverse_order(0) == \
+           Sum(-x, (x, a + 3, a))
+    assert Sum(x, (x, a + 1, a + 1)).reverse_order(0) == \
+           Sum(-x, (x, a + 2, a))
+    assert Sum(x, (x, a, b)).reverse_order(0) == Sum(-x, (x, b + 1, a - 1))
+    assert Sum(x, (x, a, b)).reverse_order(x) == Sum(-x, (x, b + 1, a - 1))
+    assert Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+    assert Sum(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
+        Sum(x*y, (x, b + 1, a - 1), (y, 6, 1))
+
+
+def test_issue_7097():
+    assert sum(x**n/n for n in range(1, 401)) == summation(x**n/n, (n, 1, 400))
+
+
+def test_factor_expand_subs():
+    # test factoring
+    assert Sum(4 * x, (x, 1, y)).factor() == 4 * Sum(x, (x, 1, y))
+    assert Sum(x * a, (x, 1, y)).factor() == a * Sum(x, (x, 1, y))
+    assert Sum(4 * x * a, (x, 1, y)).factor() == 4 * a * Sum(x, (x, 1, y))
+    assert Sum(4 * x * y, (x, 1, y)).factor() == 4 * y * Sum(x, (x, 1, y))
+
+    # test expand
+    _x = Symbol('x', zero=False)
+    assert Sum(x+1,(x,1,y)).expand() == Sum(x,(x,1,y)) + Sum(1,(x,1,y))
+    assert Sum(x+a*x**2,(x,1,y)).expand() == Sum(x,(x,1,y)) + Sum(a*x**2,(x,1,y))
+    assert Sum(_x**(n + 1)*(n + 1), (n, -1, oo)).expand() \
+        == Sum(n*_x*_x**n + _x*_x**n, (n, -1, oo))
+    assert Sum(x**(n + 1)*(n + 1), (n, -1, oo)).expand(power_exp=False) \
+        == Sum(n*x**(n + 1) + x**(n + 1), (n, -1, oo))
+    assert Sum(x**(n + 1)*(n + 1), (n, -1, oo)).expand(force=True) \
+           == Sum(x*x**n, (n, -1, oo)) + Sum(n*x*x**n, (n, -1, oo))
+    assert Sum(a*n+a*n**2,(n,0,4)).expand() \
+        == Sum(a*n,(n,0,4)) + Sum(a*n**2,(n,0,4))
+    assert Sum(_x**a*_x**n,(x,0,3)) \
+        == Sum(_x**(a+n),(x,0,3)).expand(power_exp=True)
+    _a, _n = symbols('a n', positive=True)
+    assert Sum(x**(_a+_n),(x,0,3)).expand(power_exp=True) \
+        == Sum(x**_a*x**_n, (x, 0, 3))
+    assert Sum(x**(_a-_n),(x,0,3)).expand(power_exp=True) \
+        == Sum(x**(_a-_n),(x,0,3)).expand(power_exp=False)
+
+    # test subs
+    assert Sum(1/(1+a*x**2),(x,0,3)).subs([(a,3)]) == Sum(1/(1+3*x**2),(x,0,3))
+    assert Sum(x*y,(x,0,y),(y,0,x)).subs([(x,3)]) == Sum(x*y,(x,0,y),(y,0,3))
+    assert Sum(x,(x,1,10)).subs([(x,y-2)]) == Sum(x,(x,1,10))
+    assert Sum(1/x,(x,1,10)).subs([(x,(3+n)**3)]) == Sum(1/x,(x,1,10))
+    assert Sum(1/x,(x,1,10)).subs([(x,3*x-2)]) == Sum(1/x,(x,1,10))
+
+
+def test_distribution_over_equality():
+    assert Product(Eq(x*2, f(x)), (x, 1, 3)).doit() == Eq(48, f(1)*f(2)*f(3))
+    assert Sum(Eq(f(x), x**2), (x, 0, y)) == \
+        Eq(Sum(f(x), (x, 0, y)), Sum(x**2, (x, 0, y)))
+
+
+def test_issue_2787():
+    n, k = symbols('n k', positive=True, integer=True)
+    p = symbols('p', positive=True)
+    binomial_dist = binomial(n, k)*p**k*(1 - p)**(n - k)
+    s = Sum(binomial_dist*k, (k, 0, n))
+    res = s.doit().simplify()
+    ans = Piecewise(
+        (n*p, x),
+        (Sum(k*p**k*binomial(n, k)*(1 - p)**(n - k), (k, 0, n)),
+        True)).subs(x, (Eq(n, 1) | (n > 1)) & (p/Abs(p - 1) <= 1))
+    ans2 = Piecewise(
+        (n*p, x),
+        (factorial(n)*Sum(p**k*(1 - p)**(-k + n)/
+        (factorial(-k + n)*factorial(k - 1)), (k, 0, n)),
+        True)).subs(x, (Eq(n, 1) | (n > 1)) & (p/Abs(p - 1) <= 1))
+    assert res in [ans, ans2]  # XXX system dependent
+    # Issue #17165: make sure that another simplify does not complicate
+    # the result by much. Why didn't first simplify replace
+    # Eq(n, 1) | (n > 1) with True?
+    assert res.simplify().count_ops() <= res.count_ops() + 2
+
+
+def test_issue_4668():
+    assert summation(1/n, (n, 2, oo)) is oo
+
+
+def test_matrix_sum():
+    A = Matrix([[0, 1], [n, 0]])
+
+    result = Sum(A, (n, 0, 3)).doit()
+    assert result == Matrix([[0, 4], [6, 0]])
+    assert result.__class__ == ImmutableDenseMatrix
+
+    A = SparseMatrix([[0, 1], [n, 0]])
+
+    result = Sum(A, (n, 0, 3)).doit()
+    assert result.__class__ == ImmutableSparseMatrix
+
+
+def test_failing_matrix_sum():
+    n = Symbol('n')
+    # TODO Implement matrix geometric series summation.
+    A = Matrix([[0, 1, 0], [-1, 0, 0], [0, 0, 0]])
+    assert Sum(A ** n, (n, 1, 4)).doit() == \
+        Matrix([[0, 0, 0], [0, 0, 0], [0, 0, 0]])
+    # issue sympy/sympy#16989
+    assert summation(A**n, (n, 1, 1)) == A
+
+
+def test_indexed_idx_sum():
+    i = symbols('i', cls=Idx)
+    r = Indexed('r', i)
+    assert Sum(r, (i, 0, 3)).doit() == sum(r.xreplace({i: j}) for j in range(4))
+    assert Product(r, (i, 0, 3)).doit() == prod([r.xreplace({i: j}) for j in range(4)])
+
+    j = symbols('j', integer=True)
+    assert Sum(r, (i, j, j+2)).doit() == sum(r.xreplace({i: j+k}) for k in range(3))
+    assert Product(r, (i, j, j+2)).doit() == prod([r.xreplace({i: j+k}) for k in range(3)])
+
+    k = Idx('k', range=(1, 3))
+    A = IndexedBase('A')
+    assert Sum(A[k], k).doit() == sum(A[Idx(j, (1, 3))] for j in range(1, 4))
+    assert Product(A[k], k).doit() == prod([A[Idx(j, (1, 3))] for j in range(1, 4)])
+
+    raises(ValueError, lambda: Sum(A[k], (k, 1, 4)))
+    raises(ValueError, lambda: Sum(A[k], (k, 0, 3)))
+    raises(ValueError, lambda: Sum(A[k], (k, 2, oo)))
+
+    raises(ValueError, lambda: Product(A[k], (k, 1, 4)))
+    raises(ValueError, lambda: Product(A[k], (k, 0, 3)))
+    raises(ValueError, lambda: Product(A[k], (k, 2, oo)))
+
+
+@slow
+def test_is_convergent():
+    # divergence tests --
+    assert Sum(n/(2*n + 1), (n, 1, oo)).is_convergent() is S.false
+    assert Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(3**(-2*n - 1)*n**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum((-1)**n*n, (n, 3, oo)).is_convergent() is S.false
+    assert Sum((-1)**n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(log(1/n), (n, 2, oo)).is_convergent() is S.false
+    assert Sum(sin(n), (n, 1, oo)).is_convergent() is S.false
+
+    # Raabe's test --
+    assert Sum(Product((3*m),(m,1,n))/Product((3*m+4),(m,1,n)),(n,1,oo)).is_convergent() is S.true
+
+    # root test --
+    assert Sum((-12)**n/n, (n, 1, oo)).is_convergent() is S.false
+
+    # integral test --
+
+    # p-series test --
+    assert Sum(1/(n**2 + 1), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(1/n**Rational(6, 5), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(2/(n*sqrt(n - 1)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(sqrt(n)*sqrt(n)), (n, 2, oo)).is_convergent() is S.false
+    assert Sum(factorial(n) / factorial(n+2), (n, 1, oo)).is_convergent() is S.true
+    assert Sum(rf(5,n)/rf(7,n),(n,1,oo)).is_convergent() is S.true
+    assert Sum((rf(1, n)*rf(2, n))/(rf(3, n)*factorial(n)),(n,1,oo)).is_convergent() is S.false
+
+    # comparison test --
+    assert Sum(1/(n + log(n)), (n, 1, oo)).is_convergent() is S.false
+    assert Sum(1/(n**2*log(n)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*log(n)), (n, 2, oo)).is_convergent() is S.false
+    assert Sum(2/(n*log(n)*log(log(n))**2), (n, 5, oo)).is_convergent() is S.true
+    assert Sum(2/(n*log(n)**2), (n, 2, oo)).is_convergent() is S.true
+    assert Sum((n - 1)/(n**2*log(n)**3), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*log(n)*log(log(n))), (n, 5, oo)).is_convergent() is S.false
+    assert Sum((n - 1)/(n*log(n)**3), (n, 3, oo)).is_convergent() is S.false
+    assert Sum(2/(n**2*log(n)), (n, 2, oo)).is_convergent() is S.true
+    assert Sum(1/(n*sqrt(log(n))*log(log(n))), (n, 100, oo)).is_convergent() is S.false
+    assert Sum(log(log(n))/(n*log(n)**2), (n, 100, oo)).is_convergent() is S.true
+    assert Sum(log(n)/n**2, (n, 5, oo)).is_convergent() is S.true
+
+    # alternating series tests --
+    assert Sum((-1)**(n - 1)/(n**2 - 1), (n, 3, oo)).is_convergent() is S.true
+
+    # with -negativeInfinite Limits
+    assert Sum(1/(n**2 + 1), (n, -oo, 1)).is_convergent() is S.true
+    assert Sum(1/(n - 1), (n, -oo, -1)).is_convergent() is S.false
+    assert Sum(1/(n**2 - 1), (n, -oo, -5)).is_convergent() is S.true
+    assert Sum(1/(n**2 - 1), (n, -oo, 2)).is_convergent() is S.true
+    assert Sum(1/(n**2 - 1), (n, -oo, oo)).is_convergent() is S.true
+
+    # piecewise functions
+    f = Piecewise((n**(-2), n <= 1), (n**2, n > 1))
+    assert Sum(f, (n, 1, oo)).is_convergent() is S.false
+    assert Sum(f, (n, -oo, oo)).is_convergent() is S.false
+    assert Sum(f, (n, 1, 100)).is_convergent() is S.true
+    #assert Sum(f, (n, -oo, 1)).is_convergent() is S.true
+
+    # integral test
+
+    assert Sum(log(n)/n**3, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(-log(n)/n**3, (n, 1, oo)).is_convergent() is S.true
+    # the following function has maxima located at (x, y) =
+    # (1.2, 0.43), (3.0, -0.25) and (6.8, 0.050)
+    eq = (x - 2)*(x**2 - 6*x + 4)*exp(-x)
+    assert Sum(eq, (x, 1, oo)).is_convergent() is S.true
+    assert Sum(eq, (x, 1, 2)).is_convergent() is S.true
+    assert Sum(1/(x**3), (x, 1, oo)).is_convergent() is S.true
+    assert Sum(1/(x**S.Half), (x, 1, oo)).is_convergent() is S.false
+
+    # issue 19545
+    assert Sum(1/n - 3/(3*n +2), (n, 1, oo)).is_convergent() is S.true
+
+    # issue 19836
+    assert Sum(4/(n + 2) - 5/(n + 1) + 1/n,(n, 7, oo)).is_convergent() is S.true
+
+
+def test_is_absolutely_convergent():
+    assert Sum((-1)**n, (n, 1, oo)).is_absolutely_convergent() is S.false
+    assert Sum((-1)**n/n**2, (n, 1, oo)).is_absolutely_convergent() is S.true
+
+
+@XFAIL
+def test_convergent_failing():
+    # dirichlet tests
+    assert Sum(sin(n)/n, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(sin(2*n)/n, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_6966():
+    i, k, m = symbols('i k m', integer=True)
+    z_i, q_i = symbols('z_i q_i')
+    a_k = Sum(-q_i*z_i/k,(i,1,m))
+    b_k = a_k.diff(z_i)
+    assert isinstance(b_k, Sum)
+    assert b_k == Sum(-q_i/k,(i,1,m))
+
+
+def test_issue_10156():
+    cx = Sum(2*y**2*x, (x, 1,3))
+    e = 2*y*Sum(2*cx*x**2, (x, 1, 9))
+    assert e.factor() == \
+        8*y**3*Sum(x, (x, 1, 3))*Sum(x**2, (x, 1, 9))
+
+
+def test_issue_10973():
+    assert Sum((-n + (n**3 + 1)**(S(1)/3))/log(n), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14103():
+    assert Sum(sin(n)**2 + cos(n)**2 - 1, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(sin(pi*n), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14129():
+    x = Symbol('x', zero=False)
+    assert Sum( k*x**k, (k, 0, n-1)).doit() == \
+        Piecewise((n**2/2 - n/2, Eq(x, 1)), ((n*x*x**n -
+            n*x**n - x*x**n + x)/(x - 1)**2, True))
+    assert Sum( x**k, (k, 0, n-1)).doit() == \
+        Piecewise((n, Eq(x, 1)), ((-x**n + 1)/(-x + 1), True))
+    assert Sum( k*(x/y+x)**k, (k, 0, n-1)).doit() == \
+        Piecewise((n*(n - 1)/2, Eq(x, y/(y + 1))),
+        (x*(y + 1)*(n*x*y*(x + x/y)**(n - 1) +
+        n*x*(x + x/y)**(n - 1) - n*y*(x + x/y)**(n - 1) -
+        x*y*(x + x/y)**(n - 1) - x*(x + x/y)**(n - 1) + y)/
+        (x*y + x - y)**2, True))
+
+
+def test_issue_14112():
+    assert Sum((-1)**n/sqrt(n), (n, 1, oo)).is_absolutely_convergent() is S.false
+    assert Sum((-1)**(2*n)/n, (n, 1, oo)).is_convergent() is S.false
+    assert Sum((-2)**n + (-3)**n, (n, 1, oo)).is_convergent() is S.false
+
+
+def test_issue_14219():
+    A = diag(0, 2, -3)
+    res = diag(1, 15, -20)
+    assert Sum(A**n, (n, 0, 3)).doit() == res
+
+
+def test_sin_times_absolutely_convergent():
+    assert Sum(sin(n) / n**3, (n, 1, oo)).is_convergent() is S.true
+    assert Sum(sin(n) * log(n) / n**3, (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14111():
+    assert Sum(1/log(log(n)), (n, 22, oo)).is_convergent() is S.false
+
+
+def test_issue_14484():
+    assert Sum(sin(n)/log(log(n)), (n, 22, oo)).is_convergent() is S.false
+
+
+def test_issue_14640():
+    i, n = symbols("i n", integer=True)
+    a, b, c = symbols("a b c", zero=False)
+
+    assert Sum(a**-i/(a - b), (i, 0, n)).doit() == Sum(
+        1/(a*a**i - a**i*b), (i, 0, n)).doit() == Piecewise(
+            (n + 1, Eq(1/a, 1)),
+            ((-a**(-n - 1) + 1)/(1 - 1/a), True))/(a - b)
+
+    assert Sum((b*a**i - c*a**i)**-2, (i, 0, n)).doit() == Piecewise(
+        (n + 1, Eq(a**(-2), 1)),
+        ((-a**(-2*n - 2) + 1)/(1 - 1/a**2), True))/(b - c)**2
+
+    s = Sum(i*(a**(n - i) - b**(n - i))/(a - b), (i, 0, n)).doit()
+    assert not s.has(Sum)
+    assert s.subs({a: 2, b: 3, n: 5}) == 122
+
+
+def test_issue_15943():
+    s = Sum(binomial(n, k)*factorial(n - k), (k, 0, n)).doit().rewrite(gamma)
+    assert s == -E*(n + 1)*gamma(n + 1)*lowergamma(n + 1, 1)/gamma(n + 2
+        ) + E*gamma(n + 1)
+    assert s.simplify() == E*(factorial(n) - lowergamma(n + 1, 1))
+
+
+def test_Sum_dummy_eq():
+    assert not Sum(x, (x, a, b)).dummy_eq(1)
+    assert not Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, b), (a, 1, 2)))
+    assert not Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, c)))
+    assert Sum(x, (x, a, b)).dummy_eq(Sum(x, (x, a, b)))
+    d = Dummy()
+    assert Sum(x, (x, a, d)).dummy_eq(Sum(x, (x, a, c)), c)
+    assert not Sum(x, (x, a, d)).dummy_eq(Sum(x, (x, a, c)))
+    assert Sum(x, (x, a, c)).dummy_eq(Sum(y, (y, a, c)))
+    assert Sum(x, (x, a, d)).dummy_eq(Sum(y, (y, a, c)), c)
+    assert not Sum(x, (x, a, d)).dummy_eq(Sum(y, (y, a, c)))
+
+
+def test_issue_15852():
+    assert summation(x**y*y, (y, -oo, oo)).doit() == Sum(x**y*y, (y, -oo, oo))
+
+
+def test_exceptions():
+    S = Sum(x, (x, a, b))
+    raises(ValueError, lambda: S.change_index(x, x**2, y))
+    S = Sum(x, (x, a, b), (x, 1, 4))
+    raises(ValueError, lambda: S.index(x))
+    S = Sum(x, (x, a, b), (y, 1, 4))
+    raises(ValueError, lambda: S.reorder([x]))
+    S = Sum(x, (x, y, b), (y, 1, 4))
+    raises(ReorderError, lambda: S.reorder_limit(0, 1))
+    S = Sum(x*y, (x, a, b), (y, 1, 4))
+    raises(NotImplementedError, lambda: S.is_convergent())
+
+
+def test_sumproducts_assumptions():
+    M = Symbol('M', integer=True, positive=True)
+
+    m = Symbol('m', integer=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, -M, M)).is_positive is None
+        assert func(m, (m, -M, M)).is_nonpositive is None
+        assert func(m, (m, -M, M)).is_negative is None
+        assert func(m, (m, -M, M)).is_nonnegative is None
+        assert func(m, (m, -M, M)).is_finite is True
+
+    m = Symbol('m', integer=True, nonnegative=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, 0, M)).is_positive is None
+        assert func(m, (m, 0, M)).is_nonpositive is None
+        assert func(m, (m, 0, M)).is_negative is False
+        assert func(m, (m, 0, M)).is_nonnegative is True
+        assert func(m, (m, 0, M)).is_finite is True
+
+    m = Symbol('m', integer=True, positive=True)
+    for func in [Sum, Product]:
+        assert func(m, (m, 1, M)).is_positive is True
+        assert func(m, (m, 1, M)).is_nonpositive is False
+        assert func(m, (m, 1, M)).is_negative is False
+        assert func(m, (m, 1, M)).is_nonnegative is True
+        assert func(m, (m, 1, M)).is_finite is True
+
+    m = Symbol('m', integer=True, negative=True)
+    assert Sum(m, (m, -M, -1)).is_positive is False
+    assert Sum(m, (m, -M, -1)).is_nonpositive is True
+    assert Sum(m, (m, -M, -1)).is_negative is True
+    assert Sum(m, (m, -M, -1)).is_nonnegative is False
+    assert Sum(m, (m, -M, -1)).is_finite is True
+    assert Product(m, (m, -M, -1)).is_positive is None
+    assert Product(m, (m, -M, -1)).is_nonpositive is None
+    assert Product(m, (m, -M, -1)).is_negative is None
+    assert Product(m, (m, -M, -1)).is_nonnegative is None
+    assert Product(m, (m, -M, -1)).is_finite is True
+
+    m = Symbol('m', integer=True, nonpositive=True)
+    assert Sum(m, (m, -M, 0)).is_positive is False
+    assert Sum(m, (m, -M, 0)).is_nonpositive is True
+    assert Sum(m, (m, -M, 0)).is_negative is None
+    assert Sum(m, (m, -M, 0)).is_nonnegative is None
+    assert Sum(m, (m, -M, 0)).is_finite is True
+    assert Product(m, (m, -M, 0)).is_positive is None
+    assert Product(m, (m, -M, 0)).is_nonpositive is None
+    assert Product(m, (m, -M, 0)).is_negative is None
+    assert Product(m, (m, -M, 0)).is_nonnegative is None
+    assert Product(m, (m, -M, 0)).is_finite is True
+
+    m = Symbol('m', integer=True)
+    assert Sum(2, (m, 0, oo)).is_positive is None
+    assert Sum(2, (m, 0, oo)).is_nonpositive is None
+    assert Sum(2, (m, 0, oo)).is_negative is None
+    assert Sum(2, (m, 0, oo)).is_nonnegative is None
+    assert Sum(2, (m, 0, oo)).is_finite is None
+
+    assert Product(2, (m, 0, oo)).is_positive is None
+    assert Product(2, (m, 0, oo)).is_nonpositive is None
+    assert Product(2, (m, 0, oo)).is_negative is False
+    assert Product(2, (m, 0, oo)).is_nonnegative is None
+    assert Product(2, (m, 0, oo)).is_finite is None
+
+    assert Product(0, (x, M, M-1)).is_positive is True
+    assert Product(0, (x, M, M-1)).is_finite is True
+
+
+def test_expand_with_assumptions():
+    M = Symbol('M', integer=True, positive=True)
+    x = Symbol('x', positive=True)
+    m = Symbol('m', nonnegative=True)
+    assert log(Product(x**m, (m, 0, M))).expand() == Sum(m*log(x), (m, 0, M))
+    assert log(Product(exp(x**m), (m, 0, M))).expand() == Sum(x**m, (m, 0, M))
+    assert log(Product(x**m, (m, 0, M))).rewrite(Sum).expand() == Sum(m*log(x), (m, 0, M))
+    assert log(Product(exp(x**m), (m, 0, M))).rewrite(Sum).expand() == Sum(x**m, (m, 0, M))
+
+    n = Symbol('n', nonnegative=True)
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    assert log(Product(x**i*y**j, (i, 1, n), (j, 1, m))).expand() \
+        == Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+    m = Symbol('m', nonnegative=True, integer=True)
+    s = Sum(x**m, (m, 0, M))
+    s_as_product = s.rewrite(Product)
+    assert s_as_product.has(Product)
+    assert s_as_product == log(Product(exp(x**m), (m, 0, M)))
+    assert s_as_product.expand() == s
+    s5 = s.subs(M, 5)
+    s5_as_product = s5.rewrite(Product)
+    assert s5_as_product.has(Product)
+    assert s5_as_product.doit().expand() == s5.doit()
+
+
+def test_has_finite_limits():
+    x = Symbol('x')
+    assert Sum(1, (x, 1, 9)).has_finite_limits is True
+    assert Sum(1, (x, 1, oo)).has_finite_limits is False
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_finite_limits is None
+    M = Symbol('M', positive=True)
+    assert Sum(1, (x, 1, M)).has_finite_limits is True
+    x = Symbol('x', positive=True)
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_finite_limits is True
+
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_finite_limits is False
+
+def test_has_reversed_limits():
+    assert Sum(1, (x, 1, 1)).has_reversed_limits is False
+    assert Sum(1, (x, 1, 9)).has_reversed_limits is False
+    assert Sum(1, (x, 1, -9)).has_reversed_limits is True
+    assert Sum(1, (x, 1, 0)).has_reversed_limits is True
+    assert Sum(1, (x, 1, oo)).has_reversed_limits is False
+    M = Symbol('M')
+    assert Sum(1, (x, 1, M)).has_reversed_limits is None
+    M = Symbol('M', positive=True, integer=True)
+    assert Sum(1, (x, 1, M)).has_reversed_limits is False
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_reversed_limits is False
+    M = Symbol('M', negative=True)
+    assert Sum(1, (x, 1, M)).has_reversed_limits is True
+
+    assert Sum(1, (x, 1, M), (y, -oo, oo)).has_reversed_limits is True
+    assert Sum(1, (x, oo, oo)).has_reversed_limits is None
+
+
+def test_has_empty_sequence():
+    assert Sum(1, (x, 1, 1)).has_empty_sequence is False
+    assert Sum(1, (x, 1, 9)).has_empty_sequence is False
+    assert Sum(1, (x, 1, -9)).has_empty_sequence is False
+    assert Sum(1, (x, 1, 0)).has_empty_sequence is True
+    assert Sum(1, (x, y, y - 1)).has_empty_sequence is True
+    assert Sum(1, (x, 3, 2), (y, -oo, oo)).has_empty_sequence is True
+    assert Sum(1, (y, -oo, oo), (x, 3, 2)).has_empty_sequence is True
+    assert Sum(1, (x, oo, oo)).has_empty_sequence is False
+
+
+def test_empty_sequence():
+    assert Product(x*y, (x, -oo, oo), (y, 1, 0)).doit() == 1
+    assert Product(x*y, (y, 1, 0), (x, -oo, oo)).doit() == 1
+    assert Sum(x, (x, -oo, oo), (y, 1, 0)).doit() == 0
+    assert Sum(x, (y, 1, 0), (x, -oo, oo)).doit() == 0
+
+
+def test_issue_8016():
+    k = Symbol('k', integer=True)
+    n, m = symbols('n, m', integer=True, positive=True)
+    s = Sum(binomial(m, k)*binomial(m, n - k)*(-1)**k, (k, 0, n))
+    assert s.doit().simplify() == \
+        cos(pi*n/2)*gamma(m + 1)/gamma(n/2 + 1)/gamma(m - n/2 + 1)
+
+
+def test_issue_14313():
+    assert Sum(S.Half**floor(n/2), (n, 1, oo)).is_convergent()
+
+
+def test_issue_14563():
+    # The assertion was failing due to no assumptions methods in Sums and Product
+    assert 1 % Sum(1, (x, 0, 1)) == 1
+
+
+def test_issue_16735():
+    assert Sum(5**n/gamma(n+1), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_14871():
+    assert Sum((Rational(1, 10))**n*rf(0, n)/factorial(n), (n, 0, oo)).rewrite(factorial).doit() == 1
+
+
+def test_issue_17165():
+    n = symbols("n", integer=True)
+    x = symbols('x')
+    s = (x*Sum(x**n, (n, -1, oo)))
+    ssimp = s.doit().simplify()
+
+    assert ssimp == Piecewise((-1/(x - 1), (x > -1) & (x < 1)),
+                              (x*Sum(x**n, (n, -1, oo)), True)), ssimp
+    assert ssimp.simplify() == ssimp
+
+
+def test_issue_19379():
+    assert Sum(factorial(n)/factorial(n + 2), (n, 1, oo)).is_convergent() is S.true
+
+
+def test_issue_20777():
+    assert Sum(exp(x*sin(n/m)), (n, 1, m)).doit() == Sum(exp(x*sin(n/m)), (n, 1, m))
+
+
+def test__dummy_with_inherited_properties_concrete():
+    x = Symbol('x')
+
+    from sympy.core.containers import Tuple
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 0, 5))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_nonnegative
+    assert d.is_extended_nonnegative
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 1, 9))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_positive
+    assert d.is_odd is None
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, -5, 5))
+    assert d.is_real
+    assert d.is_integer
+    assert d.is_positive is None
+    assert d.is_extended_nonnegative is None
+    assert d.is_odd is None
+
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, -1.5, 1.5))
+    assert d.is_real
+    assert d.is_integer is None
+    assert d.is_positive is None
+    assert d.is_extended_nonnegative is None
+
+    N = Symbol('N', integer=True, positive=True)
+    d = _dummy_with_inherited_properties_concrete(Tuple(x, 2, N))
+    assert d.is_real
+    assert d.is_positive
+    assert d.is_integer
+
+    # Return None if no assumptions are added
+    N = Symbol('N', integer=True, positive=True)
+    d = _dummy_with_inherited_properties_concrete(Tuple(N, 2, 4))
+    assert d is None
+
+    x = Symbol('x', negative=True)
+    raises(InconsistentAssumptions,
+           lambda: _dummy_with_inherited_properties_concrete(Tuple(x, 1, 5)))
+
+
+def test_matrixsymbol_summation_numerical_limits():
+    A = MatrixSymbol('A', 3, 3)
+    n = Symbol('n', integer=True)
+
+    assert Sum(A**n, (n, 0, 2)).doit() == Identity(3) + A + A**2
+    assert Sum(A, (n, 0, 2)).doit() == 3*A
+    assert Sum(n*A, (n, 0, 2)).doit() == 3*A
+
+    B = Matrix([[0, n, 0], [-1, 0, 0], [0, 0, 2]])
+    ans = Matrix([[0, 6, 0], [-4, 0, 0], [0, 0, 8]]) + 4*A
+    assert Sum(A+B, (n, 0, 3)).doit() == ans
+    ans = A*Matrix([[0, 6, 0], [-4, 0, 0], [0, 0, 8]])
+    assert Sum(A*B, (n, 0, 3)).doit() == ans
+
+    ans = (A**2*Matrix([[-2, 0, 0], [0,-2, 0], [0, 0, 4]]) +
+           A**3*Matrix([[0, -9, 0], [3, 0, 0], [0, 0, 8]]) +
+           A*Matrix([[0, 1, 0], [-1, 0, 0], [0, 0, 2]]))
+    assert Sum(A**n*B**n, (n, 1, 3)).doit() == ans
+
+
+def test_issue_21651():
+    i = Symbol('i')
+    a = Sum(floor(2*2**(-i)), (i, S.One, 2))
+    assert a.doit() == S.One
+
+
+@XFAIL
+def test_matrixsymbol_summation_symbolic_limits():
+    N = Symbol('N', integer=True, positive=True)
+
+    A = MatrixSymbol('A', 3, 3)
+    n = Symbol('n', integer=True)
+    assert Sum(A, (n, 0, N)).doit() == (N+1)*A
+    assert Sum(n*A, (n, 0, N)).doit() == (N**2/2+N/2)*A
+
+
+def test_summation_by_residues():
+    x = Symbol('x')
+
+    # Examples from Nakhle H. Asmar, Loukas Grafakos,
+    # Complex Analysis with Applications
+    assert eval_sum_residue(1 / (x**2 + 1), (x, -oo, oo)) == pi/tanh(pi)
+    assert eval_sum_residue(1 / x**6, (x, S(1), oo)) == pi**6/945
+    assert eval_sum_residue(1 / (x**2 + 9), (x, -oo, oo)) == pi/(3*tanh(3*pi))
+    assert eval_sum_residue(1 / (x**2 + 1)**2, (x, -oo, oo)).cancel() == \
+        (-pi**2*tanh(pi)**2 + pi*tanh(pi) + pi**2)/(2*tanh(pi)**2)
+    assert eval_sum_residue(x**2 / (x**2 + 1)**2, (x, -oo, oo)).cancel() == \
+        (-pi**2 + pi*tanh(pi) + pi**2*tanh(pi)**2)/(2*tanh(pi)**2)
+    assert eval_sum_residue(1 / (4*x**2 - 1), (x, -oo, oo)) == 0
+    assert eval_sum_residue(x**2 / (x**2 - S(1)/4)**2, (x, -oo, oo)) == pi**2/2
+    assert eval_sum_residue(1 / (4*x**2 - 1)**2, (x, -oo, oo)) == pi**2/8
+    assert eval_sum_residue(1 / ((x - S(1)/2)**2 + 1), (x, -oo, oo)) == pi*tanh(pi)
+    assert eval_sum_residue(1 / x**2, (x, S(1), oo)) == pi**2/6
+    assert eval_sum_residue(1 / x**4, (x, S(1), oo)) == pi**4/90
+    assert eval_sum_residue(1 / x**2 / (x**2 + 4), (x, S(1), oo)) == \
+        -pi*(-pi/12 - 1/(16*pi) + 1/(8*tanh(2*pi)))/2
+
+    # Some examples made from 1 / (x**2 + 1)
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(0), oo)) == \
+        S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(1), oo)) == \
+        -S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 1), (x, S(-1), oo)) == \
+        1 + pi/(2*tanh(pi))
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, -oo, oo)) == \
+        pi/sinh(pi)
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(0), oo)) == \
+        pi/(2*sinh(pi)) + S(1)/2
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(1), oo)) == \
+        -S(1)/2 + pi/(2*sinh(pi))
+    assert eval_sum_residue((-1)**x / (x**2 + 1), (x, S(-1), oo)) == \
+        pi/(2*sinh(pi))
+
+    # Some examples made from shifting of 1 / (x**2 + 1)
+    assert eval_sum_residue(1 / (x**2 + 2*x + 2), (x, S(-1), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 + 4*x + 5), (x, S(-2), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 - 2*x + 2), (x, S(1), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue(1 / (x**2 - 4*x + 5), (x, S(2), oo)) == S(1)/2 + pi/(2*tanh(pi))
+    assert eval_sum_residue((-1)**x * -1 / (x**2 + 2*x + 2), (x, S(-1), oo)) ==  S(1)/2 + pi/(2*sinh(pi))
+    assert eval_sum_residue((-1)**x * -1 / (x**2 -2*x + 2), (x, S(1), oo)) == S(1)/2 + pi/(2*sinh(pi))
+
+    # Some examples made from 1 / x**2
+    assert eval_sum_residue(1 / x**2, (x, S(2), oo)) == -1 + pi**2/6
+    assert eval_sum_residue(1 / x**2, (x, S(3), oo)) == -S(5)/4 + pi**2/6
+    assert eval_sum_residue((-1)**x / x**2, (x, S(1), oo)) == -pi**2/12
+    assert eval_sum_residue((-1)**x / x**2, (x, S(2), oo)) == 1 - pi**2/12
+
+
+@slow
+def test_summation_by_residues_failing():
+    x = Symbol('x')
+
+    # Failing because of the bug in residue computation
+    assert eval_sum_residue(x**2 / (x**4 + 1), (x, S(1), oo))
+    assert eval_sum_residue(1 / ((x - 1)*(x - 2) + 1), (x, -oo, oo)) != 0
+
+
+def test_process_limits():
+    from sympy.concrete.expr_with_limits import _process_limits
+
+    # these should be (x, Range(3)) not Range(3)
+    raises(ValueError, lambda: _process_limits(
+        Range(3), discrete=True))
+    raises(ValueError, lambda: _process_limits(
+        Range(3), discrete=False))
+    # these should be (x, union) not union
+    # (but then we would get a TypeError because we don't
+    # handle non-contiguous sets: see below use of `union`)
+    union = Or(x < 1, x > 3).as_set()
+    raises(ValueError, lambda: _process_limits(
+        union, discrete=True))
+    raises(ValueError, lambda: _process_limits(
+        union, discrete=False))
+
+    # error not triggered if not needed
+    assert _process_limits((x, 1, 2)) == ([(x, 1, 2)], 1)
+
+    # this equivalence is used to detect Reals in _process_limits
+    assert isinstance(S.Reals, Interval)
+
+    C = Integral  # continuous limits
+    assert C(x, x >= 5) == C(x, (x, 5, oo))
+    assert C(x, x < 3) == C(x, (x, -oo, 3))
+    ans = C(x, (x, 0, 3))
+    assert C(x, And(x >= 0, x < 3)) == ans
+    assert C(x, (x, Interval.Ropen(0, 3))) == ans
+    raises(TypeError, lambda: C(x, (x, Range(3))))
+
+    # discrete limits
+    for D in (Sum, Product):
+        r, ans = Range(3, 10, 2), D(2*x + 3, (x, 0, 3))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        r, ans = Range(3, oo, 2), D(2*x + 3, (x, 0, oo))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        r, ans = Range(-oo, 5, 2), D(3 - 2*x, (x, 0, oo))
+        assert D(x, (x, r)) == ans
+        assert D(x, (x, r.reversed)) == ans
+        raises(TypeError, lambda: D(x, x > 0))
+        raises(ValueError, lambda: D(x, Interval(1, 3)))
+        raises(NotImplementedError, lambda: D(x, (x, union)))
+
+
+def test_pr_22677():
+    b = Symbol('b', integer=True, positive=True)
+    assert Sum(1/x**2,(x, 0, b)).doit() == Sum(x**(-2), (x, 0, b))
+    assert Sum(1/(x - b)**2,(x, 0, b-1)).doit() == Sum(
+        (-b + x)**(-2), (x, 0, b - 1))
+
+
+def test_issue_23952():
+    p, q = symbols("p q", real=True, nonnegative=True)
+    k1, k2 = symbols("k1 k2", integer=True, nonnegative=True)
+    n = Symbol("n", integer=True, positive=True)
+    expr = Sum(abs(k1 - k2)*p**k1 *(1 - q)**(n - k2),
+        (k1, 0, n), (k2, 0, n))
+    assert expr.subs(p,0).subs(q,1).subs(n, 3).doit() == 3
diff --git a/.venv/lib/python3.12/site-packages/sympy/conftest.py b/.venv/lib/python3.12/site-packages/sympy/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..788ec7ed8a38de422b76c4ac19057513670d2d38
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/conftest.py
@@ -0,0 +1,96 @@
+import sys
+
+sys._running_pytest = True  # type: ignore
+from sympy.external.importtools import version_tuple
+
+import pytest
+from sympy.core.cache import clear_cache, USE_CACHE
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.utilities.misc import ARCH
+import re
+
+try:
+    import hypothesis
+
+    hypothesis.settings.register_profile("sympy_hypothesis_profile", deadline=None)
+    hypothesis.settings.load_profile("sympy_hypothesis_profile")
+except ImportError:
+    raise ImportError(
+        "hypothesis is a required dependency to run the SymPy test suite. "
+        "Install it with 'pip install hypothesis' or 'conda install -c conda-forge hypothesis'"
+    )
+
+
+sp = re.compile(r"([0-9]+)/([1-9][0-9]*)")
+
+
+def process_split(config, items):
+    split = config.getoption("--split")
+    if not split:
+        return
+    m = sp.match(split)
+    if not m:
+        raise ValueError(
+            "split must be a string of the form a/b " "where a and b are ints."
+        )
+    i, t = map(int, m.groups())
+    start, end = (i - 1) * len(items) // t, i * len(items) // t
+
+    if i < t:
+        # remove elements from end of list first
+        del items[end:]
+    del items[:start]
+
+
+def pytest_report_header(config):
+    s = "architecture: %s\n" % ARCH
+    s += "cache:        %s\n" % USE_CACHE
+    version = ""
+    if GROUND_TYPES == "gmpy":
+        import gmpy2
+
+        version = gmpy2.version()
+    elif GROUND_TYPES == "flint":
+        try:
+            from flint import __version__
+        except ImportError:
+            version = "unknown"
+        else:
+            version = f'(python-flint=={__version__})'
+    s += "ground types: %s %s\n" % (GROUND_TYPES, version)
+    return s
+
+
+def pytest_terminal_summary(terminalreporter):
+    if terminalreporter.stats.get("error", None) or terminalreporter.stats.get(
+        "failed", None
+    ):
+        terminalreporter.write_sep(" ", "DO *NOT* COMMIT!", red=True, bold=True)
+
+
+def pytest_addoption(parser):
+    parser.addoption("--split", action="store", default="", help="split tests")
+
+
+def pytest_collection_modifyitems(config, items):
+    """pytest hook."""
+    # handle splits
+    process_split(config, items)
+
+
+@pytest.fixture(autouse=True, scope="module")
+def file_clear_cache():
+    clear_cache()
+
+
+@pytest.fixture(autouse=True, scope="module")
+def check_disabled(request):
+    if getattr(request.module, "disabled", False):
+        pytest.skip("test requirements not met.")
+    elif getattr(request.module, "ipython", False):
+        # need to check version and options for ipython tests
+        if (
+            version_tuple(pytest.__version__) < version_tuple("2.6.3")
+            and pytest.config.getvalue("-s") != "no"
+        ):
+            pytest.skip("run py.test with -s or upgrade to newer version.")
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__init__.py b/.venv/lib/python3.12/site-packages/sympy/core/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4c03c9fc11479bb6d93a3bff3dfd0992ef994a19
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/__init__.py
@@ -0,0 +1,103 @@
+"""Core module. Provides the basic operations needed in sympy.
+"""
+
+from .sympify import sympify, SympifyError
+from .cache import cacheit
+from .assumptions import assumptions, check_assumptions, failing_assumptions, common_assumptions
+from .basic import Basic, Atom
+from .singleton import S
+from .expr import Expr, AtomicExpr, UnevaluatedExpr
+from .symbol import Symbol, Wild, Dummy, symbols, var
+from .numbers import Number, Float, Rational, Integer, NumberSymbol, \
+    RealNumber, igcd, ilcm, seterr, E, I, nan, oo, pi, zoo, \
+    AlgebraicNumber, comp, mod_inverse
+from .power import Pow
+from .intfunc import integer_nthroot, integer_log, num_digits, trailing
+from .mul import Mul, prod
+from .add import Add
+from .mod import Mod
+from .relational import ( Rel, Eq, Ne, Lt, Le, Gt, Ge,
+    Equality, GreaterThan, LessThan, Unequality, StrictGreaterThan,
+    StrictLessThan )
+from .multidimensional import vectorize
+from .function import Lambda, WildFunction, Derivative, diff, FunctionClass, \
+    Function, Subs, expand, PoleError, count_ops, \
+    expand_mul, expand_log, expand_func, \
+    expand_trig, expand_complex, expand_multinomial, nfloat, \
+    expand_power_base, expand_power_exp, arity
+from .evalf import PrecisionExhausted, N
+from .containers import Tuple, Dict
+from .exprtools import gcd_terms, factor_terms, factor_nc
+from .parameters import evaluate
+from .kind import UndefinedKind, NumberKind, BooleanKind
+from .traversal import preorder_traversal, bottom_up, use, postorder_traversal
+from .sorting import default_sort_key, ordered
+
+# expose singletons
+Catalan = S.Catalan
+EulerGamma = S.EulerGamma
+GoldenRatio = S.GoldenRatio
+TribonacciConstant = S.TribonacciConstant
+
+__all__ = [
+    'sympify', 'SympifyError',
+
+    'cacheit',
+
+    'assumptions', 'check_assumptions', 'failing_assumptions',
+    'common_assumptions',
+
+    'Basic', 'Atom',
+
+    'S',
+
+    'Expr', 'AtomicExpr', 'UnevaluatedExpr',
+
+    'Symbol', 'Wild', 'Dummy', 'symbols', 'var',
+
+    'Number', 'Float', 'Rational', 'Integer', 'NumberSymbol', 'RealNumber',
+    'igcd', 'ilcm', 'seterr', 'E', 'I', 'nan', 'oo', 'pi', 'zoo',
+    'AlgebraicNumber', 'comp', 'mod_inverse',
+
+    'Pow',
+
+    'integer_nthroot', 'integer_log', 'num_digits', 'trailing',
+
+    'Mul', 'prod',
+
+    'Add',
+
+    'Mod',
+
+    'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge', 'Equality', 'GreaterThan',
+    'LessThan', 'Unequality', 'StrictGreaterThan', 'StrictLessThan',
+
+    'vectorize',
+
+    'Lambda', 'WildFunction', 'Derivative', 'diff', 'FunctionClass',
+    'Function', 'Subs', 'expand', 'PoleError', 'count_ops', 'expand_mul',
+    'expand_log', 'expand_func', 'expand_trig', 'expand_complex',
+    'expand_multinomial', 'nfloat', 'expand_power_base', 'expand_power_exp',
+    'arity',
+
+    'PrecisionExhausted', 'N',
+
+    'evalf', # The module?
+
+    'Tuple', 'Dict',
+
+    'gcd_terms', 'factor_terms', 'factor_nc',
+
+    'evaluate',
+
+    'Catalan',
+    'EulerGamma',
+    'GoldenRatio',
+    'TribonacciConstant',
+
+    'UndefinedKind', 'NumberKind', 'BooleanKind',
+
+    'preorder_traversal', 'bottom_up', 'use', 'postorder_traversal',
+
+    'default_sort_key', 'ordered',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e833a3e17b1fa4266eb971a54826c63b9f9825b1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/_print_helpers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/_print_helpers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b25645bc0347f29605c77496128353456f6748ce
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/_print_helpers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/add.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/add.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f18f6255af187264239892a40b8f2bce354e44ad
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/add.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/alphabets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/alphabets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1388552d3dfafe9d65643e7d0d27207891caed26
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/alphabets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a4beda6346264598799aa1dd10892ebdb04fc2b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions_generated.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions_generated.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4ed879ffcb27945c56aeb1e794cfc8bbd841191
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/assumptions_generated.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/backend.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/backend.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b09d675b6f962106a6b6f868d681bed7ecaea932
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/backend.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/basic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/basic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e846bda12398e2e08fa653593f0f84411a141d83
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/basic.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/cache.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/cache.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a8b5d30de82a080a889f233e500e22ebcace9a7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/cache.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/compatibility.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/compatibility.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac1eeecad14db69a919bd7e838fb3f0f89049b43
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/compatibility.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/containers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/containers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac0a0229d351622257d1cf14465c9f4facae878a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/containers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/core.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/core.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4e25f1a7ab3a05a0c899f7eb3a5ab26349dac114
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/core.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/coreerrors.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/coreerrors.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f057fad128f83d30f0bed3dcafe78e1bde6c498f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/coreerrors.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/decorators.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/decorators.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23d12d9ed494ad530ebfb25ac65460b177387e0a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/decorators.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/evalf.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/evalf.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4f97dad286b9e603fc06ae2401552bbc12897fd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/evalf.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/expr.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/expr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd6b1beb82d1e9ba725c467f0ef4e9cd5a522acf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/expr.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1bbada6d9185d0f3f82ea98edd30d14333133a05ea83399093278603fabfcffd
+size 156328
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/exprtools.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/exprtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..073888aebc47f29e8c0605d7d1471ee538ebb190
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/exprtools.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/facts.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/facts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7dd109263b377681f194bc6d898d33852b8b65e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/facts.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/function.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/function.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98b384ca9dbbcb1da007e0f2cabc850f5b334982
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/function.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f010e3720ba6d2f5b0281c6a891df7147f5238c88513b2155aad4689e02e879c
+size 137775
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/intfunc.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/intfunc.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b8b6f7513fc731f2b21cb97d314b1baaf0ea1fab
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/intfunc.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/kind.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/kind.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbb330baa8edd72d30575c44454bcddcff2983cd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/kind.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/logic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/logic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..920809e022e766708cc1c39a6351843c5d62428a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/logic.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mod.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mod.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1a99ba8afb3800e6aa24e1ac4a00a9b93719cf11
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mod.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mul.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mul.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f29846a2744e379d25ec040d6b96c317d2f81cb9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/mul.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/multidimensional.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/multidimensional.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d313414a8ce415db785f42ce9a4d976473f26605
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/multidimensional.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..310e83d29173aead6baba4ea8800519092f72388
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/numbers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e0e36ac8264c2fdf99d2c42bae91cf9c5d847964fba09bd19810fbf89e0118af
+size 184659
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/operations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/operations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8d18ed75179fa77b550cd746564c4230c6bf398c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/operations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/parameters.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/parameters.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c14d1f0e469047cb9cd5520b364c41af09cf988
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/parameters.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/power.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/power.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e0b7b6384179d8122d74c3e3a899d51db7e07b70
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/power.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/random.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/random.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27991f157da799a1a4a5d43e449c8e9aa08f7b38
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/random.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/relational.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/relational.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a52a4532bd1bdd776736014a8e0bbba528f0eb47
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/relational.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/rules.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/rules.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54f52d3df3c4041b2bd766f059d15d0170798c5e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/rules.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/singleton.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/singleton.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c596ccbb2075f8a455e2ed7977f12cb93cc2af99
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/singleton.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sorting.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sorting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6617c543025106905c0dc6b0636caddf3dc032fd
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sorting.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/symbol.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/symbol.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0fb558e2fe1a306cac35fa98f2950bd6f494414
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/symbol.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sympify.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sympify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf37f8ec281810fe4a5fb5d35daf88d50860be8a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/sympify.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/trace.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/trace.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..559dc96a1017a91d145cdd431e2f9fe5be402d45
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/trace.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/traversal.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/traversal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7516f163e607123ae47ec53c137c9f16079d1115
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/__pycache__/traversal.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/_print_helpers.py b/.venv/lib/python3.12/site-packages/sympy/core/_print_helpers.py
new file mode 100644
index 0000000000000000000000000000000000000000..d704ed220d444e2d8510b280dca85c8ae6149d4c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/_print_helpers.py
@@ -0,0 +1,65 @@
+"""
+Base class to provide str and repr hooks that `init_printing` can overwrite.
+
+This is exposed publicly in the `printing.defaults` module,
+but cannot be defined there without causing circular imports.
+"""
+
+class Printable:
+    """
+    The default implementation of printing for SymPy classes.
+
+    This implements a hack that allows us to print elements of built-in
+    Python containers in a readable way. Natively Python uses ``repr()``
+    even if ``str()`` was explicitly requested. Mix in this trait into
+    a class to get proper default printing.
+
+    This also adds support for LaTeX printing in jupyter notebooks.
+    """
+
+    # Since this class is used as a mixin we set empty slots. That means that
+    # instances of any subclasses that use slots will not need to have a
+    # __dict__.
+    __slots__ = ()
+
+    # Note, we always use the default ordering (lex) in __str__ and __repr__,
+    # regardless of the global setting. See issue 5487.
+    def __str__(self):
+        from sympy.printing.str import sstr
+        return sstr(self, order=None)
+
+    __repr__ = __str__
+
+    def _repr_disabled(self):
+        """
+        No-op repr function used to disable jupyter display hooks.
+
+        When :func:`sympy.init_printing` is used to disable certain display
+        formats, this function is copied into the appropriate ``_repr_*_``
+        attributes.
+
+        While we could just set the attributes to `None``, doing it this way
+        allows derived classes to call `super()`.
+        """
+        return None
+
+    # We don't implement _repr_png_ here because it would add a large amount of
+    # data to any notebook containing SymPy expressions, without adding
+    # anything useful to the notebook. It can still enabled manually, e.g.,
+    # for the qtconsole, with init_printing().
+    _repr_png_ = _repr_disabled
+
+    _repr_svg_ = _repr_disabled
+
+    def _repr_latex_(self):
+        """
+        IPython/Jupyter LaTeX printing
+
+        To change the behavior of this (e.g., pass in some settings to LaTeX),
+        use init_printing(). init_printing() will also enable LaTeX printing
+        for built in numeric types like ints and container types that contain
+        SymPy objects, like lists and dictionaries of expressions.
+        """
+        from sympy.printing.latex import latex
+        s = latex(self, mode='plain')
+        return "$\\displaystyle %s$" % s
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/add.py b/.venv/lib/python3.12/site-packages/sympy/core/add.py
new file mode 100644
index 0000000000000000000000000000000000000000..2d280f3286c34cd0dea14bf61194ed03ee6bf6ae
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/add.py
@@ -0,0 +1,1280 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar
+from collections import defaultdict
+from functools import reduce
+from operator import attrgetter
+from .basic import _args_sortkey
+from .parameters import global_parameters
+from .logic import _fuzzy_group, fuzzy_or, fuzzy_not
+from .singleton import S
+from .operations import AssocOp, AssocOpDispatcher
+from .cache import cacheit
+from .intfunc import ilcm, igcd
+from .expr import Expr
+from .kind import UndefinedKind
+from sympy.utilities.iterables import is_sequence, sift
+
+
+if TYPE_CHECKING:
+    from sympy.core.numbers import Number
+    from sympy.series.order import Order
+
+
+def _could_extract_minus_sign(expr):
+    # assume expr is Add-like
+    # We choose the one with less arguments with minus signs
+    negative_args = sum(1 for i in expr.args
+        if i.could_extract_minus_sign())
+    positive_args = len(expr.args) - negative_args
+    if positive_args > negative_args:
+        return False
+    elif positive_args < negative_args:
+        return True
+    # choose based on .sort_key() to prefer
+    # x - 1 instead of 1 - x and
+    # 3 - sqrt(2) instead of -3 + sqrt(2)
+    return bool(expr.sort_key() < (-expr).sort_key())
+
+
+def _addsort(args):
+    # in-place sorting of args
+    args.sort(key=_args_sortkey)
+
+
+def _unevaluated_Add(*args):
+    """Return a well-formed unevaluated Add: Numbers are collected and
+    put in slot 0 and args are sorted. Use this when args have changed
+    but you still want to return an unevaluated Add.
+
+    Examples
+    ========
+
+    >>> from sympy.core.add import _unevaluated_Add as uAdd
+    >>> from sympy import S, Add
+    >>> from sympy.abc import x, y
+    >>> a = uAdd(*[S(1.0), x, S(2)])
+    >>> a.args[0]
+    3.00000000000000
+    >>> a.args[1]
+    x
+
+    Beyond the Number being in slot 0, there is no other assurance of
+    order for the arguments since they are hash sorted. So, for testing
+    purposes, output produced by this in some other function can only
+    be tested against the output of this function or as one of several
+    options:
+
+    >>> opts = (Add(x, y, evaluate=False), Add(y, x, evaluate=False))
+    >>> a = uAdd(x, y)
+    >>> assert a in opts and a == uAdd(x, y)
+    >>> uAdd(x + 1, x + 2)
+    x + x + 3
+    """
+    args = list(args)
+    newargs = []
+    co = S.Zero
+    while args:
+        a = args.pop()
+        if a.is_Add:
+            # this will keep nesting from building up
+            # so that x + (x + 1) -> x + x + 1 (3 args)
+            args.extend(a.args)
+        elif a.is_Number:
+            co += a
+        else:
+            newargs.append(a)
+    _addsort(newargs)
+    if co:
+        newargs.insert(0, co)
+    return Add._from_args(newargs)
+
+
+class Add(Expr, AssocOp):
+    """
+    Expression representing addition operation for algebraic group.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Every argument of ``Add()`` must be ``Expr``. Infix operator ``+``
+    on most scalar objects in SymPy calls this class.
+
+    Another use of ``Add()`` is to represent the structure of abstract
+    addition so that its arguments can be substituted to return different
+    class. Refer to examples section for this.
+
+    ``Add()`` evaluates the argument unless ``evaluate=False`` is passed.
+    The evaluation logic includes:
+
+    1. Flattening
+        ``Add(x, Add(y, z))`` -> ``Add(x, y, z)``
+
+    2. Identity removing
+        ``Add(x, 0, y)`` -> ``Add(x, y)``
+
+    3. Coefficient collecting by ``.as_coeff_Mul()``
+        ``Add(x, 2*x)`` -> ``Mul(3, x)``
+
+    4. Term sorting
+        ``Add(y, x, 2)`` -> ``Add(2, x, y)``
+
+    If no argument is passed, identity element 0 is returned. If single
+    element is passed, that element is returned.
+
+    Note that ``Add(*args)`` is more efficient than ``sum(args)`` because
+    it flattens the arguments. ``sum(a, b, c, ...)`` recursively adds the
+    arguments as ``a + (b + (c + ...))``, which has quadratic complexity.
+    On the other hand, ``Add(a, b, c, d)`` does not assume nested
+    structure, making the complexity linear.
+
+    Since addition is group operation, every argument should have the
+    same :obj:`sympy.core.kind.Kind()`.
+
+    Examples
+    ========
+
+    >>> from sympy import Add, I
+    >>> from sympy.abc import x, y
+    >>> Add(x, 1)
+    x + 1
+    >>> Add(x, x)
+    2*x
+    >>> 2*x**2 + 3*x + I*y + 2*y + 2*x/5 + 1.0*y + 1
+    2*x**2 + 17*x/5 + 3.0*y + I*y + 1
+
+    If ``evaluate=False`` is passed, result is not evaluated.
+
+    >>> Add(1, 2, evaluate=False)
+    1 + 2
+    >>> Add(x, x, evaluate=False)
+    x + x
+
+    ``Add()`` also represents the general structure of addition operation.
+
+    >>> from sympy import MatrixSymbol
+    >>> A,B = MatrixSymbol('A', 2,2), MatrixSymbol('B', 2,2)
+    >>> expr = Add(x,y).subs({x:A, y:B})
+    >>> expr
+    A + B
+    >>> type(expr)
+    
+
+    Note that the printers do not display in args order.
+
+    >>> Add(x, 1)
+    x + 1
+    >>> Add(x, 1).args
+    (1, x)
+
+    See Also
+    ========
+
+    MatAdd
+
+    """
+
+    __slots__ = ()
+
+    is_Add = True
+
+    _args_type = Expr
+
+    identity: ClassVar[Expr]
+
+    if TYPE_CHECKING:
+
+        def __new__(cls, *args: Expr | complex, evaluate: bool=True) -> Expr: # type: ignore
+            ...
+
+        @property
+        def args(self) -> tuple[Expr, ...]:
+            ...
+
+    @classmethod
+    def flatten(cls, seq: list[Expr]) -> tuple[list[Expr], list[Expr], None]:
+        """
+        Takes the sequence "seq" of nested Adds and returns a flatten list.
+
+        Returns: (commutative_part, noncommutative_part, order_symbols)
+
+        Applies associativity, all terms are commutable with respect to
+        addition.
+
+        NB: the removal of 0 is already handled by AssocOp.__new__
+
+        See Also
+        ========
+
+        sympy.core.mul.Mul.flatten
+
+        """
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.matrices.expressions import MatrixExpr
+        from sympy.tensor.tensor import TensExpr, TensAdd
+        rv = None
+        if len(seq) == 2:
+            a, b = seq
+            if b.is_Rational:
+                a, b = b, a
+            if a.is_Rational:
+                if b.is_Mul:
+                    rv = [a, b], [], None
+            if rv:
+                if all(s.is_commutative for s in rv[0]):
+                    return rv
+                return [], rv[0], None
+
+        # term -> coeff
+        # e.g. x**2 -> 5   for ... + 5*x**2 + ...
+        terms: dict[Expr, Number] = {}
+
+        # coefficient (Number or zoo) to always be in slot 0
+        # e.g. 3 + ...
+        coeff: Expr = S.Zero
+
+        order_factors: list[Order] = []
+
+        extra: list[MatrixExpr] = []
+
+        for o in seq:
+
+            # O(x)
+            if o.is_Order:
+                if o.expr.is_zero: # type: ignore
+                    continue
+                if any(o1.contains(o) for o1 in order_factors):
+                    continue
+                order_factors = [o1 for o1 in order_factors if not o.contains(o1)] # type: ignore
+                order_factors = [o] + order_factors # type: ignore
+                continue
+
+            # 3 or NaN
+            elif o.is_Number:
+                if (o is S.NaN or coeff is S.ComplexInfinity and
+                        o.is_finite is False) and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                if coeff.is_Number or isinstance(coeff, AccumBounds):
+                    coeff += o
+                    if coeff is S.NaN and not extra:
+                        # we know for sure the result will be nan
+                        return [S.NaN], [], None
+                continue
+
+            elif isinstance(o, AccumBounds):
+                coeff = o.__add__(coeff)
+                continue
+
+            elif isinstance(o, MatrixExpr):
+                # can't add 0 to Matrix so make sure coeff is not 0
+                extra.append(o)
+                continue
+
+            elif isinstance(o, TensExpr):
+                coeff = TensAdd(o, coeff).doit(deep=False)
+                continue
+
+            elif o is S.ComplexInfinity:
+                if coeff.is_finite is False and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                coeff = S.ComplexInfinity
+                continue
+
+            # Add([...])
+            elif o.is_Add:
+                # NB: here we assume Add is always commutative
+                o_args: tuple[Expr, ...] = o.args # type: ignore
+                seq.extend(o_args)  # TODO zerocopy?
+                continue
+
+            # Mul([...])
+            elif o.is_Mul:
+                c, s = o.as_coeff_Mul()
+
+            # check for unevaluated Pow, e.g. 2**3 or 2**(-1/2)
+            elif o.is_Pow:
+                b, e = o.as_base_exp()
+                if b.is_Number and (e.is_Integer or
+                                   (e.is_Rational and e.is_negative)):
+                    seq.append(b**e)
+                    continue
+                c, s = S.One, o
+
+            else:
+                # everything else
+                c = S.One
+                s = o
+
+            # now we have:
+            # o = c*s, where
+            #
+            # c is a Number
+            # s is an expression with number factor extracted
+            # let's collect terms with the same s, so e.g.
+            # 2*x**2 + 3*x**2  ->  5*x**2
+            if s in terms:
+                terms[s] += c
+                if terms[s] is S.NaN and not extra:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+            else:
+                terms[s] = c
+
+        # now let's construct new args:
+        # [2*x**2, x**3, 7*x**4, pi, ...]
+        newseq = []
+        noncommutative = False
+        for s, c in terms.items():
+            # 0*s
+            if c.is_zero:
+                continue
+            # 1*s
+            elif c is S.One:
+                newseq.append(s)
+            # c*s
+            else:
+                if s.is_Mul:
+                    # Mul, already keeps its arguments in perfect order.
+                    # so we can simply put c in slot0 and go the fast way.
+                    #
+                    # XXX: This breaks VectorMul unless it overrides
+                    # _new_rawargs
+                    cs = s._new_rawargs(*((c,) + s.args)) # type: ignore
+                    newseq.append(cs)
+                elif s.is_Add:
+                    # we just re-create the unevaluated Mul
+                    newseq.append(Mul(c, s, evaluate=False))
+                else:
+                    # alternatively we have to call all Mul's machinery (slow)
+                    newseq.append(Mul(c, s))
+
+            noncommutative = noncommutative or not s.is_commutative
+
+        # oo, -oo
+        if coeff is S.Infinity:
+            newseq = [f for f in newseq if not (f.is_extended_nonnegative or f.is_real)]
+
+        elif coeff is S.NegativeInfinity:
+            newseq = [f for f in newseq if not (f.is_extended_nonpositive or f.is_real)]
+
+        if coeff is S.ComplexInfinity:
+            # zoo might be
+            #   infinite_real + finite_im
+            #   finite_real + infinite_im
+            #   infinite_real + infinite_im
+            # addition of a finite real or imaginary number won't be able to
+            # change the zoo nature; adding an infinite qualtity would result
+            # in a NaN condition if it had sign opposite of the infinite
+            # portion of zoo, e.g., infinite_real - infinite_real.
+            newseq = [c for c in newseq if not (c.is_finite and
+                                                c.is_extended_real is not None)]
+
+        # process O(x)
+        if order_factors:
+            newseq2 = []
+            for t in newseq:
+                # x + O(x) -> O(x)
+                if not any(o.contains(t) for o in order_factors):
+                    newseq2.append(t)
+            newseq = newseq2 + order_factors # type: ignore
+            # 1 + O(1) -> O(1)
+            for o in order_factors:
+                if o.contains(coeff):
+                    coeff = S.Zero
+                    break
+
+        # order args canonically
+        _addsort(newseq)
+
+        # current code expects coeff to be first
+        if coeff is not S.Zero:
+            newseq.insert(0, coeff)
+
+        if extra:
+            newseq += extra
+            noncommutative = True
+
+        # we are done
+        if noncommutative:
+            return [], newseq, None
+        else:
+            return newseq, [], None
+
+    @classmethod
+    def class_key(cls):
+        return 3, 1, cls.__name__
+
+    @property
+    def kind(self):
+        k = attrgetter('kind')
+        kinds = map(k, self.args)
+        kinds = frozenset(kinds)
+        if len(kinds) != 1:
+            # Since addition is group operator, kind must be same.
+            # We know that this is unexpected signature, so return this.
+            result = UndefinedKind
+        else:
+            result, = kinds
+        return result
+
+    def could_extract_minus_sign(self):
+        return _could_extract_minus_sign(self)
+
+    @cacheit
+    def as_coeff_add(self, *deps):
+        """
+        Returns a tuple (coeff, args) where self is treated as an Add and coeff
+        is the Number term and args is a tuple of all other terms.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (7 + 3*x).as_coeff_add()
+        (7, (3*x,))
+        >>> (7*x).as_coeff_add()
+        (0, (7*x,))
+        """
+        if deps:
+            l1, l2 = sift(self.args, lambda x: x.has_free(*deps), binary=True)
+            return self._new_rawargs(*l2), tuple(l1)
+        coeff, notrat = self.args[0].as_coeff_add()
+        if coeff is not S.Zero:
+            return coeff, notrat + self.args[1:]
+        return S.Zero, self.args
+
+    def as_coeff_Add(self, rational=False, deps=None) -> tuple[Number, Expr]:
+        """
+        Efficiently extract the coefficient of a summation.
+        """
+        coeff, args = self.args[0], self.args[1:]
+
+        if coeff.is_Number and not rational or coeff.is_Rational:
+            return coeff, self._new_rawargs(*args) # type: ignore
+        return S.Zero, self
+
+    # Note, we intentionally do not implement Add.as_coeff_mul().  Rather, we
+    # let Expr.as_coeff_mul() just always return (S.One, self) for an Add.  See
+    # issue 5524.
+
+    def _eval_power(self, expt):
+        from .evalf import pure_complex
+        from .relational import is_eq
+        if len(self.args) == 2 and any(_.is_infinite for _ in self.args):
+            if expt.is_zero is False and is_eq(expt, S.One) is False:
+                # looking for literal a + I*b
+                a, b = self.args
+                if a.coeff(S.ImaginaryUnit):
+                    a, b = b, a
+                ico = b.coeff(S.ImaginaryUnit)
+                if ico and ico.is_extended_real and a.is_extended_real:
+                    if expt.is_extended_negative:
+                        return S.Zero
+                    if expt.is_extended_positive:
+                        return S.ComplexInfinity
+            return
+        if expt.is_Rational and self.is_number:
+            ri = pure_complex(self)
+            if ri:
+                r, i = ri
+                if expt.q == 2:
+                    from sympy.functions.elementary.miscellaneous import sqrt
+                    D = sqrt(r**2 + i**2)
+                    if D.is_Rational:
+                        from .exprtools import factor_terms
+                        from sympy.functions.elementary.complexes import sign
+                        from .function import expand_multinomial
+                        # (r, i, D) is a Pythagorean triple
+                        root = sqrt(factor_terms((D - r)/2))**expt.p
+                        return root*expand_multinomial((
+                            # principle value
+                            (D + r)/abs(i) + sign(i)*S.ImaginaryUnit)**expt.p)
+                elif expt == -1:
+                    return _unevaluated_Mul(
+                        r - i*S.ImaginaryUnit,
+                        1/(r**2 + i**2))
+
+    @cacheit
+    def _eval_derivative(self, s):
+        return self.func(*[a.diff(s) for a in self.args])
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        terms = [t.nseries(x, n=n, logx=logx, cdir=cdir) for t in self.args]
+        return self.func(*terms)
+
+    def _matches_simple(self, expr, repl_dict):
+        # handle (w+3).matches('x+5') -> {w: x+2}
+        coeff, terms = self.as_coeff_add()
+        if len(terms) == 1:
+            return terms[0].matches(expr - coeff, repl_dict)
+        return
+
+    def matches(self, expr, repl_dict=None, old=False):
+        return self._matches_commutative(expr, repl_dict, old)
+
+    @staticmethod
+    def _combine_inverse(lhs, rhs):
+        """
+        Returns lhs - rhs, but treats oo like a symbol so oo - oo
+        returns 0, instead of a nan.
+        """
+        from sympy.simplify.simplify import signsimp
+        inf = (S.Infinity, S.NegativeInfinity)
+        if lhs.has(*inf) or rhs.has(*inf):
+            from .symbol import Dummy
+            oo = Dummy('oo')
+            reps = {
+                S.Infinity: oo,
+                S.NegativeInfinity: -oo}
+            ireps = {v: k for k, v in reps.items()}
+            eq = lhs.xreplace(reps) - rhs.xreplace(reps)
+            if eq.has(oo):
+                eq = eq.replace(
+                    lambda x: x.is_Pow and x.base is oo,
+                    lambda x: x.base)
+            rv = eq.xreplace(ireps)
+        else:
+            rv = lhs - rhs
+        srv = signsimp(rv)
+        return srv if srv.is_Number else rv
+
+    @cacheit
+    def as_two_terms(self):
+        """Return head and tail of self.
+
+        This is the most efficient way to get the head and tail of an
+        expression.
+
+        - if you want only the head, use self.args[0];
+        - if you want to process the arguments of the tail then use
+          self.as_coef_add() which gives the head and a tuple containing
+          the arguments of the tail when treated as an Add.
+        - if you want the coefficient when self is treated as a Mul
+          then use self.as_coeff_mul()[0]
+
+        >>> from sympy.abc import x, y
+        >>> (3*x - 2*y + 5).as_two_terms()
+        (5, 3*x - 2*y)
+        """
+        return self.args[0], self._new_rawargs(*self.args[1:])
+
+    def as_numer_denom(self) -> tuple[Expr, Expr]:
+        """
+        Decomposes an expression to its numerator part and its
+        denominator part.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y, z
+        >>> (x*y/z).as_numer_denom()
+        (x*y, z)
+        >>> (x*(y + 1)/y**7).as_numer_denom()
+        (x*(y + 1), y**7)
+
+        See Also
+        ========
+
+        sympy.core.expr.Expr.as_numer_denom
+        """
+        # clear rational denominator
+        content, expr = self.primitive()
+        if not isinstance(expr, Add):
+            return Mul(content, expr, evaluate=False).as_numer_denom()
+        ncon, dcon = content.as_numer_denom()
+
+        # collect numerators and denominators of the terms
+        nd = defaultdict(list)
+        for f in expr.args:
+            ni, di = f.as_numer_denom()
+            nd[di].append(ni)
+
+        # check for quick exit
+        if len(nd) == 1:
+            d, n = nd.popitem()
+            return self.func(
+                *[_keep_coeff(ncon, ni) for ni in n]), _keep_coeff(dcon, d)
+
+        # sum up the terms having a common denominator
+        nd2 = {d: self.func(*n) if len(n) > 1 else n[0] for d, n in nd.items()}
+
+        # assemble single numerator and denominator
+        denoms, numers = [list(i) for i in zip(*iter(nd2.items()))]
+        n, d = self.func(*[Mul(*(denoms[:i] + [numers[i]] + denoms[i + 1:]))
+                   for i in range(len(numers))]), Mul(*denoms)
+
+        return _keep_coeff(ncon, n), _keep_coeff(dcon, d)
+
+    def _eval_is_polynomial(self, syms):
+        return all(term._eval_is_polynomial(syms) for term in self.args)
+
+    def _eval_is_rational_function(self, syms):
+        return all(term._eval_is_rational_function(syms) for term in self.args)
+
+    def _eval_is_meromorphic(self, x, a):
+        return _fuzzy_group((arg.is_meromorphic(x, a) for arg in self.args),
+                            quick_exit=True)
+
+    def _eval_is_algebraic_expr(self, syms):
+        return all(term._eval_is_algebraic_expr(syms) for term in self.args)
+
+    # assumption methods
+    _eval_is_real = lambda self: _fuzzy_group(
+        (a.is_real for a in self.args), quick_exit=True)
+    _eval_is_extended_real = lambda self: _fuzzy_group(
+        (a.is_extended_real for a in self.args), quick_exit=True)
+    _eval_is_complex = lambda self: _fuzzy_group(
+        (a.is_complex for a in self.args), quick_exit=True)
+    _eval_is_antihermitian = lambda self: _fuzzy_group(
+        (a.is_antihermitian for a in self.args), quick_exit=True)
+    _eval_is_finite = lambda self: _fuzzy_group(
+        (a.is_finite for a in self.args), quick_exit=True)
+    _eval_is_hermitian = lambda self: _fuzzy_group(
+        (a.is_hermitian for a in self.args), quick_exit=True)
+    _eval_is_integer = lambda self: _fuzzy_group(
+        (a.is_integer for a in self.args), quick_exit=True)
+    _eval_is_rational = lambda self: _fuzzy_group(
+        (a.is_rational for a in self.args), quick_exit=True)
+    _eval_is_algebraic = lambda self: _fuzzy_group(
+        (a.is_algebraic for a in self.args), quick_exit=True)
+    _eval_is_commutative = lambda self: _fuzzy_group(
+        a.is_commutative for a in self.args)
+
+    def _eval_is_infinite(self):
+        sawinf = False
+        for a in self.args:
+            ainf = a.is_infinite
+            if ainf is None:
+                return None
+            elif ainf is True:
+                # infinite+infinite might not be infinite
+                if sawinf is True:
+                    return None
+                sawinf = True
+        return sawinf
+
+    def _eval_is_imaginary(self):
+        nz = []
+        im_I = []
+        for a in self.args:
+            if a.is_extended_real:
+                if a.is_zero:
+                    pass
+                elif a.is_zero is False:
+                    nz.append(a)
+                else:
+                    return
+            elif a.is_imaginary:
+                im_I.append(a*S.ImaginaryUnit)
+            elif a.is_Mul and S.ImaginaryUnit in a.args:
+                coeff, ai = a.as_coeff_mul(S.ImaginaryUnit)
+                if ai == (S.ImaginaryUnit,) and coeff.is_extended_real:
+                    im_I.append(-coeff)
+                else:
+                    return
+            else:
+                return
+        b = self.func(*nz)
+        if b != self:
+            if b.is_zero:
+                return fuzzy_not(self.func(*im_I).is_zero)
+            elif b.is_zero is False:
+                return False
+
+    def _eval_is_zero(self):
+        if self.is_commutative is False:
+            # issue 10528: there is no way to know if a nc symbol
+            # is zero or not
+            return
+        nz = []
+        z = 0
+        im_or_z = False
+        im = 0
+        for a in self.args:
+            if a.is_extended_real:
+                if a.is_zero:
+                    z += 1
+                elif a.is_zero is False:
+                    nz.append(a)
+                else:
+                    return
+            elif a.is_imaginary:
+                im += 1
+            elif a.is_Mul and S.ImaginaryUnit in a.args:
+                coeff, ai = a.as_coeff_mul(S.ImaginaryUnit)
+                if ai == (S.ImaginaryUnit,) and coeff.is_extended_real:
+                    im_or_z = True
+                else:
+                    return
+            else:
+                return
+        if z == len(self.args):
+            return True
+        if len(nz) in [0, len(self.args)]:
+            return None
+        b = self.func(*nz)
+        if b.is_zero:
+            if not im_or_z:
+                if im == 0:
+                    return True
+                elif im == 1:
+                    return False
+        if b.is_zero is False:
+            return False
+
+    def _eval_is_odd(self):
+        l = [f for f in self.args if not (f.is_even is True)]
+        if not l:
+            return False
+        if l[0].is_odd:
+            return self._new_rawargs(*l[1:]).is_even
+
+    def _eval_is_irrational(self):
+        for t in self.args:
+            a = t.is_irrational
+            if a:
+                others = list(self.args)
+                others.remove(t)
+                if all(x.is_rational is True for x in others):
+                    return True
+                return None
+            if a is None:
+                return
+        return False
+
+    def _all_nonneg_or_nonppos(self):
+        nn = np = 0
+        for a in self.args:
+            if a.is_nonnegative:
+                if np:
+                    return False
+                nn = 1
+            elif a.is_nonpositive:
+                if nn:
+                    return False
+                np = 1
+            else:
+                break
+        else:
+            return True
+
+    def _eval_is_extended_positive(self):
+        if self.is_number:
+            return super()._eval_is_extended_positive()
+        c, a = self.as_coeff_Add()
+        if not c.is_zero:
+            from .exprtools import _monotonic_sign
+            v = _monotonic_sign(a)
+            if v is not None:
+                s = v + c
+                if s != self and s.is_extended_positive and a.is_extended_nonnegative:
+                    return True
+                if len(self.free_symbols) == 1:
+                    v = _monotonic_sign(self)
+                    if v is not None and v != self and v.is_extended_positive:
+                        return True
+        pos = nonneg = nonpos = unknown_sign = False
+        saw_INF = set()
+        args = [a for a in self.args if not a.is_zero]
+        if not args:
+            return False
+        for a in args:
+            ispos = a.is_extended_positive
+            infinite = a.is_infinite
+            if infinite:
+                saw_INF.add(fuzzy_or((ispos, a.is_extended_nonnegative)))
+                if True in saw_INF and False in saw_INF:
+                    return
+            if ispos:
+                pos = True
+                continue
+            elif a.is_extended_nonnegative:
+                nonneg = True
+                continue
+            elif a.is_extended_nonpositive:
+                nonpos = True
+                continue
+
+            if infinite is None:
+                return
+            unknown_sign = True
+
+        if saw_INF:
+            if len(saw_INF) > 1:
+                return
+            return saw_INF.pop()
+        elif unknown_sign:
+            return
+        elif not nonpos and not nonneg and pos:
+            return True
+        elif not nonpos and pos:
+            return True
+        elif not pos and not nonneg:
+            return False
+
+    def _eval_is_extended_nonnegative(self):
+        if not self.is_number:
+            c, a = self.as_coeff_Add()
+            if not c.is_zero and a.is_extended_nonnegative:
+                from .exprtools import _monotonic_sign
+                v = _monotonic_sign(a)
+                if v is not None:
+                    s = v + c
+                    if s != self and s.is_extended_nonnegative:
+                        return True
+                    if len(self.free_symbols) == 1:
+                        v = _monotonic_sign(self)
+                        if v is not None and v != self and v.is_extended_nonnegative:
+                            return True
+
+    def _eval_is_extended_nonpositive(self):
+        if not self.is_number:
+            c, a = self.as_coeff_Add()
+            if not c.is_zero and a.is_extended_nonpositive:
+                from .exprtools import _monotonic_sign
+                v = _monotonic_sign(a)
+                if v is not None:
+                    s = v + c
+                    if s != self and s.is_extended_nonpositive:
+                        return True
+                    if len(self.free_symbols) == 1:
+                        v = _monotonic_sign(self)
+                        if v is not None and v != self and v.is_extended_nonpositive:
+                            return True
+
+    def _eval_is_extended_negative(self):
+        if self.is_number:
+            return super()._eval_is_extended_negative()
+        c, a = self.as_coeff_Add()
+        if not c.is_zero:
+            from .exprtools import _monotonic_sign
+            v = _monotonic_sign(a)
+            if v is not None:
+                s = v + c
+                if s != self and s.is_extended_negative and a.is_extended_nonpositive:
+                    return True
+                if len(self.free_symbols) == 1:
+                    v = _monotonic_sign(self)
+                    if v is not None and v != self and v.is_extended_negative:
+                        return True
+        neg = nonpos = nonneg = unknown_sign = False
+        saw_INF = set()
+        args = [a for a in self.args if not a.is_zero]
+        if not args:
+            return False
+        for a in args:
+            isneg = a.is_extended_negative
+            infinite = a.is_infinite
+            if infinite:
+                saw_INF.add(fuzzy_or((isneg, a.is_extended_nonpositive)))
+                if True in saw_INF and False in saw_INF:
+                    return
+            if isneg:
+                neg = True
+                continue
+            elif a.is_extended_nonpositive:
+                nonpos = True
+                continue
+            elif a.is_extended_nonnegative:
+                nonneg = True
+                continue
+
+            if infinite is None:
+                return
+            unknown_sign = True
+
+        if saw_INF:
+            if len(saw_INF) > 1:
+                return
+            return saw_INF.pop()
+        elif unknown_sign:
+            return
+        elif not nonneg and not nonpos and neg:
+            return True
+        elif not nonneg and neg:
+            return True
+        elif not neg and not nonpos:
+            return False
+
+    def _eval_subs(self, old, new):
+        if not old.is_Add:
+            if old is S.Infinity and -old in self.args:
+                # foo - oo is foo + (-oo) internally
+                return self.xreplace({-old: -new})
+            return None
+
+        coeff_self, terms_self = self.as_coeff_Add()
+        coeff_old, terms_old = old.as_coeff_Add()
+
+        if coeff_self.is_Rational and coeff_old.is_Rational:
+            if terms_self == terms_old:   # (2 + a).subs( 3 + a, y) -> -1 + y
+                return self.func(new, coeff_self, -coeff_old)
+            if terms_self == -terms_old:  # (2 + a).subs(-3 - a, y) -> -1 - y
+                return self.func(-new, coeff_self, coeff_old)
+
+        if coeff_self.is_Rational and coeff_old.is_Rational \
+                or coeff_self == coeff_old:
+            args_old, args_self = self.func.make_args(
+                terms_old), self.func.make_args(terms_self)
+            if len(args_old) < len(args_self):  # (a+b+c).subs(b+c,x) -> a+x
+                self_set = set(args_self)
+                old_set = set(args_old)
+
+                if old_set < self_set:
+                    ret_set = self_set - old_set
+                    return self.func(new, coeff_self, -coeff_old,
+                               *[s._subs(old, new) for s in ret_set])
+
+                args_old = self.func.make_args(
+                    -terms_old)     # (a+b+c+d).subs(-b-c,x) -> a-x+d
+                old_set = set(args_old)
+                if old_set < self_set:
+                    ret_set = self_set - old_set
+                    return self.func(-new, coeff_self, coeff_old,
+                               *[s._subs(old, new) for s in ret_set])
+
+    def removeO(self):
+        args = [a for a in self.args if not a.is_Order]
+        return self._new_rawargs(*args)
+
+    def getO(self):
+        args = [a for a in self.args if a.is_Order]
+        if args:
+            return self._new_rawargs(*args)
+
+    @cacheit
+    def extract_leading_order(self, symbols, point=None):
+        """
+        Returns the leading term and its order.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x + 1 + 1/x**5).extract_leading_order(x)
+        ((x**(-5), O(x**(-5))),)
+        >>> (1 + x).extract_leading_order(x)
+        ((1, O(1)),)
+        >>> (x + x**2).extract_leading_order(x)
+        ((x, O(x)),)
+
+        """
+        from sympy.series.order import Order
+        lst = []
+        symbols = list(symbols if is_sequence(symbols) else [symbols])
+        if not point:
+            point = [0]*len(symbols)
+        seq = [(f, Order(f, *zip(symbols, point))) for f in self.args]
+        for ef, of in seq:
+            for e, o in lst:
+                if o.contains(of) and o != of:
+                    of = None
+                    break
+            if of is None:
+                continue
+            new_lst = [(ef, of)]
+            for e, o in lst:
+                if of.contains(o) and o != of:
+                    continue
+                new_lst.append((e, o))
+            lst = new_lst
+        return tuple(lst)
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Return a tuple representing a complex number.
+
+        Examples
+        ========
+
+        >>> from sympy import I
+        >>> (7 + 9*I).as_real_imag()
+        (7, 9)
+        >>> ((1 + I)/(1 - I)).as_real_imag()
+        (0, 1)
+        >>> ((1 + 2*I)*(1 + 3*I)).as_real_imag()
+        (-5, 5)
+        """
+        sargs = self.args
+        re_part, im_part = [], []
+        for term in sargs:
+            re, im = term.as_real_imag(deep=deep)
+            re_part.append(re)
+            im_part.append(im)
+        return (self.func(*re_part), self.func(*im_part))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.core.symbol import Dummy, Symbol
+        from sympy.series.order import Order
+        from sympy.functions.elementary.exponential import log
+        from sympy.functions.elementary.piecewise import Piecewise, piecewise_fold
+        from .function import expand_mul
+
+        o = self.getO()
+        if o is None:
+            o = Order(0)
+        old = self.removeO()
+
+        if old.has(Piecewise):
+            old = piecewise_fold(old)
+
+        # This expansion is the last part of expand_log. expand_log also calls
+        # expand_mul with factor=True, which would be more expensive
+        if any(isinstance(a, log) for a in self.args):
+            logflags = {"deep": True, "log": True, "mul": False, "power_exp": False,
+                "power_base": False, "multinomial": False, "basic": False, "force": False,
+                "factor": False}
+            old = old.expand(**logflags)
+        expr = expand_mul(old)
+
+        if not expr.is_Add:
+            return expr.as_leading_term(x, logx=logx, cdir=cdir)
+
+        infinite = [t for t in expr.args if t.is_infinite]
+
+        _logx = Dummy('logx') if logx is None else logx
+        leading_terms = [t.as_leading_term(x, logx=_logx, cdir=cdir) for t in expr.args]
+
+        min, new_expr = Order(0), S.Zero
+
+        try:
+            for term in leading_terms:
+                order = Order(term, x)
+                if not min or order not in min:
+                    min = order
+                    new_expr = term
+                elif min in order:
+                    new_expr += term
+
+        except TypeError:
+            return expr
+
+        if logx is None:
+            new_expr = new_expr.subs(_logx, log(x))
+
+        is_zero = new_expr.is_zero
+        if is_zero is None:
+            new_expr = new_expr.trigsimp().cancel()
+            is_zero = new_expr.is_zero
+        if is_zero is True:
+            # simple leading term analysis gave us cancelled terms but we have to send
+            # back a term, so compute the leading term (via series)
+            try:
+                n0 = min.getn()
+            except NotImplementedError:
+                n0 = S.One
+            if n0.has(Symbol):
+                n0 = S.One
+            res = Order(1)
+            incr = S.One
+            while res.is_Order:
+                res = old._eval_nseries(x, n=n0+incr, logx=logx, cdir=cdir).cancel().powsimp().trigsimp()
+                incr *= 2
+            return res.as_leading_term(x, logx=logx, cdir=cdir)
+
+        elif new_expr is S.NaN:
+            return old.func._from_args(infinite) + o
+
+        else:
+            return new_expr
+
+    def _eval_adjoint(self):
+        return self.func(*[t.adjoint() for t in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[t.conjugate() for t in self.args])
+
+    def _eval_transpose(self):
+        return self.func(*[t.transpose() for t in self.args])
+
+    def primitive(self):
+        """
+        Return ``(R, self/R)`` where ``R``` is the Rational GCD of ``self```.
+
+        ``R`` is collected only from the leading coefficient of each term.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+
+        >>> (2*x + 4*y).primitive()
+        (2, x + 2*y)
+
+        >>> (2*x/3 + 4*y/9).primitive()
+        (2/9, 3*x + 2*y)
+
+        >>> (2*x/3 + 4.2*y).primitive()
+        (1/3, 2*x + 12.6*y)
+
+        No subprocessing of term factors is performed:
+
+        >>> ((2 + 2*x)*x + 2).primitive()
+        (1, x*(2*x + 2) + 2)
+
+        Recursive processing can be done with the ``as_content_primitive()``
+        method:
+
+        >>> ((2 + 2*x)*x + 2).as_content_primitive()
+        (2, x*(x + 1) + 1)
+
+        See also: primitive() function in polytools.py
+
+        """
+
+        terms = []
+        inf = False
+        for a in self.args:
+            c, m = a.as_coeff_Mul()
+            if not c.is_Rational:
+                c = S.One
+                m = a
+            inf = inf or m is S.ComplexInfinity
+            terms.append((c.p, c.q, m))
+
+        if not inf:
+            ngcd = reduce(igcd, [t[0] for t in terms], 0)
+            dlcm = reduce(ilcm, [t[1] for t in terms], 1)
+        else:
+            ngcd = reduce(igcd, [t[0] for t in terms if t[1]], 0)
+            dlcm = reduce(ilcm, [t[1] for t in terms if t[1]], 1)
+
+        if ngcd == dlcm == 1:
+            return S.One, self
+        if not inf:
+            for i, (p, q, term) in enumerate(terms):
+                terms[i] = _keep_coeff(Rational((p//ngcd)*(dlcm//q)), term)
+        else:
+            for i, (p, q, term) in enumerate(terms):
+                if q:
+                    terms[i] = _keep_coeff(Rational((p//ngcd)*(dlcm//q)), term)
+                else:
+                    terms[i] = _keep_coeff(Rational(p, q), term)
+
+        # we don't need a complete re-flattening since no new terms will join
+        # so we just use the same sort as is used in Add.flatten. When the
+        # coefficient changes, the ordering of terms may change, e.g.
+        #     (3*x, 6*y) -> (2*y, x)
+        #
+        # We do need to make sure that term[0] stays in position 0, however.
+        #
+        if terms[0].is_Number or terms[0] is S.ComplexInfinity:
+            c = terms.pop(0)
+        else:
+            c = None
+        _addsort(terms)
+        if c:
+            terms.insert(0, c)
+        return Rational(ngcd, dlcm), self._new_rawargs(*terms)
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self. If radical is True (default is False) then
+        common radicals will be removed and included as a factor of the
+        primitive expression.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> (3 + 3*sqrt(2)).as_content_primitive()
+        (3, 1 + sqrt(2))
+
+        Radical content can also be factored out of the primitive:
+
+        >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
+        (2, sqrt(2)*(1 + 2*sqrt(5)))
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+        con, prim = self.func(*[_keep_coeff(*a.as_content_primitive(
+            radical=radical, clear=clear)) for a in self.args]).primitive()
+        if not clear and not con.is_Integer and prim.is_Add:
+            con, d = con.as_numer_denom()
+            _p = prim/d
+            if any(a.as_coeff_Mul()[0].is_Integer for a in _p.args):
+                prim = _p
+            else:
+                con /= d
+        if radical and prim.is_Add:
+            # look for common radicals that can be removed
+            args = prim.args
+            rads = []
+            common_q = None
+            for m in args:
+                term_rads = defaultdict(list)
+                for ai in Mul.make_args(m):
+                    if ai.is_Pow:
+                        b, e = ai.as_base_exp()
+                        if e.is_Rational and b.is_Integer:
+                            term_rads[e.q].append(abs(int(b))**e.p)
+                if not term_rads:
+                    break
+                if common_q is None:
+                    common_q = set(term_rads.keys())
+                else:
+                    common_q = common_q & set(term_rads.keys())
+                    if not common_q:
+                        break
+                rads.append(term_rads)
+            else:
+                # process rads
+                # keep only those in common_q
+                for r in rads:
+                    for q in list(r.keys()):
+                        if q not in common_q:
+                            r.pop(q)
+                    for q in r:
+                        r[q] = Mul(*r[q])
+                # find the gcd of bases for each q
+                G = []
+                for q in common_q:
+                    g = reduce(igcd, [r[q] for r in rads], 0)
+                    if g != 1:
+                        G.append(g**Rational(1, q))
+                if G:
+                    G = Mul(*G)
+                    args = [ai/G for ai in args]
+                    prim = G*prim.func(*args)
+
+        return con, prim
+
+    @property
+    def _sorted_args(self):
+        from .sorting import default_sort_key
+        return tuple(sorted(self.args, key=default_sort_key))
+
+    def _eval_difference_delta(self, n, step):
+        from sympy.series.limitseq import difference_delta as dd
+        return self.func(*[dd(a, n, step) for a in self.args])
+
+    @property
+    def _mpc_(self):
+        """
+        Convert self to an mpmath mpc if possible
+        """
+        from .numbers import Float
+        re_part, rest = self.as_coeff_Add()
+        im_part, imag_unit = rest.as_coeff_Mul()
+        if not imag_unit == S.ImaginaryUnit:
+            # ValueError may seem more reasonable but since it's a @property,
+            # we need to use AttributeError to keep from confusing things like
+            # hasattr.
+            raise AttributeError("Cannot convert Add to mpc. Must be of the form Number + Number*I")
+
+        return (Float(re_part)._mpf_, Float(im_part)._mpf_)
+
+    def __neg__(self):
+        if not global_parameters.distribute:
+            return super().__neg__()
+        return Mul(S.NegativeOne, self)
+
+add = AssocOpDispatcher('add')
+
+from .mul import Mul, _keep_coeff, _unevaluated_Mul
+from .numbers import Rational
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/alphabets.py b/.venv/lib/python3.12/site-packages/sympy/core/alphabets.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ea2ae1c410ccd30e7ec9551f4cd8b19a36cdba1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/alphabets.py
@@ -0,0 +1,4 @@
+greeks = ('alpha', 'beta', 'gamma', 'delta', 'epsilon', 'zeta',
+                    'eta', 'theta', 'iota', 'kappa', 'lambda', 'mu', 'nu',
+                    'xi', 'omicron', 'pi', 'rho', 'sigma', 'tau', 'upsilon',
+                    'phi', 'chi', 'psi', 'omega')
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/assumptions.py b/.venv/lib/python3.12/site-packages/sympy/core/assumptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..677e86c5e39390b0b188a5158dd2fabfbac4c760
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/assumptions.py
@@ -0,0 +1,692 @@
+"""
+This module contains the machinery handling assumptions.
+Do also consider the guide :ref:`assumptions-guide`.
+
+All symbolic objects have assumption attributes that can be accessed via
+``.is_`` attribute.
+
+Assumptions determine certain properties of symbolic objects and can
+have 3 possible values: ``True``, ``False``, ``None``.  ``True`` is returned if the
+object has the property and ``False`` is returned if it does not or cannot
+(i.e. does not make sense):
+
+    >>> from sympy import I
+    >>> I.is_algebraic
+    True
+    >>> I.is_real
+    False
+    >>> I.is_prime
+    False
+
+When the property cannot be determined (or when a method is not
+implemented) ``None`` will be returned. For example,  a generic symbol, ``x``,
+may or may not be positive so a value of ``None`` is returned for ``x.is_positive``.
+
+By default, all symbolic values are in the largest set in the given context
+without specifying the property. For example, a symbol that has a property
+being integer, is also real, complex, etc.
+
+Here follows a list of possible assumption names:
+
+.. glossary::
+
+    commutative
+        object commutes with any other object with
+        respect to multiplication operation. See [12]_.
+
+    complex
+        object can have only values from the set
+        of complex numbers. See [13]_.
+
+    imaginary
+        object value is a number that can be written as a real
+        number multiplied by the imaginary unit ``I``.  See
+        [3]_.  Please note that ``0`` is not considered to be an
+        imaginary number, see
+        `issue #7649 `_.
+
+    real
+        object can have only values from the set
+        of real numbers.
+
+    extended_real
+        object can have only values from the set
+        of real numbers, ``oo`` and ``-oo``.
+
+    integer
+        object can have only values from the set
+        of integers.
+
+    odd
+    even
+        object can have only values from the set of
+        odd (even) integers [2]_.
+
+    prime
+        object is a natural number greater than 1 that has
+        no positive divisors other than 1 and itself.  See [6]_.
+
+    composite
+        object is a positive integer that has at least one positive
+        divisor other than 1 or the number itself.  See [4]_.
+
+    zero
+        object has the value of 0.
+
+    nonzero
+        object is a real number that is not zero.
+
+    rational
+        object can have only values from the set
+        of rationals.
+
+    algebraic
+        object can have only values from the set
+        of algebraic numbers [11]_.
+
+    transcendental
+        object can have only values from the set
+        of transcendental numbers [10]_.
+
+    irrational
+        object value cannot be represented exactly by :class:`~.Rational`, see [5]_.
+
+    finite
+    infinite
+        object absolute value is bounded (arbitrarily large).
+        See [7]_, [8]_, [9]_.
+
+    negative
+    nonnegative
+        object can have only negative (nonnegative)
+        values [1]_.
+
+    positive
+    nonpositive
+        object can have only positive (nonpositive) values.
+
+    extended_negative
+    extended_nonnegative
+    extended_positive
+    extended_nonpositive
+    extended_nonzero
+        as without the extended part, but also including infinity with
+        corresponding sign, e.g., extended_positive includes ``oo``
+
+    hermitian
+    antihermitian
+        object belongs to the field of Hermitian
+        (antihermitian) operators.
+
+Examples
+========
+
+    >>> from sympy import Symbol
+    >>> x = Symbol('x', real=True); x
+    x
+    >>> x.is_real
+    True
+    >>> x.is_complex
+    True
+
+See Also
+========
+
+.. seealso::
+
+    :py:class:`sympy.core.numbers.ImaginaryUnit`
+    :py:class:`sympy.core.numbers.Zero`
+    :py:class:`sympy.core.numbers.One`
+    :py:class:`sympy.core.numbers.Infinity`
+    :py:class:`sympy.core.numbers.NegativeInfinity`
+    :py:class:`sympy.core.numbers.ComplexInfinity`
+
+Notes
+=====
+
+The fully-resolved assumptions for any SymPy expression
+can be obtained as follows:
+
+    >>> from sympy.core.assumptions import assumptions
+    >>> x = Symbol('x',positive=True)
+    >>> assumptions(x + I)
+    {'commutative': True, 'complex': True, 'composite': False, 'even':
+    False, 'extended_negative': False, 'extended_nonnegative': False,
+    'extended_nonpositive': False, 'extended_nonzero': False,
+    'extended_positive': False, 'extended_real': False, 'finite': True,
+    'imaginary': False, 'infinite': False, 'integer': False, 'irrational':
+    False, 'negative': False, 'noninteger': False, 'nonnegative': False,
+    'nonpositive': False, 'nonzero': False, 'odd': False, 'positive':
+    False, 'prime': False, 'rational': False, 'real': False, 'zero':
+    False}
+
+Developers Notes
+================
+
+The current (and possibly incomplete) values are stored
+in the ``obj._assumptions dictionary``; queries to getter methods
+(with property decorators) or attributes of objects/classes
+will return values and update the dictionary.
+
+    >>> eq = x**2 + I
+    >>> eq._assumptions
+    {}
+    >>> eq.is_finite
+    True
+    >>> eq._assumptions
+    {'finite': True, 'infinite': False}
+
+For a :class:`~.Symbol`, there are two locations for assumptions that may
+be of interest. The ``assumptions0`` attribute gives the full set of
+assumptions derived from a given set of initial assumptions. The
+latter assumptions are stored as ``Symbol._assumptions_orig``
+
+    >>> Symbol('x', prime=True, even=True)._assumptions_orig
+    {'even': True, 'prime': True}
+
+The ``_assumptions_orig`` are not necessarily canonical nor are they filtered
+in any way: they records the assumptions used to instantiate a Symbol and (for
+storage purposes) represent a more compact representation of the assumptions
+needed to recreate the full set in ``Symbol.assumptions0``.
+
+
+References
+==========
+
+.. [1] https://en.wikipedia.org/wiki/Negative_number
+.. [2] https://en.wikipedia.org/wiki/Parity_%28mathematics%29
+.. [3] https://en.wikipedia.org/wiki/Imaginary_number
+.. [4] https://en.wikipedia.org/wiki/Composite_number
+.. [5] https://en.wikipedia.org/wiki/Irrational_number
+.. [6] https://en.wikipedia.org/wiki/Prime_number
+.. [7] https://en.wikipedia.org/wiki/Finite
+.. [8] https://docs.python.org/3/library/math.html#math.isfinite
+.. [9] https://numpy.org/doc/stable/reference/generated/numpy.isfinite.html
+.. [10] https://en.wikipedia.org/wiki/Transcendental_number
+.. [11] https://en.wikipedia.org/wiki/Algebraic_number
+.. [12] https://en.wikipedia.org/wiki/Commutative_property
+.. [13] https://en.wikipedia.org/wiki/Complex_number
+
+"""
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from .facts import FactRules, FactKB
+from .sympify import sympify
+
+from sympy.core.random import _assumptions_shuffle as shuffle
+from sympy.core.assumptions_generated import generated_assumptions as _assumptions
+
+def _load_pre_generated_assumption_rules() -> FactRules:
+    """ Load the assumption rules from pre-generated data
+
+    To update the pre-generated data, see :method::`_generate_assumption_rules`
+    """
+    _assume_rules=FactRules._from_python(_assumptions)
+    return _assume_rules
+
+def _generate_assumption_rules():
+    """ Generate the default assumption rules
+
+    This method should only be called to update the pre-generated
+    assumption rules.
+
+    To update the pre-generated assumptions run: bin/ask_update.py
+
+    """
+    _assume_rules = FactRules([
+
+    'integer        ->  rational',
+    'rational       ->  real',
+    'rational       ->  algebraic',
+    'algebraic      ->  complex',
+    'transcendental ==  complex & !algebraic',
+    'real           ->  hermitian',
+    'imaginary      ->  complex',
+    'imaginary      ->  antihermitian',
+    'extended_real  ->  commutative',
+    'complex        ->  commutative',
+    'complex        ->  finite',
+
+    'odd            ==  integer & !even',
+    'even           ==  integer & !odd',
+
+    'real           ->  complex',
+    'extended_real  ->  real | infinite',
+    'real           ==  extended_real & finite',
+
+    'extended_real        ==  extended_negative | zero | extended_positive',
+    'extended_negative    ==  extended_nonpositive & extended_nonzero',
+    'extended_positive    ==  extended_nonnegative & extended_nonzero',
+
+    'extended_nonpositive ==  extended_real & !extended_positive',
+    'extended_nonnegative ==  extended_real & !extended_negative',
+
+    'real           ==  negative | zero | positive',
+    'negative       ==  nonpositive & nonzero',
+    'positive       ==  nonnegative & nonzero',
+
+    'nonpositive    ==  real & !positive',
+    'nonnegative    ==  real & !negative',
+
+    'positive       ==  extended_positive & finite',
+    'negative       ==  extended_negative & finite',
+    'nonpositive    ==  extended_nonpositive & finite',
+    'nonnegative    ==  extended_nonnegative & finite',
+    'nonzero        ==  extended_nonzero & finite',
+
+    'zero           ->  even & finite',
+    'zero           ==  extended_nonnegative & extended_nonpositive',
+    'zero           ==  nonnegative & nonpositive',
+    'nonzero        ->  real',
+
+    'prime          ->  integer & positive',
+    'composite      ->  integer & positive & !prime',
+    '!composite     ->  !positive | !even | prime',
+
+    'irrational     ==  real & !rational',
+
+    'imaginary      ->  !extended_real',
+
+    'infinite       ==  !finite',
+    'noninteger     ==  extended_real & !integer',
+    'extended_nonzero == extended_real & !zero',
+    ])
+    return _assume_rules
+
+
+_assume_rules = _load_pre_generated_assumption_rules()
+_assume_defined = _assume_rules.defined_facts.copy()
+_assume_defined.add('polar')
+_assume_defined = frozenset(_assume_defined)
+
+
+def assumptions(expr, _check=None):
+    """return the T/F assumptions of ``expr``"""
+    n = sympify(expr)
+    if n.is_Symbol:
+        rv = n.assumptions0  # are any important ones missing?
+        if _check is not None:
+            rv = {k: rv[k] for k in set(rv) & set(_check)}
+        return rv
+    rv = {}
+    for k in _assume_defined if _check is None else _check:
+        v = getattr(n, 'is_{}'.format(k))
+        if v is not None:
+            rv[k] = v
+    return rv
+
+
+def common_assumptions(exprs, check=None):
+    """return those assumptions which have the same True or False
+    value for all the given expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.core import common_assumptions
+    >>> from sympy import oo, pi, sqrt
+    >>> common_assumptions([-4, 0, sqrt(2), 2, pi, oo])
+    {'commutative': True, 'composite': False,
+    'extended_real': True, 'imaginary': False, 'odd': False}
+
+    By default, all assumptions are tested; pass an iterable of the
+    assumptions to limit those that are reported:
+
+    >>> common_assumptions([0, 1, 2], ['positive', 'integer'])
+    {'integer': True}
+    """
+    check = _assume_defined if check is None else set(check)
+    if not check or not exprs:
+        return {}
+
+    # get all assumptions for each
+    assume = [assumptions(i, _check=check) for i in sympify(exprs)]
+    # focus on those of interest that are True
+    for i, e in enumerate(assume):
+        assume[i] = {k: e[k] for k in set(e) & check}
+    # what assumptions are in common?
+    common = set.intersection(*[set(i) for i in assume])
+    # which ones hold the same value
+    a = assume[0]
+    return {k: a[k] for k in common if all(a[k] == b[k]
+        for b in assume)}
+
+
+def failing_assumptions(expr, **assumptions):
+    """
+    Return a dictionary containing assumptions with values not
+    matching those of the passed assumptions.
+
+    Examples
+    ========
+
+    >>> from sympy import failing_assumptions, Symbol
+
+    >>> x = Symbol('x', positive=True)
+    >>> y = Symbol('y')
+    >>> failing_assumptions(6*x + y, positive=True)
+    {'positive': None}
+
+    >>> failing_assumptions(x**2 - 1, positive=True)
+    {'positive': None}
+
+    If *expr* satisfies all of the assumptions, an empty dictionary is returned.
+
+    >>> failing_assumptions(x**2, positive=True)
+    {}
+
+    """
+    expr = sympify(expr)
+    failed = {}
+    for k in assumptions:
+        test = getattr(expr, 'is_%s' % k, None)
+        if test is not assumptions[k]:
+            failed[k] = test
+    return failed  # {} or {assumption: value != desired}
+
+
+def check_assumptions(expr, against=None, **assume):
+    """
+    Checks whether assumptions of ``expr`` match the T/F assumptions
+    given (or possessed by ``against``). True is returned if all
+    assumptions match; False is returned if there is a mismatch and
+    the assumption in ``expr`` is not None; else None is returned.
+
+    Explanation
+    ===========
+
+    *assume* is a dict of assumptions with True or False values
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, pi, I, exp, check_assumptions
+    >>> check_assumptions(-5, integer=True)
+    True
+    >>> check_assumptions(pi, real=True, integer=False)
+    True
+    >>> check_assumptions(pi, negative=True)
+    False
+    >>> check_assumptions(exp(I*pi/7), real=False)
+    True
+    >>> x = Symbol('x', positive=True)
+    >>> check_assumptions(2*x + 1, positive=True)
+    True
+    >>> check_assumptions(-2*x - 5, positive=True)
+    False
+
+    To check assumptions of *expr* against another variable or expression,
+    pass the expression or variable as ``against``.
+
+    >>> check_assumptions(2*x + 1, x)
+    True
+
+    To see if a number matches the assumptions of an expression, pass
+    the number as the first argument, else its specific assumptions
+    may not have a non-None value in the expression:
+
+    >>> check_assumptions(x, 3)
+    >>> check_assumptions(3, x)
+    True
+
+    ``None`` is returned if ``check_assumptions()`` could not conclude.
+
+    >>> check_assumptions(2*x - 1, x)
+
+    >>> z = Symbol('z')
+    >>> check_assumptions(z, real=True)
+
+    See Also
+    ========
+
+    failing_assumptions
+
+    """
+    expr = sympify(expr)
+    if against is not None:
+        if assume:
+            raise ValueError(
+                'Expecting `against` or `assume`, not both.')
+        assume = assumptions(against)
+    known = True
+    for k, v in assume.items():
+        if v is None:
+            continue
+        e = getattr(expr, 'is_' + k, None)
+        if e is None:
+            known = None
+        elif v != e:
+            return False
+    return known
+
+
+class StdFactKB(FactKB):
+    """A FactKB specialized for the built-in rules
+
+    This is the only kind of FactKB that Basic objects should use.
+    """
+    def __init__(self, facts=None):
+        super().__init__(_assume_rules)
+        # save a copy of the facts dict
+        if not facts:
+            self._generator = {}
+        elif not isinstance(facts, FactKB):
+            self._generator = facts.copy()
+        else:
+            self._generator = facts.generator
+        if facts:
+            self.deduce_all_facts(facts)
+
+    def copy(self):
+        return self.__class__(self)
+
+    @property
+    def generator(self):
+        return self._generator.copy()
+
+
+def as_property(fact):
+    """Convert a fact name to the name of the corresponding property"""
+    return 'is_%s' % fact
+
+
+def make_property(fact):
+    """Create the automagic property corresponding to a fact."""
+
+    def getit(self):
+        try:
+            return self._assumptions[fact]
+        except KeyError:
+            if self._assumptions is self.default_assumptions:
+                self._assumptions = self.default_assumptions.copy()
+            return _ask(fact, self)
+
+    getit.func_name = as_property(fact)
+    return property(getit)
+
+
+def _ask(fact, obj):
+    """
+    Find the truth value for a property of an object.
+
+    This function is called when a request is made to see what a fact
+    value is.
+
+    For this we use several techniques:
+
+    First, the fact-evaluation function is tried, if it exists (for
+    example _eval_is_integer). Then we try related facts. For example
+
+        rational   -->   integer
+
+    another example is joined rule:
+
+        integer & !odd  --> even
+
+    so in the latter case if we are looking at what 'even' value is,
+    'integer' and 'odd' facts will be asked.
+
+    In all cases, when we settle on some fact value, its implications are
+    deduced, and the result is cached in ._assumptions.
+    """
+    # FactKB which is dict-like and maps facts to their known values:
+    assumptions = obj._assumptions
+
+    # A dict that maps facts to their handlers:
+    handler_map = obj._prop_handler
+
+    # This is our queue of facts to check:
+    facts_to_check = [fact]
+    facts_queued = {fact}
+
+    # Loop over the queue as it extends
+    for fact_i in facts_to_check:
+
+        # If fact_i has already been determined then we don't need to rerun the
+        # handler. There is a potential race condition for multithreaded code
+        # though because it's possible that fact_i was checked in another
+        # thread. The main logic of the loop below would potentially skip
+        # checking assumptions[fact] in this case so we check it once after the
+        # loop to be sure.
+        if fact_i in assumptions:
+            continue
+
+        # Now we call the associated handler for fact_i if it exists.
+        fact_i_value = None
+        handler_i = handler_map.get(fact_i)
+        if handler_i is not None:
+            fact_i_value = handler_i(obj)
+
+        # If we get a new value for fact_i then we should update our knowledge
+        # of fact_i as well as any related facts that can be inferred using the
+        # inference rules connecting the fact_i and any other fact values that
+        # are already known.
+        if fact_i_value is not None:
+            assumptions.deduce_all_facts(((fact_i, fact_i_value),))
+
+        # Usually if assumptions[fact] is now not None then that is because of
+        # the call to deduce_all_facts above. The handler for fact_i returned
+        # True or False and knowing fact_i (which is equal to fact in the first
+        # iteration) implies knowing a value for fact. It is also possible
+        # though that independent code e.g. called indirectly by the handler or
+        # called in another thread in a multithreaded context might have
+        # resulted in assumptions[fact] being set. Either way we return it.
+        fact_value = assumptions.get(fact)
+        if fact_value is not None:
+            return fact_value
+
+        # Extend the queue with other facts that might determine fact_i. Here
+        # we randomise the order of the facts that are checked. This should not
+        # lead to any non-determinism if all handlers are logically consistent
+        # with the inference rules for the facts. Non-deterministic assumptions
+        # queries can result from bugs in the handlers that are exposed by this
+        # call to shuffle. These are pushed to the back of the queue meaning
+        # that the inference graph is traversed in breadth-first order.
+        new_facts_to_check = list(_assume_rules.prereq[fact_i] - facts_queued)
+        shuffle(new_facts_to_check)
+        facts_to_check.extend(new_facts_to_check)
+        facts_queued.update(new_facts_to_check)
+
+    # The above loop should be able to handle everything fine in a
+    # single-threaded context but in multithreaded code it is possible that
+    # this thread skipped computing a particular fact that was computed in
+    # another thread (due to the continue). In that case it is possible that
+    # fact was inferred and is now stored in the assumptions dict but it wasn't
+    # checked for in the body of the loop. This is an obscure case but to make
+    # sure we catch it we check once here at the end of the loop.
+    if fact in assumptions:
+        return assumptions[fact]
+
+    # This query can not be answered. It's possible that e.g. another thread
+    # has already stored None for fact but assumptions._tell does not mind if
+    # we call _tell twice setting the same value. If this raises
+    # InconsistentAssumptions then it probably means that another thread
+    # attempted to compute this and got a value of True or False rather than
+    # None. In that case there must be a bug in at least one of the handlers.
+    # If the handlers are all deterministic and are consistent with the
+    # inference rules then the same value should be computed for fact in all
+    # threads.
+    assumptions._tell(fact, None)
+    return None
+
+
+def _prepare_class_assumptions(cls):
+    """Precompute class level assumptions and generate handlers.
+
+    This is called by Basic.__init_subclass__ each time a Basic subclass is
+    defined.
+    """
+
+    local_defs = {}
+    for k in _assume_defined:
+        attrname = as_property(k)
+        v = cls.__dict__.get(attrname, '')
+        if isinstance(v, (bool, int, type(None))):
+            if v is not None:
+                v = bool(v)
+            local_defs[k] = v
+
+    defs = {}
+    for base in reversed(cls.__bases__):
+        assumptions = getattr(base, '_explicit_class_assumptions', None)
+        if assumptions is not None:
+            defs.update(assumptions)
+    defs.update(local_defs)
+
+    cls._explicit_class_assumptions = defs
+    cls.default_assumptions = StdFactKB(defs)
+
+    cls._prop_handler = {}
+    for k in _assume_defined:
+        eval_is_meth = getattr(cls, '_eval_is_%s' % k, None)
+        if eval_is_meth is not None:
+            cls._prop_handler[k] = eval_is_meth
+
+    # Put definite results directly into the class dict, for speed
+    for k, v in cls.default_assumptions.items():
+        setattr(cls, as_property(k), v)
+
+    # protection e.g. for Integer.is_even=F <- (Rational.is_integer=F)
+    derived_from_bases = set()
+    for base in cls.__bases__:
+        default_assumptions = getattr(base, 'default_assumptions', None)
+        # is an assumption-aware class
+        if default_assumptions is not None:
+            derived_from_bases.update(default_assumptions)
+
+    for fact in derived_from_bases - set(cls.default_assumptions):
+        pname = as_property(fact)
+        if pname not in cls.__dict__:
+            setattr(cls, pname, make_property(fact))
+
+    # Finally, add any missing automagic property (e.g. for Basic)
+    for fact in _assume_defined:
+        pname = as_property(fact)
+        if not hasattr(cls, pname):
+            setattr(cls, pname, make_property(fact))
+
+
+# XXX: ManagedProperties used to be the metaclass for Basic but now Basic does
+# not use a metaclass. We leave this here for backwards compatibility for now
+# in case someone has been using the ManagedProperties class in downstream
+# code. The reason that it might have been used is that when subclassing a
+# class and wanting to use a metaclass the metaclass must be a subclass of the
+# metaclass for the class that is being subclassed. Anyone wanting to subclass
+# Basic and use a metaclass in their subclass would have needed to subclass
+# ManagedProperties. Here ManagedProperties is not the metaclass for Basic any
+# more but it should still be usable as a metaclass for Basic subclasses since
+# it is a subclass of type which is now the metaclass for Basic.
+class ManagedProperties(type):
+    def __init__(cls, *args, **kwargs):
+        msg = ("The ManagedProperties metaclass. "
+               "Basic does not use metaclasses any more")
+        sympy_deprecation_warning(msg,
+            deprecated_since_version="1.12",
+            active_deprecations_target='managedproperties')
+
+        # Here we still call this function in case someone is using
+        # ManagedProperties for something that is not a Basic subclass. For
+        # Basic subclasses this function is now called by __init_subclass__ and
+        # so this metaclass is not needed any more.
+        _prepare_class_assumptions(cls)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/assumptions_generated.py b/.venv/lib/python3.12/site-packages/sympy/core/assumptions_generated.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4b2597a72b500155370db385b58e61f0f951984
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/assumptions_generated.py
@@ -0,0 +1,1615 @@
+"""
+Do NOT manually edit this file.
+Instead, run ./bin/ask_update.py.
+"""
+
+defined_facts = [
+    'algebraic',
+    'antihermitian',
+    'commutative',
+    'complex',
+    'composite',
+    'even',
+    'extended_negative',
+    'extended_nonnegative',
+    'extended_nonpositive',
+    'extended_nonzero',
+    'extended_positive',
+    'extended_real',
+    'finite',
+    'hermitian',
+    'imaginary',
+    'infinite',
+    'integer',
+    'irrational',
+    'negative',
+    'noninteger',
+    'nonnegative',
+    'nonpositive',
+    'nonzero',
+    'odd',
+    'positive',
+    'prime',
+    'rational',
+    'real',
+    'transcendental',
+    'zero',
+] # defined_facts
+
+
+full_implications = dict( [
+    # Implications of algebraic = True:
+    (('algebraic', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('finite', True),
+        ('infinite', False),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of algebraic = False:
+    (('algebraic', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of antihermitian = True:
+    (('antihermitian', True), set( (
+       ) ),
+     ),
+    # Implications of antihermitian = False:
+    (('antihermitian', False), set( (
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of commutative = True:
+    (('commutative', True), set( (
+       ) ),
+     ),
+    # Implications of commutative = False:
+    (('commutative', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of complex = True:
+    (('complex', True), set( (
+        ('commutative', True),
+        ('finite', True),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of complex = False:
+    (('complex', False), set( (
+        ('algebraic', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = True:
+    (('composite', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of composite = False:
+    (('composite', False), set( (
+       ) ),
+     ),
+    # Implications of even = True:
+    (('even', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('odd', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of even = False:
+    (('even', False), set( (
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = True:
+    (('extended_negative', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_negative = False:
+    (('extended_negative', False), set( (
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = True:
+    (('extended_nonnegative', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+       ) ),
+     ),
+    # Implications of extended_nonnegative = False:
+    (('extended_nonnegative', False), set( (
+        ('composite', False),
+        ('extended_positive', False),
+        ('nonnegative', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = True:
+    (('extended_nonpositive', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_nonpositive = False:
+    (('extended_nonpositive', False), set( (
+        ('extended_negative', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = True:
+    (('extended_nonzero', True), set( (
+        ('commutative', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_nonzero = False:
+    (('extended_nonzero', False), set( (
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_positive', False),
+        ('negative', False),
+        ('nonzero', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_positive = True:
+    (('extended_positive', True), set( (
+        ('commutative', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('negative', False),
+        ('nonpositive', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of extended_positive = False:
+    (('extended_positive', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of extended_real = True:
+    (('extended_real', True), set( (
+        ('commutative', True),
+        ('imaginary', False),
+       ) ),
+     ),
+    # Implications of extended_real = False:
+    (('extended_real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of finite = True:
+    (('finite', True), set( (
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of finite = False:
+    (('finite', False), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('imaginary', False),
+        ('infinite', True),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of hermitian = True:
+    (('hermitian', True), set( (
+       ) ),
+     ),
+    # Implications of hermitian = False:
+    (('hermitian', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = True:
+    (('imaginary', True), set( (
+        ('antihermitian', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', False),
+        ('finite', True),
+        ('infinite', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of imaginary = False:
+    (('imaginary', False), set( (
+       ) ),
+     ),
+    # Implications of infinite = True:
+    (('infinite', True), set( (
+        ('algebraic', False),
+        ('complex', False),
+        ('composite', False),
+        ('even', False),
+        ('finite', False),
+        ('imaginary', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', False),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of infinite = False:
+    (('infinite', False), set( (
+        ('finite', True),
+       ) ),
+     ),
+    # Implications of integer = True:
+    (('integer', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('noninteger', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of integer = False:
+    (('integer', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = True:
+    (('irrational', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', False),
+        ('noninteger', True),
+        ('nonzero', True),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of irrational = False:
+    (('irrational', False), set( (
+       ) ),
+     ),
+    # Implications of negative = True:
+    (('negative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', True),
+        ('extended_nonnegative', False),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('nonnegative', False),
+        ('nonpositive', True),
+        ('nonzero', True),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of negative = False:
+    (('negative', False), set( (
+       ) ),
+     ),
+    # Implications of noninteger = True:
+    (('noninteger', True), set( (
+        ('commutative', True),
+        ('composite', False),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('imaginary', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of noninteger = False:
+    (('noninteger', False), set( (
+       ) ),
+     ),
+    # Implications of nonnegative = True:
+    (('nonnegative', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonnegative = False:
+    (('nonnegative', False), set( (
+        ('composite', False),
+        ('positive', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonpositive = True:
+    (('nonpositive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_nonpositive', True),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('positive', False),
+        ('prime', False),
+        ('real', True),
+       ) ),
+     ),
+    # Implications of nonpositive = False:
+    (('nonpositive', False), set( (
+        ('negative', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = True:
+    (('nonzero', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of nonzero = False:
+    (('nonzero', False), set( (
+        ('composite', False),
+        ('negative', False),
+        ('positive', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of odd = True:
+    (('odd', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('even', False),
+        ('extended_nonzero', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('noninteger', False),
+        ('nonzero', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of odd = False:
+    (('odd', False), set( (
+       ) ),
+     ),
+    # Implications of positive = True:
+    (('positive', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('negative', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('real', True),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of positive = False:
+    (('positive', False), set( (
+        ('composite', False),
+        ('prime', False),
+       ) ),
+     ),
+    # Implications of prime = True:
+    (('prime', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', False),
+        ('extended_nonzero', True),
+        ('extended_positive', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', False),
+        ('nonzero', True),
+        ('positive', True),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of prime = False:
+    (('prime', False), set( (
+       ) ),
+     ),
+    # Implications of rational = True:
+    (('rational', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('irrational', False),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of rational = False:
+    (('rational', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of real = True:
+    (('real', True), set( (
+        ('commutative', True),
+        ('complex', True),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+       ) ),
+     ),
+    # Implications of real = False:
+    (('real', False), set( (
+        ('composite', False),
+        ('even', False),
+        ('integer', False),
+        ('irrational', False),
+        ('negative', False),
+        ('nonnegative', False),
+        ('nonpositive', False),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = True:
+    (('transcendental', True), set( (
+        ('algebraic', False),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', False),
+        ('finite', True),
+        ('infinite', False),
+        ('integer', False),
+        ('odd', False),
+        ('prime', False),
+        ('rational', False),
+        ('zero', False),
+       ) ),
+     ),
+    # Implications of transcendental = False:
+    (('transcendental', False), set( (
+       ) ),
+     ),
+    # Implications of zero = True:
+    (('zero', True), set( (
+        ('algebraic', True),
+        ('commutative', True),
+        ('complex', True),
+        ('composite', False),
+        ('even', True),
+        ('extended_negative', False),
+        ('extended_nonnegative', True),
+        ('extended_nonpositive', True),
+        ('extended_nonzero', False),
+        ('extended_positive', False),
+        ('extended_real', True),
+        ('finite', True),
+        ('hermitian', True),
+        ('imaginary', False),
+        ('infinite', False),
+        ('integer', True),
+        ('irrational', False),
+        ('negative', False),
+        ('noninteger', False),
+        ('nonnegative', True),
+        ('nonpositive', True),
+        ('nonzero', False),
+        ('odd', False),
+        ('positive', False),
+        ('prime', False),
+        ('rational', True),
+        ('real', True),
+        ('transcendental', False),
+       ) ),
+     ),
+    # Implications of zero = False:
+    (('zero', False), set( (
+       ) ),
+     ),
+ ] ) # full_implications
+
+
+prereq = {
+
+    # facts that could determine the value of algebraic
+    'algebraic': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of antihermitian
+    'antihermitian': {
+        'imaginary',
+    },
+
+    # facts that could determine the value of commutative
+    'commutative': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of complex
+    'complex': {
+        'algebraic',
+        'commutative',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of composite
+    'composite': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of even
+    'even': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'odd',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_negative
+    'extended_negative': {
+        'commutative',
+        'composite',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonnegative
+    'extended_nonnegative': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonnegative',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonpositive
+    'extended_nonpositive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_nonzero
+    'extended_nonzero': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_positive',
+        'extended_real',
+        'imaginary',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_positive
+    'extended_positive': {
+        'commutative',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_real',
+        'imaginary',
+        'negative',
+        'nonpositive',
+        'positive',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of extended_real
+    'extended_real': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of finite
+    'finite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of hermitian
+    'hermitian': {
+        'composite',
+        'even',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of imaginary
+    'imaginary': {
+        'antihermitian',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of infinite
+    'infinite': {
+        'algebraic',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'imaginary',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of integer
+    'integer': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'noninteger',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of irrational
+    'irrational': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of negative
+    'negative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of noninteger
+    'noninteger': {
+        'commutative',
+        'composite',
+        'even',
+        'extended_real',
+        'imaginary',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'zero',
+    },
+
+    # facts that could determine the value of nonnegative
+    'nonnegative': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonpositive
+    'nonpositive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonpositive',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of nonzero
+    'nonzero': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_nonzero',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'irrational',
+        'negative',
+        'odd',
+        'positive',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of odd
+    'odd': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'noninteger',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of positive
+    'positive': {
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'prime',
+        'real',
+        'zero',
+    },
+
+    # facts that could determine the value of prime
+    'prime': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'positive',
+        'rational',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of rational
+    'rational': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'odd',
+        'prime',
+        'real',
+        'transcendental',
+        'zero',
+    },
+
+    # facts that could determine the value of real
+    'real': {
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of transcendental
+    'transcendental': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'finite',
+        'infinite',
+        'integer',
+        'odd',
+        'prime',
+        'rational',
+        'zero',
+    },
+
+    # facts that could determine the value of zero
+    'zero': {
+        'algebraic',
+        'commutative',
+        'complex',
+        'composite',
+        'even',
+        'extended_negative',
+        'extended_nonnegative',
+        'extended_nonpositive',
+        'extended_nonzero',
+        'extended_positive',
+        'extended_real',
+        'finite',
+        'hermitian',
+        'imaginary',
+        'infinite',
+        'integer',
+        'irrational',
+        'negative',
+        'noninteger',
+        'nonnegative',
+        'nonpositive',
+        'nonzero',
+        'odd',
+        'positive',
+        'prime',
+        'rational',
+        'real',
+        'transcendental',
+    },
+
+} # prereq
+
+
+# Note: the order of the beta rules is used in the beta_triggers
+beta_rules = [
+
+    # Rules implying composite = True
+    ({('even', True), ('positive', True), ('prime', False)},
+        ('composite', True)),
+
+    # Rules implying even = False
+    ({('composite', False), ('positive', True), ('prime', False)},
+        ('even', False)),
+
+    # Rules implying even = True
+    ({('integer', True), ('odd', False)},
+        ('even', True)),
+
+    # Rules implying extended_negative = True
+    ({('extended_positive', False), ('extended_real', True), ('zero', False)},
+        ('extended_negative', True)),
+    ({('extended_nonpositive', True), ('extended_nonzero', True)},
+        ('extended_negative', True)),
+
+    # Rules implying extended_nonnegative = True
+    ({('extended_negative', False), ('extended_real', True)},
+        ('extended_nonnegative', True)),
+
+    # Rules implying extended_nonpositive = True
+    ({('extended_positive', False), ('extended_real', True)},
+        ('extended_nonpositive', True)),
+
+    # Rules implying extended_nonzero = True
+    ({('extended_real', True), ('zero', False)},
+        ('extended_nonzero', True)),
+
+    # Rules implying extended_positive = True
+    ({('extended_negative', False), ('extended_real', True), ('zero', False)},
+        ('extended_positive', True)),
+    ({('extended_nonnegative', True), ('extended_nonzero', True)},
+        ('extended_positive', True)),
+
+    # Rules implying extended_real = False
+    ({('infinite', False), ('real', False)},
+        ('extended_real', False)),
+    ({('extended_negative', False), ('extended_positive', False), ('zero', False)},
+        ('extended_real', False)),
+
+    # Rules implying infinite = True
+    ({('extended_real', True), ('real', False)},
+        ('infinite', True)),
+
+    # Rules implying irrational = True
+    ({('rational', False), ('real', True)},
+        ('irrational', True)),
+
+    # Rules implying negative = True
+    ({('positive', False), ('real', True), ('zero', False)},
+        ('negative', True)),
+    ({('nonpositive', True), ('nonzero', True)},
+        ('negative', True)),
+    ({('extended_negative', True), ('finite', True)},
+        ('negative', True)),
+
+    # Rules implying noninteger = True
+    ({('extended_real', True), ('integer', False)},
+        ('noninteger', True)),
+
+    # Rules implying nonnegative = True
+    ({('negative', False), ('real', True)},
+        ('nonnegative', True)),
+    ({('extended_nonnegative', True), ('finite', True)},
+        ('nonnegative', True)),
+
+    # Rules implying nonpositive = True
+    ({('positive', False), ('real', True)},
+        ('nonpositive', True)),
+    ({('extended_nonpositive', True), ('finite', True)},
+        ('nonpositive', True)),
+
+    # Rules implying nonzero = True
+    ({('extended_nonzero', True), ('finite', True)},
+        ('nonzero', True)),
+
+    # Rules implying odd = True
+    ({('even', False), ('integer', True)},
+        ('odd', True)),
+
+    # Rules implying positive = False
+    ({('composite', False), ('even', True), ('prime', False)},
+        ('positive', False)),
+
+    # Rules implying positive = True
+    ({('negative', False), ('real', True), ('zero', False)},
+        ('positive', True)),
+    ({('nonnegative', True), ('nonzero', True)},
+        ('positive', True)),
+    ({('extended_positive', True), ('finite', True)},
+        ('positive', True)),
+
+    # Rules implying prime = True
+    ({('composite', False), ('even', True), ('positive', True)},
+        ('prime', True)),
+
+    # Rules implying real = False
+    ({('negative', False), ('positive', False), ('zero', False)},
+        ('real', False)),
+
+    # Rules implying real = True
+    ({('extended_real', True), ('infinite', False)},
+        ('real', True)),
+    ({('extended_real', True), ('finite', True)},
+        ('real', True)),
+
+    # Rules implying transcendental = True
+    ({('algebraic', False), ('complex', True)},
+        ('transcendental', True)),
+
+    # Rules implying zero = True
+    ({('extended_negative', False), ('extended_positive', False), ('extended_real', True)},
+        ('zero', True)),
+    ({('negative', False), ('positive', False), ('real', True)},
+        ('zero', True)),
+    ({('extended_nonnegative', True), ('extended_nonpositive', True)},
+        ('zero', True)),
+    ({('nonnegative', True), ('nonpositive', True)},
+        ('zero', True)),
+
+] # beta_rules
+beta_triggers = {
+    ('algebraic', False): [32, 11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('algebraic', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('antihermitian', False): [],
+    ('commutative', False): [],
+    ('complex', False): [10, 12, 11, 3, 8, 17, 7],
+    ('complex', True): [32, 10, 30, 31, 27, 16, 21, 19, 22],
+    ('composite', False): [1, 28, 24],
+    ('composite', True): [23, 2],
+    ('even', False): [23, 11, 3, 8, 29, 14, 25, 7],
+    ('even', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 0, 28, 24, 7],
+    ('extended_negative', False): [11, 33, 8, 5, 29, 34, 25, 18],
+    ('extended_negative', True): [30, 12, 31, 29, 14, 20, 16, 21, 22, 17],
+    ('extended_nonnegative', False): [11, 3, 6, 29, 14, 20, 7],
+    ('extended_nonnegative', True): [30, 12, 31, 33, 8, 9, 6, 29, 34, 25, 18, 19, 35, 17, 7],
+    ('extended_nonpositive', False): [11, 8, 5, 29, 25, 18, 7],
+    ('extended_nonpositive', True): [30, 12, 31, 3, 33, 4, 5, 29, 14, 34, 20, 21, 35, 17, 7],
+    ('extended_nonzero', False): [11, 33, 6, 5, 29, 34, 20, 18],
+    ('extended_nonzero', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22, 17],
+    ('extended_positive', False): [11, 3, 33, 6, 29, 14, 34, 20],
+    ('extended_positive', True): [30, 12, 31, 29, 25, 18, 27, 19, 22, 17],
+    ('extended_real', False): [],
+    ('extended_real', True): [30, 12, 31, 3, 33, 8, 6, 5, 17, 7],
+    ('finite', False): [11, 3, 8, 17, 7],
+    ('finite', True): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('hermitian', False): [10, 12, 11, 3, 8, 17, 7],
+    ('imaginary', True): [32],
+    ('infinite', False): [10, 30, 31, 27, 16, 21, 19, 22],
+    ('infinite', True): [11, 3, 8, 17, 7],
+    ('integer', False): [11, 3, 8, 29, 14, 25, 17, 7],
+    ('integer', True): [23, 2, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 7],
+    ('irrational', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('negative', False): [29, 34, 25, 18],
+    ('negative', True): [32, 13, 17],
+    ('noninteger', True): [30, 12, 31, 3, 8, 4, 9, 6, 5, 29, 14, 25, 22],
+    ('nonnegative', False): [11, 3, 8, 29, 14, 20, 7],
+    ('nonnegative', True): [32, 33, 8, 9, 6, 34, 25, 26, 20, 27, 21, 22, 35, 36, 13, 17, 7],
+    ('nonpositive', False): [11, 3, 8, 29, 25, 18, 7],
+    ('nonpositive', True): [32, 3, 33, 4, 5, 14, 34, 15, 18, 16, 19, 22, 35, 36, 13, 17, 7],
+    ('nonzero', False): [29, 34, 20, 18],
+    ('nonzero', True): [32, 3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19, 13, 17],
+    ('odd', False): [2],
+    ('odd', True): [3, 8, 4, 9, 6, 5, 14, 25, 15, 26, 20, 18, 27, 16, 21, 19],
+    ('positive', False): [29, 14, 34, 20],
+    ('positive', True): [32, 0, 1, 28, 13, 17],
+    ('prime', False): [0, 1, 24],
+    ('prime', True): [23, 2],
+    ('rational', False): [11, 3, 8, 29, 14, 25, 13, 17, 7],
+    ('rational', True): [3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 17, 7],
+    ('real', False): [10, 12, 11, 3, 8, 17, 7],
+    ('real', True): [32, 3, 33, 8, 6, 5, 14, 34, 25, 20, 18, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('transcendental', True): [10, 30, 31, 11, 3, 8, 29, 14, 25, 27, 16, 21, 19, 22, 13, 17, 7],
+    ('zero', False): [11, 3, 8, 29, 14, 25, 7],
+    ('zero', True): [],
+} # beta_triggers
+
+
+generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,
+               'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers}
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/backend.py b/.venv/lib/python3.12/site-packages/sympy/core/backend.py
new file mode 100644
index 0000000000000000000000000000000000000000..34a4e05a4a4ac50d0830960cb324871a20e9a12d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/backend.py
@@ -0,0 +1,120 @@
+import os
+USE_SYMENGINE = os.getenv('USE_SYMENGINE', '0')
+USE_SYMENGINE = USE_SYMENGINE.lower() in ('1', 't', 'true')  # type: ignore
+
+if USE_SYMENGINE:
+    from symengine import (Symbol, Integer, sympify as sympify_symengine, S,
+        SympifyError, exp, log, gamma, sqrt, I, E, pi, Matrix,
+        sin, cos, tan, cot, csc, sec, asin, acos, atan, acot, acsc, asec,
+        sinh, cosh, tanh, coth, asinh, acosh, atanh, acoth,
+        lambdify, symarray, diff, zeros, eye, diag, ones,
+        expand, Function, symbols, var, Add, Mul, Derivative,
+        ImmutableMatrix, MatrixBase, Rational, Basic)
+    from symengine.lib.symengine_wrapper import gcd as igcd
+    from symengine import AppliedUndef
+
+    def sympify(a, *, strict=False):
+        """
+        Notes
+        =====
+
+        SymEngine's ``sympify`` does not accept keyword arguments and is
+        therefore not compatible with SymPy's ``sympify`` with ``strict=True``
+        (which ensures that only the types for which an explicit conversion has
+        been defined are converted). This wrapper adds an additional parameter
+        ``strict`` (with default ``False``) that will raise a ``SympifyError``
+        if ``strict=True`` and the argument passed to the parameter ``a`` is a
+        string.
+
+        See Also
+        ========
+
+        sympify: Converts an arbitrary expression to a type that can be used
+            inside SymPy.
+
+        """
+        # The parameter ``a`` is used for this function to keep compatibility
+        # with the SymEngine docstring.
+        if strict and isinstance(a, str):
+            raise SympifyError(a)
+        return sympify_symengine(a)
+
+    # Keep the SymEngine docstring and append the additional "Notes" and "See
+    # Also" sections. Replacement of spaces is required to correctly format the
+    # indentation of the combined docstring.
+    sympify.__doc__ = (
+        sympify_symengine.__doc__
+        + sympify.__doc__.replace('        ', '    ')  # type: ignore
+    )
+else:
+    from sympy.core.add import Add
+    from sympy.core.basic import Basic
+    from sympy.core.function import (diff, Function, AppliedUndef,
+        expand, Derivative)
+    from sympy.core.mul import Mul
+    from sympy.core.intfunc import igcd
+    from sympy.core.numbers import pi, I, Integer, Rational, E
+    from sympy.core.singleton import S
+    from sympy.core.symbol import Symbol, var, symbols
+    from sympy.core.sympify import SympifyError, sympify
+    from sympy.functions.elementary.exponential import log, exp
+    from sympy.functions.elementary.hyperbolic import (coth, sinh,
+        acosh, acoth, tanh, asinh, atanh, cosh)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (csc,
+        asec, cos, atan, sec, acot, asin, tan, sin, cot, acsc, acos)
+    from sympy.functions.special.gamma_functions import gamma
+    from sympy.matrices.dense import (eye, zeros, diag, Matrix,
+        ones, symarray)
+    from sympy.matrices.immutable import ImmutableMatrix
+    from sympy.matrices.matrixbase import MatrixBase
+    from sympy.utilities.lambdify import lambdify
+
+
+#
+# XXX: Handling of immutable and mutable matrices in SymEngine is inconsistent
+# with SymPy's matrix classes in at least SymEngine version 0.7.0. Until that
+# is fixed the function below is needed for consistent behaviour when
+# attempting to simplify a matrix.
+#
+# Expected behaviour of a SymPy mutable/immutable matrix .simplify() method:
+#
+#   Matrix.simplify() : works in place, returns None
+#   ImmutableMatrix.simplify() : returns a simplified copy
+#
+# In SymEngine both mutable and immutable matrices simplify in place and return
+# None. This is inconsistent with the matrix being "immutable" and also the
+# returned None leads to problems in the mechanics module.
+#
+# The simplify function should not be used because simplify(M) sympifies the
+# matrix M and the SymEngine matrices all sympify to SymPy matrices. If we want
+# to work with SymEngine matrices then we need to use their .simplify() method
+# but that method does not work correctly with immutable matrices.
+#
+# The _simplify_matrix function can be removed when the SymEngine bug is fixed.
+# Since this should be a temporary problem we do not make this function part of
+# the public API.
+#
+#   SymEngine issue: https://github.com/symengine/symengine.py/issues/363
+#
+
+def _simplify_matrix(M):
+    """Return a simplified copy of the matrix M"""
+    if not isinstance(M, (Matrix, ImmutableMatrix)):
+        raise TypeError("The matrix M must be an instance of Matrix or ImmutableMatrix")
+    Mnew = M.as_mutable() # makes a copy if mutable
+    Mnew.simplify()
+    if isinstance(M, ImmutableMatrix):
+        Mnew = Mnew.as_immutable()
+    return Mnew
+
+
+__all__ = [
+    'Symbol', 'Integer', 'sympify', 'S', 'SympifyError', 'exp', 'log',
+    'gamma', 'sqrt', 'I', 'E', 'pi', 'Matrix', 'sin', 'cos', 'tan', 'cot',
+    'csc', 'sec', 'asin', 'acos', 'atan', 'acot', 'acsc', 'asec', 'sinh',
+    'cosh', 'tanh', 'coth', 'asinh', 'acosh', 'atanh', 'acoth', 'lambdify',
+    'symarray', 'diff', 'zeros', 'eye', 'diag', 'ones', 'expand', 'Function',
+    'symbols', 'var', 'Add', 'Mul', 'Derivative', 'ImmutableMatrix',
+    'MatrixBase', 'Rational', 'Basic', 'igcd', 'AppliedUndef',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/basic.py b/.venv/lib/python3.12/site-packages/sympy/core/basic.py
new file mode 100644
index 0000000000000000000000000000000000000000..92f6e710113ce0523ad15100abb0acd00f03f741
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/basic.py
@@ -0,0 +1,2355 @@
+"""Base class for all the objects in SymPy"""
+from __future__ import annotations
+
+from collections import Counter
+from collections.abc import Mapping, Iterable
+from itertools import zip_longest
+from functools import cmp_to_key
+from typing import TYPE_CHECKING, overload
+
+from .assumptions import _prepare_class_assumptions
+from .cache import cacheit
+from .sympify import _sympify, sympify, SympifyError, _external_converter
+from .sorting import ordered
+from .kind import Kind, UndefinedKind
+from ._print_helpers import Printable
+
+from sympy.utilities.decorator import deprecated
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import iterable, numbered_symbols
+from sympy.utilities.misc import filldedent, func_name
+
+
+if TYPE_CHECKING:
+    from typing import ClassVar, TypeVar, Any
+    from typing_extensions import Self
+    from .assumptions import StdFactKB
+    from .symbol import Symbol
+
+    Tbasic = TypeVar("Tbasic", bound='Basic')
+
+
+def as_Basic(expr):
+    """Return expr as a Basic instance using strict sympify
+    or raise a TypeError; this is just a wrapper to _sympify,
+    raising a TypeError instead of a SympifyError."""
+    try:
+        return _sympify(expr)
+    except SympifyError:
+        raise TypeError(
+            'Argument must be a Basic object, not `%s`' % func_name(
+            expr))
+
+
+# Key for sorting commutative args in canonical order
+# by name. This is used for canonical ordering of the
+# args for Add and Mul *if* the names of both classes
+# being compared appear here. Some things in this list
+# are not spelled the same as their name so they do not,
+# in effect, appear here. See Basic.compare.
+ordering_of_classes = [
+    # singleton numbers
+    'Zero', 'One', 'Half', 'Infinity', 'NaN', 'NegativeOne', 'NegativeInfinity',
+    # numbers
+    'Integer', 'Rational', 'Float',
+    # singleton symbols
+    'Exp1', 'Pi', 'ImaginaryUnit',
+    # symbols
+    'Symbol', 'Wild',
+    # arithmetic operations
+    'Pow', 'Mul', 'Add',
+    # function values
+    'Derivative', 'Integral',
+    # defined singleton functions
+    'Abs', 'Sign', 'Sqrt',
+    'Floor', 'Ceiling',
+    'Re', 'Im', 'Arg',
+    'Conjugate',
+    'Exp', 'Log',
+    'Sin', 'Cos', 'Tan', 'Cot', 'ASin', 'ACos', 'ATan', 'ACot',
+    'Sinh', 'Cosh', 'Tanh', 'Coth', 'ASinh', 'ACosh', 'ATanh', 'ACoth',
+    'RisingFactorial', 'FallingFactorial',
+    'factorial', 'binomial',
+    'Gamma', 'LowerGamma', 'UpperGamma', 'PolyGamma',
+    'Erf',
+    # special polynomials
+    'Chebyshev', 'Chebyshev2',
+    # undefined functions
+    'Function', 'WildFunction',
+    # anonymous functions
+    'Lambda',
+    # Landau O symbol
+    'Order',
+    # relational operations
+    'Equality', 'Unequality', 'StrictGreaterThan', 'StrictLessThan',
+    'GreaterThan', 'LessThan',
+]
+
+def _cmp_name(x: type, y: type) -> int:
+    """return -1, 0, 1 if the name of x is before that of y.
+    A string comparison is done if either name does not appear
+    in `ordering_of_classes`. This is the helper for
+    ``Basic.compare``
+
+    Examples
+    ========
+
+    >>> from sympy import cos, tan, sin
+    >>> from sympy.core import basic
+    >>> save = basic.ordering_of_classes
+    >>> basic.ordering_of_classes = ()
+    >>> basic._cmp_name(cos, tan)
+    -1
+    >>> basic.ordering_of_classes = ["tan", "sin", "cos"]
+    >>> basic._cmp_name(cos, tan)
+    1
+    >>> basic._cmp_name(sin, cos)
+    -1
+    >>> basic.ordering_of_classes = save
+
+    """
+    n1 = x.__name__
+    n2 = y.__name__
+    if n1 == n2:
+        return 0
+
+    # If the other object is not a Basic subclass, then we are not equal to it.
+    if not issubclass(y, Basic):
+        return -1
+
+    UNKNOWN = len(ordering_of_classes) + 1
+    try:
+        i1 = ordering_of_classes.index(n1)
+    except ValueError:
+        i1 = UNKNOWN
+    try:
+        i2 = ordering_of_classes.index(n2)
+    except ValueError:
+        i2 = UNKNOWN
+    if i1 == UNKNOWN and i2 == UNKNOWN:
+        return (n1 > n2) - (n1 < n2)
+    return (i1 > i2) - (i1 < i2)
+
+
+
+@cacheit
+def _get_postprocessors(clsname, arg_type):
+    # Since only Add, Mul, Pow can be clsname, this cache
+    # is not quadratic.
+    postprocessors = set()
+    mappings = _get_postprocessors_for_type(arg_type)
+    for mapping in mappings:
+        f = mapping.get(clsname, None)
+        if f is not None:
+            postprocessors.update(f)
+    return postprocessors
+
+@cacheit
+def _get_postprocessors_for_type(arg_type):
+    return tuple(
+        Basic._constructor_postprocessor_mapping[cls]
+        for cls in arg_type.mro()
+        if cls in Basic._constructor_postprocessor_mapping
+    )
+
+
+class Basic(Printable):
+    """
+    Base class for all SymPy objects.
+
+    Notes and conventions
+    =====================
+
+    1) Always use ``.args``, when accessing parameters of some instance:
+
+    >>> from sympy import cot
+    >>> from sympy.abc import x, y
+
+    >>> cot(x).args
+    (x,)
+
+    >>> cot(x).args[0]
+    x
+
+    >>> (x*y).args
+    (x, y)
+
+    >>> (x*y).args[1]
+    y
+
+
+    2) Never use internal methods or variables (the ones prefixed with ``_``):
+
+    >>> cot(x)._args    # do not use this, use cot(x).args instead
+    (x,)
+
+
+    3)  By "SymPy object" we mean something that can be returned by
+        ``sympify``.  But not all objects one encounters using SymPy are
+        subclasses of Basic.  For example, mutable objects are not:
+
+        >>> from sympy import Basic, Matrix, sympify
+        >>> A = Matrix([[1, 2], [3, 4]]).as_mutable()
+        >>> isinstance(A, Basic)
+        False
+
+        >>> B = sympify(A)
+        >>> isinstance(B, Basic)
+        True
+    """
+    __slots__ = ('_mhash',              # hash value
+                 '_args',               # arguments
+                 '_assumptions'
+                )
+
+    _args: tuple[Basic, ...]
+    _mhash: int | None
+
+    @property
+    def __sympy__(self):
+        return True
+
+    def __init_subclass__(cls):
+        # Initialize the default_assumptions FactKB and also any assumptions
+        # property methods. This method will only be called for subclasses of
+        # Basic but not for Basic itself so we call
+        # _prepare_class_assumptions(Basic) below the class definition.
+        super().__init_subclass__()
+        _prepare_class_assumptions(cls)
+
+    # To be overridden with True in the appropriate subclasses
+    is_number = False
+    is_Atom = False
+    is_Symbol = False
+    is_symbol = False
+    is_Indexed = False
+    is_Dummy = False
+    is_Wild = False
+    is_Function = False
+    is_Add = False
+    is_Mul = False
+    is_Pow = False
+    is_Number = False
+    is_Float = False
+    is_Rational = False
+    is_Integer = False
+    is_NumberSymbol = False
+    is_Order = False
+    is_Derivative = False
+    is_Piecewise = False
+    is_Poly = False
+    is_AlgebraicNumber = False
+    is_Relational = False
+    is_Equality = False
+    is_Boolean = False
+    is_Not = False
+    is_Matrix = False
+    is_Vector = False
+    is_Point = False
+    is_MatAdd = False
+    is_MatMul = False
+
+    default_assumptions: ClassVar[StdFactKB]
+
+    is_composite: bool | None
+    is_noninteger: bool | None
+    is_extended_positive: bool | None
+    is_negative: bool | None
+    is_complex: bool | None
+    is_extended_nonpositive: bool | None
+    is_integer: bool | None
+    is_positive: bool | None
+    is_rational: bool | None
+    is_extended_nonnegative: bool | None
+    is_infinite: bool | None
+    is_antihermitian: bool | None
+    is_extended_negative: bool | None
+    is_extended_real: bool | None
+    is_finite: bool | None
+    is_polar: bool | None
+    is_imaginary: bool | None
+    is_transcendental: bool | None
+    is_extended_nonzero: bool | None
+    is_nonzero: bool | None
+    is_odd: bool | None
+    is_algebraic: bool | None
+    is_prime: bool | None
+    is_commutative: bool | None
+    is_nonnegative: bool | None
+    is_nonpositive: bool | None
+    is_hermitian: bool | None
+    is_irrational: bool | None
+    is_real: bool | None
+    is_zero: bool | None
+    is_even: bool | None
+
+    kind: Kind = UndefinedKind
+
+    def __new__(cls, *args):
+        obj = object.__new__(cls)
+        obj._assumptions = cls.default_assumptions
+        obj._mhash = None  # will be set by __hash__ method.
+
+        obj._args = args  # all items in args must be Basic objects
+        return obj
+
+    def copy(self):
+        return self.func(*self.args)
+
+    def __getnewargs__(self):
+        return self.args
+
+    def __getstate__(self):
+        return None
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+    def __reduce_ex__(self, protocol):
+        if protocol < 2:
+            msg = "Only pickle protocol 2 or higher is supported by SymPy"
+            raise NotImplementedError(msg)
+        return super().__reduce_ex__(protocol)
+
+    def __hash__(self) -> int:
+        # hash cannot be cached using cache_it because infinite recurrence
+        # occurs as hash is needed for setting cache dictionary keys
+        h = self._mhash
+        if h is None:
+            h = hash((type(self).__name__,) + self._hashable_content())
+            self._mhash = h
+        return h
+
+    def _hashable_content(self):
+        """Return a tuple of information about self that can be used to
+        compute the hash. If a class defines additional attributes,
+        like ``name`` in Symbol, then this method should be updated
+        accordingly to return such relevant attributes.
+
+        Defining more than _hashable_content is necessary if __eq__ has
+        been defined by a class. See note about this in Basic.__eq__."""
+        return self._args
+
+    @property
+    def assumptions0(self):
+        """
+        Return object `type` assumptions.
+
+        For example:
+
+          Symbol('x', real=True)
+          Symbol('x', integer=True)
+
+        are different objects. In other words, besides Python type (Symbol in
+        this case), the initial assumptions are also forming their typeinfo.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy.abc import x
+        >>> x.assumptions0
+        {'commutative': True}
+        >>> x = Symbol("x", positive=True)
+        >>> x.assumptions0
+        {'commutative': True, 'complex': True, 'extended_negative': False,
+         'extended_nonnegative': True, 'extended_nonpositive': False,
+         'extended_nonzero': True, 'extended_positive': True, 'extended_real':
+         True, 'finite': True, 'hermitian': True, 'imaginary': False,
+         'infinite': False, 'negative': False, 'nonnegative': True,
+         'nonpositive': False, 'nonzero': True, 'positive': True, 'real':
+         True, 'zero': False}
+        """
+        return {}
+
+    def compare(self, other):
+        """
+        Return -1, 0, 1 if the object is less than, equal,
+        or greater than other in a canonical sense.
+        Non-Basic are always greater than Basic.
+        If both names of the classes being compared appear
+        in the `ordering_of_classes` then the ordering will
+        depend on the appearance of the names there.
+        If either does not appear in that list, then the
+        comparison is based on the class name.
+        If the names are the same then a comparison is made
+        on the length of the hashable content.
+        Items of the equal-lengthed contents are then
+        successively compared using the same rules. If there
+        is never a difference then 0 is returned.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> x.compare(y)
+        -1
+        >>> x.compare(x)
+        0
+        >>> y.compare(x)
+        1
+
+        """
+        # all redefinitions of __cmp__ method should start with the
+        # following lines:
+        if self is other:
+            return 0
+        n1 = self.__class__
+        n2 = other.__class__
+        c = _cmp_name(n1, n2)
+        if c:
+            return c
+        #
+        st = self._hashable_content()
+        ot = other._hashable_content()
+        len_st = len(st)
+        len_ot = len(ot)
+        c = (len_st > len_ot) - (len_st < len_ot)
+        if c:
+            return c
+        for l, r in zip(st, ot):
+            if isinstance(l, Basic):
+                c = l.compare(r)
+            elif isinstance(l, frozenset):
+                l = Basic(*l) if isinstance(l, frozenset) else l
+                r = Basic(*r) if isinstance(r, frozenset) else r
+                c = l.compare(r)
+            else:
+                c = (l > r) - (l < r)
+            if c:
+                return c
+        return 0
+
+    @classmethod
+    def fromiter(cls, args, **assumptions):
+        """
+        Create a new object from an iterable.
+
+        This is a convenience function that allows one to create objects from
+        any iterable, without having to convert to a list or tuple first.
+
+        Examples
+        ========
+
+        >>> from sympy import Tuple
+        >>> Tuple.fromiter(i for i in range(5))
+        (0, 1, 2, 3, 4)
+
+        """
+        return cls(*tuple(args), **assumptions)
+
+    @classmethod
+    def class_key(cls) -> tuple[int, int, str]:
+        """Nice order of classes."""
+        return 5, 0, cls.__name__
+
+    @cacheit
+    def sort_key(self, order=None):
+        """
+        Return a sort key.
+
+        Examples
+        ========
+
+        >>> from sympy import S, I
+
+        >>> sorted([S(1)/2, I, -I], key=lambda x: x.sort_key())
+        [1/2, -I, I]
+
+        >>> S("[x, 1/x, 1/x**2, x**2, x**(1/2), x**(1/4), x**(3/2)]")
+        [x, 1/x, x**(-2), x**2, sqrt(x), x**(1/4), x**(3/2)]
+        >>> sorted(_, key=lambda x: x.sort_key())
+        [x**(-2), 1/x, x**(1/4), sqrt(x), x, x**(3/2), x**2]
+
+        """
+
+        # XXX: remove this when issue 5169 is fixed
+        def inner_key(arg):
+            if isinstance(arg, Basic):
+                return arg.sort_key(order)
+            else:
+                return arg
+
+        args = self._sorted_args
+        args = len(args), tuple([inner_key(arg) for arg in args])
+        return self.class_key(), args, S.One.sort_key(), S.One
+
+    def _do_eq_sympify(self, other):
+        """Returns a boolean indicating whether a == b when either a
+        or b is not a Basic. This is only done for types that were either
+        added to `converter` by a 3rd party or when the object has `_sympy_`
+        defined. This essentially reuses the code in `_sympify` that is
+        specific for this use case. Non-user defined types that are meant
+        to work with SymPy should be handled directly in the __eq__ methods
+        of the `Basic` classes it could equate to and not be converted. Note
+        that after conversion, `==`  is used again since it is not
+        necessarily clear whether `self` or `other`'s __eq__ method needs
+        to be used."""
+        for superclass in type(other).__mro__:
+            conv = _external_converter.get(superclass)
+            if conv is not None:
+                return self == conv(other)
+        if hasattr(other, '_sympy_'):
+            return self == other._sympy_()
+        return NotImplemented
+
+    def __eq__(self, other):
+        """Return a boolean indicating whether a == b on the basis of
+        their symbolic trees.
+
+        This is the same as a.compare(b) == 0 but faster.
+
+        Notes
+        =====
+
+        If a class that overrides __eq__() needs to retain the
+        implementation of __hash__() from a parent class, the
+        interpreter must be told this explicitly by setting
+        __hash__ : Callable[[object], int] = .__hash__.
+        Otherwise the inheritance of __hash__() will be blocked,
+        just as if __hash__ had been explicitly set to None.
+
+        References
+        ==========
+
+        from https://docs.python.org/dev/reference/datamodel.html#object.__hash__
+        """
+        if self is other:
+            return True
+
+        if not isinstance(other, Basic):
+            return self._do_eq_sympify(other)
+
+        # check for pure number expr
+        if  not (self.is_Number and other.is_Number) and (
+                type(self) != type(other)):
+            return False
+        a, b = self._hashable_content(), other._hashable_content()
+        if a != b:
+            return False
+        # check number *in* an expression
+        for a, b in zip(a, b):
+            if not isinstance(a, Basic):
+                continue
+            if a.is_Number and type(a) != type(b):
+                return False
+        return True
+
+    def __ne__(self, other):
+        """``a != b``  -> Compare two symbolic trees and see whether they are different
+
+        this is the same as:
+
+        ``a.compare(b) != 0``
+
+        but faster
+        """
+        return not self == other
+
+    def dummy_eq(self, other, symbol=None):
+        """
+        Compare two expressions and handle dummy symbols.
+
+        Examples
+        ========
+
+        >>> from sympy import Dummy
+        >>> from sympy.abc import x, y
+
+        >>> u = Dummy('u')
+
+        >>> (u**2 + 1).dummy_eq(x**2 + 1)
+        True
+        >>> (u**2 + 1) == (x**2 + 1)
+        False
+
+        >>> (u**2 + y).dummy_eq(x**2 + y, x)
+        True
+        >>> (u**2 + y).dummy_eq(x**2 + y, y)
+        False
+
+        """
+        s = self.as_dummy()
+        o = _sympify(other)
+        o = o.as_dummy()
+
+        dummy_symbols = [i for i in s.free_symbols if i.is_Dummy]
+
+        if len(dummy_symbols) == 1:
+            dummy = dummy_symbols.pop()
+        else:
+            return s == o
+
+        if symbol is None:
+            symbols = o.free_symbols
+
+            if len(symbols) == 1:
+                symbol = symbols.pop()
+            else:
+                return s == o
+
+        tmp = dummy.__class__()
+
+        return s.xreplace({dummy: tmp}) == o.xreplace({symbol: tmp})
+
+    @overload
+    def atoms(self) -> set[Basic]: ...
+    @overload
+    def atoms(self, *types: Tbasic | type[Tbasic]) -> set[Tbasic]: ...
+
+    def atoms(self, *types: Tbasic | type[Tbasic]) -> set[Basic] | set[Tbasic]:
+        """Returns the atoms that form the current object.
+
+        By default, only objects that are truly atomic and cannot
+        be divided into smaller pieces are returned: symbols, numbers,
+        and number symbols like I and pi. It is possible to request
+        atoms of any type, however, as demonstrated below.
+
+        Examples
+        ========
+
+        >>> from sympy import I, pi, sin
+        >>> from sympy.abc import x, y
+        >>> (1 + x + 2*sin(y + I*pi)).atoms()
+        {1, 2, I, pi, x, y}
+
+        If one or more types are given, the results will contain only
+        those types of atoms.
+
+        >>> from sympy import Number, NumberSymbol, Symbol
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Symbol)
+        {x, y}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number)
+        {1, 2}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol)
+        {1, 2, pi}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Number, NumberSymbol, I)
+        {1, 2, I, pi}
+
+        Note that I (imaginary unit) and zoo (complex infinity) are special
+        types of number symbols and are not part of the NumberSymbol class.
+
+        The type can be given implicitly, too:
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(x) # x is a Symbol
+        {x, y}
+
+        Be careful to check your assumptions when using the implicit option
+        since ``S(1).is_Integer = True`` but ``type(S(1))`` is ``One``, a special type
+        of SymPy atom, while ``type(S(2))`` is type ``Integer`` and will find all
+        integers in an expression:
+
+        >>> from sympy import S
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(1))
+        {1}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(S(2))
+        {1, 2}
+
+        Finally, arguments to atoms() can select more than atomic atoms: any
+        SymPy type (loaded in core/__init__.py) can be listed as an argument
+        and those types of "atoms" as found in scanning the arguments of the
+        expression recursively:
+
+        >>> from sympy import Function, Mul
+        >>> from sympy.core.function import AppliedUndef
+        >>> f = Function('f')
+        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(Function)
+        {f(x), sin(y + I*pi)}
+        >>> (1 + f(x) + 2*sin(y + I*pi)).atoms(AppliedUndef)
+        {f(x)}
+
+        >>> (1 + x + 2*sin(y + I*pi)).atoms(Mul)
+        {I*pi, 2*sin(y + I*pi)}
+
+        """
+        nodes = _preorder_traversal(self)
+        if types:
+            types2 = tuple([t if isinstance(t, type) else type(t) for t in types])
+            return {node for node in nodes if isinstance(node, types2)}
+        else:
+            return {node for node in nodes if not node.args}
+
+    @property
+    def free_symbols(self) -> set[Basic]:
+        """Return from the atoms of self those which are free symbols.
+
+        Not all free symbols are ``Symbol`` (see examples)
+
+        For most expressions, all symbols are free symbols. For some classes
+        this is not true. e.g. Integrals use Symbols for the dummy variables
+        which are bound variables, so Integral has a method to return all
+        symbols except those. Derivative keeps track of symbols with respect
+        to which it will perform a derivative; those are
+        bound variables, too, so it has its own free_symbols method.
+
+        Any other method that uses bound variables should implement a
+        free_symbols method.
+
+        Examples
+        ========
+
+        >>> from sympy import Derivative, Integral, IndexedBase
+        >>> from sympy.abc import x, y, n
+        >>> (x + 1).free_symbols
+        {x}
+        >>> Integral(x, y).free_symbols
+        {x, y}
+
+        Not all free symbols are actually symbols:
+
+        >>> IndexedBase('F')[0].free_symbols
+        {F, F[0]}
+
+        The symbols of differentiation are not included unless they
+        appear in the expression being differentiated.
+
+        >>> Derivative(x + y, y).free_symbols
+        {x, y}
+        >>> Derivative(x, y).free_symbols
+        {x}
+        >>> Derivative(x, (y, n)).free_symbols
+        {n, x}
+
+        If you want to know if a symbol is in the variables of the
+        Derivative you can do so as follows:
+
+        >>> Derivative(x, y).has_free(y)
+        True
+        """
+        empty: set[Basic] = set()
+        return empty.union(*(a.free_symbols for a in self.args))
+
+    @property
+    def expr_free_symbols(self):
+        sympy_deprecation_warning("""
+        The expr_free_symbols property is deprecated. Use free_symbols to get
+        the free symbols of an expression.
+        """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-expr-free-symbols")
+        return set()
+
+    def as_dummy(self) -> "Self":
+        """Return the expression with any objects having structurally
+        bound symbols replaced with unique, canonical symbols within
+        the object in which they appear and having only the default
+        assumption for commutativity being True. When applied to a
+        symbol a new symbol having only the same commutativity will be
+        returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, Symbol
+        >>> from sympy.abc import x
+        >>> r = Symbol('r', real=True)
+        >>> Integral(r, (r, x)).as_dummy()
+        Integral(_0, (_0, x))
+        >>> _.variables[0].is_real is None
+        True
+        >>> r.as_dummy()
+        _r
+
+        Notes
+        =====
+
+        Any object that has structurally bound variables should have
+        a property, ``bound_symbols`` that returns those symbols
+        appearing in the object.
+        """
+        from .symbol import Dummy, Symbol
+        def can(x):
+            # mask free that shadow bound
+            free = x.free_symbols
+            bound = set(x.bound_symbols)
+            d = {i: Dummy() for i in bound & free}
+            x = x.subs(d)
+            # replace bound with canonical names
+            x = x.xreplace(x.canonical_variables)
+            # return after undoing masking
+            return x.xreplace({v: k for k, v in d.items()})
+        if not self.has(Symbol):
+            return self
+        return self.replace(
+            lambda x: hasattr(x, 'bound_symbols'),
+            can,
+            simultaneous=False) # type:ignore
+
+    @property
+    def canonical_variables(self) -> dict[Basic, Symbol]:
+        """Return a dictionary mapping any variable defined in
+        ``self.bound_symbols`` to Symbols that do not clash
+        with any free symbols in the expression.
+
+        Examples
+        ========
+
+        >>> from sympy import Lambda
+        >>> from sympy.abc import x
+        >>> Lambda(x, 2*x).canonical_variables
+        {x: _0}
+        """
+        bound: list[Basic] | None = getattr(self, 'bound_symbols', None)
+        if bound is None:
+            return {}
+        dums = numbered_symbols('_')
+        reps = {}
+        # watch out for free symbol that are not in bound symbols;
+        # those that are in bound symbols are about to get changed
+
+        # XXX: free_symbols only returns particular kinds of expressions that
+        # generally have a .name attribute. There is not a proper class/type
+        # that represents this.
+        names = {i.name for i in self.free_symbols - set(bound)} # type: ignore
+        for b in bound:
+            d = next(dums)
+            if b.is_Symbol:
+                while d.name in names:
+                    d = next(dums)
+            reps[b] = d
+        return reps
+
+    def rcall(self, *args):
+        """Apply on the argument recursively through the expression tree.
+
+        This method is used to simulate a common abuse of notation for
+        operators. For instance, in SymPy the following will not work:
+
+        ``(x+Lambda(y, 2*y))(z) == x+2*z``,
+
+        however, you can use:
+
+        >>> from sympy import Lambda
+        >>> from sympy.abc import x, y, z
+        >>> (x + Lambda(y, 2*y)).rcall(z)
+        x + 2*z
+        """
+        if callable(self):
+            return self(*args)
+        elif self.args:
+            newargs = [sub.rcall(*args) for sub in self.args]
+            return self.func(*newargs)
+        else:
+            return self
+
+    def is_hypergeometric(self, k):
+        from sympy.simplify.simplify import hypersimp
+        from sympy.functions.elementary.piecewise import Piecewise
+        if self.has(Piecewise):
+            return None
+        return hypersimp(self, k) is not None
+
+    @property
+    def is_comparable(self):
+        """Return True if self can be computed to a real number
+        (or already is a real number) with precision, else False.
+
+        Examples
+        ========
+
+        >>> from sympy import exp_polar, pi, I
+        >>> (I*exp_polar(I*pi/2)).is_comparable
+        True
+        >>> (I*exp_polar(I*pi*2)).is_comparable
+        False
+
+        A False result does not mean that `self` cannot be rewritten
+        into a form that would be comparable. For example, the
+        difference computed below is zero but without simplification
+        it does not evaluate to a zero with precision:
+
+        >>> e = 2**pi*(1 + 2**pi)
+        >>> dif = e - e.expand()
+        >>> dif.is_comparable
+        False
+        >>> dif.n(2)._prec
+        1
+
+        """
+        return self._eval_is_comparable()
+
+    def _eval_is_comparable(self) -> bool:
+        # Expr.is_comparable overrides this
+        return False
+
+    @property
+    def func(self):
+        """
+        The top-level function in an expression.
+
+        The following should hold for all objects::
+
+            >> x == x.func(*x.args)
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> a = 2*x
+        >>> a.func
+        
+        >>> a.args
+        (2, x)
+        >>> a.func(*a.args)
+        2*x
+        >>> a == a.func(*a.args)
+        True
+
+        """
+        return self.__class__
+
+    @property
+    def args(self) -> tuple[Basic, ...]:
+        """Returns a tuple of arguments of 'self'.
+
+        Examples
+        ========
+
+        >>> from sympy import cot
+        >>> from sympy.abc import x, y
+
+        >>> cot(x).args
+        (x,)
+
+        >>> cot(x).args[0]
+        x
+
+        >>> (x*y).args
+        (x, y)
+
+        >>> (x*y).args[1]
+        y
+
+        Notes
+        =====
+
+        Never use self._args, always use self.args.
+        Only use _args in __new__ when creating a new function.
+        Do not override .args() from Basic (so that it is easy to
+        change the interface in the future if needed).
+        """
+        return self._args
+
+    @property
+    def _sorted_args(self):
+        """
+        The same as ``args``.  Derived classes which do not fix an
+        order on their arguments should override this method to
+        produce the sorted representation.
+        """
+        return self.args
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """A stub to allow Basic args (like Tuple) to be skipped when computing
+        the content and primitive components of an expression.
+
+        See Also
+        ========
+
+        sympy.core.expr.Expr.as_content_primitive
+        """
+        return S.One, self
+
+    @overload
+    def subs(self, arg1: Mapping[Basic | complex, Basic | complex], arg2: None=None, **kwargs: Any) -> Basic: ...
+    @overload
+    def subs(self, arg1: Iterable[tuple[Basic | complex, Basic | complex]], arg2: None=None, **kwargs: Any) -> Basic: ...
+    @overload
+    def subs(self, arg1: Basic | complex, arg2: Basic | complex, **kwargs: Any) -> Basic: ...
+
+    def subs(self, arg1: Mapping[Basic | complex, Basic | complex]
+            | Iterable[tuple[Basic | complex, Basic | complex]] | Basic | complex,
+             arg2: Basic | complex | None = None, **kwargs: Any) -> Basic:
+        """
+        Substitutes old for new in an expression after sympifying args.
+
+        `args` is either:
+          - two arguments, e.g. foo.subs(old, new)
+          - one iterable argument, e.g. foo.subs(iterable). The iterable may be
+             o an iterable container with (old, new) pairs. In this case the
+               replacements are processed in the order given with successive
+               patterns possibly affecting replacements already made.
+             o a dict or set whose key/value items correspond to old/new pairs.
+               In this case the old/new pairs will be sorted by op count and in
+               case of a tie, by number of args and the default_sort_key. The
+               resulting sorted list is then processed as an iterable container
+               (see previous).
+
+        If the keyword ``simultaneous`` is True, the subexpressions will not be
+        evaluated until all the substitutions have been made.
+
+        Examples
+        ========
+
+        >>> from sympy import pi, exp, limit, oo
+        >>> from sympy.abc import x, y
+        >>> (1 + x*y).subs(x, pi)
+        pi*y + 1
+        >>> (1 + x*y).subs({x:pi, y:2})
+        1 + 2*pi
+        >>> (1 + x*y).subs([(x, pi), (y, 2)])
+        1 + 2*pi
+        >>> reps = [(y, x**2), (x, 2)]
+        >>> (x + y).subs(reps)
+        6
+        >>> (x + y).subs(reversed(reps))
+        x**2 + 2
+
+        >>> (x**2 + x**4).subs(x**2, y)
+        y**2 + y
+
+        To replace only the x**2 but not the x**4, use xreplace:
+
+        >>> (x**2 + x**4).xreplace({x**2: y})
+        x**4 + y
+
+        To delay evaluation until all substitutions have been made,
+        set the keyword ``simultaneous`` to True:
+
+        >>> (x/y).subs([(x, 0), (y, 0)])
+        0
+        >>> (x/y).subs([(x, 0), (y, 0)], simultaneous=True)
+        nan
+
+        This has the added feature of not allowing subsequent substitutions
+        to affect those already made:
+
+        >>> ((x + y)/y).subs({x + y: y, y: x + y})
+        1
+        >>> ((x + y)/y).subs({x + y: y, y: x + y}, simultaneous=True)
+        y/(x + y)
+
+        In order to obtain a canonical result, unordered iterables are
+        sorted by count_op length, number of arguments and by the
+        default_sort_key to break any ties. All other iterables are left
+        unsorted.
+
+        >>> from sympy import sqrt, sin, cos
+        >>> from sympy.abc import a, b, c, d, e
+
+        >>> A = (sqrt(sin(2*x)), a)
+        >>> B = (sin(2*x), b)
+        >>> C = (cos(2*x), c)
+        >>> D = (x, d)
+        >>> E = (exp(x), e)
+
+        >>> expr = sqrt(sin(2*x))*sin(exp(x)*x)*cos(2*x) + sin(2*x)
+
+        >>> expr.subs(dict([A, B, C, D, E]))
+        a*c*sin(d*e) + b
+
+        The resulting expression represents a literal replacement of the
+        old arguments with the new arguments. This may not reflect the
+        limiting behavior of the expression:
+
+        >>> (x**3 - 3*x).subs({x: oo})
+        nan
+
+        >>> limit(x**3 - 3*x, x, oo)
+        oo
+
+        If the substitution will be followed by numerical
+        evaluation, it is better to pass the substitution to
+        evalf as
+
+        >>> (1/x).evalf(subs={x: 3.0}, n=21)
+        0.333333333333333333333
+
+        rather than
+
+        >>> (1/x).subs({x: 3.0}).evalf(21)
+        0.333333333333333314830
+
+        as the former will ensure that the desired level of precision is
+        obtained.
+
+        See Also
+        ========
+        replace: replacement capable of doing wildcard-like matching,
+                 parsing of match, and conditional replacements
+        xreplace: exact node replacement in expr tree; also capable of
+                  using matching rules
+        sympy.core.evalf.EvalfMixin.evalf: calculates the given formula to a desired level of precision
+
+        """
+        from .containers import Dict
+        from .symbol import Dummy, Symbol
+        from .numbers import _illegal
+
+        items: Iterable[tuple[Basic | complex, Basic | complex]]
+
+        unordered = False
+        if arg2 is None:
+
+            if isinstance(arg1, set):
+                items = arg1
+                unordered = True
+            elif isinstance(arg1, (Dict, Mapping)):
+                unordered = True
+                items = arg1.items() # type: ignore
+            elif not iterable(arg1):
+                raise ValueError(filldedent("""
+                   When a single argument is passed to subs
+                   it should be a dictionary of old: new pairs or an iterable
+                   of (old, new) tuples."""))
+            else:
+                items = arg1 # type: ignore
+        else:
+            items = [(arg1, arg2)] # type: ignore
+
+        def sympify_old(old) -> Basic:
+            if isinstance(old, str):
+                # Use Symbol rather than parse_expr for old
+                return Symbol(old)
+            elif isinstance(old, type):
+                # Allow a type e.g. Function('f') or sin
+                return sympify(old, strict=False)
+            else:
+                return sympify(old, strict=True)
+
+        def sympify_new(new) -> Basic:
+            if isinstance(new, (str, type)):
+                # Allow a type or parse a string input
+                return sympify(new, strict=False)
+            else:
+                return sympify(new, strict=True)
+
+        sequence = [(sympify_old(s1), sympify_new(s2)) for s1, s2 in items]
+
+        # skip if there is no change
+        sequence = [(s1, s2) for s1, s2 in sequence if not _aresame(s1, s2)]
+
+        simultaneous = kwargs.pop('simultaneous', False)
+
+        if unordered:
+            from .sorting import _nodes, default_sort_key
+            sequence_dict = dict(sequence)
+            # order so more complex items are first and items
+            # of identical complexity are ordered so
+            # f(x) < f(y) < x < y
+            # \___ 2 __/    \_1_/  <- number of nodes
+            #
+            # For more complex ordering use an unordered sequence.
+            k = list(ordered(sequence_dict, default=False, keys=(
+                lambda x: -_nodes(x),
+                default_sort_key,
+                )))
+            sequence = [(k, sequence_dict[k]) for k in k]
+            # do infinities first
+            if not simultaneous:
+                redo = [i for i, seq in enumerate(sequence) if seq[1] in _illegal]
+                for i in reversed(redo):
+                    sequence.insert(0, sequence.pop(i))
+
+        if simultaneous:  # XXX should this be the default for dict subs?
+            reps = {}
+            rv = self
+            kwargs['hack2'] = True
+            m = Dummy('subs_m')
+            for old, new in sequence:
+                com = new.is_commutative
+                if com is None:
+                    com = True
+                d = Dummy('subs_d', commutative=com)
+                # using d*m so Subs will be used on dummy variables
+                # in things like Derivative(f(x, y), x) in which x
+                # is both free and bound
+                rv = rv._subs(old, d*m, **kwargs)
+                if not isinstance(rv, Basic):
+                    break
+                reps[d] = new
+            reps[m] = S.One  # get rid of m
+            return rv.xreplace(reps)
+        else:
+            rv = self
+            for old, new in sequence:
+                rv = rv._subs(old, new, **kwargs)
+                if not isinstance(rv, Basic):
+                    break
+            return rv
+
+    @cacheit
+    def _subs(self, old, new, **hints):
+        """Substitutes an expression old -> new.
+
+        If self is not equal to old then _eval_subs is called.
+        If _eval_subs does not want to make any special replacement
+        then a None is received which indicates that the fallback
+        should be applied wherein a search for replacements is made
+        amongst the arguments of self.
+
+        >>> from sympy import Add
+        >>> from sympy.abc import x, y, z
+
+        Examples
+        ========
+
+        Add's _eval_subs knows how to target x + y in the following
+        so it makes the change:
+
+        >>> (x + y + z).subs(x + y, 1)
+        z + 1
+
+        Add's _eval_subs does not need to know how to find x + y in
+        the following:
+
+        >>> Add._eval_subs(z*(x + y) + 3, x + y, 1) is None
+        True
+
+        The returned None will cause the fallback routine to traverse the args and
+        pass the z*(x + y) arg to Mul where the change will take place and the
+        substitution will succeed:
+
+        >>> (z*(x + y) + 3).subs(x + y, 1)
+        z + 3
+
+        ** Developers Notes **
+
+        An _eval_subs routine for a class should be written if:
+
+            1) any arguments are not instances of Basic (e.g. bool, tuple);
+
+            2) some arguments should not be targeted (as in integration
+               variables);
+
+            3) if there is something other than a literal replacement
+               that should be attempted (as in Piecewise where the condition
+               may be updated without doing a replacement).
+
+        If it is overridden, here are some special cases that might arise:
+
+            1) If it turns out that no special change was made and all
+               the original sub-arguments should be checked for
+               replacements then None should be returned.
+
+            2) If it is necessary to do substitutions on a portion of
+               the expression then _subs should be called. _subs will
+               handle the case of any sub-expression being equal to old
+               (which usually would not be the case) while its fallback
+               will handle the recursion into the sub-arguments. For
+               example, after Add's _eval_subs removes some matching terms
+               it must process the remaining terms so it calls _subs
+               on each of the un-matched terms and then adds them
+               onto the terms previously obtained.
+
+           3) If the initial expression should remain unchanged then
+              the original expression should be returned. (Whenever an
+              expression is returned, modified or not, no further
+              substitution of old -> new is attempted.) Sum's _eval_subs
+              routine uses this strategy when a substitution is attempted
+              on any of its summation variables.
+        """
+
+        def fallback(self, old, new):
+            """
+            Try to replace old with new in any of self's arguments.
+            """
+            hit = False
+            args = list(self.args)
+            for i, arg in enumerate(args):
+                if not hasattr(arg, '_eval_subs'):
+                    continue
+                arg = arg._subs(old, new, **hints)
+                if not _aresame(arg, args[i]):
+                    hit = True
+                    args[i] = arg
+            if hit:
+                rv = self.func(*args)
+                hack2 = hints.get('hack2', False)
+                if hack2 and self.is_Mul and not rv.is_Mul:  # 2-arg hack
+                    coeff = S.One
+                    nonnumber = []
+                    for i in args:
+                        if i.is_Number:
+                            coeff *= i
+                        else:
+                            nonnumber.append(i)
+                    nonnumber = self.func(*nonnumber)
+                    if coeff is S.One:
+                        return nonnumber
+                    else:
+                        return self.func(coeff, nonnumber, evaluate=False)
+                return rv
+            return self
+
+        if _aresame(self, old):
+            return new
+
+        rv = self._eval_subs(old, new)
+        if rv is None:
+            rv = fallback(self, old, new)
+        return rv
+
+    def _eval_subs(self, old, new) -> Basic | None:
+        """Override this stub if you want to do anything more than
+        attempt a replacement of old with new in the arguments of self.
+
+        See also
+        ========
+
+        _subs
+        """
+        return None
+
+    def xreplace(self, rule):
+        """
+        Replace occurrences of objects within the expression.
+
+        Parameters
+        ==========
+
+        rule : dict-like
+            Expresses a replacement rule
+
+        Returns
+        =======
+
+        xreplace : the result of the replacement
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, pi, exp
+        >>> x, y, z = symbols('x y z')
+        >>> (1 + x*y).xreplace({x: pi})
+        pi*y + 1
+        >>> (1 + x*y).xreplace({x: pi, y: 2})
+        1 + 2*pi
+
+        Replacements occur only if an entire node in the expression tree is
+        matched:
+
+        >>> (x*y + z).xreplace({x*y: pi})
+        z + pi
+        >>> (x*y*z).xreplace({x*y: pi})
+        x*y*z
+        >>> (2*x).xreplace({2*x: y, x: z})
+        y
+        >>> (2*2*x).xreplace({2*x: y, x: z})
+        4*z
+        >>> (x + y + 2).xreplace({x + y: 2})
+        x + y + 2
+        >>> (x + 2 + exp(x + 2)).xreplace({x + 2: y})
+        x + exp(y) + 2
+
+        xreplace does not differentiate between free and bound symbols. In the
+        following, subs(x, y) would not change x since it is a bound symbol,
+        but xreplace does:
+
+        >>> from sympy import Integral
+        >>> Integral(x, (x, 1, 2*x)).xreplace({x: y})
+        Integral(y, (y, 1, 2*y))
+
+        Trying to replace x with an expression raises an error:
+
+        >>> Integral(x, (x, 1, 2*x)).xreplace({x: 2*y}) # doctest: +SKIP
+        ValueError: Invalid limits given: ((2*y, 1, 4*y),)
+
+        See Also
+        ========
+        replace: replacement capable of doing wildcard-like matching,
+                 parsing of match, and conditional replacements
+        subs: substitution of subexpressions as defined by the objects
+              themselves.
+
+        """
+        value, _ = self._xreplace(rule)
+        return value
+
+    def _xreplace(self, rule):
+        """
+        Helper for xreplace. Tracks whether a replacement actually occurred.
+        """
+        if self in rule:
+            return rule[self], True
+        elif rule:
+            args = []
+            changed = False
+            for a in self.args:
+                _xreplace = getattr(a, '_xreplace', None)
+                if _xreplace is not None:
+                    a_xr = _xreplace(rule)
+                    args.append(a_xr[0])
+                    changed |= a_xr[1]
+                else:
+                    args.append(a)
+            args = tuple(args)
+            if changed:
+                return self.func(*args), True
+        return self, False
+
+    @cacheit
+    def has(self, *patterns):
+        """
+        Test whether any subexpression matches any of the patterns.
+
+        Examples
+        ========
+
+        >>> from sympy import sin
+        >>> from sympy.abc import x, y, z
+        >>> (x**2 + sin(x*y)).has(z)
+        False
+        >>> (x**2 + sin(x*y)).has(x, y, z)
+        True
+        >>> x.has(x)
+        True
+
+        Note ``has`` is a structural algorithm with no knowledge of
+        mathematics. Consider the following half-open interval:
+
+        >>> from sympy import Interval
+        >>> i = Interval.Lopen(0, 5); i
+        Interval.Lopen(0, 5)
+        >>> i.args
+        (0, 5, True, False)
+        >>> i.has(4)  # there is no "4" in the arguments
+        False
+        >>> i.has(0)  # there *is* a "0" in the arguments
+        True
+
+        Instead, use ``contains`` to determine whether a number is in the
+        interval or not:
+
+        >>> i.contains(4)
+        True
+        >>> i.contains(0)
+        False
+
+
+        Note that ``expr.has(*patterns)`` is exactly equivalent to
+        ``any(expr.has(p) for p in patterns)``. In particular, ``False`` is
+        returned when the list of patterns is empty.
+
+        >>> x.has()
+        False
+
+        """
+        return self._has(iterargs, *patterns)
+
+    def has_xfree(self, s: set[Basic]):
+        """Return True if self has any of the patterns in s as a
+        free argument, else False. This is like `Basic.has_free`
+        but this will only report exact argument matches.
+
+        Examples
+        ========
+
+        >>> from sympy import Function
+        >>> from sympy.abc import x, y
+        >>> f = Function('f')
+        >>> f(x).has_xfree({f})
+        False
+        >>> f(x).has_xfree({f(x)})
+        True
+        >>> f(x + 1).has_xfree({x})
+        True
+        >>> f(x + 1).has_xfree({x + 1})
+        True
+        >>> f(x + y + 1).has_xfree({x + 1})
+        False
+        """
+        # protect O(1) containment check by requiring:
+        if type(s) is not set:
+            raise TypeError('expecting set argument')
+        return any(a in s for a in iterfreeargs(self))
+
+    @cacheit
+    def has_free(self, *patterns):
+        """Return True if self has object(s) ``x`` as a free expression
+        else False.
+
+        Examples
+        ========
+
+        >>> from sympy import Integral, Function
+        >>> from sympy.abc import x, y
+        >>> f = Function('f')
+        >>> g = Function('g')
+        >>> expr = Integral(f(x), (f(x), 1, g(y)))
+        >>> expr.free_symbols
+        {y}
+        >>> expr.has_free(g(y))
+        True
+        >>> expr.has_free(*(x, f(x)))
+        False
+
+        This works for subexpressions and types, too:
+
+        >>> expr.has_free(g)
+        True
+        >>> (x + y + 1).has_free(y + 1)
+        True
+        """
+        if not patterns:
+            return False
+        p0 = patterns[0]
+        if len(patterns) == 1 and iterable(p0) and not isinstance(p0, Basic):
+            # Basic can contain iterables (though not non-Basic, ideally)
+            # but don't encourage mixed passing patterns
+            raise TypeError(filldedent('''
+                Expecting 1 or more Basic args, not a single
+                non-Basic iterable. Don't forget to unpack
+                iterables: `eq.has_free(*patterns)`'''))
+        # try quick test first
+        s = set(patterns)
+        rv = self.has_xfree(s)
+        if rv:
+            return rv
+        # now try matching through slower _has
+        return self._has(iterfreeargs, *patterns)
+
+    def _has(self, iterargs, *patterns):
+        # separate out types and unhashable objects
+        type_set = set()  # only types
+        p_set = set()  # hashable non-types
+        for p in patterns:
+            if isinstance(p, type) and issubclass(p, Basic):
+                type_set.add(p)
+                continue
+            if not isinstance(p, Basic):
+                try:
+                    p = _sympify(p)
+                except SympifyError:
+                    continue  # Basic won't have this in it
+            p_set.add(p)  # fails if object defines __eq__ but
+                          # doesn't define __hash__
+        types = tuple(type_set)   #
+        for i in iterargs(self):  #
+            if i in p_set:        # <--- here, too
+                return True
+            if isinstance(i, types):
+                return True
+
+        # use matcher if defined, e.g. operations defines
+        # matcher that checks for exact subset containment,
+        # (x + y + 1).has(x + 1) -> True
+        for i in p_set - type_set:  # types don't have matchers
+            if not hasattr(i, '_has_matcher'):
+                continue
+            match = i._has_matcher()
+            if any(match(arg) for arg in iterargs(self)):
+                return True
+
+        # no success
+        return False
+
+    def replace(self, query, value, map=False, simultaneous=True, exact=None) -> Basic:
+        """
+        Replace matching subexpressions of ``self`` with ``value``.
+
+        If ``map = True`` then also return the mapping {old: new} where ``old``
+        was a sub-expression found with query and ``new`` is the replacement
+        value for it. If the expression itself does not match the query, then
+        the returned value will be ``self.xreplace(map)`` otherwise it should
+        be ``self.subs(ordered(map.items()))``.
+
+        Traverses an expression tree and performs replacement of matching
+        subexpressions from the bottom to the top of the tree. The default
+        approach is to do the replacement in a simultaneous fashion so
+        changes made are targeted only once. If this is not desired or causes
+        problems, ``simultaneous`` can be set to False.
+
+        In addition, if an expression containing more than one Wild symbol
+        is being used to match subexpressions and the ``exact`` flag is None
+        it will be set to True so the match will only succeed if all non-zero
+        values are received for each Wild that appears in the match pattern.
+        Setting this to False accepts a match of 0; while setting it True
+        accepts all matches that have a 0 in them. See example below for
+        cautions.
+
+        The list of possible combinations of queries and replacement values
+        is listed below:
+
+        Examples
+        ========
+
+        Initial setup
+
+        >>> from sympy import log, sin, cos, tan, Wild, Mul, Add
+        >>> from sympy.abc import x, y
+        >>> f = log(sin(x)) + tan(sin(x**2))
+
+        1.1. type -> type
+            obj.replace(type, newtype)
+
+            When object of type ``type`` is found, replace it with the
+            result of passing its argument(s) to ``newtype``.
+
+            >>> f.replace(sin, cos)
+            log(cos(x)) + tan(cos(x**2))
+            >>> sin(x).replace(sin, cos, map=True)
+            (cos(x), {sin(x): cos(x)})
+            >>> (x*y).replace(Mul, Add)
+            x + y
+
+        1.2. type -> func
+            obj.replace(type, func)
+
+            When object of type ``type`` is found, apply ``func`` to its
+            argument(s). ``func`` must be written to handle the number
+            of arguments of ``type``.
+
+            >>> f.replace(sin, lambda arg: sin(2*arg))
+            log(sin(2*x)) + tan(sin(2*x**2))
+            >>> (x*y).replace(Mul, lambda *args: sin(2*Mul(*args)))
+            sin(2*x*y)
+
+        2.1. pattern -> expr
+            obj.replace(pattern(wild), expr(wild))
+
+            Replace subexpressions matching ``pattern`` with the expression
+            written in terms of the Wild symbols in ``pattern``.
+
+            >>> a, b = map(Wild, 'ab')
+            >>> f.replace(sin(a), tan(a))
+            log(tan(x)) + tan(tan(x**2))
+            >>> f.replace(sin(a), tan(a/2))
+            log(tan(x/2)) + tan(tan(x**2/2))
+            >>> f.replace(sin(a), a)
+            log(x) + tan(x**2)
+            >>> (x*y).replace(a*x, a)
+            y
+
+            Matching is exact by default when more than one Wild symbol
+            is used: matching fails unless the match gives non-zero
+            values for all Wild symbols:
+
+            >>> (2*x + y).replace(a*x + b, b - a)
+            y - 2
+            >>> (2*x).replace(a*x + b, b - a)
+            2*x
+
+            When set to False, the results may be non-intuitive:
+
+            >>> (2*x).replace(a*x + b, b - a, exact=False)
+            2/x
+
+        2.2. pattern -> func
+            obj.replace(pattern(wild), lambda wild: expr(wild))
+
+            All behavior is the same as in 2.1 but now a function in terms of
+            pattern variables is used rather than an expression:
+
+            >>> f.replace(sin(a), lambda a: sin(2*a))
+            log(sin(2*x)) + tan(sin(2*x**2))
+
+        3.1. func -> func
+            obj.replace(filter, func)
+
+            Replace subexpression ``e`` with ``func(e)`` if ``filter(e)``
+            is True.
+
+            >>> g = 2*sin(x**3)
+            >>> g.replace(lambda expr: expr.is_Number, lambda expr: expr**2)
+            4*sin(x**9)
+
+        The expression itself is also targeted by the query but is done in
+        such a fashion that changes are not made twice.
+
+            >>> e = x*(x*y + 1)
+            >>> e.replace(lambda x: x.is_Mul, lambda x: 2*x)
+            2*x*(2*x*y + 1)
+
+        When matching a single symbol, `exact` will default to True, but
+        this may or may not be the behavior that is desired:
+
+        Here, we want `exact=False`:
+
+        >>> from sympy import Function
+        >>> f = Function('f')
+        >>> e = f(1) + f(0)
+        >>> q = f(a), lambda a: f(a + 1)
+        >>> e.replace(*q, exact=False)
+        f(1) + f(2)
+        >>> e.replace(*q, exact=True)
+        f(0) + f(2)
+
+        But here, the nature of matching makes selecting
+        the right setting tricky:
+
+        >>> e = x**(1 + y)
+        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=False)
+        x
+        >>> (x**(1 + y)).replace(x**(1 + a), lambda a: x**-a, exact=True)
+        x**(-x - y + 1)
+        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=False)
+        x
+        >>> (x**y).replace(x**(1 + a), lambda a: x**-a, exact=True)
+        x**(1 - y)
+
+        It is probably better to use a different form of the query
+        that describes the target expression more precisely:
+
+        >>> (1 + x**(1 + y)).replace(
+        ... lambda x: x.is_Pow and x.exp.is_Add and x.exp.args[0] == 1,
+        ... lambda x: x.base**(1 - (x.exp - 1)))
+        ...
+        x**(1 - y) + 1
+
+        See Also
+        ========
+
+        subs: substitution of subexpressions as defined by the objects
+              themselves.
+        xreplace: exact node replacement in expr tree; also capable of
+                  using matching rules
+
+        """
+
+        try:
+            query = _sympify(query)
+        except SympifyError:
+            pass
+        try:
+            value = _sympify(value)
+        except SympifyError:
+            pass
+        if isinstance(query, type):
+            _query = lambda expr: isinstance(expr, query)
+
+            if isinstance(value, type):
+                _value = lambda expr, result: value(*expr.args)
+            elif callable(value):
+                _value = lambda expr, result: value(*expr.args)
+            else:
+                raise TypeError(
+                    "given a type, replace() expects another "
+                    "type or a callable")
+        elif isinstance(query, Basic):
+            _query = lambda expr: expr.match(query)
+            if exact is None:
+                from .symbol import Wild
+                exact = (len(query.atoms(Wild)) > 1)
+
+            if isinstance(value, Basic):
+                if exact:
+                    _value = lambda expr, result: (value.subs(result)
+                        if all(result.values()) else expr)
+                else:
+                    _value = lambda expr, result: value.subs(result)
+            elif callable(value):
+                # match dictionary keys get the trailing underscore stripped
+                # from them and are then passed as keywords to the callable;
+                # if ``exact`` is True, only accept match if there are no null
+                # values amongst those matched.
+                if exact:
+                    _value = lambda expr, result: (value(**
+                        {str(k)[:-1]: v for k, v in result.items()})
+                        if all(val for val in result.values()) else expr)
+                else:
+                    _value = lambda expr, result: value(**
+                        {str(k)[:-1]: v for k, v in result.items()})
+            else:
+                raise TypeError(
+                    "given an expression, replace() expects "
+                    "another expression or a callable")
+        elif callable(query):
+            _query = query
+
+            if callable(value):
+                _value = lambda expr, result: value(expr)
+            else:
+                raise TypeError(
+                    "given a callable, replace() expects "
+                    "another callable")
+        else:
+            raise TypeError(
+                "first argument to replace() must be a "
+                "type, an expression or a callable")
+
+        def walk(rv, F):
+            """Apply ``F`` to args and then to result.
+            """
+            args = getattr(rv, 'args', None)
+            if args is not None:
+                if args:
+                    newargs = tuple([walk(a, F) for a in args])
+                    if args != newargs:
+                        rv = rv.func(*newargs)
+                        if simultaneous:
+                            # if rv is something that was already
+                            # matched (that was changed) then skip
+                            # applying F again
+                            for i, e in enumerate(args):
+                                if rv == e and e != newargs[i]:
+                                    return rv
+                rv = F(rv)
+            return rv
+
+        mapping = {}  # changes that took place
+
+        def rec_replace(expr):
+            result = _query(expr)
+            if result or result == {}:
+                v = _value(expr, result)
+                if v is not None and v != expr:
+                    if map:
+                        mapping[expr] = v
+                    expr = v
+            return expr
+
+        rv = walk(self, rec_replace)
+        return (rv, mapping) if map else rv # type: ignore
+
+    def find(self, query, group=False):
+        """Find all subexpressions matching a query."""
+        query = _make_find_query(query)
+        results = list(filter(query, _preorder_traversal(self)))
+
+        if not group:
+            return set(results)
+        return dict(Counter(results))
+
+    def count(self, query):
+        """Count the number of matching subexpressions."""
+        query = _make_find_query(query)
+        return sum(bool(query(sub)) for sub in _preorder_traversal(self))
+
+    def matches(self, expr, repl_dict=None, old=False):
+        """
+        Helper method for match() that looks for a match between Wild symbols
+        in self and expressions in expr.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Wild, Basic
+        >>> a, b, c = symbols('a b c')
+        >>> x = Wild('x')
+        >>> Basic(a + x, x).matches(Basic(a + b, c)) is None
+        True
+        >>> Basic(a + x, x).matches(Basic(a + b + c, b + c))
+        {x_: b + c}
+        """
+        expr = sympify(expr)
+        if not isinstance(expr, self.__class__):
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+
+        if self == expr:
+            return repl_dict
+
+        if len(self.args) != len(expr.args):
+            return None
+
+        d = repl_dict  # already a copy
+        for arg, other_arg in zip(self.args, expr.args):
+            if arg == other_arg:
+                continue
+            if arg.is_Relational:
+                try:
+                    d = arg.xreplace(d).matches(other_arg, d, old=old)
+                except TypeError: # Should be InvalidComparisonError when introduced
+                    d = None
+            else:
+                    d = arg.xreplace(d).matches(other_arg, d, old=old)
+            if d is None:
+                return None
+        return d
+
+    def match(self, pattern, old=False):
+        """
+        Pattern matching.
+
+        Wild symbols match all.
+
+        Return ``None`` when expression (self) does not match with pattern.
+        Otherwise return a dictionary such that::
+
+          pattern.xreplace(self.match(pattern)) == self
+
+        Examples
+        ========
+
+        >>> from sympy import Wild, Sum
+        >>> from sympy.abc import x, y
+        >>> p = Wild("p")
+        >>> q = Wild("q")
+        >>> r = Wild("r")
+        >>> e = (x+y)**(x+y)
+        >>> e.match(p**p)
+        {p_: x + y}
+        >>> e.match(p**q)
+        {p_: x + y, q_: x + y}
+        >>> e = (2*x)**2
+        >>> e.match(p*q**r)
+        {p_: 4, q_: x, r_: 2}
+        >>> (p*q**r).xreplace(e.match(p*q**r))
+        4*x**2
+
+        Since match is purely structural expressions that are equivalent up to
+        bound symbols will not match:
+
+        >>> print(Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, p))))
+        None
+
+        An expression with bound symbols can be matched if the pattern uses
+        a distinct ``Wild`` for each bound symbol:
+
+        >>> Sum(x, (x, 1, 2)).match(Sum(q, (q, 1, p)))
+        {p_: 2, q_: x}
+
+        The ``old`` flag will give the old-style pattern matching where
+        expressions and patterns are essentially solved to give the match. Both
+        of the following give None unless ``old=True``:
+
+        >>> (x - 2).match(p - x, old=True)
+        {p_: 2*x - 2}
+        >>> (2/x).match(p*x, old=True)
+        {p_: 2/x**2}
+
+        See Also
+        ========
+
+        matches: pattern.matches(expr) is the same as expr.match(pattern)
+        xreplace: exact structural replacement
+        replace: structural replacement with pattern matching
+        Wild: symbolic placeholders for expressions in pattern matching
+        """
+        pattern = sympify(pattern)
+        return pattern.matches(self, old=old)
+
+    def count_ops(self, visual=False):
+        """Wrapper for count_ops that returns the operation count."""
+        from .function import count_ops
+        return count_ops(self, visual)
+
+    def doit(self, **hints):
+        """Evaluate objects that are not evaluated by default like limits,
+        integrals, sums and products. All objects of this kind will be
+        evaluated recursively, unless some species were excluded via 'hints'
+        or unless the 'deep' hint was set to 'False'.
+
+        >>> from sympy import Integral
+        >>> from sympy.abc import x
+
+        >>> 2*Integral(x, x)
+        2*Integral(x, x)
+
+        >>> (2*Integral(x, x)).doit()
+        x**2
+
+        >>> (2*Integral(x, x)).doit(deep=False)
+        2*Integral(x, x)
+
+        """
+        if hints.get('deep', True):
+            terms = [term.doit(**hints) if isinstance(term, Basic) else term
+                                         for term in self.args]
+            return self.func(*terms)
+        else:
+            return self
+
+    def simplify(self, **kwargs) -> Basic:
+        """See the simplify function in sympy.simplify"""
+        from sympy.simplify.simplify import simplify
+        return simplify(self, **kwargs)
+
+    def refine(self, assumption=True):
+        """See the refine function in sympy.assumptions"""
+        from sympy.assumptions.refine import refine
+        return refine(self, assumption)
+
+    def _eval_derivative_n_times(self, s, n):
+        # This is the default evaluator for derivatives (as called by `diff`
+        # and `Derivative`), it will attempt a loop to derive the expression
+        # `n` times by calling the corresponding `_eval_derivative` method,
+        # while leaving the derivative unevaluated if `n` is symbolic.  This
+        # method should be overridden if the object has a closed form for its
+        # symbolic n-th derivative.
+        from .numbers import Integer
+        if isinstance(n, (int, Integer)):
+            obj = self
+            for i in range(n):
+                prev = obj
+                obj = obj._eval_derivative(s)
+                if obj is None:
+                    return None
+                elif obj == prev:
+                    break
+            return obj
+        else:
+            return None
+
+    def rewrite(self, *args, deep=True, **hints):
+        """
+        Rewrite *self* using a defined rule.
+
+        Rewriting transforms an expression to another, which is mathematically
+        equivalent but structurally different. For example you can rewrite
+        trigonometric functions as complex exponentials or combinatorial
+        functions as gamma function.
+
+        This method takes a *pattern* and a *rule* as positional arguments.
+        *pattern* is optional parameter which defines the types of expressions
+        that will be transformed. If it is not passed, all possible expressions
+        will be rewritten. *rule* defines how the expression will be rewritten.
+
+        Parameters
+        ==========
+
+        args : Expr
+            A *rule*, or *pattern* and *rule*.
+            - *pattern* is a type or an iterable of types.
+            - *rule* can be any object.
+
+        deep : bool, optional
+            If ``True``, subexpressions are recursively transformed. Default is
+            ``True``.
+
+        Examples
+        ========
+
+        If *pattern* is unspecified, all possible expressions are transformed.
+
+        >>> from sympy import cos, sin, exp, I
+        >>> from sympy.abc import x
+        >>> expr = cos(x) + I*sin(x)
+        >>> expr.rewrite(exp)
+        exp(I*x)
+
+        Pattern can be a type or an iterable of types.
+
+        >>> expr.rewrite(sin, exp)
+        exp(I*x)/2 + cos(x) - exp(-I*x)/2
+        >>> expr.rewrite([cos,], exp)
+        exp(I*x)/2 + I*sin(x) + exp(-I*x)/2
+        >>> expr.rewrite([cos, sin], exp)
+        exp(I*x)
+
+        Rewriting behavior can be implemented by defining ``_eval_rewrite()``
+        method.
+
+        >>> from sympy import Expr, sqrt, pi
+        >>> class MySin(Expr):
+        ...     def _eval_rewrite(self, rule, args, **hints):
+        ...         x, = args
+        ...         if rule == cos:
+        ...             return cos(pi/2 - x, evaluate=False)
+        ...         if rule == sqrt:
+        ...             return sqrt(1 - cos(x)**2)
+        >>> MySin(MySin(x)).rewrite(cos)
+        cos(-cos(-x + pi/2) + pi/2)
+        >>> MySin(x).rewrite(sqrt)
+        sqrt(1 - cos(x)**2)
+
+        Defining ``_eval_rewrite_as_[...]()`` method is supported for backwards
+        compatibility reason. This may be removed in the future and using it is
+        discouraged.
+
+        >>> class MySin(Expr):
+        ...     def _eval_rewrite_as_cos(self, *args, **hints):
+        ...         x, = args
+        ...         return cos(pi/2 - x, evaluate=False)
+        >>> MySin(x).rewrite(cos)
+        cos(-x + pi/2)
+
+        """
+        if not args:
+            return self
+
+        hints.update(deep=deep)
+
+        pattern = args[:-1]
+        rule = args[-1]
+
+        # Special case: map `abs` to `Abs`
+        if rule is abs:
+            from sympy.functions.elementary.complexes import Abs
+            rule = Abs
+
+        # support old design by _eval_rewrite_as_[...] method
+        if isinstance(rule, str):
+            method = "_eval_rewrite_as_%s" % rule
+        elif hasattr(rule, "__name__"):
+            # rule is class or function
+            clsname = rule.__name__
+            method = "_eval_rewrite_as_%s" % clsname
+        else:
+            # rule is instance
+            clsname = rule.__class__.__name__
+            method = "_eval_rewrite_as_%s" % clsname
+
+        if pattern:
+            if iterable(pattern[0]):
+                pattern = pattern[0]
+            pattern = tuple(p for p in pattern if self.has(p))
+            if not pattern:
+                return self
+        # hereafter, empty pattern is interpreted as all pattern.
+
+        return self._rewrite(pattern, rule, method, **hints)
+
+    def _rewrite(self, pattern, rule, method, **hints):
+        deep = hints.pop('deep', True)
+        if deep:
+            args = [a._rewrite(pattern, rule, method, **hints)
+                    for a in self.args]
+        else:
+            args = self.args
+        if not pattern or any(isinstance(self, p) for p in pattern):
+            meth = getattr(self, method, None)
+            if meth is not None:
+                rewritten = meth(*args, **hints)
+            else:
+                rewritten = self._eval_rewrite(rule, args, **hints)
+            if rewritten is not None:
+                return rewritten
+        if not args:
+            return self
+        return self.func(*args)
+
+    def _eval_rewrite(self, rule, args, **hints):
+        return None
+
+    _constructor_postprocessor_mapping = {}  # type: ignore
+
+    @classmethod
+    def _exec_constructor_postprocessors(cls, obj):
+        # WARNING: This API is experimental.
+
+        # This is an experimental API that introduces constructor
+        # postprosessors for SymPy Core elements. If an argument of a SymPy
+        # expression has a `_constructor_postprocessor_mapping` attribute, it will
+        # be interpreted as a dictionary containing lists of postprocessing
+        # functions for matching expression node names.
+
+        clsname = obj.__class__.__name__
+        postprocessors = {f for i in obj.args
+                            for f in _get_postprocessors(clsname, type(i))}
+        for f in postprocessors:
+            obj = f(obj)
+
+        return obj
+
+    def _sage_(self):
+        """
+        Convert *self* to a symbolic expression of SageMath.
+
+        This version of the method is merely a placeholder.
+        """
+        old_method = self._sage_
+        from sage.interfaces.sympy import sympy_init # type: ignore
+        sympy_init()  # may monkey-patch _sage_ method into self's class or superclasses
+        if old_method == self._sage_:
+            raise NotImplementedError('conversion to SageMath is not implemented')
+        else:
+            # call the freshly monkey-patched method
+            return self._sage_()
+
+    def could_extract_minus_sign(self) -> bool:
+        return False  # see Expr.could_extract_minus_sign
+
+    def is_same(a, b, approx=None):
+        """Return True if a and b are structurally the same, else False.
+        If `approx` is supplied, it will be used to test whether two
+        numbers are the same or not. By default, only numbers of the
+        same type will compare equal, so S.Half != Float(0.5).
+
+        Examples
+        ========
+
+        In SymPy (unlike Python) two numbers do not compare the same if they are
+        not of the same type:
+
+        >>> from sympy import S
+        >>> 2.0 == S(2)
+        False
+        >>> 0.5 == S.Half
+        False
+
+        By supplying a function with which to compare two numbers, such
+        differences can be ignored. e.g. `equal_valued` will return True
+        for decimal numbers having a denominator that is a power of 2,
+        regardless of precision.
+
+        >>> from sympy import Float
+        >>> from sympy.core.numbers import equal_valued
+        >>> (S.Half/4).is_same(Float(0.125, 1), equal_valued)
+        True
+        >>> Float(1, 2).is_same(Float(1, 10), equal_valued)
+        True
+
+        But decimals without a power of 2 denominator will compare
+        as not being the same.
+
+        >>> Float(0.1, 9).is_same(Float(0.1, 10), equal_valued)
+        False
+
+        But arbitrary differences can be ignored by supplying a function
+        to test the equivalence of two numbers:
+
+        >>> import math
+        >>> Float(0.1, 9).is_same(Float(0.1, 10), math.isclose)
+        True
+
+        Other objects might compare the same even though types are not the
+        same. This routine will only return True if two expressions are
+        identical in terms of class types.
+
+        >>> from sympy import eye, Basic
+        >>> eye(1) == S(eye(1))  # mutable vs immutable
+        True
+        >>> Basic.is_same(eye(1), S(eye(1)))
+        False
+
+        """
+        from .numbers import Number
+        from .traversal import postorder_traversal as pot
+        for t in zip_longest(pot(a), pot(b)):
+            if None in t:
+                return False
+            a, b = t
+            if isinstance(a, Number):
+                if not isinstance(b, Number):
+                    return False
+                if approx:
+                    return approx(a, b)
+            if not (a == b and a.__class__ == b.__class__):
+                return False
+        return True
+
+_aresame = Basic.is_same  # for sake of others importing this
+
+# key used by Mul and Add to make canonical args
+_args_sortkey = cmp_to_key(Basic.compare)
+
+# For all Basic subclasses _prepare_class_assumptions is called by
+# Basic.__init_subclass__ but that method is not called for Basic itself so we
+# call the function here instead.
+_prepare_class_assumptions(Basic)
+
+
+class Atom(Basic):
+    """
+    A parent class for atomic things. An atom is an expression with no subexpressions.
+
+    Examples
+    ========
+
+    Symbol, Number, Rational, Integer, ...
+    But not: Add, Mul, Pow, ...
+    """
+
+    is_Atom = True
+
+    __slots__ = ()
+
+    def matches(self, expr, repl_dict=None, old=False):
+        if self == expr:
+            if repl_dict is None:
+                return {}
+            return repl_dict.copy()
+
+    def xreplace(self, rule, hack2=False):
+        return rule.get(self, self)
+
+    def doit(self, **hints):
+        return self
+
+    @classmethod
+    def class_key(cls):
+        return 2, 0, cls.__name__
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (1, (str(self),)), S.One.sort_key(), S.One
+
+    def _eval_simplify(self, **kwargs):
+        return self
+
+    @property
+    def _sorted_args(self):
+        # this is here as a safeguard against accidentally using _sorted_args
+        # on Atoms -- they cannot be rebuilt as atom.func(*atom._sorted_args)
+        # since there are no args. So the calling routine should be checking
+        # to see that this property is not called for Atoms.
+        raise AttributeError('Atoms have no args. It might be necessary'
+        ' to make a check for Atoms in the calling code.')
+
+
+def _atomic(e, recursive=False):
+    """Return atom-like quantities as far as substitution is
+    concerned: Derivatives, Functions and Symbols. Do not
+    return any 'atoms' that are inside such quantities unless
+    they also appear outside, too, unless `recursive` is True.
+
+    Examples
+    ========
+
+    >>> from sympy import Derivative, Function, cos
+    >>> from sympy.abc import x, y
+    >>> from sympy.core.basic import _atomic
+    >>> f = Function('f')
+    >>> _atomic(x + y)
+    {x, y}
+    >>> _atomic(x + f(y))
+    {x, f(y)}
+    >>> _atomic(Derivative(f(x), x) + cos(x) + y)
+    {y, cos(x), Derivative(f(x), x)}
+
+    """
+    pot = _preorder_traversal(e)
+    seen = set()
+    if isinstance(e, Basic):
+        free = getattr(e, "free_symbols", None)
+        if free is None:
+            return {e}
+    else:
+        return set()
+    from .symbol import Symbol
+    from .function import Derivative, Function
+    atoms = set()
+    for p in pot:
+        if p in seen:
+            pot.skip()
+            continue
+        seen.add(p)
+        if isinstance(p, Symbol) and p in free:
+            atoms.add(p)
+        elif isinstance(p, (Derivative, Function)):
+            if not recursive:
+                pot.skip()
+            atoms.add(p)
+    return atoms
+
+
+def _make_find_query(query):
+    """Convert the argument of Basic.find() into a callable"""
+    try:
+        query = _sympify(query)
+    except SympifyError:
+        pass
+    if isinstance(query, type):
+        return lambda expr: isinstance(expr, query)
+    elif isinstance(query, Basic):
+        return lambda expr: expr.match(query) is not None
+    return query
+
+# Delayed to avoid cyclic import
+from .singleton import S
+from .traversal import (preorder_traversal as _preorder_traversal,
+   iterargs, iterfreeargs)
+
+preorder_traversal = deprecated(
+    """
+    Using preorder_traversal from the sympy.core.basic submodule is
+    deprecated.
+
+    Instead, use preorder_traversal from the top-level sympy namespace, like
+
+        sympy.preorder_traversal
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="deprecated-traversal-functions-moved",
+)(_preorder_traversal)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__init__.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee87614a9c145acf5fb5b10793945085401fe08e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_arit.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_arit.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09c4a83ffd1afd74fd9acc27f8664119d6d4b7a7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_arit.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_assumptions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_assumptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2a71e1ff2895bf8cdf2d107250df42987ec99fa1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_assumptions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_basic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_basic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f215c0654d08901e61fc5b034a205845a597f78b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_basic.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_expand.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_expand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..968935e35abbc69df8cdb250c59dd0df1e0d5ec7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_expand.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..400702bdfd77e6d4af5f8465fda78e230df8e6bf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_numbers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_sympify.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_sympify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bade536f56463edb47955af61eda2c65ae00084a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/__pycache__/bench_sympify.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_arit.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_arit.py
new file mode 100644
index 0000000000000000000000000000000000000000..39860943b763a30cf4f91578dbac37dc7e6e444e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_arit.py
@@ -0,0 +1,43 @@
+from sympy.core import Add, Mul, symbols
+
+x, y, z = symbols('x,y,z')
+
+
+def timeit_neg():
+    -x
+
+
+def timeit_Add_x1():
+    x + 1
+
+
+def timeit_Add_1x():
+    1 + x
+
+
+def timeit_Add_x05():
+    x + 0.5
+
+
+def timeit_Add_xy():
+    x + y
+
+
+def timeit_Add_xyz():
+    Add(*[x, y, z])
+
+
+def timeit_Mul_xy():
+    x*y
+
+
+def timeit_Mul_xyz():
+    Mul(*[x, y, z])
+
+
+def timeit_Div_xy():
+    x/y
+
+
+def timeit_Div_2y():
+    2/y
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_assumptions.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_assumptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..1a8e47928b76034dd1d7ba8b8f87bd527bb1cdeb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_assumptions.py
@@ -0,0 +1,12 @@
+from sympy.core import Symbol, Integer
+
+x = Symbol('x')
+i3 = Integer(3)
+
+
+def timeit_x_is_integer():
+    x.is_integer
+
+
+def timeit_Integer_is_irrational():
+    i3.is_irrational
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_basic.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_basic.py
new file mode 100644
index 0000000000000000000000000000000000000000..df2a382ecbd3cf6eb1f8555577dabb5e07c6643b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_basic.py
@@ -0,0 +1,15 @@
+from sympy.core import symbols, S
+
+x, y = symbols('x,y')
+
+
+def timeit_Symbol_meth_lookup():
+    x.diff  # no call, just method lookup
+
+
+def timeit_S_lookup():
+    S.Exp1
+
+
+def timeit_Symbol_eq_xy():
+    x == y
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_expand.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_expand.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f5ac513e368cb7e9b542926bc25a5695de6d914
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_expand.py
@@ -0,0 +1,23 @@
+from sympy.core import symbols, I
+
+x, y, z = symbols('x,y,z')
+
+p = 3*x**2*y*z**7 + 7*x*y*z**2 + 4*x + x*y**4
+e = (x + y + z + 1)**32
+
+
+def timeit_expand_nothing_todo():
+    p.expand()
+
+
+def bench_expand_32():
+    """(x+y+z+1)**32  -> expand"""
+    e.expand()
+
+
+def timeit_expand_complex_number_1():
+    ((2 + 3*I)**1000).expand(complex=True)
+
+
+def timeit_expand_complex_number_2():
+    ((2 + 3*I/4)**1000).expand(complex=True)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_numbers.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c7484c389232b3622fb4b6724e4ab8534dde382
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_numbers.py
@@ -0,0 +1,92 @@
+from sympy.core.numbers import Integer, Rational, pi, oo
+from sympy.core.intfunc import integer_nthroot, igcd
+from sympy.core.singleton import S
+
+i3 = Integer(3)
+i4 = Integer(4)
+r34 = Rational(3, 4)
+q45 = Rational(4, 5)
+
+
+def timeit_Integer_create():
+    Integer(2)
+
+
+def timeit_Integer_int():
+    int(i3)
+
+
+def timeit_neg_one():
+    -S.One
+
+
+def timeit_Integer_neg():
+    -i3
+
+
+def timeit_Integer_abs():
+    abs(i3)
+
+
+def timeit_Integer_sub():
+    i3 - i3
+
+
+def timeit_abs_pi():
+    abs(pi)
+
+
+def timeit_neg_oo():
+    -oo
+
+
+def timeit_Integer_add_i1():
+    i3 + 1
+
+
+def timeit_Integer_add_ij():
+    i3 + i4
+
+
+def timeit_Integer_add_Rational():
+    i3 + r34
+
+
+def timeit_Integer_mul_i4():
+    i3*4
+
+
+def timeit_Integer_mul_ij():
+    i3*i4
+
+
+def timeit_Integer_mul_Rational():
+    i3*r34
+
+
+def timeit_Integer_eq_i3():
+    i3 == 3
+
+
+def timeit_Integer_ed_Rational():
+    i3 == r34
+
+
+def timeit_integer_nthroot():
+    integer_nthroot(100, 2)
+
+
+def timeit_number_igcd_23_17():
+    igcd(23, 17)
+
+
+def timeit_number_igcd_60_3600():
+    igcd(60, 3600)
+
+
+def timeit_Rational_add_r1():
+    r34 + 1
+
+
+def timeit_Rational_add_rq():
+    r34 + q45
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_sympify.py b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_sympify.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8cc0abc1e35439a1a495454abf87769d5b40d04
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/benchmarks/bench_sympify.py
@@ -0,0 +1,11 @@
+from sympy.core import sympify, Symbol
+
+x = Symbol('x')
+
+
+def timeit_sympify_1():
+    sympify(1)
+
+
+def timeit_sympify_x():
+    sympify(x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/cache.py b/.venv/lib/python3.12/site-packages/sympy/core/cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec11600a5e40ad446a6e5dde8820d46ea915b06a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/cache.py
@@ -0,0 +1,210 @@
+""" Caching facility for SymPy """
+from importlib import import_module
+from typing import Callable
+
+class _cache(list):
+    """ List of cached functions """
+
+    def print_cache(self):
+        """print cache info"""
+
+        for item in self:
+            name = item.__name__
+            myfunc = item
+            while hasattr(myfunc, '__wrapped__'):
+                if hasattr(myfunc, 'cache_info'):
+                    info = myfunc.cache_info()
+                    break
+                else:
+                    myfunc = myfunc.__wrapped__
+            else:
+                info = None
+
+            print(name, info)
+
+    def clear_cache(self):
+        """clear cache content"""
+        for item in self:
+            myfunc = item
+            while hasattr(myfunc, '__wrapped__'):
+                if hasattr(myfunc, 'cache_clear'):
+                    myfunc.cache_clear()
+                    break
+                else:
+                    myfunc = myfunc.__wrapped__
+
+
+# global cache registry:
+CACHE = _cache()
+# make clear and print methods available
+print_cache = CACHE.print_cache
+clear_cache = CACHE.clear_cache
+
+from functools import lru_cache, wraps
+
+def __cacheit(maxsize):
+    """caching decorator.
+
+        important: the result of cached function must be *immutable*
+
+
+        Examples
+        ========
+
+        >>> from sympy import cacheit
+        >>> @cacheit
+        ... def f(a, b):
+        ...    return a+b
+
+        >>> @cacheit
+        ... def f(a, b): # noqa: F811
+        ...    return [a, b] # <-- WRONG, returns mutable object
+
+        to force cacheit to check returned results mutability and consistency,
+        set environment variable SYMPY_USE_CACHE to 'debug'
+    """
+    def func_wrapper(func):
+        cfunc = lru_cache(maxsize, typed=True)(func)
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            try:
+                retval = cfunc(*args, **kwargs)
+            except TypeError as e:
+                if not e.args or not e.args[0].startswith('unhashable type:'):
+                    raise
+                retval = func(*args, **kwargs)
+            return retval
+
+        wrapper.cache_info = cfunc.cache_info
+        wrapper.cache_clear = cfunc.cache_clear
+
+        CACHE.append(wrapper)
+        return wrapper
+
+    return func_wrapper
+########################################
+
+
+def __cacheit_nocache(func):
+    return func
+
+
+def __cacheit_debug(maxsize):
+    """cacheit + code to check cache consistency"""
+    def func_wrapper(func):
+        cfunc = __cacheit(maxsize)(func)
+
+        @wraps(func)
+        def wrapper(*args, **kw_args):
+            # always call function itself and compare it with cached version
+            r1 = func(*args, **kw_args)
+            r2 = cfunc(*args, **kw_args)
+
+            # try to see if the result is immutable
+            #
+            # this works because:
+            #
+            # hash([1,2,3])         -> raise TypeError
+            # hash({'a':1, 'b':2})  -> raise TypeError
+            # hash((1,[2,3]))       -> raise TypeError
+            #
+            # hash((1,2,3))         -> just computes the hash
+            hash(r1), hash(r2)
+
+            # also see if returned values are the same
+            if r1 != r2:
+                raise RuntimeError("Returned values are not the same")
+            return r1
+        return wrapper
+    return func_wrapper
+
+
+def _getenv(key, default=None):
+    from os import getenv
+    return getenv(key, default)
+
+# SYMPY_USE_CACHE=yes/no/debug
+USE_CACHE = _getenv('SYMPY_USE_CACHE', 'yes').lower()
+# SYMPY_CACHE_SIZE=some_integer/None
+# special cases :
+#  SYMPY_CACHE_SIZE=0    -> No caching
+#  SYMPY_CACHE_SIZE=None -> Unbounded caching
+scs = _getenv('SYMPY_CACHE_SIZE', '1000')
+if scs.lower() == 'none':
+    SYMPY_CACHE_SIZE = None
+else:
+    try:
+        SYMPY_CACHE_SIZE = int(scs)
+    except ValueError:
+        raise RuntimeError(
+            'SYMPY_CACHE_SIZE must be a valid integer or None. ' + \
+            'Got: %s' % SYMPY_CACHE_SIZE)
+
+if USE_CACHE == 'no':
+    cacheit = __cacheit_nocache
+elif USE_CACHE == 'yes':
+    cacheit = __cacheit(SYMPY_CACHE_SIZE)
+elif USE_CACHE == 'debug':
+    cacheit = __cacheit_debug(SYMPY_CACHE_SIZE)   # a lot slower
+else:
+    raise RuntimeError(
+        'unrecognized value for SYMPY_USE_CACHE: %s' % USE_CACHE)
+
+
+def cached_property(func):
+    '''Decorator to cache property method'''
+    attrname = '__' + func.__name__
+    _cached_property_sentinel = object()
+    def propfunc(self):
+        val = getattr(self, attrname, _cached_property_sentinel)
+        if val is _cached_property_sentinel:
+            val = func(self)
+            setattr(self, attrname, val)
+        return val
+    return property(propfunc)
+
+
+def lazy_function(module : str, name : str) -> Callable:
+    """Create a lazy proxy for a function in a module.
+
+    The module containing the function is not imported until the function is used.
+
+    """
+    func = None
+
+    def _get_function():
+        nonlocal func
+        if func is None:
+            func = getattr(import_module(module), name)
+        return func
+
+    # The metaclass is needed so that help() shows the docstring
+    class LazyFunctionMeta(type):
+        @property
+        def __doc__(self):
+            docstring = _get_function().__doc__
+            docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
+            return docstring
+
+    class LazyFunction(metaclass=LazyFunctionMeta):
+        def __call__(self, *args, **kwargs):
+            # inline get of function for performance gh-23832
+            nonlocal func
+            if func is None:
+                func = getattr(import_module(module), name)
+            return func(*args, **kwargs)
+
+        @property
+        def __doc__(self):
+            docstring = _get_function().__doc__
+            docstring += f"\n\nNote: this is a {self.__class__.__name__} wrapper of '{module}.{name}'"
+            return docstring
+
+        def __str__(self):
+            return _get_function().__str__()
+
+        def __repr__(self):
+            return f"<{__class__.__name__} object at 0x{id(self):x}>: wrapping '{module}.{name}'"
+
+    return LazyFunction()
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/compatibility.py b/.venv/lib/python3.12/site-packages/sympy/core/compatibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..637a2698dbb39a042d3d664404bb0a4cba7fd004
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/compatibility.py
@@ -0,0 +1,35 @@
+"""
+.. deprecated:: 1.10
+
+   ``sympy.core.compatibility`` is deprecated. See
+   :ref:`sympy-core-compatibility`.
+
+Reimplementations of constructs introduced in later versions of Python than
+we support. Also some functions that are needed SymPy-wide and are located
+here for easy import.
+
+"""
+
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning("""
+The sympy.core.compatibility submodule is deprecated.
+
+This module was only ever intended for internal use. Some of the functions
+that were in this module are available from the top-level SymPy namespace,
+i.e.,
+
+    from sympy import ordered, default_sort_key
+
+The remaining were only intended for internal SymPy use and should not be used
+by user code.
+""",
+                          deprecated_since_version="1.10",
+                          active_deprecations_target="deprecated-sympy-core-compatibility",
+                          )
+
+
+from .sorting import ordered, _nodes, default_sort_key # noqa:F401
+from sympy.utilities.misc import as_int as _as_int # noqa:F401
+from sympy.utilities.iterables import iterable, is_sequence, NotIterable # noqa:F401
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/containers.py b/.venv/lib/python3.12/site-packages/sympy/core/containers.py
new file mode 100644
index 0000000000000000000000000000000000000000..35352009e87f3a7809a53031080cefdadb6528be
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/containers.py
@@ -0,0 +1,415 @@
+"""Module for SymPy containers
+
+    (SymPy objects that store other SymPy objects)
+
+    The containers implemented in this module are subclassed to Basic.
+    They are supposed to work seamlessly within the SymPy framework.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from collections.abc import MutableSet
+from typing import Any, Callable
+
+from .basic import Basic
+from .sorting import default_sort_key, ordered
+from .sympify import _sympify, sympify, _sympy_converter, SympifyError
+from sympy.core.kind import Kind
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+class Tuple(Basic):
+    """
+    Wrapper around the builtin tuple object.
+
+    Explanation
+    ===========
+
+    The Tuple is a subclass of Basic, so that it works well in the
+    SymPy framework.  The wrapped tuple is available as self.args, but
+    you can also access elements or slices with [:] syntax.
+
+    Parameters
+    ==========
+
+    sympify : bool
+        If ``False``, ``sympify`` is not called on ``args``. This
+        can be used for speedups for very large tuples where the
+        elements are known to already be SymPy objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Tuple, symbols
+    >>> a, b, c, d = symbols('a b c d')
+    >>> Tuple(a, b, c)[1:]
+    (b, c)
+    >>> Tuple(a, b, c).subs(a, d)
+    (d, b, c)
+
+    """
+
+    def __new__(cls, *args, **kwargs):
+        if kwargs.get('sympify', True):
+            args = (sympify(arg) for arg in args)
+        obj = Basic.__new__(cls, *args)
+        return obj
+
+    def __getitem__(self, i):
+        if isinstance(i, slice):
+            indices = i.indices(len(self))
+            return Tuple(*(self.args[j] for j in range(*indices)))
+        return self.args[i]
+
+    def __len__(self):
+        return len(self.args)
+
+    def __contains__(self, item):
+        return item in self.args
+
+    def __iter__(self):
+        return iter(self.args)
+
+    def __add__(self, other):
+        if isinstance(other, Tuple):
+            return Tuple(*(self.args + other.args))
+        elif isinstance(other, tuple):
+            return Tuple(*(self.args + other))
+        else:
+            return NotImplemented
+
+    def __radd__(self, other):
+        if isinstance(other, Tuple):
+            return Tuple(*(other.args + self.args))
+        elif isinstance(other, tuple):
+            return Tuple(*(other + self.args))
+        else:
+            return NotImplemented
+
+    def __mul__(self, other):
+        try:
+            n = as_int(other)
+        except ValueError:
+            raise TypeError("Can't multiply sequence by non-integer of type '%s'" % type(other))
+        return self.func(*(self.args*n))
+
+    __rmul__ = __mul__
+
+    def __eq__(self, other):
+        if isinstance(other, Basic):
+            return super().__eq__(other)
+        return self.args == other
+
+    def __ne__(self, other):
+        if isinstance(other, Basic):
+            return super().__ne__(other)
+        return self.args != other
+
+    def __hash__(self):
+        return hash(self.args)
+
+    def _to_mpmath(self, prec):
+        return tuple(a._to_mpmath(prec) for a in self.args)
+
+    def __lt__(self, other):
+        return _sympify(self.args < other.args)
+
+    def __le__(self, other):
+        return _sympify(self.args <= other.args)
+
+    # XXX: Basic defines count() as something different, so we can't
+    # redefine it here. Originally this lead to cse() test failure.
+    def tuple_count(self, value) -> int:
+        """Return number of occurrences of value."""
+        return self.args.count(value)
+
+    def index(self, value, start=None, stop=None):
+        """Searches and returns the first index of the value."""
+        # XXX: One would expect:
+        #
+        # return self.args.index(value, start, stop)
+        #
+        # here. Any trouble with that? Yes:
+        #
+        # >>> (1,).index(1, None, None)
+        # Traceback (most recent call last):
+        #   File "", line 1, in 
+        # TypeError: slice indices must be integers or None or have an __index__ method
+        #
+        # See: http://bugs.python.org/issue13340
+
+        if start is None and stop is None:
+            return self.args.index(value)
+        elif stop is None:
+            return self.args.index(value, start)
+        else:
+            return self.args.index(value, start, stop)
+
+    @property
+    def kind(self):
+        """
+        The kind of a Tuple instance.
+
+        The kind of a Tuple is always of :class:`TupleKind` but
+        parametrised by the number of elements and the kind of each element.
+
+        Examples
+        ========
+
+        >>> from sympy import Tuple, Matrix
+        >>> Tuple(1, 2).kind
+        TupleKind(NumberKind, NumberKind)
+        >>> Tuple(Matrix([1, 2]), 1).kind
+        TupleKind(MatrixKind(NumberKind), NumberKind)
+        >>> Tuple(1, 2).kind.element_kind
+        (NumberKind, NumberKind)
+
+        See Also
+        ========
+
+        sympy.matrices.kind.MatrixKind
+        sympy.core.kind.NumberKind
+        """
+        return TupleKind(*(i.kind for i in self.args))
+
+_sympy_converter[tuple] = lambda tup: Tuple(*tup)
+
+
+
+
+
+def tuple_wrapper(method):
+    """
+    Decorator that converts any tuple in the function arguments into a Tuple.
+
+    Explanation
+    ===========
+
+    The motivation for this is to provide simple user interfaces.  The user can
+    call a function with regular tuples in the argument, and the wrapper will
+    convert them to Tuples before handing them to the function.
+
+    Explanation
+    ===========
+
+    >>> from sympy.core.containers import tuple_wrapper
+    >>> def f(*args):
+    ...    return args
+    >>> g = tuple_wrapper(f)
+
+    The decorated function g sees only the Tuple argument:
+
+    >>> g(0, (1, 2), 3)
+    (0, (1, 2), 3)
+
+    """
+    def wrap_tuples(*args, **kw_args):
+        newargs = []
+        for arg in args:
+            if isinstance(arg, tuple):
+                newargs.append(Tuple(*arg))
+            else:
+                newargs.append(arg)
+        return method(*newargs, **kw_args)
+    return wrap_tuples
+
+
+class Dict(Basic):
+    """
+    Wrapper around the builtin dict object.
+
+    Explanation
+    ===========
+
+    The Dict is a subclass of Basic, so that it works well in the
+    SymPy framework.  Because it is immutable, it may be included
+    in sets, but its values must all be given at instantiation and
+    cannot be changed afterwards.  Otherwise it behaves identically
+    to the Python dict.
+
+    Examples
+    ========
+
+    >>> from sympy import Dict, Symbol
+
+    >>> D = Dict({1: 'one', 2: 'two'})
+    >>> for key in D:
+    ...    if key == 1:
+    ...        print('%s %s' % (key, D[key]))
+    1 one
+
+    The args are sympified so the 1 and 2 are Integers and the values
+    are Symbols. Queries automatically sympify args so the following work:
+
+    >>> 1 in D
+    True
+    >>> D.has(Symbol('one')) # searches keys and values
+    True
+    >>> 'one' in D # not in the keys
+    False
+    >>> D[1]
+    one
+
+    """
+
+    elements: frozenset[Tuple]
+    _dict: dict[Basic, Basic]
+
+    def __new__(cls, *args):
+        if len(args) == 1 and isinstance(args[0], (dict, Dict)):
+            items = [Tuple(k, v) for k, v in args[0].items()]
+        elif iterable(args) and all(len(arg) == 2 for arg in args):
+            items = [Tuple(k, v) for k, v in args]
+        else:
+            raise TypeError('Pass Dict args as Dict((k1, v1), ...) or Dict({k1: v1, ...})')
+        elements = frozenset(items)
+        obj = Basic.__new__(cls, *ordered(items))
+        obj.elements = elements
+        obj._dict = dict(items)  # In case Tuple decides it wants to sympify
+        return obj
+
+    def __getitem__(self, key):
+        """x.__getitem__(y) <==> x[y]"""
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            raise KeyError(key)
+
+        return self._dict[key]
+
+    def __setitem__(self, key, value):
+        raise NotImplementedError("SymPy Dicts are Immutable")
+
+    def items(self):
+        '''Returns a set-like object providing a view on dict's items.
+        '''
+        return self._dict.items()
+
+    def keys(self):
+        '''Returns the list of the dict's keys.'''
+        return self._dict.keys()
+
+    def values(self):
+        '''Returns the list of the dict's values.'''
+        return self._dict.values()
+
+    def __iter__(self):
+        '''x.__iter__() <==> iter(x)'''
+        return iter(self._dict)
+
+    def __len__(self):
+        '''x.__len__() <==> len(x)'''
+        return self._dict.__len__()
+
+    def get(self, key, default=None):
+        '''Returns the value for key if the key is in the dictionary.'''
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            return default
+        return self._dict.get(key, default)
+
+    def __contains__(self, key):
+        '''D.__contains__(k) -> True if D has a key k, else False'''
+        try:
+            key = _sympify(key)
+        except SympifyError:
+            return False
+        return key in self._dict
+
+    def __lt__(self, other):
+        return _sympify(self.args < other.args)
+
+    @property
+    def _sorted_args(self):
+        return tuple(sorted(self.args, key=default_sort_key))
+
+    def __eq__(self, other):
+        if isinstance(other, dict):
+            return self == Dict(other)
+        return super().__eq__(other)
+
+    __hash__ : Callable[[Basic], Any] = Basic.__hash__
+
+# this handles dict, defaultdict, OrderedDict
+_sympy_converter[dict] = lambda d: Dict(*d.items())
+
+class OrderedSet(MutableSet):
+    def __init__(self, iterable=None):
+        if iterable:
+            self.map = OrderedDict((item, None) for item in iterable)
+        else:
+            self.map = OrderedDict()
+
+    def __len__(self):
+        return len(self.map)
+
+    def __contains__(self, key):
+        return key in self.map
+
+    def add(self, key):
+        self.map[key] = None
+
+    def discard(self, key):
+        self.map.pop(key)
+
+    def pop(self, last=True):
+        return self.map.popitem(last=last)[0]
+
+    def __iter__(self):
+        yield from self.map.keys()
+
+    def __repr__(self):
+        if not self.map:
+            return '%s()' % (self.__class__.__name__,)
+        return '%s(%r)' % (self.__class__.__name__, list(self.map.keys()))
+
+    def intersection(self, other):
+        return self.__class__([val for val in self if val in other])
+
+    def difference(self, other):
+        return self.__class__([val for val in self if val not in other])
+
+    def update(self, iterable):
+        for val in iterable:
+            self.add(val)
+
+class TupleKind(Kind):
+    """
+    TupleKind is a subclass of Kind, which is used to define Kind of ``Tuple``.
+
+    Parameters of TupleKind will be kinds of all the arguments in Tuples, for
+    example
+
+    Parameters
+    ==========
+
+    args : tuple(element_kind)
+       element_kind is kind of element.
+       args is tuple of kinds of element
+
+    Examples
+    ========
+
+    >>> from sympy import Tuple
+    >>> Tuple(1, 2).kind
+    TupleKind(NumberKind, NumberKind)
+    >>> Tuple(1, 2).kind.element_kind
+    (NumberKind, NumberKind)
+
+    See Also
+    ========
+
+    sympy.core.kind.NumberKind
+    MatrixKind
+    sympy.sets.sets.SetKind
+    """
+    def __new__(cls, *args):
+        obj = super().__new__(cls, *args)
+        obj.element_kind = args
+        return obj
+
+    def __repr__(self):
+        return "TupleKind{}".format(self.element_kind)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/core.py b/.venv/lib/python3.12/site-packages/sympy/core/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a45bb06919d7a8ef88e2c9958decac705c0b8ee
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/core.py
@@ -0,0 +1,21 @@
+""" The core's core. """
+from __future__ import annotations
+
+
+class Registry:
+    """
+    Base class for registry objects.
+
+    Registries map a name to an object using attribute notation. Registry
+    classes behave singletonically: all their instances share the same state,
+    which is stored in the class object.
+
+    All subclasses should set `__slots__ = ()`.
+    """
+    __slots__ = ()
+
+    def __setattr__(self, name, obj):
+        setattr(self.__class__, name, obj)
+
+    def __delattr__(self, name):
+        delattr(self.__class__, name)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/coreerrors.py b/.venv/lib/python3.12/site-packages/sympy/core/coreerrors.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2dbdd5227d7b0495145072d31bd993f13f31f0d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/coreerrors.py
@@ -0,0 +1,23 @@
+"""Definitions of common exceptions for :mod:`sympy.core` module. """
+
+from typing import Callable
+
+
+class BaseCoreError(Exception):
+    """Base class for core related exceptions. """
+
+
+class NonCommutativeExpression(BaseCoreError):
+    """Raised when expression didn't have commutative property. """
+
+
+class LazyExceptionMessage:
+    """Wrapper class that lets you specify an expensive to compute
+    error message that is only evaluated if the error is rendered."""
+    callback: Callable[[], str]
+
+    def __init__(self, callback: Callable[[], str]):
+        self.callback = callback
+
+    def __str__(self):
+        return self.callback()
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/decorators.py b/.venv/lib/python3.12/site-packages/sympy/core/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..afd6ae0c72dc32d260586c6411507e4859a9f8ff
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/decorators.py
@@ -0,0 +1,250 @@
+"""
+SymPy core decorators.
+
+The purpose of this module is to expose decorators without any other
+dependencies, so that they can be easily imported anywhere in sympy/core.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from functools import wraps
+from .sympify import SympifyError, sympify
+
+
+if TYPE_CHECKING:
+    from typing import Callable, TypeVar, Union
+    T1 = TypeVar('T1')
+    T2 = TypeVar('T2')
+    T3 = TypeVar('T3')
+
+
+def _sympifyit(arg, retval=None) -> Callable[[Callable[[T1, T2], T3]], Callable[[T1, T2], T3]]:
+    """
+    decorator to smartly _sympify function arguments
+
+    Explanation
+    ===========
+
+    @_sympifyit('other', NotImplemented)
+    def add(self, other):
+        ...
+
+    In add, other can be thought of as already being a SymPy object.
+
+    If it is not, the code is likely to catch an exception, then other will
+    be explicitly _sympified, and the whole code restarted.
+
+    if _sympify(arg) fails, NotImplemented will be returned
+
+    See also
+    ========
+
+    __sympifyit
+    """
+    def deco(func):
+        return __sympifyit(func, arg, retval)
+
+    return deco
+
+
+def __sympifyit(func, arg, retval=None):
+    """Decorator to _sympify `arg` argument for function `func`.
+
+       Do not use directly -- use _sympifyit instead.
+    """
+
+    # we support f(a,b) only
+    if not func.__code__.co_argcount:
+        raise LookupError("func not found")
+    # only b is _sympified
+    assert func.__code__.co_varnames[1] == arg
+    if retval is None:
+        @wraps(func)
+        def __sympifyit_wrapper(a, b):
+            return func(a, sympify(b, strict=True))
+
+    else:
+        @wraps(func)
+        def __sympifyit_wrapper(a, b):
+            try:
+                # If an external class has _op_priority, it knows how to deal
+                # with SymPy objects. Otherwise, it must be converted.
+                if not hasattr(b, '_op_priority'):
+                    b = sympify(b, strict=True)
+                return func(a, b)
+            except SympifyError:
+                return retval
+
+    return __sympifyit_wrapper
+
+
+def call_highest_priority(method_name: str
+    ) -> Callable[[Callable[[T1, T2], T3]], Callable[[T1, T2], T3]]:
+    """A decorator for binary special methods to handle _op_priority.
+
+    Explanation
+    ===========
+
+    Binary special methods in Expr and its subclasses use a special attribute
+    '_op_priority' to determine whose special method will be called to
+    handle the operation. In general, the object having the highest value of
+    '_op_priority' will handle the operation. Expr and subclasses that define
+    custom binary special methods (__mul__, etc.) should decorate those
+    methods with this decorator to add the priority logic.
+
+    The ``method_name`` argument is the name of the method of the other class
+    that will be called.  Use this decorator in the following manner::
+
+        # Call other.__rmul__ if other._op_priority > self._op_priority
+        @call_highest_priority('__rmul__')
+        def __mul__(self, other):
+            ...
+
+        # Call other.__mul__ if other._op_priority > self._op_priority
+        @call_highest_priority('__mul__')
+        def __rmul__(self, other):
+        ...
+    """
+    def priority_decorator(func: Callable[[T1, T2], T3]) -> Callable[[T1, T2], T3]:
+        @wraps(func)
+        def binary_op_wrapper(self: T1, other: T2) -> T3:
+            if hasattr(other, '_op_priority'):
+                if other._op_priority > self._op_priority:  # type: ignore
+                    f: Union[Callable[[T1], T3], None] = getattr(other, method_name, None)
+                    if f is not None:
+                        return f(self)
+            return func(self, other)
+        return binary_op_wrapper
+    return priority_decorator
+
+
+def sympify_method_args(cls: type[T1]) -> type[T1]:
+    '''Decorator for a class with methods that sympify arguments.
+
+    Explanation
+    ===========
+
+    The sympify_method_args decorator is to be used with the sympify_return
+    decorator for automatic sympification of method arguments. This is
+    intended for the common idiom of writing a class like :
+
+    Examples
+    ========
+
+    >>> from sympy import Basic, SympifyError, S
+    >>> from sympy.core.sympify import _sympify
+
+    >>> class MyTuple(Basic):
+    ...     def __add__(self, other):
+    ...         try:
+    ...             other = _sympify(other)
+    ...         except SympifyError:
+    ...             return NotImplemented
+    ...         if not isinstance(other, MyTuple):
+    ...             return NotImplemented
+    ...         return MyTuple(*(self.args + other.args))
+
+    >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4))
+    MyTuple(1, 2, 3, 4)
+
+    In the above it is important that we return NotImplemented when other is
+    not sympifiable and also when the sympified result is not of the expected
+    type. This allows the MyTuple class to be used cooperatively with other
+    classes that overload __add__ and want to do something else in combination
+    with instance of Tuple.
+
+    Using this decorator the above can be written as
+
+    >>> from sympy.core.decorators import sympify_method_args, sympify_return
+
+    >>> @sympify_method_args
+    ... class MyTuple(Basic):
+    ...     @sympify_return([('other', 'MyTuple')], NotImplemented)
+    ...     def __add__(self, other):
+    ...          return MyTuple(*(self.args + other.args))
+
+    >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4))
+    MyTuple(1, 2, 3, 4)
+
+    The idea here is that the decorators take care of the boiler-plate code
+    for making this happen in each method that potentially needs to accept
+    unsympified arguments. Then the body of e.g. the __add__ method can be
+    written without needing to worry about calling _sympify or checking the
+    type of the resulting object.
+
+    The parameters for sympify_return are a list of tuples of the form
+    (parameter_name, expected_type) and the value to return (e.g.
+    NotImplemented). The expected_type parameter can be a type e.g. Tuple or a
+    string 'Tuple'. Using a string is useful for specifying a Type within its
+    class body (as in the above example).
+
+    Notes: Currently sympify_return only works for methods that take a single
+    argument (not including self). Specifying an expected_type as a string
+    only works for the class in which the method is defined.
+    '''
+    # Extract the wrapped methods from each of the wrapper objects created by
+    # the sympify_return decorator. Doing this here allows us to provide the
+    # cls argument which is used for forward string referencing.
+    for attrname, obj in cls.__dict__.items():
+        if isinstance(obj, _SympifyWrapper):
+            setattr(cls, attrname, obj.make_wrapped(cls))
+    return cls
+
+
+def sympify_return(*args):
+    '''Function/method decorator to sympify arguments automatically
+
+    See the docstring of sympify_method_args for explanation.
+    '''
+    # Store a wrapper object for the decorated method
+    def wrapper(func: Callable[[T1, T2], T3]) -> Callable[[T1, T2], T3]:
+        return _SympifyWrapper(func, args)  # type: ignore
+    return wrapper
+
+
+class _SympifyWrapper:
+    '''Internal class used by sympify_return and sympify_method_args'''
+
+    def __init__(self, func, args):
+        self.func = func
+        self.args = args
+
+    def make_wrapped(self, cls):
+        func = self.func
+        parameters, retval = self.args
+
+        # XXX: Handle more than one parameter?
+        [(parameter, expectedcls)] = parameters
+
+        # Handle forward references to the current class using strings
+        if expectedcls == cls.__name__:
+            expectedcls = cls
+
+        # Raise RuntimeError since this is a failure at import time and should
+        # not be recoverable.
+        nargs = func.__code__.co_argcount
+        # we support f(a, b) only
+        if nargs != 2:
+            raise RuntimeError('sympify_return can only be used with 2 argument functions')
+        # only b is _sympified
+        if func.__code__.co_varnames[1] != parameter:
+            raise RuntimeError('parameter name mismatch "%s" in %s' %
+                    (parameter, func.__name__))
+
+        @wraps(func)
+        def _func(self, other):
+            # XXX: The check for _op_priority here should be removed. It is
+            # needed to stop mutable matrices from being sympified to
+            # immutable matrices which breaks things in quantum...
+            if not hasattr(other, '_op_priority'):
+                try:
+                    other = sympify(other, strict=True)
+                except SympifyError:
+                    return retval
+            if not isinstance(other, expectedcls):
+                return retval
+            return func(self, other)
+
+        return _func
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/evalf.py b/.venv/lib/python3.12/site-packages/sympy/core/evalf.py
new file mode 100644
index 0000000000000000000000000000000000000000..55a981090360556b357ec1cade5576e226633be8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/evalf.py
@@ -0,0 +1,1808 @@
+"""
+Adaptive numerical evaluation of SymPy expressions, using mpmath
+for mathematical functions.
+"""
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING, Any, overload, Type
+
+import math
+
+import mpmath.libmp as libmp
+from mpmath import (
+    make_mpc, make_mpf, mp, mpc, mpf, nsum, quadts, quadosc, workprec)
+from mpmath import inf as mpmath_inf
+from mpmath.libmp import (from_int, from_man_exp, from_rational, fhalf,
+                          fnan, finf, fninf, fnone, fone, fzero, mpf_abs, mpf_add,
+                          mpf_atan, mpf_atan2, mpf_cmp, mpf_cos, mpf_e, mpf_exp, mpf_log, mpf_lt,
+                          mpf_mul, mpf_neg, mpf_pi, mpf_pow, mpf_pow_int, mpf_shift, mpf_sin,
+                          mpf_sqrt, normalize, round_nearest, to_int, to_str, mpf_tan)
+from mpmath.libmp import bitcount as mpmath_bitcount
+from mpmath.libmp.backend import MPZ
+from mpmath.libmp.libmpc import _infs_nan
+from mpmath.libmp.libmpf import dps_to_prec, prec_to_dps
+
+from .sympify import sympify
+from .singleton import S
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.lambdify import lambdify
+from sympy.utilities.misc import as_int
+
+if TYPE_CHECKING:
+    from sympy.core.expr import Expr
+    from sympy.core.add import Add
+    from sympy.core.mul import Mul
+    from sympy.core.power import Pow
+    from sympy.core.symbol import Symbol
+    from sympy.integrals.integrals import Integral
+    from sympy.concrete.summations import Sum
+    from sympy.concrete.products import Product
+    from sympy.functions.elementary.exponential import exp, log
+    from sympy.functions.elementary.complexes import Abs, re, im
+    from sympy.functions.elementary.integers import ceiling, floor
+    from sympy.functions.elementary.trigonometric import atan
+    from .numbers import Float, Rational, Integer, AlgebraicNumber, Number
+
+LG10 = math.log2(10)
+rnd = round_nearest
+
+
+def bitcount(n):
+    """Return smallest integer, b, such that |n|/2**b < 1.
+    """
+    return mpmath_bitcount(abs(int(n)))
+
+# Used in a few places as placeholder values to denote exponents and
+# precision levels, e.g. of exact numbers. Must be careful to avoid
+# passing these to mpmath functions or returning them in final results.
+INF = float(mpmath_inf)
+MINUS_INF = float(-mpmath_inf)
+
+# ~= 100 digits. Real men set this to INF.
+DEFAULT_MAXPREC = 333
+
+
+class PrecisionExhausted(ArithmeticError):
+    pass
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#              Helper functions for arithmetic and complex parts             #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+"""
+An mpf value tuple is a tuple of integers (sign, man, exp, bc)
+representing a floating-point number: [1, -1][sign]*man*2**exp where
+sign is 0 or 1 and bc should correspond to the number of bits used to
+represent the mantissa (man) in binary notation, e.g.
+"""
+
+MPF_TUP = tuple[int, int, int, int]  # mpf value tuple
+
+"""
+Explanation
+===========
+
+>>> from sympy.core.evalf import bitcount
+>>> sign, man, exp, bc = 0, 5, 1, 3
+>>> n = [1, -1][sign]*man*2**exp
+>>> n, bitcount(man)
+(10, 3)
+
+A temporary result is a tuple (re, im, re_acc, im_acc) where
+re and im are nonzero mpf value tuples representing approximate
+numbers, or None to denote exact zeros.
+
+re_acc, im_acc are integers denoting log2(e) where e is the estimated
+relative accuracy of the respective complex part, but may be anything
+if the corresponding complex part is None.
+
+"""
+TMP_RES = Any  # temporary result, should be some variant of
+# tUnion[tTuple[Optional[MPF_TUP], Optional[MPF_TUP],
+#               Optional[int], Optional[int]],
+#        'ComplexInfinity']
+# but mypy reports error because it doesn't know as we know
+# 1. re and re_acc are either both None or both MPF_TUP
+# 2. sometimes the result can't be zoo
+
+# type of the "options" parameter in internal evalf functions
+OPT_DICT = dict[str, Any]
+
+
+def fastlog(x: MPF_TUP | None) -> int | Any:
+    """Fast approximation of log2(x) for an mpf value tuple x.
+
+    Explanation
+    ===========
+
+    Calculated as exponent + width of mantissa. This is an
+    approximation for two reasons: 1) it gives the ceil(log2(abs(x)))
+    value and 2) it is too high by 1 in the case that x is an exact
+    power of 2. Although this is easy to remedy by testing to see if
+    the odd mpf mantissa is 1 (indicating that one was dealing with
+    an exact power of 2) that would decrease the speed and is not
+    necessary as this is only being used as an approximation for the
+    number of bits in x. The correct return value could be written as
+    "x[2] + (x[3] if x[1] != 1 else 0)".
+        Since mpf tuples always have an odd mantissa, no check is done
+    to see if the mantissa is a multiple of 2 (in which case the
+    result would be too large by 1).
+
+    Examples
+    ========
+
+    >>> from sympy import log
+    >>> from sympy.core.evalf import fastlog, bitcount
+    >>> s, m, e = 0, 5, 1
+    >>> bc = bitcount(m)
+    >>> n = [1, -1][s]*m*2**e
+    >>> n, (log(n)/log(2)).evalf(2), fastlog((s, m, e, bc))
+    (10, 3.3, 4)
+    """
+
+    if not x or x == fzero:
+        return MINUS_INF
+    return x[2] + x[3]
+
+
+def pure_complex(v: Expr, or_real=False) -> tuple[Number, Number] | None:
+    """Return a and b if v matches a + I*b where b is not zero and
+    a and b are Numbers, else None. If `or_real` is True then 0 will
+    be returned for `b` if `v` is a real number.
+
+    Examples
+    ========
+
+    >>> from sympy.core.evalf import pure_complex
+    >>> from sympy import sqrt, I, S
+    >>> a, b, surd = S(2), S(3), sqrt(2)
+    >>> pure_complex(a)
+    >>> pure_complex(a, or_real=True)
+    (2, 0)
+    >>> pure_complex(surd)
+    >>> pure_complex(a + b*I)
+    (2, 3)
+    >>> pure_complex(I)
+    (0, 1)
+    """
+    h, t = v.as_coeff_Add()
+    if t:
+        c, i = t.as_coeff_Mul()
+        if i is S.ImaginaryUnit:
+            return h, c
+    elif or_real:
+        return h, S.Zero
+    return None
+
+
+# I don't know what this is, see function scaled_zero below
+SCALED_ZERO_TUP = tuple[list[int], int, int, int]
+
+
+
+@overload
+def scaled_zero(mag: SCALED_ZERO_TUP, sign=1) -> MPF_TUP:
+    ...
+@overload
+def scaled_zero(mag: int, sign=1) -> tuple[SCALED_ZERO_TUP, int]:
+    ...
+def scaled_zero(mag: SCALED_ZERO_TUP | int, sign=1) -> \
+        MPF_TUP | tuple[SCALED_ZERO_TUP, int]:
+    """Return an mpf representing a power of two with magnitude ``mag``
+    and -1 for precision. Or, if ``mag`` is a scaled_zero tuple, then just
+    remove the sign from within the list that it was initially wrapped
+    in.
+
+    Examples
+    ========
+
+    >>> from sympy.core.evalf import scaled_zero
+    >>> from sympy import Float
+    >>> z, p = scaled_zero(100)
+    >>> z, p
+    (([0], 1, 100, 1), -1)
+    >>> ok = scaled_zero(z)
+    >>> ok
+    (0, 1, 100, 1)
+    >>> Float(ok)
+    1.26765060022823e+30
+    >>> Float(ok, p)
+    0.e+30
+    >>> ok, p = scaled_zero(100, -1)
+    >>> Float(scaled_zero(ok), p)
+    -0.e+30
+    """
+    if isinstance(mag, tuple) and len(mag) == 4 and iszero(mag, scaled=True):
+        return (mag[0][0],) + mag[1:]
+    elif isinstance(mag, SYMPY_INTS):
+        if sign not in [-1, 1]:
+            raise ValueError('sign must be +/-1')
+        rv, p = mpf_shift(fone, mag), -1
+        s = 0 if sign == 1 else 1
+        rv = ([s],) + rv[1:]
+        return rv, p
+    else:
+        raise ValueError('scaled zero expects int or scaled_zero tuple.')
+
+
+def iszero(mpf: MPF_TUP | SCALED_ZERO_TUP | None, scaled=False) -> bool | None:
+    if not scaled:
+        return not mpf or not mpf[1] and not mpf[-1]
+    return mpf and isinstance(mpf[0], list) and mpf[1] == mpf[-1] == 1
+
+
+def complex_accuracy(result: TMP_RES) -> int | Any:
+    """
+    Returns relative accuracy of a complex number with given accuracies
+    for the real and imaginary parts. The relative accuracy is defined
+    in the complex norm sense as ||z|+|error|| / |z| where error
+    is equal to (real absolute error) + (imag absolute error)*i.
+
+    The full expression for the (logarithmic) error can be approximated
+    easily by using the max norm to approximate the complex norm.
+
+    In the worst case (re and im equal), this is wrong by a factor
+    sqrt(2), or by log2(sqrt(2)) = 0.5 bit.
+    """
+    if result is S.ComplexInfinity:
+        return INF
+    re, im, re_acc, im_acc = result
+    if not im:
+        if not re:
+            return INF
+        return re_acc
+    if not re:
+        return im_acc
+    re_size = fastlog(re)
+    im_size = fastlog(im)
+    absolute_error = max(re_size - re_acc, im_size - im_acc)
+    relative_error = absolute_error - max(re_size, im_size)
+    return -relative_error
+
+
+def get_abs(expr: Expr, prec: int, options: OPT_DICT) -> TMP_RES:
+    result = evalf(expr, prec + 2, options)
+    if result is S.ComplexInfinity:
+        return finf, None, prec, None
+    re, im, re_acc, im_acc = result
+    if not re:
+        re, re_acc, im, im_acc = im, im_acc, re, re_acc
+    if im:
+        if expr.is_number:
+            abs_expr, _, acc, _ = evalf(abs(N(expr, prec + 2)),
+                                        prec + 2, options)
+            return abs_expr, None, acc, None
+        else:
+            if 'subs' in options:
+                return libmp.mpc_abs((re, im), prec), None, re_acc, None
+            return abs(expr), None, prec, None
+    elif re:
+        return mpf_abs(re), None, re_acc, None
+    else:
+        return None, None, None, None
+
+
+def get_complex_part(expr: Expr, no: int, prec: int, options: OPT_DICT) -> TMP_RES:
+    """no = 0 for real part, no = 1 for imaginary part"""
+    workprec = prec
+    i = 0
+    while 1:
+        res = evalf(expr, workprec, options)
+        if res is S.ComplexInfinity:
+            return fnan, None, prec, None
+        value, accuracy = res[no::2]
+        # XXX is the last one correct? Consider re((1+I)**2).n()
+        if (not value) or accuracy >= prec or -value[2] > prec:
+            return value, None, accuracy, None
+        workprec += max(30, 2**i)
+        i += 1
+
+
+def evalf_abs(expr: 'Abs', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_abs(expr.args[0], prec, options)
+
+
+def evalf_re(expr: 're', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_complex_part(expr.args[0], 0, prec, options)
+
+
+def evalf_im(expr: 'im', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_complex_part(expr.args[0], 1, prec, options)
+
+
+def finalize_complex(re: MPF_TUP, im: MPF_TUP, prec: int) -> TMP_RES:
+    if re == fzero and im == fzero:
+        raise ValueError("got complex zero with unknown accuracy")
+    elif re == fzero:
+        return None, im, None, prec
+    elif im == fzero:
+        return re, None, prec, None
+
+    size_re = fastlog(re)
+    size_im = fastlog(im)
+    if size_re > size_im:
+        re_acc = prec
+        im_acc = prec + min(-(size_re - size_im), 0)
+    else:
+        im_acc = prec
+        re_acc = prec + min(-(size_im - size_re), 0)
+    return re, im, re_acc, im_acc
+
+
+def chop_parts(value: TMP_RES, prec: int) -> TMP_RES:
+    """
+    Chop off tiny real or complex parts.
+    """
+    if value is S.ComplexInfinity:
+        return value
+    re, im, re_acc, im_acc = value
+    # Method 1: chop based on absolute value
+    if re and re not in _infs_nan and (fastlog(re) < -prec + 4):
+        re, re_acc = None, None
+    if im and im not in _infs_nan and (fastlog(im) < -prec + 4):
+        im, im_acc = None, None
+    # Method 2: chop if inaccurate and relatively small
+    if re and im:
+        delta = fastlog(re) - fastlog(im)
+        if re_acc < 2 and (delta - re_acc <= -prec + 4):
+            re, re_acc = None, None
+        if im_acc < 2 and (delta - im_acc >= prec - 4):
+            im, im_acc = None, None
+    return re, im, re_acc, im_acc
+
+
+def check_target(expr: Expr, result: TMP_RES, prec: int):
+    a = complex_accuracy(result)
+    if a < prec:
+        raise PrecisionExhausted("Failed to distinguish the expression: \n\n%s\n\n"
+            "from zero. Try simplifying the input, using chop=True, or providing "
+            "a higher maxn for evalf" % (expr))
+
+
+def get_integer_part(expr: Expr, no: int, options: OPT_DICT, return_ints=False) -> \
+        TMP_RES | tuple[int, int]:
+    """
+    With no = 1, computes ceiling(expr)
+    With no = -1, computes floor(expr)
+
+    Note: this function either gives the exact result or signals failure.
+    """
+    from sympy.functions.elementary.complexes import re, im
+    # The expression is likely less than 2^30 or so
+    assumed_size = 30
+    result = evalf(expr, assumed_size, options)
+    if result is S.ComplexInfinity:
+        raise ValueError("Cannot get integer part of Complex Infinity")
+    ire, iim, ire_acc, iim_acc = result
+
+    # We now know the size, so we can calculate how much extra precision
+    # (if any) is needed to get within the nearest integer
+    if ire and iim:
+        gap = max(fastlog(ire) - ire_acc, fastlog(iim) - iim_acc)
+    elif ire:
+        gap = fastlog(ire) - ire_acc
+    elif iim:
+        gap = fastlog(iim) - iim_acc
+    else:
+        # ... or maybe the expression was exactly zero
+        if return_ints:
+            return 0, 0
+        else:
+            return None, None, None, None
+
+    margin = 10
+
+    if gap >= -margin:
+        prec = margin + assumed_size + gap
+        ire, iim, ire_acc, iim_acc = evalf(
+            expr, prec, options)
+    else:
+        prec = assumed_size
+
+    # We can now easily find the nearest integer, but to find floor/ceil, we
+    # must also calculate whether the difference to the nearest integer is
+    # positive or negative (which may fail if very close).
+    def calc_part(re_im: Expr, nexpr: MPF_TUP):
+        from .add import Add
+        _, _, exponent, _ = nexpr
+        is_int = exponent == 0
+        nint = int(to_int(nexpr, rnd))
+        if is_int:
+            # make sure that we had enough precision to distinguish
+            # between nint and the re or im part (re_im) of expr that
+            # was passed to calc_part
+            ire, iim, ire_acc, iim_acc = evalf(
+                re_im - nint, 10, options)  # don't need much precision
+            assert not iim
+            size = -fastlog(ire) + 2  # -ve b/c ire is less than 1
+            if size > prec:
+                ire, iim, ire_acc, iim_acc = evalf(
+                    re_im, size, options)
+                assert not iim
+                nexpr = ire
+            nint = int(to_int(nexpr, rnd))
+            _, _, new_exp, _ = ire
+            is_int = new_exp == 0
+        if not is_int:
+            # if there are subs and they all contain integer re/im parts
+            # then we can (hopefully) safely substitute them into the
+            # expression
+            s = options.get('subs', False)
+            if s:
+                # use strict=False with as_int because we take
+                # 2.0 == 2
+                def is_int_reim(x):
+                    """Check for integer or integer + I*integer."""
+                    try:
+                        as_int(x, strict=False)
+                        return True
+                    except ValueError:
+                        try:
+                            [as_int(i, strict=False) for i in x.as_real_imag()]
+                            return True
+                        except ValueError:
+                            return False
+
+                if all(is_int_reim(v) for v in s.values()):
+                    re_im = re_im.subs(s)
+
+            re_im = Add(re_im, -nint, evaluate=False)
+            x, _, x_acc, _ = evalf(re_im, 10, options)
+            try:
+                check_target(re_im, (x, None, x_acc, None), 3)
+            except PrecisionExhausted:
+                if not re_im.equals(0):
+                    raise PrecisionExhausted
+                x = fzero
+            nint += int(no*(mpf_cmp(x or fzero, fzero) == no))
+        nint = from_int(nint)
+        return nint, INF
+
+    re_, im_, re_acc, im_acc = None, None, None, None
+
+    if ire is not None and ire != fzero:
+        re_, re_acc = calc_part(re(expr, evaluate=False), ire)
+    if iim is not None and iim != fzero:
+        im_, im_acc = calc_part(im(expr, evaluate=False), iim)
+
+    if return_ints:
+        return int(to_int(re_ or fzero)), int(to_int(im_ or fzero))
+    return re_, im_, re_acc, im_acc
+
+
+def evalf_ceiling(expr: 'ceiling', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_integer_part(expr.args[0], 1, options)
+
+
+def evalf_floor(expr: 'floor', prec: int, options: OPT_DICT) -> TMP_RES:
+    return get_integer_part(expr.args[0], -1, options)
+
+
+def evalf_float(expr: 'Float', prec: int, options: OPT_DICT) -> TMP_RES:
+    return expr._mpf_, None, prec, None
+
+
+def evalf_rational(expr: 'Rational', prec: int, options: OPT_DICT) -> TMP_RES:
+    return from_rational(expr.p, expr.q, prec), None, prec, None
+
+
+def evalf_integer(expr: 'Integer', prec: int, options: OPT_DICT) -> TMP_RES:
+    return from_int(expr.p, prec), None, prec, None
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Arithmetic operations                           #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def add_terms(terms: list, prec: int, target_prec: int) -> \
+        tuple[MPF_TUP | SCALED_ZERO_TUP | None, int | None]:
+    """
+    Helper for evalf_add. Adds a list of (mpfval, accuracy) terms.
+
+    Returns
+    =======
+
+    - None, None if there are no non-zero terms;
+    - terms[0] if there is only 1 term;
+    - scaled_zero if the sum of the terms produces a zero by cancellation
+      e.g. mpfs representing 1 and -1 would produce a scaled zero which need
+      special handling since they are not actually zero and they are purposely
+      malformed to ensure that they cannot be used in anything but accuracy
+      calculations;
+    - a tuple that is scaled to target_prec that corresponds to the
+      sum of the terms.
+
+    The returned mpf tuple will be normalized to target_prec; the input
+    prec is used to define the working precision.
+
+    XXX explain why this is needed and why one cannot just loop using mpf_add
+    """
+
+    terms = [t for t in terms if not iszero(t[0])]
+    if not terms:
+        return None, None
+    elif len(terms) == 1:
+        return terms[0]
+
+    # see if any argument is NaN or oo and thus warrants a special return
+    special = []
+    from .numbers import Float
+    for t in terms:
+        arg = Float._new(t[0], 1)
+        if arg is S.NaN or arg.is_infinite:
+            special.append(arg)
+    if special:
+        from .add import Add
+        rv = evalf(Add(*special), prec + 4, {})
+        return rv[0], rv[2]
+
+    working_prec = 2*prec
+    sum_man, sum_exp = 0, 0
+    absolute_err: list[int] = []
+
+    for x, accuracy in terms:
+        sign, man, exp, bc = x
+        if sign:
+            man = -man
+        absolute_err.append(bc + exp - accuracy)
+        delta = exp - sum_exp
+        if exp >= sum_exp:
+            # x much larger than existing sum?
+            # first: quick test
+            if ((delta > working_prec) and
+                ((not sum_man) or
+                 delta - bitcount(abs(sum_man)) > working_prec)):
+                sum_man = man
+                sum_exp = exp
+            else:
+                sum_man += (man << delta)
+        else:
+            delta = -delta
+            # x much smaller than existing sum?
+            if delta - bc > working_prec:
+                if not sum_man:
+                    sum_man, sum_exp = man, exp
+            else:
+                sum_man = (sum_man << delta) + man
+                sum_exp = exp
+    absolute_error = max(absolute_err)
+    if not sum_man:
+        return scaled_zero(absolute_error)
+    if sum_man < 0:
+        sum_sign = 1
+        sum_man = -sum_man
+    else:
+        sum_sign = 0
+    sum_bc = bitcount(sum_man)
+    sum_accuracy = sum_exp + sum_bc - absolute_error
+    r = normalize(sum_sign, sum_man, sum_exp, sum_bc, target_prec,
+        rnd), sum_accuracy
+    return r
+
+
+def evalf_add(v: 'Add', prec: int, options: OPT_DICT) -> TMP_RES:
+    res = pure_complex(v)
+    if res:
+        h, c = res
+        re, _, re_acc, _ = evalf(h, prec, options)
+        im, _, im_acc, _ = evalf(c, prec, options)
+        return re, im, re_acc, im_acc
+
+    oldmaxprec = options.get('maxprec', DEFAULT_MAXPREC)
+
+    i = 0
+    target_prec = prec
+    while 1:
+        options['maxprec'] = min(oldmaxprec, 2*prec)
+
+        terms = [evalf(arg, prec + 10, options) for arg in v.args]
+        n = terms.count(S.ComplexInfinity)
+        if n >= 2:
+            return fnan, None, prec, None
+        re, re_acc = add_terms(
+            [a[0::2] for a in terms if isinstance(a, tuple) and a[0]], prec, target_prec)
+        im, im_acc = add_terms(
+            [a[1::2] for a in terms if isinstance(a, tuple) and a[1]], prec, target_prec)
+        if n == 1:
+            if re in (finf, fninf, fnan) or im in (finf, fninf, fnan):
+                return fnan, None, prec, None
+            return S.ComplexInfinity
+        acc = complex_accuracy((re, im, re_acc, im_acc))
+        if acc >= target_prec:
+            if options.get('verbose'):
+                print("ADD: wanted", target_prec, "accurate bits, got", re_acc, im_acc)
+            break
+        else:
+            if (prec - target_prec) > options['maxprec']:
+                break
+
+            prec = prec + max(10 + 2**i, target_prec - acc)
+            i += 1
+            if options.get('verbose'):
+                print("ADD: restarting with prec", prec)
+
+    options['maxprec'] = oldmaxprec
+    if iszero(re, scaled=True):
+        re = scaled_zero(re)
+    if iszero(im, scaled=True):
+        im = scaled_zero(im)
+    return re, im, re_acc, im_acc
+
+
+def evalf_mul(v: 'Mul', prec: int, options: OPT_DICT) -> TMP_RES:
+    res = pure_complex(v)
+    if res:
+        # the only pure complex that is a mul is h*I
+        _, h = res
+        im, _, im_acc, _ = evalf(h, prec, options)
+        return None, im, None, im_acc
+    args = list(v.args)
+
+    # see if any argument is NaN or oo and thus warrants a special return
+    has_zero = False
+    special = []
+    from .numbers import Float
+    for arg in args:
+        result = evalf(arg, prec, options)
+        if result is S.ComplexInfinity:
+            special.append(result)
+            continue
+        if result[0] is None:
+            if result[1] is None:
+                has_zero = True
+            continue
+        num = Float._new(result[0], 1)
+        if num is S.NaN:
+            return fnan, None, prec, None
+        if num.is_infinite:
+            special.append(num)
+    if special:
+        if has_zero:
+            return fnan, None, prec, None
+        from .mul import Mul
+        return evalf(Mul(*special), prec + 4, {})
+    if has_zero:
+        return None, None, None, None
+
+    # With guard digits, multiplication in the real case does not destroy
+    # accuracy. This is also true in the complex case when considering the
+    # total accuracy; however accuracy for the real or imaginary parts
+    # separately may be lower.
+    acc = prec
+
+    # XXX: big overestimate
+    working_prec = prec + len(args) + 5
+
+    # Empty product is 1
+    start = man, exp, bc = MPZ(1), 0, 1
+
+    # First, we multiply all pure real or pure imaginary numbers.
+    # direction tells us that the result should be multiplied by
+    # I**direction; all other numbers get put into complex_factors
+    # to be multiplied out after the first phase.
+    last = len(args)
+    direction = 0
+    args.append(S.One)
+    complex_factors = []
+
+    for i, arg in enumerate(args):
+        if i != last and pure_complex(arg):
+            args[-1] = (args[-1]*arg).expand()
+            continue
+        elif i == last and arg is S.One:
+            continue
+        re, im, re_acc, im_acc = evalf(arg, working_prec, options)
+        if re and im:
+            complex_factors.append((re, im, re_acc, im_acc))
+            continue
+        elif re:
+            (s, m, e, b), w_acc = re, re_acc
+        elif im:
+            (s, m, e, b), w_acc = im, im_acc
+            direction += 1
+        else:
+            return None, None, None, None
+        direction += 2*s
+        man *= m
+        exp += e
+        bc += b
+        while bc > 3*working_prec:
+            man >>= working_prec
+            exp += working_prec
+            bc -= working_prec
+        acc = min(acc, w_acc)
+    sign = (direction & 2) >> 1
+    if not complex_factors:
+        v = normalize(sign, man, exp, bitcount(man), prec, rnd)
+        # multiply by i
+        if direction & 1:
+            return None, v, None, acc
+        else:
+            return v, None, acc, None
+    else:
+        # initialize with the first term
+        if (man, exp, bc) != start:
+            # there was a real part; give it an imaginary part
+            re, im = (sign, man, exp, bitcount(man)), (0, MPZ(0), 0, 0)
+            i0 = 0
+        else:
+            # there is no real part to start (other than the starting 1)
+            wre, wim, wre_acc, wim_acc = complex_factors[0]
+            acc = min(acc,
+                      complex_accuracy((wre, wim, wre_acc, wim_acc)))
+            re = wre
+            im = wim
+            i0 = 1
+
+        for wre, wim, wre_acc, wim_acc in complex_factors[i0:]:
+            # acc is the overall accuracy of the product; we aren't
+            # computing exact accuracies of the product.
+            acc = min(acc,
+                      complex_accuracy((wre, wim, wre_acc, wim_acc)))
+
+            use_prec = working_prec
+            A = mpf_mul(re, wre, use_prec)
+            B = mpf_mul(mpf_neg(im), wim, use_prec)
+            C = mpf_mul(re, wim, use_prec)
+            D = mpf_mul(im, wre, use_prec)
+            re = mpf_add(A, B, use_prec)
+            im = mpf_add(C, D, use_prec)
+        if options.get('verbose'):
+            print("MUL: wanted", prec, "accurate bits, got", acc)
+        # multiply by I
+        if direction & 1:
+            re, im = mpf_neg(im), re
+        return re, im, acc, acc
+
+
+def evalf_pow(v: 'Pow', prec: int, options) -> TMP_RES:
+
+    target_prec = prec
+    base, exp = v.args
+
+    # We handle x**n separately. This has two purposes: 1) it is much
+    # faster, because we avoid calling evalf on the exponent, and 2) it
+    # allows better handling of real/imaginary parts that are exactly zero
+    if exp.is_Integer:
+        p: int = exp.p  # type: ignore
+        # Exact
+        if not p:
+            return fone, None, prec, None
+        # Exponentiation by p magnifies relative error by |p|, so the
+        # base must be evaluated with increased precision if p is large
+        prec += int(math.log2(abs(p)))
+        result = evalf(base, prec + 5, options)
+        if result is S.ComplexInfinity:
+            if p < 0:
+                return None, None, None, None
+            return result
+        re, im, re_acc, im_acc = result
+        # Real to integer power
+        if re and not im:
+            return mpf_pow_int(re, p, target_prec), None, target_prec, None
+        # (x*I)**n = I**n * x**n
+        if im and not re:
+            z = mpf_pow_int(im, p, target_prec)
+            case = p % 4
+            if case == 0:
+                return z, None, target_prec, None
+            if case == 1:
+                return None, z, None, target_prec
+            if case == 2:
+                return mpf_neg(z), None, target_prec, None
+            if case == 3:
+                return None, mpf_neg(z), None, target_prec
+        # Zero raised to an integer power
+        if not re:
+            if p < 0:
+                return S.ComplexInfinity
+            return None, None, None, None
+        # General complex number to arbitrary integer power
+        re, im = libmp.mpc_pow_int((re, im), p, prec)
+        # Assumes full accuracy in input
+        return finalize_complex(re, im, target_prec)
+
+    result = evalf(base, prec + 5, options)
+    if result is S.ComplexInfinity:
+        if exp.is_Rational:
+            if exp < 0:
+                return None, None, None, None
+            return result
+        raise NotImplementedError
+
+    # Pure square root
+    if exp is S.Half:
+        xre, xim, _, _ = result
+        # General complex square root
+        if xim:
+            re, im = libmp.mpc_sqrt((xre or fzero, xim), prec)
+            return finalize_complex(re, im, prec)
+        if not xre:
+            return None, None, None, None
+        # Square root of a negative real number
+        if mpf_lt(xre, fzero):
+            return None, mpf_sqrt(mpf_neg(xre), prec), None, prec
+        # Positive square root
+        return mpf_sqrt(xre, prec), None, prec, None
+
+    # We first evaluate the exponent to find its magnitude
+    # This determines the working precision that must be used
+    prec += 10
+    result = evalf(exp, prec, options)
+    if result is S.ComplexInfinity:
+        return fnan, None, prec, None
+    yre, yim, _, _ = result
+    # Special cases: x**0
+    if not (yre or yim):
+        return fone, None, prec, None
+
+    ysize = fastlog(yre)
+    # Restart if too big
+    # XXX: prec + ysize might exceed maxprec
+    if ysize > 5:
+        prec += ysize
+        yre, yim, _, _ = evalf(exp, prec, options)
+
+    # Pure exponential function; no need to evalf the base
+    if base is S.Exp1:
+        if yim:
+            re, im = libmp.mpc_exp((yre or fzero, yim), prec)
+            return finalize_complex(re, im, target_prec)
+        return mpf_exp(yre, target_prec), None, target_prec, None
+
+    xre, xim, _, _ = evalf(base, prec + 5, options)
+    # 0**y
+    if not (xre or xim):
+        if yim:
+            return fnan, None, prec, None
+        if yre[0] == 1:  # y < 0
+            return S.ComplexInfinity
+        return None, None, None, None
+
+    # (real ** complex) or (complex ** complex)
+    if yim:
+        re, im = libmp.mpc_pow(
+            (xre or fzero, xim or fzero), (yre or fzero, yim),
+            target_prec)
+        return finalize_complex(re, im, target_prec)
+    # complex ** real
+    if xim:
+        re, im = libmp.mpc_pow_mpf((xre or fzero, xim), yre, target_prec)
+        return finalize_complex(re, im, target_prec)
+    # negative ** real
+    elif mpf_lt(xre, fzero):
+        re, im = libmp.mpc_pow_mpf((xre, fzero), yre, target_prec)
+        return finalize_complex(re, im, target_prec)
+    # positive ** real
+    else:
+        return mpf_pow(xre, yre, target_prec), None, target_prec, None
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Special functions                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def evalf_exp(expr: 'exp', prec: int, options: OPT_DICT) -> TMP_RES:
+    from .power import Pow
+    return evalf_pow(Pow(S.Exp1, expr.exp, evaluate=False), prec, options)
+
+
+def evalf_trig(v: Expr, prec: int, options: OPT_DICT) -> TMP_RES:
+    """
+    This function handles sin , cos and tan of complex arguments.
+
+    """
+    from sympy.functions.elementary.trigonometric import cos, sin, tan
+    if isinstance(v, cos):
+        func = mpf_cos
+    elif isinstance(v, sin):
+        func = mpf_sin
+    elif isinstance(v,tan):
+        func = mpf_tan
+    else:
+        raise NotImplementedError
+    arg = v.args[0]
+    # 20 extra bits is possibly overkill. It does make the need
+    # to restart very unlikely
+    xprec = prec + 20
+    re, im, re_acc, im_acc = evalf(arg, xprec, options)
+    if im:
+        if 'subs' in options:
+            v = v.subs(options['subs'])
+        return evalf(v._eval_evalf(prec), prec, options)
+    if not re:
+        if isinstance(v, cos):
+            return fone, None, prec, None
+        elif isinstance(v, sin):
+            return None, None, None, None
+        elif isinstance(v,tan):
+            return None, None, None, None
+        else:
+            raise NotImplementedError
+    # For trigonometric functions, we are interested in the
+    # fixed-point (absolute) accuracy of the argument.
+    xsize = fastlog(re)
+    # Magnitude <= 1.0. OK to compute directly, because there is no
+    # danger of hitting the first root of cos (with sin, magnitude
+    # <= 2.0 would actually be ok)
+    if xsize < 1:
+        return func(re, prec, rnd), None, prec, None
+    # Very large
+    if xsize >= 10:
+        xprec = prec + xsize
+        re, im, re_acc, im_acc = evalf(arg, xprec, options)
+    # Need to repeat in case the argument is very close to a
+    # multiple of pi (or pi/2), hitting close to a root
+    while 1:
+        y = func(re, prec, rnd)
+        ysize = fastlog(y)
+        gap = -ysize
+        accuracy = (xprec - xsize) - gap
+        if accuracy < prec:
+            if options.get('verbose'):
+                print("SIN/COS/TAN", accuracy, "wanted", prec, "gap", gap)
+                print(to_str(y, 10))
+            if xprec > options.get('maxprec', DEFAULT_MAXPREC):
+                return y, None, accuracy, None
+            xprec += gap
+            re, im, re_acc, im_acc = evalf(arg, xprec, options)
+            continue
+        else:
+            return y, None, prec, None
+
+
+def evalf_log(expr: 'log', prec: int, options: OPT_DICT) -> TMP_RES:
+    if len(expr.args)>1:
+        expr = expr.doit()
+        return evalf(expr, prec, options)
+    arg = expr.args[0]
+    workprec = prec + 10
+    result = evalf(arg, workprec, options)
+    if result is S.ComplexInfinity:
+        return result
+    xre, xim, xacc, _ = result
+
+    # evalf can return NoneTypes if chop=True
+    # issue 18516, 19623
+    if xre is xim is None:
+        # Dear reviewer, I do not know what -inf is;
+        # it looks to be (1, 0, -789, -3)
+        # but I'm not sure in general,
+        # so we just let mpmath figure
+        # it out by taking log of 0 directly.
+        # It would be better to return -inf instead.
+        xre = fzero
+
+    if xim:
+        from sympy.functions.elementary.complexes import Abs
+        from sympy.functions.elementary.exponential import log
+
+        # XXX: use get_abs etc instead
+        re = evalf_log(
+            log(Abs(arg, evaluate=False), evaluate=False), prec, options)
+        im = mpf_atan2(xim, xre or fzero, prec)
+        return re[0], im, re[2], prec
+
+    imaginary_term = (mpf_cmp(xre, fzero) < 0)
+
+    re = mpf_log(mpf_abs(xre), prec, rnd)
+    size = fastlog(re)
+    if prec - size > workprec and re != fzero:
+        from .add import Add
+        # We actually need to compute 1+x accurately, not x
+        add = Add(S.NegativeOne, arg, evaluate=False)
+        xre, xim, _, _ = evalf_add(add, prec, options)
+        prec2 = workprec - fastlog(xre)
+        # xre is now x - 1 so we add 1 back here to calculate x
+        re = mpf_log(mpf_abs(mpf_add(xre, fone, prec2)), prec, rnd)
+
+    re_acc = prec
+
+    if imaginary_term:
+        return re, mpf_pi(prec), re_acc, prec
+    else:
+        return re, None, re_acc, None
+
+
+def evalf_atan(v: 'atan', prec: int, options: OPT_DICT) -> TMP_RES:
+    arg = v.args[0]
+    xre, xim, reacc, imacc = evalf(arg, prec + 5, options)
+    if xre is xim is None:
+        return (None,)*4
+    if xim:
+        raise NotImplementedError
+    return mpf_atan(xre, prec, rnd), None, prec, None
+
+
+def evalf_subs(prec: int, subs: dict) -> dict:
+    """ Change all Float entries in `subs` to have precision prec. """
+    newsubs = {}
+    for a, b in subs.items():
+        b = S(b)
+        if b.is_Float:
+            b = b._eval_evalf(prec)
+        newsubs[a] = b
+    return newsubs
+
+
+def evalf_piecewise(expr: Expr, prec: int, options: OPT_DICT) -> TMP_RES:
+    from .numbers import Float, Integer
+    if 'subs' in options:
+        expr = expr.subs(evalf_subs(prec, options['subs']))
+        newopts = options.copy()
+        del newopts['subs']
+        if hasattr(expr, 'func'):
+            return evalf(expr, prec, newopts)
+        if isinstance(expr, float):
+            return evalf(Float(expr), prec, newopts)
+        if isinstance(expr, int):
+            return evalf(Integer(expr), prec, newopts)
+
+    # We still have undefined symbols
+    raise NotImplementedError
+
+
+def evalf_alg_num(a: 'AlgebraicNumber', prec: int, options: OPT_DICT) -> TMP_RES:
+    return evalf(a.to_root(), prec, options)
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            High-level operations                           #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def as_mpmath(x: Any, prec: int, options: OPT_DICT) -> mpc | mpf:
+    from .numbers import Infinity, NegativeInfinity, Zero
+    x = sympify(x)
+    if isinstance(x, Zero) or x == 0.0:
+        return mpf(0)
+    if isinstance(x, Infinity):
+        return mpf('inf')
+    if isinstance(x, NegativeInfinity):
+        return mpf('-inf')
+    # XXX
+    result = evalf(x, prec, options)
+    return quad_to_mpmath(result)
+
+
+def do_integral(expr: 'Integral', prec: int, options: OPT_DICT) -> TMP_RES:
+    func = expr.args[0]
+    x, xlow, xhigh = expr.args[1]
+    if xlow == xhigh:
+        xlow = xhigh = 0
+    elif x not in func.free_symbols:
+        # only the difference in limits matters in this case
+        # so if there is a symbol in common that will cancel
+        # out when taking the difference, then use that
+        # difference
+        if xhigh.free_symbols & xlow.free_symbols:
+            diff = xhigh - xlow
+            if diff.is_number:
+                xlow, xhigh = 0, diff
+
+    oldmaxprec = options.get('maxprec', DEFAULT_MAXPREC)
+    options['maxprec'] = min(oldmaxprec, 2*prec)
+
+    with workprec(prec + 5):
+        xlow = as_mpmath(xlow, prec + 15, options)
+        xhigh = as_mpmath(xhigh, prec + 15, options)
+
+        # Integration is like summation, and we can phone home from
+        # the integrand function to update accuracy summation style
+        # Note that this accuracy is inaccurate, since it fails
+        # to account for the variable quadrature weights,
+        # but it is better than nothing
+
+        from sympy.functions.elementary.trigonometric import cos, sin
+        from .symbol import Wild
+
+        have_part = [False, False]
+        max_real_term: float | int = MINUS_INF
+        max_imag_term: float | int = MINUS_INF
+
+        def f(t: Expr) -> mpc | mpf:
+            nonlocal max_real_term, max_imag_term
+            re, im, re_acc, im_acc = evalf(func, mp.prec, {'subs': {x: t}})
+
+            have_part[0] = re or have_part[0]
+            have_part[1] = im or have_part[1]
+
+            max_real_term = max(max_real_term, fastlog(re))
+            max_imag_term = max(max_imag_term, fastlog(im))
+
+            if im:
+                return mpc(re or fzero, im)
+            return mpf(re or fzero)
+
+        if options.get('quad') == 'osc':
+            A = Wild('A', exclude=[x])
+            B = Wild('B', exclude=[x])
+            D = Wild('D')
+            m = func.match(cos(A*x + B)*D)
+            if not m:
+                m = func.match(sin(A*x + B)*D)
+            if not m:
+                raise ValueError("An integrand of the form sin(A*x+B)*f(x) "
+                  "or cos(A*x+B)*f(x) is required for oscillatory quadrature")
+            period = as_mpmath(2*S.Pi/m[A], prec + 15, options)
+            result = quadosc(f, [xlow, xhigh], period=period)
+            # XXX: quadosc does not do error detection yet
+            quadrature_error = MINUS_INF
+        else:
+            result, quadrature_err = quadts(f, [xlow, xhigh], error=1)
+            quadrature_error = fastlog(quadrature_err._mpf_)
+
+    options['maxprec'] = oldmaxprec
+
+    if have_part[0]:
+        re: MPF_TUP | None = result.real._mpf_
+        re_acc: int | None
+        if re == fzero:
+            re_s, re_acc = scaled_zero(int(-max(prec, max_real_term, quadrature_error)))
+            re = scaled_zero(re_s)  # handled ok in evalf_integral
+        else:
+            re_acc = int(-max(max_real_term - fastlog(re) - prec, quadrature_error))
+    else:
+        re, re_acc = None, None
+
+    if have_part[1]:
+        im: MPF_TUP | None = result.imag._mpf_
+        im_acc: int | None
+        if im == fzero:
+            im_s, im_acc = scaled_zero(int(-max(prec, max_imag_term, quadrature_error)))
+            im = scaled_zero(im_s)  # handled ok in evalf_integral
+        else:
+            im_acc = int(-max(max_imag_term - fastlog(im) - prec, quadrature_error))
+    else:
+        im, im_acc = None, None
+
+    result = re, im, re_acc, im_acc
+    return result
+
+
+def evalf_integral(expr: 'Integral', prec: int, options: OPT_DICT) -> TMP_RES:
+    limits = expr.limits
+    if len(limits) != 1 or len(limits[0]) != 3:
+        raise NotImplementedError
+    workprec = prec
+    i = 0
+    maxprec = options.get('maxprec', INF)
+    while 1:
+        result = do_integral(expr, workprec, options)
+        accuracy = complex_accuracy(result)
+        if accuracy >= prec:  # achieved desired precision
+            break
+        if workprec >= maxprec:  # can't increase accuracy any more
+            break
+        if accuracy == -1:
+            # maybe the answer really is zero and maybe we just haven't increased
+            # the precision enough. So increase by doubling to not take too long
+            # to get to maxprec.
+            workprec *= 2
+        else:
+            workprec += max(prec, 2**i)
+        workprec = min(workprec, maxprec)
+        i += 1
+    return result
+
+
+def check_convergence(numer: Expr, denom: Expr, n: Symbol) -> tuple[int, Any, Any]:
+    """
+    Returns
+    =======
+
+    (h, g, p) where
+    -- h is:
+        > 0 for convergence of rate 1/factorial(n)**h
+        < 0 for divergence of rate factorial(n)**(-h)
+        = 0 for geometric or polynomial convergence or divergence
+
+    -- abs(g) is:
+        > 1 for geometric convergence of rate 1/h**n
+        < 1 for geometric divergence of rate h**n
+        = 1 for polynomial convergence or divergence
+
+        (g < 0 indicates an alternating series)
+
+    -- p is:
+        > 1 for polynomial convergence of rate 1/n**h
+        <= 1 for polynomial divergence of rate n**(-h)
+
+    """
+    from sympy.polys.polytools import Poly
+    npol = Poly(numer, n)
+    dpol = Poly(denom, n)
+    p = npol.degree()
+    q = dpol.degree()
+    rate = q - p
+    if rate:
+        return rate, None, None
+    constant = dpol.LC() / npol.LC()
+    from .numbers import equal_valued
+    if not equal_valued(abs(constant), 1):
+        return rate, constant, None
+    if npol.degree() == dpol.degree() == 0:
+        return rate, constant, 0
+    pc = npol.all_coeffs()[1]
+    qc = dpol.all_coeffs()[1]
+    return rate, constant, (qc - pc)/dpol.LC()
+
+
+def hypsum(expr: Expr, n: Symbol, start: int, prec: int) -> mpf:
+    """
+    Sum a rapidly convergent infinite hypergeometric series with
+    given general term, e.g. e = hypsum(1/factorial(n), n). The
+    quotient between successive terms must be a quotient of integer
+    polynomials.
+    """
+    from .numbers import Float, equal_valued
+    from sympy.simplify.simplify import hypersimp
+
+    if prec == float('inf'):
+        raise NotImplementedError('does not support inf prec')
+
+    if start:
+        expr = expr.subs(n, n + start)
+    hs = hypersimp(expr, n)
+    if hs is None:
+        raise NotImplementedError("a hypergeometric series is required")
+    num, den = hs.as_numer_denom()
+
+    func1 = lambdify(n, num)
+    func2 = lambdify(n, den)
+
+    h, g, p = check_convergence(num, den, n)
+
+    if h < 0:
+        raise ValueError("Sum diverges like (n!)^%i" % (-h))
+
+    eterm = expr.subs(n, 0)
+    if not eterm.is_Rational:
+        raise NotImplementedError("Non rational term functionality is not implemented.")
+
+    term: Rational = eterm # type: ignore
+
+    # Direct summation if geometric or faster
+    if h > 0 or (h == 0 and abs(g) > 1):
+        term = (MPZ(term.p) << prec) // term.q
+        s = term
+        k = 1
+        while abs(term) > 5:
+            term *= MPZ(func1(k - 1))
+            term //= MPZ(func2(k - 1))
+            s += term
+            k += 1
+        return from_man_exp(s, -prec)
+    else:
+        alt = g < 0
+        if abs(g) < 1:
+            raise ValueError("Sum diverges like (%i)^n" % abs(1/g))
+        if p < 1 or (equal_valued(p, 1) and not alt):
+            raise ValueError("Sum diverges like n^%i" % (-p))
+        # We have polynomial convergence: use Richardson extrapolation
+        vold = None
+        ndig = prec_to_dps(prec)
+        while True:
+            # Need to use at least quad precision because a lot of cancellation
+            # might occur in the extrapolation process; we check the answer to
+            # make sure that the desired precision has been reached, too.
+            prec2 = 4*prec
+            term0 = (MPZ(term.p) << prec2) // term.q
+
+            def summand(k, _term=[term0]):
+                if k:
+                    k = int(k)
+                    _term[0] *= MPZ(func1(k - 1))
+                    _term[0] //= MPZ(func2(k - 1))
+                return make_mpf(from_man_exp(_term[0], -prec2))
+
+            with workprec(prec):
+                v = nsum(summand, [0, mpmath_inf], method='richardson')
+            vf = Float(v, ndig)
+            if vold is not None and vold == vf:
+                break
+            prec += prec  # double precision each time
+            vold = vf
+
+        return v._mpf_
+
+
+def evalf_prod(expr: 'Product', prec: int, options: OPT_DICT) -> TMP_RES:
+    if all((l[1] - l[2]).is_Integer for l in expr.limits):
+        result = evalf(expr.doit(), prec=prec, options=options)
+    else:
+        from sympy.concrete.summations import Sum
+        result = evalf(expr.rewrite(Sum), prec=prec, options=options)
+    return result
+
+
+def evalf_sum(expr: 'Sum', prec: int, options: OPT_DICT) -> TMP_RES:
+    from .numbers import Float
+    if 'subs' in options:
+        expr = expr.subs(options['subs']) # type: ignore
+    func = expr.function
+    limits = expr.limits
+    if len(limits) != 1 or len(limits[0]) != 3:
+        raise NotImplementedError
+    if func.is_zero:
+        return None, None, prec, None
+    prec2 = prec + 10
+    try:
+        n, a, b = limits[0]
+        if b is not S.Infinity or a is S.NegativeInfinity or a != int(a):
+            raise NotImplementedError
+        # Use fast hypergeometric summation if possible
+        v = hypsum(func, n, int(a), prec2)
+        delta = prec - fastlog(v)
+        if fastlog(v) < -10:
+            v = hypsum(func, n, int(a), delta)
+        return v, None, min(prec, delta), None
+    except NotImplementedError:
+        # Euler-Maclaurin summation for general series
+        eps = Float(2.0)**(-prec)
+        for i in range(1, 5):
+            m = n = 2**i * prec
+            s, err = expr.euler_maclaurin(m=m, n=n, eps=eps,
+                eval_integral=False)
+            err = err.evalf()
+            if err is S.NaN:
+                raise NotImplementedError
+            if err <= eps:
+                break
+        err = fastlog(evalf(abs(err), 20, options)[0])
+        re, im, re_acc, im_acc = evalf(s, prec2, options)
+        if re_acc is None:
+            re_acc = -err
+        if im_acc is None:
+            im_acc = -err
+        return re, im, re_acc, im_acc
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Symbolic interface                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def evalf_symbol(x: Expr, prec: int, options: OPT_DICT) -> TMP_RES:
+    val = options['subs'][x]
+    if isinstance(val, mpf):
+        if not val:
+            return None, None, None, None
+        return val._mpf_, None, prec, None
+    else:
+        if '_cache' not in options:
+            options['_cache'] = {}
+        cache = options['_cache']
+        cached, cached_prec = cache.get(x, (None, MINUS_INF))
+        if cached_prec >= prec:
+            return cached
+        v = evalf(sympify(val), prec, options)
+        cache[x] = (v, prec)
+        return v
+
+evalf_table: dict[Type[Expr], Callable[[Expr, int, OPT_DICT], TMP_RES]] = {}
+
+
+def _create_evalf_table():
+    global evalf_table
+    from sympy.concrete.products import Product
+    from sympy.concrete.summations import Sum
+    from .add import Add
+    from .mul import Mul
+    from .numbers import Exp1, Float, Half, ImaginaryUnit, Integer, NaN, NegativeOne, One, Pi, Rational, \
+        Zero, ComplexInfinity, AlgebraicNumber
+    from .power import Pow
+    from .symbol import Dummy, Symbol
+    from sympy.functions.elementary.complexes import Abs, im, re
+    from sympy.functions.elementary.exponential import exp, log
+    from sympy.functions.elementary.integers import ceiling, floor
+    from sympy.functions.elementary.piecewise import Piecewise
+    from sympy.functions.elementary.trigonometric import atan, cos, sin, tan
+    from sympy.integrals.integrals import Integral
+    evalf_table = {
+        Symbol: evalf_symbol,
+        Dummy: evalf_symbol,
+        Float: evalf_float,
+        Rational: evalf_rational,
+        Integer: evalf_integer,
+        Zero: lambda x, prec, options: (None, None, prec, None),
+        One: lambda x, prec, options: (fone, None, prec, None),
+        Half: lambda x, prec, options: (fhalf, None, prec, None),
+        Pi: lambda x, prec, options: (mpf_pi(prec), None, prec, None),
+        Exp1: lambda x, prec, options: (mpf_e(prec), None, prec, None),
+        ImaginaryUnit: lambda x, prec, options: (None, fone, None, prec),
+        NegativeOne: lambda x, prec, options: (fnone, None, prec, None),
+        ComplexInfinity: lambda x, prec, options: S.ComplexInfinity,
+        NaN: lambda x, prec, options: (fnan, None, prec, None),
+
+        exp: evalf_exp,
+
+        cos: evalf_trig,
+        sin: evalf_trig,
+        tan: evalf_trig,
+
+        Add: evalf_add,
+        Mul: evalf_mul,
+        Pow: evalf_pow,
+
+        log: evalf_log,
+        atan: evalf_atan,
+        Abs: evalf_abs,
+
+        re: evalf_re,
+        im: evalf_im,
+        floor: evalf_floor,
+        ceiling: evalf_ceiling,
+
+        Integral: evalf_integral,
+        Sum: evalf_sum,
+        Product: evalf_prod,
+        Piecewise: evalf_piecewise,
+
+        AlgebraicNumber: evalf_alg_num,
+    }
+
+
+def evalf(x: Expr, prec: int, options: OPT_DICT) -> TMP_RES:
+    """
+    Evaluate the ``Expr`` instance, ``x``
+    to a binary precision of ``prec``. This
+    function is supposed to be used internally.
+
+    Parameters
+    ==========
+
+    x : Expr
+        The formula to evaluate to a float.
+    prec : int
+        The binary precision that the output should have.
+    options : dict
+        A dictionary with the same entries as
+        ``EvalfMixin.evalf`` and in addition,
+        ``maxprec`` which is the maximum working precision.
+
+    Returns
+    =======
+
+    An optional tuple, ``(re, im, re_acc, im_acc)``
+    which are the real, imaginary, real accuracy
+    and imaginary accuracy respectively. ``re`` is
+    an mpf value tuple and so is ``im``. ``re_acc``
+    and ``im_acc`` are ints.
+
+    NB: all these return values can be ``None``.
+    If all values are ``None``, then that represents 0.
+    Note that 0 is also represented as ``fzero = (0, 0, 0, 0)``.
+    """
+    from sympy.functions.elementary.complexes import re as re_, im as im_
+    try:
+        rf = evalf_table[type(x)]
+        r = rf(x, prec, options)
+    except KeyError:
+        # Fall back to ordinary evalf if possible
+        if 'subs' in options:
+            x = x.subs(evalf_subs(prec, options['subs']))
+        xe = x._eval_evalf(prec)
+        if xe is None:
+            raise NotImplementedError
+        as_real_imag = getattr(xe, "as_real_imag", None)
+        if as_real_imag is None:
+            raise NotImplementedError # e.g. FiniteSet(-1.0, 1.0).evalf()
+        re, im = as_real_imag()
+        if re.has(re_) or im.has(im_):
+            raise NotImplementedError
+        if not re:
+            re = None
+            reprec = None
+        elif re.is_number:
+            re = re._to_mpmath(prec, allow_ints=False)._mpf_
+            reprec = prec
+        else:
+            raise NotImplementedError
+        if not im:
+            im = None
+            imprec = None
+        elif im.is_number:
+            im = im._to_mpmath(prec, allow_ints=False)._mpf_
+            imprec = prec
+        else:
+            raise NotImplementedError
+        r = re, im, reprec, imprec
+
+    if options.get("verbose"):
+        print("### input", x)
+        print("### output", to_str(r[0] or fzero, 50) if isinstance(r, tuple) else r)
+        print("### raw", r) # r[0], r[2]
+        print()
+    chop = options.get('chop', False)
+    if chop:
+        if chop is True:
+            chop_prec = prec
+        else:
+            # convert (approximately) from given tolerance;
+            # the formula here will will make 1e-i rounds to 0 for
+            # i in the range +/-27 while 2e-i will not be chopped
+            chop_prec = int(round(-3.321*math.log10(chop) + 2.5))
+            if chop_prec == 3:
+                chop_prec -= 1
+        r = chop_parts(r, chop_prec)
+    if options.get("strict"):
+        check_target(x, r, prec)
+    return r
+
+
+def quad_to_mpmath(q, ctx=None):
+    """Turn the quad returned by ``evalf`` into an ``mpf`` or ``mpc``. """
+    mpc = make_mpc if ctx is None else ctx.make_mpc
+    mpf = make_mpf if ctx is None else ctx.make_mpf
+    if q is S.ComplexInfinity:
+        raise NotImplementedError
+    re, im, _, _ = q
+    if im:
+        if not re:
+            re = fzero
+        return mpc((re, im))
+    elif re:
+        return mpf(re)
+    else:
+        return mpf(fzero)
+
+
+class EvalfMixin:
+    """Mixin class adding evalf capability."""
+
+    __slots__: tuple[str, ...] = ()
+
+    def evalf(self, n=15, subs=None, maxn=100, chop=False, strict=False, quad=None, verbose=False):
+        """
+        Evaluate the given formula to an accuracy of *n* digits.
+
+        Parameters
+        ==========
+
+        subs : dict, optional
+            Substitute numerical values for symbols, e.g.
+            ``subs={x:3, y:1+pi}``. The substitutions must be given as a
+            dictionary.
+
+        maxn : int, optional
+            Allow a maximum temporary working precision of maxn digits.
+
+        chop : bool or number, optional
+            Specifies how to replace tiny real or imaginary parts in
+            subresults by exact zeros.
+
+            When ``True`` the chop value defaults to standard precision.
+
+            Otherwise the chop value is used to determine the
+            magnitude of "small" for purposes of chopping.
+
+            >>> from sympy import N
+            >>> x = 1e-4
+            >>> N(x, chop=True)
+            0.000100000000000000
+            >>> N(x, chop=1e-5)
+            0.000100000000000000
+            >>> N(x, chop=1e-4)
+            0
+
+        strict : bool, optional
+            Raise ``PrecisionExhausted`` if any subresult fails to
+            evaluate to full accuracy, given the available maxprec.
+
+        quad : str, optional
+            Choose algorithm for numerical quadrature. By default,
+            tanh-sinh quadrature is used. For oscillatory
+            integrals on an infinite interval, try ``quad='osc'``.
+
+        verbose : bool, optional
+            Print debug information.
+
+        Notes
+        =====
+
+        When Floats are naively substituted into an expression,
+        precision errors may adversely affect the result. For example,
+        adding 1e16 (a Float) to 1 will truncate to 1e16; if 1e16 is
+        then subtracted, the result will be 0.
+        That is exactly what happens in the following:
+
+        >>> from sympy.abc import x, y, z
+        >>> values = {x: 1e16, y: 1, z: 1e16}
+        >>> (x + y - z).subs(values)
+        0
+
+        Using the subs argument for evalf is the accurate way to
+        evaluate such an expression:
+
+        >>> (x + y - z).evalf(subs=values)
+        1.00000000000000
+        """
+        from .numbers import Float, Number
+        n = n if n is not None else 15
+
+        if subs and is_sequence(subs):
+            raise TypeError('subs must be given as a dictionary')
+
+        # for sake of sage that doesn't like evalf(1)
+        if n == 1 and isinstance(self, Number):
+            from .expr import _mag
+            rv = self.evalf(2, subs, maxn, chop, strict, quad, verbose)
+            m = _mag(rv)
+            rv = rv.round(1 - m)
+            return rv
+
+        if not evalf_table:
+            _create_evalf_table()
+        prec = dps_to_prec(n)
+        options = {'maxprec': max(prec, int(maxn*LG10)), 'chop': chop,
+               'strict': strict, 'verbose': verbose}
+        if subs is not None:
+            options['subs'] = subs
+        if quad is not None:
+            options['quad'] = quad
+        try:
+            result = evalf(self, prec + 4, options)
+        except NotImplementedError:
+            # Fall back to the ordinary evalf
+            if hasattr(self, 'subs') and subs is not None:  # issue 20291
+                v = self.subs(subs)._eval_evalf(prec)
+            else:
+                v = self._eval_evalf(prec)
+            if v is None:
+                return self
+            elif not v.is_number:
+                return v
+            try:
+                # If the result is numerical, normalize it
+                result = evalf(v, prec, options)
+            except NotImplementedError:
+                # Probably contains symbols or unknown functions
+                return v
+        if result is S.ComplexInfinity:
+            return result
+        re, im, re_acc, im_acc = result
+        if re is S.NaN or im is S.NaN:
+            return S.NaN
+        if re:
+            p = max(min(prec, re_acc), 1)
+            re = Float._new(re, p)
+        else:
+            re = S.Zero
+        if im:
+            p = max(min(prec, im_acc), 1)
+            im = Float._new(im, p)
+            return re + im*S.ImaginaryUnit
+        else:
+            return re
+
+    n = evalf
+
+    def _evalf(self, prec: int) -> Expr:
+        """Helper for evalf. Does the same thing but takes binary precision"""
+        r = self._eval_evalf(prec)
+        if r is None:
+            r = self # type: ignore
+        return r # type: ignore
+
+    def _eval_evalf(self, prec: int) -> Expr | None:
+        return None
+
+    def _to_mpmath(self, prec, allow_ints=True):
+        # mpmath functions accept ints as input
+        errmsg = "cannot convert to mpmath number"
+        if allow_ints and self.is_Integer:
+            return self.p
+        if hasattr(self, '_as_mpf_val'):
+            return make_mpf(self._as_mpf_val(prec))
+        try:
+            result = evalf(self, prec, {})
+            return quad_to_mpmath(result)
+        except NotImplementedError:
+            v = self._eval_evalf(prec)
+            if v is None:
+                raise ValueError(errmsg)
+            if v.is_Float:
+                return make_mpf(v._mpf_)
+            # Number + Number*I is also fine
+            re, im = v.as_real_imag()
+            if allow_ints and re.is_Integer:
+                re = from_int(re.p)
+            elif re.is_Float:
+                re = re._mpf_
+            else:
+                raise ValueError(errmsg)
+            if allow_ints and im.is_Integer:
+                im = from_int(im.p)
+            elif im.is_Float:
+                im = im._mpf_
+            else:
+                raise ValueError(errmsg)
+            return make_mpc((re, im))
+
+
+def N(x, n=15, **options):
+    r"""
+    Calls x.evalf(n, \*\*options).
+
+    Explanations
+    ============
+
+    Both .n() and N() are equivalent to .evalf(); use the one that you like better.
+    See also the docstring of .evalf() for information on the options.
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, oo, N
+    >>> from sympy.abc import k
+    >>> Sum(1/k**k, (k, 1, oo))
+    Sum(k**(-k), (k, 1, oo))
+    >>> N(_, 4)
+    1.291
+
+    """
+    # by using rational=True, any evaluation of a string
+    # will be done using exact values for the Floats
+    return sympify(x, rational=True).evalf(n, **options)
+
+
+def _evalf_with_bounded_error(x: Expr, eps: Expr | None = None,
+                              m: int = 0,
+                              options: OPT_DICT | None = None) -> TMP_RES:
+    """
+    Evaluate *x* to within a bounded absolute error.
+
+    Parameters
+    ==========
+
+    x : Expr
+        The quantity to be evaluated.
+    eps : Expr, None, optional (default=None)
+        Positive real upper bound on the acceptable error.
+    m : int, optional (default=0)
+        If *eps* is None, then use 2**(-m) as the upper bound on the error.
+    options: OPT_DICT
+        As in the ``evalf`` function.
+
+    Returns
+    =======
+
+    A tuple ``(re, im, re_acc, im_acc)``, as returned by ``evalf``.
+
+    See Also
+    ========
+
+    evalf
+
+    """
+    if eps is not None:
+        if not (eps.is_Rational or eps.is_Float) or not eps > 0:
+            raise ValueError("eps must be positive")
+        r, _, _, _ = evalf(1/eps, 1, {})
+        m = fastlog(r)
+
+    c, d, _, _ = evalf(x, 1, {})
+    # Note: If x = a + b*I, then |a| <= 2|c| and |b| <= 2|d|, with equality
+    # only in the zero case.
+    # If a is non-zero, then |c| = 2**nc for some integer nc, and c has
+    # bitcount 1. Therefore 2**fastlog(c) = 2**(nc+1) = 2|c| is an upper bound
+    # on |a|. Likewise for b and d.
+    nr, ni = fastlog(c), fastlog(d)
+    n = max(nr, ni) + 1
+    # If x is 0, then n is MINUS_INF, and p will be 1. Otherwise,
+    # n - 1 bits get us past the integer parts of a and b, and +1 accounts for
+    # the factor of <= sqrt(2) that is |x|/max(|a|, |b|).
+    p = max(1, m + n + 1)
+
+    options = options or {}
+    return evalf(x, p, options)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/expr.py b/.venv/lib/python3.12/site-packages/sympy/core/expr.py
new file mode 100644
index 0000000000000000000000000000000000000000..e66ff239a679942f2cc95c3f66af1fc13f7229d9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/expr.py
@@ -0,0 +1,4194 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, overload
+from collections.abc import Iterable, Mapping
+from functools import reduce
+import re
+
+from .sympify import sympify, _sympify
+from .basic import Basic, Atom
+from .singleton import S
+from .evalf import EvalfMixin, pure_complex, DEFAULT_MAXPREC
+from .decorators import call_highest_priority, sympify_method_args, sympify_return
+from .cache import cacheit
+from .logic import fuzzy_or, fuzzy_not
+from .intfunc import mod_inverse
+from .sorting import default_sort_key
+from .kind import NumberKind
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.misc import as_int, func_name, filldedent
+from sympy.utilities.iterables import has_variety, sift
+from mpmath.libmp import mpf_log, prec_to_dps
+from mpmath.libmp.libintmath import giant_steps
+
+
+if TYPE_CHECKING:
+    from typing import Any
+    from typing_extensions import Self
+    from .numbers import Number
+
+from collections import defaultdict
+
+
+def _corem(eq, c):  # helper for extract_additively
+    # return co, diff from co*c + diff
+    co = []
+    non = []
+    for i in Add.make_args(eq):
+        ci = i.coeff(c)
+        if not ci:
+            non.append(i)
+        else:
+            co.append(ci)
+    return Add(*co), Add(*non)
+
+
+@sympify_method_args
+class Expr(Basic, EvalfMixin):
+    """
+    Base class for algebraic expressions.
+
+    Explanation
+    ===========
+
+    Everything that requires arithmetic operations to be defined
+    should subclass this class, instead of Basic (which should be
+    used only for argument storage and expression manipulation, i.e.
+    pattern matching, substitutions, etc).
+
+    If you want to override the comparisons of expressions:
+    Should use _eval_is_ge for inequality, or _eval_is_eq, with multiple dispatch.
+    _eval_is_ge return true if x >= y, false if x < y, and None if the two types
+    are not comparable or the comparison is indeterminate
+
+    See Also
+    ========
+
+    sympy.core.basic.Basic
+    """
+
+    __slots__: tuple[str, ...] = ()
+
+    if TYPE_CHECKING:
+
+        def __new__(cls, *args: Basic) -> Self:
+            ...
+
+        @overload # type: ignore
+        def subs(self, arg1: Mapping[Basic | complex, Expr | complex], arg2: None=None) -> Expr: ...
+        @overload
+        def subs(self, arg1: Iterable[tuple[Basic | complex, Expr | complex]], arg2: None=None, **kwargs: Any) -> Expr: ...
+        @overload
+        def subs(self, arg1: Expr | complex, arg2: Expr | complex) -> Expr: ...
+        @overload
+        def subs(self, arg1: Mapping[Basic | complex, Basic | complex], arg2: None=None, **kwargs: Any) -> Basic: ...
+        @overload
+        def subs(self, arg1: Iterable[tuple[Basic | complex, Basic | complex]], arg2: None=None, **kwargs: Any) -> Basic: ...
+        @overload
+        def subs(self, arg1: Basic | complex, arg2: Basic | complex, **kwargs: Any) -> Basic: ...
+
+        def subs(self, arg1: Mapping[Basic | complex, Basic | complex] | Basic | complex, # type: ignore
+                 arg2: Basic | complex | None = None, **kwargs: Any) -> Basic:
+            ...
+
+        def simplify(self, **kwargs) -> Expr:
+            ...
+
+        def evalf(self, n: int = 15, subs: dict[Basic, Basic | float] | None = None,
+                  maxn: int = 100, chop: bool = False, strict: bool  = False,
+                  quad: str | None = None, verbose: bool = False) -> Expr:
+            ...
+
+        n = evalf
+
+    is_scalar = True  # self derivative is 1
+
+    @property
+    def _diff_wrt(self):
+        """Return True if one can differentiate with respect to this
+        object, else False.
+
+        Explanation
+        ===========
+
+        Subclasses such as Symbol, Function and Derivative return True
+        to enable derivatives wrt them. The implementation in Derivative
+        separates the Symbol and non-Symbol (_diff_wrt=True) variables and
+        temporarily converts the non-Symbols into Symbols when performing
+        the differentiation. By default, any object deriving from Expr
+        will behave like a scalar with self.diff(self) == 1. If this is
+        not desired then the object must also set `is_scalar = False` or
+        else define an _eval_derivative routine.
+
+        Note, see the docstring of Derivative for how this should work
+        mathematically. In particular, note that expr.subs(yourclass, Symbol)
+        should be well-defined on a structural level, or this will lead to
+        inconsistent results.
+
+        Examples
+        ========
+
+        >>> from sympy import Expr
+        >>> e = Expr()
+        >>> e._diff_wrt
+        False
+        >>> class MyScalar(Expr):
+        ...     _diff_wrt = True
+        ...
+        >>> MyScalar().diff(MyScalar())
+        1
+        >>> class MySymbol(Expr):
+        ...     _diff_wrt = True
+        ...     is_scalar = False
+        ...
+        >>> MySymbol().diff(MySymbol())
+        Derivative(MySymbol(), MySymbol())
+        """
+        return False
+
+    @cacheit
+    def sort_key(self, order=None):
+
+        coeff, expr = self.as_coeff_Mul()
+
+        if expr.is_Pow:
+            base, exp = expr.as_base_exp()
+            if base is S.Exp1:
+                # If we remove this, many doctests will go crazy:
+                # (keeps E**x sorted like the exp(x) function,
+                #  part of exp(x) to E**x transition)
+                base, exp = Function("exp")(exp), S.One
+            expr = base
+        else:
+            exp = S.One
+
+        if expr.is_Dummy:
+            args = (expr.sort_key(),)
+        elif expr.is_Atom:
+            args = (str(expr),)
+        else:
+            if expr.is_Add:
+                args = expr.as_ordered_terms(order=order)
+            elif expr.is_Mul:
+                args = expr.as_ordered_factors(order=order)
+            else:
+                args = expr.args
+
+            args = tuple(
+                [ default_sort_key(arg, order=order) for arg in args ])
+
+        args = (len(args), tuple(args))
+        exp = exp.sort_key(order=order)
+
+        return expr.class_key(), args, exp, coeff
+
+    def _hashable_content(self):
+        """Return a tuple of information about self that can be used to
+        compute the hash. If a class defines additional attributes,
+        like ``name`` in Symbol, then this method should be updated
+        accordingly to return such relevant attributes.
+        Defining more than _hashable_content is necessary if __eq__ has
+        been defined by a class. See note about this in Basic.__eq__."""
+        return self._args
+
+    # ***************
+    # * Arithmetics *
+    # ***************
+    # Expr and its subclasses use _op_priority to determine which object
+    # passed to a binary special method (__mul__, etc.) will handle the
+    # operation. In general, the 'call_highest_priority' decorator will choose
+    # the object with the highest _op_priority to handle the call.
+    # Custom subclasses that want to define their own binary special methods
+    # should set an _op_priority value that is higher than the default.
+    #
+    # **NOTE**:
+    # This is a temporary fix, and will eventually be replaced with
+    # something better and more powerful.  See issue 5510.
+    _op_priority = 10.0
+
+    @property
+    def _add_handler(self):
+        return Add
+
+    @property
+    def _mul_handler(self):
+        return Mul
+
+    def __pos__(self) -> Expr:
+        return self
+
+    def __neg__(self) -> Expr:
+        # Mul has its own __neg__ routine, so we just
+        # create a 2-args Mul with the -1 in the canonical
+        # slot 0.
+        c = self.is_commutative
+        return Mul._from_args((S.NegativeOne, self), c)
+
+    def __abs__(self) -> Expr:
+        from sympy.functions.elementary.complexes import Abs
+        return Abs(self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__radd__')
+    def __add__(self, other) -> Expr:
+        return Add(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__add__')
+    def __radd__(self, other) -> Expr:
+        return Add(other, self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rsub__')
+    def __sub__(self, other) -> Expr:
+        return Add(self, -other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__sub__')
+    def __rsub__(self, other) -> Expr:
+        return Add(other, -self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other) -> Expr:
+        return Mul(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other) -> Expr:
+        return Mul(other, self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rpow__')
+    def _pow(self, other):
+        return Pow(self, other)
+
+    def __pow__(self, other, mod=None) -> Expr:
+        if mod is None:
+            return self._pow(other)
+        try:
+            _self, other, mod = as_int(self), as_int(other), as_int(mod)
+            if other >= 0:
+                return _sympify(pow(_self, other, mod))
+            else:
+                return _sympify(mod_inverse(pow(_self, -other, mod), mod))
+        except ValueError:
+            power = self._pow(other)
+            try:
+                return power%mod
+            except TypeError:
+                return NotImplemented
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__pow__')
+    def __rpow__(self, other) -> Expr:
+        return Pow(other, self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other) -> Expr:
+        denom = Pow(other, S.NegativeOne)
+        if self is S.One:
+            return denom
+        else:
+            return Mul(self, denom)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__truediv__')
+    def __rtruediv__(self, other) -> Expr:
+        denom = Pow(self, S.NegativeOne)
+        if other is S.One:
+            return denom
+        else:
+            return Mul(other, denom)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rmod__')
+    def __mod__(self, other) -> Expr:
+        return Mod(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__mod__')
+    def __rmod__(self, other) -> Expr:
+        return Mod(other, self)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rfloordiv__')
+    def __floordiv__(self, other) -> Expr:
+        from sympy.functions.elementary.integers import floor
+        return floor(self / other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__floordiv__')
+    def __rfloordiv__(self, other) -> Expr:
+        from sympy.functions.elementary.integers import floor
+        return floor(other / self)
+
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__rdivmod__')
+    def __divmod__(self, other) -> tuple[Expr, Expr]:
+        from sympy.functions.elementary.integers import floor
+        return floor(self / other), Mod(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    @call_highest_priority('__divmod__')
+    def __rdivmod__(self, other) -> tuple[Expr, Expr]:
+        from sympy.functions.elementary.integers import floor
+        return floor(other / self), Mod(other, self)
+
+    def __int__(self) -> int:
+        if not self.is_number:
+            raise TypeError("Cannot convert symbols to int")
+        r = self.round(2)
+        if not r.is_Number:
+            raise TypeError("Cannot convert complex to int")
+        if r in (S.NaN, S.Infinity, S.NegativeInfinity):
+            raise TypeError("Cannot convert %s to int" % r)
+        i = int(r)
+        if not i:
+            return i
+        if int_valued(r):
+            # non-integer self should pass one of these tests
+            if (self > i) is S.true:
+                return i
+            if (self < i) is S.true:
+                return i - 1
+            ok = self.equals(i)
+            if ok is None:
+                raise TypeError('cannot compute int value accurately')
+            if ok:
+                return i
+            # off by one
+            return i - (1 if i > 0 else -1)
+        return i
+
+    def __float__(self) -> float:
+        # Don't bother testing if it's a number; if it's not this is going
+        # to fail, and if it is we still need to check that it evalf'ed to
+        # a number.
+        result = self.evalf()
+        if result.is_Number:
+            return float(result)
+        if result.is_number and result.as_real_imag()[1]:
+            raise TypeError("Cannot convert complex to float")
+        raise TypeError("Cannot convert expression to float")
+
+    def __complex__(self) -> complex:
+        result = self.evalf()
+        re, im = result.as_real_imag()
+        return complex(float(re), float(im))
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    def __ge__(self, other):
+        from .relational import GreaterThan
+        return GreaterThan(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    def __le__(self, other):
+        from .relational import LessThan
+        return LessThan(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    def __gt__(self, other):
+        from .relational import StrictGreaterThan
+        return StrictGreaterThan(self, other)
+
+    @sympify_return([('other', 'Expr')], NotImplemented)
+    def __lt__(self, other):
+        from .relational import StrictLessThan
+        return StrictLessThan(self, other)
+
+    def __trunc__(self):
+        if not self.is_number:
+            raise TypeError("Cannot truncate symbols and expressions")
+        else:
+            return Integer(self)
+
+    def __format__(self, format_spec: str):
+        if self.is_number:
+            mt = re.match(r'\+?\d*\.(\d+)f', format_spec)
+            if mt:
+                prec = int(mt.group(1))
+                rounded = self.round(prec)
+                if rounded.is_Integer:
+                    return format(int(rounded), format_spec)
+                if rounded.is_Float:
+                    return format(rounded, format_spec)
+        return super().__format__(format_spec)
+
+    @staticmethod
+    def _from_mpmath(x, prec):
+        if hasattr(x, "_mpf_"):
+            return Float._new(x._mpf_, prec)
+        elif hasattr(x, "_mpc_"):
+            re, im = x._mpc_
+            re = Float._new(re, prec)
+            im = Float._new(im, prec)*S.ImaginaryUnit
+            return re + im
+        else:
+            raise TypeError("expected mpmath number (mpf or mpc)")
+
+    @property
+    def is_number(self):
+        """Returns True if ``self`` has no free symbols and no
+        undefined functions (AppliedUndef, to be precise). It will be
+        faster than ``if not self.free_symbols``, however, since
+        ``is_number`` will fail as soon as it hits a free symbol
+        or undefined function.
+
+        Examples
+        ========
+
+        >>> from sympy import Function, Integral, cos, sin, pi
+        >>> from sympy.abc import x
+        >>> f = Function('f')
+
+        >>> x.is_number
+        False
+        >>> f(1).is_number
+        False
+        >>> (2*x).is_number
+        False
+        >>> (2 + Integral(2, x)).is_number
+        False
+        >>> (2 + Integral(2, (x, 1, 2))).is_number
+        True
+
+        Not all numbers are Numbers in the SymPy sense:
+
+        >>> pi.is_number, pi.is_Number
+        (True, False)
+
+        If something is a number it should evaluate to a number with
+        real and imaginary parts that are Numbers; the result may not
+        be comparable, however, since the real and/or imaginary part
+        of the result may not have precision.
+
+        >>> cos(1).is_number and cos(1).is_comparable
+        True
+
+        >>> z = cos(1)**2 + sin(1)**2 - 1
+        >>> z.is_number
+        True
+        >>> z.is_comparable
+        False
+
+        See Also
+        ========
+
+        sympy.core.basic.Basic.is_comparable
+        """
+        return all(obj.is_number for obj in self.args)
+
+    def _eval_is_comparable(self):
+        # Basic._eval_is_comparable always returns False, so we override it
+        # here
+        is_extended_real = self.is_extended_real
+        if is_extended_real is False:
+            return False
+        if not self.is_number:
+            return False
+
+        # XXX: as_real_imag() can be a very expensive operation. It should not
+        # be used here because is_comparable is used implicitly in many places.
+        # Probably this method should just return self.evalf(2).is_Number.
+
+        n, i = self.as_real_imag()
+
+        if not n.is_Number:
+            n = n.evalf(2)
+            if not n.is_Number:
+                return False
+
+        if not i.is_Number:
+            i = i.evalf(2)
+            if not i.is_Number:
+                return False
+
+        if i:
+            # if _prec = 1 we can't decide and if not,
+            # the answer is False because numbers with
+            # imaginary parts can't be compared
+            # so return False
+            return False
+        else:
+            return n._prec != 1
+
+    def _random(self, n=None, re_min=-1, im_min=-1, re_max=1, im_max=1):
+        """Return self evaluated, if possible, replacing free symbols with
+        random complex values, if necessary.
+
+        Explanation
+        ===========
+
+        The random complex value for each free symbol is generated
+        by the random_complex_number routine giving real and imaginary
+        parts in the range given by the re_min, re_max, im_min, and im_max
+        values. The returned value is evaluated to a precision of n
+        (if given) else the maximum of 15 and the precision needed
+        to get more than 1 digit of precision. If the expression
+        could not be evaluated to a number, or could not be evaluated
+        to more than 1 digit of precision, then None is returned.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> from sympy.abc import x, y
+        >>> x._random()                         # doctest: +SKIP
+        0.0392918155679172 + 0.916050214307199*I
+        >>> x._random(2)                        # doctest: +SKIP
+        -0.77 - 0.87*I
+        >>> (x + y/2)._random(2)                # doctest: +SKIP
+        -0.57 + 0.16*I
+        >>> sqrt(2)._random(2)
+        1.4
+
+        See Also
+        ========
+
+        sympy.core.random.random_complex_number
+        """
+
+        free = self.free_symbols
+        prec = 1
+        if free:
+            from sympy.core.random import random_complex_number
+            a, c, b, d = re_min, re_max, im_min, im_max
+            reps = dict(list(zip(free, [random_complex_number(a, b, c, d, rational=True)
+                           for zi in free])))
+            try:
+                nmag = abs(self.evalf(2, subs=reps))
+            except (ValueError, TypeError):
+                # if an out of range value resulted in evalf problems
+                # then return None -- XXX is there a way to know how to
+                # select a good random number for a given expression?
+                # e.g. when calculating n! negative values for n should not
+                # be used
+                return None
+        else:
+            reps = {}
+            nmag = abs(self.evalf(2))
+
+        if not hasattr(nmag, '_prec'):
+            # e.g. exp_polar(2*I*pi) doesn't evaluate but is_number is True
+            return None
+
+        if nmag._prec == 1:
+            # increase the precision up to the default maximum
+            # precision to see if we can get any significance
+
+            # evaluate
+            for prec in giant_steps(2, DEFAULT_MAXPREC):
+                nmag = abs(self.evalf(prec, subs=reps))
+                if nmag._prec != 1:
+                    break
+
+        if nmag._prec != 1:
+            if n is None:
+                n = max(prec, 15)
+            return self.evalf(n, subs=reps)
+
+        # never got any significance
+        return None
+
+    def is_constant(self, *wrt, **flags):
+        """Return True if self is constant, False if not, or None if
+        the constancy could not be determined conclusively.
+
+        Explanation
+        ===========
+
+        If an expression has no free symbols then it is a constant. If
+        there are free symbols it is possible that the expression is a
+        constant, perhaps (but not necessarily) zero. To test such
+        expressions, a few strategies are tried:
+
+        1) numerical evaluation at two random points. If two such evaluations
+        give two different values and the values have a precision greater than
+        1 then self is not constant. If the evaluations agree or could not be
+        obtained with any precision, no decision is made. The numerical testing
+        is done only if ``wrt`` is different than the free symbols.
+
+        2) differentiation with respect to variables in 'wrt' (or all free
+        symbols if omitted) to see if the expression is constant or not. This
+        will not always lead to an expression that is zero even though an
+        expression is constant (see added test in test_expr.py). If
+        all derivatives are zero then self is constant with respect to the
+        given symbols.
+
+        3) finding out zeros of denominator expression with free_symbols.
+        It will not be constant if there are zeros. It gives more negative
+        answers for expression that are not constant.
+
+        If neither evaluation nor differentiation can prove the expression is
+        constant, None is returned unless two numerical values happened to be
+        the same and the flag ``failing_number`` is True -- in that case the
+        numerical value will be returned.
+
+        If flag simplify=False is passed, self will not be simplified;
+        the default is True since self should be simplified before testing.
+
+        Examples
+        ========
+
+        >>> from sympy import cos, sin, Sum, S, pi
+        >>> from sympy.abc import a, n, x, y
+        >>> x.is_constant()
+        False
+        >>> S(2).is_constant()
+        True
+        >>> Sum(x, (x, 1, 10)).is_constant()
+        True
+        >>> Sum(x, (x, 1, n)).is_constant()
+        False
+        >>> Sum(x, (x, 1, n)).is_constant(y)
+        True
+        >>> Sum(x, (x, 1, n)).is_constant(n)
+        False
+        >>> Sum(x, (x, 1, n)).is_constant(x)
+        True
+        >>> eq = a*cos(x)**2 + a*sin(x)**2 - a
+        >>> eq.is_constant()
+        True
+        >>> eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
+        True
+
+        >>> (0**x).is_constant()
+        False
+        >>> x.is_constant()
+        False
+        >>> (x**x).is_constant()
+        False
+        >>> one = cos(x)**2 + sin(x)**2
+        >>> one.is_constant()
+        True
+        >>> ((one - 1)**(x + 1)).is_constant() in (True, False) # could be 0 or 1
+        True
+        """
+
+        simplify = flags.get('simplify', True)
+
+        if self.is_number:
+            return True
+        free = self.free_symbols
+        if not free:
+            return True  # assume f(1) is some constant
+
+        # if we are only interested in some symbols and they are not in the
+        # free symbols then this expression is constant wrt those symbols
+        wrt = set(wrt)
+        if wrt and not wrt & free:
+            return True
+        wrt = wrt or free
+
+        # simplify unless this has already been done
+        expr = self
+        if simplify:
+            expr = expr.simplify()
+
+        # is_zero should be a quick assumptions check; it can be wrong for
+        # numbers (see test_is_not_constant test), giving False when it
+        # shouldn't, but hopefully it will never give True unless it is sure.
+        if expr.is_zero:
+            return True
+
+        # Don't attempt substitution or differentiation with non-number symbols
+        wrt_number = {sym for sym in wrt if sym.kind is NumberKind}
+
+        # try numerical evaluation to see if we get two different values
+        failing_number = None
+        if wrt_number == free:
+            # try 0 (for a) and 1 (for b)
+            try:
+                a = expr.subs(list(zip(free, [0]*len(free))),
+                    simultaneous=True)
+                if a is S.NaN:
+                    # evaluation may succeed when substitution fails
+                    a = expr._random(None, 0, 0, 0, 0)
+            except ZeroDivisionError:
+                a = None
+            if a is not None and a is not S.NaN:
+                try:
+                    b = expr.subs(list(zip(free, [1]*len(free))),
+                        simultaneous=True)
+                    if b is S.NaN:
+                        # evaluation may succeed when substitution fails
+                        b = expr._random(None, 1, 0, 1, 0)
+                except ZeroDivisionError:
+                    b = None
+                if b is not None and b is not S.NaN and b.equals(a) is False:
+                    return False
+                # try random real
+                b = expr._random(None, -1, 0, 1, 0)
+                if b is not None and b is not S.NaN and b.equals(a) is False:
+                    return False
+                # try random complex
+                b = expr._random()
+                if b is not None and b is not S.NaN:
+                    if b.equals(a) is False:
+                        return False
+                    failing_number = a if a.is_number else b
+
+        # now we will test each wrt symbol (or all free symbols) to see if the
+        # expression depends on them or not using differentiation. This is
+        # not sufficient for all expressions, however, so we don't return
+        # False if we get a derivative other than 0 with free symbols.
+        for w in wrt_number:
+            deriv = expr.diff(w)
+            if simplify:
+                deriv = deriv.simplify()
+            if deriv != 0:
+                if not (pure_complex(deriv, or_real=True)):
+                    if flags.get('failing_number', False):
+                        return failing_number
+                return False
+        from sympy.solvers.solvers import denoms
+        return fuzzy_not(fuzzy_or(den.is_zero for den in denoms(self)))
+
+    def equals(self, other, failing_expression=False):
+        """Return True if self == other, False if it does not, or None. If
+        failing_expression is True then the expression which did not simplify
+        to a 0 will be returned instead of None.
+
+        Explanation
+        ===========
+
+        If ``self`` is a Number (or complex number) that is not zero, then
+        the result is False.
+
+        If ``self`` is a number and has not evaluated to zero, evalf will be
+        used to test whether the expression evaluates to zero. If it does so
+        and the result has significance (i.e. the precision is either -1, for
+        a Rational result, or is greater than 1) then the evalf value will be
+        used to return True or False.
+
+        """
+        from sympy.simplify.simplify import nsimplify, simplify
+        from sympy.solvers.solvers import solve
+        from sympy.polys.polyerrors import NotAlgebraic
+        from sympy.polys.numberfields import minimal_polynomial
+
+        other = sympify(other)
+
+        if not isinstance(other, Expr):
+            return False
+
+        if self == other:
+            return True
+
+        # they aren't the same so see if we can make the difference 0;
+        # don't worry about doing simplification steps one at a time
+        # because if the expression ever goes to 0 then the subsequent
+        # simplification steps that are done will be very fast.
+        diff = factor_terms(simplify(self - other), radical=True)
+
+        if not diff:
+            return True
+
+        if not diff.has(Add, Mod):
+            # if there is no expanding to be done after simplifying
+            # then this can't be a zero
+            return False
+
+        factors = diff.as_coeff_mul()[1]
+        if len(factors) > 1:  # avoid infinity recursion
+            fac_zero = [fac.equals(0) for fac in factors]
+            if None not in fac_zero:  # every part can be decided
+                return any(fac_zero)
+
+        constant = diff.is_constant(simplify=False, failing_number=True)
+
+        if constant is False:
+            return False
+
+        if not diff.is_number:
+            if constant is None:
+                # e.g. unless the right simplification is done, a symbolic
+                # zero is possible (see expression of issue 6829: without
+                # simplification constant will be None).
+                return
+
+        if constant is True:
+            # this gives a number whether there are free symbols or not
+            ndiff = diff._random()
+            # is_comparable will work whether the result is real
+            # or complex; it could be None, however.
+            if ndiff and ndiff.is_comparable:
+                return False
+
+        # sometimes we can use a simplified result to give a clue as to
+        # what the expression should be; if the expression is *not* zero
+        # then we should have been able to compute that and so now
+        # we can just consider the cases where the approximation appears
+        # to be zero -- we try to prove it via minimal_polynomial.
+        #
+        # removed
+        # ns = nsimplify(diff)
+        # if diff.is_number and (not ns or ns == diff):
+        #
+        # The thought was that if it nsimplifies to 0 that's a sure sign
+        # to try the following to prove it; or if it changed but wasn't
+        # zero that might be a sign that it's not going to be easy to
+        # prove. But tests seem to be working without that logic.
+        #
+        if diff.is_number:
+            # try to prove via self-consistency
+            surds = [s for s in diff.atoms(Pow) if s.args[0].is_Integer]
+            # it seems to work better to try big ones first
+            surds.sort(key=lambda x: -x.args[0])
+            for s in surds:
+                try:
+                    # simplify is False here -- this expression has already
+                    # been identified as being hard to identify as zero;
+                    # we will handle the checking ourselves using nsimplify
+                    # to see if we are in the right ballpark or not and if so
+                    # *then* the simplification will be attempted.
+                    sol = solve(diff, s, simplify=False)
+                    if sol:
+                        if s in sol:
+                            # the self-consistent result is present
+                            return True
+                        if all(si.is_Integer for si in sol):
+                            # perfect powers are removed at instantiation
+                            # so surd s cannot be an integer
+                            return False
+                        if all(i.is_algebraic is False for i in sol):
+                            # a surd is algebraic
+                            return False
+                        if any(si in surds for si in sol):
+                            # it wasn't equal to s but it is in surds
+                            # and different surds are not equal
+                            return False
+                        if any(nsimplify(s - si) == 0 and
+                                simplify(s - si) == 0 for si in sol):
+                            return True
+                        if s.is_real:
+                            if any(nsimplify(si, [s]) == s and simplify(si) == s
+                                    for si in sol):
+                                return True
+                except NotImplementedError:
+                    pass
+
+            # try to prove with minimal_polynomial but know when
+            # *not* to use this or else it can take a long time. e.g. issue 8354
+            if True:  # change True to condition that assures non-hang
+                try:
+                    mp = minimal_polynomial(diff)
+                    if mp.is_Symbol:
+                        return True
+                    return False
+                except (NotAlgebraic, NotImplementedError):
+                    pass
+
+        # diff has not simplified to zero; constant is either None, True
+        # or the number with significance (is_comparable) that was randomly
+        # calculated twice as the same value.
+        if constant not in (True, None) and constant != 0:
+            return False
+
+        if failing_expression:
+            return diff
+        return None
+
+    def _eval_is_extended_positive_negative(self, positive):
+        from sympy.polys.numberfields import minimal_polynomial
+        from sympy.polys.polyerrors import NotAlgebraic
+        if self.is_number:
+            # check to see that we can get a value
+            try:
+                n2 = self._eval_evalf(2)
+            # XXX: This shouldn't be caught here
+            # Catches ValueError: hypsum() failed to converge to the requested
+            # 34 bits of accuracy
+            except ValueError:
+                return None
+            if n2 is None:
+                return None
+            if getattr(n2, '_prec', 1) == 1:  # no significance
+                return None
+            if n2 is S.NaN:
+                return None
+
+            f = self.evalf(2)
+            if f.is_Float:
+                match = f, S.Zero
+            else:
+                match = pure_complex(f)
+            if match is None:
+                return False
+            r, i = match
+            if not (i.is_Number and r.is_Number):
+                return False
+            if r._prec != 1 and i._prec != 1:
+                return bool(not i and ((r > 0) if positive else (r < 0)))
+            elif r._prec == 1 and (not i or i._prec == 1) and \
+                    self._eval_is_algebraic() and not self.has(Function):
+                try:
+                    if minimal_polynomial(self).is_Symbol:
+                        return False
+                except (NotAlgebraic, NotImplementedError):
+                    pass
+
+    def _eval_is_extended_positive(self):
+        return self._eval_is_extended_positive_negative(positive=True)
+
+    def _eval_is_extended_negative(self):
+        return self._eval_is_extended_positive_negative(positive=False)
+
+    def _eval_interval(self, x, a, b):
+        """
+        Returns evaluation over an interval.  For most functions this is:
+
+        self.subs(x, b) - self.subs(x, a),
+
+        possibly using limit() if NaN is returned from subs, or if
+        singularities are found between a and b.
+
+        If b or a is None, it only evaluates -self.subs(x, a) or self.subs(b, x),
+        respectively.
+
+        """
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.functions.elementary.exponential import log
+        from sympy.series.limits import limit, Limit
+        from sympy.sets.sets import Interval
+        from sympy.solvers.solveset import solveset
+
+        if (a is None and b is None):
+            raise ValueError('Both interval ends cannot be None.')
+
+        def _eval_endpoint(left):
+            c = a if left else b
+            if c is None:
+                return S.Zero
+            else:
+                C = self.subs(x, c)
+                if C.has(S.NaN, S.Infinity, S.NegativeInfinity,
+                         S.ComplexInfinity, AccumBounds):
+                    if (a < b) != False:
+                        C = limit(self, x, c, "+" if left else "-")
+                    else:
+                        C = limit(self, x, c, "-" if left else "+")
+
+                    if isinstance(C, Limit):
+                        raise NotImplementedError("Could not compute limit")
+            return C
+
+        if a == b:
+            return S.Zero
+
+        A = _eval_endpoint(left=True)
+        if A is S.NaN:
+            return A
+
+        B = _eval_endpoint(left=False)
+
+        if (a and b) is None:
+            return B - A
+
+        value = B - A
+
+        if a.is_comparable and b.is_comparable:
+            if a < b:
+                domain = Interval(a, b)
+            else:
+                domain = Interval(b, a)
+            # check the singularities of self within the interval
+            # if singularities is a ConditionSet (not iterable), catch the exception and pass
+            singularities = solveset(self.cancel().as_numer_denom()[1], x,
+                domain=domain)
+            for logterm in self.atoms(log):
+                singularities = singularities | solveset(logterm.args[0], x,
+                    domain=domain)
+            try:
+                for s in singularities:
+                    if value is S.NaN:
+                        # no need to keep adding, it will stay NaN
+                        break
+                    if not s.is_comparable:
+                        continue
+                    if (a < s) == (s < b) == True:
+                        value += -limit(self, x, s, "+") + limit(self, x, s, "-")
+                    elif (b < s) == (s < a) == True:
+                        value += limit(self, x, s, "+") - limit(self, x, s, "-")
+            except TypeError:
+                pass
+
+        return value
+
+    def _eval_power(self, expt) -> Expr | None:
+        # subclass to compute self**other for cases when
+        # other is not NaN, 0, or 1
+        return None
+
+    def _eval_conjugate(self):
+        if self.is_extended_real:
+            return self
+        elif self.is_imaginary:
+            return -self
+
+    def conjugate(self):
+        """Returns the complex conjugate of 'self'."""
+        from sympy.functions.elementary.complexes import conjugate as c
+        return c(self)
+
+    def dir(self, x, cdir):
+        if self.is_zero:
+            return S.Zero
+        from sympy.functions.elementary.exponential import log
+        minexp = S.Zero
+        arg = self
+        while arg:
+            minexp += S.One
+            arg = arg.diff(x)
+            coeff = arg.subs(x, 0)
+            if coeff is S.NaN:
+                coeff = arg.limit(x, 0)
+            if coeff is S.ComplexInfinity:
+                try:
+                    coeff, _ = arg.leadterm(x)
+                    if coeff.has(log(x)):
+                        raise ValueError()
+                except ValueError:
+                    coeff = arg.limit(x, 0)
+            if coeff != S.Zero:
+                break
+        return coeff*cdir**minexp
+
+    def _eval_transpose(self):
+        from sympy.functions.elementary.complexes import conjugate
+        if self.is_commutative:
+            return self
+        elif self.is_hermitian:
+            return conjugate(self)
+        elif self.is_antihermitian:
+            return -conjugate(self)
+
+    def transpose(self):
+        from sympy.functions.elementary.complexes import transpose
+        return transpose(self)
+
+    def _eval_adjoint(self):
+        from sympy.functions.elementary.complexes import conjugate, transpose
+        if self.is_hermitian:
+            return self
+        elif self.is_antihermitian:
+            return -self
+        obj = self._eval_conjugate()
+        if obj is not None:
+            return transpose(obj)
+        obj = self._eval_transpose()
+        if obj is not None:
+            return conjugate(obj)
+
+    def adjoint(self):
+        from sympy.functions.elementary.complexes import adjoint
+        return adjoint(self)
+
+    @classmethod
+    def _parse_order(cls, order):
+        """Parse and configure the ordering of terms. """
+        from sympy.polys.orderings import monomial_key
+
+        startswith = getattr(order, "startswith", None)
+        if startswith is None:
+            reverse = False
+        else:
+            reverse = startswith('rev-')
+            if reverse:
+                order = order[4:]
+
+        monom_key = monomial_key(order)
+
+        def neg(monom):
+            return tuple([neg(m) if isinstance(m, tuple) else -m for m in monom])
+
+        def key(term):
+            _, ((re, im), monom, ncpart) = term
+
+            monom = neg(monom_key(monom))
+            ncpart = tuple([e.sort_key(order=order) for e in ncpart])
+            coeff = ((bool(im), im), (re, im))
+
+            return monom, ncpart, coeff
+
+        return key, reverse
+
+    def as_ordered_factors(self, order=None):
+        """Return list of ordered factors (if Mul) else [self]."""
+        return [self]
+
+    def as_poly(self, *gens, **args):
+        """Converts ``self`` to a polynomial or returns ``None``.
+
+        Explanation
+        ===========
+
+        >>> from sympy import sin
+        >>> from sympy.abc import x, y
+
+        >>> print((x**2 + x*y).as_poly())
+        Poly(x**2 + x*y, x, y, domain='ZZ')
+
+        >>> print((x**2 + x*y).as_poly(x, y))
+        Poly(x**2 + x*y, x, y, domain='ZZ')
+
+        >>> print((x**2 + sin(y)).as_poly(x, y))
+        None
+
+        """
+        from sympy.polys.polyerrors import PolynomialError, GeneratorsNeeded
+        from sympy.polys.polytools import Poly
+
+        try:
+            poly = Poly(self, *gens, **args)
+
+            if not poly.is_Poly:
+                return None
+            else:
+                return poly
+        except (PolynomialError, GeneratorsNeeded):
+            # PolynomialError is caught for e.g. exp(x).as_poly(x)
+            # GeneratorsNeeded is caught for e.g. S(2).as_poly()
+            return None
+
+    def as_ordered_terms(self, order=None, data=False):
+        """
+        Transform an expression to an ordered list of terms.
+
+        Examples
+        ========
+
+        >>> from sympy import sin, cos
+        >>> from sympy.abc import x
+
+        >>> (sin(x)**2*cos(x) + sin(x)**2 + 1).as_ordered_terms()
+        [sin(x)**2*cos(x), sin(x)**2, 1]
+
+        """
+
+        from .numbers import Number, NumberSymbol
+
+        if order is None and self.is_Add:
+            # Spot the special case of Add(Number, Mul(Number, expr)) with the
+            # first number positive and the second number negative
+            key = lambda x:not isinstance(x, (Number, NumberSymbol))
+            add_args = sorted(Add.make_args(self), key=key)
+            if (len(add_args) == 2
+                and isinstance(add_args[0], (Number, NumberSymbol))
+                and isinstance(add_args[1], Mul)):
+                mul_args = sorted(Mul.make_args(add_args[1]), key=key)
+                if (len(mul_args) == 2
+                    and isinstance(mul_args[0], Number)
+                    and add_args[0].is_positive
+                    and mul_args[0].is_negative):
+                    return add_args
+
+        key, reverse = self._parse_order(order)
+        terms, gens = self.as_terms()
+
+        if not any(term.is_Order for term, _ in terms):
+            ordered = sorted(terms, key=key, reverse=reverse)
+        else:
+            _terms, _order = [], []
+
+            for term, repr in terms:
+                if not term.is_Order:
+                    _terms.append((term, repr))
+                else:
+                    _order.append((term, repr))
+
+            ordered = sorted(_terms, key=key, reverse=True) \
+                + sorted(_order, key=key, reverse=True)
+
+        if data:
+            return ordered, gens
+        else:
+            return [term for term, _ in ordered]
+
+    def as_terms(self):
+        """Transform an expression to a list of terms. """
+        from .exprtools import decompose_power
+
+        gens, terms = set(), []
+
+        for term in Add.make_args(self):
+            coeff, _term = term.as_coeff_Mul()
+
+            coeff = complex(coeff)
+            cpart, ncpart = {}, []
+
+            if _term is not S.One:
+                for factor in Mul.make_args(_term):
+                    if factor.is_number:
+                        try:
+                            coeff *= complex(factor)
+                        except (TypeError, ValueError):
+                            pass
+                        else:
+                            continue
+
+                    if factor.is_commutative:
+                        base, exp = decompose_power(factor)
+
+                        cpart[base] = exp
+                        gens.add(base)
+                    else:
+                        ncpart.append(factor)
+
+            coeff = coeff.real, coeff.imag
+            ncpart = tuple(ncpart)
+
+            terms.append((term, (coeff, cpart, ncpart)))
+
+        gens = sorted(gens, key=default_sort_key)
+
+        k, indices = len(gens), {}
+
+        for i, g in enumerate(gens):
+            indices[g] = i
+
+        result = []
+
+        for term, (coeff, cpart, ncpart) in terms:
+            monom = [0]*k
+
+            for base, exp in cpart.items():
+                monom[indices[base]] = exp
+
+            result.append((term, (coeff, tuple(monom), ncpart)))
+
+        return result, gens
+
+    def removeO(self) -> Expr:
+        """Removes the additive O(..) symbol if there is one"""
+        return self
+
+    def getO(self) -> Expr | None:
+        """Returns the additive O(..) symbol if there is one, else None."""
+        return None
+
+    def getn(self):
+        """
+        Returns the order of the expression.
+
+        Explanation
+        ===========
+
+        The order is determined either from the O(...) term. If there
+        is no O(...) term, it returns None.
+
+        Examples
+        ========
+
+        >>> from sympy import O
+        >>> from sympy.abc import x
+        >>> (1 + x + O(x**2)).getn()
+        2
+        >>> (1 + x).getn()
+
+        """
+        o = self.getO()
+        if o is None:
+            return None
+        elif o.is_Order:
+            o = o.expr
+            if o is S.One:
+                return S.Zero
+            if o.is_Symbol:
+                return S.One
+            if o.is_Pow:
+                return o.args[1]
+            if o.is_Mul:  # x**n*log(x)**n or x**n/log(x)**n
+                for oi in o.args:
+                    if oi.is_Symbol:
+                        return S.One
+                    if oi.is_Pow:
+                        from .symbol import Dummy, Symbol
+                        syms = oi.atoms(Symbol)
+                        if len(syms) == 1:
+                            x = syms.pop()
+                            oi = oi.subs(x, Dummy('x', positive=True))
+                            if oi.base.is_Symbol and oi.exp.is_Rational:
+                                return abs(oi.exp)
+
+        raise NotImplementedError('not sure of order of %s' % o)
+
+    def count_ops(self, visual=False):
+        from .function import count_ops
+        return count_ops(self, visual)
+
+    def args_cnc(self, cset=False, warn=True, split_1=True):
+        """Return [commutative factors, non-commutative factors] of self.
+
+        Explanation
+        ===========
+
+        self is treated as a Mul and the ordering of the factors is maintained.
+        If ``cset`` is True the commutative factors will be returned in a set.
+        If there were repeated factors (as may happen with an unevaluated Mul)
+        then an error will be raised unless it is explicitly suppressed by
+        setting ``warn`` to False.
+
+        Note: -1 is always separated from a Number unless split_1 is False.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, oo
+        >>> A, B = symbols('A B', commutative=0)
+        >>> x, y = symbols('x y')
+        >>> (-2*x*y).args_cnc()
+        [[-1, 2, x, y], []]
+        >>> (-2.5*x).args_cnc()
+        [[-1, 2.5, x], []]
+        >>> (-2*x*A*B*y).args_cnc()
+        [[-1, 2, x, y], [A, B]]
+        >>> (-2*x*A*B*y).args_cnc(split_1=False)
+        [[-2, x, y], [A, B]]
+        >>> (-2*x*y).args_cnc(cset=True)
+        [{-1, 2, x, y}, []]
+
+        The arg is always treated as a Mul:
+
+        >>> (-2 + x + A).args_cnc()
+        [[], [x - 2 + A]]
+        >>> (-oo).args_cnc() # -oo is a singleton
+        [[-1, oo], []]
+        """
+        args = list(Mul.make_args(self))
+
+        for i, mi in enumerate(args):
+            if not mi.is_commutative:
+                c = args[:i]
+                nc = args[i:]
+                break
+        else:
+            c = args
+            nc = []
+
+        if c and split_1 and (
+            c[0].is_Number and
+            c[0].is_extended_negative and
+                c[0] is not S.NegativeOne):
+            c[:1] = [S.NegativeOne, -c[0]]
+
+        if cset:
+            clen = len(c)
+            c = set(c)
+            if clen and warn and len(c) != clen:
+                raise ValueError('repeated commutative arguments: %s' %
+                                 [ci for ci in c if list(self.args).count(ci) > 1])
+        return [c, nc]
+
+    def coeff(self, x: Expr, n=1, right=False, _first=True):
+        """
+        Returns the coefficient from the term(s) containing ``x**n``. If ``n``
+        is zero then all terms independent of ``x`` will be returned.
+
+        Explanation
+        ===========
+
+        When ``x`` is noncommutative, the coefficient to the left (default) or
+        right of ``x`` can be returned. The keyword 'right' is ignored when
+        ``x`` is commutative.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols
+        >>> from sympy.abc import x, y, z
+
+        You can select terms that have an explicit negative in front of them:
+
+        >>> (-x + 2*y).coeff(-1)
+        x
+        >>> (x - 2*y).coeff(-1)
+        2*y
+
+        You can select terms with no Rational coefficient:
+
+        >>> (x + 2*y).coeff(1)
+        x
+        >>> (3 + 2*x + 4*x**2).coeff(1)
+        0
+
+        You can select terms independent of x by making n=0; in this case
+        expr.as_independent(x)[0] is returned (and 0 will be returned instead
+        of None):
+
+        >>> (3 + 2*x + 4*x**2).coeff(x, 0)
+        3
+        >>> eq = ((x + 1)**3).expand() + 1
+        >>> eq
+        x**3 + 3*x**2 + 3*x + 2
+        >>> [eq.coeff(x, i) for i in reversed(range(4))]
+        [1, 3, 3, 2]
+        >>> eq -= 2
+        >>> [eq.coeff(x, i) for i in reversed(range(4))]
+        [1, 3, 3, 0]
+
+        You can select terms that have a numerical term in front of them:
+
+        >>> (-x - 2*y).coeff(2)
+        -y
+        >>> from sympy import sqrt
+        >>> (x + sqrt(2)*x).coeff(sqrt(2))
+        x
+
+        The matching is exact:
+
+        >>> (3 + 2*x + 4*x**2).coeff(x)
+        2
+        >>> (3 + 2*x + 4*x**2).coeff(x**2)
+        4
+        >>> (3 + 2*x + 4*x**2).coeff(x**3)
+        0
+        >>> (z*(x + y)**2).coeff((x + y)**2)
+        z
+        >>> (z*(x + y)**2).coeff(x + y)
+        0
+
+        In addition, no factoring is done, so 1 + z*(1 + y) is not obtained
+        from the following:
+
+        >>> (x + z*(x + x*y)).coeff(x)
+        1
+
+        If such factoring is desired, factor_terms can be used first:
+
+        >>> from sympy import factor_terms
+        >>> factor_terms(x + z*(x + x*y)).coeff(x)
+        z*(y + 1) + 1
+
+        >>> n, m, o = symbols('n m o', commutative=False)
+        >>> n.coeff(n)
+        1
+        >>> (3*n).coeff(n)
+        3
+        >>> (n*m + m*n*m).coeff(n) # = (1 + m)*n*m
+        1 + m
+        >>> (n*m + m*n*m).coeff(n, right=True) # = (1 + m)*n*m
+        m
+
+        If there is more than one possible coefficient 0 is returned:
+
+        >>> (n*m + m*n).coeff(n)
+        0
+
+        If there is only one possible coefficient, it is returned:
+
+        >>> (n*m + x*m*n).coeff(m*n)
+        x
+        >>> (n*m + x*m*n).coeff(m*n, right=1)
+        1
+
+        See Also
+        ========
+
+        as_coefficient: separate the expression into a coefficient and factor
+        as_coeff_Add: separate the additive constant from an expression
+        as_coeff_Mul: separate the multiplicative constant from an expression
+        as_independent: separate x-dependent terms/factors from others
+        sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly
+        sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used
+        """
+        x = sympify(x)
+        if not isinstance(x, Basic):
+            return S.Zero
+
+        n = as_int(n)
+
+        if not x:
+            return S.Zero
+
+        if x == self:
+            if n == 1:
+                return S.One
+            return S.Zero
+
+        co2: list[Expr]
+
+        if x is S.One:
+            co2 = [a for a in Add.make_args(self) if a.as_coeff_Mul()[0] is S.One]
+            if not co2:
+                return S.Zero
+            return Add(*co2)
+
+        if n == 0:
+            if x.is_Add and self.is_Add:
+                c = self.coeff(x, right=right)
+                if not c:
+                    return S.Zero
+                if not right:
+                    return self - Add(*[a*x for a in Add.make_args(c)])
+                return self - Add(*[x*a for a in Add.make_args(c)])
+            return self.as_independent(x, as_Add=True)[0]
+
+        # continue with the full method, looking for this power of x:
+        x = x**n
+
+        def incommon(l1, l2):
+            if not l1 or not l2:
+                return []
+            n = min(len(l1), len(l2))
+            for i in range(n):
+                if l1[i] != l2[i]:
+                    return l1[:i]
+            return l1[:]
+
+        def find(l, sub, first=True):
+            """ Find where list sub appears in list l. When ``first`` is True
+            the first occurrence from the left is returned, else the last
+            occurrence is returned. Return None if sub is not in l.
+
+            Examples
+            ========
+
+            >> l = range(5)*2
+            >> find(l, [2, 3])
+            2
+            >> find(l, [2, 3], first=0)
+            7
+            >> find(l, [2, 4])
+            None
+
+            """
+            if not sub or not l or len(sub) > len(l):
+                return None
+            n = len(sub)
+            if not first:
+                l.reverse()
+                sub.reverse()
+            for i in range(len(l) - n + 1):
+                if all(l[i + j] == sub[j] for j in range(n)):
+                    break
+            else:
+                i = None
+            if not first:
+                l.reverse()
+                sub.reverse()
+            if i is not None and not first:
+                i = len(l) - (i + n)
+            return i
+
+        co2 = []
+        co: list[tuple[set[Expr], list[Expr]]] = []
+        args = Add.make_args(self)
+        self_c = self.is_commutative
+        x_c = x.is_commutative
+        if self_c and not x_c:
+            return S.Zero
+        if _first and self.is_Add and not self_c and not x_c:
+            # get the part that depends on x exactly
+            xargs = Mul.make_args(x)
+            d = Add(*[i for i in Add.make_args(self.as_independent(x)[1])
+                if all(xi in Mul.make_args(i) for xi in xargs)])
+            rv = d.coeff(x, right=right, _first=False)
+            if not rv.is_Add or not right:
+                return rv
+            c_part, nc_part = zip(*[i.args_cnc() for i in rv.args])
+            if has_variety(c_part):
+                return rv
+            return Add(*[Mul._from_args(i) for i in nc_part])
+
+        one_c = self_c or x_c
+        xargs, nx = x.args_cnc(cset=True, warn=bool(not x_c))
+        # find the parts that pass the commutative terms
+        for a in args:
+            margs, nc = a.args_cnc(cset=True, warn=bool(not self_c))
+            if nc is None:
+                nc = []
+            if len(xargs) > len(margs):
+                continue
+            resid = margs.difference(xargs)
+            if len(resid) + len(xargs) == len(margs):
+                if one_c:
+                    co2.append(Mul(*(list(resid) + nc)))
+                else:
+                    co.append((resid, nc))
+        if one_c:
+            if co2 == []:
+                return S.Zero
+            elif co2:
+                return Add(*co2)
+        else:  # both nc
+            # now check the non-comm parts
+            if not co:
+                return S.Zero
+            if all(n == co[0][1] for r, n in co):
+                ii = find(co[0][1], nx, right)
+                if ii is not None:
+                    if not right:
+                        return Mul(Add(*[Mul(*r) for r, c in co]), Mul(*co[0][1][:ii]))
+                    else:
+                        return Mul(*co[0][1][ii + len(nx):])
+            beg = reduce(incommon, (n[1] for n in co))
+            if beg:
+                ii = find(beg, nx, right)
+                if ii is not None:
+                    if not right:
+                        gcdc = co[0][0]
+                        for i in range(1, len(co)):
+                            gcdc = gcdc.intersection(co[i][0])
+                            if not gcdc:
+                                break
+                        return Mul(*(list(gcdc) + beg[:ii]))
+                    else:
+                        m = ii + len(nx)
+                        return Add(*[Mul(*(list(r) + n[m:])) for r, n in co])
+            end = list(reversed(
+                reduce(incommon, (list(reversed(n[1])) for n in co))))
+            if end:
+                ii = find(end, nx, right)
+                if ii is not None:
+                    if not right:
+                        return Add(*[Mul(*(list(r) + n[:-len(end) + ii])) for r, n in co])
+                    else:
+                        return Mul(*end[ii + len(nx):])
+            # look for single match
+            hit = None
+            for i, (r, n) in enumerate(co):
+                ii = find(n, nx, right)
+                if ii is not None:
+                    if not hit:
+                        hit = ii, r, n
+                    else:
+                        break
+            else:
+                if hit:
+                    ii, r, n = hit
+                    if not right:
+                        return Mul(*(list(r) + n[:ii]))
+                    else:
+                        return Mul(*n[ii + len(nx):])
+
+            return S.Zero
+
+    def as_expr(self, *gens):
+        """
+        Convert a polynomial to a SymPy expression.
+
+        Examples
+        ========
+
+        >>> from sympy import sin
+        >>> from sympy.abc import x, y
+
+        >>> f = (x**2 + x*y).as_poly(x, y)
+        >>> f.as_expr()
+        x**2 + x*y
+
+        >>> sin(x).as_expr()
+        sin(x)
+
+        """
+        return self
+
+    def as_coefficient(self, expr: Expr) -> Expr | None:
+        """
+        Extracts symbolic coefficient at the given expression. In
+        other words, this functions separates 'self' into the product
+        of 'expr' and 'expr'-free coefficient. If such separation
+        is not possible it will return None.
+
+        Examples
+        ========
+
+        >>> from sympy import E, pi, sin, I, Poly
+        >>> from sympy.abc import x
+
+        >>> E.as_coefficient(E)
+        1
+        >>> (2*E).as_coefficient(E)
+        2
+        >>> (2*sin(E)*E).as_coefficient(E)
+
+        Two terms have E in them so a sum is returned. (If one were
+        desiring the coefficient of the term exactly matching E then
+        the constant from the returned expression could be selected.
+        Or, for greater precision, a method of Poly can be used to
+        indicate the desired term from which the coefficient is
+        desired.)
+
+        >>> (2*E + x*E).as_coefficient(E)
+        x + 2
+        >>> _.args[0]  # just want the exact match
+        2
+        >>> p = Poly(2*E + x*E); p
+        Poly(x*E + 2*E, x, E, domain='ZZ')
+        >>> p.coeff_monomial(E)
+        2
+        >>> p.nth(0, 1)
+        2
+
+        Since the following cannot be written as a product containing
+        E as a factor, None is returned. (If the coefficient ``2*x`` is
+        desired then the ``coeff`` method should be used.)
+
+        >>> (2*E*x + x).as_coefficient(E)
+        >>> (2*E*x + x).coeff(E)
+        2*x
+
+        >>> (E*(x + 1) + x).as_coefficient(E)
+
+        >>> (2*pi*I).as_coefficient(pi*I)
+        2
+        >>> (2*I).as_coefficient(pi*I)
+
+        See Also
+        ========
+
+        coeff: return sum of terms have a given factor
+        as_coeff_Add: separate the additive constant from an expression
+        as_coeff_Mul: separate the multiplicative constant from an expression
+        as_independent: separate x-dependent terms/factors from others
+        sympy.polys.polytools.Poly.coeff_monomial: efficiently find the single coefficient of a monomial in Poly
+        sympy.polys.polytools.Poly.nth: like coeff_monomial but powers of monomial terms are used
+
+
+        """
+
+        r = self.extract_multiplicatively(expr)
+        if r and not r.has(expr):
+            return r
+        else:
+            return None
+
+    def as_independent(self, *deps, **hint) -> tuple[Expr, Expr]:
+        """
+        A mostly naive separation of a Mul or Add into arguments that are not
+        are dependent on deps. To obtain as complete a separation of variables
+        as possible, use a separation method first, e.g.:
+
+        * separatevars() to change Mul, Add and Pow (including exp) into Mul
+        * .expand(mul=True) to change Add or Mul into Add
+        * .expand(log=True) to change log expr into an Add
+
+        The only non-naive thing that is done here is to respect noncommutative
+        ordering of variables and to always return (0, 0) for `self` of zero
+        regardless of hints.
+
+        For nonzero `self`, the returned tuple (i, d) has the
+        following interpretation:
+
+        * i will has no variable that appears in deps
+        * d will either have terms that contain variables that are in deps, or
+          be equal to 0 (when self is an Add) or 1 (when self is a Mul)
+        * if self is an Add then self = i + d
+        * if self is a Mul then self = i*d
+        * otherwise (self, S.One) or (S.One, self) is returned.
+
+        To force the expression to be treated as an Add, use the hint as_Add=True
+
+        Examples
+        ========
+
+        -- self is an Add
+
+        >>> from sympy import sin, cos, exp
+        >>> from sympy.abc import x, y, z
+
+        >>> (x + x*y).as_independent(x)
+        (0, x*y + x)
+        >>> (x + x*y).as_independent(y)
+        (x, x*y)
+        >>> (2*x*sin(x) + y + x + z).as_independent(x)
+        (y + z, 2*x*sin(x) + x)
+        >>> (2*x*sin(x) + y + x + z).as_independent(x, y)
+        (z, 2*x*sin(x) + x + y)
+
+        -- self is a Mul
+
+        >>> (x*sin(x)*cos(y)).as_independent(x)
+        (cos(y), x*sin(x))
+
+        non-commutative terms cannot always be separated out when self is a Mul
+
+        >>> from sympy import symbols
+        >>> n1, n2, n3 = symbols('n1 n2 n3', commutative=False)
+        >>> (n1 + n1*n2).as_independent(n2)
+        (n1, n1*n2)
+        >>> (n2*n1 + n1*n2).as_independent(n2)
+        (0, n1*n2 + n2*n1)
+        >>> (n1*n2*n3).as_independent(n1)
+        (1, n1*n2*n3)
+        >>> (n1*n2*n3).as_independent(n2)
+        (n1, n2*n3)
+        >>> ((x-n1)*(x-y)).as_independent(x)
+        (1, (x - y)*(x - n1))
+
+        -- self is anything else:
+
+        >>> (sin(x)).as_independent(x)
+        (1, sin(x))
+        >>> (sin(x)).as_independent(y)
+        (sin(x), 1)
+        >>> exp(x+y).as_independent(x)
+        (1, exp(x + y))
+
+        -- force self to be treated as an Add:
+
+        >>> (3*x).as_independent(x, as_Add=True)
+        (0, 3*x)
+
+        -- force self to be treated as a Mul:
+
+        >>> (3+x).as_independent(x, as_Add=False)
+        (1, x + 3)
+        >>> (-3+x).as_independent(x, as_Add=False)
+        (1, x - 3)
+
+        Note how the below differs from the above in making the
+        constant on the dep term positive.
+
+        >>> (y*(-3+x)).as_independent(x)
+        (y, x - 3)
+
+        -- use .as_independent() for true independence testing instead
+           of .has(). The former considers only symbols in the free
+           symbols while the latter considers all symbols
+
+        >>> from sympy import Integral
+        >>> I = Integral(x, (x, 1, 2))
+        >>> I.has(x)
+        True
+        >>> x in I.free_symbols
+        False
+        >>> I.as_independent(x) == (I, 1)
+        True
+        >>> (I + x).as_independent(x) == (I, x)
+        True
+
+        Note: when trying to get independent terms, a separation method
+        might need to be used first. In this case, it is important to keep
+        track of what you send to this routine so you know how to interpret
+        the returned values
+
+        >>> from sympy import separatevars, log
+        >>> separatevars(exp(x+y)).as_independent(x)
+        (exp(y), exp(x))
+        >>> (x + x*y).as_independent(y)
+        (x, x*y)
+        >>> separatevars(x + x*y).as_independent(y)
+        (x, y + 1)
+        >>> (x*(1 + y)).as_independent(y)
+        (x, y + 1)
+        >>> (x*(1 + y)).expand(mul=True).as_independent(y)
+        (x, x*y)
+        >>> a, b=symbols('a b', positive=True)
+        >>> (log(a*b).expand(log=True)).as_independent(b)
+        (log(a), log(b))
+
+        See Also
+        ========
+
+        separatevars
+        expand_log
+        sympy.core.add.Add.as_two_terms
+        sympy.core.mul.Mul.as_two_terms
+        as_coeff_mul
+        """
+        from .symbol import Symbol
+        from .add import _unevaluated_Add
+        from .mul import _unevaluated_Mul
+
+        if self is S.Zero:
+            return (self, self)
+
+        func = self.func
+        want: type[Add] | type[Mul]
+        if hint.get('as_Add', isinstance(self, Add) ):
+            want = Add
+        else:
+            want = Mul
+
+        # sift out deps into symbolic and other and ignore
+        # all symbols but those that are in the free symbols
+        sym = set()
+        other = []
+        for d in deps:
+            if isinstance(d, Symbol):  # Symbol.is_Symbol is True
+                sym.add(d)
+            else:
+                other.append(d)
+
+        def has(e):
+            """return the standard has() if there are no literal symbols, else
+            check to see that symbol-deps are in the free symbols."""
+            has_other = e.has(*other)
+            if not sym:
+                return has_other
+            return has_other or e.has(*(e.free_symbols & sym))
+
+        if (want is not func or
+                func is not Add and func is not Mul):
+            if has(self):
+                return (want.identity, self)
+            else:
+                return (self, want.identity)
+        else:
+            if func is Add:
+                args = list(self.args)
+            else:
+                args, nc = self.args_cnc()
+
+        d = sift(args, has)
+        depend = d[True]
+        indep = d[False]
+        if func is Add:  # all terms were treated as commutative
+            return (Add(*indep), _unevaluated_Add(*depend))
+        else:  # handle noncommutative by stopping at first dependent term
+            for i, n in enumerate(nc):
+                if has(n):
+                    depend.extend(nc[i:])
+                    break
+                indep.append(n)
+            return Mul(*indep), _unevaluated_Mul(*depend)
+
+    def as_real_imag(self, deep=True, **hints) -> tuple[Expr, Expr]:
+        """Performs complex expansion on 'self' and returns a tuple
+           containing collected both real and imaginary parts. This
+           method cannot be confused with re() and im() functions,
+           which does not perform complex expansion at evaluation.
+
+           However it is possible to expand both re() and im()
+           functions and get exactly the same results as with
+           a single call to this function.
+
+           >>> from sympy import symbols, I
+
+           >>> x, y = symbols('x,y', real=True)
+
+           >>> (x + y*I).as_real_imag()
+           (x, y)
+
+           >>> from sympy.abc import z, w
+
+           >>> (z + w*I).as_real_imag()
+           (re(z) - im(w), re(w) + im(z))
+
+        """
+        if hints.get('ignore') == self:
+            return None  # type: ignore
+        else:
+            from sympy.functions.elementary.complexes import im, re
+            return (re(self), im(self))
+
+    def as_powers_dict(self):
+        """Return self as a dictionary of factors with each factor being
+        treated as a power. The keys are the bases of the factors and the
+        values, the corresponding exponents. The resulting dictionary should
+        be used with caution if the expression is a Mul and contains non-
+        commutative factors since the order that they appeared will be lost in
+        the dictionary.
+
+        See Also
+        ========
+        as_ordered_factors: An alternative for noncommutative applications,
+                            returning an ordered list of factors.
+        args_cnc: Similar to as_ordered_factors, but guarantees separation
+                  of commutative and noncommutative factors.
+        """
+        d = defaultdict(int)
+        d.update([self.as_base_exp()])
+        return d
+
+    def as_coefficients_dict(self, *syms):
+        """Return a dictionary mapping terms to their Rational coefficient.
+        Since the dictionary is a defaultdict, inquiries about terms which
+        were not present will return a coefficient of 0.
+
+        If symbols ``syms`` are provided, any multiplicative terms
+        independent of them will be considered a coefficient and a
+        regular dictionary of syms-dependent generators as keys and
+        their corresponding coefficients as values will be returned.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import a, x, y
+        >>> (3*x + a*x + 4).as_coefficients_dict()
+        {1: 4, x: 3, a*x: 1}
+        >>> _[a]
+        0
+        >>> (3*a*x).as_coefficients_dict()
+        {a*x: 3}
+        >>> (3*a*x).as_coefficients_dict(x)
+        {x: 3*a}
+        >>> (3*a*x).as_coefficients_dict(y)
+        {1: 3*a*x}
+
+        """
+        d = defaultdict(list)
+        if not syms:
+            for ai in Add.make_args(self):
+                c, m = ai.as_coeff_Mul()
+                d[m].append(c)
+            for k, v in d.items():
+                if len(v) == 1:
+                    d[k] = v[0]
+                else:
+                    d[k] = Add(*v)
+        else:
+            ind, dep = self.as_independent(*syms, as_Add=True)
+            for i in Add.make_args(dep):
+                if i.is_Mul:
+                    c, x = i.as_coeff_mul(*syms)
+                    if c is S.One:
+                        d[i].append(c)
+                    else:
+                        d[i._new_rawargs(*x)].append(c)
+                elif i:
+                    d[i].append(S.One)
+            d = {k: Add(*d[k]) for k in d}
+            if ind is not S.Zero:
+                d.update({S.One: ind})
+        di = defaultdict(int)
+        di.update(d)
+        return di
+
+    def as_base_exp(self) -> tuple[Expr, Expr]:
+        # a -> b ** e
+        return self, S.One
+
+    def as_coeff_mul(self, *deps, **kwargs) -> tuple[Expr, tuple[Expr, ...]]:
+        """Return the tuple (c, args) where self is written as a Mul, ``m``.
+
+        c should be a Rational multiplied by any factors of the Mul that are
+        independent of deps.
+
+        args should be a tuple of all other factors of m; args is empty
+        if self is a Number or if self is independent of deps (when given).
+
+        This should be used when you do not know if self is a Mul or not but
+        you want to treat self as a Mul or if you want to process the
+        individual arguments of the tail of self as a Mul.
+
+        - if you know self is a Mul and want only the head, use self.args[0];
+        - if you do not want to process the arguments of the tail but need the
+          tail then use self.as_two_terms() which gives the head and tail;
+        - if you want to split self into an independent and dependent parts
+          use ``self.as_independent(*deps)``
+
+        >>> from sympy import S
+        >>> from sympy.abc import x, y
+        >>> (S(3)).as_coeff_mul()
+        (3, ())
+        >>> (3*x*y).as_coeff_mul()
+        (3, (x, y))
+        >>> (3*x*y).as_coeff_mul(x)
+        (3*y, (x,))
+        >>> (3*y).as_coeff_mul(x)
+        (3*y, ())
+        """
+        if deps:
+            if not self.has(*deps):
+                return self, ()
+        return S.One, (self,)
+
+    def as_coeff_add(self, *deps) -> tuple[Expr, tuple[Expr, ...]]:
+        """Return the tuple (c, args) where self is written as an Add, ``a``.
+
+        c should be a Rational added to any terms of the Add that are
+        independent of deps.
+
+        args should be a tuple of all other terms of ``a``; args is empty
+        if self is a Number or if self is independent of deps (when given).
+
+        This should be used when you do not know if self is an Add or not but
+        you want to treat self as an Add or if you want to process the
+        individual arguments of the tail of self as an Add.
+
+        - if you know self is an Add and want only the head, use self.args[0];
+        - if you do not want to process the arguments of the tail but need the
+          tail then use self.as_two_terms() which gives the head and tail.
+        - if you want to split self into an independent and dependent parts
+          use ``self.as_independent(*deps)``
+
+        >>> from sympy import S
+        >>> from sympy.abc import x, y
+        >>> (S(3)).as_coeff_add()
+        (3, ())
+        >>> (3 + x).as_coeff_add()
+        (3, (x,))
+        >>> (3 + x + y).as_coeff_add(x)
+        (y + 3, (x,))
+        >>> (3 + y).as_coeff_add(x)
+        (y + 3, ())
+
+        """
+        if deps:
+            if not self.has_free(*deps):
+                return self, ()
+        return S.Zero, (self,)
+
+    def primitive(self) -> tuple[Number, Expr]:
+        """Return the positive Rational that can be extracted non-recursively
+        from every term of self (i.e., self is treated like an Add). This is
+        like the as_coeff_Mul() method but primitive always extracts a positive
+        Rational (never a negative or a Float).
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (3*(x + 1)**2).primitive()
+        (3, (x + 1)**2)
+        >>> a = (6*x + 2); a.primitive()
+        (2, 3*x + 1)
+        >>> b = (x/2 + 3); b.primitive()
+        (1/2, x + 6)
+        >>> (a*b).primitive() == (1, a*b)
+        True
+        """
+        if not self:
+            return S.One, S.Zero
+        c, r = self.as_coeff_Mul(rational=True)
+        if c.is_negative:
+            c, r = -c, -r
+        return c, r
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """This method should recursively remove a Rational from all arguments
+        and return that (content) and the new self (primitive). The content
+        should always be positive and ``Mul(*foo.as_content_primitive()) == foo``.
+        The primitive need not be in canonical form and should try to preserve
+        the underlying structure if possible (i.e. expand_mul should not be
+        applied to self).
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> from sympy.abc import x, y, z
+
+        >>> eq = 2 + 2*x + 2*y*(3 + 3*y)
+
+        The as_content_primitive function is recursive and retains structure:
+
+        >>> eq.as_content_primitive()
+        (2, x + 3*y*(y + 1) + 1)
+
+        Integer powers will have Rationals extracted from the base:
+
+        >>> ((2 + 6*x)**2).as_content_primitive()
+        (4, (3*x + 1)**2)
+        >>> ((2 + 6*x)**(2*y)).as_content_primitive()
+        (1, (2*(3*x + 1))**(2*y))
+
+        Terms may end up joining once their as_content_primitives are added:
+
+        >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
+        (11, x*(y + 1))
+        >>> ((3*(x*(1 + y)) + 2*x*(3 + 3*y))).as_content_primitive()
+        (9, x*(y + 1))
+        >>> ((3*(z*(1 + y)) + 2.0*x*(3 + 3*y))).as_content_primitive()
+        (1, 6.0*x*(y + 1) + 3*z*(y + 1))
+        >>> ((5*(x*(1 + y)) + 2*x*(3 + 3*y))**2).as_content_primitive()
+        (121, x**2*(y + 1)**2)
+        >>> ((x*(1 + y) + 0.4*x*(3 + 3*y))**2).as_content_primitive()
+        (1, 4.84*x**2*(y + 1)**2)
+
+        Radical content can also be factored out of the primitive:
+
+        >>> (2*sqrt(2) + 4*sqrt(10)).as_content_primitive(radical=True)
+        (2, sqrt(2)*(1 + 2*sqrt(5)))
+
+        If clear=False (default is True) then content will not be removed
+        from an Add if it can be distributed to leave one or more
+        terms with integer coefficients.
+
+        >>> (x/2 + y).as_content_primitive()
+        (1/2, x + 2*y)
+        >>> (x/2 + y).as_content_primitive(clear=False)
+        (1, x/2 + y)
+        """
+        return S.One, self
+
+    def as_numer_denom(self) -> tuple[Expr, Expr]:
+        """Return the numerator and the denominator of an expression.
+
+        expression -> a/b -> a, b
+
+        This is just a stub that should be defined by
+        an object's class methods to get anything else.
+
+        See Also
+        ========
+
+        normal: return ``a/b`` instead of ``(a, b)``
+
+        """
+        return self, S.One
+
+    def normal(self):
+        """Return the expression as a fraction.
+
+        expression -> a/b
+
+        See Also
+        ========
+
+        as_numer_denom: return ``(a, b)`` instead of ``a/b``
+
+        """
+        from .mul import _unevaluated_Mul
+        n, d = self.as_numer_denom()
+        if d is S.One:
+            return n
+        if d.is_Number:
+            return _unevaluated_Mul(n, 1/d)
+        else:
+            return n/d
+
+    def extract_multiplicatively(self, c: Expr) -> Expr | None:
+        """Return None if it's not possible to make self in the form
+           c * something in a nice way, i.e. preserving the properties
+           of arguments of self.
+
+           Examples
+           ========
+
+           >>> from sympy import symbols, Rational
+
+           >>> x, y = symbols('x,y', real=True)
+
+           >>> ((x*y)**3).extract_multiplicatively(x**2 * y)
+           x*y**2
+
+           >>> ((x*y)**3).extract_multiplicatively(x**4 * y)
+
+           >>> (2*x).extract_multiplicatively(2)
+           x
+
+           >>> (2*x).extract_multiplicatively(3)
+
+           >>> (Rational(1, 2)*x).extract_multiplicatively(3)
+           x/6
+
+        """
+        from sympy.functions.elementary.exponential import exp
+        from .add import _unevaluated_Add
+        c = sympify(c)
+        if self is S.NaN:
+            return None
+        if c is S.One:
+            return self
+        elif c == self:
+            return S.One
+
+        if c.is_Add:
+            cc, pc = c.primitive()
+            if cc is not S.One:
+                c = Mul(cc, pc, evaluate=False)
+
+        if c.is_Mul:
+            a, b = c.as_two_terms() # type: ignore
+            x = self.extract_multiplicatively(a)
+            if x is not None:
+                return x.extract_multiplicatively(b)
+            else:
+                return x
+
+        quotient = self / c
+        if self.is_Number:
+            if self is S.Infinity:
+                if c.is_positive:
+                    return S.Infinity
+            elif self is S.NegativeInfinity:
+                if c.is_negative:
+                    return S.Infinity
+                elif c.is_positive:
+                    return S.NegativeInfinity
+            elif self is S.ComplexInfinity:
+                if not c.is_zero:
+                    return S.ComplexInfinity
+            elif self.is_Integer:
+                if not quotient.is_Integer:
+                    return None
+                elif self.is_positive and quotient.is_negative:
+                    return None
+                else:
+                    return quotient
+            elif self.is_Rational:
+                if not quotient.is_Rational:
+                    return None
+                elif self.is_positive and quotient.is_negative:
+                    return None
+                else:
+                    return quotient
+            elif self.is_Float:
+                if not quotient.is_Float:
+                    return None
+                elif self.is_positive and quotient.is_negative:
+                    return None
+                else:
+                    return quotient
+        elif self.is_NumberSymbol or self.is_Symbol or self is S.ImaginaryUnit:
+            if quotient.is_Mul and len(quotient.args) == 2:
+                if quotient.args[0].is_Integer and quotient.args[0].is_positive and quotient.args[1] == self:
+                    return quotient
+            elif quotient.is_Integer and c.is_Number:
+                return quotient
+        elif self.is_Add:
+            cs, ps = self.primitive()
+            # assert cs >= 1
+            if c.is_Number and c is not S.NegativeOne:
+                # assert c != 1 (handled at top)
+                if cs is not S.One:
+                    if c.is_negative:
+                        xc = cs.extract_multiplicatively(-c)
+                        if xc is not None:
+                            xc = -xc
+                    else:
+                        xc = cs.extract_multiplicatively(c)
+                    if xc is not None:
+                        return xc*ps  # rely on 2-arg Mul to restore Add
+                return None # |c| != 1 can only be extracted from cs
+            if c == ps:
+                return cs
+            # check args of ps
+            newargs = []
+            arg: Expr
+            for arg in ps.args: # type: ignore
+                newarg = arg.extract_multiplicatively(c)
+                if newarg is None:
+                    return None # all or nothing
+                newargs.append(newarg)
+            if cs is not S.One:
+                args = [cs*t for t in newargs]
+                # args may be in different order
+                return _unevaluated_Add(*args)
+            else:
+                return Add._from_args(newargs)
+        elif self.is_Mul:
+            args: list[Expr] = list(self.args) # type: ignore
+            for i, arg in enumerate(args):
+                newarg = arg.extract_multiplicatively(c)
+                if newarg is not None:
+                    args[i] = newarg
+                    return Mul(*args)
+        elif self.is_Pow or isinstance(self, exp):
+            sb, se = self.as_base_exp()
+            cb, ce = c.as_base_exp()
+            if cb == sb:
+                new_exp = se.extract_additively(ce)
+                if new_exp is not None:
+                    return Pow(sb, new_exp)
+            elif c == sb:
+                new_exp = se.extract_additively(1)
+                if new_exp is not None:
+                    return Pow(sb, new_exp)
+
+        return None
+
+    def extract_additively(self, c):
+        """Return self - c if it's possible to subtract c from self and
+        make all matching coefficients move towards zero, else return None.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> e = 2*x + 3
+        >>> e.extract_additively(x + 1)
+        x + 2
+        >>> e.extract_additively(3*x)
+        >>> e.extract_additively(4)
+        >>> (y*(x + 1)).extract_additively(x + 1)
+        >>> ((x + 1)*(x + 2*y + 1) + 3).extract_additively(x + 1)
+        (x + 1)*(x + 2*y) + 3
+
+        See Also
+        ========
+        extract_multiplicatively
+        coeff
+        as_coefficient
+
+        """
+
+        c = sympify(c)
+        if self is S.NaN:
+            return None
+        if c.is_zero:
+            return self
+        elif c == self:
+            return S.Zero
+        elif self == S.Zero:
+            return None
+
+        if self.is_Number:
+            if not c.is_Number:
+                return None
+            co = self
+            diff = co - c
+            # XXX should we match types? i.e should 3 - .1 succeed?
+            if (co > 0 and diff >= 0 and diff < co or
+                    co < 0 and diff <= 0 and diff > co):
+                return diff
+            return None
+
+        if c.is_Number:
+            co, t = self.as_coeff_Add()
+            xa = co.extract_additively(c)
+            if xa is None:
+                return None
+            return xa + t
+
+        # handle the args[0].is_Number case separately
+        # since we will have trouble looking for the coeff of
+        # a number.
+        if c.is_Add and c.args[0].is_Number:
+            # whole term as a term factor
+            co = self.coeff(c)
+            xa0 = (co.extract_additively(1) or 0)*c
+            if xa0:
+                diff = self - co*c
+                return (xa0 + (diff.extract_additively(c) or diff)) or None
+            # term-wise
+            h, t = c.as_coeff_Add()
+            sh, st = self.as_coeff_Add()
+            xa = sh.extract_additively(h)
+            if xa is None:
+                return None
+            xa2 = st.extract_additively(t)
+            if xa2 is None:
+                return None
+            return xa + xa2
+
+        # whole term as a term factor
+        co, diff = _corem(self, c)
+        xa0 = (co.extract_additively(1) or 0)*c
+        if xa0:
+            return (xa0 + (diff.extract_additively(c) or diff)) or None
+        # term-wise
+        coeffs = []
+        for a in Add.make_args(c):
+            ac, at = a.as_coeff_Mul()
+            co = self.coeff(at)
+            if not co:
+                return None
+            coc, cot = co.as_coeff_Add()
+            xa = coc.extract_additively(ac)
+            if xa is None:
+                return None
+            self -= co*at
+            coeffs.append((cot + xa)*at)
+        coeffs.append(self)
+        return Add(*coeffs)
+
+    @property
+    def expr_free_symbols(self):
+        """
+        Like ``free_symbols``, but returns the free symbols only if
+        they are contained in an expression node.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> (x + y).expr_free_symbols # doctest: +SKIP
+        {x, y}
+
+        If the expression is contained in a non-expression object, do not return
+        the free symbols. Compare:
+
+        >>> from sympy import Tuple
+        >>> t = Tuple(x + y)
+        >>> t.expr_free_symbols # doctest: +SKIP
+        set()
+        >>> t.free_symbols
+        {x, y}
+        """
+        sympy_deprecation_warning("""
+        The expr_free_symbols property is deprecated. Use free_symbols to get
+        the free symbols of an expression.
+        """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-expr-free-symbols")
+        return {j for i in self.args for j in i.expr_free_symbols}
+
+    def could_extract_minus_sign(self) -> bool:
+        """Return True if self has -1 as a leading factor or has
+        more literal negative signs than positive signs in a sum,
+        otherwise False.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> e = x - y
+        >>> {i.could_extract_minus_sign() for i in (e, -e)}
+        {False, True}
+
+        Though the ``y - x`` is considered like ``-(x - y)``, since it
+        is in a product without a leading factor of -1, the result is
+        false below:
+
+        >>> (x*(y - x)).could_extract_minus_sign()
+        False
+
+        To put something in canonical form wrt to sign, use `signsimp`:
+
+        >>> from sympy import signsimp
+        >>> signsimp(x*(y - x))
+        -x*(x - y)
+        >>> _.could_extract_minus_sign()
+        True
+        """
+        return False
+
+    def extract_branch_factor(self, allow_half=False):
+        """
+        Try to write self as ``exp_polar(2*pi*I*n)*z`` in a nice way.
+        Return (z, n).
+
+        >>> from sympy import exp_polar, I, pi
+        >>> from sympy.abc import x, y
+        >>> exp_polar(I*pi).extract_branch_factor()
+        (exp_polar(I*pi), 0)
+        >>> exp_polar(2*I*pi).extract_branch_factor()
+        (1, 1)
+        >>> exp_polar(-pi*I).extract_branch_factor()
+        (exp_polar(I*pi), -1)
+        >>> exp_polar(3*pi*I + x).extract_branch_factor()
+        (exp_polar(x + I*pi), 1)
+        >>> (y*exp_polar(-5*pi*I)*exp_polar(3*pi*I + 2*pi*x)).extract_branch_factor()
+        (y*exp_polar(2*pi*x), -1)
+        >>> exp_polar(-I*pi/2).extract_branch_factor()
+        (exp_polar(-I*pi/2), 0)
+
+        If allow_half is True, also extract exp_polar(I*pi):
+
+        >>> exp_polar(I*pi).extract_branch_factor(allow_half=True)
+        (1, 1/2)
+        >>> exp_polar(2*I*pi).extract_branch_factor(allow_half=True)
+        (1, 1)
+        >>> exp_polar(3*I*pi).extract_branch_factor(allow_half=True)
+        (1, 3/2)
+        >>> exp_polar(-I*pi).extract_branch_factor(allow_half=True)
+        (1, -1/2)
+        """
+        from sympy.functions.elementary.exponential import exp_polar
+        from sympy.functions.elementary.integers import ceiling
+
+        n = S.Zero
+        res = S.One
+        args = Mul.make_args(self)
+        exps = []
+        for arg in args:
+            if isinstance(arg, exp_polar):
+                exps += [arg.exp]
+            else:
+                res *= arg
+        piimult = S.Zero
+        extras = []
+
+        ipi = S.Pi*S.ImaginaryUnit
+        while exps:
+            exp = exps.pop()
+            if exp.is_Add:
+                exps += exp.args
+                continue
+            if exp.is_Mul:
+                coeff = exp.as_coefficient(ipi)
+                if coeff is not None:
+                    piimult += coeff
+                    continue
+            extras += [exp]
+        if piimult.is_number:
+            coeff = piimult
+            tail = ()
+        else:
+            coeff, tail = piimult.as_coeff_add(*piimult.free_symbols)
+        # round down to nearest multiple of 2
+        branchfact = ceiling(coeff/2 - S.Half)*2
+        n += branchfact/2
+        c = coeff - branchfact
+        if allow_half:
+            nc = c.extract_additively(1)
+            if nc is not None:
+                n += S.Half
+                c = nc
+        newexp = ipi*Add(*((c, ) + tail)) + Add(*extras)
+        if newexp != 0:
+            res *= exp_polar(newexp)
+        return res, n
+
+    def is_polynomial(self, *syms):
+        r"""
+        Return True if self is a polynomial in syms and False otherwise.
+
+        This checks if self is an exact polynomial in syms.  This function
+        returns False for expressions that are "polynomials" with symbolic
+        exponents.  Thus, you should be able to apply polynomial algorithms to
+        expressions for which this returns True, and Poly(expr, \*syms) should
+        work if and only if expr.is_polynomial(\*syms) returns True. The
+        polynomial does not have to be in expanded form.  If no symbols are
+        given, all free symbols in the expression will be used.
+
+        This is not part of the assumptions system.  You cannot do
+        Symbol('z', polynomial=True).
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Function
+        >>> x = Symbol('x')
+        >>> ((x**2 + 1)**4).is_polynomial(x)
+        True
+        >>> ((x**2 + 1)**4).is_polynomial()
+        True
+        >>> (2**x + 1).is_polynomial(x)
+        False
+        >>> (2**x + 1).is_polynomial(2**x)
+        True
+        >>> f = Function('f')
+        >>> (f(x) + 1).is_polynomial(x)
+        False
+        >>> (f(x) + 1).is_polynomial(f(x))
+        True
+        >>> (1/f(x) + 1).is_polynomial(f(x))
+        False
+
+        >>> n = Symbol('n', nonnegative=True, integer=True)
+        >>> (x**n + 1).is_polynomial(x)
+        False
+
+        This function does not attempt any nontrivial simplifications that may
+        result in an expression that does not appear to be a polynomial to
+        become one.
+
+        >>> from sympy import sqrt, factor, cancel
+        >>> y = Symbol('y', positive=True)
+        >>> a = sqrt(y**2 + 2*y + 1)
+        >>> a.is_polynomial(y)
+        False
+        >>> factor(a)
+        y + 1
+        >>> factor(a).is_polynomial(y)
+        True
+
+        >>> b = (y**2 + 2*y + 1)/(y + 1)
+        >>> b.is_polynomial(y)
+        False
+        >>> cancel(b)
+        y + 1
+        >>> cancel(b).is_polynomial(y)
+        True
+
+        See also .is_rational_function()
+
+        """
+        if syms:
+            syms = set(map(sympify, syms))
+        else:
+            syms = self.free_symbols
+            if not syms:
+                return True
+
+        return self._eval_is_polynomial(syms)
+
+    def _eval_is_polynomial(self, syms) -> bool | None:
+        if self in syms:
+            return True
+        if not self.has_free(*syms):
+            # constant polynomial
+            return True
+        # subclasses should return True or False
+        return None
+
+    def is_rational_function(self, *syms):
+        """
+        Test whether function is a ratio of two polynomials in the given
+        symbols, syms. When syms is not given, all free symbols will be used.
+        The rational function does not have to be in expanded or in any kind of
+        canonical form.
+
+        This function returns False for expressions that are "rational
+        functions" with symbolic exponents.  Thus, you should be able to call
+        .as_numer_denom() and apply polynomial algorithms to the result for
+        expressions for which this returns True.
+
+        This is not part of the assumptions system.  You cannot do
+        Symbol('z', rational_function=True).
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, sin
+        >>> from sympy.abc import x, y
+
+        >>> (x/y).is_rational_function()
+        True
+
+        >>> (x**2).is_rational_function()
+        True
+
+        >>> (x/sin(y)).is_rational_function(y)
+        False
+
+        >>> n = Symbol('n', integer=True)
+        >>> (x**n + 1).is_rational_function(x)
+        False
+
+        This function does not attempt any nontrivial simplifications that may
+        result in an expression that does not appear to be a rational function
+        to become one.
+
+        >>> from sympy import sqrt, factor
+        >>> y = Symbol('y', positive=True)
+        >>> a = sqrt(y**2 + 2*y + 1)/y
+        >>> a.is_rational_function(y)
+        False
+        >>> factor(a)
+        (y + 1)/y
+        >>> factor(a).is_rational_function(y)
+        True
+
+        See also is_algebraic_expr().
+
+        """
+        if syms:
+            syms = set(map(sympify, syms))
+        else:
+            syms = self.free_symbols
+            if not syms:
+                return self not in _illegal
+
+        return self._eval_is_rational_function(syms)
+
+    def _eval_is_rational_function(self, syms) -> bool | None:
+        if self in syms:
+            return True
+        if not self.has_xfree(syms):
+            return True
+        # subclasses should return True or False
+        return None
+
+    def is_meromorphic(self, x, a):
+        """
+        This tests whether an expression is meromorphic as
+        a function of the given symbol ``x`` at the point ``a``.
+
+        This method is intended as a quick test that will return
+        None if no decision can be made without simplification or
+        more detailed analysis.
+
+        Examples
+        ========
+
+        >>> from sympy import zoo, log, sin, sqrt
+        >>> from sympy.abc import x
+
+        >>> f = 1/x**2 + 1 - 2*x**3
+        >>> f.is_meromorphic(x, 0)
+        True
+        >>> f.is_meromorphic(x, 1)
+        True
+        >>> f.is_meromorphic(x, zoo)
+        True
+
+        >>> g = x**log(3)
+        >>> g.is_meromorphic(x, 0)
+        False
+        >>> g.is_meromorphic(x, 1)
+        True
+        >>> g.is_meromorphic(x, zoo)
+        False
+
+        >>> h = sin(1/x)*x**2
+        >>> h.is_meromorphic(x, 0)
+        False
+        >>> h.is_meromorphic(x, 1)
+        True
+        >>> h.is_meromorphic(x, zoo)
+        True
+
+        Multivalued functions are considered meromorphic when their
+        branches are meromorphic. Thus most functions are meromorphic
+        everywhere except at essential singularities and branch points.
+        In particular, they will be meromorphic also on branch cuts
+        except at their endpoints.
+
+        >>> log(x).is_meromorphic(x, -1)
+        True
+        >>> log(x).is_meromorphic(x, 0)
+        False
+        >>> sqrt(x).is_meromorphic(x, -1)
+        True
+        >>> sqrt(x).is_meromorphic(x, 0)
+        False
+
+        """
+        if not x.is_symbol:
+            raise TypeError("{} should be of symbol type".format(x))
+        a = sympify(a)
+
+        return self._eval_is_meromorphic(x, a)
+
+    def _eval_is_meromorphic(self, x, a) -> bool | None:
+        if self == x:
+            return True
+        if not self.has_free(x):
+            return True
+        # subclasses should return True or False
+        return None
+
+    def is_algebraic_expr(self, *syms):
+        """
+        This tests whether a given expression is algebraic or not, in the
+        given symbols, syms. When syms is not given, all free symbols
+        will be used. The rational function does not have to be in expanded
+        or in any kind of canonical form.
+
+        This function returns False for expressions that are "algebraic
+        expressions" with symbolic exponents. This is a simple extension to the
+        is_rational_function, including rational exponentiation.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, sqrt
+        >>> x = Symbol('x', real=True)
+        >>> sqrt(1 + x).is_rational_function()
+        False
+        >>> sqrt(1 + x).is_algebraic_expr()
+        True
+
+        This function does not attempt any nontrivial simplifications that may
+        result in an expression that does not appear to be an algebraic
+        expression to become one.
+
+        >>> from sympy import exp, factor
+        >>> a = sqrt(exp(x)**2 + 2*exp(x) + 1)/(exp(x) + 1)
+        >>> a.is_algebraic_expr(x)
+        False
+        >>> factor(a).is_algebraic_expr()
+        True
+
+        See Also
+        ========
+
+        is_rational_function
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Algebraic_expression
+
+        """
+        if syms:
+            syms = set(map(sympify, syms))
+        else:
+            syms = self.free_symbols
+            if not syms:
+                return True
+
+        return self._eval_is_algebraic_expr(syms)
+
+    def _eval_is_algebraic_expr(self, syms) -> bool | None:
+        if self in syms:
+            return True
+        if not self.has_free(*syms):
+            return True
+        # subclasses should return True or False
+        return None
+
+    ###################################################################################
+    ##################### SERIES, LEADING TERM, LIMIT, ORDER METHODS ##################
+    ###################################################################################
+
+    def series(self, x=None, x0=0, n=6, dir="+", logx=None, cdir=0):
+        """
+        Series expansion of "self" around ``x = x0`` yielding either terms of
+        the series one by one (the lazy series given when n=None), else
+        all the terms at once when n != None.
+
+        Returns the series expansion of "self" around the point ``x = x0``
+        with respect to ``x`` up to ``O((x - x0)**n, x, x0)`` (default n is 6).
+
+        If ``x=None`` and ``self`` is univariate, the univariate symbol will
+        be supplied, otherwise an error will be raised.
+
+        Parameters
+        ==========
+
+        expr : Expression
+               The expression whose series is to be expanded.
+
+        x : Symbol
+            It is the variable of the expression to be calculated.
+
+        x0 : Value
+             The value around which ``x`` is calculated. Can be any value
+             from ``-oo`` to ``oo``.
+
+        n : Value
+            The value used to represent the order in terms of ``x**n``,
+            up to which the series is to be expanded.
+
+        dir : String, optional
+              The series-expansion can be bi-directional. If ``dir="+"``,
+              then (x->x0+). If ``dir="-", then (x->x0-). For infinite
+              ``x0`` (``oo`` or ``-oo``), the ``dir`` argument is determined
+              from the direction of the infinity (i.e., ``dir="-"`` for
+              ``oo``).
+
+        logx : optional
+               It is used to replace any log(x) in the returned series with a
+               symbolic value rather than evaluating the actual value.
+
+        cdir : optional
+               It stands for complex direction, and indicates the direction
+               from which the expansion needs to be evaluated.
+
+        Examples
+        ========
+
+        >>> from sympy import cos, exp, tan
+        >>> from sympy.abc import x, y
+        >>> cos(x).series()
+        1 - x**2/2 + x**4/24 + O(x**6)
+        >>> cos(x).series(n=4)
+        1 - x**2/2 + O(x**4)
+        >>> cos(x).series(x, x0=1, n=2)
+        cos(1) - (x - 1)*sin(1) + O((x - 1)**2, (x, 1))
+        >>> e = cos(x + exp(y))
+        >>> e.series(y, n=2)
+        cos(x + 1) - y*sin(x + 1) + O(y**2)
+        >>> e.series(x, n=2)
+        cos(exp(y)) - x*sin(exp(y)) + O(x**2)
+
+        If ``n=None`` then a generator of the series terms will be returned.
+
+        >>> term=cos(x).series(n=None)
+        >>> [next(term) for i in range(2)]
+        [1, -x**2/2]
+
+        For ``dir=+`` (default) the series is calculated from the right and
+        for ``dir=-`` the series from the left. For smooth functions this
+        flag will not alter the results.
+
+        >>> abs(x).series(dir="+")
+        x
+        >>> abs(x).series(dir="-")
+        -x
+        >>> f = tan(x)
+        >>> f.series(x, 2, 6, "+")
+        tan(2) + (1 + tan(2)**2)*(x - 2) + (x - 2)**2*(tan(2)**3 + tan(2)) +
+        (x - 2)**3*(1/3 + 4*tan(2)**2/3 + tan(2)**4) + (x - 2)**4*(tan(2)**5 +
+        5*tan(2)**3/3 + 2*tan(2)/3) + (x - 2)**5*(2/15 + 17*tan(2)**2/15 +
+        2*tan(2)**4 + tan(2)**6) + O((x - 2)**6, (x, 2))
+
+        >>> f.series(x, 2, 3, "-")
+        tan(2) + (2 - x)*(-tan(2)**2 - 1) + (2 - x)**2*(tan(2)**3 + tan(2))
+        + O((x - 2)**3, (x, 2))
+
+        For rational expressions this method may return original expression without the Order term.
+        >>> (1/x).series(x, n=8)
+        1/x
+
+        Returns
+        =======
+
+        Expr : Expression
+            Series expansion of the expression about x0
+
+        Raises
+        ======
+
+        TypeError
+            If "n" and "x0" are infinity objects
+
+        PoleError
+            If "x0" is an infinity object
+
+        """
+        if x is None:
+            syms = self.free_symbols
+            if not syms:
+                return self
+            elif len(syms) > 1:
+                raise ValueError('x must be given for multivariate functions.')
+            x = syms.pop()
+
+        from .symbol import Dummy, Symbol
+        if isinstance(x, Symbol):
+            dep = x in self.free_symbols
+        else:
+            d = Dummy()
+            dep = d in self.xreplace({x: d}).free_symbols
+        if not dep:
+            if n is None:
+                return (s for s in [self])
+            else:
+                return self
+
+        if len(dir) != 1 or dir not in '+-':
+            raise ValueError("Dir must be '+' or '-'")
+
+        if n is not None:
+            n = int(n)
+            if n < 0:
+                raise ValueError("Number of terms should be nonnegative")
+
+        x0 = sympify(x0)
+        cdir = sympify(cdir)
+        from sympy.functions.elementary.complexes import im, sign
+
+        if not cdir.is_zero:
+            if cdir.is_real:
+                dir = '+' if cdir.is_positive else '-'
+            else:
+                dir = '+' if im(cdir).is_positive else '-'
+        else:
+            if x0 and x0.is_infinite:
+                cdir = sign(x0).simplify()
+            elif str(dir) == "+":
+                cdir = S.One
+            elif str(dir) == "-":
+                cdir = S.NegativeOne
+            elif cdir == S.Zero:
+                cdir = S.One
+
+        cdir = cdir/abs(cdir)
+
+        if x0 and x0.is_infinite:
+            from .function import PoleError
+            try:
+                s = self.subs(x, cdir/x).series(x, n=n, dir='+', cdir=1)
+                if n is None:
+                    return (si.subs(x, cdir/x) for si in s)
+                return s.subs(x, cdir/x)
+            except PoleError:
+                s = self.subs(x, cdir*x).aseries(x, n=n)
+                return s.subs(x, cdir*x)
+
+        # use rep to shift origin to x0 and change sign (if dir is negative)
+        # and undo the process with rep2
+        if x0 or cdir != 1:
+            s = self.subs({x: x0 + cdir*x}).series(x, x0=0, n=n, dir='+', logx=logx, cdir=1)
+            if n is None:  # lseries...
+                return (si.subs({x: x/cdir - x0/cdir}) for si in s)
+            return s.subs({x: x/cdir - x0/cdir})
+
+        # from here on it's x0=0 and dir='+' handling
+
+        if x.is_positive is x.is_negative is None or x.is_Symbol is not True:
+            # replace x with an x that has a positive assumption
+            xpos = Dummy('x', positive=True)
+            rv = self.subs(x, xpos).series(xpos, x0, n, dir, logx=logx, cdir=cdir)
+            if n is None:
+                return (s.subs(xpos, x) for s in rv)
+            else:
+                return rv.subs(xpos, x)
+
+        from sympy.series.order import Order
+        if n is not None:  # nseries handling
+            s1 = self._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+            o = s1.getO() or S.Zero
+            if o:
+                # make sure the requested order is returned
+                ngot = o.getn()
+                if ngot > n:
+                    # leave o in its current form (e.g. with x*log(x)) so
+                    # it eats terms properly, then replace it below
+                    if n != 0:
+                        s1 += o.subs(x, x**Rational(n, ngot))
+                    else:
+                        s1 += Order(1, x)
+                elif ngot < n:
+                    # increase the requested number of terms to get the desired
+                    # number keep increasing (up to 9) until the received order
+                    # is different than the original order and then predict how
+                    # many additional terms are needed
+                    from sympy.functions.elementary.integers import ceiling
+                    for more in range(1, 9):
+                        s1 = self._eval_nseries(x, n=n + more, logx=logx, cdir=cdir)
+                        newn = s1.getn()
+                        if newn != ngot:
+                            ndo = n + ceiling((n - ngot)*more/(newn - ngot))
+                            s1 = self._eval_nseries(x, n=ndo, logx=logx, cdir=cdir)
+                            while s1.getn() < n:
+                                s1 = self._eval_nseries(x, n=ndo, logx=logx, cdir=cdir)
+                                ndo += 1
+                            break
+                    else:
+                        raise ValueError('Could not calculate %s terms for %s'
+                                         % (str(n), self))
+                    s1 += Order(x**n, x)
+                o = s1.getO()
+                s1 = s1.removeO()
+            elif s1.has(Order):
+                # asymptotic expansion
+                return s1
+            else:
+                o = Order(x**n, x)
+                s1done = s1.doit()
+                try:
+                    if (s1done + o).removeO() == s1done:
+                        o = S.Zero
+                except NotImplementedError:
+                    return s1
+
+            try:
+                from sympy.simplify.radsimp import collect
+                return collect(s1, x) + o
+            except NotImplementedError:
+                return s1 + o
+
+        else:  # lseries handling
+            def yield_lseries(s):
+                """Return terms of lseries one at a time."""
+                for si in s:
+                    if not si.is_Add:
+                        yield si
+                        continue
+                    # yield terms 1 at a time if possible
+                    # by increasing order until all the
+                    # terms have been returned
+                    yielded = 0
+                    o = Order(si, x)*x
+                    ndid = 0
+                    ndo = len(si.args)
+                    while 1:
+                        do = (si - yielded + o).removeO()
+                        o *= x
+                        if not do or do.is_Order:
+                            continue
+                        if do.is_Add:
+                            ndid += len(do.args)
+                        else:
+                            ndid += 1
+                        yield do
+                        if ndid == ndo:
+                            break
+                        yielded += do
+
+            return yield_lseries(self.removeO()._eval_lseries(x, logx=logx, cdir=cdir))
+
+    def aseries(self, x=None, n=6, bound=0, hir=False):
+        """Asymptotic Series expansion of self.
+        This is equivalent to ``self.series(x, oo, n)``.
+
+        Parameters
+        ==========
+
+        self : Expression
+               The expression whose series is to be expanded.
+
+        x : Symbol
+            It is the variable of the expression to be calculated.
+
+        n : Value
+            The value used to represent the order in terms of ``x**n``,
+            up to which the series is to be expanded.
+
+        hir : Boolean
+              Set this parameter to be True to produce hierarchical series.
+              It stops the recursion at an early level and may provide nicer
+              and more useful results.
+
+        bound : Value, Integer
+                Use the ``bound`` parameter to give limit on rewriting
+                coefficients in its normalised form.
+
+        Examples
+        ========
+
+        >>> from sympy import sin, exp
+        >>> from sympy.abc import x
+
+        >>> e = sin(1/x + exp(-x)) - sin(1/x)
+
+        >>> e.aseries(x)
+        (1/(24*x**4) - 1/(2*x**2) + 1 + O(x**(-6), (x, oo)))*exp(-x)
+
+        >>> e.aseries(x, n=3, hir=True)
+        -exp(-2*x)*sin(1/x)/2 + exp(-x)*cos(1/x) + O(exp(-3*x), (x, oo))
+
+        >>> e = exp(exp(x)/(1 - 1/x))
+
+        >>> e.aseries(x)
+        exp(exp(x)/(1 - 1/x))
+
+        >>> e.aseries(x, bound=3) # doctest: +SKIP
+        exp(exp(x)/x**2)*exp(exp(x)/x)*exp(-exp(x) + exp(x)/(1 - 1/x) - exp(x)/x - exp(x)/x**2)*exp(exp(x))
+
+        For rational expressions this method may return original expression without the Order term.
+        >>> (1/x).aseries(x, n=8)
+        1/x
+
+        Returns
+        =======
+
+        Expr
+            Asymptotic series expansion of the expression.
+
+        Notes
+        =====
+
+        This algorithm is directly induced from the limit computational algorithm provided by Gruntz.
+        It majorly uses the mrv and rewrite sub-routines. The overall idea of this algorithm is first
+        to look for the most rapidly varying subexpression w of a given expression f and then expands f
+        in a series in w. Then same thing is recursively done on the leading coefficient
+        till we get constant coefficients.
+
+        If the most rapidly varying subexpression of a given expression f is f itself,
+        the algorithm tries to find a normalised representation of the mrv set and rewrites f
+        using this normalised representation.
+
+        If the expansion contains an order term, it will be either ``O(x ** (-n))`` or ``O(w ** (-n))``
+        where ``w`` belongs to the most rapidly varying expression of ``self``.
+
+        References
+        ==========
+
+        .. [1] Gruntz, Dominik. A new algorithm for computing asymptotic series.
+               In: Proc. 1993 Int. Symp. Symbolic and Algebraic Computation. 1993.
+               pp. 239-244.
+        .. [2] Gruntz thesis - p90
+        .. [3] https://en.wikipedia.org/wiki/Asymptotic_expansion
+
+        See Also
+        ========
+
+        Expr.aseries: See the docstring of this function for complete details of this wrapper.
+        """
+
+        from .symbol import Dummy
+
+        if x.is_positive is x.is_negative is None:
+            xpos = Dummy('x', positive=True)
+            return self.subs(x, xpos).aseries(xpos, n, bound, hir).subs(xpos, x)
+
+        from .function import PoleError
+        from sympy.series.gruntz import mrv, rewrite
+
+        try:
+            om, exps = mrv(self, x)
+        except PoleError:
+            return self
+
+        # We move one level up by replacing `x` by `exp(x)`, and then
+        # computing the asymptotic series for f(exp(x)). Then asymptotic series
+        # can be obtained by moving one-step back, by replacing x by ln(x).
+
+        from sympy.functions.elementary.exponential import exp, log
+        from sympy.series.order import Order
+
+        if x in om:
+            s = self.subs(x, exp(x)).aseries(x, n, bound, hir).subs(x, log(x))
+            if s.getO():
+                return s + Order(1/x**n, (x, S.Infinity))
+            return s
+
+        k = Dummy('k', positive=True)
+        # f is rewritten in terms of omega
+        func, logw = rewrite(exps, om, x, k)
+
+        if self in om:
+            if bound <= 0:
+                return self
+            s = (self.exp).aseries(x, n, bound=bound)
+            s = s.func(*[t.removeO() for t in s.args])
+            try:
+                res = exp(s.subs(x, 1/x).as_leading_term(x).subs(x, 1/x))
+            except PoleError:
+                res = self
+
+            func = exp(self.args[0] - res.args[0]) / k
+            logw = log(1/res)
+
+        s = func.series(k, 0, n)
+        from sympy.core.function import expand_mul
+        s = expand_mul(s)
+        # Hierarchical series
+        if hir:
+            return s.subs(k, exp(logw))
+
+        o = s.getO()
+        terms = sorted(Add.make_args(s.removeO()), key=lambda i: int(i.as_coeff_exponent(k)[1]))
+        s = S.Zero
+        has_ord = False
+
+        # Then we recursively expand these coefficients one by one into
+        # their asymptotic series in terms of their most rapidly varying subexpressions.
+        for t in terms:
+            coeff, expo = t.as_coeff_exponent(k)
+            if coeff.has(x):
+                # Recursive step
+                snew = coeff.aseries(x, n, bound=bound-1)
+                if has_ord and snew.getO():
+                    break
+                elif snew.getO():
+                    has_ord = True
+                s += (snew * k**expo)
+            else:
+                s += t
+
+        if not o or has_ord:
+            return s.subs(k, exp(logw))
+        return (s + o).subs(k, exp(logw))
+
+
+    def taylor_term(self, n, x, *previous_terms):
+        """General method for the taylor term.
+
+        This method is slow, because it differentiates n-times. Subclasses can
+        redefine it to make it faster by using the "previous_terms".
+        """
+        from .symbol import Dummy
+        from sympy.functions.combinatorial.factorials import factorial
+
+        x = sympify(x)
+        _x = Dummy('x')
+        return self.subs(x, _x).diff(_x, n).subs(_x, x).subs(x, 0) * x**n / factorial(n)
+
+    def lseries(self, x=None, x0=0, dir='+', logx=None, cdir=0):
+        """
+        Wrapper for series yielding an iterator of the terms of the series.
+
+        Note: an infinite series will yield an infinite iterator. The following,
+        for exaxmple, will never terminate. It will just keep printing terms
+        of the sin(x) series::
+
+          for term in sin(x).lseries(x):
+              print term
+
+        The advantage of lseries() over nseries() is that many times you are
+        just interested in the next term in the series (i.e. the first term for
+        example), but you do not know how many you should ask for in nseries()
+        using the "n" parameter.
+
+        See also nseries().
+        """
+        return self.series(x, x0, n=None, dir=dir, logx=logx, cdir=cdir)
+
+    def _eval_lseries(self, x, logx=None, cdir=0):
+        # default implementation of lseries is using nseries(), and adaptively
+        # increasing the "n". As you can see, it is not very efficient, because
+        # we are calculating the series over and over again. Subclasses should
+        # override this method and implement much more efficient yielding of
+        # terms.
+        n = 0
+        series = self._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+        while series.is_Order:
+            n += 1
+            series = self._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+        e = series.removeO()
+        yield e
+        if e is S.Zero:
+            return
+
+        while 1:
+            while 1:
+                n += 1
+                series = self._eval_nseries(x, n=n, logx=logx, cdir=cdir).removeO()
+                if e != series:
+                    break
+                if (series - self).cancel() is S.Zero:
+                    return
+            yield series - e
+            e = series
+
+    def nseries(self, x=None, x0=0, n=6, dir='+', logx=None, cdir=0):
+        """
+        Wrapper to _eval_nseries if assumptions allow, else to series.
+
+        If x is given, x0 is 0, dir='+', and self has x, then _eval_nseries is
+        called. This calculates "n" terms in the innermost expressions and
+        then builds up the final series just by "cross-multiplying" everything
+        out.
+
+        The optional ``logx`` parameter can be used to replace any log(x) in the
+        returned series with a symbolic value to avoid evaluating log(x) at 0. A
+        symbol to use in place of log(x) should be provided.
+
+        Advantage -- it's fast, because we do not have to determine how many
+        terms we need to calculate in advance.
+
+        Disadvantage -- you may end up with less terms than you may have
+        expected, but the O(x**n) term appended will always be correct and
+        so the result, though perhaps shorter, will also be correct.
+
+        If any of those assumptions is not met, this is treated like a
+        wrapper to series which will try harder to return the correct
+        number of terms.
+
+        See also lseries().
+
+        Examples
+        ========
+
+        >>> from sympy import sin, log, Symbol
+        >>> from sympy.abc import x, y
+        >>> sin(x).nseries(x, 0, 6)
+        x - x**3/6 + x**5/120 + O(x**6)
+        >>> log(x+1).nseries(x, 0, 5)
+        x - x**2/2 + x**3/3 - x**4/4 + O(x**5)
+
+        Handling of the ``logx`` parameter --- in the following example the
+        expansion fails since ``sin`` does not have an asymptotic expansion
+        at -oo (the limit of log(x) as x approaches 0):
+
+        >>> e = sin(log(x))
+        >>> e.nseries(x, 0, 6)
+        Traceback (most recent call last):
+        ...
+        PoleError: ...
+        ...
+        >>> logx = Symbol('logx')
+        >>> e.nseries(x, 0, 6, logx=logx)
+        sin(logx)
+
+        In the following example, the expansion works but only returns self
+        unless the ``logx`` parameter is used:
+
+        >>> e = x**y
+        >>> e.nseries(x, 0, 2)
+        x**y
+        >>> e.nseries(x, 0, 2, logx=logx)
+        exp(logx*y)
+
+        """
+        if x and x not in self.free_symbols:
+            return self
+        if x is None or x0 or dir != '+':  # {see XPOS above} or (x.is_positive == x.is_negative == None):
+            return self.series(x, x0, n, dir, cdir=cdir)
+        else:
+            return self._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir):
+        """
+        Return terms of series for self up to O(x**n) at x=0
+        from the positive direction.
+
+        This is a method that should be overridden in subclasses. Users should
+        never call this method directly (use .nseries() instead), so you do not
+        have to write docstrings for _eval_nseries().
+        """
+        raise NotImplementedError(filldedent("""
+                     The _eval_nseries method should be added to
+                     %s to give terms up to O(x**n) at x=0
+                     from the positive direction so it is available when
+                     nseries calls it.""" % self.func)
+                     )
+
+    def limit(self, x, xlim, dir='+'):
+        """ Compute limit x->xlim.
+        """
+        from sympy.series.limits import limit
+        return limit(self, x, xlim, dir)
+
+    @cacheit
+    def as_leading_term(self, *symbols, logx=None, cdir=0):
+        """
+        Returns the leading (nonzero) term of the series expansion of self.
+
+        The _eval_as_leading_term routines are used to do this, and they must
+        always return a non-zero value.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (1 + x + x**2).as_leading_term(x)
+        1
+        >>> (1/x**2 + x + x**2).as_leading_term(x)
+        x**(-2)
+
+        """
+        if len(symbols) > 1:
+            c = self
+            for x in symbols:
+                c = c.as_leading_term(x, logx=logx, cdir=cdir)
+            return c
+        elif not symbols:
+            return self
+        x = sympify(symbols[0])
+        cdir = sympify(cdir)
+        if not x.is_symbol:
+            raise ValueError('expecting a Symbol but got %s' % x)
+        if x not in self.free_symbols:
+            return self
+        obj = self._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        if obj is not None:
+            from sympy.simplify.powsimp import powsimp
+            return powsimp(obj, deep=True, combine='exp')
+        raise NotImplementedError('as_leading_term(%s, %s)' % (self, x))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        return self
+
+    def as_coeff_exponent(self, x) -> tuple[Expr, Expr]:
+        """ ``c*x**e -> c,e`` where x can be any symbolic expression.
+        """
+        from sympy.simplify.radsimp import collect
+        s = collect(self, x)
+        c, p = s.as_coeff_mul(x)
+        if len(p) == 1:
+            b, e = p[0].as_base_exp()
+            if b == x:
+                return c, e
+        return s, S.Zero
+
+    def leadterm(self, x, logx=None, cdir=0):
+        """
+        Returns the leading term a*x**b as a tuple (a, b).
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x
+        >>> (1+x+x**2).leadterm(x)
+        (1, 0)
+        >>> (1/x**2+x+x**2).leadterm(x)
+        (1, -2)
+
+        """
+        from .symbol import Dummy
+        from sympy.functions.elementary.exponential import log
+        l = self.as_leading_term(x, logx=logx, cdir=cdir)
+        d = Dummy('logx')
+        if l.has(log(x)):
+            l = l.subs(log(x), d)
+        c, e = l.as_coeff_exponent(x)
+        if x in c.free_symbols:
+            raise ValueError(filldedent("""
+                cannot compute leadterm(%s, %s). The coefficient
+                should have been free of %s but got %s""" % (self, x, x, c)))
+        c = c.subs(d, log(x))
+        return c, e
+
+    def as_coeff_Mul(self, rational: bool = False) -> tuple['Number', Expr]:
+        """Efficiently extract the coefficient of a product."""
+        return S.One, self
+
+    def as_coeff_Add(self, rational=False) -> tuple['Number', Expr]:
+        """Efficiently extract the coefficient of a summation."""
+        return S.Zero, self
+
+    def fps(self, x=None, x0=0, dir=1, hyper=True, order=4, rational=True,
+            full=False):
+        """
+        Compute formal power power series of self.
+
+        See the docstring of the :func:`fps` function in sympy.series.formal for
+        more information.
+        """
+        from sympy.series.formal import fps
+
+        return fps(self, x, x0, dir, hyper, order, rational, full)
+
+    def fourier_series(self, limits=None):
+        """Compute fourier sine/cosine series of self.
+
+        See the docstring of the :func:`fourier_series` in sympy.series.fourier
+        for more information.
+        """
+        from sympy.series.fourier import fourier_series
+
+        return fourier_series(self, limits)
+
+    ###################################################################################
+    ##################### DERIVATIVE, INTEGRAL, FUNCTIONAL METHODS ####################
+    ###################################################################################
+
+    def diff(self, *symbols, **assumptions):
+        assumptions.setdefault("evaluate", True)
+        return _derivative_dispatch(self, *symbols, **assumptions)
+
+    ###########################################################################
+    ###################### EXPRESSION EXPANSION METHODS #######################
+    ###########################################################################
+
+    # Relevant subclasses should override _eval_expand_hint() methods.  See
+    # the docstring of expand() for more info.
+
+    def _eval_expand_complex(self, **hints):
+        real, imag = self.as_real_imag(**hints)
+        return real + S.ImaginaryUnit*imag
+
+    @staticmethod
+    def _expand_hint(expr, hint, deep=True, **hints):
+        """
+        Helper for ``expand()``.  Recursively calls ``expr._eval_expand_hint()``.
+
+        Returns ``(expr, hit)``, where expr is the (possibly) expanded
+        ``expr`` and ``hit`` is ``True`` if ``expr`` was truly expanded and
+        ``False`` otherwise.
+        """
+        hit = False
+        # XXX: Hack to support non-Basic args
+        #              |
+        #              V
+        if deep and getattr(expr, 'args', ()) and not expr.is_Atom:
+            sargs = []
+            for arg in expr.args:
+                arg, arghit = Expr._expand_hint(arg, hint, **hints)
+                hit |= arghit
+                sargs.append(arg)
+
+            if hit:
+                expr = expr.func(*sargs)
+
+        if hasattr(expr, hint):
+            newexpr = getattr(expr, hint)(**hints)
+            if newexpr != expr:
+                return (newexpr, True)
+
+        return (expr, hit)
+
+    @cacheit
+    def expand(self, deep=True, modulus=None, power_base=True, power_exp=True,
+            mul=True, log=True, multinomial=True, basic=True, **hints):
+        """
+        Expand an expression using hints.
+
+        See the docstring of the expand() function in sympy.core.function for
+        more information.
+
+        """
+        from sympy.simplify.radsimp import fraction
+
+        hints.update(power_base=power_base, power_exp=power_exp, mul=mul,
+           log=log, multinomial=multinomial, basic=basic)
+
+        expr = self
+        # default matches fraction's default
+        _fraction = lambda x: fraction(x, hints.get('exact', False))
+        if hints.pop('frac', False):
+            n, d = [a.expand(deep=deep, modulus=modulus, **hints)
+                    for a in _fraction(self)]
+            return n/d
+        elif hints.pop('denom', False):
+            n, d = _fraction(self)
+            return n/d.expand(deep=deep, modulus=modulus, **hints)
+        elif hints.pop('numer', False):
+            n, d = _fraction(self)
+            return n.expand(deep=deep, modulus=modulus, **hints)/d
+
+        # Although the hints are sorted here, an earlier hint may get applied
+        # at a given node in the expression tree before another because of how
+        # the hints are applied.  e.g. expand(log(x*(y + z))) -> log(x*y +
+        # x*z) because while applying log at the top level, log and mul are
+        # applied at the deeper level in the tree so that when the log at the
+        # upper level gets applied, the mul has already been applied at the
+        # lower level.
+
+        # Additionally, because hints are only applied once, the expression
+        # may not be expanded all the way.   For example, if mul is applied
+        # before multinomial, x*(x + 1)**2 won't be expanded all the way.  For
+        # now, we just use a special case to make multinomial run before mul,
+        # so that at least polynomials will be expanded all the way.  In the
+        # future, smarter heuristics should be applied.
+        # TODO: Smarter heuristics
+
+        def _expand_hint_key(hint):
+            """Make multinomial come before mul"""
+            if hint == 'mul':
+                return 'mulz'
+            return hint
+
+        for hint in sorted(hints.keys(), key=_expand_hint_key):
+            use_hint = hints[hint]
+            if use_hint:
+                hint = '_eval_expand_' + hint
+                expr, hit = Expr._expand_hint(expr, hint, deep=deep, **hints)
+
+        while True:
+            was = expr
+            if hints.get('multinomial', False):
+                expr, _ = Expr._expand_hint(
+                    expr, '_eval_expand_multinomial', deep=deep, **hints)
+            if hints.get('mul', False):
+                expr, _ = Expr._expand_hint(
+                    expr, '_eval_expand_mul', deep=deep, **hints)
+            if hints.get('log', False):
+                expr, _ = Expr._expand_hint(
+                    expr, '_eval_expand_log', deep=deep, **hints)
+            if expr == was:
+                break
+
+        if modulus is not None:
+            modulus = sympify(modulus)
+
+            if not modulus.is_Integer or modulus <= 0:
+                raise ValueError(
+                    "modulus must be a positive integer, got %s" % modulus)
+
+            terms = []
+
+            for term in Add.make_args(expr):
+                coeff, tail = term.as_coeff_Mul(rational=True)
+
+                coeff %= modulus
+
+                if coeff:
+                    terms.append(coeff*tail)
+
+            expr = Add(*terms)
+
+        return expr
+
+    ###########################################################################
+    ################### GLOBAL ACTION VERB WRAPPER METHODS ####################
+    ###########################################################################
+
+    def integrate(self, *args, **kwargs):
+        """See the integrate function in sympy.integrals"""
+        from sympy.integrals.integrals import integrate
+        return integrate(self, *args, **kwargs)
+
+    def nsimplify(self, constants=(), tolerance=None, full=False):
+        """See the nsimplify function in sympy.simplify"""
+        from sympy.simplify.simplify import nsimplify
+        return nsimplify(self, constants, tolerance, full)
+
+    def separate(self, deep=False, force=False):
+        """See the separate function in sympy.simplify"""
+        from .function import expand_power_base
+        return expand_power_base(self, deep=deep, force=force)
+
+    def collect(self, syms, func=None, evaluate=True, exact=False, distribute_order_term=True):
+        """See the collect function in sympy.simplify"""
+        from sympy.simplify.radsimp import collect
+        return collect(self, syms, func, evaluate, exact, distribute_order_term)
+
+    def together(self, *args, **kwargs):
+        """See the together function in sympy.polys"""
+        from sympy.polys.rationaltools import together
+        return together(self, *args, **kwargs)
+
+    def apart(self, x=None, **args):
+        """See the apart function in sympy.polys"""
+        from sympy.polys.partfrac import apart
+        return apart(self, x, **args)
+
+    def ratsimp(self):
+        """See the ratsimp function in sympy.simplify"""
+        from sympy.simplify.ratsimp import ratsimp
+        return ratsimp(self)
+
+    def trigsimp(self, **args):
+        """See the trigsimp function in sympy.simplify"""
+        from sympy.simplify.trigsimp import trigsimp
+        return trigsimp(self, **args)
+
+    def radsimp(self, **kwargs):
+        """See the radsimp function in sympy.simplify"""
+        from sympy.simplify.radsimp import radsimp
+        return radsimp(self, **kwargs)
+
+    def powsimp(self, *args, **kwargs):
+        """See the powsimp function in sympy.simplify"""
+        from sympy.simplify.powsimp import powsimp
+        return powsimp(self, *args, **kwargs)
+
+    def combsimp(self):
+        """See the combsimp function in sympy.simplify"""
+        from sympy.simplify.combsimp import combsimp
+        return combsimp(self)
+
+    def gammasimp(self):
+        """See the gammasimp function in sympy.simplify"""
+        from sympy.simplify.gammasimp import gammasimp
+        return gammasimp(self)
+
+    def factor(self, *gens, **args):
+        """See the factor() function in sympy.polys.polytools"""
+        from sympy.polys.polytools import factor
+        return factor(self, *gens, **args)
+
+    def cancel(self, *gens, **args):
+        """See the cancel function in sympy.polys"""
+        from sympy.polys.polytools import cancel
+        return cancel(self, *gens, **args)
+
+    def invert(self, g, *gens, **args):
+        """Return the multiplicative inverse of ``self`` mod ``g``
+        where ``self`` (and ``g``) may be symbolic expressions).
+
+        See Also
+        ========
+        sympy.core.intfunc.mod_inverse, sympy.polys.polytools.invert
+        """
+        if self.is_number and getattr(g, 'is_number', True):
+            return mod_inverse(self, g)
+        from sympy.polys.polytools import invert
+        return invert(self, g, *gens, **args)
+
+    def round(self, n=None):
+        """Return x rounded to the given decimal place.
+
+        If a complex number would results, apply round to the real
+        and imaginary components of the number.
+
+        Examples
+        ========
+
+        >>> from sympy import pi, E, I, S, Number
+        >>> pi.round()
+        3
+        >>> pi.round(2)
+        3.14
+        >>> (2*pi + E*I).round()
+        6 + 3*I
+
+        The round method has a chopping effect:
+
+        >>> (2*pi + I/10).round()
+        6
+        >>> (pi/10 + 2*I).round()
+        2*I
+        >>> (pi/10 + E*I).round(2)
+        0.31 + 2.72*I
+
+        Notes
+        =====
+
+        The Python ``round`` function uses the SymPy ``round`` method so it
+        will always return a SymPy number (not a Python float or int):
+
+        >>> isinstance(round(S(123), -2), Number)
+        True
+        """
+        x = self
+
+        if not x.is_number:
+            raise TypeError("Cannot round symbolic expression")
+        if not x.is_Atom:
+            if not pure_complex(x.n(2), or_real=True):
+                raise TypeError(
+                    'Expected a number but got %s:' % func_name(x))
+        elif x in _illegal:
+            return x
+        if not (xr := x.is_extended_real):
+            r, i = x.as_real_imag()
+            if xr is False:
+                return r.round(n) + S.ImaginaryUnit*i.round(n)
+            if i.equals(0):
+                return r.round(n)
+        if not x:
+            return S.Zero if n is None else x
+
+        p = as_int(n or 0)
+
+        if x.is_Integer:
+            return Integer(round(int(x), p))
+
+        digits_to_decimal = _mag(x)  # _mag(12) = 2, _mag(.012) = -1
+        allow = digits_to_decimal + p
+        precs = [f._prec for f in x.atoms(Float)]
+        dps = prec_to_dps(max(precs)) if precs else None
+        if dps is None:
+            # assume everything is exact so use the Python
+            # float default or whatever was requested
+            dps = max(15, allow)
+        else:
+            allow = min(allow, dps)
+        # this will shift all digits to right of decimal
+        # and give us dps to work with as an int
+        shift = -digits_to_decimal + dps
+        extra = 1  # how far we look past known digits
+        # NOTE
+        # mpmath will calculate the binary representation to
+        # an arbitrary number of digits but we must base our
+        # answer on a finite number of those digits, e.g.
+        # .575 2589569785738035/2**52 in binary.
+        # mpmath shows us that the first 18 digits are
+        #     >>> Float(.575).n(18)
+        #     0.574999999999999956
+        # The default precision is 15 digits and if we ask
+        # for 15 we get
+        #     >>> Float(.575).n(15)
+        #     0.575000000000000
+        # mpmath handles rounding at the 15th digit. But we
+        # need to be careful since the user might be asking
+        # for rounding at the last digit and our semantics
+        # are to round toward the even final digit when there
+        # is a tie. So the extra digit will be used to make
+        # that decision. In this case, the value is the same
+        # to 15 digits:
+        #     >>> Float(.575).n(16)
+        #     0.5750000000000000
+        # Now converting this to the 15 known digits gives
+        #     575000000000000.0
+        # which rounds to integer
+        #    5750000000000000
+        # And now we can round to the desired digt, e.g. at
+        # the second from the left and we get
+        #    5800000000000000
+        # and rescaling that gives
+        #    0.58
+        # as the final result.
+        # If the value is made slightly less than 0.575 we might
+        # still obtain the same value:
+        #    >>> Float(.575-1e-16).n(16)*10**15
+        #    574999999999999.8
+        # What 15 digits best represents the known digits (which are
+        # to the left of the decimal? 5750000000000000, the same as
+        # before. The only way we will round down (in this case) is
+        # if we declared that we had more than 15 digits of precision.
+        # For example, if we use 16 digits of precision, the integer
+        # we deal with is
+        #    >>> Float(.575-1e-16).n(17)*10**16
+        #    5749999999999998.4
+        # and this now rounds to 5749999999999998 and (if we round to
+        # the 2nd digit from the left) we get 5700000000000000.
+        #
+        xf = x.n(dps + extra)*Pow(10, shift)
+        if xf.is_Number and xf._prec == 1:  # xf.is_Add will raise below
+            # is x == 0?
+            if x.equals(0):
+                return Float(0)
+            raise ValueError('not computing with precision')
+        xi = Integer(xf)
+        # use the last digit to select the value of xi
+        # nearest to x before rounding at the desired digit
+        sign = 1 if x > 0 else -1
+        dif2 = sign*(xf - xi).n(extra)
+        if dif2 < 0:
+            raise NotImplementedError(
+                'not expecting int(x) to round away from 0')
+        if dif2 > .5:
+            xi += sign  # round away from 0
+        elif dif2 == .5:
+            xi += sign if xi%2 else -sign  # round toward even
+        # shift p to the new position
+        ip = p - shift
+        # let Python handle the int rounding then rescale
+        xr = round(xi.p, ip)
+        # restore scale
+        rv = Rational(xr, Pow(10, shift))
+        # return Float or Integer
+        if rv.is_Integer:
+            if n is None:  # the single-arg case
+                return rv
+            # use str or else it won't be a float
+            return Float(str(rv), dps)  # keep same precision
+        else:
+            if not allow and rv > self:
+                allow += 1
+            return Float(rv, allow)
+
+    __round__ = round
+
+    def _eval_derivative_matrix_lines(self, x):
+        from sympy.matrices.expressions.matexpr import _LeftRightArgs
+        return [_LeftRightArgs([S.One, S.One], higher=self._eval_derivative(x))]
+
+
+class AtomicExpr(Atom, Expr):
+    """
+    A parent class for object which are both atoms and Exprs.
+
+    For example: Symbol, Number, Rational, Integer, ...
+    But not: Add, Mul, Pow, ...
+    """
+    is_number = False
+    is_Atom = True
+
+    __slots__ = ()
+
+    def _eval_derivative(self, s):
+        if self == s:
+            return S.One
+        return S.Zero
+
+    def _eval_derivative_n_times(self, s, n):
+        from .containers import Tuple
+        from sympy.matrices.expressions.matexpr import MatrixExpr
+        from sympy.matrices.matrixbase import MatrixBase
+        if isinstance(s, (MatrixBase, Tuple, Iterable, MatrixExpr)):
+            return super()._eval_derivative_n_times(s, n)
+        from .relational import Eq
+        from sympy.functions.elementary.piecewise import Piecewise
+        if self == s:
+            return Piecewise((self, Eq(n, 0)), (1, Eq(n, 1)), (0, True))
+        else:
+            return Piecewise((self, Eq(n, 0)), (0, True))
+
+    def _eval_is_polynomial(self, syms):
+        return True
+
+    def _eval_is_rational_function(self, syms):
+        return self not in _illegal
+
+    def _eval_is_meromorphic(self, x, a):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        return (not self.is_Number or self.is_finite) and not isinstance(self, AccumBounds)
+
+    def _eval_is_algebraic_expr(self, syms):
+        return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        return self
+
+    @property
+    def expr_free_symbols(self):
+        sympy_deprecation_warning("""
+        The expr_free_symbols property is deprecated. Use free_symbols to get
+        the free symbols of an expression.
+        """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-expr-free-symbols")
+        return {self}
+
+
+def _mag(x):
+    r"""Return integer $i$ such that $0.1 \le x/10^i < 1$
+
+    Examples
+    ========
+
+    >>> from sympy.core.expr import _mag
+    >>> from sympy import Float
+    >>> _mag(Float(.1))
+    0
+    >>> _mag(Float(.01))
+    -1
+    >>> _mag(Float(1234))
+    4
+    """
+    from math import log10, ceil, log
+    xpos = abs(x.n())
+    if not xpos:
+        return S.Zero
+    try:
+        mag_first_dig = int(ceil(log10(xpos)))
+    except (ValueError, OverflowError):
+        mag_first_dig = int(ceil(Float(mpf_log(xpos._mpf_, 53))/log(10)))
+    # check that we aren't off by 1
+    if (xpos/S(10)**mag_first_dig) >= 1:
+        assert 1 <= (xpos/S(10)**mag_first_dig) < 10
+        mag_first_dig += 1
+    return mag_first_dig
+
+
+class UnevaluatedExpr(Expr):
+    """
+    Expression that is not evaluated unless released.
+
+    Examples
+    ========
+
+    >>> from sympy import UnevaluatedExpr
+    >>> from sympy.abc import x
+    >>> x*(1/x)
+    1
+    >>> x*UnevaluatedExpr(1/x)
+    x*1/x
+
+    """
+
+    def __new__(cls, arg, **kwargs):
+        arg = _sympify(arg)
+        obj = Expr.__new__(cls, arg, **kwargs)
+        return obj
+
+    def doit(self, **hints):
+        if hints.get("deep", True):
+            return self.args[0].doit(**hints)
+        else:
+            return self.args[0]
+
+
+
+def unchanged(func, *args):
+    """Return True if `func` applied to the `args` is unchanged.
+    Can be used instead of `assert foo == foo`.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, cos, pi
+    >>> from sympy.core.expr import unchanged
+    >>> from sympy.abc import x
+
+    >>> unchanged(cos, 1)  # instead of assert cos(1) == cos(1)
+    True
+
+    >>> unchanged(cos, pi)
+    False
+
+    Comparison of args uses the builtin capabilities of the object's
+    arguments to test for equality so args can be defined loosely. Here,
+    the ExprCondPair arguments of Piecewise compare as equal to the
+    tuples that can be used to create the Piecewise:
+
+    >>> unchanged(Piecewise, (x, x > 1), (0, True))
+    True
+    """
+    f = func(*args)
+    return f.func == func and f.args == args
+
+
+class ExprBuilder:
+    def __init__(self, op, args=None, validator=None, check=True):
+        if not hasattr(op, "__call__"):
+            raise TypeError("op {} needs to be callable".format(op))
+        self.op = op
+        if args is None:
+            self.args = []
+        else:
+            self.args = args
+        self.validator = validator
+        if (validator is not None) and check:
+            self.validate()
+
+    @staticmethod
+    def _build_args(args):
+        return [i.build() if isinstance(i, ExprBuilder) else i for i in args]
+
+    def validate(self):
+        if self.validator is None:
+            return
+        args = self._build_args(self.args)
+        self.validator(*args)
+
+    def build(self, check=True):
+        args = self._build_args(self.args)
+        if self.validator and check:
+            self.validator(*args)
+        return self.op(*args)
+
+    def append_argument(self, arg, check=True):
+        self.args.append(arg)
+        if self.validator and check:
+            self.validate(*self.args)
+
+    def __getitem__(self, item):
+        if item == 0:
+            return self.op
+        else:
+            return self.args[item-1]
+
+    def __repr__(self):
+        return str(self.build())
+
+    def search_element(self, elem):
+        for i, arg in enumerate(self.args):
+            if isinstance(arg, ExprBuilder):
+                ret = arg.search_index(elem)
+                if ret is not None:
+                    return (i,) + ret
+            elif id(arg) == id(elem):
+                return (i,)
+        return None
+
+
+from .mul import Mul
+from .add import Add
+from .power import Pow
+from .function import Function, _derivative_dispatch
+from .mod import Mod
+from .exprtools import factor_terms
+from .numbers import Float, Integer, Rational, _illegal, int_valued
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/exprtools.py b/.venv/lib/python3.12/site-packages/sympy/core/exprtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..4868e4416a72e91dc12c9113d90b9c31c5e26011
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/exprtools.py
@@ -0,0 +1,1573 @@
+"""Tools for manipulating of large commutative expressions. """
+
+from __future__ import annotations
+
+from .add import Add
+from .mul import Mul, _keep_coeff
+from .power import Pow
+from .basic import Basic
+from .expr import Expr
+from .function import expand_power_exp
+from .sympify import sympify
+from .numbers import Rational, Integer, Number, I, equal_valued
+from .singleton import S
+from .sorting import default_sort_key, ordered
+from .symbol import Dummy
+from .traversal import preorder_traversal
+from .coreerrors import NonCommutativeExpression
+from .containers import Tuple, Dict
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.utilities.iterables import (common_prefix, common_suffix,
+        variations, iterable, is_sequence)
+
+from collections import defaultdict
+
+
+_eps = Dummy(positive=True)
+
+
+def _isnumber(i):
+    return isinstance(i, (SYMPY_INTS, float)) or i.is_Number
+
+
+def _monotonic_sign(self):
+    """Return the value closest to 0 that ``self`` may have if all symbols
+    are signed and the result is uniformly the same sign for all values of symbols.
+    If a symbol is only signed but not known to be an
+    integer or the result is 0 then a symbol representative of the sign of self
+    will be returned. Otherwise, None is returned if a) the sign could be positive
+    or negative or b) self is not in one of the following forms:
+
+    - L(x, y, ...) + A: a function linear in all symbols x, y, ... with an
+      additive constant; if A is zero then the function can be a monomial whose
+      sign is monotonic over the range of the variables, e.g. (x + 1)**3 if x is
+      nonnegative.
+    - A/L(x, y, ...) + B: the inverse of a function linear in all symbols x, y, ...
+      that does not have a sign change from positive to negative for any set
+      of values for the variables.
+    - M(x, y, ...) + A: a monomial M whose factors are all signed and a constant, A.
+    - A/M(x, y, ...) + B: the inverse of a monomial and constants A and B.
+    - P(x): a univariate polynomial
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import _monotonic_sign as F
+    >>> from sympy import Dummy
+    >>> nn = Dummy(integer=True, nonnegative=True)
+    >>> p = Dummy(integer=True, positive=True)
+    >>> p2 = Dummy(integer=True, positive=True)
+    >>> F(nn + 1)
+    1
+    >>> F(p - 1)
+    _nneg
+    >>> F(nn*p + 1)
+    1
+    >>> F(p2*p + 1)
+    2
+    >>> F(nn - 1)  # could be negative, zero or positive
+    """
+    if not self.is_extended_real:
+        return
+
+    if (-self).is_Symbol:
+        rv = _monotonic_sign(-self)
+        return rv if rv is None else -rv
+
+    if not self.is_Add and self.as_numer_denom()[1].is_number:
+        s = self
+        if s.is_prime:
+            if s.is_odd:
+                return Integer(3)
+            else:
+                return Integer(2)
+        elif s.is_composite:
+            if s.is_odd:
+                return Integer(9)
+            else:
+                return Integer(4)
+        elif s.is_positive:
+            if s.is_even:
+                if s.is_prime is False:
+                    return Integer(4)
+                else:
+                    return Integer(2)
+            elif s.is_integer:
+                return S.One
+            else:
+                return _eps
+        elif s.is_extended_negative:
+            if s.is_even:
+                return Integer(-2)
+            elif s.is_integer:
+                return S.NegativeOne
+            else:
+                return -_eps
+        if s.is_zero or s.is_extended_nonpositive or s.is_extended_nonnegative:
+            return S.Zero
+        return None
+
+    # univariate polynomial
+    free = self.free_symbols
+    if len(free) == 1:
+        if self.is_polynomial():
+            from sympy.polys.polytools import real_roots
+            from sympy.polys.polyroots import roots
+            from sympy.polys.polyerrors import PolynomialError
+            x = free.pop()
+            x0 = _monotonic_sign(x)
+            if x0 in (_eps, -_eps):
+                x0 = S.Zero
+            if x0 is not None:
+                d = self.diff(x)
+                if d.is_number:
+                    currentroots = []
+                else:
+                    try:
+                        currentroots = real_roots(d)
+                    except (PolynomialError, NotImplementedError):
+                        currentroots = [r for r in roots(d, x) if r.is_extended_real]
+                y = self.subs(x, x0)
+                if x.is_nonnegative and all(
+                        (r - x0).is_nonpositive for r in currentroots):
+                    if y.is_nonnegative and d.is_positive:
+                        if y:
+                            return y if y.is_positive else Dummy('pos', positive=True)
+                        else:
+                            return Dummy('nneg', nonnegative=True)
+                    if y.is_nonpositive and d.is_negative:
+                        if y:
+                            return y if y.is_negative else Dummy('neg', negative=True)
+                        else:
+                            return Dummy('npos', nonpositive=True)
+                elif x.is_nonpositive and all(
+                        (r - x0).is_nonnegative for r in currentroots):
+                    if y.is_nonnegative and d.is_negative:
+                        if y:
+                            return Dummy('pos', positive=True)
+                        else:
+                            return Dummy('nneg', nonnegative=True)
+                    if y.is_nonpositive and d.is_positive:
+                        if y:
+                            return Dummy('neg', negative=True)
+                        else:
+                            return Dummy('npos', nonpositive=True)
+        else:
+            n, d = self.as_numer_denom()
+            den = None
+            if n.is_number:
+                den = _monotonic_sign(d)
+            elif not d.is_number:
+                if _monotonic_sign(n) is not None:
+                    den = _monotonic_sign(d)
+            if den is not None and (den.is_positive or den.is_negative):
+                v = n*den
+                if v.is_positive:
+                    return Dummy('pos', positive=True)
+                elif v.is_nonnegative:
+                    return Dummy('nneg', nonnegative=True)
+                elif v.is_negative:
+                    return Dummy('neg', negative=True)
+                elif v.is_nonpositive:
+                    return Dummy('npos', nonpositive=True)
+        return None
+
+    # multivariate
+    c, a = self.as_coeff_Add()
+    v = None
+    if not a.is_polynomial():
+        # F/A or A/F where A is a number and F is a signed, rational monomial
+        n, d = a.as_numer_denom()
+        if not (n.is_number or d.is_number):
+            return
+        if (
+                a.is_Mul or a.is_Pow) and \
+                a.is_rational and \
+                all(p.exp.is_Integer for p in a.atoms(Pow) if p.is_Pow) and \
+                (a.is_positive or a.is_negative):
+            v = S.One
+            for ai in Mul.make_args(a):
+                if ai.is_number:
+                    v *= ai
+                    continue
+                reps = {}
+                for x in ai.free_symbols:
+                    reps[x] = _monotonic_sign(x)
+                    if reps[x] is None:
+                        return
+                v *= ai.subs(reps)
+    elif c:
+        # signed linear expression
+        if not any(p for p in a.atoms(Pow) if not p.is_number) and (a.is_nonpositive or a.is_nonnegative):
+            free = list(a.free_symbols)
+            p = {}
+            for i in free:
+                v = _monotonic_sign(i)
+                if v is None:
+                    return
+                p[i] = v or (_eps if i.is_nonnegative else -_eps)
+            v = a.xreplace(p)
+    if v is not None:
+        rv = v + c
+        if v.is_nonnegative and rv.is_positive:
+            return rv.subs(_eps, 0)
+        if v.is_nonpositive and rv.is_negative:
+            return rv.subs(_eps, 0)
+
+
+def decompose_power(expr: Expr) -> tuple[Expr, int]:
+    """
+    Decompose power into symbolic base and integer exponent.
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import decompose_power
+    >>> from sympy.abc import x, y
+    >>> from sympy import exp
+
+    >>> decompose_power(x)
+    (x, 1)
+    >>> decompose_power(x**2)
+    (x, 2)
+    >>> decompose_power(exp(2*y/3))
+    (exp(y/3), 2)
+
+    """
+    base, exp = expr.as_base_exp()
+
+    if exp.is_Number:
+        if exp.is_Rational:
+            if not exp.is_Integer:
+                base = Pow(base, Rational(1, exp.q))  # type: ignore
+            e = exp.p  # type: ignore
+        else:
+            base, e = expr, 1
+    else:
+        exp, tail = exp.as_coeff_Mul(rational=True)
+
+        if exp is S.NegativeOne:
+            base, e = Pow(base, tail), -1
+        elif exp is not S.One:
+            # todo: after dropping python 3.7 support, use overload and Literal
+            #  in as_coeff_Mul to make exp Rational, and remove these 2 ignores
+            tail = _keep_coeff(Rational(1, exp.q), tail)  # type: ignore
+            base, e = Pow(base, tail), exp.p  # type: ignore
+        else:
+            base, e = expr, 1
+
+    return base, e
+
+
+def decompose_power_rat(expr: Expr) -> tuple[Expr, Rational]:
+    """
+    Decompose power into symbolic base and rational exponent;
+    if the exponent is not a Rational, then separate only the
+    integer coefficient.
+
+    Examples
+    ========
+
+    >>> from sympy.core.exprtools import decompose_power_rat
+    >>> from sympy.abc import x
+    >>> from sympy import sqrt, exp
+
+    >>> decompose_power_rat(sqrt(x))
+    (x, 1/2)
+    >>> decompose_power_rat(exp(-3*x/2))
+    (exp(x/2), -3)
+
+    """
+    base, exp = expr.as_base_exp()
+    if not exp.is_Rational:
+        base, exp_i = decompose_power(expr)
+        exp = Integer(exp_i)
+    return base, exp # type: ignore
+
+
+class Factors:
+    """Efficient representation of ``f_1*f_2*...*f_n``."""
+
+    __slots__ = ('factors', 'gens')
+
+    def __init__(self, factors=None):  # Factors
+        """Initialize Factors from dict or expr.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x
+        >>> from sympy import I
+        >>> e = 2*x**3
+        >>> Factors(e)
+        Factors({2: 1, x: 3})
+        >>> Factors(e.as_powers_dict())
+        Factors({2: 1, x: 3})
+        >>> f = _
+        >>> f.factors  # underlying dictionary
+        {2: 1, x: 3}
+        >>> f.gens  # base of each factor
+        frozenset({2, x})
+        >>> Factors(0)
+        Factors({0: 1})
+        >>> Factors(I)
+        Factors({I: 1})
+
+        Notes
+        =====
+
+        Although a dictionary can be passed, only minimal checking is
+        performed: powers of -1 and I are made canonical.
+
+        """
+        if isinstance(factors, (SYMPY_INTS, float)):
+            factors = S(factors)
+        if isinstance(factors, Factors):
+            factors = factors.factors.copy()
+        elif factors in (None, S.One):
+            factors = {}
+        elif factors is S.Zero or factors == 0:
+            factors = {S.Zero: S.One}
+        elif isinstance(factors, Number):
+            n = factors
+            factors = {}
+            if n < 0:
+                factors[S.NegativeOne] = S.One
+                n = -n
+            if n is not S.One:
+                if n.is_Float or n.is_Integer or n is S.Infinity:
+                    factors[n] = S.One
+                elif n.is_Rational:
+                    # since we're processing Numbers, the denominator is
+                    # stored with a negative exponent; all other factors
+                    # are left .
+                    if n.p != 1:
+                        factors[Integer(n.p)] = S.One
+                    factors[Integer(n.q)] = S.NegativeOne
+                else:
+                    raise ValueError('Expected Float|Rational|Integer, not %s' % n)
+        elif isinstance(factors, Basic) and not factors.args:
+            factors = {factors: S.One}
+        elif isinstance(factors, Expr):
+            c, nc = factors.args_cnc()
+            i = c.count(I)
+            for _ in range(i):
+                c.remove(I)
+            factors = dict(Mul._from_args(c).as_powers_dict())
+            # Handle all rational Coefficients
+            for f in list(factors.keys()):
+                if isinstance(f, Rational) and not isinstance(f, Integer):
+                    p, q = Integer(f.p), Integer(f.q)
+                    factors[p] = (factors[p] if p in factors else S.Zero) + factors[f]
+                    factors[q] = (factors[q] if q in factors else S.Zero) - factors[f]
+                    factors.pop(f)
+            if i:
+                factors[I] = factors.get(I, S.Zero) + i
+            if nc:
+                factors[Mul(*nc, evaluate=False)] = S.One
+        else:
+            factors = factors.copy()  # /!\ should be dict-like
+
+            # tidy up -/+1 and I exponents if Rational
+
+            handle = [k for k in factors if k is I or k in (-1, 1)]
+            if handle:
+                i1 = S.One
+                for k in handle:
+                    if not _isnumber(factors[k]):
+                        continue
+                    i1 *= k**factors.pop(k)
+                if i1 is not S.One:
+                    for a in i1.args if i1.is_Mul else [i1]:  # at worst, -1.0*I*(-1)**e
+                        if a is S.NegativeOne:
+                            factors[a] = S.One
+                        elif a is I:
+                            factors[I] = S.One
+                        elif a.is_Pow:
+                            factors[a.base] = factors.get(a.base, S.Zero) + a.exp
+                        elif equal_valued(a, 1):
+                            factors[a] = S.One
+                        elif equal_valued(a, -1):
+                            factors[-a] = S.One
+                            factors[S.NegativeOne] = S.One
+                        else:
+                            raise ValueError('unexpected factor in i1: %s' % a)
+
+        self.factors = factors
+        keys = getattr(factors, 'keys', None)
+        if keys is None:
+            raise TypeError('expecting Expr or dictionary')
+        self.gens = frozenset(keys())
+
+    def __hash__(self):  # Factors
+        keys = tuple(ordered(self.factors.keys()))
+        values = [self.factors[k] for k in keys]
+        return hash((keys, values))
+
+    def __repr__(self):  # Factors
+        return "Factors({%s})" % ', '.join(
+            ['%s: %s' % (k, v) for k, v in ordered(self.factors.items())])
+
+    @property
+    def is_zero(self):  # Factors
+        """
+        >>> from sympy.core.exprtools import Factors
+        >>> Factors(0).is_zero
+        True
+        """
+        f = self.factors
+        return len(f) == 1 and S.Zero in f
+
+    @property
+    def is_one(self):  # Factors
+        """
+        >>> from sympy.core.exprtools import Factors
+        >>> Factors(1).is_one
+        True
+        """
+        return not self.factors
+
+    def as_expr(self):  # Factors
+        """Return the underlying expression.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y
+        >>> Factors((x*y**2).as_powers_dict()).as_expr()
+        x*y**2
+
+        """
+
+        args = []
+        for factor, exp in self.factors.items():
+            if exp != 1:
+                if isinstance(exp, Integer):
+                    b, e = factor.as_base_exp()
+                    e = _keep_coeff(exp, e)
+                    args.append(b**e)
+                else:
+                    args.append(factor**exp)
+            else:
+                args.append(factor)
+        return Mul(*args)
+
+    def mul(self, other):  # Factors
+        """Return Factors of ``self * other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.mul(b)
+        Factors({x: 2, y: 3, z: -1})
+        >>> a*b
+        Factors({x: 2, y: 3, z: -1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+        if any(f.is_zero for f in (self, other)):
+            return Factors(S.Zero)
+        factors = dict(self.factors)
+
+        for factor, exp in other.factors.items():
+            if factor in factors:
+                exp = factors[factor] + exp
+
+                if not exp:
+                    del factors[factor]
+                    continue
+
+            factors[factor] = exp
+
+        return Factors(factors)
+
+    def normal(self, other):
+        """Return ``self`` and ``other`` with ``gcd`` removed from each.
+        The only differences between this and method ``div`` is that this
+        is 1) optimized for the case when there are few factors in common and
+        2) this does not raise an error if ``other`` is zero.
+
+        See Also
+        ========
+        div
+
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                return (Factors(), Factors(S.Zero))
+            if self.is_zero:
+                return (Factors(S.Zero), Factors())
+
+        self_factors = dict(self.factors)
+        other_factors = dict(other.factors)
+
+        for factor, self_exp in self.factors.items():
+            try:
+                other_exp = other.factors[factor]
+            except KeyError:
+                continue
+
+            exp = self_exp - other_exp
+
+            if not exp:
+                del self_factors[factor]
+                del other_factors[factor]
+            elif _isnumber(exp):
+                if exp > 0:
+                    self_factors[factor] = exp
+                    del other_factors[factor]
+                else:
+                    del self_factors[factor]
+                    other_factors[factor] = -exp
+            else:
+                r = self_exp.extract_additively(other_exp)
+                if r is not None:
+                    if r:
+                        self_factors[factor] = r
+                        del other_factors[factor]
+                    else:  # should be handled already
+                        del self_factors[factor]
+                        del other_factors[factor]
+                else:
+                    sc, sa = self_exp.as_coeff_Add()
+                    if sc:
+                        oc, oa = other_exp.as_coeff_Add()
+                        diff = sc - oc
+                        if diff > 0:
+                            self_factors[factor] -= oc
+                            other_exp = oa
+                        elif diff < 0:
+                            self_factors[factor] -= sc
+                            other_factors[factor] -= sc
+                            other_exp = oa - diff
+                        else:
+                            self_factors[factor] = sa
+                            other_exp = oa
+                    if other_exp:
+                        other_factors[factor] = other_exp
+                    else:
+                        del other_factors[factor]
+
+        return Factors(self_factors), Factors(other_factors)
+
+    def div(self, other):  # Factors
+        """Return ``self`` and ``other`` with ``gcd`` removed from each.
+        This is optimized for the case when there are many factors in common.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> from sympy import S
+
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> a.div(a)
+        (Factors({}), Factors({}))
+        >>> a.div(x*z)
+        (Factors({y: 2}), Factors({z: 1}))
+
+        The ``/`` operator only gives ``quo``:
+
+        >>> a/x
+        Factors({y: 2})
+
+        Factors treats its factors as though they are all in the numerator, so
+        if you violate this assumption the results will be correct but will
+        not strictly correspond to the numerator and denominator of the ratio:
+
+        >>> a.div(x/z)
+        (Factors({y: 2}), Factors({z: -1}))
+
+        Factors is also naive about bases: it does not attempt any denesting
+        of Rational-base terms, for example the following does not become
+        2**(2*x)/2.
+
+        >>> Factors(2**(2*x + 2)).div(S(8))
+        (Factors({2: 2*x + 2}), Factors({8: 1}))
+
+        factor_terms can clean up such Rational-bases powers:
+
+        >>> from sympy import factor_terms
+        >>> n, d = Factors(2**(2*x + 2)).div(S(8))
+        >>> n.as_expr()/d.as_expr()
+        2**(2*x + 2)/8
+        >>> factor_terms(_)
+        2**(2*x)/2
+
+        """
+        quo, rem = dict(self.factors), {}
+
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                raise ZeroDivisionError
+            if self.is_zero:
+                return (Factors(S.Zero), Factors())
+
+        for factor, exp in other.factors.items():
+            if factor in quo:
+                d = quo[factor] - exp
+                if _isnumber(d):
+                    if d <= 0:
+                        del quo[factor]
+
+                    if d >= 0:
+                        if d:
+                            quo[factor] = d
+
+                        continue
+
+                    exp = -d
+
+                else:
+                    r = quo[factor].extract_additively(exp)
+                    if r is not None:
+                        if r:
+                            quo[factor] = r
+                        else:  # should be handled already
+                            del quo[factor]
+                    else:
+                        other_exp = exp
+                        sc, sa = quo[factor].as_coeff_Add()
+                        if sc:
+                            oc, oa = other_exp.as_coeff_Add()
+                            diff = sc - oc
+                            if diff > 0:
+                                quo[factor] -= oc
+                                other_exp = oa
+                            elif diff < 0:
+                                quo[factor] -= sc
+                                other_exp = oa - diff
+                            else:
+                                quo[factor] = sa
+                                other_exp = oa
+                        if other_exp:
+                            rem[factor] = other_exp
+                        else:
+                            assert factor not in rem
+                    continue
+
+            rem[factor] = exp
+
+        return Factors(quo), Factors(rem)
+
+    def quo(self, other):  # Factors
+        """Return numerator Factor of ``self / other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.quo(b)  # same as a/b
+        Factors({y: 1})
+        """
+        return self.div(other)[0]
+
+    def rem(self, other):  # Factors
+        """Return denominator Factors of ``self / other``.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.rem(b)
+        Factors({z: -1})
+        >>> a.rem(a)
+        Factors({})
+        """
+        return self.div(other)[1]
+
+    def pow(self, other):  # Factors
+        """Return self raised to a non-negative integer power.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> a**2
+        Factors({x: 2, y: 4})
+
+        """
+        if isinstance(other, Factors):
+            other = other.as_expr()
+            if other.is_Integer:
+                other = int(other)
+        if isinstance(other, SYMPY_INTS) and other >= 0:
+            factors = {}
+
+            if other:
+                for factor, exp in self.factors.items():
+                    factors[factor] = exp*other
+
+            return Factors(factors)
+        else:
+            raise ValueError("expected non-negative integer, got %s" % other)
+
+    def gcd(self, other):  # Factors
+        """Return Factors of ``gcd(self, other)``. The keys are
+        the intersection of factors with the minimum exponent for
+        each factor.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.gcd(b)
+        Factors({x: 1, y: 1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if other.is_zero:
+                return Factors(self.factors)
+
+        factors = {}
+
+        for factor, exp in self.factors.items():
+            factor, exp = sympify(factor), sympify(exp)
+            if factor in other.factors:
+                lt = (exp - other.factors[factor]).is_negative
+                if lt == True:
+                    factors[factor] = exp
+                elif lt == False:
+                    factors[factor] = other.factors[factor]
+
+        return Factors(factors)
+
+    def lcm(self, other):  # Factors
+        """Return Factors of ``lcm(self, other)`` which are
+        the union of factors with the maximum exponent for
+        each factor.
+
+        Examples
+        ========
+
+        >>> from sympy.core.exprtools import Factors
+        >>> from sympy.abc import x, y, z
+        >>> a = Factors((x*y**2).as_powers_dict())
+        >>> b = Factors((x*y/z).as_powers_dict())
+        >>> a.lcm(b)
+        Factors({x: 1, y: 2, z: -1})
+        """
+        if not isinstance(other, Factors):
+            other = Factors(other)
+            if any(f.is_zero for f in (self, other)):
+                return Factors(S.Zero)
+
+        factors = dict(self.factors)
+
+        for factor, exp in other.factors.items():
+            if factor in factors:
+                exp = max(exp, factors[factor])
+
+            factors[factor] = exp
+
+        return Factors(factors)
+
+    def __mul__(self, other):  # Factors
+        return self.mul(other)
+
+    def __divmod__(self, other):  # Factors
+        return self.div(other)
+
+    def __truediv__(self, other):  # Factors
+        return self.quo(other)
+
+    def __mod__(self, other):  # Factors
+        return self.rem(other)
+
+    def __pow__(self, other):  # Factors
+        return self.pow(other)
+
+    def __eq__(self, other):  # Factors
+        if not isinstance(other, Factors):
+            other = Factors(other)
+        return self.factors == other.factors
+
+    def __ne__(self, other):  # Factors
+        return not self == other
+
+
+class Term:
+    """Efficient representation of ``coeff*(numer/denom)``. """
+
+    __slots__ = ('coeff', 'numer', 'denom')
+
+    def __init__(self, term, numer=None, denom=None):  # Term
+        if numer is None and denom is None:
+            if not term.is_commutative:
+                raise NonCommutativeExpression(
+                    'commutative expression expected')
+
+            coeff, factors = term.as_coeff_mul()
+            numer, denom = defaultdict(int), defaultdict(int)
+
+            for factor in factors:
+                base, exp = decompose_power(factor)
+
+                if base.is_Add:
+                    cont, base = base.primitive()
+                    coeff *= cont**exp
+
+                if exp > 0:
+                    numer[base] += exp
+                else:
+                    denom[base] += -exp
+
+            numer = Factors(numer)
+            denom = Factors(denom)
+        else:
+            coeff = term
+
+            if numer is None:
+                numer = Factors()
+
+            if denom is None:
+                denom = Factors()
+
+        self.coeff = coeff
+        self.numer = numer
+        self.denom = denom
+
+    def __hash__(self):  # Term
+        return hash((self.coeff, self.numer, self.denom))
+
+    def __repr__(self):  # Term
+        return "Term(%s, %s, %s)" % (self.coeff, self.numer, self.denom)
+
+    def as_expr(self):  # Term
+        return self.coeff*(self.numer.as_expr()/self.denom.as_expr())
+
+    def mul(self, other):  # Term
+        coeff = self.coeff*other.coeff
+        numer = self.numer.mul(other.numer)
+        denom = self.denom.mul(other.denom)
+
+        numer, denom = numer.normal(denom)
+
+        return Term(coeff, numer, denom)
+
+    def inv(self):  # Term
+        return Term(1/self.coeff, self.denom, self.numer)
+
+    def quo(self, other):  # Term
+        return self.mul(other.inv())
+
+    def pow(self, other):  # Term
+        if other < 0:
+            return self.inv().pow(-other)
+        else:
+            return Term(self.coeff ** other,
+                        self.numer.pow(other),
+                        self.denom.pow(other))
+
+    def gcd(self, other):  # Term
+        return Term(self.coeff.gcd(other.coeff),
+                    self.numer.gcd(other.numer),
+                    self.denom.gcd(other.denom))
+
+    def lcm(self, other):  # Term
+        return Term(self.coeff.lcm(other.coeff),
+                    self.numer.lcm(other.numer),
+                    self.denom.lcm(other.denom))
+
+    def __mul__(self, other):  # Term
+        if isinstance(other, Term):
+            return self.mul(other)
+        else:
+            return NotImplemented
+
+    def __truediv__(self, other):  # Term
+        if isinstance(other, Term):
+            return self.quo(other)
+        else:
+            return NotImplemented
+
+    def __pow__(self, other):  # Term
+        if isinstance(other, SYMPY_INTS):
+            return self.pow(other)
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):  # Term
+        return (self.coeff == other.coeff and
+                self.numer == other.numer and
+                self.denom == other.denom)
+
+    def __ne__(self, other):  # Term
+        return not self == other
+
+
+def _gcd_terms(terms, isprimitive=False, fraction=True):
+    """Helper function for :func:`gcd_terms`.
+
+    Parameters
+    ==========
+
+    isprimitive : boolean, optional
+        If ``isprimitive`` is True then the call to primitive
+        for an Add will be skipped. This is useful when the
+        content has already been extracted.
+
+    fraction : boolean, optional
+        If ``fraction`` is True then the expression will appear over a common
+        denominator, the lcm of all term denominators.
+    """
+
+    if isinstance(terms, Basic) and not isinstance(terms, Tuple):
+        terms = Add.make_args(terms)
+
+    terms = list(map(Term, [t for t in terms if t]))
+
+    # there is some simplification that may happen if we leave this
+    # here rather than duplicate it before the mapping of Term onto
+    # the terms
+    if len(terms) == 0:
+        return S.Zero, S.Zero, S.One
+
+    if len(terms) == 1:
+        cont = terms[0].coeff
+        numer = terms[0].numer.as_expr()
+        denom = terms[0].denom.as_expr()
+
+    else:
+        cont = terms[0]
+        for term in terms[1:]:
+            cont = cont.gcd(term)
+
+        for i, term in enumerate(terms):
+            terms[i] = term.quo(cont)
+
+        if fraction:
+            denom = terms[0].denom
+
+            for term in terms[1:]:
+                denom = denom.lcm(term.denom)
+
+            numers = []
+            for term in terms:
+                numer = term.numer.mul(denom.quo(term.denom))
+                numers.append(term.coeff*numer.as_expr())
+        else:
+            numers = [t.as_expr() for t in terms]
+            denom = Term(S.One).numer
+
+        cont = cont.as_expr()
+        numer = Add(*numers)
+        denom = denom.as_expr()
+
+    if not isprimitive and numer.is_Add:
+        _cont, numer = numer.primitive()
+        cont *= _cont
+
+    return cont, numer, denom
+
+
+def gcd_terms(terms, isprimitive=False, clear=True, fraction=True):
+    """Compute the GCD of ``terms`` and put them together.
+
+    Parameters
+    ==========
+
+    terms : Expr
+        Can be an expression or a non-Basic sequence of expressions
+        which will be handled as though they are terms from a sum.
+
+    isprimitive : bool, optional
+        If ``isprimitive`` is True the _gcd_terms will not run the primitive
+        method on the terms.
+
+    clear : bool, optional
+        It controls the removal of integers from the denominator of an Add
+        expression. When True (default), all numerical denominator will be cleared;
+        when False the denominators will be cleared only if all terms had numerical
+        denominators other than 1.
+
+    fraction : bool, optional
+        When True (default), will put the expression over a common
+        denominator.
+
+    Examples
+    ========
+
+    >>> from sympy import gcd_terms
+    >>> from sympy.abc import x, y
+
+    >>> gcd_terms((x + 1)**2*y + (x + 1)*y**2)
+    y*(x + 1)*(x + y + 1)
+    >>> gcd_terms(x/2 + 1)
+    (x + 2)/2
+    >>> gcd_terms(x/2 + 1, clear=False)
+    x/2 + 1
+    >>> gcd_terms(x/2 + y/2, clear=False)
+    (x + y)/2
+    >>> gcd_terms(x/2 + 1/x)
+    (x**2 + 2)/(2*x)
+    >>> gcd_terms(x/2 + 1/x, fraction=False)
+    (x + 2/x)/2
+    >>> gcd_terms(x/2 + 1/x, fraction=False, clear=False)
+    x/2 + 1/x
+
+    >>> gcd_terms(x/2/y + 1/x/y)
+    (x**2 + 2)/(2*x*y)
+    >>> gcd_terms(x/2/y + 1/x/y, clear=False)
+    (x**2/2 + 1)/(x*y)
+    >>> gcd_terms(x/2/y + 1/x/y, clear=False, fraction=False)
+    (x/2 + 1/x)/y
+
+    The ``clear`` flag was ignored in this case because the returned
+    expression was a rational expression, not a simple sum.
+
+    See Also
+    ========
+
+    factor_terms, sympy.polys.polytools.terms_gcd
+
+    """
+    def mask(terms):
+        """replace nc portions of each term with a unique Dummy symbols
+        and return the replacements to restore them"""
+        args = [(a, []) if a.is_commutative else a.args_cnc() for a in terms]
+        reps = []
+        for i, (c, nc) in enumerate(args):
+            if nc:
+                nc = Mul(*nc)
+                d = Dummy()
+                reps.append((d, nc))
+                c.append(d)
+                args[i] = Mul(*c)
+            else:
+                args[i] = c
+        return args, dict(reps)
+
+    isadd = isinstance(terms, Add)
+    addlike = isadd or not isinstance(terms, Basic) and \
+        is_sequence(terms, include=set) and \
+        not isinstance(terms, Dict)
+
+    if addlike:
+        if isadd:  # i.e. an Add
+            terms = list(terms.args)
+        else:
+            terms = sympify(terms)
+        terms, reps = mask(terms)
+        cont, numer, denom = _gcd_terms(terms, isprimitive, fraction)
+        numer = numer.xreplace(reps)
+        coeff, factors = cont.as_coeff_Mul()
+        if not clear:
+            c, _coeff = coeff.as_coeff_Mul()
+            if not c.is_Integer and not clear and numer.is_Add:
+                n, d = c.as_numer_denom()
+                _numer = numer/d
+                if any(a.as_coeff_Mul()[0].is_Integer
+                        for a in _numer.args):
+                    numer = _numer
+                    coeff = n*_coeff
+        return _keep_coeff(coeff, factors*numer/denom, clear=clear)
+
+    if not isinstance(terms, Basic):
+        return terms
+
+    if terms.is_Atom:
+        return terms
+
+    if terms.is_Mul:
+        c, args = terms.as_coeff_mul()
+        return _keep_coeff(c, Mul(*[gcd_terms(i, isprimitive, clear, fraction)
+            for i in args]), clear=clear)
+
+    def handle(a):
+        # don't treat internal args like terms of an Add
+        if not isinstance(a, Expr):
+            if isinstance(a, Basic):
+                if not a.args:
+                    return a
+                return a.func(*[handle(i) for i in a.args])
+            return type(a)([handle(i) for i in a])
+        return gcd_terms(a, isprimitive, clear, fraction)
+
+    if isinstance(terms, Dict):
+        return Dict(*[(k, handle(v)) for k, v in terms.args])
+    return terms.func(*[handle(i) for i in terms.args])
+
+
+def _factor_sum_int(expr, **kwargs):
+    """Return Sum or Integral object with factors that are not
+    in the wrt variables removed. In cases where there are additive
+    terms in the function of the object that are independent, the
+    object will be separated into two objects.
+
+    Examples
+    ========
+
+    >>> from sympy import Sum, factor_terms
+    >>> from sympy.abc import x, y
+    >>> factor_terms(Sum(x + y, (x, 1, 3)))
+    y*Sum(1, (x, 1, 3)) + Sum(x, (x, 1, 3))
+    >>> factor_terms(Sum(x*y, (x, 1, 3)))
+    y*Sum(x, (x, 1, 3))
+
+    Notes
+    =====
+
+    If a function in the summand or integrand is replaced
+    with a symbol, then this simplification should not be
+    done or else an incorrect result will be obtained when
+    the symbol is replaced with an expression that depends
+    on the variables of summation/integration:
+
+    >>> eq = Sum(y, (x, 1, 3))
+    >>> factor_terms(eq).subs(y, x).doit()
+    3*x
+    >>> eq.subs(y, x).doit()
+    6
+    """
+    result = expr.function
+    if result == 0:
+        return S.Zero
+    limits = expr.limits
+
+    # get the wrt variables
+    wrt = {i.args[0] for i in limits}
+
+    # factor out any common terms that are independent of wrt
+    f = factor_terms(result, **kwargs)
+    i, d = f.as_independent(*wrt)
+    if isinstance(f, Add):
+        return i * expr.func(1, *limits) + expr.func(d, *limits)
+    else:
+        return i * expr.func(d, *limits)
+
+
+def factor_terms(expr: Expr | complex, radical=False, clear=False, fraction=False, sign=True) -> Expr:
+    """Remove common factors from terms in all arguments without
+    changing the underlying structure of the expr. No expansion or
+    simplification (and no processing of non-commutatives) is performed.
+
+    Parameters
+    ==========
+
+    radical: bool, optional
+        If radical=True then a radical common to all terms will be factored
+        out of any Add sub-expressions of the expr.
+
+    clear : bool, optional
+        If clear=False (default) then coefficients will not be separated
+        from a single Add if they can be distributed to leave one or more
+        terms with integer coefficients.
+
+    fraction : bool, optional
+        If fraction=True (default is False) then a common denominator will be
+        constructed for the expression.
+
+    sign : bool, optional
+        If sign=True (default) then even if the only factor in common is a -1,
+        it will be factored out of the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import factor_terms, Symbol
+    >>> from sympy.abc import x, y
+    >>> factor_terms(x + x*(2 + 4*y)**3)
+    x*(8*(2*y + 1)**3 + 1)
+    >>> A = Symbol('A', commutative=False)
+    >>> factor_terms(x*A + x*A + x*y*A)
+    x*(y*A + 2*A)
+
+    When ``clear`` is False, a rational will only be factored out of an
+    Add expression if all terms of the Add have coefficients that are
+    fractions:
+
+    >>> factor_terms(x/2 + 1, clear=False)
+    x/2 + 1
+    >>> factor_terms(x/2 + 1, clear=True)
+    (x + 2)/2
+
+    If a -1 is all that can be factored out, to *not* factor it out, the
+    flag ``sign`` must be False:
+
+    >>> factor_terms(-x - y)
+    -(x + y)
+    >>> factor_terms(-x - y, sign=False)
+    -x - y
+    >>> factor_terms(-2*x - 2*y, sign=False)
+    -2*(x + y)
+
+    See Also
+    ========
+
+    gcd_terms, sympy.polys.polytools.terms_gcd
+
+    """
+    def do(expr):
+        from sympy.concrete.summations import Sum
+        from sympy.integrals.integrals import Integral
+        is_iterable = iterable(expr)
+
+        if not isinstance(expr, Basic) or expr.is_Atom:
+            if is_iterable:
+                return type(expr)([do(i) for i in expr])
+            return expr
+
+        if expr.is_Pow or expr.is_Function or \
+                is_iterable or not hasattr(expr, 'args_cnc'):
+            args = expr.args
+            newargs = tuple([do(i) for i in args])
+            if newargs == args:
+                return expr
+            return expr.func(*newargs)
+
+        if isinstance(expr, (Sum, Integral)):
+            return _factor_sum_int(expr,
+                radical=radical, clear=clear,
+                fraction=fraction, sign=sign)
+
+        cont, p = expr.as_content_primitive(radical=radical, clear=clear)
+        if p.is_Add:
+            list_args = [do(a) for a in Add.make_args(p)]
+            # get a common negative (if there) which gcd_terms does not remove
+            if not any(a.as_coeff_Mul()[0].extract_multiplicatively(-1) is None
+                       for a in list_args):
+                cont = -cont
+                list_args = [-a for a in list_args]
+            # watch out for exp(-(x+2)) which gcd_terms will change to exp(-x-2)
+            special = {}
+            for i, a in enumerate(list_args):
+                b, e = a.as_base_exp()
+                if e.is_Mul and e != Mul(*e.args):
+                    list_args[i] = Dummy()
+                    special[list_args[i]] = a
+            # rebuild p not worrying about the order which gcd_terms will fix
+            p = Add._from_args(list_args)
+            p = gcd_terms(p,
+                isprimitive=True,
+                clear=clear,
+                fraction=fraction).xreplace(special)
+        elif p.args:
+            p = p.func(
+                *[do(a) for a in p.args])
+        rv = _keep_coeff(cont, p, clear=clear, sign=sign)
+        return rv
+    expr2 = sympify(expr)
+    return do(expr2)
+
+
+def _mask_nc(eq, name=None):
+    """
+    Return ``eq`` with non-commutative objects replaced with Dummy
+    symbols. A dictionary that can be used to restore the original
+    values is returned: if it is None, the expression is noncommutative
+    and cannot be made commutative. The third value returned is a list
+    of any non-commutative symbols that appear in the returned equation.
+
+    Explanation
+    ===========
+
+    All non-commutative objects other than Symbols are replaced with
+    a non-commutative Symbol. Identical objects will be identified
+    by identical symbols.
+
+    If there is only 1 non-commutative object in an expression it will
+    be replaced with a commutative symbol. Otherwise, the non-commutative
+    entities are retained and the calling routine should handle
+    replacements in this case since some care must be taken to keep
+    track of the ordering of symbols when they occur within Muls.
+
+    Parameters
+    ==========
+
+    name : str
+        ``name``, if given, is the name that will be used with numbered Dummy
+        variables that will replace the non-commutative objects and is mainly
+        used for doctesting purposes.
+
+    Examples
+    ========
+
+    >>> from sympy.physics.secondquant import Commutator, NO, F, Fd
+    >>> from sympy import symbols
+    >>> from sympy.core.exprtools import _mask_nc
+    >>> from sympy.abc import x, y
+    >>> A, B, C = symbols('A,B,C', commutative=False)
+
+    One nc-symbol:
+
+    >>> _mask_nc(A**2 - x**2, 'd')
+    (_d0**2 - x**2, {_d0: A}, [])
+
+    Multiple nc-symbols:
+
+    >>> _mask_nc(A**2 - B**2, 'd')
+    (A**2 - B**2, {}, [A, B])
+
+    An nc-object with nc-symbols but no others outside of it:
+
+    >>> _mask_nc(1 + x*Commutator(A, B), 'd')
+    (_d0*x + 1, {_d0: Commutator(A, B)}, [])
+    >>> _mask_nc(NO(Fd(x)*F(y)), 'd')
+    (_d0, {_d0: NO(CreateFermion(x)*AnnihilateFermion(y))}, [])
+
+    Multiple nc-objects:
+
+    >>> eq = x*Commutator(A, B) + x*Commutator(A, C)*Commutator(A, B)
+    >>> _mask_nc(eq, 'd')
+    (x*_d0 + x*_d1*_d0, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1])
+
+    Multiple nc-objects and nc-symbols:
+
+    >>> eq = A*Commutator(A, B) + B*Commutator(A, C)
+    >>> _mask_nc(eq, 'd')
+    (A*_d0 + B*_d1, {_d0: Commutator(A, B), _d1: Commutator(A, C)}, [_d0, _d1, A, B])
+
+    """
+    name = name or 'mask'
+    # Make Dummy() append sequential numbers to the name
+
+    def numbered_names():
+        i = 0
+        while True:
+            yield name + str(i)
+            i += 1
+
+    names = numbered_names()
+
+    def Dummy(*args, **kwargs):
+        from .symbol import Dummy
+        return Dummy(next(names), *args, **kwargs)
+
+    expr = eq
+    if expr.is_commutative:
+        return eq, {}, []
+
+    # identify nc-objects; symbols and other
+    rep = []
+    nc_obj = set()
+    nc_syms = set()
+    pot = preorder_traversal(expr, keys=default_sort_key)
+    for a in pot:
+        if any(a == r[0] for r in rep):
+            pot.skip()
+        elif not a.is_commutative:
+            if a.is_symbol:
+                nc_syms.add(a)
+                pot.skip()
+            elif not (a.is_Add or a.is_Mul or a.is_Pow):
+                nc_obj.add(a)
+                pot.skip()
+
+    # If there is only one nc symbol or object, it can be factored regularly
+    # but polys is going to complain, so replace it with a Dummy.
+    if len(nc_obj) == 1 and not nc_syms:
+        rep.append((nc_obj.pop(), Dummy()))
+    elif len(nc_syms) == 1 and not nc_obj:
+        rep.append((nc_syms.pop(), Dummy()))
+
+    # Any remaining nc-objects will be replaced with an nc-Dummy and
+    # identified as an nc-Symbol to watch out for
+    nc_obj = sorted(nc_obj, key=default_sort_key)
+    for n in nc_obj:
+        nc = Dummy(commutative=False)
+        rep.append((n, nc))
+        nc_syms.add(nc)
+    expr = expr.subs(rep)
+
+    nc_syms = list(nc_syms)
+    nc_syms.sort(key=default_sort_key)
+    return expr, {v: k for k, v in rep}, nc_syms
+
+
+def factor_nc(expr):
+    """Return the factored form of ``expr`` while handling non-commutative
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy import factor_nc, Symbol
+    >>> from sympy.abc import x
+    >>> A = Symbol('A', commutative=False)
+    >>> B = Symbol('B', commutative=False)
+    >>> factor_nc((x**2 + 2*A*x + A**2).expand())
+    (x + A)**2
+    >>> factor_nc(((x + A)*(x + B)).expand())
+    (x + A)*(x + B)
+    """
+    expr = sympify(expr)
+    if not isinstance(expr, Expr) or not expr.args:
+        return expr
+    if not expr.is_Add:
+        return expr.func(*[factor_nc(a) for a in expr.args])
+    expr = expr.func(*[expand_power_exp(i) for i in expr.args])
+
+    from sympy.polys.polytools import gcd, factor
+    expr, rep, nc_symbols = _mask_nc(expr)
+
+    if rep:
+        return factor(expr).subs(rep)
+    else:
+        args = [a.args_cnc() for a in Add.make_args(expr)]
+        c = g = l = r = S.One
+        hit = False
+        # find any commutative gcd term
+        for i, a in enumerate(args):
+            if i == 0:
+                c = Mul._from_args(a[0])
+            elif a[0]:
+                c = gcd(c, Mul._from_args(a[0]))
+            else:
+                c = S.One
+        if c is not S.One:
+            hit = True
+            c, g = c.as_coeff_Mul()
+            if g is not S.One:
+                for i, (cc, _) in enumerate(args):
+                    cc = list(Mul.make_args(Mul._from_args(list(cc))/g))
+                    args[i][0] = cc
+            for i, (cc, _) in enumerate(args):
+                if cc:
+                    cc[0] = cc[0]/c
+                else:
+                    cc = [1/c]
+                args[i][0] = cc
+        # find any noncommutative common prefix
+        for i, a in enumerate(args):
+            if i == 0:
+                n = a[1][:]
+            else:
+                n = common_prefix(n, a[1])
+            if not n:
+                # is there a power that can be extracted?
+                if not args[0][1]:
+                    break
+                b, e = args[0][1][0].as_base_exp()
+                ok = False
+                if e.is_Integer:
+                    for t in args:
+                        if not t[1]:
+                            break
+                        bt, et = t[1][0].as_base_exp()
+                        if et.is_Integer and bt == b:
+                            e = min(e, et)
+                        else:
+                            break
+                    else:
+                        ok = hit = True
+                        l = b**e
+                        il = b**-e
+                        for _ in args:
+                            _[1][0] = il*_[1][0]
+                        break
+                if not ok:
+                    break
+        else:
+            hit = True
+            lenn = len(n)
+            l = Mul(*n)
+            for _ in args:
+                _[1] = _[1][lenn:]
+        # find any noncommutative common suffix
+        for i, a in enumerate(args):
+            if i == 0:
+                n = a[1][:]
+            else:
+                n = common_suffix(n, a[1])
+            if not n:
+                # is there a power that can be extracted?
+                if not args[0][1]:
+                    break
+                b, e = args[0][1][-1].as_base_exp()
+                ok = False
+                if e.is_Integer:
+                    for t in args:
+                        if not t[1]:
+                            break
+                        bt, et = t[1][-1].as_base_exp()
+                        if et.is_Integer and bt == b:
+                            e = min(e, et)
+                        else:
+                            break
+                    else:
+                        ok = hit = True
+                        r = b**e
+                        il = b**-e
+                        for _ in args:
+                            _[1][-1] = _[1][-1]*il
+                        break
+                if not ok:
+                    break
+        else:
+            hit = True
+            lenn = len(n)
+            r = Mul(*n)
+            for _ in args:
+                _[1] = _[1][:len(_[1]) - lenn]
+        if hit:
+            mid = Add(*[Mul(*cc)*Mul(*nc) for cc, nc in args])
+        else:
+            mid = expr
+
+        from sympy.simplify.powsimp import powsimp
+
+        # sort the symbols so the Dummys would appear in the same
+        # order as the original symbols, otherwise you may introduce
+        # a factor of -1, e.g. A**2 - B**2) -- {A:y, B:x} --> y**2 - x**2
+        # and the former factors into two terms, (A - B)*(A + B) while the
+        # latter factors into 3 terms, (-1)*(x - y)*(x + y)
+        rep1 = [(n, Dummy()) for n in sorted(nc_symbols, key=default_sort_key)]
+        unrep1 = [(v, k) for k, v in rep1]
+        unrep1.reverse()
+        new_mid, r2, _ = _mask_nc(mid.subs(rep1))
+        new_mid = powsimp(factor(new_mid))
+
+        new_mid = new_mid.subs(r2).subs(unrep1)
+
+        if new_mid.is_Pow:
+            return _keep_coeff(c, g*l*new_mid*r)
+
+        if new_mid.is_Mul:
+            def _pemexpand(expr):
+                "Expand with the minimal set of hints necessary to check the result."
+                return expr.expand(deep=True, mul=True, power_exp=True,
+                    power_base=False, basic=False, multinomial=True, log=False)
+            # XXX TODO there should be a way to inspect what order the terms
+            # must be in and just select the plausible ordering without
+            # checking permutations
+            cfac = []
+            ncfac = []
+            for f in new_mid.args:
+                if f.is_commutative:
+                    cfac.append(f)
+                else:
+                    b, e = f.as_base_exp()
+                    if e.is_Integer:
+                        ncfac.extend([b]*e)
+                    else:
+                        ncfac.append(f)
+            pre_mid = g*Mul(*cfac)*l
+            target = _pemexpand(expr/c)
+            for s in variations(ncfac, len(ncfac)):
+                ok = pre_mid*Mul(*s)*r
+                if _pemexpand(ok) == target:
+                    return _keep_coeff(c, ok)
+
+        # mid was an Add that didn't factor successfully
+        return _keep_coeff(c, g*l*mid*r)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/facts.py b/.venv/lib/python3.12/site-packages/sympy/core/facts.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b98d9b14bbac661d3c0fd1d1fd87977a792fb74
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/facts.py
@@ -0,0 +1,634 @@
+r"""This is rule-based deduction system for SymPy
+
+The whole thing is split into two parts
+
+ - rules compilation and preparation of tables
+ - runtime inference
+
+For rule-based inference engines, the classical work is RETE algorithm [1],
+[2] Although we are not implementing it in full (or even significantly)
+it's still worth a read to understand the underlying ideas.
+
+In short, every rule in a system of rules is one of two forms:
+
+ - atom                     -> ...      (alpha rule)
+ - And(atom1, atom2, ...)   -> ...      (beta rule)
+
+
+The major complexity is in efficient beta-rules processing and usually for an
+expert system a lot of effort goes into code that operates on beta-rules.
+
+
+Here we take minimalistic approach to get something usable first.
+
+ - (preparation)    of alpha- and beta- networks, everything except
+ - (runtime)        FactRules.deduce_all_facts
+
+             _____________________________________
+            ( Kirr: I've never thought that doing )
+            ( logic stuff is that difficult...    )
+             -------------------------------------
+                    o   ^__^
+                     o  (oo)\_______
+                        (__)\       )\/\
+                            ||----w |
+                            ||     ||
+
+
+Some references on the topic
+----------------------------
+
+[1] https://en.wikipedia.org/wiki/Rete_algorithm
+[2] http://reports-archive.adm.cs.cmu.edu/anon/1995/CMU-CS-95-113.pdf
+
+https://en.wikipedia.org/wiki/Propositional_formula
+https://en.wikipedia.org/wiki/Inference_rule
+https://en.wikipedia.org/wiki/List_of_rules_of_inference
+"""
+
+from collections import defaultdict
+from typing import Iterator
+
+from .logic import Logic, And, Or, Not
+
+
+def _base_fact(atom):
+    """Return the literal fact of an atom.
+
+    Effectively, this merely strips the Not around a fact.
+    """
+    if isinstance(atom, Not):
+        return atom.arg
+    else:
+        return atom
+
+
+def _as_pair(atom):
+    if isinstance(atom, Not):
+        return (atom.arg, False)
+    else:
+        return (atom, True)
+
+# XXX this prepares forward-chaining rules for alpha-network
+
+
+def transitive_closure(implications):
+    """
+    Computes the transitive closure of a list of implications
+
+    Uses Warshall's algorithm, as described at
+    http://www.cs.hope.edu/~cusack/Notes/Notes/DiscreteMath/Warshall.pdf.
+    """
+    full_implications = set(implications)
+    literals = set().union(*map(set, full_implications))
+
+    for k in literals:
+        for i in literals:
+            if (i, k) in full_implications:
+                for j in literals:
+                    if (k, j) in full_implications:
+                        full_implications.add((i, j))
+
+    return full_implications
+
+
+def deduce_alpha_implications(implications):
+    """deduce all implications
+
+       Description by example
+       ----------------------
+
+       given set of logic rules:
+
+         a -> b
+         b -> c
+
+       we deduce all possible rules:
+
+         a -> b, c
+         b -> c
+
+
+       implications: [] of (a,b)
+       return:       {} of a -> set([b, c, ...])
+    """
+    implications = implications + [(Not(j), Not(i)) for (i, j) in implications]
+    res = defaultdict(set)
+    full_implications = transitive_closure(implications)
+    for a, b in full_implications:
+        if a == b:
+            continue    # skip a->a cyclic input
+
+        res[a].add(b)
+
+    # Clean up tautologies and check consistency
+    for a, impl in res.items():
+        impl.discard(a)
+        na = Not(a)
+        if na in impl:
+            raise ValueError(
+                'implications are inconsistent: %s -> %s %s' % (a, na, impl))
+
+    return res
+
+
+def apply_beta_to_alpha_route(alpha_implications, beta_rules):
+    """apply additional beta-rules (And conditions) to already-built
+    alpha implication tables
+
+       TODO: write about
+
+       - static extension of alpha-chains
+       - attaching refs to beta-nodes to alpha chains
+
+
+       e.g.
+
+       alpha_implications:
+
+       a  ->  [b, !c, d]
+       b  ->  [d]
+       ...
+
+
+       beta_rules:
+
+       &(b,d) -> e
+
+
+       then we'll extend a's rule to the following
+
+       a  ->  [b, !c, d, e]
+    """
+    x_impl = {}
+    for x in alpha_implications.keys():
+        x_impl[x] = (set(alpha_implications[x]), [])
+    for bcond, bimpl in beta_rules:
+        for bk in bcond.args:
+            if bk in x_impl:
+                continue
+            x_impl[bk] = (set(), [])
+
+    # static extensions to alpha rules:
+    # A: x -> a,b   B: &(a,b) -> c  ==>  A: x -> a,b,c
+    seen_static_extension = True
+    while seen_static_extension:
+        seen_static_extension = False
+
+        for bcond, bimpl in beta_rules:
+            if not isinstance(bcond, And):
+                raise TypeError("Cond is not And")
+            bargs = set(bcond.args)
+            for x, (ximpls, bb) in x_impl.items():
+                x_all = ximpls | {x}
+                # A: ... -> a   B: &(...) -> a  is non-informative
+                if bimpl not in x_all and bargs.issubset(x_all):
+                    ximpls.add(bimpl)
+
+                    # we introduced new implication - now we have to restore
+                    # completeness of the whole set.
+                    bimpl_impl = x_impl.get(bimpl)
+                    if bimpl_impl is not None:
+                        ximpls |= bimpl_impl[0]
+                    seen_static_extension = True
+
+    # attach beta-nodes which can be possibly triggered by an alpha-chain
+    for bidx, (bcond, bimpl) in enumerate(beta_rules):
+        bargs = set(bcond.args)
+        for x, (ximpls, bb) in x_impl.items():
+            x_all = ximpls | {x}
+            # A: ... -> a   B: &(...) -> a      (non-informative)
+            if bimpl in x_all:
+                continue
+            # A: x -> a...  B: &(!a,...) -> ... (will never trigger)
+            # A: x -> a...  B: &(...) -> !a     (will never trigger)
+            if any(Not(xi) in bargs or Not(xi) == bimpl for xi in x_all):
+                continue
+
+            if bargs & x_all:
+                bb.append(bidx)
+
+    return x_impl
+
+
+def rules_2prereq(rules):
+    """build prerequisites table from rules
+
+       Description by example
+       ----------------------
+
+       given set of logic rules:
+
+         a -> b, c
+         b -> c
+
+       we build prerequisites (from what points something can be deduced):
+
+         b <- a
+         c <- a, b
+
+       rules:   {} of a -> [b, c, ...]
+       return:  {} of c <- [a, b, ...]
+
+       Note however, that this prerequisites may be *not* enough to prove a
+       fact. An example is 'a -> b' rule, where prereq(a) is b, and prereq(b)
+       is a. That's because a=T -> b=T, and b=F -> a=F, but a=F -> b=?
+    """
+    prereq = defaultdict(set)
+    for (a, _), impl in rules.items():
+        if isinstance(a, Not):
+            a = a.args[0]
+        for (i, _) in impl:
+            if isinstance(i, Not):
+                i = i.args[0]
+            prereq[i].add(a)
+    return prereq
+
+################
+# RULES PROVER #
+################
+
+
+class TautologyDetected(Exception):
+    """(internal) Prover uses it for reporting detected tautology"""
+    pass
+
+
+class Prover:
+    """ai - prover of logic rules
+
+       given a set of initial rules, Prover tries to prove all possible rules
+       which follow from given premises.
+
+       As a result proved_rules are always either in one of two forms: alpha or
+       beta:
+
+       Alpha rules
+       -----------
+
+       This are rules of the form::
+
+         a -> b & c & d & ...
+
+
+       Beta rules
+       ----------
+
+       This are rules of the form::
+
+         &(a,b,...) -> c & d & ...
+
+
+       i.e. beta rules are join conditions that say that something follows when
+       *several* facts are true at the same time.
+    """
+
+    def __init__(self):
+        self.proved_rules = []
+        self._rules_seen = set()
+
+    def split_alpha_beta(self):
+        """split proved rules into alpha and beta chains"""
+        rules_alpha = []    # a      -> b
+        rules_beta = []     # &(...) -> b
+        for a, b in self.proved_rules:
+            if isinstance(a, And):
+                rules_beta.append((a, b))
+            else:
+                rules_alpha.append((a, b))
+        return rules_alpha, rules_beta
+
+    @property
+    def rules_alpha(self):
+        return self.split_alpha_beta()[0]
+
+    @property
+    def rules_beta(self):
+        return self.split_alpha_beta()[1]
+
+    def process_rule(self, a, b):
+        """process a -> b rule"""   # TODO write more?
+        if (not a) or isinstance(b, bool):
+            return
+        if isinstance(a, bool):
+            return
+        if (a, b) in self._rules_seen:
+            return
+        else:
+            self._rules_seen.add((a, b))
+
+        # this is the core of processing
+        try:
+            self._process_rule(a, b)
+        except TautologyDetected:
+            pass
+
+    def _process_rule(self, a, b):
+        # right part first
+
+        # a -> b & c    -->  a -> b  ;  a -> c
+        # (?) FIXME this is only correct when b & c != null !
+
+        if isinstance(b, And):
+            sorted_bargs = sorted(b.args, key=str)
+            for barg in sorted_bargs:
+                self.process_rule(a, barg)
+
+        # a -> b | c    -->  !b & !c -> !a
+        #               -->   a & !b -> c
+        #               -->   a & !c -> b
+        elif isinstance(b, Or):
+            sorted_bargs = sorted(b.args, key=str)
+            # detect tautology first
+            if not isinstance(a, Logic):    # Atom
+                # tautology:  a -> a|c|...
+                if a in sorted_bargs:
+                    raise TautologyDetected(a, b, 'a -> a|c|...')
+            self.process_rule(And(*[Not(barg) for barg in b.args]), Not(a))
+
+            for bidx in range(len(sorted_bargs)):
+                barg = sorted_bargs[bidx]
+                brest = sorted_bargs[:bidx] + sorted_bargs[bidx + 1:]
+                self.process_rule(And(a, Not(barg)), Or(*brest))
+
+        # left part
+
+        # a & b -> c    -->  IRREDUCIBLE CASE -- WE STORE IT AS IS
+        #                    (this will be the basis of beta-network)
+        elif isinstance(a, And):
+            sorted_aargs = sorted(a.args, key=str)
+            if b in sorted_aargs:
+                raise TautologyDetected(a, b, 'a & b -> a')
+            self.proved_rules.append((a, b))
+            # XXX NOTE at present we ignore  !c -> !a | !b
+
+        elif isinstance(a, Or):
+            sorted_aargs = sorted(a.args, key=str)
+            if b in sorted_aargs:
+                raise TautologyDetected(a, b, 'a | b -> a')
+            for aarg in sorted_aargs:
+                self.process_rule(aarg, b)
+
+        else:
+            # both `a` and `b` are atoms
+            self.proved_rules.append((a, b))             # a  -> b
+            self.proved_rules.append((Not(b), Not(a)))   # !b -> !a
+
+########################################
+
+
+class FactRules:
+    """Rules that describe how to deduce facts in logic space
+
+       When defined, these rules allow implications to quickly be determined
+       for a set of facts. For this precomputed deduction tables are used.
+       see `deduce_all_facts`   (forward-chaining)
+
+       Also it is possible to gather prerequisites for a fact, which is tried
+       to be proven.    (backward-chaining)
+
+
+       Definition Syntax
+       -----------------
+
+       a -> b       -- a=T -> b=T  (and automatically b=F -> a=F)
+       a -> !b      -- a=T -> b=F
+       a == b       -- a -> b & b -> a
+       a -> b & c   -- a=T -> b=T & c=T
+       # TODO b | c
+
+
+       Internals
+       ---------
+
+       .full_implications[k, v]: all the implications of fact k=v
+       .beta_triggers[k, v]: beta rules that might be triggered when k=v
+       .prereq  -- {} k <- [] of k's prerequisites
+
+       .defined_facts -- set of defined fact names
+    """
+
+    def __init__(self, rules):
+        """Compile rules into internal lookup tables"""
+
+        if isinstance(rules, str):
+            rules = rules.splitlines()
+
+        # --- parse and process rules ---
+        P = Prover()
+
+        for rule in rules:
+            # XXX `a` is hardcoded to be always atom
+            a, op, b = rule.split(None, 2)
+
+            a = Logic.fromstring(a)
+            b = Logic.fromstring(b)
+
+            if op == '->':
+                P.process_rule(a, b)
+            elif op == '==':
+                P.process_rule(a, b)
+                P.process_rule(b, a)
+            else:
+                raise ValueError('unknown op %r' % op)
+
+        # --- build deduction networks ---
+        self.beta_rules = []
+        for bcond, bimpl in P.rules_beta:
+            self.beta_rules.append(
+                ({_as_pair(a) for a in bcond.args}, _as_pair(bimpl)))
+
+        # deduce alpha implications
+        impl_a = deduce_alpha_implications(P.rules_alpha)
+
+        # now:
+        # - apply beta rules to alpha chains  (static extension), and
+        # - further associate beta rules to alpha chain (for inference
+        # at runtime)
+        impl_ab = apply_beta_to_alpha_route(impl_a, P.rules_beta)
+
+        # extract defined fact names
+        self.defined_facts = {_base_fact(k) for k in impl_ab.keys()}
+
+        # build rels (forward chains)
+        full_implications = defaultdict(set)
+        beta_triggers = defaultdict(set)
+        for k, (impl, betaidxs) in impl_ab.items():
+            full_implications[_as_pair(k)] = {_as_pair(i) for i in impl}
+            beta_triggers[_as_pair(k)] = betaidxs
+
+        self.full_implications = full_implications
+        self.beta_triggers = beta_triggers
+
+        # build prereq (backward chains)
+        prereq = defaultdict(set)
+        rel_prereq = rules_2prereq(full_implications)
+        for k, pitems in rel_prereq.items():
+            prereq[k] |= pitems
+        self.prereq = prereq
+
+    def _to_python(self) -> str:
+        """ Generate a string with plain python representation of the instance """
+        return '\n'.join(self.print_rules())
+
+    @classmethod
+    def _from_python(cls, data : dict):
+        """ Generate an instance from the plain python representation """
+        self = cls('')
+        for key in ['full_implications', 'beta_triggers', 'prereq']:
+            d=defaultdict(set)
+            d.update(data[key])
+            setattr(self, key, d)
+        self.beta_rules = data['beta_rules']
+        self.defined_facts = set(data['defined_facts'])
+
+        return self
+
+    def _defined_facts_lines(self):
+        yield 'defined_facts = ['
+        for fact in sorted(self.defined_facts):
+            yield f'    {fact!r},'
+        yield '] # defined_facts'
+
+    def _full_implications_lines(self):
+        yield 'full_implications = dict( ['
+        for fact in sorted(self.defined_facts):
+            for value in (True, False):
+                yield f'    # Implications of {fact} = {value}:'
+                yield f'    (({fact!r}, {value!r}), set( ('
+                implications = self.full_implications[(fact, value)]
+                for implied in sorted(implications):
+                    yield f'        {implied!r},'
+                yield '       ) ),'
+                yield '     ),'
+        yield ' ] ) # full_implications'
+
+    def _prereq_lines(self):
+        yield 'prereq = {'
+        yield ''
+        for fact in sorted(self.prereq):
+            yield f'    # facts that could determine the value of {fact}'
+            yield f'    {fact!r}: {{'
+            for pfact in sorted(self.prereq[fact]):
+                yield f'        {pfact!r},'
+            yield '    },'
+            yield ''
+        yield '} # prereq'
+
+    def _beta_rules_lines(self):
+        reverse_implications = defaultdict(list)
+        for n, (pre, implied) in enumerate(self.beta_rules):
+            reverse_implications[implied].append((pre, n))
+
+        yield '# Note: the order of the beta rules is used in the beta_triggers'
+        yield 'beta_rules = ['
+        yield ''
+        m = 0
+        indices = {}
+        for implied in sorted(reverse_implications):
+            fact, value = implied
+            yield f'    # Rules implying {fact} = {value}'
+            for pre, n in reverse_implications[implied]:
+                indices[n] = m
+                m += 1
+                setstr = ", ".join(map(str, sorted(pre)))
+                yield f'    ({{{setstr}}},'
+                yield f'        {implied!r}),'
+            yield ''
+        yield '] # beta_rules'
+
+        yield 'beta_triggers = {'
+        for query in sorted(self.beta_triggers):
+            fact, value = query
+            triggers = [indices[n] for n in self.beta_triggers[query]]
+            yield f'    {query!r}: {triggers!r},'
+        yield '} # beta_triggers'
+
+    def print_rules(self) -> Iterator[str]:
+        """ Returns a generator with lines to represent the facts and rules """
+        yield from self._defined_facts_lines()
+        yield ''
+        yield ''
+        yield from self._full_implications_lines()
+        yield ''
+        yield ''
+        yield from self._prereq_lines()
+        yield ''
+        yield ''
+        yield from self._beta_rules_lines()
+        yield ''
+        yield ''
+        yield "generated_assumptions = {'defined_facts': defined_facts, 'full_implications': full_implications,"
+        yield "               'prereq': prereq, 'beta_rules': beta_rules, 'beta_triggers': beta_triggers}"
+
+
+class InconsistentAssumptions(ValueError):
+    def __str__(self):
+        kb, fact, value = self.args
+        return "%s, %s=%s" % (kb, fact, value)
+
+
+class FactKB(dict):
+    """
+    A simple propositional knowledge base relying on compiled inference rules.
+    """
+    def __str__(self):
+        return '{\n%s}' % ',\n'.join(
+            ["\t%s: %s" % i for i in sorted(self.items())])
+
+    def __init__(self, rules):
+        self.rules = rules
+
+    def _tell(self, k, v):
+        """Add fact k=v to the knowledge base.
+
+        Returns True if the KB has actually been updated, False otherwise.
+        """
+        if k in self and self[k] is not None:
+            if self[k] == v:
+                return False
+            else:
+                raise InconsistentAssumptions(self, k, v)
+        else:
+            self[k] = v
+            return True
+
+    # *********************************************
+    # * This is the workhorse, so keep it *fast*. *
+    # *********************************************
+    def deduce_all_facts(self, facts):
+        """
+        Update the KB with all the implications of a list of facts.
+
+        Facts can be specified as a dictionary or as a list of (key, value)
+        pairs.
+        """
+        # keep frequently used attributes locally, so we'll avoid extra
+        # attribute access overhead
+        full_implications = self.rules.full_implications
+        beta_triggers = self.rules.beta_triggers
+        beta_rules = self.rules.beta_rules
+
+        if isinstance(facts, dict):
+            facts = facts.items()
+
+        while facts:
+            beta_maytrigger = set()
+
+            # --- alpha chains ---
+            for k, v in facts:
+                if not self._tell(k, v) or v is None:
+                    continue
+
+                # lookup routing tables
+                for key, value in full_implications[k, v]:
+                    self._tell(key, value)
+
+                beta_maytrigger.update(beta_triggers[k, v])
+
+            # --- beta chains ---
+            facts = []
+            for bidx in beta_maytrigger:
+                bcond, bimpl = beta_rules[bidx]
+                if all(self.get(k) is v for k, v in bcond):
+                    facts.append(bimpl)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/function.py b/.venv/lib/python3.12/site-packages/sympy/core/function.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac850845e0bb2aaf9b535635567d6e2629527ad7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/function.py
@@ -0,0 +1,3423 @@
+"""
+There are three types of functions implemented in SymPy:
+
+    1) defined functions (in the sense that they can be evaluated) like
+       exp or sin; they have a name and a body:
+           f = exp
+    2) undefined function which have a name but no body. Undefined
+       functions can be defined using a Function class as follows:
+           f = Function('f')
+       (the result will be a Function instance)
+    3) anonymous function (or lambda function) which have a body (defined
+       with dummy variables) but have no name:
+           f = Lambda(x, exp(x)*x)
+           f = Lambda((x, y), exp(x)*y)
+    The fourth type of functions are composites, like (sin + cos)(x); these work in
+    SymPy core, but are not yet part of SymPy.
+
+    Examples
+    ========
+
+    >>> import sympy
+    >>> f = sympy.Function("f")
+    >>> from sympy.abc import x
+    >>> f(x)
+    f(x)
+    >>> print(sympy.srepr(f(x).func))
+    Function('f')
+    >>> f(x).args
+    (x,)
+
+"""
+
+from __future__ import annotations
+
+from typing import Any
+from collections.abc import Iterable
+import copyreg
+
+from .add import Add
+from .basic import Basic, _atomic
+from .cache import cacheit
+from .containers import Tuple, Dict
+from .decorators import _sympifyit
+from .evalf import pure_complex
+from .expr import Expr, AtomicExpr
+from .logic import fuzzy_and, fuzzy_or, fuzzy_not, FuzzyBool
+from .mul import Mul
+from .numbers import Rational, Float, Integer
+from .operations import LatticeOp
+from .parameters import global_parameters
+from .rules import Transform
+from .singleton import S
+from .sympify import sympify, _sympify
+
+from .sorting import default_sort_key, ordered
+from sympy.utilities.exceptions import (sympy_deprecation_warning,
+                                        SymPyDeprecationWarning, ignore_warnings)
+from sympy.utilities.iterables import (has_dups, sift, iterable,
+    is_sequence, uniq, topological_sort)
+from sympy.utilities.lambdify import MPMATH_TRANSLATIONS
+from sympy.utilities.misc import as_int, filldedent, func_name
+
+import mpmath
+from mpmath.libmp.libmpf import prec_to_dps
+
+import inspect
+from collections import Counter
+
+def _coeff_isneg(a):
+    """Return True if the leading Number is negative.
+
+    Examples
+    ========
+
+    >>> from sympy.core.function import _coeff_isneg
+    >>> from sympy import S, Symbol, oo, pi
+    >>> _coeff_isneg(-3*pi)
+    True
+    >>> _coeff_isneg(S(3))
+    False
+    >>> _coeff_isneg(-oo)
+    True
+    >>> _coeff_isneg(Symbol('n', negative=True)) # coeff is 1
+    False
+
+    For matrix expressions:
+
+    >>> from sympy import MatrixSymbol, sqrt
+    >>> A = MatrixSymbol("A", 3, 3)
+    >>> _coeff_isneg(-sqrt(2)*A)
+    True
+    >>> _coeff_isneg(sqrt(2)*A)
+    False
+    """
+
+    if a.is_MatMul:
+        a = a.args[0]
+    if a.is_Mul:
+        a = a.args[0]
+    return a.is_Number and a.is_extended_negative
+
+
+class PoleError(Exception):
+    pass
+
+
+class ArgumentIndexError(ValueError):
+    def __str__(self):
+        return ("Invalid operation with argument number %s for Function %s" %
+               (self.args[1], self.args[0]))
+
+
+class BadSignatureError(TypeError):
+    '''Raised when a Lambda is created with an invalid signature'''
+    pass
+
+
+class BadArgumentsError(TypeError):
+    '''Raised when a Lambda is called with an incorrect number of arguments'''
+    pass
+
+
+# Python 3 version that does not raise a Deprecation warning
+def arity(cls):
+    """Return the arity of the function if it is known, else None.
+
+    Explanation
+    ===========
+
+    When default values are specified for some arguments, they are
+    optional and the arity is reported as a tuple of possible values.
+
+    Examples
+    ========
+
+    >>> from sympy import arity, log
+    >>> arity(lambda x: x)
+    1
+    >>> arity(log)
+    (1, 2)
+    >>> arity(lambda *x: sum(x)) is None
+    True
+    """
+    eval_ = getattr(cls, 'eval', cls)
+
+    parameters = inspect.signature(eval_).parameters.items()
+    if [p for _, p in parameters if p.kind == p.VAR_POSITIONAL]:
+        return
+    p_or_k = [p for _, p in parameters if p.kind == p.POSITIONAL_OR_KEYWORD]
+    # how many have no default and how many have a default value
+    no, yes = map(len, sift(p_or_k,
+        lambda p:p.default == p.empty, binary=True))
+    return no if not yes else tuple(range(no, no + yes + 1))
+
+class FunctionClass(type):
+    """
+    Base class for function classes. FunctionClass is a subclass of type.
+
+    Use Function('' [ , signature ]) to create
+    undefined function classes.
+    """
+    _new = type.__new__
+
+    def __init__(cls, *args, **kwargs):
+        # honor kwarg value or class-defined value before using
+        # the number of arguments in the eval function (if present)
+        nargs = kwargs.pop('nargs', cls.__dict__.get('nargs', arity(cls)))
+        if nargs is None and 'nargs' not in cls.__dict__:
+            for supcls in cls.__mro__:
+                if hasattr(supcls, '_nargs'):
+                    nargs = supcls._nargs
+                    break
+                else:
+                    continue
+
+        # Canonicalize nargs here; change to set in nargs.
+        if is_sequence(nargs):
+            if not nargs:
+                raise ValueError(filldedent('''
+                    Incorrectly specified nargs as %s:
+                    if there are no arguments, it should be
+                    `nargs = 0`;
+                    if there are any number of arguments,
+                    it should be
+                    `nargs = None`''' % str(nargs)))
+            nargs = tuple(ordered(set(nargs)))
+        elif nargs is not None:
+            nargs = (as_int(nargs),)
+        cls._nargs = nargs
+
+        # When __init__ is called from UndefinedFunction it is called with
+        # just one arg but when it is called from subclassing Function it is
+        # called with the usual (name, bases, namespace) type() signature.
+        if len(args) == 3:
+            namespace = args[2]
+            if 'eval' in namespace and not isinstance(namespace['eval'], classmethod):
+                raise TypeError("eval on Function subclasses should be a class method (defined with @classmethod)")
+
+    @property
+    def __signature__(self):
+        """
+        Allow Python 3's inspect.signature to give a useful signature for
+        Function subclasses.
+        """
+        # Python 3 only, but backports (like the one in IPython) still might
+        # call this.
+        try:
+            from inspect import signature
+        except ImportError:
+            return None
+
+        # TODO: Look at nargs
+        return signature(self.eval)
+
+    @property
+    def free_symbols(self):
+        return set()
+
+    @property
+    def xreplace(self):
+        # Function needs args so we define a property that returns
+        # a function that takes args...and then use that function
+        # to return the right value
+        return lambda rule, **_: rule.get(self, self)
+
+    @property
+    def nargs(self):
+        """Return a set of the allowed number of arguments for the function.
+
+        Examples
+        ========
+
+        >>> from sympy import Function
+        >>> f = Function('f')
+
+        If the function can take any number of arguments, the set of whole
+        numbers is returned:
+
+        >>> Function('f').nargs
+        Naturals0
+
+        If the function was initialized to accept one or more arguments, a
+        corresponding set will be returned:
+
+        >>> Function('f', nargs=1).nargs
+        {1}
+        >>> Function('f', nargs=(2, 1)).nargs
+        {1, 2}
+
+        The undefined function, after application, also has the nargs
+        attribute; the actual number of arguments is always available by
+        checking the ``args`` attribute:
+
+        >>> f = Function('f')
+        >>> f(1).nargs
+        Naturals0
+        >>> len(f(1).args)
+        1
+        """
+        from sympy.sets.sets import FiniteSet
+        # XXX it would be nice to handle this in __init__ but there are import
+        # problems with trying to import FiniteSet there
+        return FiniteSet(*self._nargs) if self._nargs else S.Naturals0
+
+    def _valid_nargs(self, n : int) -> bool:
+        """ Return True if the specified integer is a valid number of arguments
+
+        The number of arguments n is guaranteed to be an integer and positive
+
+        """
+        if self._nargs:
+            return n in self._nargs
+
+        nargs = self.nargs
+        return nargs is S.Naturals0 or n in nargs
+
+    def __repr__(cls):
+        return cls.__name__
+
+
+class Application(Basic, metaclass=FunctionClass):
+    """
+    Base class for applied functions.
+
+    Explanation
+    ===========
+
+    Instances of Application represent the result of applying an application of
+    any type to any object.
+    """
+
+    is_Function = True
+
+    @cacheit
+    def __new__(cls, *args, **options):
+        from sympy.sets.fancysets import Naturals0
+        from sympy.sets.sets import FiniteSet
+
+        args = list(map(sympify, args))
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        # WildFunction (and anything else like it) may have nargs defined
+        # and we throw that value away here
+        options.pop('nargs', None)
+
+        if options:
+            raise ValueError("Unknown options: %s" % options)
+
+        if evaluate:
+            evaluated = cls.eval(*args)
+            if evaluated is not None:
+                return evaluated
+
+        obj = super().__new__(cls, *args, **options)
+
+        # make nargs uniform here
+        sentinel = object()
+        objnargs = getattr(obj, "nargs", sentinel)
+        if objnargs is not sentinel:
+            # things passing through here:
+            #  - functions subclassed from Function (e.g. myfunc(1).nargs)
+            #  - functions like cos(1).nargs
+            #  - AppliedUndef with given nargs like Function('f', nargs=1)(1).nargs
+            # Canonicalize nargs here
+            if is_sequence(objnargs):
+                nargs = tuple(ordered(set(objnargs)))
+            elif objnargs is not None:
+                nargs = (as_int(objnargs),)
+            else:
+                nargs = None
+        else:
+            # things passing through here:
+            #  - WildFunction('f').nargs
+            #  - AppliedUndef with no nargs like Function('f')(1).nargs
+            nargs = obj._nargs  # note the underscore here
+        # convert to FiniteSet
+        obj.nargs = FiniteSet(*nargs) if nargs else Naturals0()
+        return obj
+
+    @classmethod
+    def eval(cls, *args):
+        """
+        Returns a canonical form of cls applied to arguments args.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is called when the class ``cls`` is about to be
+        instantiated and it should return either some simplified instance
+        (possible of some other class), or if the class ``cls`` should be
+        unmodified, return None.
+
+        Examples of ``eval()`` for the function "sign"
+
+        .. code-block:: python
+
+            @classmethod
+            def eval(cls, arg):
+                if arg is S.NaN:
+                    return S.NaN
+                if arg.is_zero: return S.Zero
+                if arg.is_positive: return S.One
+                if arg.is_negative: return S.NegativeOne
+                if isinstance(arg, Mul):
+                    coeff, terms = arg.as_coeff_Mul(rational=True)
+                    if coeff is not S.One:
+                        return cls(coeff) * cls(terms)
+
+        """
+        return
+
+    @property
+    def func(self):
+        return self.__class__
+
+    def _eval_subs(self, old, new):
+        if (old.is_Function and new.is_Function and
+            callable(old) and callable(new) and
+            old == self.func and len(self.args) in new.nargs):
+            return new(*[i._subs(old, new) for i in self.args])
+
+
+class Function(Application, Expr):
+    r"""
+    Base class for applied mathematical functions.
+
+    It also serves as a constructor for undefined function classes.
+
+    See the :ref:`custom-functions` guide for details on how to subclass
+    ``Function`` and what methods can be defined.
+
+    Examples
+    ========
+
+    **Undefined Functions**
+
+    To create an undefined function, pass a string of the function name to
+    ``Function``.
+
+    >>> from sympy import Function, Symbol
+    >>> x = Symbol('x')
+    >>> f = Function('f')
+    >>> g = Function('g')(x)
+    >>> f
+    f
+    >>> f(x)
+    f(x)
+    >>> g
+    g(x)
+    >>> f(x).diff(x)
+    Derivative(f(x), x)
+    >>> g.diff(x)
+    Derivative(g(x), x)
+
+    Assumptions can be passed to ``Function`` the same as with a
+    :class:`~.Symbol`. Alternatively, you can use a ``Symbol`` with
+    assumptions for the function name and the function will inherit the name
+    and assumptions associated with the ``Symbol``:
+
+    >>> f_real = Function('f', real=True)
+    >>> f_real(x).is_real
+    True
+    >>> f_real_inherit = Function(Symbol('f', real=True))
+    >>> f_real_inherit(x).is_real
+    True
+
+    Note that assumptions on a function are unrelated to the assumptions on
+    the variables it is called on. If you want to add a relationship, subclass
+    ``Function`` and define custom assumptions handler methods. See the
+    :ref:`custom-functions-assumptions` section of the :ref:`custom-functions`
+    guide for more details.
+
+    **Custom Function Subclasses**
+
+    The :ref:`custom-functions` guide has several
+    :ref:`custom-functions-complete-examples` of how to subclass ``Function``
+    to create a custom function.
+
+    """
+
+    @property
+    def _diff_wrt(self):
+        return False
+
+    @cacheit
+    def __new__(cls, *args, **options) -> type[AppliedUndef]:  # type: ignore
+        # Handle calls like Function('f')
+        if cls is Function:
+            return UndefinedFunction(*args, **options)  # type: ignore
+        else:
+            return cls._new_(*args, **options)  # type: ignore
+
+    @classmethod
+    def _new_(cls, *args, **options) -> Expr:
+        n = len(args)
+
+        if not cls._valid_nargs(n):
+            # XXX: exception message must be in exactly this format to
+            # make it work with NumPy's functions like vectorize(). See,
+            # for example, https://github.com/numpy/numpy/issues/1697.
+            # The ideal solution would be just to attach metadata to
+            # the exception and change NumPy to take advantage of this.
+            temp = ('%(name)s takes %(qual)s %(args)s '
+                   'argument%(plural)s (%(given)s given)')
+            raise TypeError(temp % {
+                'name': cls,
+                'qual': 'exactly' if len(cls.nargs) == 1 else 'at least',
+                'args': min(cls.nargs),
+                'plural': 's'*(min(cls.nargs) != 1),
+                'given': n})
+
+        evaluate = options.get('evaluate', global_parameters.evaluate)
+        result = super().__new__(cls, *args, **options)
+        if evaluate and isinstance(result, cls) and result.args:
+            _should_evalf = [cls._should_evalf(a) for a in result.args]
+            pr2 = min(_should_evalf)
+            if pr2 > 0:
+                pr = max(_should_evalf)
+                result = result.evalf(prec_to_dps(pr))
+
+        return _sympify(result)
+
+    @classmethod
+    def _should_evalf(cls, arg):
+        """
+        Decide if the function should automatically evalf().
+
+        Explanation
+        ===========
+
+        By default (in this implementation), this happens if (and only if) the
+        ARG is a floating point number (including complex numbers).
+        This function is used by __new__.
+
+        Returns the precision to evalf to, or -1 if it should not evalf.
+        """
+        if arg.is_Float:
+            return arg._prec
+        if not arg.is_Add:
+            return -1
+        m = pure_complex(arg)
+        if m is None:
+            return -1
+        # the elements of m are of type Number, so have a _prec
+        return max(m[0]._prec, m[1]._prec)
+
+    @classmethod
+    def class_key(cls):
+        from sympy.sets.fancysets import Naturals0
+        funcs = {
+            'exp': 10,
+            'log': 11,
+            'sin': 20,
+            'cos': 21,
+            'tan': 22,
+            'cot': 23,
+            'sinh': 30,
+            'cosh': 31,
+            'tanh': 32,
+            'coth': 33,
+            'conjugate': 40,
+            're': 41,
+            'im': 42,
+            'arg': 43,
+        }
+        name = cls.__name__
+
+        try:
+            i = funcs[name]
+        except KeyError:
+            i = 0 if isinstance(cls.nargs, Naturals0) else 10000
+
+        return 4, i, name
+
+    def _eval_evalf(self, prec):
+
+        def _get_mpmath_func(fname):
+            """Lookup mpmath function based on name"""
+            if isinstance(self, AppliedUndef):
+                # Shouldn't lookup in mpmath but might have ._imp_
+                return None
+
+            if not hasattr(mpmath, fname):
+                fname = MPMATH_TRANSLATIONS.get(fname, None)
+                if fname is None:
+                    return None
+            return getattr(mpmath, fname)
+
+        _eval_mpmath = getattr(self, '_eval_mpmath', None)
+        if _eval_mpmath is None:
+            func = _get_mpmath_func(self.func.__name__)
+            args = self.args
+        else:
+            func, args = _eval_mpmath()
+
+        # Fall-back evaluation
+        if func is None:
+            imp = getattr(self, '_imp_', None)
+            if imp is None:
+                return None
+            try:
+                return Float(imp(*[i.evalf(prec) for i in self.args]), prec)
+            except (TypeError, ValueError):
+                return None
+
+        # Convert all args to mpf or mpc
+        # Convert the arguments to *higher* precision than requested for the
+        # final result.
+        # XXX + 5 is a guess, it is similar to what is used in evalf.py. Should
+        #     we be more intelligent about it?
+        try:
+            args = [arg._to_mpmath(prec + 5) for arg in args]
+            def bad(m):
+                from mpmath import mpf, mpc
+                # the precision of an mpf value is the last element
+                # if that is 1 (and m[1] is not 1 which would indicate a
+                # power of 2), then the eval failed; so check that none of
+                # the arguments failed to compute to a finite precision.
+                # Note: An mpc value has two parts, the re and imag tuple;
+                # check each of those parts, too. Anything else is allowed to
+                # pass
+                if isinstance(m, mpf):
+                    m = m._mpf_
+                    return m[1] !=1 and m[-1] == 1
+                elif isinstance(m, mpc):
+                    m, n = m._mpc_
+                    return m[1] !=1 and m[-1] == 1 and \
+                        n[1] !=1 and n[-1] == 1
+                else:
+                    return False
+            if any(bad(a) for a in args):
+                raise ValueError  # one or more args failed to compute with significance
+        except ValueError:
+            return
+
+        with mpmath.workprec(prec):
+            v = func(*args)
+
+        return Expr._from_mpmath(v, prec)
+
+    def _eval_derivative(self, s):
+        # f(x).diff(s) -> x.diff(s) * f.fdiff(1)(s)
+        i = 0
+        l = []
+        for a in self.args:
+            i += 1
+            da = a.diff(s)
+            if da.is_zero:
+                continue
+            try:
+                df = self.fdiff(i)
+            except ArgumentIndexError:
+                df = Function.fdiff(self, i)
+            l.append(df * da)
+        return Add(*l)
+
+    def _eval_is_commutative(self):
+        return fuzzy_and(a.is_commutative for a in self.args)
+
+    def _eval_is_meromorphic(self, x, a):
+        if not self.args:
+            return True
+        if any(arg.has(x) for arg in self.args[1:]):
+            return False
+
+        arg = self.args[0]
+        if not arg._eval_is_meromorphic(x, a):
+            return None
+
+        return fuzzy_not(type(self).is_singular(arg.subs(x, a)))
+
+    _singularities: FuzzyBool | tuple[Expr, ...] = None
+
+    @classmethod
+    def is_singular(cls, a):
+        """
+        Tests whether the argument is an essential singularity
+        or a branch point, or the functions is non-holomorphic.
+        """
+        ss = cls._singularities
+        if ss in (True, None, False):
+            return ss
+
+        return fuzzy_or(a.is_infinite if s is S.ComplexInfinity
+                        else (a - s).is_zero for s in ss)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        """
+        Compute an asymptotic expansion around args0, in terms of self.args.
+        This function is only used internally by _eval_nseries and should not
+        be called directly; derived classes can overwrite this to implement
+        asymptotic expansions.
+        """
+        raise PoleError(filldedent('''
+            Asymptotic expansion of %s around %s is
+            not implemented.''' % (type(self), args0)))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        """
+        This function does compute series for multivariate functions,
+        but the expansion is always in terms of *one* variable.
+
+        Examples
+        ========
+
+        >>> from sympy import atan2
+        >>> from sympy.abc import x, y
+        >>> atan2(x, y).series(x, n=2)
+        atan2(0, y) + x/y + O(x**2)
+        >>> atan2(x, y).series(y, n=2)
+        -y/x + atan2(x, 0) + O(y**2)
+
+        This function also computes asymptotic expansions, if necessary
+        and possible:
+
+        >>> from sympy import loggamma
+        >>> loggamma(1/x)._eval_nseries(x,0,None)
+        -1/x - log(x)/x + log(x)/2 + O(1)
+
+        """
+        from .symbol import uniquely_named_symbol
+        from sympy.series.order import Order
+        from sympy.sets.sets import FiniteSet
+        args = self.args
+        args0 = [t.limit(x, 0) for t in args]
+        if any(t.is_finite is False for t in args0):
+            from .numbers import oo, zoo, nan
+            a = [t.as_leading_term(x, logx=logx) for t in args]
+            a0 = [t.limit(x, 0) for t in a]
+            if any(t.has(oo, -oo, zoo, nan) for t in a0):
+                return self._eval_aseries(n, args0, x, logx)
+            # Careful: the argument goes to oo, but only logarithmically so. We
+            # are supposed to do a power series expansion "around the
+            # logarithmic term". e.g.
+            #      f(1+x+log(x))
+            #     -> f(1+logx) + x*f'(1+logx) + O(x**2)
+            # where 'logx' is given in the argument
+            a = [t._eval_nseries(x, n, logx) for t in args]
+            z = [r - r0 for (r, r0) in zip(a, a0)]
+            p = [Dummy() for _ in z]
+            q = []
+            v = None
+            for ai, zi, pi in zip(a0, z, p):
+                if zi.has(x):
+                    if v is not None:
+                        raise NotImplementedError
+                    q.append(ai + pi)
+                    v = pi
+                else:
+                    q.append(ai)
+            e1 = self.func(*q)
+            if v is None:
+                return e1
+            s = e1._eval_nseries(v, n, logx)
+            o = s.getO()
+            s = s.removeO()
+            s = s.subs(v, zi).expand() + Order(o.expr.subs(v, zi), x)
+            return s
+        if (self.func.nargs is S.Naturals0
+                or (self.func.nargs == FiniteSet(1) and args0[0])
+                or any(c > 1 for c in self.func.nargs)):
+            e = self
+            e1 = e.expand()
+            if e == e1:
+                #for example when e = sin(x+1) or e = sin(cos(x))
+                #let's try the general algorithm
+                if len(e.args) == 1:
+                    # issue 14411
+                    e = e.func(e.args[0].cancel())
+                term = e.subs(x, S.Zero)
+                if term.is_finite is False or term is S.NaN:
+                    raise PoleError("Cannot expand %s around 0" % (self))
+                series = term
+                fact = S.One
+
+                _x = uniquely_named_symbol('xi', self)
+                e = e.subs(x, _x)
+                for i in range(1, n):
+                    fact *= Rational(i)
+                    e = e.diff(_x)
+                    subs = e.subs(_x, S.Zero)
+                    if subs is S.NaN:
+                        # try to evaluate a limit if we have to
+                        subs = e.limit(_x, S.Zero)
+                    if subs.is_finite is False:
+                        raise PoleError("Cannot expand %s around 0" % (self))
+                    term = subs*(x**i)/fact
+                    term = term.expand()
+                    series += term
+                return series + Order(x**n, x)
+            return e1.nseries(x, n=n, logx=logx)
+        arg = self.args[0]
+        l = []
+        g = None
+        # try to predict a number of terms needed
+        nterms = n + 2
+        cf = Order(arg.as_leading_term(x), x).getn()
+        if cf != 0:
+            nterms = (n/cf).ceiling()
+        for i in range(nterms):
+            g = self.taylor_term(i, arg, g)
+            g = g.nseries(x, n=n, logx=logx)
+            l.append(g)
+        return Add(*l) + Order(x**n, x)
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of the function.
+        """
+        if not (1 <= argindex <= len(self.args)):
+            raise ArgumentIndexError(self, argindex)
+        ix = argindex - 1
+        A = self.args[ix]
+        if A._diff_wrt:
+            if len(self.args) == 1 or not A.is_Symbol:
+                return _derivative_dispatch(self, A)
+            for i, v in enumerate(self.args):
+                if i != ix and A in v.free_symbols:
+                    # it can't be in any other argument's free symbols
+                    # issue 8510
+                    break
+            else:
+                return _derivative_dispatch(self, A)
+
+        # See issue 4624 and issue 4719, 5600 and 8510
+        D = Dummy('xi_%i' % argindex, dummy_index=hash(A))
+        args = self.args[:ix] + (D,) + self.args[ix + 1:]
+        return Subs(Derivative(self.func(*args), D), D, A)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        """Stub that should be overridden by new Functions to return
+        the first non-zero term in a series if ever an x-dependent
+        argument whose leading term vanishes as x -> 0 might be encountered.
+        See, for example, cos._eval_as_leading_term.
+        """
+        from sympy.series.order import Order
+        args = [a.as_leading_term(x, logx=logx) for a in self.args]
+        o = Order(1, x)
+        if any(x in a.free_symbols and o.contains(a) for a in args):
+            # Whereas x and any finite number are contained in O(1, x),
+            # expressions like 1/x are not. If any arg simplified to a
+            # vanishing expression as x -> 0 (like x or x**2, but not
+            # 3, 1/x, etc...) then the _eval_as_leading_term is needed
+            # to supply the first non-zero term of the series,
+            #
+            # e.g. expression    leading term
+            #      ----------    ------------
+            #      cos(1/x)      cos(1/x)
+            #      cos(cos(x))   cos(1)
+            #      cos(x)        1        <- _eval_as_leading_term needed
+            #      sin(x)        x        <- _eval_as_leading_term needed
+            #
+            raise NotImplementedError(
+                '%s has no _eval_as_leading_term routine' % self.func)
+        else:
+            return self
+
+
+class DefinedFunction(Function):
+    """Base class for defined functions like ``sin``, ``cos``, ..."""
+
+    @cacheit
+    def __new__(cls, *args, **options) -> Expr:  # type: ignore
+        return cls._new_(*args, **options)
+
+
+class AppliedUndef(Function):
+    """
+    Base class for expressions resulting from the application of an undefined
+    function.
+    """
+
+    is_number = False
+
+    name: str
+
+    def __new__(cls, *args, **options) -> Expr:  # type: ignore
+        args = tuple(map(sympify, args))
+        u = [a.name for a in args if isinstance(a, UndefinedFunction)]
+        if u:
+            raise TypeError('Invalid argument: expecting an expression, not UndefinedFunction%s: %s' % (
+                's'*(len(u) > 1), ', '.join(u)))
+        obj: Expr = super().__new__(cls, *args, **options)  # type: ignore
+        return obj
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        return self
+
+    @property
+    def _diff_wrt(self):
+        """
+        Allow derivatives wrt to undefined functions.
+
+        Examples
+        ========
+
+        >>> from sympy import Function, Symbol
+        >>> f = Function('f')
+        >>> x = Symbol('x')
+        >>> f(x)._diff_wrt
+        True
+        >>> f(x).diff(x)
+        Derivative(f(x), x)
+        """
+        return True
+
+
+class UndefSageHelper:
+    """
+    Helper to facilitate Sage conversion.
+    """
+    def __get__(self, ins, typ):
+        import sage.all as sage
+        if ins is None:
+            return lambda: sage.function(typ.__name__)
+        else:
+            args = [arg._sage_() for arg in ins.args]
+            return lambda : sage.function(ins.__class__.__name__)(*args)
+
+_undef_sage_helper = UndefSageHelper()
+
+
+class UndefinedFunction(FunctionClass):
+    """
+    The (meta)class of undefined functions.
+    """
+    name: str
+    _sage_: UndefSageHelper
+
+    def __new__(mcl, name, bases=(AppliedUndef,), __dict__=None, **kwargs) -> type[AppliedUndef]:
+        from .symbol import _filter_assumptions
+        # Allow Function('f', real=True)
+        # and/or Function(Symbol('f', real=True))
+        assumptions, kwargs = _filter_assumptions(kwargs)
+        if isinstance(name, Symbol):
+            assumptions = name._merge(assumptions)
+            name = name.name
+        elif not isinstance(name, str):
+            raise TypeError('expecting string or Symbol for name')
+        else:
+            commutative = assumptions.get('commutative', None)
+            assumptions = Symbol(name, **assumptions).assumptions0
+            if commutative is None:
+                assumptions.pop('commutative')
+        __dict__ = __dict__ or {}
+        # put the `is_*` for into __dict__
+        __dict__.update({'is_%s' % k: v for k, v in assumptions.items()})
+        # You can add other attributes, although they do have to be hashable
+        # (but seriously, if you want to add anything other than assumptions,
+        # just subclass Function)
+        __dict__.update(kwargs)
+        # add back the sanitized assumptions without the is_ prefix
+        kwargs.update(assumptions)
+        # Save these for __eq__
+        __dict__.update({'_kwargs': kwargs})
+        # do this for pickling
+        __dict__['__module__'] = None
+        obj = super().__new__(mcl, name, bases, __dict__)  # type: ignore
+        obj.name = name
+        obj._sage_ = _undef_sage_helper
+        return obj  # type: ignore
+
+    def __instancecheck__(cls, instance):
+        return cls in type(instance).__mro__
+
+    _kwargs: dict[str, bool | None] = {}
+
+    def __hash__(self):
+        return hash((self.class_key(), frozenset(self._kwargs.items())))
+
+    def __eq__(self, other):
+        return (isinstance(other, self.__class__) and
+            self.class_key() == other.class_key() and
+            self._kwargs == other._kwargs)
+
+    def __ne__(self, other):
+        return not self == other
+
+    @property
+    def _diff_wrt(self):
+        return False
+
+
+# Using copyreg is the only way to make a dynamically generated instance of a
+# metaclass picklable without using a custom pickler. It is not possible to
+# define e.g. __reduce__ on the metaclass because obj.__reduce__ will retrieve
+# the __reduce__ method for reducing instances of the type rather than for the
+# type itself.
+def _reduce_undef(f):
+    return (_rebuild_undef, (f.name, f._kwargs))
+
+def _rebuild_undef(name, kwargs):
+    return Function(name, **kwargs)
+
+copyreg.pickle(UndefinedFunction, _reduce_undef)
+
+
+# XXX: The type: ignore on WildFunction is because mypy complains:
+#
+# sympy/core/function.py:939: error: Cannot determine type of 'sort_key' in
+# base class 'Expr'
+#
+# Somehow this is because of the @cacheit decorator but it is not clear how to
+# fix it.
+
+
+class WildFunction(Function, AtomicExpr):  # type: ignore
+    """
+    A WildFunction function matches any function (with its arguments).
+
+    Examples
+    ========
+
+    >>> from sympy import WildFunction, Function, cos
+    >>> from sympy.abc import x, y
+    >>> F = WildFunction('F')
+    >>> f = Function('f')
+    >>> F.nargs
+    Naturals0
+    >>> x.match(F)
+    >>> F.match(F)
+    {F_: F_}
+    >>> f(x).match(F)
+    {F_: f(x)}
+    >>> cos(x).match(F)
+    {F_: cos(x)}
+    >>> f(x, y).match(F)
+    {F_: f(x, y)}
+
+    To match functions with a given number of arguments, set ``nargs`` to the
+    desired value at instantiation:
+
+    >>> F = WildFunction('F', nargs=2)
+    >>> F.nargs
+    {2}
+    >>> f(x).match(F)
+    >>> f(x, y).match(F)
+    {F_: f(x, y)}
+
+    To match functions with a range of arguments, set ``nargs`` to a tuple
+    containing the desired number of arguments, e.g. if ``nargs = (1, 2)``
+    then functions with 1 or 2 arguments will be matched.
+
+    >>> F = WildFunction('F', nargs=(1, 2))
+    >>> F.nargs
+    {1, 2}
+    >>> f(x).match(F)
+    {F_: f(x)}
+    >>> f(x, y).match(F)
+    {F_: f(x, y)}
+    >>> f(x, y, 1).match(F)
+
+    """
+
+    # XXX: What is this class attribute used for?
+    include: set[Any] = set()
+
+    def __init__(cls, name, **assumptions):
+        from sympy.sets.sets import Set, FiniteSet
+        cls.name = name
+        nargs = assumptions.pop('nargs', S.Naturals0)
+        if not isinstance(nargs, Set):
+            # Canonicalize nargs here.  See also FunctionClass.
+            if is_sequence(nargs):
+                nargs = tuple(ordered(set(nargs)))
+            elif nargs is not None:
+                nargs = (as_int(nargs),)
+            nargs = FiniteSet(*nargs)
+        cls.nargs = nargs
+
+    def matches(self, expr, repl_dict=None, old=False):
+        if not isinstance(expr, (AppliedUndef, Function)):
+            return None
+        if len(expr.args) not in self.nargs:
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+
+        repl_dict[self] = expr
+        return repl_dict
+
+
+class Derivative(Expr):
+    """
+    Carries out differentiation of the given expression with respect to symbols.
+
+    Examples
+    ========
+
+    >>> from sympy import Derivative, Function, symbols, Subs
+    >>> from sympy.abc import x, y
+    >>> f, g = symbols('f g', cls=Function)
+
+    >>> Derivative(x**2, x, evaluate=True)
+    2*x
+
+    Denesting of derivatives retains the ordering of variables:
+
+        >>> Derivative(Derivative(f(x, y), y), x)
+        Derivative(f(x, y), y, x)
+
+    Contiguously identical symbols are merged into a tuple giving
+    the symbol and the count:
+
+        >>> Derivative(f(x), x, x, y, x)
+        Derivative(f(x), (x, 2), y, x)
+
+    If the derivative cannot be performed, and evaluate is True, the
+    order of the variables of differentiation will be made canonical:
+
+        >>> Derivative(f(x, y), y, x, evaluate=True)
+        Derivative(f(x, y), x, y)
+
+    Derivatives with respect to undefined functions can be calculated:
+
+        >>> Derivative(f(x)**2, f(x), evaluate=True)
+        2*f(x)
+
+    Such derivatives will show up when the chain rule is used to
+    evaluate a derivative:
+
+        >>> f(g(x)).diff(x)
+        Derivative(f(g(x)), g(x))*Derivative(g(x), x)
+
+    Substitution is used to represent derivatives of functions with
+    arguments that are not symbols or functions:
+
+        >>> f(2*x + 3).diff(x) == 2*Subs(f(y).diff(y), y, 2*x + 3)
+        True
+
+    Notes
+    =====
+
+    Simplification of high-order derivatives:
+
+    Because there can be a significant amount of simplification that can be
+    done when multiple differentiations are performed, results will be
+    automatically simplified in a fairly conservative fashion unless the
+    keyword ``simplify`` is set to False.
+
+        >>> from sympy import sqrt, diff, Function, symbols
+        >>> from sympy.abc import x, y, z
+        >>> f, g = symbols('f,g', cls=Function)
+
+        >>> e = sqrt((x + 1)**2 + x)
+        >>> diff(e, (x, 5), simplify=False).count_ops()
+        136
+        >>> diff(e, (x, 5)).count_ops()
+        30
+
+    Ordering of variables:
+
+    If evaluate is set to True and the expression cannot be evaluated, the
+    list of differentiation symbols will be sorted, that is, the expression is
+    assumed to have continuous derivatives up to the order asked.
+
+    Derivative wrt non-Symbols:
+
+    For the most part, one may not differentiate wrt non-symbols.
+    For example, we do not allow differentiation wrt `x*y` because
+    there are multiple ways of structurally defining where x*y appears
+    in an expression: a very strict definition would make
+    (x*y*z).diff(x*y) == 0. Derivatives wrt defined functions (like
+    cos(x)) are not allowed, either:
+
+        >>> (x*y*z).diff(x*y)
+        Traceback (most recent call last):
+        ...
+        ValueError: Can't calculate derivative wrt x*y.
+
+    To make it easier to work with variational calculus, however,
+    derivatives wrt AppliedUndef and Derivatives are allowed.
+    For example, in the Euler-Lagrange method one may write
+    F(t, u, v) where u = f(t) and v = f'(t). These variables can be
+    written explicitly as functions of time::
+
+        >>> from sympy.abc import t
+        >>> F = Function('F')
+        >>> U = f(t)
+        >>> V = U.diff(t)
+
+    The derivative wrt f(t) can be obtained directly:
+
+        >>> direct = F(t, U, V).diff(U)
+
+    When differentiation wrt a non-Symbol is attempted, the non-Symbol
+    is temporarily converted to a Symbol while the differentiation
+    is performed and the same answer is obtained:
+
+        >>> indirect = F(t, U, V).subs(U, x).diff(x).subs(x, U)
+        >>> assert direct == indirect
+
+    The implication of this non-symbol replacement is that all
+    functions are treated as independent of other functions and the
+    symbols are independent of the functions that contain them::
+
+        >>> x.diff(f(x))
+        0
+        >>> g(x).diff(f(x))
+        0
+
+    It also means that derivatives are assumed to depend only
+    on the variables of differentiation, not on anything contained
+    within the expression being differentiated::
+
+        >>> F = f(x)
+        >>> Fx = F.diff(x)
+        >>> Fx.diff(F)  # derivative depends on x, not F
+        0
+        >>> Fxx = Fx.diff(x)
+        >>> Fxx.diff(Fx)  # derivative depends on x, not Fx
+        0
+
+    The last example can be made explicit by showing the replacement
+    of Fx in Fxx with y:
+
+        >>> Fxx.subs(Fx, y)
+        Derivative(y, x)
+
+        Since that in itself will evaluate to zero, differentiating
+        wrt Fx will also be zero:
+
+        >>> _.doit()
+        0
+
+    Replacing undefined functions with concrete expressions
+
+    One must be careful to replace undefined functions with expressions
+    that contain variables consistent with the function definition and
+    the variables of differentiation or else insconsistent result will
+    be obtained. Consider the following example:
+
+    >>> eq = f(x)*g(y)
+    >>> eq.subs(f(x), x*y).diff(x, y).doit()
+    y*Derivative(g(y), y) + g(y)
+    >>> eq.diff(x, y).subs(f(x), x*y).doit()
+    y*Derivative(g(y), y)
+
+    The results differ because `f(x)` was replaced with an expression
+    that involved both variables of differentiation. In the abstract
+    case, differentiation of `f(x)` by `y` is 0; in the concrete case,
+    the presence of `y` made that derivative nonvanishing and produced
+    the extra `g(y)` term.
+
+    Defining differentiation for an object
+
+    An object must define ._eval_derivative(symbol) method that returns
+    the differentiation result. This function only needs to consider the
+    non-trivial case where expr contains symbol and it should call the diff()
+    method internally (not _eval_derivative); Derivative should be the only
+    one to call _eval_derivative.
+
+    Any class can allow derivatives to be taken with respect to
+    itself (while indicating its scalar nature). See the
+    docstring of Expr._diff_wrt.
+
+    See Also
+    ========
+    _sort_variable_count
+    """
+
+    is_Derivative = True
+
+    @property
+    def _diff_wrt(self):
+        """An expression may be differentiated wrt a Derivative if
+        it is in elementary form.
+
+        Examples
+        ========
+
+        >>> from sympy import Function, Derivative, cos
+        >>> from sympy.abc import x
+        >>> f = Function('f')
+
+        >>> Derivative(f(x), x)._diff_wrt
+        True
+        >>> Derivative(cos(x), x)._diff_wrt
+        False
+        >>> Derivative(x + 1, x)._diff_wrt
+        False
+
+        A Derivative might be an unevaluated form of what will not be
+        a valid variable of differentiation if evaluated. For example,
+
+        >>> Derivative(f(f(x)), x).doit()
+        Derivative(f(x), x)*Derivative(f(f(x)), f(x))
+
+        Such an expression will present the same ambiguities as arise
+        when dealing with any other product, like ``2*x``, so ``_diff_wrt``
+        is False:
+
+        >>> Derivative(f(f(x)), x)._diff_wrt
+        False
+        """
+        return self.expr._diff_wrt and isinstance(self.doit(), Derivative)
+
+    def __new__(cls, expr, *variables, **kwargs):
+        expr = sympify(expr)
+        if not isinstance(expr, Basic):
+            raise TypeError(f"Cannot represent derivative of {type(expr)}")
+        symbols_or_none = getattr(expr, "free_symbols", None)
+        has_symbol_set = isinstance(symbols_or_none, set)
+
+        if not has_symbol_set:
+            raise ValueError(filldedent('''
+                Since there are no variables in the expression %s,
+                it cannot be differentiated.''' % expr))
+
+        # determine value for variables if it wasn't given
+        if not variables:
+            variables = expr.free_symbols
+            if len(variables) != 1:
+                if expr.is_number:
+                    return S.Zero
+                if len(variables) == 0:
+                    raise ValueError(filldedent('''
+                        Since there are no variables in the expression,
+                        the variable(s) of differentiation must be supplied
+                        to differentiate %s''' % expr))
+                else:
+                    raise ValueError(filldedent('''
+                        Since there is more than one variable in the
+                        expression, the variable(s) of differentiation
+                        must be supplied to differentiate %s''' % expr))
+
+        # Split the list of variables into a list of the variables we are diff
+        # wrt, where each element of the list has the form (s, count) where
+        # s is the entity to diff wrt and count is the order of the
+        # derivative.
+        variable_count = []
+        array_likes = (tuple, list, Tuple)
+
+        from sympy.tensor.array import Array, NDimArray
+
+        for i, v in enumerate(variables):
+            if isinstance(v, UndefinedFunction):
+                raise TypeError(
+                    "cannot differentiate wrt "
+                    "UndefinedFunction: %s" % v)
+
+            if isinstance(v, array_likes):
+                if len(v) == 0:
+                    # Ignore empty tuples: Derivative(expr, ... , (), ... )
+                    continue
+                if isinstance(v[0], array_likes):
+                    # Derive by array: Derivative(expr, ... , [[x, y, z]], ... )
+                    if len(v) == 1:
+                        v = Array(v[0])
+                        count = 1
+                    else:
+                        v, count = v
+                        v = Array(v)
+                else:
+                    v, count = v
+                if count == 0:
+                    continue
+                variable_count.append(Tuple(v, count))
+                continue
+
+            v = sympify(v)
+            if isinstance(v, Integer):
+                if i == 0:
+                    raise ValueError("First variable cannot be a number: %i" % v)
+                count = v
+                prev, prevcount = variable_count[-1]
+                if prevcount != 1:
+                    raise TypeError("tuple {} followed by number {}".format((prev, prevcount), v))
+                if count == 0:
+                    variable_count.pop()
+                else:
+                    variable_count[-1] = Tuple(prev, count)
+            else:
+                count = 1
+                variable_count.append(Tuple(v, count))
+
+        # light evaluation of contiguous, identical
+        # items: (x, 1), (x, 1) -> (x, 2)
+        merged = []
+        for t in variable_count:
+            v, c = t
+            if c.is_negative:
+                raise ValueError(
+                    'order of differentiation must be nonnegative')
+            if merged and merged[-1][0] == v:
+                c += merged[-1][1]
+                if not c:
+                    merged.pop()
+                else:
+                    merged[-1] = Tuple(v, c)
+            else:
+                merged.append(t)
+        variable_count = merged
+
+        # sanity check of variables of differentation; we waited
+        # until the counts were computed since some variables may
+        # have been removed because the count was 0
+        for v, c in variable_count:
+            # v must have _diff_wrt True
+            if not v._diff_wrt:
+                __ = ''  # filler to make error message neater
+                raise ValueError(filldedent('''
+                    Can't calculate derivative wrt %s.%s''' % (v,
+                    __)))
+
+        # We make a special case for 0th derivative, because there is no
+        # good way to unambiguously print this.
+        if len(variable_count) == 0:
+            return expr
+
+        evaluate = kwargs.get('evaluate', False)
+
+        if evaluate:
+            if isinstance(expr, Derivative):
+                expr = expr.canonical
+            variable_count = [
+                (v.canonical if isinstance(v, Derivative) else v, c)
+                for v, c in variable_count]
+
+            # Look for a quick exit if there are symbols that don't appear in
+            # expression at all. Note, this cannot check non-symbols like
+            # Derivatives as those can be created by intermediate
+            # derivatives.
+            zero = False
+            free = expr.free_symbols
+            from sympy.matrices.expressions.matexpr import MatrixExpr
+
+            for v, c in variable_count:
+                vfree = v.free_symbols
+                if c.is_positive and vfree:
+                    if isinstance(v, AppliedUndef):
+                        # these match exactly since
+                        # x.diff(f(x)) == g(x).diff(f(x)) == 0
+                        # and are not created by differentiation
+                        D = Dummy()
+                        if not expr.xreplace({v: D}).has(D):
+                            zero = True
+                            break
+                    elif isinstance(v, MatrixExpr):
+                        zero = False
+                        break
+                    elif isinstance(v, Symbol) and v not in free:
+                        zero = True
+                        break
+                    else:
+                        if not free & vfree:
+                            # e.g. v is IndexedBase or Matrix
+                            zero = True
+                            break
+            if zero:
+                return cls._get_zero_with_shape_like(expr)
+
+            # make the order of symbols canonical
+            #TODO: check if assumption of discontinuous derivatives exist
+            variable_count = cls._sort_variable_count(variable_count)
+
+        # denest
+        if isinstance(expr, Derivative):
+            variable_count = list(expr.variable_count) + variable_count
+            expr = expr.expr
+            return _derivative_dispatch(expr, *variable_count, **kwargs)
+
+        # we return here if evaluate is False or if there is no
+        # _eval_derivative method
+        if not evaluate or not hasattr(expr, '_eval_derivative'):
+            # return an unevaluated Derivative
+            if evaluate and variable_count == [(expr, 1)] and expr.is_scalar:
+                # special hack providing evaluation for classes
+                # that have defined is_scalar=True but have no
+                # _eval_derivative defined
+                return S.One
+            return Expr.__new__(cls, expr, *variable_count)
+
+        # evaluate the derivative by calling _eval_derivative method
+        # of expr for each variable
+        # -------------------------------------------------------------
+        nderivs = 0  # how many derivatives were performed
+        unhandled = []
+        from sympy.matrices.matrixbase import MatrixBase
+        for i, (v, count) in enumerate(variable_count):
+
+            old_expr = expr
+            old_v = None
+
+            is_symbol = v.is_symbol or isinstance(v,
+                (Iterable, Tuple, MatrixBase, NDimArray))
+
+            if not is_symbol:
+                old_v = v
+                v = Dummy('xi')
+                expr = expr.xreplace({old_v: v})
+                # Derivatives and UndefinedFunctions are independent
+                # of all others
+                clashing = not (isinstance(old_v, (Derivative, AppliedUndef)))
+                if v not in expr.free_symbols and not clashing:
+                    return expr.diff(v)  # expr's version of 0
+                if not old_v.is_scalar and not hasattr(
+                        old_v, '_eval_derivative'):
+                    # special hack providing evaluation for classes
+                    # that have defined is_scalar=True but have no
+                    # _eval_derivative defined
+                    expr *= old_v.diff(old_v)
+
+            obj = cls._dispatch_eval_derivative_n_times(expr, v, count)
+            if obj is not None and obj.is_zero:
+                return obj
+
+            nderivs += count
+
+            if old_v is not None:
+                if obj is not None:
+                    # remove the dummy that was used
+                    obj = obj.subs(v, old_v)
+                # restore expr
+                expr = old_expr
+
+            if obj is None:
+                # we've already checked for quick-exit conditions
+                # that give 0 so the remaining variables
+                # are contained in the expression but the expression
+                # did not compute a derivative so we stop taking
+                # derivatives
+                unhandled = variable_count[i:]
+                break
+
+            expr = obj
+
+        # what we have so far can be made canonical
+        expr = expr.replace(
+            lambda x: isinstance(x, Derivative),
+            lambda x: x.canonical)
+
+        if unhandled:
+            if isinstance(expr, Derivative):
+                unhandled = list(expr.variable_count) + unhandled
+                expr = expr.expr
+            expr = Expr.__new__(cls, expr, *unhandled)
+
+        if (nderivs > 1) == True and kwargs.get('simplify', True):
+            from .exprtools import factor_terms
+            from sympy.simplify.simplify import signsimp
+            expr = factor_terms(signsimp(expr))
+        return expr
+
+    @property
+    def canonical(cls):
+        return cls.func(cls.expr,
+            *Derivative._sort_variable_count(cls.variable_count))
+
+    @classmethod
+    def _sort_variable_count(cls, vc):
+        """
+        Sort (variable, count) pairs into canonical order while
+        retaining order of variables that do not commute during
+        differentiation:
+
+        * symbols and functions commute with each other
+        * derivatives commute with each other
+        * a derivative does not commute with anything it contains
+        * any other object is not allowed to commute if it has
+          free symbols in common with another object
+
+        Examples
+        ========
+
+        >>> from sympy import Derivative, Function, symbols
+        >>> vsort = Derivative._sort_variable_count
+        >>> x, y, z = symbols('x y z')
+        >>> f, g, h = symbols('f g h', cls=Function)
+
+        Contiguous items are collapsed into one pair:
+
+        >>> vsort([(x, 1), (x, 1)])
+        [(x, 2)]
+        >>> vsort([(y, 1), (f(x), 1), (y, 1), (f(x), 1)])
+        [(y, 2), (f(x), 2)]
+
+        Ordering is canonical.
+
+        >>> def vsort0(*v):
+        ...     # docstring helper to
+        ...     # change vi -> (vi, 0), sort, and return vi vals
+        ...     return [i[0] for i in vsort([(i, 0) for i in v])]
+
+        >>> vsort0(y, x)
+        [x, y]
+        >>> vsort0(g(y), g(x), f(y))
+        [f(y), g(x), g(y)]
+
+        Symbols are sorted as far to the left as possible but never
+        move to the left of a derivative having the same symbol in
+        its variables; the same applies to AppliedUndef which are
+        always sorted after Symbols:
+
+        >>> dfx = f(x).diff(x)
+        >>> assert vsort0(dfx, y) == [y, dfx]
+        >>> assert vsort0(dfx, x) == [dfx, x]
+        """
+        if not vc:
+            return []
+        vc = list(vc)
+        if len(vc) == 1:
+            return [Tuple(*vc[0])]
+        V = list(range(len(vc)))
+        E = []
+        v = lambda i: vc[i][0]
+        D = Dummy()
+        def _block(d, v, wrt=False):
+            # return True if v should not come before d else False
+            if d == v:
+                return wrt
+            if d.is_Symbol:
+                return False
+            if isinstance(d, Derivative):
+                # a derivative blocks if any of it's variables contain
+                # v; the wrt flag will return True for an exact match
+                # and will cause an AppliedUndef to block if v is in
+                # the arguments
+                if any(_block(k, v, wrt=True)
+                        for k in d._wrt_variables):
+                    return True
+                return False
+            if not wrt and isinstance(d, AppliedUndef):
+                return False
+            if v.is_Symbol:
+                return v in d.free_symbols
+            if isinstance(v, AppliedUndef):
+                return _block(d.xreplace({v: D}), D)
+            return d.free_symbols & v.free_symbols
+        for i in range(len(vc)):
+            for j in range(i):
+                if _block(v(j), v(i)):
+                    E.append((j,i))
+        # this is the default ordering to use in case of ties
+        O = dict(zip(ordered(uniq([i for i, c in vc])), range(len(vc))))
+        ix = topological_sort((V, E), key=lambda i: O[v(i)])
+        # merge counts of contiguously identical items
+        merged = []
+        for v, c in [vc[i] for i in ix]:
+            if merged and merged[-1][0] == v:
+                merged[-1][1] += c
+            else:
+                merged.append([v, c])
+        return [Tuple(*i) for i in merged]
+
+    def _eval_is_commutative(self):
+        return self.expr.is_commutative
+
+    def _eval_derivative(self, v):
+        # If v (the variable of differentiation) is not in
+        # self.variables, we might be able to take the derivative.
+        if v not in self._wrt_variables:
+            dedv = self.expr.diff(v)
+            if isinstance(dedv, Derivative):
+                return dedv.func(dedv.expr, *(self.variable_count + dedv.variable_count))
+            # dedv (d(self.expr)/dv) could have simplified things such that the
+            # derivative wrt things in self.variables can now be done. Thus,
+            # we set evaluate=True to see if there are any other derivatives
+            # that can be done. The most common case is when dedv is a simple
+            # number so that the derivative wrt anything else will vanish.
+            return self.func(dedv, *self.variables, evaluate=True)
+        # In this case v was in self.variables so the derivative wrt v has
+        # already been attempted and was not computed, either because it
+        # couldn't be or evaluate=False originally.
+        variable_count = list(self.variable_count)
+        variable_count.append((v, 1))
+        return self.func(self.expr, *variable_count, evaluate=False)
+
+    def doit(self, **hints):
+        expr = self.expr
+        if hints.get('deep', True):
+            expr = expr.doit(**hints)
+        hints['evaluate'] = True
+        rv = self.func(expr, *self.variable_count, **hints)
+        if rv!= self and rv.has(Derivative):
+            rv =  rv.doit(**hints)
+        return rv
+
+    @_sympifyit('z0', NotImplementedError)
+    def doit_numerically(self, z0):
+        """
+        Evaluate the derivative at z numerically.
+
+        When we can represent derivatives at a point, this should be folded
+        into the normal evalf. For now, we need a special method.
+        """
+        if len(self.free_symbols) != 1 or len(self.variables) != 1:
+            raise NotImplementedError('partials and higher order derivatives')
+        z = list(self.free_symbols)[0]
+
+        def eval(x):
+            f0 = self.expr.subs(z, Expr._from_mpmath(x, prec=mpmath.mp.prec))
+            f0 = f0.evalf(prec_to_dps(mpmath.mp.prec))
+            return f0._to_mpmath(mpmath.mp.prec)
+        return Expr._from_mpmath(mpmath.diff(eval,
+                                             z0._to_mpmath(mpmath.mp.prec)),
+                                 mpmath.mp.prec)
+
+    @property
+    def expr(self):
+        return self._args[0]
+
+    @property
+    def _wrt_variables(self):
+        # return the variables of differentiation without
+        # respect to the type of count (int or symbolic)
+        return [i[0] for i in self.variable_count]
+
+    @property
+    def variables(self):
+        # TODO: deprecate?  YES, make this 'enumerated_variables' and
+        #       name _wrt_variables as variables
+        # TODO: support for `d^n`?
+        rv = []
+        for v, count in self.variable_count:
+            if not count.is_Integer:
+                raise TypeError(filldedent('''
+                Cannot give expansion for symbolic count. If you just
+                want a list of all variables of differentiation, use
+                _wrt_variables.'''))
+            rv.extend([v]*count)
+        return tuple(rv)
+
+    @property
+    def variable_count(self):
+        return self._args[1:]
+
+    @property
+    def derivative_count(self):
+        return sum([count for _, count in self.variable_count], 0)
+
+    @property
+    def free_symbols(self):
+        ret = self.expr.free_symbols
+        # Add symbolic counts to free_symbols
+        for _, count in self.variable_count:
+            ret.update(count.free_symbols)
+        return ret
+
+    @property
+    def kind(self):
+        return self.args[0].kind
+
+    def _eval_subs(self, old, new):
+        # The substitution (old, new) cannot be done inside
+        # Derivative(expr, vars) for a variety of reasons
+        # as handled below.
+        if old in self._wrt_variables:
+            # first handle the counts
+            expr = self.func(self.expr, *[(v, c.subs(old, new))
+                for v, c in self.variable_count])
+            if expr != self:
+                return expr._eval_subs(old, new)
+            # quick exit case
+            if not getattr(new, '_diff_wrt', False):
+                # case (0): new is not a valid variable of
+                # differentiation
+                if isinstance(old, Symbol):
+                    # don't introduce a new symbol if the old will do
+                    return Subs(self, old, new)
+                else:
+                    xi = Dummy('xi')
+                    return Subs(self.xreplace({old: xi}), xi, new)
+
+        # If both are Derivatives with the same expr, check if old is
+        # equivalent to self or if old is a subderivative of self.
+        if old.is_Derivative and old.expr == self.expr:
+            if self.canonical == old.canonical:
+                return new
+
+            # collections.Counter doesn't have __le__
+            def _subset(a, b):
+                return all((a[i] <= b[i]) == True for i in a)
+
+            old_vars = Counter(dict(reversed(old.variable_count)))
+            self_vars = Counter(dict(reversed(self.variable_count)))
+            if _subset(old_vars, self_vars):
+                return _derivative_dispatch(new, *(self_vars - old_vars).items()).canonical
+
+        args = list(self.args)
+        newargs = [x._subs(old, new) for x in args]
+        if args[0] == old:
+            # complete replacement of self.expr
+            # we already checked that the new is valid so we know
+            # it won't be a problem should it appear in variables
+            return _derivative_dispatch(*newargs)
+
+        if newargs[0] != args[0]:
+            # case (1) can't change expr by introducing something that is in
+            # the _wrt_variables if it was already in the expr
+            # e.g.
+            # for Derivative(f(x, g(y)), y), x cannot be replaced with
+            # anything that has y in it; for f(g(x), g(y)).diff(g(y))
+            # g(x) cannot be replaced with anything that has g(y)
+            syms = {vi: Dummy() for vi in self._wrt_variables
+                if not vi.is_Symbol}
+            wrt = {syms.get(vi, vi) for vi in self._wrt_variables}
+            forbidden = args[0].xreplace(syms).free_symbols & wrt
+            nfree = new.xreplace(syms).free_symbols
+            ofree = old.xreplace(syms).free_symbols
+            if (nfree - ofree) & forbidden:
+                return Subs(self, old, new)
+
+        viter = ((i, j) for ((i, _), (j, _)) in zip(newargs[1:], args[1:]))
+        if any(i != j for i, j in viter):  # a wrt-variable change
+            # case (2) can't change vars by introducing a variable
+            # that is contained in expr, e.g.
+            # for Derivative(f(z, g(h(x), y)), y), y cannot be changed to
+            # x, h(x), or g(h(x), y)
+            for a in _atomic(self.expr, recursive=True):
+                for i in range(1, len(newargs)):
+                    vi, _ = newargs[i]
+                    if a == vi and vi != args[i][0]:
+                        return Subs(self, old, new)
+            # more arg-wise checks
+            vc = newargs[1:]
+            oldv = self._wrt_variables
+            newe = self.expr
+            subs = []
+            for i, (vi, ci) in enumerate(vc):
+                if not vi._diff_wrt:
+                    # case (3) invalid differentiation expression so
+                    # create a replacement dummy
+                    xi = Dummy('xi_%i' % i)
+                    # replace the old valid variable with the dummy
+                    # in the expression
+                    newe = newe.xreplace({oldv[i]: xi})
+                    # and replace the bad variable with the dummy
+                    vc[i] = (xi, ci)
+                    # and record the dummy with the new (invalid)
+                    # differentiation expression
+                    subs.append((xi, vi))
+
+            if subs:
+                # handle any residual substitution in the expression
+                newe = newe._subs(old, new)
+                # return the Subs-wrapped derivative
+                return Subs(Derivative(newe, *vc), *zip(*subs))
+
+        # everything was ok
+        return _derivative_dispatch(*newargs)
+
+    def _eval_lseries(self, x, logx, cdir=0):
+        dx = self.variables
+        for term in self.expr.lseries(x, logx=logx, cdir=cdir):
+            yield self.func(term, *dx)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.expr.nseries(x, n=n, logx=logx)
+        o = arg.getO()
+        dx = self.variables
+        rv = [self.func(a, *dx) for a in Add.make_args(arg.removeO())]
+        if o:
+            rv.append(o/x)
+        return Add(*rv)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        series_gen = self.expr.lseries(x)
+        d = S.Zero
+        for leading_term in series_gen:
+            d = diff(leading_term, *self.variables)
+            if d != 0:
+                break
+        return d
+
+    def as_finite_difference(self, points=1, x0=None, wrt=None):
+        """ Expresses a Derivative instance as a finite difference.
+
+        Parameters
+        ==========
+
+        points : sequence or coefficient, optional
+            If sequence: discrete values (length >= order+1) of the
+            independent variable used for generating the finite
+            difference weights.
+            If it is a coefficient, it will be used as the step-size
+            for generating an equidistant sequence of length order+1
+            centered around ``x0``. Default: 1 (step-size 1)
+
+        x0 : number or Symbol, optional
+            the value of the independent variable (``wrt``) at which the
+            derivative is to be approximated. Default: same as ``wrt``.
+
+        wrt : Symbol, optional
+            "with respect to" the variable for which the (partial)
+            derivative is to be approximated for. If not provided it
+            is required that the derivative is ordinary. Default: ``None``.
+
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Function, exp, sqrt, Symbol
+        >>> x, h = symbols('x h')
+        >>> f = Function('f')
+        >>> f(x).diff(x).as_finite_difference()
+        -f(x - 1/2) + f(x + 1/2)
+
+        The default step size and number of points are 1 and
+        ``order + 1`` respectively. We can change the step size by
+        passing a symbol as a parameter:
+
+        >>> f(x).diff(x).as_finite_difference(h)
+        -f(-h/2 + x)/h + f(h/2 + x)/h
+
+        We can also specify the discretized values to be used in a
+        sequence:
+
+        >>> f(x).diff(x).as_finite_difference([x, x+h, x+2*h])
+        -3*f(x)/(2*h) + 2*f(h + x)/h - f(2*h + x)/(2*h)
+
+        The algorithm is not restricted to use equidistant spacing, nor
+        do we need to make the approximation around ``x0``, but we can get
+        an expression estimating the derivative at an offset:
+
+        >>> e, sq2 = exp(1), sqrt(2)
+        >>> xl = [x-h, x+h, x+e*h]
+        >>> f(x).diff(x, 1).as_finite_difference(xl, x+h*sq2)  # doctest: +ELLIPSIS
+        2*h*((h + sqrt(2)*h)/(2*h) - (-sqrt(2)*h + h)/(2*h))*f(E*h + x)/...
+
+        To approximate ``Derivative`` around ``x0`` using a non-equidistant
+        spacing step, the algorithm supports assignment of undefined
+        functions to ``points``:
+
+        >>> dx = Function('dx')
+        >>> f(x).diff(x).as_finite_difference(points=dx(x), x0=x-h)
+        -f(-h + x - dx(-h + x)/2)/dx(-h + x) + f(-h + x + dx(-h + x)/2)/dx(-h + x)
+
+        Partial derivatives are also supported:
+
+        >>> y = Symbol('y')
+        >>> d2fdxdy=f(x,y).diff(x,y)
+        >>> d2fdxdy.as_finite_difference(wrt=x)
+        -Derivative(f(x - 1/2, y), y) + Derivative(f(x + 1/2, y), y)
+
+        We can apply ``as_finite_difference`` to ``Derivative`` instances in
+        compound expressions using ``replace``:
+
+        >>> (1 + 42**f(x).diff(x)).replace(lambda arg: arg.is_Derivative,
+        ...     lambda arg: arg.as_finite_difference())
+        42**(-f(x - 1/2) + f(x + 1/2)) + 1
+
+
+        See also
+        ========
+
+        sympy.calculus.finite_diff.apply_finite_diff
+        sympy.calculus.finite_diff.differentiate_finite
+        sympy.calculus.finite_diff.finite_diff_weights
+
+        """
+        from sympy.calculus.finite_diff import _as_finite_diff
+        return _as_finite_diff(self, points, x0, wrt)
+
+    @classmethod
+    def _get_zero_with_shape_like(cls, expr):
+        return S.Zero
+
+    @classmethod
+    def _dispatch_eval_derivative_n_times(cls, expr, v, count):
+        # Evaluate the derivative `n` times.  If
+        # `_eval_derivative_n_times` is not overridden by the current
+        # object, the default in `Basic` will call a loop over
+        # `_eval_derivative`:
+        return expr._eval_derivative_n_times(v, count)
+
+
+def _derivative_dispatch(expr, *variables, **kwargs):
+    from sympy.matrices.matrixbase import MatrixBase
+    from sympy.matrices.expressions.matexpr import MatrixExpr
+    from sympy.tensor.array import NDimArray
+    array_types = (MatrixBase, MatrixExpr, NDimArray, list, tuple, Tuple)
+    if isinstance(expr, array_types) or any(isinstance(i[0], array_types) if isinstance(i, (tuple, list, Tuple)) else isinstance(i, array_types) for i in variables):
+        from sympy.tensor.array.array_derivatives import ArrayDerivative
+        return ArrayDerivative(expr, *variables, **kwargs)
+    return Derivative(expr, *variables, **kwargs)
+
+
+class Lambda(Expr):
+    """
+    Lambda(x, expr) represents a lambda function similar to Python's
+    'lambda x: expr'. A function of several variables is written as
+    Lambda((x, y, ...), expr).
+
+    Examples
+    ========
+
+    A simple example:
+
+    >>> from sympy import Lambda
+    >>> from sympy.abc import x
+    >>> f = Lambda(x, x**2)
+    >>> f(4)
+    16
+
+    For multivariate functions, use:
+
+    >>> from sympy.abc import y, z, t
+    >>> f2 = Lambda((x, y, z, t), x + y**z + t**z)
+    >>> f2(1, 2, 3, 4)
+    73
+
+    It is also possible to unpack tuple arguments:
+
+    >>> f = Lambda(((x, y), z), x + y + z)
+    >>> f((1, 2), 3)
+    6
+
+    A handy shortcut for lots of arguments:
+
+    >>> p = x, y, z
+    >>> f = Lambda(p, x + y*z)
+    >>> f(*p)
+    x + y*z
+
+    """
+    is_Function = True
+
+    def __new__(cls, signature, expr) -> Lambda:
+        if iterable(signature) and not isinstance(signature, (tuple, Tuple)):
+            sympy_deprecation_warning(
+                """
+                Using a non-tuple iterable as the first argument to Lambda
+                is deprecated. Use Lambda(tuple(args), expr) instead.
+                """,
+                deprecated_since_version="1.5",
+                active_deprecations_target="deprecated-non-tuple-lambda",
+            )
+            signature = tuple(signature)
+        _sig = signature if iterable(signature) else (signature,)
+        sig: Tuple = sympify(_sig) # type: ignore
+        cls._check_signature(sig)
+
+        if len(sig) == 1 and sig[0] == expr:
+            return S.IdentityFunction
+
+        return Expr.__new__(cls, sig, sympify(expr))
+
+    @classmethod
+    def _check_signature(cls, sig):
+        syms = set()
+
+        def rcheck(args):
+            for a in args:
+                if a.is_symbol:
+                    if a in syms:
+                        raise BadSignatureError("Duplicate symbol %s" % a)
+                    syms.add(a)
+                elif isinstance(a, Tuple):
+                    rcheck(a)
+                else:
+                    raise BadSignatureError("Lambda signature should be only tuples"
+                        " and symbols, not %s" % a)
+
+        if not isinstance(sig, Tuple):
+            raise BadSignatureError("Lambda signature should be a tuple not %s" % sig)
+        # Recurse through the signature:
+        rcheck(sig)
+
+    @property
+    def signature(self):
+        """The expected form of the arguments to be unpacked into variables"""
+        return self._args[0]
+
+    @property
+    def expr(self):
+        """The return value of the function"""
+        return self._args[1]
+
+    @property
+    def variables(self):
+        """The variables used in the internal representation of the function"""
+        def _variables(args):
+            if isinstance(args, Tuple):
+                for arg in args:
+                    yield from _variables(arg)
+            else:
+                yield args
+        return tuple(_variables(self.signature))
+
+    @property
+    def nargs(self):
+        from sympy.sets.sets import FiniteSet
+        return FiniteSet(len(self.signature))
+
+    bound_symbols = variables
+
+    @property
+    def free_symbols(self):
+        return self.expr.free_symbols - set(self.variables)
+
+    def __call__(self, *args):
+        n = len(args)
+        if n not in self.nargs:  # Lambda only ever has 1 value in nargs
+            # XXX: exception message must be in exactly this format to
+            # make it work with NumPy's functions like vectorize(). See,
+            # for example, https://github.com/numpy/numpy/issues/1697.
+            # The ideal solution would be just to attach metadata to
+            # the exception and change NumPy to take advantage of this.
+            ## XXX does this apply to Lambda? If not, remove this comment.
+            temp = ('%(name)s takes exactly %(args)s '
+                   'argument%(plural)s (%(given)s given)')
+            raise BadArgumentsError(temp % {
+                'name': self,
+                'args': list(self.nargs)[0],
+                'plural': 's'*(list(self.nargs)[0] != 1),
+                'given': n})
+
+        d = self._match_signature(self.signature, args)
+
+        return self.expr.xreplace(d)
+
+    def _match_signature(self, sig, args):
+
+        symargmap = {}
+
+        def rmatch(pars, args):
+            for par, arg in zip(pars, args):
+                if par.is_symbol:
+                    symargmap[par] = arg
+                elif isinstance(par, Tuple):
+                    if not isinstance(arg, (tuple, Tuple)) or len(args) != len(pars):
+                        raise BadArgumentsError("Can't match %s and %s" % (args, pars))
+                    rmatch(par, arg)
+
+        rmatch(sig, args)
+
+        return symargmap
+
+    @property
+    def is_identity(self):
+        """Return ``True`` if this ``Lambda`` is an identity function. """
+        return self.signature == self.expr
+
+    def _eval_evalf(self, prec):
+        return self.func(self.args[0], self.args[1].evalf(n=prec_to_dps(prec)))
+
+
+class Subs(Expr):
+    """
+    Represents unevaluated substitutions of an expression.
+
+    ``Subs(expr, x, x0)`` represents the expression resulting
+    from substituting x with x0 in expr.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        An expression.
+
+    x : tuple, variable
+        A variable or list of distinct variables.
+
+    x0 : tuple or list of tuples
+        A point or list of evaluation points
+        corresponding to those variables.
+
+    Examples
+    ========
+
+    >>> from sympy import Subs, Function, sin, cos
+    >>> from sympy.abc import x, y, z
+    >>> f = Function('f')
+
+    Subs are created when a particular substitution cannot be made. The
+    x in the derivative cannot be replaced with 0 because 0 is not a
+    valid variables of differentiation:
+
+    >>> f(x).diff(x).subs(x, 0)
+    Subs(Derivative(f(x), x), x, 0)
+
+    Once f is known, the derivative and evaluation at 0 can be done:
+
+    >>> _.subs(f, sin).doit() == sin(x).diff(x).subs(x, 0) == cos(0)
+    True
+
+    Subs can also be created directly with one or more variables:
+
+    >>> Subs(f(x)*sin(y) + z, (x, y), (0, 1))
+    Subs(z + f(x)*sin(y), (x, y), (0, 1))
+    >>> _.doit()
+    z + f(0)*sin(1)
+
+    Notes
+    =====
+
+    ``Subs`` objects are generally useful to represent unevaluated derivatives
+    calculated at a point.
+
+    The variables may be expressions, but they are subjected to the limitations
+    of subs(), so it is usually a good practice to use only symbols for
+    variables, since in that case there can be no ambiguity.
+
+    There's no automatic expansion - use the method .doit() to effect all
+    possible substitutions of the object and also of objects inside the
+    expression.
+
+    When evaluating derivatives at a point that is not a symbol, a Subs object
+    is returned. One is also able to calculate derivatives of Subs objects - in
+    this case the expression is always expanded (for the unevaluated form, use
+    Derivative()).
+
+    In order to allow expressions to combine before doit is done, a
+    representation of the Subs expression is used internally to make
+    expressions that are superficially different compare the same:
+
+    >>> a, b = Subs(x, x, 0), Subs(y, y, 0)
+    >>> a + b
+    2*Subs(x, x, 0)
+
+    This can lead to unexpected consequences when using methods
+    like `has` that are cached:
+
+    >>> s = Subs(x, x, 0)
+    >>> s.has(x), s.has(y)
+    (True, False)
+    >>> ss = s.subs(x, y)
+    >>> ss.has(x), ss.has(y)
+    (True, False)
+    >>> s, ss
+    (Subs(x, x, 0), Subs(y, y, 0))
+    """
+    def __new__(cls, expr, variables, point, **assumptions):
+        if not is_sequence(variables, Tuple):
+            variables = [variables]
+        variables = Tuple(*variables)
+
+        if has_dups(variables):
+            repeated = [str(v) for v, i in Counter(variables).items() if i > 1]
+            __ = ', '.join(repeated)
+            raise ValueError(filldedent('''
+                The following expressions appear more than once: %s
+                ''' % __))
+
+        point = Tuple(*(point if is_sequence(point, Tuple) else [point]))
+
+        if len(point) != len(variables):
+            raise ValueError('Number of point values must be the same as '
+                             'the number of variables.')
+
+        if not point:
+            return sympify(expr)
+
+        # denest
+        if isinstance(expr, Subs):
+            variables = expr.variables + variables
+            point = expr.point + point
+            expr = expr.expr
+        else:
+            expr = sympify(expr)
+
+        # use symbols with names equal to the point value (with prepended _)
+        # to give a variable-independent expression
+        pre = "_"
+        pts = sorted(set(point), key=default_sort_key)
+        from sympy.printing.str import StrPrinter
+        class CustomStrPrinter(StrPrinter):
+            def _print_Dummy(self, expr):
+                return str(expr) + str(expr.dummy_index)
+        def mystr(expr, **settings):
+            p = CustomStrPrinter(settings)
+            return p.doprint(expr)
+        while 1:
+            s_pts = {p: Symbol(pre + mystr(p)) for p in pts}
+            reps = [(v, s_pts[p])
+                for v, p in zip(variables, point)]
+            # if any underscore-prepended symbol is already a free symbol
+            # and is a variable with a different point value, then there
+            # is a clash, e.g. _0 clashes in Subs(_0 + _1, (_0, _1), (1, 0))
+            # because the new symbol that would be created is _1 but _1
+            # is already mapped to 0 so __0 and __1 are used for the new
+            # symbols
+            if any(r in expr.free_symbols and
+                   r in variables and
+                   Symbol(pre + mystr(point[variables.index(r)])) != r
+                   for _, r in reps):
+                pre += "_"
+                continue
+            break
+
+        obj = Expr.__new__(cls, expr, Tuple(*variables), point)
+        obj._expr = expr.xreplace(dict(reps))
+        return obj
+
+    def _eval_is_commutative(self):
+        return self.expr.is_commutative
+
+    def doit(self, **hints):
+        e, v, p = self.args
+
+        # remove self mappings
+        for i, (vi, pi) in enumerate(zip(v, p)):
+            if vi == pi:
+                v = v[:i] + v[i + 1:]
+                p = p[:i] + p[i + 1:]
+        if not v:
+            return self.expr
+
+        if isinstance(e, Derivative):
+            # apply functions first, e.g. f -> cos
+            undone = []
+            for i, vi in enumerate(v):
+                if isinstance(vi, FunctionClass):
+                    e = e.subs(vi, p[i])
+                else:
+                    undone.append((vi, p[i]))
+            if not isinstance(e, Derivative):
+                e = e.doit()
+            if isinstance(e, Derivative):
+                # do Subs that aren't related to differentiation
+                undone2 = []
+                D = Dummy()
+                arg = e.args[0]
+                for vi, pi in undone:
+                    if D not in e.xreplace({vi: D}).free_symbols:
+                        if arg.has(vi):
+                            e = e.subs(vi, pi)
+                    else:
+                        undone2.append((vi, pi))
+                undone = undone2
+                # differentiate wrt variables that are present
+                wrt = []
+                D = Dummy()
+                expr = e.expr
+                free = expr.free_symbols
+                for vi, ci in e.variable_count:
+                    if isinstance(vi, Symbol) and vi in free:
+                        expr = expr.diff((vi, ci))
+                    elif D in expr.subs(vi, D).free_symbols:
+                        expr = expr.diff((vi, ci))
+                    else:
+                        wrt.append((vi, ci))
+                # inject remaining subs
+                rv = expr.subs(undone)
+                # do remaining differentiation *in order given*
+                for vc in wrt:
+                    rv = rv.diff(vc)
+            else:
+                # inject remaining subs
+                rv = e.subs(undone)
+        else:
+            rv = e.doit(**hints).subs(list(zip(v, p)))
+
+        if hints.get('deep', True) and rv != self:
+            rv = rv.doit(**hints)
+        return rv
+
+    def evalf(self, prec=None, **options):
+        return self.doit().evalf(prec, **options)
+
+    n = evalf  # type:ignore
+
+    @property
+    def variables(self):
+        """The variables to be evaluated"""
+        return self._args[1]
+
+    bound_symbols = variables
+
+    @property
+    def expr(self):
+        """The expression on which the substitution operates"""
+        return self._args[0]
+
+    @property
+    def point(self):
+        """The values for which the variables are to be substituted"""
+        return self._args[2]
+
+    @property
+    def free_symbols(self):
+        return (self.expr.free_symbols - set(self.variables) |
+            set(self.point.free_symbols))
+
+    @property
+    def expr_free_symbols(self):
+        sympy_deprecation_warning("""
+        The expr_free_symbols property is deprecated. Use free_symbols to get
+        the free symbols of an expression.
+        """,
+            deprecated_since_version="1.9",
+            active_deprecations_target="deprecated-expr-free-symbols")
+        # Don't show the warning twice from the recursive call
+        with ignore_warnings(SymPyDeprecationWarning):
+            return (self.expr.expr_free_symbols - set(self.variables) |
+                    set(self.point.expr_free_symbols))
+
+    def __eq__(self, other):
+        if not isinstance(other, Subs):
+            return False
+        return self._hashable_content() == other._hashable_content()
+
+    def __ne__(self, other):
+        return not(self == other)
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def _hashable_content(self):
+        return (self._expr.xreplace(self.canonical_variables),
+            ) + tuple(ordered([(v, p) for v, p in
+            zip(self.variables, self.point) if not self.expr.has(v)]))
+
+    def _eval_subs(self, old, new):
+        # Subs doit will do the variables in order; the semantics
+        # of subs for Subs is have the following invariant for
+        # Subs object foo:
+        #    foo.doit().subs(reps) == foo.subs(reps).doit()
+        pt = list(self.point)
+        if old in self.variables:
+            if _atomic(new) == {new} and not any(
+                    i.has(new) for i in self.args):
+                # the substitution is neutral
+                return self.xreplace({old: new})
+            # any occurrence of old before this point will get
+            # handled by replacements from here on
+            i = self.variables.index(old)
+            for j in range(i, len(self.variables)):
+                pt[j] = pt[j]._subs(old, new)
+            return self.func(self.expr, self.variables, pt)
+        v = [i._subs(old, new) for i in self.variables]
+        if v != list(self.variables):
+            return self.func(self.expr, self.variables + (old,), pt + [new])
+        expr = self.expr._subs(old, new)
+        pt = [i._subs(old, new) for i in self.point]
+        return self.func(expr, v, pt)
+
+    def _eval_derivative(self, s):
+        # Apply the chain rule of the derivative on the substitution variables:
+        f = self.expr
+        vp = V, P = self.variables, self.point
+        val = Add.fromiter(p.diff(s)*Subs(f.diff(v), *vp).doit()
+            for v, p in zip(V, P))
+
+        # these are all the free symbols in the expr
+        efree = f.free_symbols
+        # some symbols like IndexedBase include themselves and args
+        # as free symbols
+        compound = {i for i in efree if len(i.free_symbols) > 1}
+        # hide them and see what independent free symbols remain
+        dums = {Dummy() for i in compound}
+        masked = f.xreplace(dict(zip(compound, dums)))
+        ifree = masked.free_symbols - dums
+        # include the compound symbols
+        free = ifree | compound
+        # remove the variables already handled
+        free -= set(V)
+        # add back any free symbols of remaining compound symbols
+        free |= {i for j in free & compound for i in j.free_symbols}
+        # if symbols of s are in free then there is more to do
+        if free & s.free_symbols:
+            val += Subs(f.diff(s), self.variables, self.point).doit()
+        return val
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if x in self.point:
+            # x is the variable being substituted into
+            apos = self.point.index(x)
+            other = self.variables[apos]
+        else:
+            other = x
+        arg = self.expr.nseries(other, n=n, logx=logx)
+        o = arg.getO()
+        terms = Add.make_args(arg.removeO())
+        rv = Add(*[self.func(a, *self.args[1:]) for a in terms])
+        if o:
+            rv += o.subs(other, x)
+        return rv
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        if x in self.point:
+            ipos = self.point.index(x)
+            xvar = self.variables[ipos]
+            return self.expr.as_leading_term(xvar)
+        if x in self.variables:
+            # if `x` is a dummy variable, it means it won't exist after the
+            # substitution has been performed:
+            return self
+        # The variable is independent of the substitution:
+        return self.expr.as_leading_term(x)
+
+
+def diff(f, *symbols, **kwargs):
+    """
+    Differentiate f with respect to symbols.
+
+    Explanation
+    ===========
+
+    This is just a wrapper to unify .diff() and the Derivative class; its
+    interface is similar to that of integrate().  You can use the same
+    shortcuts for multiple variables as with Derivative.  For example,
+    diff(f(x), x, x, x) and diff(f(x), x, 3) both return the third derivative
+    of f(x).
+
+    You can pass evaluate=False to get an unevaluated Derivative class.  Note
+    that if there are 0 symbols (such as diff(f(x), x, 0), then the result will
+    be the function (the zeroth derivative), even if evaluate=False.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, cos, Function, diff
+    >>> from sympy.abc import x, y
+    >>> f = Function('f')
+
+    >>> diff(sin(x), x)
+    cos(x)
+    >>> diff(f(x), x, x, x)
+    Derivative(f(x), (x, 3))
+    >>> diff(f(x), x, 3)
+    Derivative(f(x), (x, 3))
+    >>> diff(sin(x)*cos(y), x, 2, y, 2)
+    sin(x)*cos(y)
+
+    >>> type(diff(sin(x), x))
+    cos
+    >>> type(diff(sin(x), x, evaluate=False))
+    
+    >>> type(diff(sin(x), x, 0))
+    sin
+    >>> type(diff(sin(x), x, 0, evaluate=False))
+    sin
+
+    >>> diff(sin(x))
+    cos(x)
+    >>> diff(sin(x*y))
+    Traceback (most recent call last):
+    ...
+    ValueError: specify differentiation variables to differentiate sin(x*y)
+
+    Note that ``diff(sin(x))`` syntax is meant only for convenience
+    in interactive sessions and should be avoided in library code.
+
+    References
+    ==========
+
+    .. [1] https://reference.wolfram.com/legacy/v5_2/Built-inFunctions/AlgebraicComputation/Calculus/D.html
+
+    See Also
+    ========
+
+    Derivative
+    idiff: computes the derivative implicitly
+
+    """
+    if hasattr(f, 'diff'):
+        return f.diff(*symbols, **kwargs)
+    kwargs.setdefault('evaluate', True)
+    return _derivative_dispatch(f, *symbols, **kwargs)
+
+
+def expand(e, deep=True, modulus=None, power_base=True, power_exp=True,
+        mul=True, log=True, multinomial=True, basic=True, **hints):
+    r"""
+    Expand an expression using methods given as hints.
+
+    Explanation
+    ===========
+
+    Hints evaluated unless explicitly set to False are:  ``basic``, ``log``,
+    ``multinomial``, ``mul``, ``power_base``, and ``power_exp`` The following
+    hints are supported but not applied unless set to True:  ``complex``,
+    ``func``, and ``trig``.  In addition, the following meta-hints are
+    supported by some or all of the other hints:  ``frac``, ``numer``,
+    ``denom``, ``modulus``, and ``force``.  ``deep`` is supported by all
+    hints.  Additionally, subclasses of Expr may define their own hints or
+    meta-hints.
+
+    The ``basic`` hint is used for any special rewriting of an object that
+    should be done automatically (along with the other hints like ``mul``)
+    when expand is called. This is a catch-all hint to handle any sort of
+    expansion that may not be described by the existing hint names. To use
+    this hint an object should override the ``_eval_expand_basic`` method.
+    Objects may also define their own expand methods, which are not run by
+    default.  See the API section below.
+
+    If ``deep`` is set to ``True`` (the default), things like arguments of
+    functions are recursively expanded.  Use ``deep=False`` to only expand on
+    the top level.
+
+    If the ``force`` hint is used, assumptions about variables will be ignored
+    in making the expansion.
+
+    Hints
+    =====
+
+    These hints are run by default
+
+    mul
+    ---
+
+    Distributes multiplication over addition:
+
+    >>> from sympy import cos, exp, sin
+    >>> from sympy.abc import x, y, z
+    >>> (y*(x + z)).expand(mul=True)
+    x*y + y*z
+
+    multinomial
+    -----------
+
+    Expand (x + y + ...)**n where n is a positive integer.
+
+    >>> ((x + y + z)**2).expand(multinomial=True)
+    x**2 + 2*x*y + 2*x*z + y**2 + 2*y*z + z**2
+
+    power_exp
+    ---------
+
+    Expand addition in exponents into multiplied bases.
+
+    >>> exp(x + y).expand(power_exp=True)
+    exp(x)*exp(y)
+    >>> (2**(x + y)).expand(power_exp=True)
+    2**x*2**y
+
+    power_base
+    ----------
+
+    Split powers of multiplied bases.
+
+    This only happens by default if assumptions allow, or if the
+    ``force`` meta-hint is used:
+
+    >>> ((x*y)**z).expand(power_base=True)
+    (x*y)**z
+    >>> ((x*y)**z).expand(power_base=True, force=True)
+    x**z*y**z
+    >>> ((2*y)**z).expand(power_base=True)
+    2**z*y**z
+
+    Note that in some cases where this expansion always holds, SymPy performs
+    it automatically:
+
+    >>> (x*y)**2
+    x**2*y**2
+
+    log
+    ---
+
+    Pull out power of an argument as a coefficient and split logs products
+    into sums of logs.
+
+    Note that these only work if the arguments of the log function have the
+    proper assumptions--the arguments must be positive and the exponents must
+    be real--or else the ``force`` hint must be True:
+
+    >>> from sympy import log, symbols
+    >>> log(x**2*y).expand(log=True)
+    log(x**2*y)
+    >>> log(x**2*y).expand(log=True, force=True)
+    2*log(x) + log(y)
+    >>> x, y = symbols('x,y', positive=True)
+    >>> log(x**2*y).expand(log=True)
+    2*log(x) + log(y)
+
+    basic
+    -----
+
+    This hint is intended primarily as a way for custom subclasses to enable
+    expansion by default.
+
+    These hints are not run by default:
+
+    complex
+    -------
+
+    Split an expression into real and imaginary parts.
+
+    >>> x, y = symbols('x,y')
+    >>> (x + y).expand(complex=True)
+    re(x) + re(y) + I*im(x) + I*im(y)
+    >>> cos(x).expand(complex=True)
+    -I*sin(re(x))*sinh(im(x)) + cos(re(x))*cosh(im(x))
+
+    Note that this is just a wrapper around ``as_real_imag()``.  Most objects
+    that wish to redefine ``_eval_expand_complex()`` should consider
+    redefining ``as_real_imag()`` instead.
+
+    func
+    ----
+
+    Expand other functions.
+
+    >>> from sympy import gamma
+    >>> gamma(x + 1).expand(func=True)
+    x*gamma(x)
+
+    trig
+    ----
+
+    Do trigonometric expansions.
+
+    >>> cos(x + y).expand(trig=True)
+    -sin(x)*sin(y) + cos(x)*cos(y)
+    >>> sin(2*x).expand(trig=True)
+    2*sin(x)*cos(x)
+
+    Note that the forms of ``sin(n*x)`` and ``cos(n*x)`` in terms of ``sin(x)``
+    and ``cos(x)`` are not unique, due to the identity `\sin^2(x) + \cos^2(x)
+    = 1`.  The current implementation uses the form obtained from Chebyshev
+    polynomials, but this may change.  See `this MathWorld article
+    `_ for more
+    information.
+
+    Notes
+    =====
+
+    - You can shut off unwanted methods::
+
+        >>> (exp(x + y)*(x + y)).expand()
+        x*exp(x)*exp(y) + y*exp(x)*exp(y)
+        >>> (exp(x + y)*(x + y)).expand(power_exp=False)
+        x*exp(x + y) + y*exp(x + y)
+        >>> (exp(x + y)*(x + y)).expand(mul=False)
+        (x + y)*exp(x)*exp(y)
+
+    - Use deep=False to only expand on the top level::
+
+        >>> exp(x + exp(x + y)).expand()
+        exp(x)*exp(exp(x)*exp(y))
+        >>> exp(x + exp(x + y)).expand(deep=False)
+        exp(x)*exp(exp(x + y))
+
+    - Hints are applied in an arbitrary, but consistent order (in the current
+      implementation, they are applied in alphabetical order, except
+      multinomial comes before mul, but this may change).  Because of this,
+      some hints may prevent expansion by other hints if they are applied
+      first. For example, ``mul`` may distribute multiplications and prevent
+      ``log`` and ``power_base`` from expanding them. Also, if ``mul`` is
+      applied before ``multinomial`, the expression might not be fully
+      distributed. The solution is to use the various ``expand_hint`` helper
+      functions or to use ``hint=False`` to this function to finely control
+      which hints are applied. Here are some examples::
+
+        >>> from sympy import expand, expand_mul, expand_power_base
+        >>> x, y, z = symbols('x,y,z', positive=True)
+
+        >>> expand(log(x*(y + z)))
+        log(x) + log(y + z)
+
+      Here, we see that ``log`` was applied before ``mul``.  To get the mul
+      expanded form, either of the following will work::
+
+        >>> expand_mul(log(x*(y + z)))
+        log(x*y + x*z)
+        >>> expand(log(x*(y + z)), log=False)
+        log(x*y + x*z)
+
+      A similar thing can happen with the ``power_base`` hint::
+
+        >>> expand((x*(y + z))**x)
+        (x*y + x*z)**x
+
+      To get the ``power_base`` expanded form, either of the following will
+      work::
+
+        >>> expand((x*(y + z))**x, mul=False)
+        x**x*(y + z)**x
+        >>> expand_power_base((x*(y + z))**x)
+        x**x*(y + z)**x
+
+        >>> expand((x + y)*y/x)
+        y + y**2/x
+
+      The parts of a rational expression can be targeted::
+
+        >>> expand((x + y)*y/x/(x + 1), frac=True)
+        (x*y + y**2)/(x**2 + x)
+        >>> expand((x + y)*y/x/(x + 1), numer=True)
+        (x*y + y**2)/(x*(x + 1))
+        >>> expand((x + y)*y/x/(x + 1), denom=True)
+        y*(x + y)/(x**2 + x)
+
+    - The ``modulus`` meta-hint can be used to reduce the coefficients of an
+      expression post-expansion::
+
+        >>> expand((3*x + 1)**2)
+        9*x**2 + 6*x + 1
+        >>> expand((3*x + 1)**2, modulus=5)
+        4*x**2 + x + 1
+
+    - Either ``expand()`` the function or ``.expand()`` the method can be
+      used.  Both are equivalent::
+
+        >>> expand((x + 1)**2)
+        x**2 + 2*x + 1
+        >>> ((x + 1)**2).expand()
+        x**2 + 2*x + 1
+
+    API
+    ===
+
+    Objects can define their own expand hints by defining
+    ``_eval_expand_hint()``.  The function should take the form::
+
+        def _eval_expand_hint(self, **hints):
+            # Only apply the method to the top-level expression
+            ...
+
+    See also the example below.  Objects should define ``_eval_expand_hint()``
+    methods only if ``hint`` applies to that specific object.  The generic
+    ``_eval_expand_hint()`` method defined in Expr will handle the no-op case.
+
+    Each hint should be responsible for expanding that hint only.
+    Furthermore, the expansion should be applied to the top-level expression
+    only.  ``expand()`` takes care of the recursion that happens when
+    ``deep=True``.
+
+    You should only call ``_eval_expand_hint()`` methods directly if you are
+    100% sure that the object has the method, as otherwise you are liable to
+    get unexpected ``AttributeError``s.  Note, again, that you do not need to
+    recursively apply the hint to args of your object: this is handled
+    automatically by ``expand()``.  ``_eval_expand_hint()`` should
+    generally not be used at all outside of an ``_eval_expand_hint()`` method.
+    If you want to apply a specific expansion from within another method, use
+    the public ``expand()`` function, method, or ``expand_hint()`` functions.
+
+    In order for expand to work, objects must be rebuildable by their args,
+    i.e., ``obj.func(*obj.args) == obj`` must hold.
+
+    Expand methods are passed ``**hints`` so that expand hints may use
+    'metahints'--hints that control how different expand methods are applied.
+    For example, the ``force=True`` hint described above that causes
+    ``expand(log=True)`` to ignore assumptions is such a metahint.  The
+    ``deep`` meta-hint is handled exclusively by ``expand()`` and is not
+    passed to ``_eval_expand_hint()`` methods.
+
+    Note that expansion hints should generally be methods that perform some
+    kind of 'expansion'.  For hints that simply rewrite an expression, use the
+    .rewrite() API.
+
+    Examples
+    ========
+
+    >>> from sympy import Expr, sympify
+    >>> class MyClass(Expr):
+    ...     def __new__(cls, *args):
+    ...         args = sympify(args)
+    ...         return Expr.__new__(cls, *args)
+    ...
+    ...     def _eval_expand_double(self, *, force=False, **hints):
+    ...         '''
+    ...         Doubles the args of MyClass.
+    ...
+    ...         If there more than four args, doubling is not performed,
+    ...         unless force=True is also used (False by default).
+    ...         '''
+    ...         if not force and len(self.args) > 4:
+    ...             return self
+    ...         return self.func(*(self.args + self.args))
+    ...
+    >>> a = MyClass(1, 2, MyClass(3, 4))
+    >>> a
+    MyClass(1, 2, MyClass(3, 4))
+    >>> a.expand(double=True)
+    MyClass(1, 2, MyClass(3, 4, 3, 4), 1, 2, MyClass(3, 4, 3, 4))
+    >>> a.expand(double=True, deep=False)
+    MyClass(1, 2, MyClass(3, 4), 1, 2, MyClass(3, 4))
+
+    >>> b = MyClass(1, 2, 3, 4, 5)
+    >>> b.expand(double=True)
+    MyClass(1, 2, 3, 4, 5)
+    >>> b.expand(double=True, force=True)
+    MyClass(1, 2, 3, 4, 5, 1, 2, 3, 4, 5)
+
+    See Also
+    ========
+
+    expand_log, expand_mul, expand_multinomial, expand_complex, expand_trig,
+    expand_power_base, expand_power_exp, expand_func, sympy.simplify.hyperexpand.hyperexpand
+
+    """
+    # don't modify this; modify the Expr.expand method
+    hints['power_base'] = power_base
+    hints['power_exp'] = power_exp
+    hints['mul'] = mul
+    hints['log'] = log
+    hints['multinomial'] = multinomial
+    hints['basic'] = basic
+    return sympify(e).expand(deep=deep, modulus=modulus, **hints)
+
+# This is a special application of two hints
+
+def _mexpand(expr, recursive=False):
+    # expand multinomials and then expand products; this may not always
+    # be sufficient to give a fully expanded expression (see
+    # test_issue_8247_8354 in test_arit)
+    if expr is None:
+        return
+    was = None
+    while was != expr:
+        was, expr = expr, expand_mul(expand_multinomial(expr))
+        if not recursive:
+            break
+    return expr
+
+
+# These are simple wrappers around single hints.
+
+
+def expand_mul(expr, deep=True):
+    """
+    Wrapper around expand that only uses the mul hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, expand_mul, exp, log
+    >>> x, y = symbols('x,y', positive=True)
+    >>> expand_mul(exp(x+y)*(x+y)*log(x*y**2))
+    x*exp(x + y)*log(x*y**2) + y*exp(x + y)*log(x*y**2)
+
+    """
+    return sympify(expr).expand(deep=deep, mul=True, power_exp=False,
+    power_base=False, basic=False, multinomial=False, log=False)
+
+
+def expand_multinomial(expr, deep=True):
+    """
+    Wrapper around expand that only uses the multinomial hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, expand_multinomial, exp
+    >>> x, y = symbols('x y', positive=True)
+    >>> expand_multinomial((x + exp(x + 1))**2)
+    x**2 + 2*x*exp(x + 1) + exp(2*x + 2)
+
+    """
+    return sympify(expr).expand(deep=deep, mul=False, power_exp=False,
+    power_base=False, basic=False, multinomial=True, log=False)
+
+
+def expand_log(expr, deep=True, force=False, factor=False):
+    """
+    Wrapper around expand that only uses the log hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, expand_log, exp, log
+    >>> x, y = symbols('x,y', positive=True)
+    >>> expand_log(exp(x+y)*(x+y)*log(x*y**2))
+    (x + y)*(log(x) + 2*log(y))*exp(x + y)
+
+    """
+    from sympy.functions.elementary.exponential import log
+    from sympy.simplify.radsimp import fraction
+    if factor is False:
+        def _handleMul(x):
+            # look for the simple case of expanded log(b**a)/log(b) -> a in args
+            n, d = fraction(x)
+            n = [i for i in n.atoms(log) if i.args[0].is_Integer]
+            d = [i for i in d.atoms(log) if i.args[0].is_Integer]
+            if len(n) == 1 and len(d) == 1:
+                n = n[0]
+                d = d[0]
+                from sympy import multiplicity
+                m = multiplicity(d.args[0], n.args[0])
+                if m:
+                    r = m + log(n.args[0]//d.args[0]**m)/d
+                    x = x.subs(n, d*r)
+            x1 = expand_mul(expand_log(x, deep=deep, force=force, factor=True))
+            if x1.count(log) <= x.count(log):
+                return x1
+            return x
+
+        expr = expr.replace(
+        lambda x: x.is_Mul and all(any(isinstance(i, log) and i.args[0].is_Rational
+        for i in Mul.make_args(j)) for j in x.as_numer_denom()),
+        _handleMul)
+
+    return sympify(expr).expand(deep=deep, log=True, mul=False,
+        power_exp=False, power_base=False, multinomial=False,
+        basic=False, force=force, factor=factor)
+
+
+def expand_func(expr, deep=True):
+    """
+    Wrapper around expand that only uses the func hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import expand_func, gamma
+    >>> from sympy.abc import x
+    >>> expand_func(gamma(x + 2))
+    x*(x + 1)*gamma(x)
+
+    """
+    return sympify(expr).expand(deep=deep, func=True, basic=False,
+    log=False, mul=False, power_exp=False, power_base=False, multinomial=False)
+
+
+def expand_trig(expr, deep=True):
+    """
+    Wrapper around expand that only uses the trig hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import expand_trig, sin
+    >>> from sympy.abc import x, y
+    >>> expand_trig(sin(x+y)*(x+y))
+    (x + y)*(sin(x)*cos(y) + sin(y)*cos(x))
+
+    """
+    return sympify(expr).expand(deep=deep, trig=True, basic=False,
+    log=False, mul=False, power_exp=False, power_base=False, multinomial=False)
+
+
+def expand_complex(expr, deep=True):
+    """
+    Wrapper around expand that only uses the complex hint.  See the expand
+    docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import expand_complex, exp, sqrt, I
+    >>> from sympy.abc import z
+    >>> expand_complex(exp(z))
+    I*exp(re(z))*sin(im(z)) + exp(re(z))*cos(im(z))
+    >>> expand_complex(sqrt(I))
+    sqrt(2)/2 + sqrt(2)*I/2
+
+    See Also
+    ========
+
+    sympy.core.expr.Expr.as_real_imag
+    """
+    return sympify(expr).expand(deep=deep, complex=True, basic=False,
+    log=False, mul=False, power_exp=False, power_base=False, multinomial=False)
+
+
+def expand_power_base(expr, deep=True, force=False):
+    """
+    Wrapper around expand that only uses the power_base hint.
+
+    A wrapper to expand(power_base=True) which separates a power with a base
+    that is a Mul into a product of powers, without performing any other
+    expansions, provided that assumptions about the power's base and exponent
+    allow.
+
+    deep=False (default is True) will only apply to the top-level expression.
+
+    force=True (default is False) will cause the expansion to ignore
+    assumptions about the base and exponent. When False, the expansion will
+    only happen if the base is non-negative or the exponent is an integer.
+
+    >>> from sympy.abc import x, y, z
+    >>> from sympy import expand_power_base, sin, cos, exp, Symbol
+
+    >>> (x*y)**2
+    x**2*y**2
+
+    >>> (2*x)**y
+    (2*x)**y
+    >>> expand_power_base(_)
+    2**y*x**y
+
+    >>> expand_power_base((x*y)**z)
+    (x*y)**z
+    >>> expand_power_base((x*y)**z, force=True)
+    x**z*y**z
+    >>> expand_power_base(sin((x*y)**z), deep=False)
+    sin((x*y)**z)
+    >>> expand_power_base(sin((x*y)**z), force=True)
+    sin(x**z*y**z)
+
+    >>> expand_power_base((2*sin(x))**y + (2*cos(x))**y)
+    2**y*sin(x)**y + 2**y*cos(x)**y
+
+    >>> expand_power_base((2*exp(y))**x)
+    2**x*exp(y)**x
+
+    >>> expand_power_base((2*cos(x))**y)
+    2**y*cos(x)**y
+
+    Notice that sums are left untouched. If this is not the desired behavior,
+    apply full ``expand()`` to the expression:
+
+    >>> expand_power_base(((x+y)*z)**2)
+    z**2*(x + y)**2
+    >>> (((x+y)*z)**2).expand()
+    x**2*z**2 + 2*x*y*z**2 + y**2*z**2
+
+    >>> expand_power_base((2*y)**(1+z))
+    2**(z + 1)*y**(z + 1)
+    >>> ((2*y)**(1+z)).expand()
+    2*2**z*y**(z + 1)
+
+    The power that is unexpanded can be expanded safely when
+    ``y != 0``, otherwise different values might be obtained for the expression:
+
+    >>> prev = _
+
+    If we indicate that ``y`` is positive but then replace it with
+    a value of 0 after expansion, the expression becomes 0:
+
+    >>> p = Symbol('p', positive=True)
+    >>> prev.subs(y, p).expand().subs(p, 0)
+    0
+
+    But if ``z = -1`` the expression would not be zero:
+
+    >>> prev.subs(y, 0).subs(z, -1)
+    1
+
+    See Also
+    ========
+
+    expand
+
+    """
+    return sympify(expr).expand(deep=deep, log=False, mul=False,
+        power_exp=False, power_base=True, multinomial=False,
+        basic=False, force=force)
+
+
+def expand_power_exp(expr, deep=True):
+    """
+    Wrapper around expand that only uses the power_exp hint.
+
+    See the expand docstring for more information.
+
+    Examples
+    ========
+
+    >>> from sympy import expand_power_exp, Symbol
+    >>> from sympy.abc import x, y
+    >>> expand_power_exp(3**(y + 2))
+    9*3**y
+    >>> expand_power_exp(x**(y + 2))
+    x**(y + 2)
+
+    If ``x = 0`` the value of the expression depends on the
+    value of ``y``; if the expression were expanded the result
+    would be 0. So expansion is only done if ``x != 0``:
+
+    >>> expand_power_exp(Symbol('x', zero=False)**(y + 2))
+    x**2*x**y
+    """
+    return sympify(expr).expand(deep=deep, complex=False, basic=False,
+    log=False, mul=False, power_exp=True, power_base=False, multinomial=False)
+
+
+def count_ops(expr, visual=False):
+    """
+    Return a representation (integer or expression) of the operations in expr.
+
+    Parameters
+    ==========
+
+    expr : Expr
+        If expr is an iterable, the sum of the op counts of the
+        items will be returned.
+
+    visual : bool, optional
+        If ``False`` (default) then the sum of the coefficients of the
+        visual expression will be returned.
+        If ``True`` then the number of each type of operation is shown
+        with the core class types (or their virtual equivalent) multiplied by the
+        number of times they occur.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import a, b, x, y
+    >>> from sympy import sin, count_ops
+
+    Although there is not a SUB object, minus signs are interpreted as
+    either negations or subtractions:
+
+    >>> (x - y).count_ops(visual=True)
+    SUB
+    >>> (-x).count_ops(visual=True)
+    NEG
+
+    Here, there are two Adds and a Pow:
+
+    >>> (1 + a + b**2).count_ops(visual=True)
+    2*ADD + POW
+
+    In the following, an Add, Mul, Pow and two functions:
+
+    >>> (sin(x)*x + sin(x)**2).count_ops(visual=True)
+    ADD + MUL + POW + 2*SIN
+
+    for a total of 5:
+
+    >>> (sin(x)*x + sin(x)**2).count_ops(visual=False)
+    5
+
+    Note that "what you type" is not always what you get. The expression
+    1/x/y is translated by sympy into 1/(x*y) so it gives a DIV and MUL rather
+    than two DIVs:
+
+    >>> (1/x/y).count_ops(visual=True)
+    DIV + MUL
+
+    The visual option can be used to demonstrate the difference in
+    operations for expressions in different forms. Here, the Horner
+    representation is compared with the expanded form of a polynomial:
+
+    >>> eq=x*(1 + x*(2 + x*(3 + x)))
+    >>> count_ops(eq.expand(), visual=True) - count_ops(eq, visual=True)
+    -MUL + 3*POW
+
+    The count_ops function also handles iterables:
+
+    >>> count_ops([x, sin(x), None, True, x + 2], visual=False)
+    2
+    >>> count_ops([x, sin(x), None, True, x + 2], visual=True)
+    ADD + SIN
+    >>> count_ops({x: sin(x), x + 2: y + 1}, visual=True)
+    2*ADD + SIN
+
+    """
+    from .relational import Relational
+    from sympy.concrete.summations import Sum
+    from sympy.integrals.integrals import Integral
+    from sympy.logic.boolalg import BooleanFunction
+    from sympy.simplify.radsimp import fraction
+
+    expr = sympify(expr)
+    if isinstance(expr, Expr) and not expr.is_Relational:
+
+        ops = []
+        args = [expr]
+        NEG = Symbol('NEG')
+        DIV = Symbol('DIV')
+        SUB = Symbol('SUB')
+        ADD = Symbol('ADD')
+        EXP = Symbol('EXP')
+        while args:
+            a = args.pop()
+
+            # if the following fails because the object is
+            # not Basic type, then the object should be fixed
+            # since it is the intention that all args of Basic
+            # should themselves be Basic
+            if a.is_Rational:
+                #-1/3 = NEG + DIV
+                if a is not S.One:
+                    if a.p < 0:
+                        ops.append(NEG)
+                    if a.q != 1:
+                        ops.append(DIV)
+                    continue
+            elif a.is_Mul or a.is_MatMul:
+                if _coeff_isneg(a):
+                    ops.append(NEG)
+                    if a.args[0] is S.NegativeOne:
+                        a = a.as_two_terms()[1]
+                    else:
+                        a = -a
+                n, d = fraction(a)
+                if n.is_Integer:
+                    ops.append(DIV)
+                    if n < 0:
+                        ops.append(NEG)
+                    args.append(d)
+                    continue  # won't be -Mul but could be Add
+                elif d is not S.One:
+                    if not d.is_Integer:
+                        args.append(d)
+                    ops.append(DIV)
+                    args.append(n)
+                    continue  # could be -Mul
+            elif a.is_Add or a.is_MatAdd:
+                aargs = list(a.args)
+                negs = 0
+                for i, ai in enumerate(aargs):
+                    if _coeff_isneg(ai):
+                        negs += 1
+                        args.append(-ai)
+                        if i > 0:
+                            ops.append(SUB)
+                    else:
+                        args.append(ai)
+                        if i > 0:
+                            ops.append(ADD)
+                if negs == len(aargs):  # -x - y = NEG + SUB
+                    ops.append(NEG)
+                elif _coeff_isneg(aargs[0]):  # -x + y = SUB, but already recorded ADD
+                    ops.append(SUB - ADD)
+                continue
+            if a.is_Pow and a.exp is S.NegativeOne:
+                ops.append(DIV)
+                args.append(a.base)  # won't be -Mul but could be Add
+                continue
+            if a == S.Exp1:
+                ops.append(EXP)
+                continue
+            if a.is_Pow and a.base == S.Exp1:
+                ops.append(EXP)
+                args.append(a.exp)
+                continue
+            if a.is_Mul or isinstance(a, LatticeOp):
+                o = Symbol(a.func.__name__.upper())
+                # count the args
+                ops.append(o*(len(a.args) - 1))
+            elif a.args and (
+                    a.is_Pow or a.is_Function or isinstance(a, (Derivative, Integral, Sum))):
+                # if it's not in the list above we don't
+                # consider a.func something to count, e.g.
+                # Tuple, MatrixSymbol, etc...
+                if isinstance(a.func, UndefinedFunction):
+                    o = Symbol("FUNC_" + a.func.__name__.upper())
+                else:
+                    o = Symbol(a.func.__name__.upper())
+                ops.append(o)
+
+            if not a.is_Symbol:
+                args.extend(a.args)
+
+    elif isinstance(expr, Dict):
+        ops = [count_ops(k, visual=visual) +
+               count_ops(v, visual=visual) for k, v in expr.items()]
+    elif iterable(expr):
+        ops = [count_ops(i, visual=visual) for i in expr]
+    elif isinstance(expr, (Relational, BooleanFunction)):
+        ops = []
+        for arg in expr.args:
+            ops.append(count_ops(arg, visual=True))
+        o = Symbol(func_name(expr, short=True).upper())
+        ops.append(o)
+    elif not isinstance(expr, Basic):
+        ops = []
+    else:  # it's Basic not isinstance(expr, Expr):
+        if not isinstance(expr, Basic):
+            raise TypeError("Invalid type of expr")
+        else:
+            ops = []
+            args = [expr]
+            while args:
+                a = args.pop()
+
+                if a.args:
+                    o = Symbol(type(a).__name__.upper())
+                    if a.is_Boolean:
+                        ops.append(o*(len(a.args)-1))
+                    else:
+                        ops.append(o)
+                    args.extend(a.args)
+
+    if not ops:
+        if visual:
+            return S.Zero
+        return 0
+
+    ops = Add(*ops)
+
+    if visual:
+        return ops
+
+    if ops.is_Number:
+        return int(ops)
+
+    return sum(int((a.args or [1])[0]) for a in Add.make_args(ops))
+
+
+def nfloat(expr, n=15, exponent=False, dkeys=False):
+    """Make all Rationals in expr Floats except those in exponents
+    (unless the exponents flag is set to True) and those in undefined
+    functions. When processing dictionaries, do not modify the keys
+    unless ``dkeys=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import nfloat, cos, pi, sqrt
+    >>> from sympy.abc import x, y
+    >>> nfloat(x**4 + x/2 + cos(pi/3) + 1 + sqrt(y))
+    x**4 + 0.5*x + sqrt(y) + 1.5
+    >>> nfloat(x**4 + sqrt(y), exponent=True)
+    x**4.0 + y**0.5
+
+    Container types are not modified:
+
+    >>> type(nfloat((1, 2))) is tuple
+    True
+    """
+    from sympy.matrices.matrixbase import MatrixBase
+
+    kw = {"n": n, "exponent": exponent, "dkeys": dkeys}
+
+    if isinstance(expr, MatrixBase):
+        return expr.applyfunc(lambda e: nfloat(e, **kw))
+
+    # handling of iterable containers
+    if iterable(expr, exclude=str):
+        if isinstance(expr, (dict, Dict)):
+            if dkeys:
+                args = [tuple((nfloat(i, **kw) for i in a))
+                    for a in expr.items()]
+            else:
+                args = [(k, nfloat(v, **kw)) for k, v in expr.items()]
+            if isinstance(expr, dict):
+                return type(expr)(args)
+            else:
+                return expr.func(*args)
+        elif isinstance(expr, Basic):
+            return expr.func(*[nfloat(a, **kw) for a in expr.args])
+        return type(expr)([nfloat(a, **kw) for a in expr])
+
+    rv = sympify(expr)
+
+    if rv.is_Number:
+        return Float(rv, n)
+    elif rv.is_number:
+        # evalf doesn't always set the precision
+        rv = rv.n(n)
+        if rv.is_Number:
+            rv = Float(rv.n(n), n)
+        else:
+            pass  # pure_complex(rv) is likely True
+        return rv
+    elif rv.is_Atom:
+        return rv
+    elif rv.is_Relational:
+        args_nfloat = (nfloat(arg, **kw) for arg in rv.args)
+        return rv.func(*args_nfloat)
+
+
+    # watch out for RootOf instances that don't like to have
+    # their exponents replaced with Dummies and also sometimes have
+    # problems with evaluating at low precision (issue 6393)
+    from sympy.polys.rootoftools import RootOf
+    rv = rv.xreplace({ro: ro.n(n) for ro in rv.atoms(RootOf)})
+
+    from .power import Pow
+    if not exponent:
+        reps = [(p, Pow(p.base, Dummy())) for p in rv.atoms(Pow)]
+        rv = rv.xreplace(dict(reps))
+    rv = rv.n(n)
+    if not exponent:
+        rv = rv.xreplace({d.exp: p.exp for p, d in reps})
+    else:
+        # Pow._eval_evalf special cases Integer exponents so if
+        # exponent is suppose to be handled we have to do so here
+        rv = rv.xreplace(Transform(
+            lambda x: Pow(x.base, Float(x.exp, n)),
+            lambda x: x.is_Pow and x.exp.is_Integer))
+
+    return rv.xreplace(Transform(
+        lambda x: x.func(*nfloat(x.args, n, exponent)),
+        lambda x: isinstance(x, Function) and not isinstance(x, AppliedUndef)))
+
+
+from .symbol import Dummy, Symbol
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/intfunc.py b/.venv/lib/python3.12/site-packages/sympy/core/intfunc.py
new file mode 100644
index 0000000000000000000000000000000000000000..50cb625dafcc1e795933311780e26423ddc6015a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/intfunc.py
@@ -0,0 +1,530 @@
+"""
+The routines here were removed from numbers.py, power.py,
+digits.py and factor_.py so they could be imported into core
+without raising circular import errors.
+
+Although the name 'intfunc' was chosen to represent functions that
+work with integers, it can also be thought of as containing
+internal/core functions that are needed by the classes of the core.
+"""
+
+import math
+import sys
+from functools import lru_cache
+
+from .sympify import sympify
+from .singleton import S
+from sympy.external.gmpy import (gcd as number_gcd, lcm as number_lcm, sqrt,
+                                 iroot, bit_scan1, gcdext)
+from sympy.utilities.misc import as_int, filldedent
+
+
+def num_digits(n, base=10):
+    """Return the number of digits needed to express n in give base.
+
+    Examples
+    ========
+
+    >>> from sympy.core.intfunc import num_digits
+    >>> num_digits(10)
+    2
+    >>> num_digits(10, 2)  # 1010 -> 4 digits
+    4
+    >>> num_digits(-100, 16)  # -64 -> 2 digits
+    2
+
+
+    Parameters
+    ==========
+
+    n: integer
+        The number whose digits are counted.
+
+    b: integer
+        The base in which digits are computed.
+
+    See Also
+    ========
+    sympy.ntheory.digits.digits, sympy.ntheory.digits.count_digits
+    """
+    if base < 0:
+        raise ValueError('base must be int greater than 1')
+    if not n:
+        return 1
+    e, t = integer_log(abs(n), base)
+    return 1 + e
+
+
+def integer_log(n, b):
+    r"""
+    Returns ``(e, bool)`` where e is the largest nonnegative integer
+    such that :math:`|n| \geq |b^e|` and ``bool`` is True if $n = b^e$.
+
+    Examples
+    ========
+
+    >>> from sympy import integer_log
+    >>> integer_log(125, 5)
+    (3, True)
+    >>> integer_log(17, 9)
+    (1, False)
+
+    If the base is positive and the number negative the
+    return value will always be the same except for 2:
+
+    >>> integer_log(-4, 2)
+    (2, False)
+    >>> integer_log(-16, 4)
+    (0, False)
+
+    When the base is negative, the returned value
+    will only be True if the parity of the exponent is
+    correct for the sign of the base:
+
+    >>> integer_log(4, -2)
+    (2, True)
+    >>> integer_log(8, -2)
+    (3, False)
+    >>> integer_log(-8, -2)
+    (3, True)
+    >>> integer_log(-4, -2)
+    (2, False)
+
+    See Also
+    ========
+    integer_nthroot
+    sympy.ntheory.primetest.is_square
+    sympy.ntheory.factor_.multiplicity
+    sympy.ntheory.factor_.perfect_power
+    """
+    n = as_int(n)
+    b = as_int(b)
+
+    if b < 0:
+        e, t = integer_log(abs(n), -b)
+        # (-2)**3 == -8
+        # (-2)**2 = 4
+        t = t and e % 2 == (n < 0)
+        return e, t
+    if b <= 1:
+        raise ValueError('base must be 2 or more')
+    if n < 0:
+        if b != 2:
+            return 0, False
+        e, t = integer_log(-n, b)
+        return e, False
+    if n == 0:
+        raise ValueError('n cannot be 0')
+
+    if n < b:
+        return 0, n == 1
+    if b == 2:
+        e = n.bit_length() - 1
+        return e, trailing(n) == e
+    t = trailing(b)
+    if 2**t == b:
+        e = int(n.bit_length() - 1)//t
+        n_ = 1 << (t*e)
+        return e, n_ == n
+
+    d = math.floor(math.log10(n) / math.log10(b))
+    n_ = b ** d
+    while n_ <= n:  # this will iterate 0, 1 or 2 times
+        d += 1
+        n_ *= b
+    return d - (n_ > n), (n_ == n or n_//b == n)
+
+
+def trailing(n):
+    """Count the number of trailing zero digits in the binary
+    representation of n, i.e. determine the largest power of 2
+    that divides n.
+
+    Examples
+    ========
+
+    >>> from sympy import trailing
+    >>> trailing(128)
+    7
+    >>> trailing(63)
+    0
+
+    See Also
+    ========
+    sympy.ntheory.factor_.multiplicity
+
+    """
+    if not n:
+        return 0
+    return bit_scan1(int(n))
+
+
+@lru_cache(1024)
+def igcd(*args):
+    """Computes nonnegative integer greatest common divisor.
+
+    Explanation
+    ===========
+
+    The algorithm is based on the well known Euclid's algorithm [1]_. To
+    improve speed, ``igcd()`` has its own caching mechanism.
+    If you do not need the cache mechanism, using ``sympy.external.gmpy.gcd``.
+
+    Examples
+    ========
+
+    >>> from sympy import igcd
+    >>> igcd(2, 4)
+    2
+    >>> igcd(5, 10, 15)
+    5
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euclidean_algorithm
+
+    """
+    if len(args) < 2:
+        raise TypeError("igcd() takes at least 2 arguments (%s given)" % len(args))
+    return int(number_gcd(*map(as_int, args)))
+
+
+igcd2 = math.gcd
+
+
+def igcd_lehmer(a, b):
+    r"""Computes greatest common divisor of two integers.
+
+    Explanation
+    ===========
+
+    Euclid's algorithm for the computation of the greatest
+    common divisor ``gcd(a, b)``  of two (positive) integers
+    $a$ and $b$ is based on the division identity
+    $$ a = q \times b + r$$,
+    where the quotient  $q$  and the remainder  $r$  are integers
+    and  $0 \le r < b$. Then each common divisor of  $a$  and  $b$
+    divides  $r$, and it follows that  ``gcd(a, b) == gcd(b, r)``.
+    The algorithm works by constructing the sequence
+    r0, r1, r2, ..., where  r0 = a, r1 = b,  and each  rn
+    is the remainder from the division of the two preceding
+    elements.
+
+    In Python, ``q = a // b``  and  ``r = a % b``  are obtained by the
+    floor division and the remainder operations, respectively.
+    These are the most expensive arithmetic operations, especially
+    for large  a  and  b.
+
+    Lehmer's algorithm [1]_ is based on the observation that the quotients
+    ``qn = r(n-1) // rn``  are in general small integers even
+    when  a  and  b  are very large. Hence the quotients can be
+    usually determined from a relatively small number of most
+    significant bits.
+
+    The efficiency of the algorithm is further enhanced by not
+    computing each long remainder in Euclid's sequence. The remainders
+    are linear combinations of  a  and  b  with integer coefficients
+    derived from the quotients. The coefficients can be computed
+    as far as the quotients can be determined from the chosen
+    most significant parts of  a  and  b. Only then a new pair of
+    consecutive remainders is computed and the algorithm starts
+    anew with this pair.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lehmer%27s_GCD_algorithm
+
+    """
+    a, b = abs(as_int(a)), abs(as_int(b))
+    if a < b:
+        a, b = b, a
+
+    # The algorithm works by using one or two digit division
+    # whenever possible. The outer loop will replace the
+    # pair (a, b) with a pair of shorter consecutive elements
+    # of the Euclidean gcd sequence until a and b
+    # fit into two Python (long) int digits.
+    nbits = 2 * sys.int_info.bits_per_digit
+
+    while a.bit_length() > nbits and b != 0:
+        # Quotients are mostly small integers that can
+        # be determined from most significant bits.
+        n = a.bit_length() - nbits
+        x, y = int(a >> n), int(b >> n)  # most significant bits
+
+        # Elements of the Euclidean gcd sequence are linear
+        # combinations of a and b with integer coefficients.
+        # Compute the coefficients of consecutive pairs
+        #     a' = A*a + B*b, b' = C*a + D*b
+        # using small integer arithmetic as far as possible.
+        A, B, C, D = 1, 0, 0, 1  # initial values
+
+        while True:
+            # The coefficients alternate in sign while looping.
+            # The inner loop combines two steps to keep track
+            # of the signs.
+
+            # At this point we have
+            #   A > 0, B <= 0, C <= 0, D > 0,
+            #   x' = x + B <= x < x" = x + A,
+            #   y' = y + C <= y < y" = y + D,
+            # and
+            #   x'*N <= a' < x"*N, y'*N <= b' < y"*N,
+            # where N = 2**n.
+
+            # Now, if y' > 0, and x"//y' and x'//y" agree,
+            # then their common value is equal to  q = a'//b'.
+            # In addition,
+            #   x'%y" = x' - q*y" < x" - q*y' = x"%y',
+            # and
+            #   (x'%y")*N < a'%b' < (x"%y')*N.
+
+            # On the other hand, we also have  x//y == q,
+            # and therefore
+            #   x'%y" = x + B - q*(y + D) = x%y + B',
+            #   x"%y' = x + A - q*(y + C) = x%y + A',
+            # where
+            #    B' = B - q*D < 0, A' = A - q*C > 0.
+
+            if y + C <= 0:
+                break
+            q = (x + A) // (y + C)
+
+            # Now  x'//y" <= q, and equality holds if
+            #   x' - q*y" = (x - q*y) + (B - q*D) >= 0.
+            # This is a minor optimization to avoid division.
+            x_qy, B_qD = x - q * y, B - q * D
+            if x_qy + B_qD < 0:
+                break
+
+            # Next step in the Euclidean sequence.
+            x, y = y, x_qy
+            A, B, C, D = C, D, A - q * C, B_qD
+
+            # At this point the signs of the coefficients
+            # change and their roles are interchanged.
+            #   A <= 0, B > 0, C > 0, D < 0,
+            #   x' = x + A <= x < x" = x + B,
+            #   y' = y + D < y < y" = y + C.
+
+            if y + D <= 0:
+                break
+            q = (x + B) // (y + D)
+            x_qy, A_qC = x - q * y, A - q * C
+            if x_qy + A_qC < 0:
+                break
+
+            x, y = y, x_qy
+            A, B, C, D = C, D, A_qC, B - q * D
+            # Now the conditions on top of the loop
+            # are again satisfied.
+            #   A > 0, B < 0, C < 0, D > 0.
+
+        if B == 0:
+            # This can only happen when y == 0 in the beginning
+            # and the inner loop does nothing.
+            # Long division is forced.
+            a, b = b, a % b
+            continue
+
+        # Compute new long arguments using the coefficients.
+        a, b = A * a + B * b, C * a + D * b
+
+    # Small divisors. Finish with the standard algorithm.
+    while b:
+        a, b = b, a % b
+
+    return a
+
+
+def ilcm(*args):
+    """Computes integer least common multiple.
+
+    Examples
+    ========
+
+    >>> from sympy import ilcm
+    >>> ilcm(5, 10)
+    10
+    >>> ilcm(7, 3)
+    21
+    >>> ilcm(5, 10, 15)
+    30
+
+    """
+    if len(args) < 2:
+        raise TypeError("ilcm() takes at least 2 arguments (%s given)" % len(args))
+    return int(number_lcm(*map(as_int, args)))
+
+
+def igcdex(a, b):
+    """Returns x, y, g such that g = x*a + y*b = gcd(a, b).
+
+    Examples
+    ========
+
+    >>> from sympy.core.intfunc import igcdex
+    >>> igcdex(2, 3)
+    (-1, 1, 1)
+    >>> igcdex(10, 12)
+    (-1, 1, 2)
+
+    >>> x, y, g = igcdex(100, 2004)
+    >>> x, y, g
+    (-20, 1, 4)
+    >>> x*100 + y*2004
+    4
+
+    """
+    g, x, y = gcdext(int(a), int(b))
+    return x, y, g
+
+
+def mod_inverse(a, m):
+    r"""
+    Return the number $c$ such that, $a \times c = 1 \pmod{m}$
+    where $c$ has the same sign as $m$. If no such value exists,
+    a ValueError is raised.
+
+    Examples
+    ========
+
+    >>> from sympy import mod_inverse, S
+
+    Suppose we wish to find multiplicative inverse $x$ of
+    3 modulo 11. This is the same as finding $x$ such
+    that $3x = 1 \pmod{11}$. One value of x that satisfies
+    this congruence is 4. Because $3 \times 4 = 12$ and $12 = 1 \pmod{11}$.
+    This is the value returned by ``mod_inverse``:
+
+    >>> mod_inverse(3, 11)
+    4
+    >>> mod_inverse(-3, 11)
+    7
+
+    When there is a common factor between the numerators of
+    `a` and `m` the inverse does not exist:
+
+    >>> mod_inverse(2, 4)
+    Traceback (most recent call last):
+    ...
+    ValueError: inverse of 2 mod 4 does not exist
+
+    >>> mod_inverse(S(2)/7, S(5)/2)
+    7/2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+    .. [2] https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+    """
+    c = None
+    try:
+        a, m = as_int(a), as_int(m)
+        if m != 1 and m != -1:
+            x, _, g = igcdex(a, m)
+            if g == 1:
+                c = x % m
+    except ValueError:
+        a, m = sympify(a), sympify(m)
+        if not (a.is_number and m.is_number):
+            raise TypeError(
+                filldedent(
+                    """
+                Expected numbers for arguments; symbolic `mod_inverse`
+                is not implemented
+                but symbolic expressions can be handled with the
+                similar function,
+                sympy.polys.polytools.invert"""
+                )
+            )
+        big = m > 1
+        if big not in (S.true, S.false):
+            raise ValueError("m > 1 did not evaluate; try to simplify %s" % m)
+        elif big:
+            c = 1 / a
+    if c is None:
+        raise ValueError("inverse of %s (mod %s) does not exist" % (a, m))
+    return c
+
+
+def isqrt(n):
+    r""" Return the largest integer less than or equal to `\sqrt{n}`.
+
+    Parameters
+    ==========
+
+    n : non-negative integer
+
+    Returns
+    =======
+
+    int : `\left\lfloor\sqrt{n}\right\rfloor`
+
+    Raises
+    ======
+
+    ValueError
+        If n is negative.
+    TypeError
+        If n is of a type that cannot be compared to ``int``.
+        Therefore, a TypeError is raised for ``str``, but not for ``float``.
+
+    Examples
+    ========
+
+    >>> from sympy.core.intfunc import isqrt
+    >>> isqrt(0)
+    0
+    >>> isqrt(9)
+    3
+    >>> isqrt(10)
+    3
+    >>> isqrt("30")
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
+    >>> from sympy.core.numbers import Rational
+    >>> isqrt(Rational(-1, 2))
+    Traceback (most recent call last):
+        ...
+    ValueError: n must be nonnegative
+
+    """
+    if n < 0:
+        raise ValueError("n must be nonnegative")
+    return int(sqrt(int(n)))
+
+
+def integer_nthroot(y, n):
+    """
+    Return a tuple containing x = floor(y**(1/n))
+    and a boolean indicating whether the result is exact (that is,
+    whether x**n == y).
+
+    Examples
+    ========
+
+    >>> from sympy import integer_nthroot
+    >>> integer_nthroot(16, 2)
+    (4, True)
+    >>> integer_nthroot(26, 2)
+    (5, False)
+
+    To simply determine if a number is a perfect square, the is_square
+    function should be used:
+
+    >>> from sympy.ntheory.primetest import is_square
+    >>> is_square(26)
+    False
+
+    See Also
+    ========
+    sympy.ntheory.primetest.is_square
+    integer_log
+    """
+    x, b = iroot(as_int(y), as_int(n))
+    return int(x), b
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/kind.py b/.venv/lib/python3.12/site-packages/sympy/core/kind.py
new file mode 100644
index 0000000000000000000000000000000000000000..83c5929eda14114659f2a5a72eb2d8b91a560f0e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/kind.py
@@ -0,0 +1,388 @@
+"""
+Module to efficiently partition SymPy objects.
+
+This system is introduced because class of SymPy object does not always
+represent the mathematical classification of the entity. For example,
+``Integral(1, x)`` and ``Integral(Matrix([1,2]), x)`` are both instance
+of ``Integral`` class. However the former is number and the latter is
+matrix.
+
+One way to resolve this is defining subclass for each mathematical type,
+such as ``MatAdd`` for the addition between matrices. Basic algebraic
+operation such as addition or multiplication take this approach, but
+defining every class for every mathematical object is not scalable.
+
+Therefore, we define the "kind" of the object and let the expression
+infer the kind of itself from its arguments. Function and class can
+filter the arguments by their kind, and behave differently according to
+the type of itself.
+
+This module defines basic kinds for core objects. Other kinds such as
+``ArrayKind`` or ``MatrixKind`` can be found in corresponding modules.
+
+.. notes::
+       This approach is experimental, and can be replaced or deleted in the future.
+       See https://github.com/sympy/sympy/pull/20549.
+"""
+
+from collections import defaultdict
+
+from .cache import cacheit
+from sympy.multipledispatch.dispatcher import (Dispatcher,
+    ambiguity_warn, ambiguity_register_error_ignore_dup,
+    str_signature, RaiseNotImplementedError)
+
+
+class KindMeta(type):
+    """
+    Metaclass for ``Kind``.
+
+    Assigns empty ``dict`` as class attribute ``_inst`` for every class,
+    in order to endow singleton-like behavior.
+    """
+    def __new__(cls, clsname, bases, dct):
+        dct['_inst'] = {}
+        return super().__new__(cls, clsname, bases, dct)
+
+
+class Kind(object, metaclass=KindMeta):
+    """
+    Base class for kinds.
+
+    Kind of the object represents the mathematical classification that
+    the entity falls into. It is expected that functions and classes
+    recognize and filter the argument by its kind.
+
+    Kind of every object must be carefully selected so that it shows the
+    intention of design. Expressions may have different kind according
+    to the kind of its arguments. For example, arguments of ``Add``
+    must have common kind since addition is group operator, and the
+    resulting ``Add()`` has the same kind.
+
+    For the performance, each kind is as broad as possible and is not
+    based on set theory. For example, ``NumberKind`` includes not only
+    complex number but expression containing ``S.Infinity`` or ``S.NaN``
+    which are not strictly number.
+
+    Kind may have arguments as parameter. For example, ``MatrixKind()``
+    may be constructed with one element which represents the kind of its
+    elements.
+
+    ``Kind`` behaves in singleton-like fashion. Same signature will
+    return the same object.
+
+    """
+    def __new__(cls, *args):
+        if args in cls._inst:
+            inst = cls._inst[args]
+        else:
+            inst = super().__new__(cls)
+            cls._inst[args] = inst
+        return inst
+
+
+class _UndefinedKind(Kind):
+    """
+    Default kind for all SymPy object. If the kind is not defined for
+    the object, or if the object cannot infer the kind from its
+    arguments, this will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy import Expr
+    >>> Expr().kind
+    UndefinedKind
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "UndefinedKind"
+
+UndefinedKind = _UndefinedKind()
+
+
+class _NumberKind(Kind):
+    """
+    Kind for all numeric object.
+
+    This kind represents every number, including complex numbers,
+    infinity and ``S.NaN``. Other objects such as quaternions do not
+    have this kind.
+
+    Most ``Expr`` are initially designed to represent the number, so
+    this will be the most common kind in SymPy core. For example
+    ``Symbol()``, which represents a scalar, has this kind as long as it
+    is commutative.
+
+    Numbers form a field. Any operation between number-kind objects will
+    result this kind as well.
+
+    Examples
+    ========
+
+    >>> from sympy import S, oo, Symbol
+    >>> S.One.kind
+    NumberKind
+    >>> (-oo).kind
+    NumberKind
+    >>> S.NaN.kind
+    NumberKind
+
+    Commutative symbol are treated as number.
+
+    >>> x = Symbol('x')
+    >>> x.kind
+    NumberKind
+    >>> Symbol('y', commutative=False).kind
+    UndefinedKind
+
+    Operation between numbers results number.
+
+    >>> (x+1).kind
+    NumberKind
+
+    See Also
+    ========
+
+    sympy.core.expr.Expr.is_Number : check if the object is strictly
+    subclass of ``Number`` class.
+
+    sympy.core.expr.Expr.is_number : check if the object is number
+    without any free symbol.
+
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "NumberKind"
+
+NumberKind = _NumberKind()
+
+
+class _BooleanKind(Kind):
+    """
+    Kind for boolean objects.
+
+    SymPy's ``S.true``, ``S.false``, and built-in ``True`` and ``False``
+    have this kind. Boolean number ``1`` and ``0`` are not relevant.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Q
+    >>> S.true.kind
+    BooleanKind
+    >>> Q.even(3).kind
+    BooleanKind
+    """
+    def __new__(cls):
+        return super().__new__(cls)
+
+    def __repr__(self):
+        return "BooleanKind"
+
+BooleanKind = _BooleanKind()
+
+
+class KindDispatcher:
+    """
+    Dispatcher to select a kind from multiple kinds by binary dispatching.
+
+    .. notes::
+       This approach is experimental, and can be replaced or deleted in
+       the future.
+
+    Explanation
+    ===========
+
+    SymPy object's :obj:`sympy.core.kind.Kind()` vaguely represents the
+    algebraic structure where the object belongs to. Therefore, with
+    given operation, we can always find a dominating kind among the
+    different kinds. This class selects the kind by recursive binary
+    dispatching. If the result cannot be determined, ``UndefinedKind``
+    is returned.
+
+    Examples
+    ========
+
+    Multiplication between numbers return number.
+
+    >>> from sympy import NumberKind, Mul
+    >>> Mul._kind_dispatcher(NumberKind, NumberKind)
+    NumberKind
+
+    Multiplication between number and unknown-kind object returns unknown kind.
+
+    >>> from sympy import UndefinedKind
+    >>> Mul._kind_dispatcher(NumberKind, UndefinedKind)
+    UndefinedKind
+
+    Any number and order of kinds is allowed.
+
+    >>> Mul._kind_dispatcher(UndefinedKind, NumberKind)
+    UndefinedKind
+    >>> Mul._kind_dispatcher(NumberKind, UndefinedKind, NumberKind)
+    UndefinedKind
+
+    Since matrix forms a vector space over scalar field, multiplication
+    between matrix with numeric element and number returns matrix with
+    numeric element.
+
+    >>> from sympy.matrices import MatrixKind
+    >>> Mul._kind_dispatcher(MatrixKind(NumberKind), NumberKind)
+    MatrixKind(NumberKind)
+
+    If a matrix with number element and another matrix with unknown-kind
+    element are multiplied, we know that the result is matrix but the
+    kind of its elements is unknown.
+
+    >>> Mul._kind_dispatcher(MatrixKind(NumberKind), MatrixKind(UndefinedKind))
+    MatrixKind(UndefinedKind)
+
+    Parameters
+    ==========
+
+    name : str
+
+    commutative : bool, optional
+        If True, binary dispatch will be automatically registered in
+        reversed order as well.
+
+    doc : str, optional
+
+    """
+    def __init__(self, name, commutative=False, doc=None):
+        self.name = name
+        self.doc = doc
+        self.commutative = commutative
+        self._dispatcher = Dispatcher(name)
+
+    def __repr__(self):
+        return "" % self.name
+
+    def register(self, *types, **kwargs):
+        """
+        Register the binary dispatcher for two kind classes.
+
+        If *self.commutative* is ``True``, signature in reversed order is
+        automatically registered as well.
+        """
+        on_ambiguity = kwargs.pop("on_ambiguity", None)
+        if not on_ambiguity:
+            if self.commutative:
+                on_ambiguity = ambiguity_register_error_ignore_dup
+            else:
+                on_ambiguity = ambiguity_warn
+        kwargs.update(on_ambiguity=on_ambiguity)
+
+        if not len(types) == 2:
+            raise RuntimeError(
+                "Only binary dispatch is supported, but got %s types: <%s>." % (
+                len(types), str_signature(types)
+            ))
+
+        def _(func):
+            self._dispatcher.add(types, func, **kwargs)
+            if self.commutative:
+                self._dispatcher.add(tuple(reversed(types)), func, **kwargs)
+        return _
+
+    def __call__(self, *args, **kwargs):
+        if self.commutative:
+            kinds = frozenset(args)
+        else:
+            kinds = []
+            prev = None
+            for a in args:
+                if prev is not a:
+                    kinds.append(a)
+                    prev = a
+        return self.dispatch_kinds(kinds, **kwargs)
+
+    @cacheit
+    def dispatch_kinds(self, kinds, **kwargs):
+        # Quick exit for the case where all kinds are same
+        if len(kinds) == 1:
+            result, = kinds
+            if not isinstance(result, Kind):
+                raise RuntimeError("%s is not a kind." % result)
+            return result
+
+        for i,kind in enumerate(kinds):
+            if not isinstance(kind, Kind):
+                raise RuntimeError("%s is not a kind." % kind)
+
+            if i == 0:
+                result = kind
+            else:
+                prev_kind = result
+
+                t1, t2 = type(prev_kind), type(kind)
+                k1, k2 = prev_kind, kind
+                func = self._dispatcher.dispatch(t1, t2)
+                if func is None and self.commutative:
+                    # try reversed order
+                    func = self._dispatcher.dispatch(t2, t1)
+                    k1, k2 = k2, k1
+                if func is None:
+                    # unregistered kind relation
+                    result = UndefinedKind
+                else:
+                    result = func(k1, k2)
+                if not isinstance(result, Kind):
+                    raise RuntimeError(
+                        "Dispatcher for {!r} and {!r} must return a Kind, but got {!r}".format(
+                        prev_kind, kind, result
+                    ))
+
+        return result
+
+    @property
+    def __doc__(self):
+        docs = [
+            "Kind dispatcher : %s" % self.name,
+            "Note that support for this is experimental. See the docs for :class:`KindDispatcher` for details"
+        ]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        s = "Registered kind classes\n"
+        s += '=' * len(s)
+        docs.append(s)
+
+        amb_sigs = []
+
+        typ_sigs = defaultdict(list)
+        for sigs in self._dispatcher.ordering[::-1]:
+            key = self._dispatcher.funcs[sigs]
+            typ_sigs[key].append(sigs)
+
+        for func, sigs in typ_sigs.items():
+
+            sigs_str = ', '.join('<%s>' % str_signature(sig) for sig in sigs)
+
+            if isinstance(func, RaiseNotImplementedError):
+                amb_sigs.append(sigs_str)
+                continue
+
+            s = 'Inputs: %s\n' % sigs_str
+            s += '-' * len(s) + '\n'
+            if func.__doc__:
+                s += func.__doc__.strip()
+            else:
+                s += func.__name__
+            docs.append(s)
+
+        if amb_sigs:
+            s = "Ambiguous kind classes\n"
+            s += '=' * len(s)
+            docs.append(s)
+
+            s = '\n'.join(amb_sigs)
+            docs.append(s)
+
+        return '\n\n'.join(docs)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/logic.py b/.venv/lib/python3.12/site-packages/sympy/core/logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..1c318063049a4657952c8ca84e0f0fdeef62a207
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/logic.py
@@ -0,0 +1,425 @@
+"""Logic expressions handling
+
+NOTE
+----
+
+at present this is mainly needed for facts.py, feel free however to improve
+this stuff for general purpose.
+"""
+
+from __future__ import annotations
+from typing import Optional
+
+# Type of a fuzzy bool
+FuzzyBool = Optional[bool]
+
+
+def _torf(args):
+    """Return True if all args are True, False if they
+    are all False, else None.
+
+    >>> from sympy.core.logic import _torf
+    >>> _torf((True, True))
+    True
+    >>> _torf((False, False))
+    False
+    >>> _torf((True, False))
+    """
+    sawT = sawF = False
+    for a in args:
+        if a is True:
+            if sawF:
+                return
+            sawT = True
+        elif a is False:
+            if sawT:
+                return
+            sawF = True
+        else:
+            return
+    return sawT
+
+
+def _fuzzy_group(args, quick_exit=False):
+    """Return True if all args are True, None if there is any None else False
+    unless ``quick_exit`` is True (then return None as soon as a second False
+    is seen.
+
+     ``_fuzzy_group`` is like ``fuzzy_and`` except that it is more
+    conservative in returning a False, waiting to make sure that all
+    arguments are True or False and returning None if any arguments are
+    None. It also has the capability of permiting only a single False and
+    returning None if more than one is seen. For example, the presence of a
+    single transcendental amongst rationals would indicate that the group is
+    no longer rational; but a second transcendental in the group would make the
+    determination impossible.
+
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import _fuzzy_group
+
+    By default, multiple Falses mean the group is broken:
+
+    >>> _fuzzy_group([False, False, True])
+    False
+
+    If multiple Falses mean the group status is unknown then set
+    `quick_exit` to True so None can be returned when the 2nd False is seen:
+
+    >>> _fuzzy_group([False, False, True], quick_exit=True)
+
+    But if only a single False is seen then the group is known to
+    be broken:
+
+    >>> _fuzzy_group([False, True, True], quick_exit=True)
+    False
+
+    """
+    saw_other = False
+    for a in args:
+        if a is True:
+            continue
+        if a is None:
+            return
+        if quick_exit and saw_other:
+            return
+        saw_other = True
+    return not saw_other
+
+
+def fuzzy_bool(x):
+    """Return True, False or None according to x.
+
+    Whereas bool(x) returns True or False, fuzzy_bool allows
+    for the None value and non-false values (which become None), too.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_bool
+    >>> from sympy.abc import x
+    >>> fuzzy_bool(x), fuzzy_bool(None)
+    (None, None)
+    >>> bool(x), bool(None)
+    (True, False)
+
+    """
+    if x is None:
+        return None
+    if x in (True, False):
+        return bool(x)
+
+
+def fuzzy_and(args):
+    """Return True (all True), False (any False) or None.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_and
+    >>> from sympy import Dummy
+
+    If you had a list of objects to test the commutivity of
+    and you want the fuzzy_and logic applied, passing an
+    iterator will allow the commutativity to only be computed
+    as many times as necessary. With this list, False can be
+    returned after analyzing the first symbol:
+
+    >>> syms = [Dummy(commutative=False), Dummy()]
+    >>> fuzzy_and(s.is_commutative for s in syms)
+    False
+
+    That False would require less work than if a list of pre-computed
+    items was sent:
+
+    >>> fuzzy_and([s.is_commutative for s in syms])
+    False
+    """
+
+    rv = True
+    for ai in args:
+        ai = fuzzy_bool(ai)
+        if ai is False:
+            return False
+        if rv:  # this will stop updating if a None is ever trapped
+            rv = ai
+    return rv
+
+
+def fuzzy_not(v):
+    """
+    Not in fuzzy logic
+
+    Return None if `v` is None else `not v`.
+
+    Examples
+    ========
+
+    >>> from sympy.core.logic import fuzzy_not
+    >>> fuzzy_not(True)
+    False
+    >>> fuzzy_not(None)
+    >>> fuzzy_not(False)
+    True
+
+    """
+    if v is None:
+        return v
+    else:
+        return not v
+
+
+def fuzzy_or(args):
+    """
+    Or in fuzzy logic. Returns True (any True), False (all False), or None
+
+    See the docstrings of fuzzy_and and fuzzy_not for more info.  fuzzy_or is
+    related to the two by the standard De Morgan's law.
+
+    >>> from sympy.core.logic import fuzzy_or
+    >>> fuzzy_or([True, False])
+    True
+    >>> fuzzy_or([True, None])
+    True
+    >>> fuzzy_or([False, False])
+    False
+    >>> print(fuzzy_or([False, None]))
+    None
+
+    """
+    rv = False
+    for ai in args:
+        ai = fuzzy_bool(ai)
+        if ai is True:
+            return True
+        if rv is False:  # this will stop updating if a None is ever trapped
+            rv = ai
+    return rv
+
+
+def fuzzy_xor(args):
+    """Return None if any element of args is not True or False, else
+    True (if there are an odd number of True elements), else False."""
+    t = 0
+    for a in args:
+        ai = fuzzy_bool(a)
+        if ai:
+            t += 1
+        elif ai is None:
+            return
+    return t % 2 == 1
+
+
+def fuzzy_nand(args):
+    """Return False if all args are True, True if they are all False,
+    else None."""
+    return fuzzy_not(fuzzy_and(args))
+
+
+class Logic:
+    """Logical expression"""
+    # {} 'op' -> LogicClass
+    op_2class: dict[str, type[Logic]] = {}
+
+    def __new__(cls, *args):
+        obj = object.__new__(cls)
+        obj.args = args
+        return obj
+
+    def __getnewargs__(self):
+        return self.args
+
+    def __hash__(self):
+        return hash((type(self).__name__,) + tuple(self.args))
+
+    def __eq__(a, b):
+        if not isinstance(b, type(a)):
+            return False
+        else:
+            return a.args == b.args
+
+    def __ne__(a, b):
+        if not isinstance(b, type(a)):
+            return True
+        else:
+            return a.args != b.args
+
+    def __lt__(self, other):
+        if self.__cmp__(other) == -1:
+            return True
+        return False
+
+    def __cmp__(self, other):
+        if type(self) is not type(other):
+            a = str(type(self))
+            b = str(type(other))
+        else:
+            a = self.args
+            b = other.args
+        return (a > b) - (a < b)
+
+    def __str__(self):
+        return '%s(%s)' % (self.__class__.__name__,
+                           ', '.join(str(a) for a in self.args))
+
+    __repr__ = __str__
+
+    @staticmethod
+    def fromstring(text):
+        """Logic from string with space around & and | but none after !.
+
+           e.g.
+
+           !a & b | c
+        """
+        lexpr = None  # current logical expression
+        schedop = None  # scheduled operation
+        for term in text.split():
+            # operation symbol
+            if term in '&|':
+                if schedop is not None:
+                    raise ValueError(
+                        'double op forbidden: "%s %s"' % (term, schedop))
+                if lexpr is None:
+                    raise ValueError(
+                        '%s cannot be in the beginning of expression' % term)
+                schedop = term
+                continue
+            if '&' in term or '|' in term:
+                raise ValueError('& and | must have space around them')
+            if term[0] == '!':
+                if len(term) == 1:
+                    raise ValueError('do not include space after "!"')
+                term = Not(term[1:])
+
+            # already scheduled operation, e.g. '&'
+            if schedop:
+                lexpr = Logic.op_2class[schedop](lexpr, term)
+                schedop = None
+                continue
+
+            # this should be atom
+            if lexpr is not None:
+                raise ValueError(
+                    'missing op between "%s" and "%s"' % (lexpr, term))
+
+            lexpr = term
+
+        # let's check that we ended up in correct state
+        if schedop is not None:
+            raise ValueError('premature end-of-expression in "%s"' % text)
+        if lexpr is None:
+            raise ValueError('"%s" is empty' % text)
+
+        # everything looks good now
+        return lexpr
+
+
+class AndOr_Base(Logic):
+
+    def __new__(cls, *args):
+        bargs = []
+        for a in args:
+            if a == cls.op_x_notx:
+                return a
+            elif a == (not cls.op_x_notx):
+                continue    # skip this argument
+            bargs.append(a)
+
+        args = sorted(set(cls.flatten(bargs)), key=hash)
+
+        for a in args:
+            if Not(a) in args:
+                return cls.op_x_notx
+
+        if len(args) == 1:
+            return args.pop()
+        elif len(args) == 0:
+            return not cls.op_x_notx
+
+        return Logic.__new__(cls, *args)
+
+    @classmethod
+    def flatten(cls, args):
+        # quick-n-dirty flattening for And and Or
+        args_queue = list(args)
+        res = []
+
+        while True:
+            try:
+                arg = args_queue.pop(0)
+            except IndexError:
+                break
+            if isinstance(arg, Logic):
+                if isinstance(arg, cls):
+                    args_queue.extend(arg.args)
+                    continue
+            res.append(arg)
+
+        args = tuple(res)
+        return args
+
+
+class And(AndOr_Base):
+    op_x_notx = False
+
+    def _eval_propagate_not(self):
+        # !(a&b&c ...) == !a | !b | !c ...
+        return Or(*[Not(a) for a in self.args])
+
+    # (a|b|...) & c == (a&c) | (b&c) | ...
+    def expand(self):
+
+        # first locate Or
+        for i, arg in enumerate(self.args):
+            if isinstance(arg, Or):
+                arest = self.args[:i] + self.args[i + 1:]
+
+                orterms = [And(*(arest + (a,))) for a in arg.args]
+                for j in range(len(orterms)):
+                    if isinstance(orterms[j], Logic):
+                        orterms[j] = orterms[j].expand()
+
+                res = Or(*orterms)
+                return res
+
+        return self
+
+
+class Or(AndOr_Base):
+    op_x_notx = True
+
+    def _eval_propagate_not(self):
+        # !(a|b|c ...) == !a & !b & !c ...
+        return And(*[Not(a) for a in self.args])
+
+
+class Not(Logic):
+
+    def __new__(cls, arg):
+        if isinstance(arg, str):
+            return Logic.__new__(cls, arg)
+
+        elif isinstance(arg, bool):
+            return not arg
+        elif isinstance(arg, Not):
+            return arg.args[0]
+
+        elif isinstance(arg, Logic):
+            # XXX this is a hack to expand right from the beginning
+            arg = arg._eval_propagate_not()
+            return arg
+
+        else:
+            raise ValueError('Not: unknown argument %r' % (arg,))
+
+    @property
+    def arg(self):
+        return self.args[0]
+
+
+Logic.op_2class['&'] = And
+Logic.op_2class['|'] = Or
+Logic.op_2class['!'] = Not
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/mod.py b/.venv/lib/python3.12/site-packages/sympy/core/mod.py
new file mode 100644
index 0000000000000000000000000000000000000000..8be0c56e497eb5ed0041801488044b50f907962c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/mod.py
@@ -0,0 +1,260 @@
+from .add import Add
+from .exprtools import gcd_terms
+from .function import DefinedFunction
+from .kind import NumberKind
+from .logic import fuzzy_and, fuzzy_not
+from .mul import Mul
+from .numbers import equal_valued
+from .relational import is_le, is_lt, is_ge, is_gt
+from .singleton import S
+
+
+class Mod(DefinedFunction):
+    """Represents a modulo operation on symbolic expressions.
+
+    Parameters
+    ==========
+
+    p : Expr
+        Dividend.
+
+    q : Expr
+        Divisor.
+
+    Notes
+    =====
+
+    The convention used is the same as Python's: the remainder always has the
+    same sign as the divisor.
+
+    Many objects can be evaluated modulo ``n`` much faster than they can be
+    evaluated directly (or at all).  For this, ``evaluate=False`` is
+    necessary to prevent eager evaluation:
+
+    >>> from sympy import binomial, factorial, Mod, Pow
+    >>> Mod(Pow(2, 10**16, evaluate=False), 97)
+    61
+    >>> Mod(factorial(10**9, evaluate=False), 10**9 + 9)
+    712524808
+    >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
+    3744312326
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> x**2 % y
+    Mod(x**2, y)
+    >>> _.subs({x: 5, y: 6})
+    1
+
+    """
+
+    kind = NumberKind
+
+    @classmethod
+    def eval(cls, p, q):
+        def number_eval(p, q):
+            """Try to return p % q if both are numbers or +/-p is known
+            to be less than or equal q.
+            """
+
+            if q.is_zero:
+                raise ZeroDivisionError("Modulo by zero")
+            if p is S.NaN or q is S.NaN or p.is_finite is False or q.is_finite is False:
+                return S.NaN
+            if p is S.Zero or p in (q, -q) or (p.is_integer and q == 1):
+                return S.Zero
+
+            if q.is_Number:
+                if p.is_Number:
+                    return p%q
+                if q == 2:
+                    if p.is_even:
+                        return S.Zero
+                    elif p.is_odd:
+                        return S.One
+
+            if hasattr(p, '_eval_Mod'):
+                rv = getattr(p, '_eval_Mod')(q)
+                if rv is not None:
+                    return rv
+
+            # by ratio
+            r = p/q
+            if r.is_integer:
+                return S.Zero
+            try:
+                d = int(r)
+            except TypeError:
+                pass
+            else:
+                if isinstance(d, int):
+                    rv = p - d*q
+                    if (rv*q < 0) == True:
+                        rv += q
+                    return rv
+
+            # by difference
+            # -2|q| < p < 2|q|
+            if q.is_positive:
+                comp1, comp2 = is_le, is_lt
+            elif q.is_negative:
+                comp1, comp2 = is_ge, is_gt
+            else:
+                return
+            ls = -2*q
+            r = p - q
+            for _ in range(4):
+                if not comp1(ls, p):
+                    return
+                if comp2(r, ls):
+                    return p - ls
+                ls += q
+
+        rv = number_eval(p, q)
+        if rv is not None:
+            return rv
+
+        # denest
+        if isinstance(p, cls):
+            qinner = p.args[1]
+            if qinner % q == 0:
+                return cls(p.args[0], q)
+            elif (qinner*(q - qinner)).is_nonnegative:
+                # |qinner| < |q| and have same sign
+                return p
+        elif isinstance(-p, cls):
+            qinner = (-p).args[1]
+            if qinner % q == 0:
+                return cls(-(-p).args[0], q)
+            elif (qinner*(q + qinner)).is_nonpositive:
+                # |qinner| < |q| and have different sign
+                return p
+        elif isinstance(p, Add):
+            # separating into modulus and non modulus
+            both_l = non_mod_l, mod_l = [], []
+            for arg in p.args:
+                both_l[isinstance(arg, cls)].append(arg)
+            # if q same for all
+            if mod_l and all(inner.args[1] == q for inner in mod_l):
+                net = Add(*non_mod_l) + Add(*[i.args[0] for i in mod_l])
+                return cls(net, q)
+
+        elif isinstance(p, Mul):
+            # separating into modulus and non modulus
+            both_l = non_mod_l, mod_l = [], []
+            for arg in p.args:
+                both_l[isinstance(arg, cls)].append(arg)
+
+            if mod_l and all(inner.args[1] == q for inner in mod_l) and all(t.is_integer for t in p.args) and q.is_integer:
+                # finding distributive term
+                non_mod_l = [cls(x, q) for x in non_mod_l]
+                mod = []
+                non_mod = []
+                for j in non_mod_l:
+                    if isinstance(j, cls):
+                        mod.append(j.args[0])
+                    else:
+                        non_mod.append(j)
+                prod_mod = Mul(*mod)
+                prod_non_mod = Mul(*non_mod)
+                prod_mod1 = Mul(*[i.args[0] for i in mod_l])
+                net = prod_mod1*prod_mod
+                return prod_non_mod*cls(net, q)
+
+            if q.is_Integer and q is not S.One:
+                if all(t.is_integer for t in p.args):
+                    non_mod_l = [i % q if i.is_Integer else i for i in p.args]
+                    if any(iq is S.Zero for iq in non_mod_l):
+                        return S.Zero
+
+            p = Mul(*(non_mod_l + mod_l))
+
+        # XXX other possibilities?
+
+        from sympy.polys.polyerrors import PolynomialError
+        from sympy.polys.polytools import gcd
+
+        # extract gcd; any further simplification should be done by the user
+        try:
+            G = gcd(p, q)
+            if not equal_valued(G, 1):
+                p, q = [gcd_terms(i/G, clear=False, fraction=False)
+                        for i in (p, q)]
+        except PolynomialError:  # issue 21373
+            G = S.One
+        pwas, qwas = p, q
+
+        # simplify terms
+        # (x + y + 2) % x -> Mod(y + 2, x)
+        if p.is_Add:
+            args = []
+            for i in p.args:
+                a = cls(i, q)
+                if a.count(cls) > i.count(cls):
+                    args.append(i)
+                else:
+                    args.append(a)
+            if args != list(p.args):
+                p = Add(*args)
+
+        else:
+            # handle coefficients if they are not Rational
+            # since those are not handled by factor_terms
+            # e.g. Mod(.6*x, .3*y) -> 0.3*Mod(2*x, y)
+            cp, p = p.as_coeff_Mul()
+            cq, q = q.as_coeff_Mul()
+            ok = False
+            if not cp.is_Rational or not cq.is_Rational:
+                r = cp % cq
+                if equal_valued(r, 0):
+                    G *= cq
+                    p *= int(cp/cq)
+                    ok = True
+            if not ok:
+                p = cp*p
+                q = cq*q
+
+        # simple -1 extraction
+        if p.could_extract_minus_sign() and q.could_extract_minus_sign():
+            G, p, q = [-i for i in (G, p, q)]
+
+        # check again to see if p and q can now be handled as numbers
+        rv = number_eval(p, q)
+        if rv is not None:
+            return rv*G
+
+        # put 1.0 from G on inside
+        if G.is_Float and equal_valued(G, 1):
+            p *= G
+            return cls(p, q, evaluate=False)
+        elif G.is_Mul and G.args[0].is_Float and equal_valued(G.args[0], 1):
+            p = G.args[0]*p
+            G = Mul._from_args(G.args[1:])
+        return G*cls(p, q, evaluate=(p, q) != (pwas, qwas))
+
+    def _eval_is_integer(self):
+        p, q = self.args
+        if fuzzy_and([p.is_integer, q.is_integer, fuzzy_not(q.is_zero)]):
+            return True
+
+    def _eval_is_nonnegative(self):
+        if self.args[1].is_positive:
+            return True
+
+    def _eval_is_nonpositive(self):
+        if self.args[1].is_negative:
+            return True
+
+    def _eval_rewrite_as_floor(self, a, b, **kwargs):
+        from sympy.functions.elementary.integers import floor
+        return a - b*floor(a/b)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.functions.elementary.integers import floor
+        return self.rewrite(floor)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.functions.elementary.integers import floor
+        return self.rewrite(floor)._eval_nseries(x, n, logx=logx, cdir=cdir)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/mul.py b/.venv/lib/python3.12/site-packages/sympy/core/mul.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd83c8610a76db4e7bc7a2a71b98e437bd00a28e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/mul.py
@@ -0,0 +1,2214 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, ClassVar
+
+from collections import defaultdict
+from functools import reduce
+from itertools import product
+import operator
+
+from .sympify import sympify
+from .basic import Basic, _args_sortkey
+from .singleton import S
+from .operations import AssocOp, AssocOpDispatcher
+from .cache import cacheit
+from .intfunc import integer_nthroot, trailing
+from .logic import fuzzy_not, _fuzzy_group
+from .expr import Expr
+from .parameters import global_parameters
+from .kind import KindDispatcher
+from .traversal import bottom_up
+from sympy.utilities.iterables import sift
+
+
+# internal marker to indicate:
+#   "there are still non-commutative objects -- don't forget to process them"
+class NC_Marker:
+    is_Order = False
+    is_Mul = False
+    is_Number = False
+    is_Poly = False
+
+    is_commutative = False
+
+
+def _mulsort(args):
+    # in-place sorting of args
+    args.sort(key=_args_sortkey)
+
+
+def _unevaluated_Mul(*args):
+    """Return a well-formed unevaluated Mul: Numbers are collected and
+    put in slot 0, any arguments that are Muls will be flattened, and args
+    are sorted. Use this when args have changed but you still want to return
+    an unevaluated Mul.
+
+    Examples
+    ========
+
+    >>> from sympy.core.mul import _unevaluated_Mul as uMul
+    >>> from sympy import S, sqrt, Mul
+    >>> from sympy.abc import x
+    >>> a = uMul(*[S(3.0), x, S(2)])
+    >>> a.args[0]
+    6.00000000000000
+    >>> a.args[1]
+    x
+
+    Two unevaluated Muls with the same arguments will
+    always compare as equal during testing:
+
+    >>> m = uMul(sqrt(2), sqrt(3))
+    >>> m == uMul(sqrt(3), sqrt(2))
+    True
+    >>> u = Mul(sqrt(3), sqrt(2), evaluate=False)
+    >>> m == uMul(u)
+    True
+    >>> m == Mul(*m.args)
+    False
+
+    """
+    cargs = []
+    ncargs = []
+    args = list(args)
+    co = S.One
+    for a in args:
+        if a.is_Mul:
+            a_c, a_nc = a.args_cnc()
+            args.extend(a_c)  # grow args
+            ncargs.extend(a_nc)
+        elif a.is_Number:
+            co *= a
+        elif a.is_commutative:
+            cargs.append(a)
+        else:
+            ncargs.append(a)
+    _mulsort(cargs)
+    if co is not S.One:
+        cargs.insert(0, co)
+    return Mul._from_args(cargs+ncargs)
+
+
+class Mul(Expr, AssocOp):
+    """
+    Expression representing multiplication operation for algebraic field.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Every argument of ``Mul()`` must be ``Expr``. Infix operator ``*``
+    on most scalar objects in SymPy calls this class.
+
+    Another use of ``Mul()`` is to represent the structure of abstract
+    multiplication so that its arguments can be substituted to return
+    different class. Refer to examples section for this.
+
+    ``Mul()`` evaluates the argument unless ``evaluate=False`` is passed.
+    The evaluation logic includes:
+
+    1. Flattening
+        ``Mul(x, Mul(y, z))`` -> ``Mul(x, y, z)``
+
+    2. Identity removing
+        ``Mul(x, 1, y)`` -> ``Mul(x, y)``
+
+    3. Exponent collecting by ``.as_base_exp()``
+        ``Mul(x, x**2)`` -> ``Pow(x, 3)``
+
+    4. Term sorting
+        ``Mul(y, x, 2)`` -> ``Mul(2, x, y)``
+
+    Since multiplication can be vector space operation, arguments may
+    have the different :obj:`sympy.core.kind.Kind()`. Kind of the
+    resulting object is automatically inferred.
+
+    Examples
+    ========
+
+    >>> from sympy import Mul
+    >>> from sympy.abc import x, y
+    >>> Mul(x, 1)
+    x
+    >>> Mul(x, x)
+    x**2
+
+    If ``evaluate=False`` is passed, result is not evaluated.
+
+    >>> Mul(1, 2, evaluate=False)
+    1*2
+    >>> Mul(x, x, evaluate=False)
+    x*x
+
+    ``Mul()`` also represents the general structure of multiplication
+    operation.
+
+    >>> from sympy import MatrixSymbol
+    >>> A = MatrixSymbol('A', 2,2)
+    >>> expr = Mul(x,y).subs({y:A})
+    >>> expr
+    x*A
+    >>> type(expr)
+    
+
+    See Also
+    ========
+
+    MatMul
+
+    """
+    __slots__ = ()
+
+    is_Mul = True
+
+    _args_type = Expr
+    _kind_dispatcher = KindDispatcher("Mul_kind_dispatcher", commutative=True)
+
+    identity: ClassVar[Expr]
+
+    @property
+    def kind(self):
+        arg_kinds = (a.kind for a in self.args)
+        return self._kind_dispatcher(*arg_kinds)
+
+    if TYPE_CHECKING:
+
+        def __new__(cls, *args: Expr | complex, evaluate: bool=True) -> Expr: # type: ignore
+            ...
+
+        @property
+        def args(self) -> tuple[Expr, ...]:
+            ...
+
+    def could_extract_minus_sign(self):
+        if self == (-self):
+            return False  # e.g. zoo*x == -zoo*x
+        c = self.args[0]
+        return c.is_Number and c.is_extended_negative
+
+    def __neg__(self):
+        c, args = self.as_coeff_mul()
+        if args[0] is not S.ComplexInfinity:
+            c = -c
+        if c is not S.One:
+            if args[0].is_Number:
+                args = list(args)
+                if c is S.NegativeOne:
+                    args[0] = -args[0]
+                else:
+                    args[0] *= c
+            else:
+                args = (c,) + args
+        return self._from_args(args, self.is_commutative)
+
+    @classmethod
+    def flatten(cls, seq):
+        """Return commutative, noncommutative and order arguments by
+        combining related terms.
+
+        Notes
+        =====
+            * In an expression like ``a*b*c``, Python process this through SymPy
+              as ``Mul(Mul(a, b), c)``. This can have undesirable consequences.
+
+              -  Sometimes terms are not combined as one would like:
+                 {c.f. https://github.com/sympy/sympy/issues/4596}
+
+                >>> from sympy import Mul, sqrt
+                >>> from sympy.abc import x, y, z
+                >>> 2*(x + 1) # this is the 2-arg Mul behavior
+                2*x + 2
+                >>> y*(x + 1)*2
+                2*y*(x + 1)
+                >>> 2*(x + 1)*y # 2-arg result will be obtained first
+                y*(2*x + 2)
+                >>> Mul(2, x + 1, y) # all 3 args simultaneously processed
+                2*y*(x + 1)
+                >>> 2*((x + 1)*y) # parentheses can control this behavior
+                2*y*(x + 1)
+
+                Powers with compound bases may not find a single base to
+                combine with unless all arguments are processed at once.
+                Post-processing may be necessary in such cases.
+                {c.f. https://github.com/sympy/sympy/issues/5728}
+
+                >>> a = sqrt(x*sqrt(y))
+                >>> a**3
+                (x*sqrt(y))**(3/2)
+                >>> Mul(a,a,a)
+                (x*sqrt(y))**(3/2)
+                >>> a*a*a
+                x*sqrt(y)*sqrt(x*sqrt(y))
+                >>> _.subs(a.base, z).subs(z, a.base)
+                (x*sqrt(y))**(3/2)
+
+              -  If more than two terms are being multiplied then all the
+                 previous terms will be re-processed for each new argument.
+                 So if each of ``a``, ``b`` and ``c`` were :class:`Mul`
+                 expression, then ``a*b*c`` (or building up the product
+                 with ``*=``) will process all the arguments of ``a`` and
+                 ``b`` twice: once when ``a*b`` is computed and again when
+                 ``c`` is multiplied.
+
+                 Using ``Mul(a, b, c)`` will process all arguments once.
+
+            * The results of Mul are cached according to arguments, so flatten
+              will only be called once for ``Mul(a, b, c)``. If you can
+              structure a calculation so the arguments are most likely to be
+              repeats then this can save time in computing the answer. For
+              example, say you had a Mul, M, that you wished to divide by ``d[i]``
+              and multiply by ``n[i]`` and you suspect there are many repeats
+              in ``n``. It would be better to compute ``M*n[i]/d[i]`` rather
+              than ``M/d[i]*n[i]`` since every time n[i] is a repeat, the
+              product, ``M*n[i]`` will be returned without flattening -- the
+              cached value will be returned. If you divide by the ``d[i]``
+              first (and those are more unique than the ``n[i]``) then that will
+              create a new Mul, ``M/d[i]`` the args of which will be traversed
+              again when it is multiplied by ``n[i]``.
+
+              {c.f. https://github.com/sympy/sympy/issues/5706}
+
+              This consideration is moot if the cache is turned off.
+
+            NB
+            --
+              The validity of the above notes depends on the implementation
+              details of Mul and flatten which may change at any time. Therefore,
+              you should only consider them when your code is highly performance
+              sensitive.
+
+              Removal of 1 from the sequence is already handled by AssocOp.__new__.
+        """
+
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.matrices.expressions import MatrixExpr
+        rv = None
+        if len(seq) == 2:
+            a, b = seq
+            if b.is_Rational:
+                a, b = b, a
+                seq = [a, b]
+            assert a is not S.One
+            if a.is_Rational and not a.is_zero:
+                r, b = b.as_coeff_Mul()
+                if b.is_Add:
+                    if r is not S.One:  # 2-arg hack
+                        # leave the Mul as a Mul?
+                        ar = a*r
+                        if ar is S.One:
+                            arb = b
+                        else:
+                            arb = cls(a*r, b, evaluate=False)
+                        rv = [arb], [], None
+                    elif global_parameters.distribute and b.is_commutative:
+                        newb = Add(*[_keep_coeff(a, bi) for bi in b.args])
+                        rv = [newb], [], None
+            if rv:
+                return rv
+
+        # apply associativity, separate commutative part of seq
+        c_part = []         # out: commutative factors
+        nc_part = []        # out: non-commutative factors
+
+        nc_seq = []
+
+        coeff = S.One       # standalone term
+                            # e.g. 3 * ...
+
+        c_powers = []       # (base,exp)      n
+                            # e.g. (x,n) for x
+
+        num_exp = []        # (num-base, exp)           y
+                            # e.g.  (3, y)  for  ... * 3  * ...
+
+        neg1e = S.Zero      # exponent on -1 extracted from Number-based Pow and I
+
+        pnum_rat = {}       # (num-base, Rat-exp)          1/2
+                            # e.g.  (3, 1/2)  for  ... * 3     * ...
+
+        order_symbols = None
+
+        # --- PART 1 ---
+        #
+        # "collect powers and coeff":
+        #
+        # o coeff
+        # o c_powers
+        # o num_exp
+        # o neg1e
+        # o pnum_rat
+        #
+        # NOTE: this is optimized for all-objects-are-commutative case
+        for o in seq:
+            # O(x)
+            if o.is_Order:
+                o, order_symbols = o.as_expr_variables(order_symbols)
+
+            # Mul([...])
+            if o.is_Mul:
+                if o.is_commutative:
+                    seq.extend(o.args)    # XXX zerocopy?
+
+                else:
+                    # NCMul can have commutative parts as well
+                    for q in o.args:
+                        if q.is_commutative:
+                            seq.append(q)
+                        else:
+                            nc_seq.append(q)
+
+                    # append non-commutative marker, so we don't forget to
+                    # process scheduled non-commutative objects
+                    seq.append(NC_Marker)
+
+                continue
+
+            # 3
+            elif o.is_Number:
+                if o is S.NaN or coeff is S.ComplexInfinity and o.is_zero:
+                    # we know for sure the result will be nan
+                    return [S.NaN], [], None
+                elif coeff.is_Number or isinstance(coeff, AccumBounds):  # it could be zoo
+                    coeff *= o
+                    if coeff is S.NaN:
+                        # we know for sure the result will be nan
+                        return [S.NaN], [], None
+                continue
+
+            elif isinstance(o, AccumBounds):
+                coeff = o.__mul__(coeff)
+                continue
+
+            elif o is S.ComplexInfinity:
+                if not coeff:
+                    # 0 * zoo = NaN
+                    return [S.NaN], [], None
+                coeff = S.ComplexInfinity
+                continue
+
+            elif not coeff and isinstance(o, Add) and any(
+                    _ in (S.NegativeInfinity, S.ComplexInfinity, S.Infinity)
+                    for __ in o.args for _ in Mul.make_args(__)):
+                # e.g 0 * (x + oo) = NaN but not
+                # 0 * (1 + Integral(x, (x, 0, oo))) which is
+                # treated like 0 * x -> 0
+                return [S.NaN], [], None
+
+            elif o is S.ImaginaryUnit:
+                neg1e += S.Half
+                continue
+
+            elif o.is_commutative:
+                #      e
+                # o = b
+                b, e = o.as_base_exp()
+
+                #  y
+                # 3
+                if o.is_Pow:
+                    if b.is_Number:
+
+                        # get all the factors with numeric base so they can be
+                        # combined below, but don't combine negatives unless
+                        # the exponent is an integer
+                        if e.is_Rational:
+                            if e.is_Integer:
+                                coeff *= Pow(b, e)  # it is an unevaluated power
+                                continue
+                            elif e.is_negative:    # also a sign of an unevaluated power
+                                seq.append(Pow(b, e))
+                                continue
+                            elif b.is_negative:
+                                neg1e += e
+                                b = -b
+                            if b is not S.One:
+                                pnum_rat.setdefault(b, []).append(e)
+                            continue
+                        elif b.is_positive or e.is_integer:
+                            num_exp.append((b, e))
+                            continue
+
+                c_powers.append((b, e))
+
+            # NON-COMMUTATIVE
+            # TODO: Make non-commutative exponents not combine automatically
+            else:
+                if o is not NC_Marker:
+                    nc_seq.append(o)
+
+                # process nc_seq (if any)
+                while nc_seq:
+                    o = nc_seq.pop(0)
+                    if not nc_part:
+                        nc_part.append(o)
+                        continue
+
+                    #                             b    c       b+c
+                    # try to combine last terms: a  * a   ->  a
+                    o1 = nc_part.pop()
+                    b1, e1 = o1.as_base_exp()
+                    b2, e2 = o.as_base_exp()
+                    new_exp = e1 + e2
+                    # Only allow powers to combine if the new exponent is
+                    # not an Add. This allow things like a**2*b**3 == a**5
+                    # if a.is_commutative == False, but prohibits
+                    # a**x*a**y and x**a*x**b from combining (x,y commute).
+                    if b1 == b2 and (not new_exp.is_Add):
+                        o12 = b1 ** new_exp
+
+                        # now o12 could be a commutative object
+                        if o12.is_commutative:
+                            seq.append(o12)
+                            continue
+                        else:
+                            nc_seq.insert(0, o12)
+
+                    else:
+                        nc_part.extend([o1, o])
+
+        # We do want a combined exponent if it would not be an Add, such as
+        #  y    2y     3y
+        # x  * x   -> x
+        # We determine if two exponents have the same term by using
+        # as_coeff_Mul.
+        #
+        # Unfortunately, this isn't smart enough to consider combining into
+        # exponents that might already be adds, so things like:
+        #  z - y    y
+        # x      * x  will be left alone.  This is because checking every possible
+        # combination can slow things down.
+
+        # gather exponents of common bases...
+        def _gather(c_powers):
+            common_b = {}  # b:e
+            for b, e in c_powers:
+                co = e.as_coeff_Mul()
+                common_b.setdefault(b, {}).setdefault(
+                    co[1], []).append(co[0])
+            for b, d in common_b.items():
+                for di, li in d.items():
+                    d[di] = Add(*li)
+            new_c_powers = []
+            for b, e in common_b.items():
+                new_c_powers.extend([(b, c*t) for t, c in e.items()])
+            return new_c_powers
+
+        # in c_powers
+        c_powers = _gather(c_powers)
+
+        # and in num_exp
+        num_exp = _gather(num_exp)
+
+        # --- PART 2 ---
+        #
+        # o process collected powers  (x**0 -> 1; x**1 -> x; otherwise Pow)
+        # o combine collected powers  (2**x * 3**x -> 6**x)
+        #   with numeric base
+
+        # ................................
+        # now we have:
+        # - coeff:
+        # - c_powers:    (b, e)
+        # - num_exp:     (2, e)
+        # - pnum_rat:    {(1/3, [1/3, 2/3, 1/4])}
+
+        #  0             1
+        # x  -> 1       x  -> x
+
+        # this should only need to run twice; if it fails because
+        # it needs to be run more times, perhaps this should be
+        # changed to a "while True" loop -- the only reason it
+        # isn't such now is to allow a less-than-perfect result to
+        # be obtained rather than raising an error or entering an
+        # infinite loop
+        for i in range(2):
+            new_c_powers = []
+            changed = False
+            for b, e in c_powers:
+                if e.is_zero:
+                    # canceling out infinities yields NaN
+                    if (b.is_Add or b.is_Mul) and any(infty in b.args
+                        for infty in (S.ComplexInfinity, S.Infinity,
+                                      S.NegativeInfinity)):
+                        return [S.NaN], [], None
+                    continue
+                if e is S.One:
+                    if b.is_Number:
+                        coeff *= b
+                        continue
+                    p = b
+                if e is not S.One:
+                    p = Pow(b, e)
+                    # check to make sure that the base doesn't change
+                    # after exponentiation; to allow for unevaluated
+                    # Pow, we only do so if b is not already a Pow
+                    if p.is_Pow and not b.is_Pow:
+                        bi = b
+                        b, e = p.as_base_exp()
+                        if b != bi:
+                            changed = True
+                c_part.append(p)
+                new_c_powers.append((b, e))
+            # there might have been a change, but unless the base
+            # matches some other base, there is nothing to do
+            if changed and len({
+                    b for b, e in new_c_powers}) != len(new_c_powers):
+                # start over again
+                c_part = []
+                c_powers = _gather(new_c_powers)
+            else:
+                break
+
+        #  x    x     x
+        # 2  * 3  -> 6
+        inv_exp_dict = {}   # exp:Mul(num-bases)     x    x
+                            # e.g.  x:6  for  ... * 2  * 3  * ...
+        for b, e in num_exp:
+            inv_exp_dict.setdefault(e, []).append(b)
+        for e, b in inv_exp_dict.items():
+            inv_exp_dict[e] = cls(*b)
+        c_part.extend([Pow(b, e) for e, b in inv_exp_dict.items() if e])
+
+        # b, e -> e' = sum(e), b
+        # {(1/5, [1/3]), (1/2, [1/12, 1/4]} -> {(1/3, [1/5, 1/2])}
+        comb_e = {}
+        for b, e in pnum_rat.items():
+            comb_e.setdefault(Add(*e), []).append(b)
+        del pnum_rat
+        # process them, reducing exponents to values less than 1
+        # and updating coeff if necessary else adding them to
+        # num_rat for further processing
+        num_rat = []
+        for e, b in comb_e.items():
+            b = cls(*b)
+            if e.q == 1:
+                coeff *= Pow(b, e)
+                continue
+            if e.p > e.q:
+                e_i, ep = divmod(e.p, e.q)
+                coeff *= Pow(b, e_i)
+                e = Rational(ep, e.q)
+            num_rat.append((b, e))
+        del comb_e
+
+        # extract gcd of bases in num_rat
+        # 2**(1/3)*6**(1/4) -> 2**(1/3+1/4)*3**(1/4)
+        pnew = defaultdict(list)
+        i = 0  # steps through num_rat which may grow
+        while i < len(num_rat):
+            bi, ei = num_rat[i]
+            if bi == 1:
+                i += 1
+                continue
+            grow = []
+            for j in range(i + 1, len(num_rat)):
+                bj, ej = num_rat[j]
+                g = bi.gcd(bj)
+                if g is not S.One:
+                    # 4**r1*6**r2 -> 2**(r1+r2)  *  2**r1 *  3**r2
+                    # this might have a gcd with something else
+                    e = ei + ej
+                    if e.q == 1:
+                        coeff *= Pow(g, e)
+                    else:
+                        if e.p > e.q:
+                            e_i, ep = divmod(e.p, e.q)  # change e in place
+                            coeff *= Pow(g, e_i)
+                            e = Rational(ep, e.q)
+                        grow.append((g, e))
+                    # update the jth item
+                    num_rat[j] = (bj/g, ej)
+                    # update bi that we are checking with
+                    bi = bi/g
+                    if bi is S.One:
+                        break
+            if bi is not S.One:
+                obj = Pow(bi, ei)
+                if obj.is_Number:
+                    coeff *= obj
+                else:
+                    # changes like sqrt(12) -> 2*sqrt(3)
+                    for obj in Mul.make_args(obj):
+                        if obj.is_Number:
+                            coeff *= obj
+                        else:
+                            assert obj.is_Pow
+                            bi, ei = obj.args
+                            pnew[ei].append(bi)
+
+            num_rat.extend(grow)
+            i += 1
+
+        # combine bases of the new powers
+        for e, b in pnew.items():
+            pnew[e] = cls(*b)
+
+        # handle -1 and I
+        if neg1e:
+            # treat I as (-1)**(1/2) and compute -1's total exponent
+            p, q =  neg1e.as_numer_denom()
+            # if the integer part is odd, extract -1
+            n, p = divmod(p, q)
+            if n % 2:
+                coeff = -coeff
+            # if it's a multiple of 1/2 extract I
+            if q == 2:
+                c_part.append(S.ImaginaryUnit)
+            elif p:
+                # see if there is any positive base this power of
+                # -1 can join
+                neg1e = Rational(p, q)
+                for e, b in pnew.items():
+                    if e == neg1e and b.is_positive:
+                        pnew[e] = -b
+                        break
+                else:
+                    # keep it separate; we've already evaluated it as
+                    # much as possible so evaluate=False
+                    c_part.append(Pow(S.NegativeOne, neg1e, evaluate=False))
+
+        # add all the pnew powers
+        c_part.extend([Pow(b, e) for e, b in pnew.items()])
+
+        # oo, -oo
+        if coeff in (S.Infinity, S.NegativeInfinity):
+            def _handle_for_oo(c_part, coeff_sign):
+                new_c_part = []
+                for t in c_part:
+                    if t.is_extended_positive:
+                        continue
+                    if t.is_extended_negative:
+                        coeff_sign *= -1
+                        continue
+                    new_c_part.append(t)
+                return new_c_part, coeff_sign
+            c_part, coeff_sign = _handle_for_oo(c_part, 1)
+            nc_part, coeff_sign = _handle_for_oo(nc_part, coeff_sign)
+            coeff *= coeff_sign
+
+        # zoo
+        if coeff is S.ComplexInfinity:
+            # zoo might be
+            #   infinite_real + bounded_im
+            #   bounded_real + infinite_im
+            #   infinite_real + infinite_im
+            # and non-zero real or imaginary will not change that status.
+            c_part = [c for c in c_part if not (fuzzy_not(c.is_zero) and
+                                                c.is_extended_real is not None)]
+            nc_part = [c for c in nc_part if not (fuzzy_not(c.is_zero) and
+                                                  c.is_extended_real is not None)]
+
+        # 0
+        elif coeff.is_zero:
+            # we know for sure the result will be 0 except the multiplicand
+            # is infinity or a matrix
+            if any(isinstance(c, MatrixExpr) for c in nc_part):
+                return [coeff], nc_part, order_symbols
+            if any(c.is_finite == False for c in c_part):
+                return [S.NaN], [], order_symbols
+            return [coeff], [], order_symbols
+
+        # check for straggling Numbers that were produced
+        _new = []
+        for i in c_part:
+            if i.is_Number:
+                coeff *= i
+            else:
+                _new.append(i)
+        c_part = _new
+
+        # order commutative part canonically
+        _mulsort(c_part)
+
+        # current code expects coeff to be always in slot-0
+        if coeff is not S.One:
+            c_part.insert(0, coeff)
+
+        # we are done
+        if (global_parameters.distribute and not nc_part and len(c_part) == 2 and
+                c_part[0].is_Number and c_part[0].is_finite and c_part[1].is_Add):
+            # 2*(1+a) -> 2 + 2 * a
+            coeff = c_part[0]
+            c_part = [Add(*[coeff*f for f in c_part[1].args])]
+
+        return c_part, nc_part, order_symbols
+
+    def _eval_power(self, expt):
+
+        # don't break up NC terms: (A*B)**3 != A**3*B**3, it is A*B*A*B*A*B
+        cargs, nc = self.args_cnc(split_1=False)
+
+        if expt.is_Integer:
+            return Mul(*[Pow(b, expt, evaluate=False) for b in cargs]) * \
+                Pow(Mul._from_args(nc), expt, evaluate=False)
+        if expt.is_Rational and expt.q == 2:
+            if self.is_imaginary:
+                a = self.as_real_imag()[1]
+                if a.is_Rational:
+                    n, d = abs(a/2).as_numer_denom()
+                    n, t = integer_nthroot(n, 2)
+                    if t:
+                        d, t = integer_nthroot(d, 2)
+                        if t:
+                            from sympy.functions.elementary.complexes import sign
+                            r = sympify(n)/d
+                            return _unevaluated_Mul(r**expt.p, (1 + sign(a)*S.ImaginaryUnit)**expt.p)
+
+        p = Pow(self, expt, evaluate=False)
+
+        if expt.is_Rational or expt.is_Float:
+            return p._eval_expand_power_base()
+
+        return p
+
+    @classmethod
+    def class_key(cls):
+        return 3, 0, cls.__name__
+
+    def _eval_evalf(self, prec):
+        c, m = self.as_coeff_Mul()
+        if c is S.NegativeOne:
+            if m.is_Mul:
+                rv = -AssocOp._eval_evalf(m, prec)
+            else:
+                mnew = m._eval_evalf(prec)
+                if mnew is not None:
+                    m = mnew
+                rv = -m
+        else:
+            rv = AssocOp._eval_evalf(self, prec)
+        if rv.is_number:
+            return rv.expand()
+        return rv
+
+    @property
+    def _mpc_(self):
+        """
+        Convert self to an mpmath mpc if possible
+        """
+        from .numbers import Float
+        im_part, imag_unit = self.as_coeff_Mul()
+        if imag_unit is not S.ImaginaryUnit:
+            # ValueError may seem more reasonable but since it's a @property,
+            # we need to use AttributeError to keep from confusing things like
+            # hasattr.
+            raise AttributeError("Cannot convert Mul to mpc. Must be of the form Number*I")
+
+        return (Float(0)._mpf_, Float(im_part)._mpf_)
+
+    @cacheit
+    def as_two_terms(self):
+        """Return head and tail of self.
+
+        This is the most efficient way to get the head and tail of an
+        expression.
+
+        - if you want only the head, use self.args[0];
+        - if you want to process the arguments of the tail then use
+          self.as_coef_mul() which gives the head and a tuple containing
+          the arguments of the tail when treated as a Mul.
+        - if you want the coefficient when self is treated as an Add
+          then use self.as_coeff_add()[0]
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> (3*x*y).as_two_terms()
+        (3, x*y)
+        """
+        args = self.args
+
+        if len(args) == 1:
+            return S.One, self
+        elif len(args) == 2:
+            return args
+
+        else:
+            return args[0], self._new_rawargs(*args[1:])
+
+    @cacheit
+    def as_coeff_mul(self, *deps, rational=True, **kwargs):
+        if deps:
+            l1, l2 = sift(self.args, lambda x: x.has(*deps), binary=True)
+            return self._new_rawargs(*l2), tuple(l1)
+        args = self.args
+        if args[0].is_Number:
+            if not rational or args[0].is_Rational:
+                return args[0], args[1:]
+            elif args[0].is_extended_negative:
+                return S.NegativeOne, (-args[0],) + args[1:]
+        return S.One, args
+
+    def as_coeff_Mul(self, rational=False):
+        """
+        Efficiently extract the coefficient of a product.
+        """
+        coeff, args = self.args[0], self.args[1:]
+
+        if coeff.is_Number:
+            if not rational or coeff.is_Rational:
+                if len(args) == 1:
+                    return coeff, args[0]
+                else:
+                    return coeff, self._new_rawargs(*args)
+            elif coeff.is_extended_negative:
+                return S.NegativeOne, self._new_rawargs(*((-coeff,) + args))
+        return S.One, self
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.complexes import Abs, im, re
+        other = []
+        coeffr = []
+        coeffi = []
+        addterms = S.One
+        for a in self.args:
+            r, i = a.as_real_imag()
+            if i.is_zero:
+                coeffr.append(r)
+            elif r.is_zero:
+                coeffi.append(i*S.ImaginaryUnit)
+            elif a.is_commutative:
+                aconj = a.conjugate() if other else None
+                # search for complex conjugate pairs:
+                for i, x in enumerate(other):
+                    if x == aconj:
+                        coeffr.append(Abs(x)**2)
+                        del other[i]
+                        break
+                else:
+                    if a.is_Add:
+                        addterms *= a
+                    else:
+                        other.append(a)
+            else:
+                other.append(a)
+        m = self.func(*other)
+        if hints.get('ignore') == m:
+            return
+        if len(coeffi) % 2:
+            imco = im(coeffi.pop(0))
+            # all other pairs make a real factor; they will be
+            # put into reco below
+        else:
+            imco = S.Zero
+        reco = self.func(*(coeffr + coeffi))
+        r, i = (reco*re(m), reco*im(m))
+        if addterms == 1:
+            if m == 1:
+                if imco.is_zero:
+                    return (reco, S.Zero)
+                else:
+                    return (S.Zero, reco*imco)
+            if imco is S.Zero:
+                return (r, i)
+            return (-imco*i, imco*r)
+        from .function import expand_mul
+        addre, addim = expand_mul(addterms, deep=False).as_real_imag()
+        if imco is S.Zero:
+            return (r*addre - i*addim, i*addre + r*addim)
+        else:
+            r, i = -imco*i, imco*r
+            return (r*addre - i*addim, r*addim + i*addre)
+
+    @staticmethod
+    def _expandsums(sums):
+        """
+        Helper function for _eval_expand_mul.
+
+        sums must be a list of instances of Basic.
+        """
+
+        L = len(sums)
+        if L == 1:
+            return sums[0].args
+        terms = []
+        left = Mul._expandsums(sums[:L//2])
+        right = Mul._expandsums(sums[L//2:])
+
+        terms = [Mul(a, b) for a in left for b in right]
+        added = Add(*terms)
+        return Add.make_args(added)  # it may have collapsed down to one term
+
+    def _eval_expand_mul(self, **hints):
+        from sympy.simplify.radsimp import fraction
+
+        # Handle things like 1/(x*(x + 1)), which are automatically converted
+        # to 1/x*1/(x + 1)
+        expr = self
+        # default matches fraction's default
+        n, d = fraction(expr, hints.get('exact', False))
+        if d.is_Mul:
+            n, d = [i._eval_expand_mul(**hints) if i.is_Mul else i
+                for i in (n, d)]
+        expr = n/d
+        if not expr.is_Mul:
+            return expr
+
+        plain, sums, rewrite = [], [], False
+        for factor in expr.args:
+            if factor.is_Add:
+                sums.append(factor)
+                rewrite = True
+            else:
+                if factor.is_commutative:
+                    plain.append(factor)
+                else:
+                    sums.append(Basic(factor))  # Wrapper
+
+        if not rewrite:
+            return expr
+        else:
+            plain = self.func(*plain)
+            if sums:
+                deep = hints.get("deep", False)
+                terms = self.func._expandsums(sums)
+                args = []
+                for term in terms:
+                    t = self.func(plain, term)
+                    if t.is_Mul and any(a.is_Add for a in t.args) and deep:
+                        t = t._eval_expand_mul()
+                    args.append(t)
+                return Add(*args)
+            else:
+                return plain
+
+    @cacheit
+    def _eval_derivative(self, s):
+        args = list(self.args)
+        terms = []
+        for i in range(len(args)):
+            d = args[i].diff(s)
+            if d:
+                # Note: reduce is used in step of Mul as Mul is unable to
+                # handle subtypes and operation priority:
+                terms.append(reduce(lambda x, y: x*y, (args[:i] + [d] + args[i + 1:]), S.One))
+        return Add.fromiter(terms)
+
+    @cacheit
+    def _eval_derivative_n_times(self, s, n):
+        from .function import AppliedUndef
+        from .symbol import Symbol, symbols, Dummy
+        if not isinstance(s, (AppliedUndef, Symbol)):
+            # other types of s may not be well behaved, e.g.
+            # (cos(x)*sin(y)).diff([[x, y, z]])
+            return super()._eval_derivative_n_times(s, n)
+        from .numbers import Integer
+        args = self.args
+        m = len(args)
+        if isinstance(n, (int, Integer)):
+            # https://en.wikipedia.org/wiki/General_Leibniz_rule#More_than_two_factors
+            terms = []
+            from sympy.ntheory.multinomial import multinomial_coefficients_iterator
+            for kvals, c in multinomial_coefficients_iterator(m, n):
+                p = Mul(*[arg.diff((s, k)) for k, arg in zip(kvals, args)])
+                terms.append(c * p)
+            return Add(*terms)
+        from sympy.concrete.summations import Sum
+        from sympy.functions.combinatorial.factorials import factorial
+        from sympy.functions.elementary.miscellaneous import Max
+        kvals = symbols("k1:%i" % m, cls=Dummy)
+        klast = n - sum(kvals)
+        nfact = factorial(n)
+        e, l = (# better to use the multinomial?
+            nfact/prod(map(factorial, kvals))/factorial(klast)*\
+            Mul(*[args[t].diff((s, kvals[t])) for t in range(m-1)])*\
+            args[-1].diff((s, Max(0, klast))),
+            [(k, 0, n) for k in kvals])
+        return Sum(e, *l)
+
+    def _eval_difference_delta(self, n, step):
+        from sympy.series.limitseq import difference_delta as dd
+        arg0 = self.args[0]
+        rest = Mul(*self.args[1:])
+        return (arg0.subs(n, n + step) * dd(rest, n, step) + dd(arg0, n, step) *
+                rest)
+
+    def _matches_simple(self, expr, repl_dict):
+        # handle (w*3).matches('x*5') -> {w: x*5/3}
+        coeff, terms = self.as_coeff_Mul()
+        terms = Mul.make_args(terms)
+        if len(terms) == 1:
+            newexpr = self.__class__._combine_inverse(expr, coeff)
+            return terms[0].matches(newexpr, repl_dict)
+        return
+
+    def matches(self, expr, repl_dict=None, old=False):
+        expr = sympify(expr)
+        if self.is_commutative and expr.is_commutative:
+            return self._matches_commutative(expr, repl_dict, old)
+        elif self.is_commutative is not expr.is_commutative:
+            return None
+
+        # Proceed only if both both expressions are non-commutative
+        c1, nc1 = self.args_cnc()
+        c2, nc2 = expr.args_cnc()
+        c1, c2 = [c or [1] for c in [c1, c2]]
+
+        # TODO: Should these be self.func?
+        comm_mul_self = Mul(*c1)
+        comm_mul_expr = Mul(*c2)
+
+        repl_dict = comm_mul_self.matches(comm_mul_expr, repl_dict, old)
+
+        # If the commutative arguments didn't match and aren't equal, then
+        # then the expression as a whole doesn't match
+        if not repl_dict and c1 != c2:
+            return None
+
+        # Now match the non-commutative arguments, expanding powers to
+        # multiplications
+        nc1 = Mul._matches_expand_pows(nc1)
+        nc2 = Mul._matches_expand_pows(nc2)
+
+        repl_dict = Mul._matches_noncomm(nc1, nc2, repl_dict)
+
+        return repl_dict or None
+
+    @staticmethod
+    def _matches_expand_pows(arg_list):
+        new_args = []
+        for arg in arg_list:
+            if arg.is_Pow and arg.exp > 0:
+                new_args.extend([arg.base] * arg.exp)
+            else:
+                new_args.append(arg)
+        return new_args
+
+    @staticmethod
+    def _matches_noncomm(nodes, targets, repl_dict=None):
+        """Non-commutative multiplication matcher.
+
+        `nodes` is a list of symbols within the matcher multiplication
+        expression, while `targets` is a list of arguments in the
+        multiplication expression being matched against.
+        """
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+
+        # List of possible future states to be considered
+        agenda = []
+        # The current matching state, storing index in nodes and targets
+        state = (0, 0)
+        node_ind, target_ind = state
+        # Mapping between wildcard indices and the index ranges they match
+        wildcard_dict = {}
+
+        while target_ind < len(targets) and node_ind < len(nodes):
+            node = nodes[node_ind]
+
+            if node.is_Wild:
+                Mul._matches_add_wildcard(wildcard_dict, state)
+
+            states_matches = Mul._matches_new_states(wildcard_dict, state,
+                                                     nodes, targets)
+            if states_matches:
+                new_states, new_matches = states_matches
+                agenda.extend(new_states)
+                if new_matches:
+                    for match in new_matches:
+                        repl_dict[match] = new_matches[match]
+            if not agenda:
+                return None
+            else:
+                state = agenda.pop()
+                node_ind, target_ind = state
+
+        return repl_dict
+
+    @staticmethod
+    def _matches_add_wildcard(dictionary, state):
+        node_ind, target_ind = state
+        if node_ind in dictionary:
+            begin, end = dictionary[node_ind]
+            dictionary[node_ind] = (begin, target_ind)
+        else:
+            dictionary[node_ind] = (target_ind, target_ind)
+
+    @staticmethod
+    def _matches_new_states(dictionary, state, nodes, targets):
+        node_ind, target_ind = state
+        node = nodes[node_ind]
+        target = targets[target_ind]
+
+        # Don't advance at all if we've exhausted the targets but not the nodes
+        if target_ind >= len(targets) - 1 and node_ind < len(nodes) - 1:
+            return None
+
+        if node.is_Wild:
+            match_attempt = Mul._matches_match_wilds(dictionary, node_ind,
+                                                     nodes, targets)
+            if match_attempt:
+                # If the same node has been matched before, don't return
+                # anything if the current match is diverging from the previous
+                # match
+                other_node_inds = Mul._matches_get_other_nodes(dictionary,
+                                                               nodes, node_ind)
+                for ind in other_node_inds:
+                    other_begin, other_end = dictionary[ind]
+                    curr_begin, curr_end = dictionary[node_ind]
+
+                    other_targets = targets[other_begin:other_end + 1]
+                    current_targets = targets[curr_begin:curr_end + 1]
+
+                    for curr, other in zip(current_targets, other_targets):
+                        if curr != other:
+                            return None
+
+                # A wildcard node can match more than one target, so only the
+                # target index is advanced
+                new_state = [(node_ind, target_ind + 1)]
+                # Only move on to the next node if there is one
+                if node_ind < len(nodes) - 1:
+                    new_state.append((node_ind + 1, target_ind + 1))
+                return new_state, match_attempt
+        else:
+            # If we're not at a wildcard, then make sure we haven't exhausted
+            # nodes but not targets, since in this case one node can only match
+            # one target
+            if node_ind >= len(nodes) - 1 and target_ind < len(targets) - 1:
+                return None
+
+            match_attempt = node.matches(target)
+
+            if match_attempt:
+                return [(node_ind + 1, target_ind + 1)], match_attempt
+            elif node == target:
+                return [(node_ind + 1, target_ind + 1)], None
+            else:
+                return None
+
+    @staticmethod
+    def _matches_match_wilds(dictionary, wildcard_ind, nodes, targets):
+        """Determine matches of a wildcard with sub-expression in `target`."""
+        wildcard = nodes[wildcard_ind]
+        begin, end = dictionary[wildcard_ind]
+        terms = targets[begin:end + 1]
+        # TODO: Should this be self.func?
+        mult = Mul(*terms) if len(terms) > 1 else terms[0]
+        return wildcard.matches(mult)
+
+    @staticmethod
+    def _matches_get_other_nodes(dictionary, nodes, node_ind):
+        """Find other wildcards that may have already been matched."""
+        ind_node = nodes[node_ind]
+        return [ind for ind in dictionary if nodes[ind] == ind_node]
+
+    @staticmethod
+    def _combine_inverse(lhs, rhs):
+        """
+        Returns lhs/rhs, but treats arguments like symbols, so things
+        like oo/oo return 1 (instead of a nan) and ``I`` behaves like
+        a symbol instead of sqrt(-1).
+        """
+        from sympy.simplify.simplify import signsimp
+        from .symbol import Dummy
+        if lhs == rhs:
+            return S.One
+
+        def check(l, r):
+            if l.is_Float and r.is_comparable:
+                # if both objects are added to 0 they will share the same "normalization"
+                # and are more likely to compare the same. Since Add(foo, 0) will not allow
+                # the 0 to pass, we use __add__ directly.
+                return l.__add__(0) == r.evalf().__add__(0)
+            return False
+        if check(lhs, rhs) or check(rhs, lhs):
+            return S.One
+        if any(i.is_Pow or i.is_Mul for i in (lhs, rhs)):
+            # gruntz and limit wants a literal I to not combine
+            # with a power of -1
+            d = Dummy('I')
+            _i = {S.ImaginaryUnit: d}
+            i_ = {d: S.ImaginaryUnit}
+            a = lhs.xreplace(_i).as_powers_dict()
+            b = rhs.xreplace(_i).as_powers_dict()
+            blen = len(b)
+            for bi in tuple(b.keys()):
+                if bi in a:
+                    a[bi] -= b.pop(bi)
+                    if not a[bi]:
+                        a.pop(bi)
+            if len(b) != blen:
+                lhs = Mul(*[k**v for k, v in a.items()]).xreplace(i_)
+                rhs = Mul(*[k**v for k, v in b.items()]).xreplace(i_)
+        rv = lhs/rhs
+        srv = signsimp(rv)
+        return srv if srv.is_Number else rv
+
+    def as_powers_dict(self):
+        d = defaultdict(int)
+        for term in self.args:
+            for b, e in term.as_powers_dict().items():
+                d[b] += e
+        return d
+
+    def as_numer_denom(self):
+        # don't use _from_args to rebuild the numerators and denominators
+        # as the order is not guaranteed to be the same once they have
+        # been separated from each other
+        numers, denoms = list(zip(*[f.as_numer_denom() for f in self.args]))
+        return self.func(*numers), self.func(*denoms)
+
+    def as_base_exp(self):
+        e1 = None
+        bases = []
+        nc = 0
+        for m in self.args:
+            b, e = m.as_base_exp()
+            if not b.is_commutative:
+                nc += 1
+            if e1 is None:
+                e1 = e
+            elif e != e1 or nc > 1 or not e.is_Integer:
+                return self, S.One
+            bases.append(b)
+        return self.func(*bases), e1
+
+    def _eval_is_polynomial(self, syms):
+        return all(term._eval_is_polynomial(syms) for term in self.args)
+
+    def _eval_is_rational_function(self, syms):
+        return all(term._eval_is_rational_function(syms) for term in self.args)
+
+    def _eval_is_meromorphic(self, x, a):
+        return _fuzzy_group((arg.is_meromorphic(x, a) for arg in self.args),
+                            quick_exit=True)
+
+    def _eval_is_algebraic_expr(self, syms):
+        return all(term._eval_is_algebraic_expr(syms) for term in self.args)
+
+    _eval_is_commutative = lambda self: _fuzzy_group(
+        a.is_commutative for a in self.args)
+
+    def _eval_is_complex(self):
+        comp = _fuzzy_group(a.is_complex for a in self.args)
+        if comp is False:
+            if any(a.is_infinite for a in self.args):
+                if any(a.is_zero is not False for a in self.args):
+                    return None
+                return False
+        return comp
+
+    def _eval_is_zero_infinite_helper(self):
+        #
+        # Helper used by _eval_is_zero and _eval_is_infinite.
+        #
+        # Three-valued logic is tricky so let us reason this carefully. It
+        # would be nice to say that we just check is_zero/is_infinite in all
+        # args but we need to be careful about the case that one arg is zero
+        # and another is infinite like Mul(0, oo) or more importantly a case
+        # where it is not known if the arguments are zero or infinite like
+        # Mul(y, 1/x). If either y or x could be zero then there is a
+        # *possibility* that we have Mul(0, oo) which should give None for both
+        # is_zero and is_infinite.
+        #
+        # We keep track of whether we have seen a zero or infinity but we also
+        # need to keep track of whether we have *possibly* seen one which
+        # would be indicated by None.
+        #
+        # For each argument there is the possibility that is_zero might give
+        # True, False or None and likewise that is_infinite might give True,
+        # False or None, giving 9 combinations. The True cases for is_zero and
+        # is_infinite are mutually exclusive though so there are 3 main cases:
+        #
+        # - is_zero = True
+        # - is_infinite = True
+        # - is_zero and is_infinite are both either False or None
+        #
+        # At the end seen_zero and seen_infinite can be any of 9 combinations
+        # of True/False/None. Unless one is False though we cannot return
+        # anything except None:
+        #
+        # - is_zero=True needs seen_zero=True and seen_infinite=False
+        # - is_zero=False needs seen_zero=False
+        # - is_infinite=True needs seen_infinite=True and seen_zero=False
+        # - is_infinite=False needs seen_infinite=False
+        # - anything else gives both is_zero=None and is_infinite=None
+        #
+        # The loop only sets the flags to True or None and never back to False.
+        # Hence as soon as neither flag is False we exit early returning None.
+        # In particular as soon as we encounter a single arg that has
+        # is_zero=is_infinite=None we exit. This is a common case since it is
+        # the default assumptions for a Symbol and also the case for most
+        # expressions containing such a symbol. The early exit gives a big
+        # speedup for something like Mul(*symbols('x:1000')).is_zero.
+        #
+        seen_zero = seen_infinite = False
+
+        for a in self.args:
+            if a.is_zero:
+                if seen_infinite is not False:
+                    return None, None
+                seen_zero = True
+            elif a.is_infinite:
+                if seen_zero is not False:
+                    return None, None
+                seen_infinite = True
+            else:
+                if seen_zero is False and a.is_zero is None:
+                    if seen_infinite is not False:
+                        return None, None
+                    seen_zero = None
+                if seen_infinite is False and a.is_infinite is None:
+                    if seen_zero is not False:
+                        return None, None
+                    seen_infinite = None
+
+        return seen_zero, seen_infinite
+
+    def _eval_is_zero(self):
+        # True iff any arg is zero and no arg is infinite but need to handle
+        # three valued logic carefully.
+        seen_zero, seen_infinite = self._eval_is_zero_infinite_helper()
+
+        if seen_zero is False:
+            return False
+        elif seen_zero is True and seen_infinite is False:
+            return True
+        else:
+            return None
+
+    def _eval_is_infinite(self):
+        # True iff any arg is infinite and no arg is zero but need to handle
+        # three valued logic carefully.
+        seen_zero, seen_infinite = self._eval_is_zero_infinite_helper()
+
+        if seen_infinite is True and seen_zero is False:
+            return True
+        elif seen_infinite is False:
+            return False
+        else:
+            return None
+
+    # We do not need to implement _eval_is_finite because the assumptions
+    # system can infer it from finite = not infinite.
+
+    def _eval_is_rational(self):
+        r = _fuzzy_group((a.is_rational for a in self.args), quick_exit=True)
+        if r:
+            return r
+        elif r is False:
+            # All args except one are rational
+            if all(a.is_zero is False for a in self.args):
+                return False
+
+    def _eval_is_algebraic(self):
+        r = _fuzzy_group((a.is_algebraic for a in self.args), quick_exit=True)
+        if r:
+            return r
+        elif r is False:
+            # All args except one are algebraic
+            if all(a.is_zero is False for a in self.args):
+                return False
+
+    # without involving odd/even checks this code would suffice:
+    #_eval_is_integer = lambda self: _fuzzy_group(
+    #    (a.is_integer for a in self.args), quick_exit=True)
+    def _eval_is_integer(self):
+        is_rational = self._eval_is_rational()
+        if is_rational is False:
+            return False
+
+        numerators = []
+        denominators = []
+        unknown = False
+        for a in self.args:
+            hit = False
+            if a.is_integer:
+                if abs(a) is not S.One:
+                    numerators.append(a)
+            elif a.is_Rational:
+                n, d = a.as_numer_denom()
+                if abs(n) is not S.One:
+                    numerators.append(n)
+                if d is not S.One:
+                    denominators.append(d)
+            elif a.is_Pow:
+                b, e = a.as_base_exp()
+                if not b.is_integer or not e.is_integer:
+                    hit = unknown = True
+                if e.is_negative:
+                    denominators.append(2 if a is S.Half else
+                        Pow(a, S.NegativeOne))
+                elif not hit:
+                    # int b and pos int e: a = b**e is integer
+                    assert not e.is_positive
+                    # for rational self and e equal to zero: a = b**e is 1
+                    assert not e.is_zero
+                    return # sign of e unknown -> self.is_integer unknown
+                else:
+                    # x**2, 2**x, or x**y with x and y int-unknown -> unknown
+                    return
+            else:
+                return
+
+        if not denominators and not unknown:
+            return True
+
+        allodd = lambda x: all(i.is_odd for i in x)
+        alleven = lambda x: all(i.is_even for i in x)
+        anyeven = lambda x: any(i.is_even for i in x)
+
+        from .relational import is_gt
+        if not numerators and denominators and all(
+                is_gt(_, S.One) for _ in denominators):
+            return False
+        elif unknown:
+            return
+        elif allodd(numerators) and anyeven(denominators):
+            return False
+        elif anyeven(numerators) and denominators == [2]:
+            return True
+        elif alleven(numerators) and allodd(denominators
+                ) and (Mul(*denominators, evaluate=False) - 1
+                ).is_positive:
+            return False
+        if len(denominators) == 1:
+            d = denominators[0]
+            if d.is_Integer and d.is_even:
+                # if minimal power of 2 in num vs den is not
+                # negative then we have an integer
+                if (Add(*[i.as_base_exp()[1] for i in
+                        numerators if i.is_even]) - trailing(d.p)
+                        ).is_nonnegative:
+                    return True
+        if len(numerators) == 1:
+            n = numerators[0]
+            if n.is_Integer and n.is_even:
+                # if minimal power of 2 in den vs num is positive
+                # then we have have a non-integer
+                if (Add(*[i.as_base_exp()[1] for i in
+                        denominators if i.is_even]) - trailing(n.p)
+                        ).is_positive:
+                    return False
+
+    def _eval_is_polar(self):
+        has_polar = any(arg.is_polar for arg in self.args)
+        return has_polar and \
+            all(arg.is_polar or arg.is_positive for arg in self.args)
+
+    def _eval_is_extended_real(self):
+        return self._eval_real_imag(True)
+
+    def _eval_real_imag(self, real):
+        zero = False
+        t_not_re_im = None
+
+        for t in self.args:
+            if (t.is_complex or t.is_infinite) is False and t.is_extended_real is False:
+                return False
+            elif t.is_imaginary:  # I
+                real = not real
+            elif t.is_extended_real:  # 2
+                if not zero:
+                    z = t.is_zero
+                    if not z and zero is False:
+                        zero = z
+                    elif z:
+                        if all(a.is_finite for a in self.args):
+                            return True
+                        return
+            elif t.is_extended_real is False:
+                # symbolic or literal like `2 + I` or symbolic imaginary
+                if t_not_re_im:
+                    return  # complex terms might cancel
+                t_not_re_im = t
+            elif t.is_imaginary is False:  # symbolic like `2` or `2 + I`
+                if t_not_re_im:
+                    return  # complex terms might cancel
+                t_not_re_im = t
+            else:
+                return
+
+        if t_not_re_im:
+            if t_not_re_im.is_extended_real is False:
+                if real:  # like 3
+                    return zero  # 3*(smthng like 2 + I or i) is not real
+            if t_not_re_im.is_imaginary is False:  # symbolic 2 or 2 + I
+                if not real:  # like I
+                    return zero  # I*(smthng like 2 or 2 + I) is not real
+        elif zero is False:
+            return real  # can't be trumped by 0
+        elif real:
+            return real  # doesn't matter what zero is
+
+    def _eval_is_imaginary(self):
+        if all(a.is_zero is False and a.is_finite for a in self.args):
+            return self._eval_real_imag(False)
+
+    def _eval_is_hermitian(self):
+        return self._eval_herm_antiherm(True)
+
+    def _eval_is_antihermitian(self):
+        return self._eval_herm_antiherm(False)
+
+    def _eval_herm_antiherm(self, herm):
+        for t in self.args:
+            if t.is_hermitian is None or t.is_antihermitian is None:
+                return
+            if t.is_hermitian:
+                continue
+            elif t.is_antihermitian:
+                herm = not herm
+            else:
+                return
+
+        if herm is not False:
+            return herm
+
+        is_zero = self._eval_is_zero()
+        if is_zero:
+            return True
+        elif is_zero is False:
+            return herm
+
+    def _eval_is_irrational(self):
+        for t in self.args:
+            a = t.is_irrational
+            if a:
+                others = list(self.args)
+                others.remove(t)
+                if all((x.is_rational and fuzzy_not(x.is_zero)) is True for x in others):
+                    return True
+                return
+            if a is None:
+                return
+        if all(x.is_real for x in self.args):
+            return False
+
+    def _eval_is_extended_positive(self):
+        """Return True if self is positive, False if not, and None if it
+        cannot be determined.
+
+        Explanation
+        ===========
+
+        This algorithm is non-recursive and works by keeping track of the
+        sign which changes when a negative or nonpositive is encountered.
+        Whether a nonpositive or nonnegative is seen is also tracked since
+        the presence of these makes it impossible to return True, but
+        possible to return False if the end result is nonpositive. e.g.
+
+            pos * neg * nonpositive -> pos or zero -> None is returned
+            pos * neg * nonnegative -> neg or zero -> False is returned
+        """
+        return self._eval_pos_neg(1)
+
+    def _eval_pos_neg(self, sign):
+        saw_NON = saw_NOT = False
+        for t in self.args:
+            if t.is_extended_positive:
+                continue
+            elif t.is_extended_negative:
+                sign = -sign
+            elif t.is_zero:
+                if all(a.is_finite for a in self.args):
+                    return False
+                return
+            elif t.is_extended_nonpositive:
+                sign = -sign
+                saw_NON = True
+            elif t.is_extended_nonnegative:
+                saw_NON = True
+            # FIXME: is_positive/is_negative is False doesn't take account of
+            # Symbol('x', infinite=True, extended_real=True) which has
+            # e.g. is_positive is False but has uncertain sign.
+            elif t.is_positive is False:
+                sign = -sign
+                if saw_NOT:
+                    return
+                saw_NOT = True
+            elif t.is_negative is False:
+                if saw_NOT:
+                    return
+                saw_NOT = True
+            else:
+                return
+        if sign == 1 and saw_NON is False and saw_NOT is False:
+            return True
+        if sign < 0:
+            return False
+
+    def _eval_is_extended_negative(self):
+        return self._eval_pos_neg(-1)
+
+    def _eval_is_odd(self):
+        is_integer = self._eval_is_integer()
+        if is_integer is not True:
+            return is_integer
+
+        from sympy.simplify.radsimp import fraction
+        n, d = fraction(self)
+        if d.is_Integer and d.is_even:
+            # if minimal power of 2 in num vs den is
+            # positive then we have an even number
+            if (Add(*[i.as_base_exp()[1] for i in
+                    Mul.make_args(n) if i.is_even]) - trailing(d.p)
+                    ).is_positive:
+                return False
+            return
+        r, acc = True, 1
+        for t in self.args:
+            if abs(t) is S.One:
+                continue
+            if t.is_even:
+                return False
+            if r is False:
+                pass
+            elif acc != 1 and (acc + t).is_odd:
+                r = False
+            elif t.is_even is None:
+                r = None
+            acc = t
+        return r
+
+    def _eval_is_even(self):
+        from sympy.simplify.radsimp import fraction
+        n, d = fraction(self)
+        if n.is_Integer and n.is_even:
+            # if minimal power of 2 in den vs num is not
+            # negative then this is not an integer and
+            # can't be even
+            if (Add(*[i.as_base_exp()[1] for i in
+                    Mul.make_args(d) if i.is_even]) - trailing(n.p)
+                    ).is_nonnegative:
+                return False
+
+    def _eval_is_composite(self):
+        """
+        Here we count the number of arguments that have a minimum value
+        greater than two.
+        If there are more than one of such a symbol then the result is composite.
+        Else, the result cannot be determined.
+        """
+        number_of_args = 0 # count of symbols with minimum value greater than one
+        for arg in self.args:
+            if not (arg.is_integer and arg.is_positive):
+                return None
+            if (arg-1).is_positive:
+                number_of_args += 1
+
+        if number_of_args > 1:
+            return True
+
+    def _eval_subs(self, old, new):
+        from sympy.functions.elementary.complexes import sign
+        from sympy.ntheory.factor_ import multiplicity
+        from sympy.simplify.powsimp import powdenest
+        from sympy.simplify.radsimp import fraction
+
+        if not old.is_Mul:
+            return None
+
+        # try keep replacement literal so -2*x doesn't replace 4*x
+        if old.args[0].is_Number and old.args[0] < 0:
+            if self.args[0].is_Number:
+                if self.args[0] < 0:
+                    return self._subs(-old, -new)
+                return None
+
+        def base_exp(a):
+            # if I and -1 are in a Mul, they get both end up with
+            # a -1 base (see issue 6421); all we want here are the
+            # true Pow or exp separated into base and exponent
+            from sympy.functions.elementary.exponential import exp
+            if a.is_Pow or isinstance(a, exp):
+                return a.as_base_exp()
+            return a, S.One
+
+        def breakup(eq):
+            """break up powers of eq when treated as a Mul:
+                   b**(Rational*e) -> b**e, Rational
+                commutatives come back as a dictionary {b**e: Rational}
+                noncommutatives come back as a list [(b**e, Rational)]
+            """
+
+            (c, nc) = (defaultdict(int), [])
+            for a in Mul.make_args(eq):
+                a = powdenest(a)
+                (b, e) = base_exp(a)
+                if e is not S.One:
+                    (co, _) = e.as_coeff_mul()
+                    b = Pow(b, e/co)
+                    e = co
+                if a.is_commutative:
+                    c[b] += e
+                else:
+                    nc.append([b, e])
+            return (c, nc)
+
+        def rejoin(b, co):
+            """
+            Put rational back with exponent; in general this is not ok, but
+            since we took it from the exponent for analysis, it's ok to put
+            it back.
+            """
+
+            (b, e) = base_exp(b)
+            return Pow(b, e*co)
+
+        def ndiv(a, b):
+            """if b divides a in an extractive way (like 1/4 divides 1/2
+            but not vice versa, and 2/5 does not divide 1/3) then return
+            the integer number of times it divides, else return 0.
+            """
+            if not b.q % a.q or not a.q % b.q:
+                return int(a/b)
+            return 0
+
+        # give Muls in the denominator a chance to be changed (see issue 5651)
+        # rv will be the default return value
+        rv = None
+        n, d = fraction(self)
+        self2 = self
+        if d is not S.One:
+            self2 = n._subs(old, new)/d._subs(old, new)
+            if not self2.is_Mul:
+                return self2._subs(old, new)
+            if self2 != self:
+                rv = self2
+
+        # Now continue with regular substitution.
+
+        # handle the leading coefficient and use it to decide if anything
+        # should even be started; we always know where to find the Rational
+        # so it's a quick test
+
+        co_self = self2.args[0]
+        co_old = old.args[0]
+        co_xmul = None
+        if co_old.is_Rational and co_self.is_Rational:
+            # if coeffs are the same there will be no updating to do
+            # below after breakup() step; so skip (and keep co_xmul=None)
+            if co_old != co_self:
+                co_xmul = co_self.extract_multiplicatively(co_old)
+        elif co_old.is_Rational:
+            return rv
+
+        # break self and old into factors
+
+        (c, nc) = breakup(self2)
+        (old_c, old_nc) = breakup(old)
+
+        # update the coefficients if we had an extraction
+        # e.g. if co_self were 2*(3/35*x)**2 and co_old = 3/5
+        # then co_self in c is replaced by (3/5)**2 and co_residual
+        # is 2*(1/7)**2
+
+        if co_xmul and co_xmul.is_Rational and abs(co_old) != 1:
+            mult = S(multiplicity(abs(co_old), co_self))
+            c.pop(co_self)
+            if co_old in c:
+                c[co_old] += mult
+            else:
+                c[co_old] = mult
+            co_residual = co_self/co_old**mult
+        else:
+            co_residual = 1
+
+        # do quick tests to see if we can't succeed
+
+        ok = True
+        if len(old_nc) > len(nc):
+            # more non-commutative terms
+            ok = False
+        elif len(old_c) > len(c):
+            # more commutative terms
+            ok = False
+        elif {i[0] for i in old_nc}.difference({i[0] for i in nc}):
+            # unmatched non-commutative bases
+            ok = False
+        elif set(old_c).difference(set(c)):
+            # unmatched commutative terms
+            ok = False
+        elif any(sign(c[b]) != sign(old_c[b]) for b in old_c):
+            # differences in sign
+            ok = False
+        if not ok:
+            return rv
+
+        if not old_c:
+            cdid = None
+        else:
+            rat = []
+            for (b, old_e) in old_c.items():
+                c_e = c[b]
+                rat.append(ndiv(c_e, old_e))
+                if not rat[-1]:
+                    return rv
+            cdid = min(rat)
+
+        if not old_nc:
+            ncdid = None
+            for i in range(len(nc)):
+                nc[i] = rejoin(*nc[i])
+        else:
+            ncdid = 0  # number of nc replacements we did
+            take = len(old_nc)  # how much to look at each time
+            limit = cdid or S.Infinity  # max number that we can take
+            failed = []  # failed terms will need subs if other terms pass
+            i = 0
+            while limit and i + take <= len(nc):
+                hit = False
+
+                # the bases must be equivalent in succession, and
+                # the powers must be extractively compatible on the
+                # first and last factor but equal in between.
+
+                rat = []
+                for j in range(take):
+                    if nc[i + j][0] != old_nc[j][0]:
+                        break
+                    elif j == 0:
+                        rat.append(ndiv(nc[i + j][1], old_nc[j][1]))
+                    elif j == take - 1:
+                        rat.append(ndiv(nc[i + j][1], old_nc[j][1]))
+                    elif nc[i + j][1] != old_nc[j][1]:
+                        break
+                    else:
+                        rat.append(1)
+                    j += 1
+                else:
+                    ndo = min(rat)
+                    if ndo:
+                        if take == 1:
+                            if cdid:
+                                ndo = min(cdid, ndo)
+                            nc[i] = Pow(new, ndo)*rejoin(nc[i][0],
+                                    nc[i][1] - ndo*old_nc[0][1])
+                        else:
+                            ndo = 1
+
+                            # the left residual
+
+                            l = rejoin(nc[i][0], nc[i][1] - ndo*
+                                    old_nc[0][1])
+
+                            # eliminate all middle terms
+
+                            mid = new
+
+                            # the right residual (which may be the same as the middle if take == 2)
+
+                            ir = i + take - 1
+                            r = (nc[ir][0], nc[ir][1] - ndo*
+                                 old_nc[-1][1])
+                            if r[1]:
+                                if i + take < len(nc):
+                                    nc[i:i + take] = [l*mid, r]
+                                else:
+                                    r = rejoin(*r)
+                                    nc[i:i + take] = [l*mid*r]
+                            else:
+
+                                # there was nothing left on the right
+
+                                nc[i:i + take] = [l*mid]
+
+                        limit -= ndo
+                        ncdid += ndo
+                        hit = True
+                if not hit:
+
+                    # do the subs on this failing factor
+
+                    failed.append(i)
+                i += 1
+            else:
+
+                if not ncdid:
+                    return rv
+
+                # although we didn't fail, certain nc terms may have
+                # failed so we rebuild them after attempting a partial
+                # subs on them
+
+                failed.extend(range(i, len(nc)))
+                for i in failed:
+                    nc[i] = rejoin(*nc[i]).subs(old, new)
+
+        # rebuild the expression
+
+        if cdid is None:
+            do = ncdid
+        elif ncdid is None:
+            do = cdid
+        else:
+            do = min(ncdid, cdid)
+
+        margs = []
+        for b in c:
+            if b in old_c:
+
+                # calculate the new exponent
+
+                e = c[b] - old_c[b]*do
+                margs.append(rejoin(b, e))
+            else:
+                margs.append(rejoin(b.subs(old, new), c[b]))
+        if cdid and not ncdid:
+
+            # in case we are replacing commutative with non-commutative,
+            # we want the new term to come at the front just like the
+            # rest of this routine
+
+            margs = [Pow(new, cdid)] + margs
+        return co_residual*self2.func(*margs)*self2.func(*nc)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from .function import PoleError
+        from sympy.functions.elementary.integers import ceiling
+        from sympy.series.order import Order
+
+        def coeff_exp(term, x):
+            lt = term.as_coeff_exponent(x)
+            if lt[0].has(x):
+                try:
+                    lt = term.leadterm(x)
+                except ValueError:
+                    return term, S.Zero
+            return lt
+
+        ords = []
+
+        try:
+            for t in self.args:
+                coeff, exp = t.leadterm(x)
+                if not coeff.has(x):
+                    ords.append((t, exp))
+                else:
+                    raise ValueError
+
+            n0 = sum(t[1] for t in ords if t[1].is_number)
+            facs = []
+            for t, m in ords:
+                n1 = ceiling(n - n0 + (m if m.is_number else 0))
+                s = t.nseries(x, n=n1, logx=logx, cdir=cdir)
+                ns = s.getn()
+                if ns is not None:
+                    if ns < n1:  # less than expected
+                        n -= n1 - ns    # reduce n
+                facs.append(s)
+
+        except (ValueError, NotImplementedError, TypeError, PoleError):
+            # XXX: Catching so many generic exceptions around a large block of
+            # code will mask bugs. Whatever purpose catching these exceptions
+            # serves should be handled in a different way.
+            n0 = sympify(sum(t[1] for t in ords if t[1].is_number))
+            if n0.is_nonnegative:
+                n0 = S.Zero
+            facs = [t.nseries(x, n=ceiling(n-n0), logx=logx, cdir=cdir) for t in self.args]
+            from sympy.simplify.powsimp import powsimp
+            res = powsimp(self.func(*facs).expand(), combine='exp', deep=True)
+            if res.has(Order):
+                res += Order(x**n, x)
+            return res
+
+        res = S.Zero
+        ords2 = [Add.make_args(factor) for factor in facs]
+
+        for fac in product(*ords2):
+            ords3 = [coeff_exp(term, x) for term in fac]
+            coeffs, powers = zip(*ords3)
+            power = sum(powers)
+            if (power - n).is_negative:
+                res += Mul(*coeffs)*(x**power)
+
+        def max_degree(e, x):
+            if e is x:
+                return S.One
+            if e.is_Atom:
+                return S.Zero
+            if e.is_Add:
+                return max(max_degree(a, x) for a in e.args)
+            if e.is_Mul:
+                return Add(*[max_degree(a, x) for a in e.args])
+            if e.is_Pow:
+                return max_degree(e.base, x)*e.exp
+            return S.Zero
+
+        if self.is_polynomial(x):
+            from sympy.polys.polyerrors import PolynomialError
+            from sympy.polys.polytools import degree
+            try:
+                if max_degree(self, x) >= n or degree(self, x) != degree(res, x):
+                    res += Order(x**n, x)
+            except PolynomialError:
+                pass
+            else:
+                return res
+
+        if res != self:
+            if (self - res).subs(x, 0) == S.Zero and n > 0:
+                lt = self._eval_as_leading_term(x, logx=logx, cdir=cdir)
+                if lt == S.Zero:
+                    return res
+            res += Order(x**n, x)
+        return res
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        return self.func(*[t.as_leading_term(x, logx=logx, cdir=cdir) for t in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[t.conjugate() for t in self.args])
+
+    def _eval_transpose(self):
+        return self.func(*[t.transpose() for t in self.args[::-1]])
+
+    def _eval_adjoint(self):
+        return self.func(*[t.adjoint() for t in self.args[::-1]])
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> (-3*sqrt(2)*(2 - 2*sqrt(2))).as_content_primitive()
+        (6, -sqrt(2)*(1 - sqrt(2)))
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+
+        coef = S.One
+        args = []
+        for a in self.args:
+            c, p = a.as_content_primitive(radical=radical, clear=clear)
+            coef *= c
+            if p is not S.One:
+                args.append(p)
+        # don't use self._from_args here to reconstruct args
+        # since there may be identical args now that should be combined
+        # e.g. (2+2*x)*(3+3*x) should be (6, (1 + x)**2) not (6, (1+x)*(1+x))
+        return coef, self.func(*args)
+
+    def as_ordered_factors(self, order=None):
+        """Transform an expression into an ordered list of factors.
+
+        Examples
+        ========
+
+        >>> from sympy import sin, cos
+        >>> from sympy.abc import x, y
+
+        >>> (2*x*y*sin(x)*cos(x)).as_ordered_factors()
+        [2, x, y, sin(x), cos(x)]
+
+        """
+        cpart, ncpart = self.args_cnc()
+        cpart.sort(key=lambda expr: expr.sort_key(order=order))
+        return cpart + ncpart
+
+    @property
+    def _sorted_args(self):
+        return tuple(self.as_ordered_factors())
+
+mul = AssocOpDispatcher('mul')
+
+
+def prod(a, start=1):
+    """Return product of elements of a. Start with int 1 so if only
+       ints are included then an int result is returned.
+
+    Examples
+    ========
+
+    >>> from sympy import prod, S
+    >>> prod(range(3))
+    0
+    >>> type(_) is int
+    True
+    >>> prod([S(2), 3])
+    6
+    >>> _.is_Integer
+    True
+
+    You can start the product at something other than 1:
+
+    >>> prod([1, 2], 3)
+    6
+
+    """
+    return reduce(operator.mul, a, start)
+
+
+def _keep_coeff(coeff, factors, clear=True, sign=False):
+    """Return ``coeff*factors`` unevaluated if necessary.
+
+    If ``clear`` is False, do not keep the coefficient as a factor
+    if it can be distributed on a single factor such that one or
+    more terms will still have integer coefficients.
+
+    If ``sign`` is True, allow a coefficient of -1 to remain factored out.
+
+    Examples
+    ========
+
+    >>> from sympy.core.mul import _keep_coeff
+    >>> from sympy.abc import x, y
+    >>> from sympy import S
+
+    >>> _keep_coeff(S.Half, x + 2)
+    (x + 2)/2
+    >>> _keep_coeff(S.Half, x + 2, clear=False)
+    x/2 + 1
+    >>> _keep_coeff(S.Half, (x + 2)*y, clear=False)
+    y*(x + 2)/2
+    >>> _keep_coeff(S(-1), x + y)
+    -x - y
+    >>> _keep_coeff(S(-1), x + y, sign=True)
+    -(x + y)
+    """
+    if not coeff.is_Number:
+        if factors.is_Number:
+            factors, coeff = coeff, factors
+        else:
+            return coeff*factors
+    if factors is S.One:
+        return coeff
+    if coeff is S.One:
+        return factors
+    elif coeff is S.NegativeOne and not sign:
+        return -factors
+    elif factors.is_Add:
+        if not clear and coeff.is_Rational and coeff.q != 1:
+            args = [i.as_coeff_Mul() for i in factors.args]
+            args = [(_keep_coeff(c, coeff), m) for c, m in args]
+            if any(c.is_Integer for c, _ in args):
+                return Add._from_args([Mul._from_args(
+                    i[1:] if i[0] == 1 else i) for i in args])
+        return Mul(coeff, factors, evaluate=False)
+    elif factors.is_Mul:
+        margs = list(factors.args)
+        if margs[0].is_Number:
+            margs[0] *= coeff
+            if margs[0] == 1:
+                margs.pop(0)
+        else:
+            margs.insert(0, coeff)
+        return Mul._from_args(margs)
+    else:
+        m = coeff*factors
+        if m.is_Number and not factors.is_Number:
+            m = Mul._from_args((coeff, factors))
+        return m
+
+def expand_2arg(e):
+    def do(e):
+        if e.is_Mul:
+            c, r = e.as_coeff_Mul()
+            if c.is_Number and r.is_Add:
+                return _unevaluated_Add(*[c*ri for ri in r.args])
+        return e
+    return bottom_up(e, do)
+
+
+from .numbers import Rational
+from .power import Pow
+from .add import Add, _unevaluated_Add
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/multidimensional.py b/.venv/lib/python3.12/site-packages/sympy/core/multidimensional.py
new file mode 100644
index 0000000000000000000000000000000000000000..133e0ab6cba6a87c627feb6f6034a6daed1128c5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/multidimensional.py
@@ -0,0 +1,131 @@
+"""
+Provides functionality for multidimensional usage of scalar-functions.
+
+Read the vectorize docstring for more details.
+"""
+
+from functools import wraps
+
+
+def apply_on_element(f, args, kwargs, n):
+    """
+    Returns a structure with the same dimension as the specified argument,
+    where each basic element is replaced by the function f applied on it. All
+    other arguments stay the same.
+    """
+    # Get the specified argument.
+    if isinstance(n, int):
+        structure = args[n]
+        is_arg = True
+    elif isinstance(n, str):
+        structure = kwargs[n]
+        is_arg = False
+
+    # Define reduced function that is only dependent on the specified argument.
+    def f_reduced(x):
+        if hasattr(x, "__iter__"):
+            return list(map(f_reduced, x))
+        else:
+            if is_arg:
+                args[n] = x
+            else:
+                kwargs[n] = x
+            return f(*args, **kwargs)
+
+    # f_reduced will call itself recursively so that in the end f is applied to
+    # all basic elements.
+    return list(map(f_reduced, structure))
+
+
+def iter_copy(structure):
+    """
+    Returns a copy of an iterable object (also copying all embedded iterables).
+    """
+    return [iter_copy(i) if hasattr(i, "__iter__") else i for i in structure]
+
+
+def structure_copy(structure):
+    """
+    Returns a copy of the given structure (numpy-array, list, iterable, ..).
+    """
+    if hasattr(structure, "copy"):
+        return structure.copy()
+    return iter_copy(structure)
+
+
+class vectorize:
+    """
+    Generalizes a function taking scalars to accept multidimensional arguments.
+
+    Examples
+    ========
+
+    >>> from sympy import vectorize, diff, sin, symbols, Function
+    >>> x, y, z = symbols('x y z')
+    >>> f, g, h = list(map(Function, 'fgh'))
+
+    >>> @vectorize(0)
+    ... def vsin(x):
+    ...     return sin(x)
+
+    >>> vsin([1, x, y])
+    [sin(1), sin(x), sin(y)]
+
+    >>> @vectorize(0, 1)
+    ... def vdiff(f, y):
+    ...     return diff(f, y)
+
+    >>> vdiff([f(x, y, z), g(x, y, z), h(x, y, z)], [x, y, z])
+    [[Derivative(f(x, y, z), x), Derivative(f(x, y, z), y), Derivative(f(x, y, z), z)], [Derivative(g(x, y, z), x), Derivative(g(x, y, z), y), Derivative(g(x, y, z), z)], [Derivative(h(x, y, z), x), Derivative(h(x, y, z), y), Derivative(h(x, y, z), z)]]
+    """
+    def __init__(self, *mdargs):
+        """
+        The given numbers and strings characterize the arguments that will be
+        treated as data structures, where the decorated function will be applied
+        to every single element.
+        If no argument is given, everything is treated multidimensional.
+        """
+        for a in mdargs:
+            if not isinstance(a, (int, str)):
+                raise TypeError("a is of invalid type")
+        self.mdargs = mdargs
+
+    def __call__(self, f):
+        """
+        Returns a wrapper for the one-dimensional function that can handle
+        multidimensional arguments.
+        """
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            # Get arguments that should be treated multidimensional
+            if self.mdargs:
+                mdargs = self.mdargs
+            else:
+                mdargs = range(len(args)) + kwargs.keys()
+
+            arglength = len(args)
+
+            for n in mdargs:
+                if isinstance(n, int):
+                    if n >= arglength:
+                        continue
+                    entry = args[n]
+                    is_arg = True
+                elif isinstance(n, str):
+                    try:
+                        entry = kwargs[n]
+                    except KeyError:
+                        continue
+                    is_arg = False
+                if hasattr(entry, "__iter__"):
+                    # Create now a copy of the given array and manipulate then
+                    # the entries directly.
+                    if is_arg:
+                        args = list(args)
+                        args[n] = structure_copy(entry)
+                    else:
+                        kwargs[n] = structure_copy(entry)
+                    result = apply_on_element(wrapper, args, kwargs, n)
+                    return result
+            return f(*args, **kwargs)
+        return wrapper
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/numbers.py b/.venv/lib/python3.12/site-packages/sympy/core/numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fa13fbb96aa25a8e60e048c0147a5e660804ccc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/numbers.py
@@ -0,0 +1,4482 @@
+from __future__ import annotations
+
+from typing import overload
+
+import numbers
+import decimal
+import fractions
+import math
+
+from .containers import Tuple
+from .sympify import (SympifyError, _sympy_converter, sympify, _convert_numpy_types,
+              _sympify, _is_numpy_instance)
+from .singleton import S, Singleton
+from .basic import Basic
+from .expr import Expr, AtomicExpr
+from .evalf import pure_complex
+from .cache import cacheit, clear_cache
+from .decorators import _sympifyit
+from .intfunc import num_digits, igcd, ilcm, mod_inverse, integer_nthroot
+from .logic import fuzzy_not
+from .kind import NumberKind
+from .sorting import ordered
+from sympy.external.gmpy import SYMPY_INTS, gmpy, flint
+from sympy.multipledispatch import dispatch
+import mpmath
+import mpmath.libmp as mlib
+from mpmath.libmp import bitcount, round_nearest as rnd
+from mpmath.libmp.backend import MPZ
+from mpmath.libmp import mpf_pow, mpf_pi, mpf_e, phi_fixed
+from mpmath.ctx_mp_python import mpnumeric
+from mpmath.libmp.libmpf import (
+    finf as _mpf_inf, fninf as _mpf_ninf,
+    fnan as _mpf_nan, fzero, _normalize as mpf_normalize,
+    prec_to_dps, dps_to_prec)
+from sympy.utilities.misc import debug
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from .parameters import global_parameters
+
+_LOG2 = math.log(2)
+
+
+def comp(z1, z2, tol=None):
+    r"""Return a bool indicating whether the error between z1 and z2
+    is $\le$ ``tol``.
+
+    Examples
+    ========
+
+    If ``tol`` is ``None`` then ``True`` will be returned if
+    :math:`|z1 - z2|\times 10^p \le 5` where $p$ is minimum value of the
+    decimal precision of each value.
+
+    >>> from sympy import comp, pi
+    >>> pi4 = pi.n(4); pi4
+    3.142
+    >>> comp(_, 3.142)
+    True
+    >>> comp(pi4, 3.141)
+    False
+    >>> comp(pi4, 3.143)
+    False
+
+    A comparison of strings will be made
+    if ``z1`` is a Number and ``z2`` is a string or ``tol`` is ''.
+
+    >>> comp(pi4, 3.1415)
+    True
+    >>> comp(pi4, 3.1415, '')
+    False
+
+    When ``tol`` is provided and $z2$ is non-zero and
+    :math:`|z1| > 1` the error is normalized by :math:`|z1|`:
+
+    >>> abs(pi4 - 3.14)/pi4
+    0.000509791731426756
+    >>> comp(pi4, 3.14, .001)  # difference less than 0.1%
+    True
+    >>> comp(pi4, 3.14, .0005)  # difference less than 0.1%
+    False
+
+    When :math:`|z1| \le 1` the absolute error is used:
+
+    >>> 1/pi4
+    0.3183
+    >>> abs(1/pi4 - 0.3183)/(1/pi4)
+    3.07371499106316e-5
+    >>> abs(1/pi4 - 0.3183)
+    9.78393554684764e-6
+    >>> comp(1/pi4, 0.3183, 1e-5)
+    True
+
+    To see if the absolute error between ``z1`` and ``z2`` is less
+    than or equal to ``tol``, call this as ``comp(z1 - z2, 0, tol)``
+    or ``comp(z1 - z2, tol=tol)``:
+
+    >>> abs(pi4 - 3.14)
+    0.00160156249999988
+    >>> comp(pi4 - 3.14, 0, .002)
+    True
+    >>> comp(pi4 - 3.14, 0, .001)
+    False
+    """
+    if isinstance(z2, str):
+        if not pure_complex(z1, or_real=True):
+            raise ValueError('when z2 is a str z1 must be a Number')
+        return str(z1) == z2
+    if not z1:
+        z1, z2 = z2, z1
+    if not z1:
+        return True
+    if not tol:
+        a, b = z1, z2
+        if tol == '':
+            return str(a) == str(b)
+        if tol is None:
+            a, b = sympify(a), sympify(b)
+            if not all(i.is_number for i in (a, b)):
+                raise ValueError('expecting 2 numbers')
+            fa = a.atoms(Float)
+            fb = b.atoms(Float)
+            if not fa and not fb:
+                # no floats -- compare exactly
+                return a == b
+            # get a to be pure_complex
+            for _ in range(2):
+                ca = pure_complex(a, or_real=True)
+                if not ca:
+                    if fa:
+                        a = a.n(prec_to_dps(min(i._prec for i in fa)))
+                        ca = pure_complex(a, or_real=True)
+                        break
+                    else:
+                        fa, fb = fb, fa
+                        a, b = b, a
+            cb = pure_complex(b)
+            if not cb and fb:
+                b = b.n(prec_to_dps(min(i._prec for i in fb)))
+                cb = pure_complex(b, or_real=True)
+            if ca and cb and (ca[1] or cb[1]):
+                return all(comp(i, j) for i, j in zip(ca, cb))
+            tol = 10**prec_to_dps(min(a._prec, getattr(b, '_prec', a._prec)))
+            return int(abs(a - b)*tol) <= 5
+    diff = abs(z1 - z2)
+    az1 = abs(z1)
+    if z2 and az1 > 1:
+        return diff/az1 <= tol
+    else:
+        return diff <= tol
+
+
+def mpf_norm(mpf, prec):
+    """Return the mpf tuple normalized appropriately for the indicated
+    precision after doing a check to see if zero should be returned or
+    not when the mantissa is 0. ``mpf_normlize`` always assumes that this
+    is zero, but it may not be since the mantissa for mpf's values "+inf",
+    "-inf" and "nan" have a mantissa of zero, too.
+
+    Note: this is not intended to validate a given mpf tuple, so sending
+    mpf tuples that were not created by mpmath may produce bad results. This
+    is only a wrapper to ``mpf_normalize`` which provides the check for non-
+    zero mpfs that have a 0 for the mantissa.
+    """
+    sign, man, expt, bc = mpf
+    if not man:
+        # hack for mpf_normalize which does not do this;
+        # it assumes that if man is zero the result is 0
+        # (see issue 6639)
+        if not bc:
+            return fzero
+        else:
+            # don't change anything; this should already
+            # be a well formed mpf tuple
+            return mpf
+
+    # Necessary if mpmath is using the gmpy backend
+    from mpmath.libmp.backend import MPZ
+    rv = mpf_normalize(sign, MPZ(man), expt, bc, prec, rnd)
+    return rv
+
+# TODO: we should use the warnings module
+_errdict = {"divide": False}
+
+
+def seterr(divide=False):
+    """
+    Should SymPy raise an exception on 0/0 or return a nan?
+
+    divide == True .... raise an exception
+    divide == False ... return nan
+    """
+    if _errdict["divide"] != divide:
+        clear_cache()
+        _errdict["divide"] = divide
+
+
+def _as_integer_ratio(p):
+    neg_pow, man, expt, _ = getattr(p, '_mpf_', mpmath.mpf(p)._mpf_)
+    p = [1, -1][neg_pow % 2]*man
+    if expt < 0:
+        q = 2**-expt
+    else:
+        q = 1
+        p *= 2**expt
+    return int(p), int(q)
+
+
+def _decimal_to_Rational_prec(dec):
+    """Convert an ordinary decimal instance to a Rational."""
+    if not dec.is_finite():
+        raise TypeError("dec must be finite, got %s." % dec)
+    s, d, e = dec.as_tuple()
+    prec = len(d)
+    if e >= 0:  # it's an integer
+        rv = Integer(int(dec))
+    else:
+        s = (-1)**s
+        d = sum(di*10**i for i, di in enumerate(reversed(d)))
+        rv = Rational(s*d, 10**-e)
+    return rv, prec
+
+_dig = str.maketrans(dict.fromkeys('1234567890'))
+
+def _literal_float(s):
+    """return True if s is space-trimmed number literal else False
+
+    Python allows underscore as digit separators: there must be a
+    digit on each side. So neither a leading underscore nor a
+    double underscore are valid as part of a number. A number does
+    not have to precede the decimal point, but there must be a
+    digit before the optional "e" or "E" that begins the signs
+    exponent of the number which must be an integer, perhaps with
+    underscore separators.
+
+    SymPy allows space as a separator; if the calling routine replaces
+    them with underscores then the same semantics will be enforced
+    for them as for underscores: there can only be 1 *between* digits.
+
+    We don't check for error from float(s) because we don't know
+    whether s is malicious or not. A regex for this could maybe
+    be written but will it be understood by most who read it?
+    """
+    # mantissa and exponent
+    parts = s.split('e')
+    if len(parts) > 2:
+        return False
+    if len(parts) == 2:
+        m, e = parts
+        if e.startswith(tuple('+-')):
+            e = e[1:]
+        if not e:
+            return False
+    else:
+        m, e = s, '1'
+    # integer and fraction of mantissa
+    parts = m.split('.')
+    if len(parts) > 2:
+        return False
+    elif len(parts) == 2:
+        i, f = parts
+    else:
+        i, f = m, '1'
+    if not i and not f:
+        return False
+    if i and i[0] in '+-':
+        i = i[1:]
+    if not i:  # -.3e4 -> -0.3e4
+        i = '1'
+    f = f or '1'
+    # check that all groups contain only digits and are not null
+    for n in (i, f, e):
+        for g in n.split('_'):
+            if not g or g.translate(_dig):
+                return False
+    return True
+
+# (a,b) -> gcd(a,b)
+
+# TODO caching with decorator, but not to degrade performance
+
+
+class Number(AtomicExpr):
+    """Represents atomic numbers in SymPy.
+
+    Explanation
+    ===========
+
+    Floating point numbers are represented by the Float class.
+    Rational numbers (of any size) are represented by the Rational class.
+    Integer numbers (of any size) are represented by the Integer class.
+    Float and Rational are subclasses of Number; Integer is a subclass
+    of Rational.
+
+    For example, ``2/3`` is represented as ``Rational(2, 3)`` which is
+    a different object from the floating point number obtained with
+    Python division ``2/3``. Even for numbers that are exactly
+    represented in binary, there is a difference between how two forms,
+    such as ``Rational(1, 2)`` and ``Float(0.5)``, are used in SymPy.
+    The rational form is to be preferred in symbolic computations.
+
+    Other kinds of numbers, such as algebraic numbers ``sqrt(2)`` or
+    complex numbers ``3 + 4*I``, are not instances of Number class as
+    they are not atomic.
+
+    See Also
+    ========
+
+    Float, Integer, Rational
+    """
+    is_commutative = True
+    is_number = True
+    is_Number = True
+
+    __slots__ = ()
+
+    # Used to make max(x._prec, y._prec) return x._prec when only x is a float
+    _prec = -1
+
+    kind = NumberKind
+
+    def __new__(cls, *obj):
+        if len(obj) == 1:
+            obj = obj[0]
+
+        if isinstance(obj, Number):
+            return obj
+        if isinstance(obj, SYMPY_INTS):
+            return Integer(obj)
+        if isinstance(obj, tuple) and len(obj) == 2:
+            return Rational(*obj)
+        if isinstance(obj, (float, mpmath.mpf, decimal.Decimal)):
+            return Float(obj)
+        if isinstance(obj, str):
+            _obj = obj.lower()  # float('INF') == float('inf')
+            if _obj == 'nan':
+                return S.NaN
+            elif _obj == 'inf':
+                return S.Infinity
+            elif _obj == '+inf':
+                return S.Infinity
+            elif _obj == '-inf':
+                return S.NegativeInfinity
+            val = sympify(obj)
+            if isinstance(val, Number):
+                return val
+            else:
+                raise ValueError('String "%s" does not denote a Number' % obj)
+        msg = "expected str|int|long|float|Decimal|Number object but got %r"
+        raise TypeError(msg % type(obj).__name__)
+
+    def could_extract_minus_sign(self):
+        return bool(self.is_extended_negative)
+
+    def invert(self, other, *gens, **args):
+        from sympy.polys.polytools import invert
+        if getattr(other, 'is_number', True):
+            return mod_inverse(self, other)
+        return invert(self, other, *gens, **args)
+
+    def __divmod__(self, other):
+        from sympy.functions.elementary.complexes import sign
+
+        try:
+            other = Number(other)
+            if self.is_infinite or S.NaN in (self, other):
+                return (S.NaN, S.NaN)
+        except TypeError:
+            return NotImplemented
+        if not other:
+            raise ZeroDivisionError('modulo by zero')
+        if self.is_Integer and other.is_Integer:
+            return Tuple(*divmod(self.p, other.p))
+        elif isinstance(other, Float):
+            rat = self/Rational(other)
+        else:
+            rat = self/other
+        if other.is_finite:
+            w = int(rat) if rat >= 0 else int(rat) - 1
+            r = self - other*w
+            if r == Float(other):
+                w += 1
+                r = 0
+            if isinstance(self, Float) or isinstance(other, Float):
+                r = Float(r)  # in case w or r is 0
+        else:
+            w = 0 if not self or (sign(self) == sign(other)) else -1
+            r = other if w else self
+        return Tuple(w, r)
+
+    def __rdivmod__(self, other):
+        try:
+            other = Number(other)
+        except TypeError:
+            return NotImplemented
+        return divmod(other, self)
+
+    def _as_mpf_val(self, prec):
+        """Evaluation of mpf tuple accurate to at least prec bits."""
+        raise NotImplementedError('%s needs ._as_mpf_val() method' %
+            (self.__class__.__name__))
+
+    def _eval_evalf(self, prec):
+        return Float._new(self._as_mpf_val(prec), prec)
+
+    def _as_mpf_op(self, prec):
+        prec = max(prec, self._prec)
+        return self._as_mpf_val(prec), prec
+
+    def __float__(self):
+        return mlib.to_float(self._as_mpf_val(53))
+
+    def floor(self):
+        raise NotImplementedError('%s needs .floor() method' %
+            (self.__class__.__name__))
+
+    def ceiling(self):
+        raise NotImplementedError('%s needs .ceiling() method' %
+            (self.__class__.__name__))
+
+    def __floor__(self):
+        return self.floor()
+
+    def __ceil__(self):
+        return self.ceiling()
+
+    def _eval_conjugate(self):
+        return self
+
+    def _eval_order(self, *symbols):
+        from sympy.series.order import Order
+        # Order(5, x, y) -> Order(1,x,y)
+        return Order(S.One, *symbols)
+
+    def _eval_subs(self, old, new):
+        if old == -self:
+            return -new
+        return self  # there is no other possibility
+
+    @classmethod
+    def class_key(cls):
+        return 1, 0, 'Number'
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (0, ()), (), self
+
+    def __neg__(self) -> Number:
+        raise NotImplementedError
+
+    @overload
+    def __add__(self, other: Number | int | float) -> Number: ...
+    @overload
+    def __add__(self, other: Expr) -> Expr: ...
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other) -> Expr:
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.NaN:
+                return S.NaN
+            elif other is S.Infinity:
+                return S.Infinity
+            elif other is S.NegativeInfinity:
+                return S.NegativeInfinity
+        return AtomicExpr.__add__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.NaN:
+                return S.NaN
+            elif other is S.Infinity:
+                return S.NegativeInfinity
+            elif other is S.NegativeInfinity:
+                return S.Infinity
+        return AtomicExpr.__sub__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.NaN:
+                return S.NaN
+            elif other is S.Infinity:
+                if self.is_zero:
+                    return S.NaN
+                elif self.is_positive:
+                    return S.Infinity
+                else:
+                    return S.NegativeInfinity
+            elif other is S.NegativeInfinity:
+                if self.is_zero:
+                    return S.NaN
+                elif self.is_positive:
+                    return S.NegativeInfinity
+                else:
+                    return S.Infinity
+        elif isinstance(other, Tuple):
+            return NotImplemented
+        return AtomicExpr.__mul__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.NaN:
+                return S.NaN
+            elif other in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+        return AtomicExpr.__truediv__(self, other)
+
+    def __eq__(self, other):
+        raise NotImplementedError('%s needs .__eq__() method' %
+            (self.__class__.__name__))
+
+    def __ne__(self, other):
+        raise NotImplementedError('%s needs .__ne__() method' %
+            (self.__class__.__name__))
+
+    def __lt__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s < %s" % (self, other))
+        raise NotImplementedError('%s needs .__lt__() method' %
+            (self.__class__.__name__))
+
+    def __le__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s <= %s" % (self, other))
+        raise NotImplementedError('%s needs .__le__() method' %
+            (self.__class__.__name__))
+
+    def __gt__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s > %s" % (self, other))
+        return _sympify(other).__lt__(self)
+
+    def __ge__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            raise TypeError("Invalid comparison %s >= %s" % (self, other))
+        return _sympify(other).__le__(self)
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def is_constant(self, *wrt, **flags):
+        return True
+
+    def as_coeff_mul(self, *deps, rational=True, **kwargs):
+        # a -> c*t
+        if self.is_Rational or not rational:
+            return self, ()
+        elif self.is_negative:
+            return S.NegativeOne, (-self,)
+        return S.One, (self,)
+
+    def as_coeff_add(self, *deps):
+        # a -> c + t
+        if self.is_Rational:
+            return self, ()
+        return S.Zero, (self,)
+
+    def as_coeff_Mul(self, rational=False):
+        """Efficiently extract the coefficient of a product."""
+        if not rational:
+            return self, S.One
+        return S.One, self
+
+    def as_coeff_Add(self, rational=False):
+        """Efficiently extract the coefficient of a summation."""
+        if not rational:
+            return self, S.Zero
+        return S.Zero, self
+
+    def gcd(self, other):
+        """Compute GCD of `self` and `other`. """
+        from sympy.polys.polytools import gcd
+        return gcd(self, other)
+
+    def lcm(self, other):
+        """Compute LCM of `self` and `other`. """
+        from sympy.polys.polytools import lcm
+        return lcm(self, other)
+
+    def cofactors(self, other):
+        """Compute GCD and cofactors of `self` and `other`. """
+        from sympy.polys.polytools import cofactors
+        return cofactors(self, other)
+
+
+class Float(Number):
+    """Represent a floating-point number of arbitrary precision.
+
+    Examples
+    ========
+
+    >>> from sympy import Float
+    >>> Float(3.5)
+    3.50000000000000
+    >>> Float(3)
+    3.00000000000000
+
+    Creating Floats from strings (and Python ``int`` and ``long``
+    types) will give a minimum precision of 15 digits, but the
+    precision will automatically increase to capture all digits
+    entered.
+
+    >>> Float(1)
+    1.00000000000000
+    >>> Float(10**20)
+    100000000000000000000.
+    >>> Float('1e20')
+    100000000000000000000.
+
+    However, *floating-point* numbers (Python ``float`` types) retain
+    only 15 digits of precision:
+
+    >>> Float(1e20)
+    1.00000000000000e+20
+    >>> Float(1.23456789123456789)
+    1.23456789123457
+
+    It may be preferable to enter high-precision decimal numbers
+    as strings:
+
+    >>> Float('1.23456789123456789')
+    1.23456789123456789
+
+    The desired number of digits can also be specified:
+
+    >>> Float('1e-3', 3)
+    0.00100
+    >>> Float(100, 4)
+    100.0
+
+    Float can automatically count significant figures if a null string
+    is sent for the precision; spaces or underscores are also allowed. (Auto-
+    counting is only allowed for strings, ints and longs).
+
+    >>> Float('123 456 789.123_456', '')
+    123456789.123456
+    >>> Float('12e-3', '')
+    0.012
+    >>> Float(3, '')
+    3.
+
+    If a number is written in scientific notation, only the digits before the
+    exponent are considered significant if a decimal appears, otherwise the
+    "e" signifies only how to move the decimal:
+
+    >>> Float('60.e2', '')  # 2 digits significant
+    6.0e+3
+    >>> Float('60e2', '')  # 4 digits significant
+    6000.
+    >>> Float('600e-2', '')  # 3 digits significant
+    6.00
+
+    Notes
+    =====
+
+    Floats are inexact by their nature unless their value is a binary-exact
+    value.
+
+    >>> approx, exact = Float(.1, 1), Float(.125, 1)
+
+    For calculation purposes, evalf needs to be able to change the precision
+    but this will not increase the accuracy of the inexact value. The
+    following is the most accurate 5-digit approximation of a value of 0.1
+    that had only 1 digit of precision:
+
+    >>> approx.evalf(5)
+    0.099609
+
+    By contrast, 0.125 is exact in binary (as it is in base 10) and so it
+    can be passed to Float or evalf to obtain an arbitrary precision with
+    matching accuracy:
+
+    >>> Float(exact, 5)
+    0.12500
+    >>> exact.evalf(20)
+    0.12500000000000000000
+
+    Trying to make a high-precision Float from a float is not disallowed,
+    but one must keep in mind that the *underlying float* (not the apparent
+    decimal value) is being obtained with high precision. For example, 0.3
+    does not have a finite binary representation. The closest rational is
+    the fraction 5404319552844595/2**54. So if you try to obtain a Float of
+    0.3 to 20 digits of precision you will not see the same thing as 0.3
+    followed by 19 zeros:
+
+    >>> Float(0.3, 20)
+    0.29999999999999998890
+
+    If you want a 20-digit value of the decimal 0.3 (not the floating point
+    approximation of 0.3) you should send the 0.3 as a string. The underlying
+    representation is still binary but a higher precision than Python's float
+    is used:
+
+    >>> Float('0.3', 20)
+    0.30000000000000000000
+
+    Although you can increase the precision of an existing Float using Float
+    it will not increase the accuracy -- the underlying value is not changed:
+
+    >>> def show(f): # binary rep of Float
+    ...     from sympy import Mul, Pow
+    ...     s, m, e, b = f._mpf_
+    ...     v = Mul(int(m), Pow(2, int(e), evaluate=False), evaluate=False)
+    ...     print('%s at prec=%s' % (v, f._prec))
+    ...
+    >>> t = Float('0.3', 3)
+    >>> show(t)
+    4915/2**14 at prec=13
+    >>> show(Float(t, 20)) # higher prec, not higher accuracy
+    4915/2**14 at prec=70
+    >>> show(Float(t, 2)) # lower prec
+    307/2**10 at prec=10
+
+    The same thing happens when evalf is used on a Float:
+
+    >>> show(t.evalf(20))
+    4915/2**14 at prec=70
+    >>> show(t.evalf(2))
+    307/2**10 at prec=10
+
+    Finally, Floats can be instantiated with an mpf tuple (n, c, p) to
+    produce the number (-1)**n*c*2**p:
+
+    >>> n, c, p = 1, 5, 0
+    >>> (-1)**n*c*2**p
+    -5
+    >>> Float((1, 5, 0))
+    -5.00000000000000
+
+    An actual mpf tuple also contains the number of bits in c as the last
+    element of the tuple:
+
+    >>> _._mpf_
+    (1, 5, 0, 3)
+
+    This is not needed for instantiation and is not the same thing as the
+    precision. The mpf tuple and the precision are two separate quantities
+    that Float tracks.
+
+    In SymPy, a Float is a number that can be computed with arbitrary
+    precision. Although floating point 'inf' and 'nan' are not such
+    numbers, Float can create these numbers:
+
+    >>> Float('-inf')
+    -oo
+    >>> _.is_Float
+    False
+
+    Zero in Float only has a single value. Values are not separate for
+    positive and negative zeroes.
+    """
+    __slots__ = ('_mpf_', '_prec')
+
+    _mpf_: tuple[int, int, int, int]
+
+    # A Float, though rational in form, does not behave like
+    # a rational in all Python expressions so we deal with
+    # exceptions (where we want to deal with the rational
+    # form of the Float as a rational) at the source rather
+    # than assigning a mathematically loaded category of 'rational'
+    is_rational = None
+    is_irrational = None
+    is_number = True
+
+    is_real = True
+    is_extended_real = True
+
+    is_Float = True
+
+    _remove_non_digits = str.maketrans(dict.fromkeys("-+_."))
+
+    def __new__(cls, num, dps=None, precision=None):
+        if dps is not None and precision is not None:
+            raise ValueError('Both decimal and binary precision supplied. '
+                             'Supply only one. ')
+
+        if isinstance(num, str):
+            _num = num = num.strip()  # Python ignores leading and trailing space
+            num = num.replace(' ', '_').lower()  # Float treats spaces as digit sep; E -> e
+            if num.startswith('.') and len(num) > 1:
+                num = '0' + num
+            elif num.startswith('-.') and len(num) > 2:
+                num = '-0.' + num[2:]
+            elif num in ('inf', '+inf'):
+                return S.Infinity
+            elif num == '-inf':
+                return S.NegativeInfinity
+            elif num == 'nan':
+                return S.NaN
+            elif not _literal_float(num):
+                raise ValueError('string-float not recognized: %s' % _num)
+        elif isinstance(num, float) and num == 0:
+            num = '0'
+        elif isinstance(num, float) and num == float('inf'):
+            return S.Infinity
+        elif isinstance(num, float) and num == float('-inf'):
+            return S.NegativeInfinity
+        elif isinstance(num, float) and math.isnan(num):
+            return S.NaN
+        elif isinstance(num, (SYMPY_INTS, Integer)):
+            num = str(num)
+        elif num is S.Infinity:
+            return num
+        elif num is S.NegativeInfinity:
+            return num
+        elif num is S.NaN:
+            return num
+        elif _is_numpy_instance(num):  # support for numpy datatypes
+            num = _convert_numpy_types(num)
+        elif isinstance(num, mpmath.mpf):
+            if precision is None:
+                if dps is None:
+                    precision = num.context.prec
+            num = num._mpf_
+
+        if dps is None and precision is None:
+            dps = 15
+            if isinstance(num, Float):
+                return num
+            if isinstance(num, str):
+                try:
+                    Num = decimal.Decimal(num)
+                except decimal.InvalidOperation:
+                    pass
+                else:
+                    isint = '.' not in num
+                    num, dps = _decimal_to_Rational_prec(Num)
+                    if num.is_Integer and isint:
+                        # 12e3 is shorthand for int, not float;
+                        # 12.e3 would be the float version
+                        dps = max(dps, num_digits(num))
+                    dps = max(15, dps)
+                    precision = dps_to_prec(dps)
+        elif precision == '' and dps is None or precision is None and dps == '':
+            if not isinstance(num, str):
+                raise ValueError('The null string can only be used when '
+                'the number to Float is passed as a string or an integer.')
+            try:
+                Num = decimal.Decimal(num)
+            except decimal.InvalidOperation:
+                raise ValueError('string-float not recognized by Decimal: %s' % num)
+            else:
+                isint = '.' not in num
+                num, dps = _decimal_to_Rational_prec(Num)
+                if num.is_Integer and isint:
+                    # without dec, e-notation is short for int
+                    dps = max(dps, num_digits(num))
+                    precision = dps_to_prec(dps)
+
+        # decimal precision(dps) is set and maybe binary precision(precision)
+        # as well.From here on binary precision is used to compute the Float.
+        # Hence, if supplied use binary precision else translate from decimal
+        # precision.
+
+        if precision is None or precision == '':
+            precision = dps_to_prec(dps)
+
+        precision = int(precision)
+
+        if isinstance(num, float):
+            _mpf_ = mlib.from_float(num, precision, rnd)
+        elif isinstance(num, str):
+            _mpf_ = mlib.from_str(num, precision, rnd)
+        elif isinstance(num, decimal.Decimal):
+            if num.is_finite():
+                _mpf_ = mlib.from_str(str(num), precision, rnd)
+            elif num.is_nan():
+                return S.NaN
+            elif num.is_infinite():
+                if num > 0:
+                    return S.Infinity
+                return S.NegativeInfinity
+            else:
+                raise ValueError("unexpected decimal value %s" % str(num))
+        elif isinstance(num, tuple) and len(num) in (3, 4):
+            if isinstance(num[1], str):
+                # it's a hexadecimal (coming from a pickled object)
+                num = list(num)
+                # If we're loading an object pickled in Python 2 into
+                # Python 3, we may need to strip a tailing 'L' because
+                # of a shim for int on Python 3, see issue #13470.
+                # Strip leading '0x' - gmpy2 only documents such inputs
+                # with base prefix as valid when the 2nd argument (base) is 0.
+                # When mpmath uses Sage as the backend, however, it
+                # ends up including '0x' when preparing the picklable tuple.
+                # See issue #19690.
+                num[1] = num[1].removeprefix('0x').removesuffix('L')
+                # Now we can assume that it is in standard form
+                num[1] = MPZ(num[1], 16)
+                _mpf_ = tuple(num)
+            else:
+                if len(num) == 4:
+                    # handle normalization hack
+                    return Float._new(num, precision)
+                else:
+                    if not all((
+                            num[0] in (0, 1),
+                            num[1] >= 0,
+                            all(type(i) in (int, int) for i in num)
+                            )):
+                        raise ValueError('malformed mpf: %s' % (num,))
+                    # don't compute number or else it may
+                    # over/underflow
+                    return Float._new(
+                        (num[0], num[1], num[2], bitcount(num[1])),
+                        precision)
+        elif isinstance(num, (Number, NumberSymbol)):
+            _mpf_ = num._as_mpf_val(precision)
+        else:
+            _mpf_ = mpmath.mpf(num, prec=precision)._mpf_
+
+        return cls._new(_mpf_, precision, zero=False)
+
+    @classmethod
+    def _new(cls, _mpf_, _prec, zero=True):
+        # special cases
+        if zero and _mpf_ == fzero:
+            return S.Zero  # Float(0) -> 0.0; Float._new((0,0,0,0)) -> 0
+        elif _mpf_ == _mpf_nan:
+            return S.NaN
+        elif _mpf_ == _mpf_inf:
+            return S.Infinity
+        elif _mpf_ == _mpf_ninf:
+            return S.NegativeInfinity
+
+        obj = Expr.__new__(cls)
+        obj._mpf_ = mpf_norm(_mpf_, _prec)
+        obj._prec = _prec
+        return obj
+
+    def __getnewargs_ex__(self):
+        sign, man, exp, bc = self._mpf_
+        arg = (sign, hex(man)[2:], exp, bc)
+        kwargs = {'precision': self._prec}
+        return ((arg,), kwargs)
+
+    def _hashable_content(self):
+        return (self._mpf_, self._prec)
+
+    def floor(self):
+        return Integer(int(mlib.to_int(
+            mlib.mpf_floor(self._mpf_, self._prec))))
+
+    def ceiling(self):
+        return Integer(int(mlib.to_int(
+            mlib.mpf_ceil(self._mpf_, self._prec))))
+
+    def __floor__(self):
+        return self.floor()
+
+    def __ceil__(self):
+        return self.ceiling()
+
+    @property
+    def num(self):
+        return mpmath.mpf(self._mpf_)
+
+    def _as_mpf_val(self, prec):
+        rv = mpf_norm(self._mpf_, prec)
+        if rv != self._mpf_ and self._prec == prec:
+            debug(self._mpf_, rv)
+        return rv
+
+    def _as_mpf_op(self, prec):
+        return self._mpf_, max(prec, self._prec)
+
+    def _eval_is_finite(self):
+        if self._mpf_ in (_mpf_inf, _mpf_ninf):
+            return False
+        return True
+
+    def _eval_is_infinite(self):
+        if self._mpf_ in (_mpf_inf, _mpf_ninf):
+            return True
+        return False
+
+    def _eval_is_integer(self):
+        if self._mpf_ == fzero:
+            return True
+        if not int_valued(self):
+            return False
+
+    def _eval_is_negative(self):
+        if self._mpf_ in (_mpf_ninf, _mpf_inf):
+            return False
+        return self.num < 0
+
+    def _eval_is_positive(self):
+        if self._mpf_ in (_mpf_ninf, _mpf_inf):
+            return False
+        return self.num > 0
+
+    def _eval_is_extended_negative(self):
+        if self._mpf_ == _mpf_ninf:
+            return True
+        if self._mpf_ == _mpf_inf:
+            return False
+        return self.num < 0
+
+    def _eval_is_extended_positive(self):
+        if self._mpf_ == _mpf_inf:
+            return True
+        if self._mpf_ == _mpf_ninf:
+            return False
+        return self.num > 0
+
+    def _eval_is_zero(self):
+        return self._mpf_ == fzero
+
+    def __bool__(self):
+        return self._mpf_ != fzero
+
+    def __neg__(self):
+        if not self:
+            return self
+        return Float._new(mlib.mpf_neg(self._mpf_), self._prec)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_add(self._mpf_, rhs, prec, rnd), prec)
+        return Number.__add__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_sub(self._mpf_, rhs, prec, rnd), prec)
+        return Number.__sub__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_mul(self._mpf_, rhs, prec, rnd), prec)
+        return Number.__mul__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Number) and other != 0 and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_div(self._mpf_, rhs, prec, rnd), prec)
+        return Number.__truediv__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mod__(self, other):
+        if isinstance(other, Rational) and other.q != 1 and global_parameters.evaluate:
+            # calculate mod with Rationals, *then* round the result
+            return Float(Rational.__mod__(Rational(self), other),
+                         precision=self._prec)
+        if isinstance(other, Float) and global_parameters.evaluate:
+            r = self/other
+            if int_valued(r):
+                return Float(0, precision=max(self._prec, other._prec))
+        if isinstance(other, Number) and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_mod(self._mpf_, rhs, prec, rnd), prec)
+        return Number.__mod__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __rmod__(self, other):
+        if isinstance(other, Float) and global_parameters.evaluate:
+            return other.__mod__(self)
+        if isinstance(other, Number) and global_parameters.evaluate:
+            rhs, prec = other._as_mpf_op(self._prec)
+            return Float._new(mlib.mpf_mod(rhs, self._mpf_, prec, rnd), prec)
+        return Number.__rmod__(self, other)
+
+    def _eval_power(self, expt):
+        """
+        expt is symbolic object but not equal to 0, 1
+
+        (-p)**r -> exp(r*log(-p)) -> exp(r*(log(p) + I*Pi)) ->
+                  -> p**r*(sin(Pi*r) + cos(Pi*r)*I)
+        """
+        if equal_valued(self, 0):
+            if expt.is_extended_positive:
+                return self
+            if expt.is_extended_negative:
+                return S.ComplexInfinity
+        if isinstance(expt, Number):
+            if isinstance(expt, Integer):
+                prec = self._prec
+                return Float._new(
+                    mlib.mpf_pow_int(self._mpf_, expt.p, prec, rnd), prec)
+            elif isinstance(expt, Rational) and \
+                    expt.p == 1 and expt.q % 2 and self.is_negative:
+                return Pow(S.NegativeOne, expt, evaluate=False)*(
+                    -self)._eval_power(expt)
+            expt, prec = expt._as_mpf_op(self._prec)
+            mpfself = self._mpf_
+            try:
+                y = mpf_pow(mpfself, expt, prec, rnd)
+                return Float._new(y, prec)
+            except mlib.ComplexResult:
+                re, im = mlib.mpc_pow(
+                    (mpfself, fzero), (expt, fzero), prec, rnd)
+                return Float._new(re, prec) + \
+                    Float._new(im, prec)*S.ImaginaryUnit
+
+    def __abs__(self):
+        return Float._new(mlib.mpf_abs(self._mpf_), self._prec)
+
+    def __int__(self):
+        if self._mpf_ == fzero:
+            return 0
+        return int(mlib.to_int(self._mpf_))  # uses round_fast = round_down
+
+    def __eq__(self, other):
+        if isinstance(other, float):
+            other = Float(other)
+        return Basic.__eq__(self, other)
+
+    def __ne__(self, other):
+        eq = self.__eq__(other)
+        if eq is NotImplemented:
+            return eq
+        else:
+            return not eq
+
+    def __hash__(self):
+        float_val = float(self)
+        if not math.isinf(float_val):
+            return hash(float_val)
+        return Basic.__hash__(self)
+
+    def _Frel(self, other, op):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Rational:
+            # test self*other.q  other.p without losing precision
+            '''
+            >>> f = Float(.1,2)
+            >>> i = 1234567890
+            >>> (f*i)._mpf_
+            (0, 471, 18, 9)
+            >>> mlib.mpf_mul(f._mpf_, mlib.from_int(i))
+            (0, 505555550955, -12, 39)
+            '''
+            smpf = mlib.mpf_mul(self._mpf_, mlib.from_int(other.q))
+            ompf = mlib.from_int(other.p)
+            return _sympify(bool(op(smpf, ompf)))
+        elif other.is_Float:
+            return _sympify(bool(
+                        op(self._mpf_, other._mpf_)))
+        elif other.is_comparable and other not in (
+                S.Infinity, S.NegativeInfinity):
+            other = other.evalf(prec_to_dps(self._prec))
+            if other._prec > 1:
+                if other.is_Number:
+                    return _sympify(bool(
+                        op(self._mpf_, other._as_mpf_val(self._prec))))
+
+    def __gt__(self, other):
+        if isinstance(other, NumberSymbol):
+            return other.__lt__(self)
+        rv = self._Frel(other, mlib.mpf_gt)
+        if rv is None:
+            return Expr.__gt__(self, other)
+        return rv
+
+    def __ge__(self, other):
+        if isinstance(other, NumberSymbol):
+            return other.__le__(self)
+        rv = self._Frel(other, mlib.mpf_ge)
+        if rv is None:
+            return Expr.__ge__(self, other)
+        return rv
+
+    def __lt__(self, other):
+        if isinstance(other, NumberSymbol):
+            return other.__gt__(self)
+        rv = self._Frel(other, mlib.mpf_lt)
+        if rv is None:
+            return Expr.__lt__(self, other)
+        return rv
+
+    def __le__(self, other):
+        if isinstance(other, NumberSymbol):
+            return other.__ge__(self)
+        rv = self._Frel(other, mlib.mpf_le)
+        if rv is None:
+            return Expr.__le__(self, other)
+        return rv
+
+    def epsilon_eq(self, other, epsilon="1e-15"):
+        return abs(self - other) < Float(epsilon)
+
+    def __format__(self, format_spec):
+        return format(decimal.Decimal(str(self)), format_spec)
+
+
+# Add sympify converters
+_sympy_converter[float] = _sympy_converter[decimal.Decimal] = Float
+
+# this is here to work nicely in Sage
+RealNumber = Float
+
+
+class Rational(Number):
+    """Represents rational numbers (p/q) of any size.
+
+    Examples
+    ========
+
+    >>> from sympy import Rational, nsimplify, S, pi
+    >>> Rational(1, 2)
+    1/2
+
+    Rational is unprejudiced in accepting input. If a float is passed, the
+    underlying value of the binary representation will be returned:
+
+    >>> Rational(.5)
+    1/2
+    >>> Rational(.2)
+    3602879701896397/18014398509481984
+
+    If the simpler representation of the float is desired then consider
+    limiting the denominator to the desired value or convert the float to
+    a string (which is roughly equivalent to limiting the denominator to
+    10**12):
+
+    >>> Rational(str(.2))
+    1/5
+    >>> Rational(.2).limit_denominator(10**12)
+    1/5
+
+    An arbitrarily precise Rational is obtained when a string literal is
+    passed:
+
+    >>> Rational("1.23")
+    123/100
+    >>> Rational('1e-2')
+    1/100
+    >>> Rational(".1")
+    1/10
+    >>> Rational('1e-2/3.2')
+    1/320
+
+    The conversion of other types of strings can be handled by
+    the sympify() function, and conversion of floats to expressions
+    or simple fractions can be handled with nsimplify:
+
+    >>> S('.[3]')  # repeating digits in brackets
+    1/3
+    >>> S('3**2/10')  # general expressions
+    9/10
+    >>> nsimplify(.3)  # numbers that have a simple form
+    3/10
+
+    But if the input does not reduce to a literal Rational, an error will
+    be raised:
+
+    >>> Rational(pi)
+    Traceback (most recent call last):
+    ...
+    TypeError: invalid input: pi
+
+
+    Low-level
+    ---------
+
+    Access numerator and denominator as .p and .q:
+
+    >>> r = Rational(3, 4)
+    >>> r
+    3/4
+    >>> r.p
+    3
+    >>> r.q
+    4
+
+    Note that p and q return integers (not SymPy Integers) so some care
+    is needed when using them in expressions:
+
+    >>> r.p/r.q
+    0.75
+
+    See Also
+    ========
+    sympy.core.sympify.sympify, sympy.simplify.simplify.nsimplify
+    """
+    is_real = True
+    is_integer = False
+    is_rational = True
+    is_number = True
+
+    __slots__ = ('p', 'q')
+
+    p: int
+    q: int
+
+    is_Rational = True
+
+    @cacheit
+    def __new__(cls, p, q=None, gcd=None):
+        if q is None:
+            if isinstance(p, Rational):
+                return p
+
+            if isinstance(p, SYMPY_INTS):
+                pass
+            else:
+                if isinstance(p, (float, Float)):
+                    return Rational(*_as_integer_ratio(p))
+
+                if not isinstance(p, str):
+                    try:
+                        p = sympify(p)
+                    except (SympifyError, SyntaxError):
+                        pass  # error will raise below
+                else:
+                    if p.count('/') > 1:
+                        raise TypeError('invalid input: %s' % p)
+                    p = p.replace(' ', '')
+                    pq = p.rsplit('/', 1)
+                    if len(pq) == 2:
+                        p, q = pq
+                        fp = fractions.Fraction(p)
+                        fq = fractions.Fraction(q)
+                        p = fp/fq
+                    try:
+                        p = fractions.Fraction(p)
+                    except ValueError:
+                        pass  # error will raise below
+                    else:
+                        return cls._new(p.numerator, p.denominator, 1)
+
+                if not isinstance(p, Rational):
+                    raise TypeError('invalid input: %s' % p)
+
+            q = 1
+
+        Q = 1
+
+        if not isinstance(p, SYMPY_INTS):
+            p = Rational(p)
+            Q *= p.q
+            p = p.p
+        else:
+            p = int(p)
+
+        if not isinstance(q, SYMPY_INTS):
+            q = Rational(q)
+            p *= q.q
+            Q *= q.p
+        else:
+            Q *= int(q)
+        q = Q
+
+        if gcd is not None:
+            sympy_deprecation_warning(
+                "gcd is deprecated in Rational, use nsimplify instead",
+                deprecated_since_version="1.11",
+                active_deprecations_target="deprecated-rational-gcd",
+                stacklevel=4,
+            )
+            return cls._new(p, q, gcd)
+
+        # p and q are now ints
+        return cls._new(p, q)
+
+    @classmethod
+    def _new(cls, p, q, gcd=None):
+        if q == 0:
+            if p == 0:
+                if _errdict["divide"]:
+                    raise ValueError("Indeterminate 0/0")
+                else:
+                    return S.NaN
+            return S.ComplexInfinity
+
+        if q < 0:
+            q = -q
+            p = -p
+
+        if gcd is None:
+            gcd = igcd(abs(p), q)
+
+        if gcd > 1:
+            p //= gcd
+            q //= gcd
+
+        return cls.from_coprime_ints(p, q)
+
+    @classmethod
+    def from_coprime_ints(cls, p: int, q: int) -> Rational:
+        """Create a Rational from a pair of coprime integers.
+
+        Both ``p`` and ``q`` should be strictly of type ``int``.
+
+        The caller should ensure that ``gcd(p,q) == 1`` and ``q > 0``.
+
+        This may be more efficient than ``Rational(p, q)``. The validity of the
+        arguments may or may not be checked so it should not be relied upon to
+        pass unvalidated or invalid arguments to this function.
+        """
+        if q == 1:
+            return Integer(p)
+        if p == 1 and q == 2:
+            return S.Half
+
+        obj = Expr.__new__(cls)
+        obj.p = p
+        obj.q = q
+        return obj
+
+    def limit_denominator(self, max_denominator=1000000):
+        """Closest Rational to self with denominator at most max_denominator.
+
+        Examples
+        ========
+
+        >>> from sympy import Rational
+        >>> Rational('3.141592653589793').limit_denominator(10)
+        22/7
+        >>> Rational('3.141592653589793').limit_denominator(100)
+        311/99
+
+        """
+        f = fractions.Fraction(self.p, self.q)
+        return Rational(f.limit_denominator(fractions.Fraction(int(max_denominator))))
+
+    def __getnewargs__(self):
+        return (self.p, self.q)
+
+    def _hashable_content(self):
+        return (self.p, self.q)
+
+    def _eval_is_positive(self):
+        return self.p > 0
+
+    def _eval_is_zero(self):
+        return self.p == 0
+
+    def __neg__(self):
+        return Rational(-self.p, self.q)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                return Rational._new(self.p + self.q*other.p, self.q, 1)
+            elif isinstance(other, Rational):
+                #TODO: this can probably be optimized more
+                return Rational(self.p*other.q + self.q*other.p, self.q*other.q)
+            elif isinstance(other, Float):
+                return other + self
+            else:
+                return Number.__add__(self, other)
+        return Number.__add__(self, other)
+    __radd__ = __add__
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                return Rational._new(self.p - self.q*other.p, self.q, 1)
+            elif isinstance(other, Rational):
+                return Rational(self.p*other.q - self.q*other.p, self.q*other.q)
+            elif isinstance(other, Float):
+                return -other + self
+            else:
+                return Number.__sub__(self, other)
+        return Number.__sub__(self, other)
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                return Rational._new(self.q*other.p - self.p, self.q, 1)
+            elif isinstance(other, Rational):
+                return Rational(self.q*other.p - self.p*other.q, self.q*other.q)
+            elif isinstance(other, Float):
+                return -self + other
+            else:
+                return Number.__rsub__(self, other)
+        return Number.__rsub__(self, other)
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                return Rational._new(self.p*other.p, self.q, igcd(other.p, self.q))
+            elif isinstance(other, Rational):
+                return Rational._new(self.p*other.p, self.q*other.q, igcd(self.p, other.q)*igcd(self.q, other.p))
+            elif isinstance(other, Float):
+                return other*self
+            else:
+                return Number.__mul__(self, other)
+        return Number.__mul__(self, other)
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                if self.p and other.p == S.Zero:
+                    return S.ComplexInfinity
+                else:
+                    return Rational._new(self.p, self.q*other.p, igcd(self.p, other.p))
+            elif isinstance(other, Rational):
+                return Rational._new(self.p*other.q, self.q*other.p, igcd(self.p, other.p)*igcd(self.q, other.q))
+            elif isinstance(other, Float):
+                return self*(1/other)
+            else:
+                return Number.__truediv__(self, other)
+        return Number.__truediv__(self, other)
+    @_sympifyit('other', NotImplemented)
+    def __rtruediv__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Integer):
+                return Rational._new(other.p*self.q, self.p, igcd(self.p, other.p))
+            elif isinstance(other, Rational):
+                return Rational._new(other.p*self.q, other.q*self.p, igcd(self.p, other.p)*igcd(self.q, other.q))
+            elif isinstance(other, Float):
+                return other*(1/self)
+            else:
+                return Number.__rtruediv__(self, other)
+        return Number.__rtruediv__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mod__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, Rational):
+                n = (self.p*other.q) // (other.p*self.q)
+                return Rational(self.p*other.q - n*other.p*self.q, self.q*other.q)
+            if isinstance(other, Float):
+                # calculate mod with Rationals, *then* round the answer
+                return Float(self.__mod__(Rational(other)),
+                             precision=other._prec)
+            return Number.__mod__(self, other)
+        return Number.__mod__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __rmod__(self, other):
+        if isinstance(other, Rational):
+            return Rational.__mod__(other, self)
+        return Number.__rmod__(self, other)
+
+    def _eval_power(self, expt):
+        if isinstance(expt, Number):
+            if isinstance(expt, Float):
+                return self._eval_evalf(expt._prec)**expt
+            if expt.is_extended_negative:
+                # (3/4)**-2 -> (4/3)**2
+                ne = -expt
+                if (ne is S.One):
+                    return Rational(self.q, self.p)
+                if self.is_negative:
+                    return S.NegativeOne**expt*Rational(self.q, -self.p)**ne
+                else:
+                    return Rational(self.q, self.p)**ne
+            if expt is S.Infinity:  # -oo already caught by test for negative
+                if self.p > self.q:
+                    # (3/2)**oo -> oo
+                    return S.Infinity
+                if self.p < -self.q:
+                    # (-3/2)**oo -> oo + I*oo
+                    return S.Infinity + S.Infinity*S.ImaginaryUnit
+                return S.Zero
+            if isinstance(expt, Integer):
+                # (4/3)**2 -> 4**2 / 3**2
+                return Rational._new(self.p**expt.p, self.q**expt.p, 1)
+            if isinstance(expt, Rational):
+                intpart = expt.p // expt.q
+                if intpart:
+                    intpart += 1
+                    remfracpart = intpart*expt.q - expt.p
+                    ratfracpart = Rational(remfracpart, expt.q)
+                    if self.p != 1:
+                        return Integer(self.p)**expt*Integer(self.q)**ratfracpart*Rational._new(1, self.q**intpart, 1)
+                    return Integer(self.q)**ratfracpart*Rational._new(1, self.q**intpart, 1)
+                else:
+                    remfracpart = expt.q - expt.p
+                    ratfracpart = Rational(remfracpart, expt.q)
+                    if self.p != 1:
+                        return Integer(self.p)**expt*Integer(self.q)**ratfracpart*Rational._new(1, self.q, 1)
+                    return Integer(self.q)**ratfracpart*Rational._new(1, self.q, 1)
+
+        if self.is_extended_negative and expt.is_even:
+            return (-self)**expt
+
+        return
+
+    def _as_mpf_val(self, prec):
+        return mlib.from_rational(self.p, self.q, prec, rnd)
+
+    def _mpmath_(self, prec, rnd):
+        return mpmath.make_mpf(mlib.from_rational(self.p, self.q, prec, rnd))
+
+    def __abs__(self):
+        return Rational(abs(self.p), self.q)
+
+    def __int__(self):
+        p, q = self.p, self.q
+        if p < 0:
+            return -int(-p//q)
+        return int(p//q)
+
+    def floor(self):
+        return Integer(self.p // self.q)
+
+    def ceiling(self):
+        return -Integer(-self.p // self.q)
+
+    def __floor__(self):
+        return self.floor()
+
+    def __ceil__(self):
+        return self.ceiling()
+
+    def __eq__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if not isinstance(other, Number):
+            # S(0) == S.false is False
+            # S(0) == False is True
+            return False
+        if other.is_NumberSymbol:
+            if other.is_irrational:
+                return False
+            return other.__eq__(self)
+        if other.is_Rational:
+            # a Rational is always in reduced form so will never be 2/4
+            # so we can just check equivalence of args
+            return self.p == other.p and self.q == other.q
+        return False
+
+    def __ne__(self, other):
+        return not self == other
+
+    def _Rrel(self, other, attr):
+        # if you want self < other, pass self, other, __gt__
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Number:
+            op = None
+            s, o = self, other
+            if other.is_NumberSymbol:
+                op = getattr(o, attr)
+            elif other.is_Float:
+                op = getattr(o, attr)
+            elif other.is_Rational:
+                s, o = Integer(s.p*o.q), Integer(s.q*o.p)
+                op = getattr(o, attr)
+            if op:
+                return op(s)
+            if o.is_number and o.is_extended_real:
+                return Integer(s.p), s.q*o
+
+    def __gt__(self, other):
+        rv = self._Rrel(other, '__lt__')
+        if rv is None:
+            rv = self, other
+        elif not isinstance(rv, tuple):
+            return rv
+        return Expr.__gt__(*rv)
+
+    def __ge__(self, other):
+        rv = self._Rrel(other, '__le__')
+        if rv is None:
+            rv = self, other
+        elif not isinstance(rv, tuple):
+            return rv
+        return Expr.__ge__(*rv)
+
+    def __lt__(self, other):
+        rv = self._Rrel(other, '__gt__')
+        if rv is None:
+            rv = self, other
+        elif not isinstance(rv, tuple):
+            return rv
+        return Expr.__lt__(*rv)
+
+    def __le__(self, other):
+        rv = self._Rrel(other, '__ge__')
+        if rv is None:
+            rv = self, other
+        elif not isinstance(rv, tuple):
+            return rv
+        return Expr.__le__(*rv)
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def factors(self, limit=None, use_trial=True, use_rho=False,
+                use_pm1=False, verbose=False, visual=False):
+        """A wrapper to factorint which return factors of self that are
+        smaller than limit (or cheap to compute). Special methods of
+        factoring are disabled by default so that only trial division is used.
+        """
+        from sympy.ntheory.factor_ import factorrat
+
+        return factorrat(self, limit=limit, use_trial=use_trial,
+                      use_rho=use_rho, use_pm1=use_pm1,
+                      verbose=verbose).copy()
+
+    @property
+    def numerator(self):
+        return self.p
+
+    @property
+    def denominator(self):
+        return self.q
+
+    @_sympifyit('other', NotImplemented)
+    def gcd(self, other):
+        if isinstance(other, Rational):
+            if other == S.Zero:
+                return other
+            return Rational(
+                igcd(self.p, other.p),
+                ilcm(self.q, other.q))
+        return Number.gcd(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def lcm(self, other):
+        if isinstance(other, Rational):
+            return Rational(
+                self.p // igcd(self.p, other.p) * other.p,
+                igcd(self.q, other.q))
+        return Number.lcm(self, other)
+
+    def as_numer_denom(self):
+        return Integer(self.p), Integer(self.q)
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self.
+
+        Examples
+        ========
+
+        >>> from sympy import S
+        >>> (S(-3)/2).as_content_primitive()
+        (3/2, -1)
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+
+        if self:
+            if self.is_positive:
+                return self, S.One
+            return -self, S.NegativeOne
+        return S.One, self
+
+    def as_coeff_Mul(self, rational=False):
+        """Efficiently extract the coefficient of a product."""
+        return self, S.One
+
+    def as_coeff_Add(self, rational=False):
+        """Efficiently extract the coefficient of a summation."""
+        return self, S.Zero
+
+
+class Integer(Rational):
+    """Represents integer numbers of any size.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer
+    >>> Integer(3)
+    3
+
+    If a float or a rational is passed to Integer, the fractional part
+    will be discarded; the effect is of rounding toward zero.
+
+    >>> Integer(3.8)
+    3
+    >>> Integer(-3.8)
+    -3
+
+    A string is acceptable input if it can be parsed as an integer:
+
+    >>> Integer("9" * 20)
+    99999999999999999999
+
+    It is rarely needed to explicitly instantiate an Integer, because
+    Python integers are automatically converted to Integer when they
+    are used in SymPy expressions.
+    """
+    q = 1
+    is_integer = True
+    is_number = True
+
+    is_Integer = True
+
+    __slots__ = ()
+
+    def _as_mpf_val(self, prec):
+        return mlib.from_int(self.p, prec, rnd)
+
+    def _mpmath_(self, prec, rnd):
+        return mpmath.make_mpf(self._as_mpf_val(prec))
+
+    @cacheit
+    def __new__(cls, i):
+        if isinstance(i, str):
+            i = i.replace(' ', '')
+        # whereas we cannot, in general, make a Rational from an
+        # arbitrary expression, we can make an Integer unambiguously
+        # (except when a non-integer expression happens to round to
+        # an integer). So we proceed by taking int() of the input and
+        # let the int routines determine whether the expression can
+        # be made into an int or whether an error should be raised.
+        try:
+            ival = int(i)
+        except TypeError:
+            raise TypeError(
+                "Argument of Integer should be of numeric type, got %s." % i)
+        # We only work with well-behaved integer types. This converts, for
+        # example, numpy.int32 instances.
+        if ival == 1:
+            return S.One
+        if ival == -1:
+            return S.NegativeOne
+        if ival == 0:
+            return S.Zero
+        obj = Expr.__new__(cls)
+        obj.p = ival
+        return obj
+
+    def __getnewargs__(self):
+        return (self.p,)
+
+    # Arithmetic operations are here for efficiency
+    def __int__(self):
+        return self.p
+
+    def floor(self):
+        return Integer(self.p)
+
+    def ceiling(self):
+        return Integer(self.p)
+
+    def __floor__(self):
+        return self.floor()
+
+    def __ceil__(self):
+        return self.ceiling()
+
+    def __neg__(self):
+        return Integer(-self.p)
+
+    def __abs__(self):
+        if self.p >= 0:
+            return self
+        else:
+            return Integer(-self.p)
+
+    def __divmod__(self, other):
+        if isinstance(other, Integer) and global_parameters.evaluate:
+            return Tuple(*(divmod(self.p, other.p)))
+        else:
+            return Number.__divmod__(self, other)
+
+    def __rdivmod__(self, other):
+        if isinstance(other, int) and global_parameters.evaluate:
+            return Tuple(*(divmod(other, self.p)))
+        else:
+            try:
+                other = Number(other)
+            except TypeError:
+                msg = "unsupported operand type(s) for divmod(): '%s' and '%s'"
+                oname = type(other).__name__
+                sname = type(self).__name__
+                raise TypeError(msg % (oname, sname))
+            return Number.__divmod__(other, self)
+
+    # TODO make it decorator + bytecodehacks?
+    def __add__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(self.p + other)
+            elif isinstance(other, Integer):
+                return Integer(self.p + other.p)
+            elif isinstance(other, Rational):
+                return Rational._new(self.p*other.q + other.p, other.q, 1)
+            return Rational.__add__(self, other)
+        else:
+            return Add(self, other)
+
+    def __radd__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(other + self.p)
+            elif isinstance(other, Rational):
+                return Rational._new(other.p + self.p*other.q, other.q, 1)
+            return Rational.__radd__(self, other)
+        return Rational.__radd__(self, other)
+
+    def __sub__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(self.p - other)
+            elif isinstance(other, Integer):
+                return Integer(self.p - other.p)
+            elif isinstance(other, Rational):
+                return Rational._new(self.p*other.q - other.p, other.q, 1)
+            return Rational.__sub__(self, other)
+        return Rational.__sub__(self, other)
+
+    def __rsub__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(other - self.p)
+            elif isinstance(other, Rational):
+                return Rational._new(other.p - self.p*other.q, other.q, 1)
+            return Rational.__rsub__(self, other)
+        return Rational.__rsub__(self, other)
+
+    def __mul__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(self.p*other)
+            elif isinstance(other, Integer):
+                return Integer(self.p*other.p)
+            elif isinstance(other, Rational):
+                return Rational._new(self.p*other.p, other.q, igcd(self.p, other.q))
+            return Rational.__mul__(self, other)
+        return Rational.__mul__(self, other)
+
+    def __rmul__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(other*self.p)
+            elif isinstance(other, Rational):
+                return Rational._new(other.p*self.p, other.q, igcd(self.p, other.q))
+            return Rational.__rmul__(self, other)
+        return Rational.__rmul__(self, other)
+
+    def __mod__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(self.p % other)
+            elif isinstance(other, Integer):
+                return Integer(self.p % other.p)
+            return Rational.__mod__(self, other)
+        return Rational.__mod__(self, other)
+
+    def __rmod__(self, other):
+        if global_parameters.evaluate:
+            if isinstance(other, int):
+                return Integer(other % self.p)
+            elif isinstance(other, Integer):
+                return Integer(other.p % self.p)
+            return Rational.__rmod__(self, other)
+        return Rational.__rmod__(self, other)
+
+    def __eq__(self, other):
+        if isinstance(other, int):
+            return (self.p == other)
+        elif isinstance(other, Integer):
+            return (self.p == other.p)
+        return Rational.__eq__(self, other)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __gt__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Integer:
+            return _sympify(self.p > other.p)
+        return Rational.__gt__(self, other)
+
+    def __lt__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Integer:
+            return _sympify(self.p < other.p)
+        return Rational.__lt__(self, other)
+
+    def __ge__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Integer:
+            return _sympify(self.p >= other.p)
+        return Rational.__ge__(self, other)
+
+    def __le__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if other.is_Integer:
+            return _sympify(self.p <= other.p)
+        return Rational.__le__(self, other)
+
+    def __hash__(self):
+        return hash(self.p)
+
+    def __index__(self):
+        return self.p
+
+    ########################################
+
+    def _eval_is_odd(self):
+        return bool(self.p % 2)
+
+    def _eval_power(self, expt):
+        """
+        Tries to do some simplifications on self**expt
+
+        Returns None if no further simplifications can be done.
+
+        Explanation
+        ===========
+
+        When exponent is a fraction (so we have for example a square root),
+        we try to find a simpler representation by factoring the argument
+        up to factors of 2**15, e.g.
+
+          - sqrt(4) becomes 2
+          - sqrt(-4) becomes 2*I
+          - (2**(3+7)*3**(6+7))**Rational(1,7) becomes 6*18**(3/7)
+
+        Further simplification would require a special call to factorint on
+        the argument which is not done here for sake of speed.
+
+        """
+        from sympy.ntheory.factor_ import perfect_power
+
+        if expt is S.Infinity:
+            if self.p > S.One:
+                return S.Infinity
+            # cases -1, 0, 1 are done in their respective classes
+            return S.Infinity + S.ImaginaryUnit*S.Infinity
+        if expt is S.NegativeInfinity:
+            return Rational._new(1, self, 1)**S.Infinity
+        if not isinstance(expt, Number):
+            # simplify when expt is even
+            # (-2)**k --> 2**k
+            if self.is_negative and expt.is_even:
+                return (-self)**expt
+        if isinstance(expt, Float):
+            # Rational knows how to exponentiate by a Float
+            return super()._eval_power(expt)
+        if not isinstance(expt, Rational):
+            return
+        if expt is S.Half and self.is_negative:
+            # we extract I for this special case since everyone is doing so
+            return S.ImaginaryUnit*Pow(-self, expt)
+        if expt.is_negative:
+            # invert base and change sign on exponent
+            ne = -expt
+            if self.is_negative:
+                return S.NegativeOne**expt*Rational._new(1, -self.p, 1)**ne
+            else:
+                return Rational._new(1, self.p, 1)**ne
+        # see if base is a perfect root, sqrt(4) --> 2
+        x, xexact = integer_nthroot(abs(self.p), expt.q)
+        if xexact:
+            # if it's a perfect root we've finished
+            result = Integer(x**abs(expt.p))
+            if self.is_negative:
+                result *= S.NegativeOne**expt
+            return result
+
+        # The following is an algorithm where we collect perfect roots
+        # from the factors of base.
+
+        # if it's not an nth root, it still might be a perfect power
+        b_pos = int(abs(self.p))
+        p = perfect_power(b_pos)
+        if p is not False:
+            # XXX: Convert to int because perfect_power may return fmpz
+            # Ideally that should be fixed in perfect_power though...
+            dict = {int(p[0]): int(p[1])}
+        else:
+            dict = Integer(b_pos).factors(limit=2**15)
+
+        # now process the dict of factors
+        out_int = 1  # integer part
+        out_rad = 1  # extracted radicals
+        sqr_int = 1
+        sqr_gcd = 0
+        sqr_dict = {}
+        for prime, exponent in dict.items():
+            exponent *= expt.p
+            # remove multiples of expt.q: (2**12)**(1/10) -> 2*(2**2)**(1/10)
+            div_e, div_m = divmod(exponent, expt.q)
+            if div_e > 0:
+                out_int *= prime**div_e
+            if div_m > 0:
+                # see if the reduced exponent shares a gcd with e.q
+                # (2**2)**(1/10) -> 2**(1/5)
+                g = igcd(div_m, expt.q)
+                if g != 1:
+                    out_rad *= Pow(prime, Rational._new(div_m//g, expt.q//g, 1))
+                else:
+                    sqr_dict[prime] = div_m
+        # identify gcd of remaining powers
+        for p, ex in sqr_dict.items():
+            if sqr_gcd == 0:
+                sqr_gcd = ex
+            else:
+                sqr_gcd = igcd(sqr_gcd, ex)
+                if sqr_gcd == 1:
+                    break
+        for k, v in sqr_dict.items():
+            sqr_int *= k**(v//sqr_gcd)
+        if sqr_int == b_pos and out_int == 1 and out_rad == 1:
+            result = None
+        else:
+            result = out_int*out_rad*Pow(sqr_int, Rational(sqr_gcd, expt.q))
+            if self.is_negative:
+                result *= Pow(S.NegativeOne, expt)
+        return result
+
+    def _eval_is_prime(self):
+        from sympy.ntheory.primetest import isprime
+
+        return isprime(self)
+
+    def _eval_is_composite(self):
+        if self > 1:
+            return fuzzy_not(self.is_prime)
+        else:
+            return False
+
+    def as_numer_denom(self):
+        return self, S.One
+
+    @_sympifyit('other', NotImplemented)
+    def __floordiv__(self, other):
+        if not isinstance(other, Expr):
+            return NotImplemented
+        if isinstance(other, Integer):
+            return Integer(self.p // other)
+        return divmod(self, other)[0]
+
+    def __rfloordiv__(self, other):
+        return Integer(Integer(other).p // self.p)
+
+    # These bitwise operations (__lshift__, __rlshift__, ..., __invert__) are defined
+    # for Integer only and not for general SymPy expressions. This is to achieve
+    # compatibility with the numbers.Integral ABC which only defines these operations
+    # among instances of numbers.Integral. Therefore, these methods check explicitly for
+    # integer types rather than using sympify because they should not accept arbitrary
+    # symbolic expressions and there is no symbolic analogue of numbers.Integral's
+    # bitwise operations.
+    def __lshift__(self, other):
+        if isinstance(other, (int, Integer, numbers.Integral)):
+            return Integer(self.p << int(other))
+        else:
+            return NotImplemented
+
+    def __rlshift__(self, other):
+        if isinstance(other, (int, numbers.Integral)):
+            return Integer(int(other) << self.p)
+        else:
+            return NotImplemented
+
+    def __rshift__(self, other):
+        if isinstance(other, (int, Integer, numbers.Integral)):
+            return Integer(self.p >> int(other))
+        else:
+            return NotImplemented
+
+    def __rrshift__(self, other):
+        if isinstance(other, (int, numbers.Integral)):
+            return Integer(int(other) >> self.p)
+        else:
+            return NotImplemented
+
+    def __and__(self, other):
+        if isinstance(other, (int, Integer, numbers.Integral)):
+            return Integer(self.p & int(other))
+        else:
+            return NotImplemented
+
+    def __rand__(self, other):
+        if isinstance(other, (int, numbers.Integral)):
+            return Integer(int(other) & self.p)
+        else:
+            return NotImplemented
+
+    def __xor__(self, other):
+        if isinstance(other, (int, Integer, numbers.Integral)):
+            return Integer(self.p ^ int(other))
+        else:
+            return NotImplemented
+
+    def __rxor__(self, other):
+        if isinstance(other, (int, numbers.Integral)):
+            return Integer(int(other) ^ self.p)
+        else:
+            return NotImplemented
+
+    def __or__(self, other):
+        if isinstance(other, (int, Integer, numbers.Integral)):
+            return Integer(self.p | int(other))
+        else:
+            return NotImplemented
+
+    def __ror__(self, other):
+        if isinstance(other, (int, numbers.Integral)):
+            return Integer(int(other) | self.p)
+        else:
+            return NotImplemented
+
+    def __invert__(self):
+        return Integer(~self.p)
+
+# Add sympify converters
+_sympy_converter[int] = Integer
+
+
+class AlgebraicNumber(Expr):
+    r"""
+    Class for representing algebraic numbers in SymPy.
+
+    Symbolically, an instance of this class represents an element
+    $\alpha \in \mathbb{Q}(\theta) \hookrightarrow \mathbb{C}$. That is, the
+    algebraic number $\alpha$ is represented as an element of a particular
+    number field $\mathbb{Q}(\theta)$, with a particular embedding of this
+    field into the complex numbers.
+
+    Formally, the primitive element $\theta$ is given by two data points: (1)
+    its minimal polynomial (which defines $\mathbb{Q}(\theta)$), and (2) a
+    particular complex number that is a root of this polynomial (which defines
+    the embedding $\mathbb{Q}(\theta) \hookrightarrow \mathbb{C}$). Finally,
+    the algebraic number $\alpha$ which we represent is then given by the
+    coefficients of a polynomial in $\theta$.
+    """
+
+    __slots__ = ('rep', 'root', 'alias', 'minpoly', '_own_minpoly')
+
+    is_AlgebraicNumber = True
+    is_algebraic = True
+    is_number = True
+
+
+    kind = NumberKind
+
+    # Optional alias symbol is not free.
+    # Actually, alias should be a Str, but some methods
+    # expect that it be an instance of Expr.
+    free_symbols: set[Basic] = set()
+
+    def __new__(cls, expr, coeffs=None, alias=None, **args):
+        r"""
+        Construct a new algebraic number $\alpha$ belonging to a number field
+        $k = \mathbb{Q}(\theta)$.
+
+        There are four instance attributes to be determined:
+
+        ===========  ============================================================================
+        Attribute    Type/Meaning
+        ===========  ============================================================================
+        ``root``     :py:class:`~.Expr` for $\theta$ as a complex number
+        ``minpoly``  :py:class:`~.Poly`, the minimal polynomial of $\theta$
+        ``rep``      :py:class:`~sympy.polys.polyclasses.DMP` giving $\alpha$ as poly in $\theta$
+        ``alias``    :py:class:`~.Symbol` for $\theta$, or ``None``
+        ===========  ============================================================================
+
+        See Parameters section for how they are determined.
+
+        Parameters
+        ==========
+
+        expr : :py:class:`~.Expr`, or pair $(m, r)$
+            There are three distinct modes of construction, depending on what
+            is passed as *expr*.
+
+            **(1)** *expr* is an :py:class:`~.AlgebraicNumber`:
+            In this case we begin by copying all four instance attributes from
+            *expr*. If *coeffs* were also given, we compose the two coeff
+            polynomials (see below). If an *alias* was given, it overrides.
+
+            **(2)** *expr* is any other type of :py:class:`~.Expr`:
+            Then ``root`` will equal *expr*. Therefore it
+            must express an algebraic quantity, and we will compute its
+            ``minpoly``.
+
+            **(3)** *expr* is an ordered pair $(m, r)$ giving the
+            ``minpoly`` $m$, and a ``root`` $r$ thereof, which together
+            define $\theta$. In this case $m$ may be either a univariate
+            :py:class:`~.Poly` or any :py:class:`~.Expr` which represents the
+            same, while $r$ must be some :py:class:`~.Expr` representing a
+            complex number that is a root of $m$, including both explicit
+            expressions in radicals, and instances of
+            :py:class:`~.ComplexRootOf` or :py:class:`~.AlgebraicNumber`.
+
+        coeffs : list, :py:class:`~.ANP`, None, optional (default=None)
+            This defines ``rep``, giving the algebraic number $\alpha$ as a
+            polynomial in $\theta$.
+
+            If a list, the elements should be integers or rational numbers.
+            If an :py:class:`~.ANP`, we take its coefficients (using its
+            :py:meth:`~.ANP.to_list()` method). If ``None``, then the list of
+            coefficients defaults to ``[1, 0]``, meaning that $\alpha = \theta$
+            is the primitive element of the field.
+
+            If *expr* was an :py:class:`~.AlgebraicNumber`, let $g(x)$ be its
+            ``rep`` polynomial, and let $f(x)$ be the polynomial defined by
+            *coeffs*. Then ``self.rep`` will represent the composition
+            $(f \circ g)(x)$.
+
+        alias : str, :py:class:`~.Symbol`, None, optional (default=None)
+            This is a way to provide a name for the primitive element. We
+            described several ways in which the *expr* argument can define the
+            value of the primitive element, but none of these methods gave it
+            a name. Here, for example, *alias* could be set as
+            ``Symbol('theta')``, in order to make this symbol appear when
+            $\alpha$ is printed, or rendered as a polynomial, using the
+            :py:meth:`~.as_poly()` method.
+
+        Examples
+        ========
+
+        Recall that we are constructing an algebraic number as a field element
+        $\alpha \in \mathbb{Q}(\theta)$.
+
+        >>> from sympy import AlgebraicNumber, sqrt, CRootOf, S
+        >>> from sympy.abc import x
+
+        Example (1): $\alpha = \theta = \sqrt{2}$
+
+        >>> a1 = AlgebraicNumber(sqrt(2))
+        >>> a1.minpoly_of_element().as_expr(x)
+        x**2 - 2
+        >>> a1.evalf(10)
+        1.414213562
+
+        Example (2): $\alpha = 3 \sqrt{2} - 5$, $\theta = \sqrt{2}$. We can
+        either build on the last example:
+
+        >>> a2 = AlgebraicNumber(a1, [3, -5])
+        >>> a2.as_expr()
+        -5 + 3*sqrt(2)
+
+        or start from scratch:
+
+        >>> a2 = AlgebraicNumber(sqrt(2), [3, -5])
+        >>> a2.as_expr()
+        -5 + 3*sqrt(2)
+
+        Example (3): $\alpha = 6 \sqrt{2} - 11$, $\theta = \sqrt{2}$. Again we
+        can build on the previous example, and we see that the coeff polys are
+        composed:
+
+        >>> a3 = AlgebraicNumber(a2, [2, -1])
+        >>> a3.as_expr()
+        -11 + 6*sqrt(2)
+
+        reflecting the fact that $(2x - 1) \circ (3x - 5) = 6x - 11$.
+
+        Example (4): $\alpha = \sqrt{2}$, $\theta = \sqrt{2} + \sqrt{3}$. The
+        easiest way is to use the :py:func:`~.to_number_field()` function:
+
+        >>> from sympy import to_number_field
+        >>> a4 = to_number_field(sqrt(2), sqrt(2) + sqrt(3))
+        >>> a4.minpoly_of_element().as_expr(x)
+        x**2 - 2
+        >>> a4.to_root()
+        sqrt(2)
+        >>> a4.primitive_element()
+        sqrt(2) + sqrt(3)
+        >>> a4.coeffs()
+        [1/2, 0, -9/2, 0]
+
+        but if you already knew the right coefficients, you could construct it
+        directly:
+
+        >>> a4 = AlgebraicNumber(sqrt(2) + sqrt(3), [S(1)/2, 0, S(-9)/2, 0])
+        >>> a4.to_root()
+        sqrt(2)
+        >>> a4.primitive_element()
+        sqrt(2) + sqrt(3)
+
+        Example (5): Construct the Golden Ratio as an element of the 5th
+        cyclotomic field, supposing we already know its coefficients. This time
+        we introduce the alias $\zeta$ for the primitive element of the field:
+
+        >>> from sympy import cyclotomic_poly
+        >>> from sympy.abc import zeta
+        >>> a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1),
+        ...                  [-1, -1, 0, 0], alias=zeta)
+        >>> a5.as_poly().as_expr()
+        -zeta**3 - zeta**2
+        >>> a5.evalf()
+        1.61803398874989
+
+        (The index ``-1`` to ``CRootOf`` selects the complex root with the
+        largest real and imaginary parts, which in this case is
+        $\mathrm{e}^{2i\pi/5}$. See :py:class:`~.ComplexRootOf`.)
+
+        Example (6): Building on the last example, construct the number
+        $2 \phi \in \mathbb{Q}(\phi)$, where $\phi$ is the Golden Ratio:
+
+        >>> from sympy.abc import phi
+        >>> a6 = AlgebraicNumber(a5.to_root(), coeffs=[2, 0], alias=phi)
+        >>> a6.as_poly().as_expr()
+        2*phi
+        >>> a6.primitive_element().evalf()
+        1.61803398874989
+
+        Note that we needed to use ``a5.to_root()``, since passing ``a5`` as
+        the first argument would have constructed the number $2 \phi$ as an
+        element of the field $\mathbb{Q}(\zeta)$:
+
+        >>> a6_wrong = AlgebraicNumber(a5, coeffs=[2, 0])
+        >>> a6_wrong.as_poly().as_expr()
+        -2*zeta**3 - 2*zeta**2
+        >>> a6_wrong.primitive_element().evalf()
+        0.309016994374947 + 0.951056516295154*I
+
+        """
+        from sympy.polys.polyclasses import ANP, DMP
+        from sympy.polys.numberfields import minimal_polynomial
+
+        expr = sympify(expr)
+        rep0 = None
+        alias0 = None
+
+        if isinstance(expr, (tuple, Tuple)):
+            minpoly, root = expr
+
+            if not minpoly.is_Poly:
+                from sympy.polys.polytools import Poly
+                minpoly = Poly(minpoly)
+        elif expr.is_AlgebraicNumber:
+            minpoly, root, rep0, alias0 = (expr.minpoly, expr.root,
+                                           expr.rep, expr.alias)
+        else:
+            minpoly, root = minimal_polynomial(
+                expr, args.get('gen'), polys=True), expr
+
+        dom = minpoly.get_domain()
+
+        if coeffs is not None:
+            if not isinstance(coeffs, ANP):
+                rep = DMP.from_sympy_list(sympify(coeffs), 0, dom)
+                scoeffs = Tuple(*coeffs)
+            else:
+                rep = DMP.from_list(coeffs.to_list(), 0, dom)
+                scoeffs = Tuple(*coeffs.to_list())
+
+        else:
+            rep = DMP.from_list([1, 0], 0, dom)
+            scoeffs = Tuple(1, 0)
+
+        if rep0 is not None:
+            from sympy.polys.densetools import dup_compose
+            c = dup_compose(rep.to_list(), rep0.to_list(), dom)
+            rep = DMP.from_list(c, 0, dom)
+            scoeffs = Tuple(*c)
+
+        if rep.degree() >= minpoly.degree():
+            rep = rep.rem(minpoly.rep)
+
+        sargs = (root, scoeffs)
+
+        alias = alias or alias0
+        if alias is not None:
+            from .symbol import Symbol
+            if not isinstance(alias, Symbol):
+                alias = Symbol(alias)
+            sargs = sargs + (alias,)
+
+        obj = Expr.__new__(cls, *sargs)
+
+        obj.rep = rep
+        obj.root = root
+        obj.alias = alias
+        obj.minpoly = minpoly
+
+        obj._own_minpoly = None
+
+        return obj
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def _eval_evalf(self, prec):
+        return self.as_expr()._evalf(prec)
+
+    @property
+    def is_aliased(self):
+        """Returns ``True`` if ``alias`` was set. """
+        return self.alias is not None
+
+    def as_poly(self, x=None):
+        """Create a Poly instance from ``self``. """
+        from sympy.polys.polytools import Poly, PurePoly
+        if x is not None:
+            return Poly.new(self.rep, x)
+        else:
+            if self.alias is not None:
+                return Poly.new(self.rep, self.alias)
+            else:
+                from .symbol import Dummy
+                return PurePoly.new(self.rep, Dummy('x'))
+
+    def as_expr(self, x=None):
+        """Create a Basic expression from ``self``. """
+        return self.as_poly(x or self.root).as_expr().expand()
+
+    def coeffs(self):
+        """Returns all SymPy coefficients of an algebraic number. """
+        return [ self.rep.dom.to_sympy(c) for c in self.rep.all_coeffs() ]
+
+    def native_coeffs(self):
+        """Returns all native coefficients of an algebraic number. """
+        return self.rep.all_coeffs()
+
+    def to_algebraic_integer(self):
+        """Convert ``self`` to an algebraic integer. """
+        from sympy.polys.polytools import Poly
+
+        f = self.minpoly
+
+        if f.LC() == 1:
+            return self
+
+        coeff = f.LC()**(f.degree() - 1)
+        poly = f.compose(Poly(f.gen/f.LC()))
+
+        minpoly = poly*coeff
+        root = f.LC()*self.root
+
+        return AlgebraicNumber((minpoly, root), self.coeffs())
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.polys.rootoftools import CRootOf
+        from sympy.polys import minpoly
+        measure, ratio = kwargs['measure'], kwargs['ratio']
+        for r in [r for r in self.minpoly.all_roots() if r.func != CRootOf]:
+            if minpoly(self.root - r).is_Symbol:
+                # use the matching root if it's simpler
+                if measure(r) < ratio*measure(self.root):
+                    return AlgebraicNumber(r)
+        return self
+
+    def field_element(self, coeffs):
+        r"""
+        Form another element of the same number field.
+
+        Explanation
+        ===========
+
+        If we represent $\alpha \in \mathbb{Q}(\theta)$, form another element
+        $\beta \in \mathbb{Q}(\theta)$ of the same number field.
+
+        Parameters
+        ==========
+
+        coeffs : list, :py:class:`~.ANP`
+            Like the *coeffs* arg to the class
+            :py:meth:`constructor<.AlgebraicNumber.__new__>`, defines the
+            new element as a polynomial in the primitive element.
+
+            If a list, the elements should be integers or rational numbers.
+            If an :py:class:`~.ANP`, we take its coefficients (using its
+            :py:meth:`~.ANP.to_list()` method).
+
+        Examples
+        ========
+
+        >>> from sympy import AlgebraicNumber, sqrt
+        >>> a = AlgebraicNumber(sqrt(5), [-1, 1])
+        >>> b = a.field_element([3, 2])
+        >>> print(a)
+        1 - sqrt(5)
+        >>> print(b)
+        2 + 3*sqrt(5)
+        >>> print(b.primitive_element() == a.primitive_element())
+        True
+
+        See Also
+        ========
+
+        AlgebraicNumber
+        """
+        return AlgebraicNumber(
+            (self.minpoly, self.root), coeffs=coeffs, alias=self.alias)
+
+    @property
+    def is_primitive_element(self):
+        r"""
+        Say whether this algebraic number $\alpha \in \mathbb{Q}(\theta)$ is
+        equal to the primitive element $\theta$ for its field.
+        """
+        c = self.coeffs()
+        # Second case occurs if self.minpoly is linear:
+        return c == [1, 0] or c == [self.root]
+
+    def primitive_element(self):
+        r"""
+        Get the primitive element $\theta$ for the number field
+        $\mathbb{Q}(\theta)$ to which this algebraic number $\alpha$ belongs.
+
+        Returns
+        =======
+
+        AlgebraicNumber
+
+        """
+        if self.is_primitive_element:
+            return self
+        return self.field_element([1, 0])
+
+    def to_primitive_element(self, radicals=True):
+        r"""
+        Convert ``self`` to an :py:class:`~.AlgebraicNumber` instance that is
+        equal to its own primitive element.
+
+        Explanation
+        ===========
+
+        If we represent $\alpha \in \mathbb{Q}(\theta)$, $\alpha \neq \theta$,
+        construct a new :py:class:`~.AlgebraicNumber` that represents
+        $\alpha \in \mathbb{Q}(\alpha)$.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt, to_number_field
+        >>> from sympy.abc import x
+        >>> a = to_number_field(sqrt(2), sqrt(2) + sqrt(3))
+
+        The :py:class:`~.AlgebraicNumber` ``a`` represents the number
+        $\sqrt{2}$ in the field $\mathbb{Q}(\sqrt{2} + \sqrt{3})$. Rendering
+        ``a`` as a polynomial,
+
+        >>> a.as_poly().as_expr(x)
+        x**3/2 - 9*x/2
+
+        reflects the fact that $\sqrt{2} = \theta^3/2 - 9 \theta/2$, where
+        $\theta = \sqrt{2} + \sqrt{3}$.
+
+        ``a`` is not equal to its own primitive element. Its minpoly
+
+        >>> a.minpoly.as_poly().as_expr(x)
+        x**4 - 10*x**2 + 1
+
+        is that of $\theta$.
+
+        Converting to a primitive element,
+
+        >>> a_prim = a.to_primitive_element()
+        >>> a_prim.minpoly.as_poly().as_expr(x)
+        x**2 - 2
+
+        we obtain an :py:class:`~.AlgebraicNumber` whose ``minpoly`` is that of
+        the number itself.
+
+        Parameters
+        ==========
+
+        radicals : boolean, optional (default=True)
+            If ``True``, then we will try to return an
+            :py:class:`~.AlgebraicNumber` whose ``root`` is an expression
+            in radicals. If that is not possible (or if *radicals* is
+            ``False``), ``root`` will be a :py:class:`~.ComplexRootOf`.
+
+        Returns
+        =======
+
+        AlgebraicNumber
+
+        See Also
+        ========
+
+        is_primitive_element
+
+        """
+        if self.is_primitive_element:
+            return self
+        m = self.minpoly_of_element()
+        r = self.to_root(radicals=radicals)
+        return AlgebraicNumber((m, r))
+
+    def minpoly_of_element(self):
+        r"""
+        Compute the minimal polynomial for this algebraic number.
+
+        Explanation
+        ===========
+
+        Recall that we represent an element $\alpha \in \mathbb{Q}(\theta)$.
+        Our instance attribute ``self.minpoly`` is the minimal polynomial for
+        our primitive element $\theta$. This method computes the minimal
+        polynomial for $\alpha$.
+
+        """
+        if self._own_minpoly is None:
+            if self.is_primitive_element:
+                self._own_minpoly = self.minpoly
+            else:
+                from sympy.polys.numberfields.minpoly import minpoly
+                theta = self.primitive_element()
+                self._own_minpoly = minpoly(self.as_expr(theta), polys=True)
+        return self._own_minpoly
+
+    def to_root(self, radicals=True, minpoly=None):
+        """
+        Convert to an :py:class:`~.Expr` that is not an
+        :py:class:`~.AlgebraicNumber`, specifically, either a
+        :py:class:`~.ComplexRootOf`, or, optionally and where possible, an
+        expression in radicals.
+
+        Parameters
+        ==========
+
+        radicals : boolean, optional (default=True)
+            If ``True``, then we will try to return the root as an expression
+            in radicals. If that is not possible, we will return a
+            :py:class:`~.ComplexRootOf`.
+
+        minpoly : :py:class:`~.Poly`
+            If the minimal polynomial for `self` has been pre-computed, it can
+            be passed in order to save time.
+
+        """
+        if self.is_primitive_element and not isinstance(self.root, AlgebraicNumber):
+            return self.root
+        m = minpoly or self.minpoly_of_element()
+        roots = m.all_roots(radicals=radicals)
+        if len(roots) == 1:
+            return roots[0]
+        ex = self.as_expr()
+        for b in roots:
+            if m.same_root(b, ex):
+                return b
+
+
+class RationalConstant(Rational):
+    """
+    Abstract base class for rationals with specific behaviors
+
+    Derived classes must define class attributes p and q and should probably all
+    be singletons.
+    """
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+
+class IntegerConstant(Integer):
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+
+class Zero(IntegerConstant, metaclass=Singleton):
+    """The number zero.
+
+    Zero is a singleton, and can be accessed by ``S.Zero``
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> Integer(0) is S.Zero
+    True
+    >>> 1/S.Zero
+    zoo
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Zero
+    """
+
+    p = 0
+    q = 1
+    is_positive = False
+    is_negative = False
+    is_zero = True
+    is_number = True
+    is_comparable = True
+
+    __slots__ = ()
+
+    def __getnewargs__(self):
+        return ()
+
+    @staticmethod
+    def __abs__():
+        return S.Zero
+
+    @staticmethod
+    def __neg__():
+        return S.Zero
+
+    def _eval_power(self, expt):
+        if expt.is_extended_positive:
+            return self
+        if expt.is_extended_negative:
+            return S.ComplexInfinity
+        if expt.is_extended_real is False:
+            return S.NaN
+        if expt.is_zero:
+            return S.One
+
+        # infinities are already handled with pos and neg
+        # tests above; now throw away leading numbers on Mul
+        # exponent since 0**-x = zoo**x even when x == 0
+        coeff, terms = expt.as_coeff_Mul()
+        if coeff.is_negative:
+            return S.ComplexInfinity**terms
+        if coeff is not S.One:  # there is a Number to discard
+            return self**terms
+
+    def _eval_order(self, *symbols):
+        # Order(0,x) -> 0
+        return self
+
+    def __bool__(self):
+        return False
+
+
+class One(IntegerConstant, metaclass=Singleton):
+    """The number one.
+
+    One is a singleton, and can be accessed by ``S.One``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> Integer(1) is S.One
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/1_%28number%29
+    """
+    is_number = True
+    is_positive = True
+
+    p = 1
+    q = 1
+
+    __slots__ = ()
+
+    def __getnewargs__(self):
+        return ()
+
+    @staticmethod
+    def __abs__():
+        return S.One
+
+    @staticmethod
+    def __neg__():
+        return S.NegativeOne
+
+    def _eval_power(self, expt):
+        return self
+
+    def _eval_order(self, *symbols):
+        return
+
+    @staticmethod
+    def factors(limit=None, use_trial=True, use_rho=False, use_pm1=False,
+                verbose=False, visual=False):
+        if visual:
+            return S.One
+        else:
+            return {}
+
+
+class NegativeOne(IntegerConstant, metaclass=Singleton):
+    """The number negative one.
+
+    NegativeOne is a singleton, and can be accessed by ``S.NegativeOne``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> Integer(-1) is S.NegativeOne
+    True
+
+    See Also
+    ========
+
+    One
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/%E2%88%921_%28number%29
+
+    """
+    is_number = True
+
+    p = -1
+    q = 1
+
+    __slots__ = ()
+
+    def __getnewargs__(self):
+        return ()
+
+    @staticmethod
+    def __abs__():
+        return S.One
+
+    @staticmethod
+    def __neg__():
+        return S.One
+
+    def _eval_power(self, expt):
+        if expt.is_odd:
+            return S.NegativeOne
+        if expt.is_even:
+            return S.One
+        if isinstance(expt, Number):
+            if isinstance(expt, Float):
+                return Float(-1.0)**expt
+            if expt is S.NaN:
+                return S.NaN
+            if expt in (S.Infinity, S.NegativeInfinity):
+                return S.NaN
+            if expt is S.Half:
+                return S.ImaginaryUnit
+            if isinstance(expt, Rational):
+                if expt.q == 2:
+                    return S.ImaginaryUnit**Integer(expt.p)
+                i, r = divmod(expt.p, expt.q)
+                if i:
+                    return self**i*self**Rational(r, expt.q)
+        return
+
+
+class Half(RationalConstant, metaclass=Singleton):
+    """The rational number 1/2.
+
+    Half is a singleton, and can be accessed by ``S.Half``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Rational
+    >>> Rational(1, 2) is S.Half
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/One_half
+    """
+    is_number = True
+
+    p = 1
+    q = 2
+
+    __slots__ = ()
+
+    def __getnewargs__(self):
+        return ()
+
+    @staticmethod
+    def __abs__():
+        return S.Half
+
+
+class Infinity(Number, metaclass=Singleton):
+    r"""Positive infinite quantity.
+
+    Explanation
+    ===========
+
+    In real analysis the symbol `\infty` denotes an unbounded
+    limit: `x\to\infty` means that `x` grows without bound.
+
+    Infinity is often used not only to define a limit but as a value
+    in the affinely extended real number system.  Points labeled `+\infty`
+    and `-\infty` can be added to the topological space of the real numbers,
+    producing the two-point compactification of the real numbers.  Adding
+    algebraic properties to this gives us the extended real numbers.
+
+    Infinity is a singleton, and can be accessed by ``S.Infinity``,
+    or can be imported as ``oo``.
+
+    Examples
+    ========
+
+    >>> from sympy import oo, exp, limit, Symbol
+    >>> 1 + oo
+    oo
+    >>> 42/oo
+    0
+    >>> x = Symbol('x')
+    >>> limit(exp(x), x, oo)
+    oo
+
+    See Also
+    ========
+
+    NegativeInfinity, NaN
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Infinity
+    """
+
+    is_commutative = True
+    is_number = True
+    is_complex = False
+    is_extended_real = True
+    is_infinite = True
+    is_comparable = True
+    is_extended_positive = True
+    is_prime = False
+
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+    def _latex(self, printer):
+        return r"\infty"
+
+    def _eval_subs(self, old, new):
+        if self == old:
+            return new
+
+    def _eval_evalf(self, prec=None):
+        return Float('inf')
+
+    def evalf(self, prec=None, **options):
+        return self._eval_evalf(prec)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other in (S.NegativeInfinity, S.NaN):
+                return S.NaN
+            return self
+        return Number.__add__(self, other)
+    __radd__ = __add__
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other in (S.Infinity, S.NaN):
+                return S.NaN
+            return self
+        return Number.__sub__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        return (-self).__add__(other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other.is_zero or other is S.NaN:
+                return S.NaN
+            if other.is_extended_positive:
+                return self
+            return S.NegativeInfinity
+        return Number.__mul__(self, other)
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.Infinity or \
+                other is S.NegativeInfinity or \
+                    other is S.NaN:
+                return S.NaN
+            if other.is_extended_nonnegative:
+                return self
+            return S.NegativeInfinity
+        return Number.__truediv__(self, other)
+
+    def __abs__(self):
+        return S.Infinity
+
+    def __neg__(self):
+        return S.NegativeInfinity
+
+    def _eval_power(self, expt):
+        """
+        ``expt`` is symbolic object but not equal to 0 or 1.
+
+        ================ ======= ==============================
+        Expression       Result  Notes
+        ================ ======= ==============================
+        ``oo ** nan``    ``nan``
+        ``oo ** -p``     ``0``   ``p`` is number, ``oo``
+        ================ ======= ==============================
+
+        See Also
+        ========
+        Pow
+        NaN
+        NegativeInfinity
+
+        """
+        if expt.is_extended_positive:
+            return S.Infinity
+        if expt.is_extended_negative:
+            return S.Zero
+        if expt is S.NaN:
+            return S.NaN
+        if expt is S.ComplexInfinity:
+            return S.NaN
+        if expt.is_extended_real is False and expt.is_number:
+            from sympy.functions.elementary.complexes import re
+            expt_real = re(expt)
+            if expt_real.is_positive:
+                return S.ComplexInfinity
+            if expt_real.is_negative:
+                return S.Zero
+            if expt_real.is_zero:
+                return S.NaN
+
+            return self**expt.evalf()
+
+    def _as_mpf_val(self, prec):
+        return mlib.finf
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __eq__(self, other):
+        return other is S.Infinity or other == float('inf')
+
+    def __ne__(self, other):
+        return other is not S.Infinity and other != float('inf')
+
+    __gt__ = Expr.__gt__
+    __ge__ = Expr.__ge__
+    __lt__ = Expr.__lt__
+    __le__ = Expr.__le__
+
+    @_sympifyit('other', NotImplemented)
+    def __mod__(self, other):
+        if not isinstance(other, Expr):
+            return NotImplemented
+        return S.NaN
+
+    __rmod__ = __mod__
+
+    def floor(self):
+        return self
+
+    def ceiling(self):
+        return self
+
+oo = S.Infinity
+
+
+class NegativeInfinity(Number, metaclass=Singleton):
+    """Negative infinite quantity.
+
+    NegativeInfinity is a singleton, and can be accessed
+    by ``S.NegativeInfinity``.
+
+    See Also
+    ========
+
+    Infinity
+    """
+
+    is_extended_real = True
+    is_complex = False
+    is_commutative = True
+    is_infinite = True
+    is_comparable = True
+    is_extended_negative = True
+    is_number = True
+    is_prime = False
+
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+    def _latex(self, printer):
+        return r"-\infty"
+
+    def _eval_subs(self, old, new):
+        if self == old:
+            return new
+
+    def _eval_evalf(self, prec=None):
+        return Float('-inf')
+
+    def evalf(self, prec=None, **options):
+        return self._eval_evalf(prec)
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other in (S.Infinity, S.NaN):
+                return S.NaN
+            return self
+        return Number.__add__(self, other)
+    __radd__ = __add__
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other in (S.NegativeInfinity, S.NaN):
+                return S.NaN
+            return self
+        return Number.__sub__(self, other)
+
+    @_sympifyit('other', NotImplemented)
+    def __rsub__(self, other):
+        return (-self).__add__(other)
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other.is_zero or other is S.NaN:
+                return S.NaN
+            if other.is_extended_positive:
+                return self
+            return S.Infinity
+        return Number.__mul__(self, other)
+    __rmul__ = __mul__
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        if isinstance(other, Number) and global_parameters.evaluate:
+            if other is S.Infinity or \
+                other is S.NegativeInfinity or \
+                    other is S.NaN:
+                return S.NaN
+            if other.is_extended_nonnegative:
+                return self
+            return S.Infinity
+        return Number.__truediv__(self, other)
+
+    def __abs__(self):
+        return S.Infinity
+
+    def __neg__(self):
+        return S.Infinity
+
+    def _eval_power(self, expt):
+        """
+        ``expt`` is symbolic object but not equal to 0 or 1.
+
+        ================ ======= ==============================
+        Expression       Result  Notes
+        ================ ======= ==============================
+        ``(-oo) ** nan`` ``nan``
+        ``(-oo) ** oo``  ``nan``
+        ``(-oo) ** -oo`` ``nan``
+        ``(-oo) ** e``   ``oo``  ``e`` is positive even integer
+        ``(-oo) ** o``   ``-oo`` ``o`` is positive odd integer
+        ================ ======= ==============================
+
+        See Also
+        ========
+
+        Infinity
+        Pow
+        NaN
+
+        """
+        if expt.is_number:
+            if expt is S.NaN or \
+                expt is S.Infinity or \
+                    expt is S.NegativeInfinity:
+                return S.NaN
+
+            if isinstance(expt, Integer) and expt.is_extended_positive:
+                if expt.is_odd:
+                    return S.NegativeInfinity
+                else:
+                    return S.Infinity
+
+            inf_part = S.Infinity**expt
+            s_part = S.NegativeOne**expt
+            if inf_part == 0 and s_part.is_finite:
+                return inf_part
+            if (inf_part is S.ComplexInfinity and
+                    s_part.is_finite and not s_part.is_zero):
+                return S.ComplexInfinity
+            return s_part*inf_part
+
+    def _as_mpf_val(self, prec):
+        return mlib.fninf
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __eq__(self, other):
+        return other is S.NegativeInfinity or other == float('-inf')
+
+    def __ne__(self, other):
+        return other is not S.NegativeInfinity and other != float('-inf')
+
+    __gt__ = Expr.__gt__
+    __ge__ = Expr.__ge__
+    __lt__ = Expr.__lt__
+    __le__ = Expr.__le__
+
+    @_sympifyit('other', NotImplemented)
+    def __mod__(self, other):
+        if not isinstance(other, Expr):
+            return NotImplemented
+        return S.NaN
+
+    __rmod__ = __mod__
+
+    def floor(self):
+        return self
+
+    def ceiling(self):
+        return self
+
+    def as_powers_dict(self):
+        return {S.NegativeOne: 1, S.Infinity: 1}
+
+
+class NaN(Number, metaclass=Singleton):
+    """
+    Not a Number.
+
+    Explanation
+    ===========
+
+    This serves as a place holder for numeric values that are indeterminate.
+    Most operations on NaN, produce another NaN.  Most indeterminate forms,
+    such as ``0/0`` or ``oo - oo` produce NaN.  Two exceptions are ``0**0``
+    and ``oo**0``, which all produce ``1`` (this is consistent with Python's
+    float).
+
+    NaN is loosely related to floating point nan, which is defined in the
+    IEEE 754 floating point standard, and corresponds to the Python
+    ``float('nan')``.  Differences are noted below.
+
+    NaN is mathematically not equal to anything else, even NaN itself.  This
+    explains the initially counter-intuitive results with ``Eq`` and ``==`` in
+    the examples below.
+
+    NaN is not comparable so inequalities raise a TypeError.  This is in
+    contrast with floating point nan where all inequalities are false.
+
+    NaN is a singleton, and can be accessed by ``S.NaN``, or can be imported
+    as ``nan``.
+
+    Examples
+    ========
+
+    >>> from sympy import nan, S, oo, Eq
+    >>> nan is S.NaN
+    True
+    >>> oo - oo
+    nan
+    >>> nan + 1
+    nan
+    >>> Eq(nan, nan)   # mathematical equality
+    False
+    >>> nan == nan     # structural equality
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/NaN
+
+    """
+    is_commutative = True
+    is_extended_real = None
+    is_real = None
+    is_rational = None
+    is_algebraic = None
+    is_transcendental = None
+    is_integer = None
+    is_comparable = False
+    is_finite = None
+    is_zero = None
+    is_prime = None
+    is_positive = None
+    is_negative = None
+    is_number = True
+
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+    def _latex(self, printer):
+        return r"\text{NaN}"
+
+    def __neg__(self):
+        return self
+
+    @_sympifyit('other', NotImplemented)
+    def __add__(self, other):
+        return self
+
+    @_sympifyit('other', NotImplemented)
+    def __sub__(self, other):
+        return self
+
+    @_sympifyit('other', NotImplemented)
+    def __mul__(self, other):
+        return self
+
+    @_sympifyit('other', NotImplemented)
+    def __truediv__(self, other):
+        return self
+
+    def floor(self):
+        return self
+
+    def ceiling(self):
+        return self
+
+    def _as_mpf_val(self, prec):
+        return _mpf_nan
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __eq__(self, other):
+        # NaN is structurally equal to another NaN
+        return other is S.NaN
+
+    def __ne__(self, other):
+        return other is not S.NaN
+
+    # Expr will _sympify and raise TypeError
+    __gt__ = Expr.__gt__
+    __ge__ = Expr.__ge__
+    __lt__ = Expr.__lt__
+    __le__ = Expr.__le__
+
+nan = S.NaN
+
+@dispatch(NaN, Expr) # type:ignore
+def _eval_is_eq(a, b): # noqa:F811
+    return False
+
+
+class ComplexInfinity(AtomicExpr, metaclass=Singleton):
+    r"""Complex infinity.
+
+    Explanation
+    ===========
+
+    In complex analysis the symbol `\tilde\infty`, called "complex
+    infinity", represents a quantity with infinite magnitude, but
+    undetermined complex phase.
+
+    ComplexInfinity is a singleton, and can be accessed by
+    ``S.ComplexInfinity``, or can be imported as ``zoo``.
+
+    Examples
+    ========
+
+    >>> from sympy import zoo
+    >>> zoo + 42
+    zoo
+    >>> 42/zoo
+    0
+    >>> zoo + zoo
+    nan
+    >>> zoo*zoo
+    zoo
+
+    See Also
+    ========
+
+    Infinity
+    """
+
+    is_commutative = True
+    is_infinite = True
+    is_number = True
+    is_prime = False
+    is_complex = False
+    is_extended_real = False
+
+    kind = NumberKind
+
+    __slots__ = ()
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+    def _latex(self, printer):
+        return r"\tilde{\infty}"
+
+    @staticmethod
+    def __abs__():
+        return S.Infinity
+
+    def floor(self):
+        return self
+
+    def ceiling(self):
+        return self
+
+    @staticmethod
+    def __neg__():
+        return S.ComplexInfinity
+
+    def _eval_power(self, expt):
+        if expt is S.ComplexInfinity:
+            return S.NaN
+
+        if isinstance(expt, Number):
+            if expt.is_zero:
+                return S.NaN
+            else:
+                if expt.is_positive:
+                    return S.ComplexInfinity
+                else:
+                    return S.Zero
+
+
+zoo = S.ComplexInfinity
+
+
+class NumberSymbol(AtomicExpr):
+
+    is_commutative = True
+    is_finite = True
+    is_number = True
+
+    __slots__ = ()
+
+    is_NumberSymbol = True
+
+    kind = NumberKind
+
+    def __new__(cls):
+        return AtomicExpr.__new__(cls)
+
+    def approximation(self, number_cls):
+        """ Return an interval with number_cls endpoints
+        that contains the value of NumberSymbol.
+        If not implemented, then return None.
+        """
+
+    def _eval_evalf(self, prec):
+        return Float._new(self._as_mpf_val(prec), prec)
+
+    def __eq__(self, other):
+        try:
+            other = _sympify(other)
+        except SympifyError:
+            return NotImplemented
+        if self is other:
+            return True
+        if other.is_Number and self.is_irrational:
+            return False
+
+        return False    # NumberSymbol != non-(Number|self)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __le__(self, other):
+        if self is other:
+            return S.true
+        return Expr.__le__(self, other)
+
+    def __ge__(self, other):
+        if self is other:
+            return S.true
+        return Expr.__ge__(self, other)
+
+    def __int__(self):
+        # subclass with appropriate return value
+        raise NotImplementedError
+
+    def __hash__(self):
+        return super().__hash__()
+
+
+class Exp1(NumberSymbol, metaclass=Singleton):
+    r"""The `e` constant.
+
+    Explanation
+    ===========
+
+    The transcendental number `e = 2.718281828\ldots` is the base of the
+    natural logarithm and of the exponential function, `e = \exp(1)`.
+    Sometimes called Euler's number or Napier's constant.
+
+    Exp1 is a singleton, and can be accessed by ``S.Exp1``,
+    or can be imported as ``E``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, log, E
+    >>> E is exp(1)
+    True
+    >>> log(E)
+    1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/E_%28mathematical_constant%29
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False  # XXX Forces is_negative/is_nonnegative
+    is_irrational = True
+    is_number = True
+    is_algebraic = False
+    is_transcendental = True
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return r"e"
+
+    @staticmethod
+    def __abs__():
+        return S.Exp1
+
+    def __int__(self):
+        return 2
+
+    def _as_mpf_val(self, prec):
+        return mpf_e(prec)
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (Integer(2), Integer(3))
+        elif issubclass(number_cls, Rational):
+            pass
+
+    def _eval_power(self, expt):
+        if global_parameters.exp_is_pow:
+            return self._eval_power_exp_is_pow(expt)
+        else:
+            from sympy.functions.elementary.exponential import exp
+            return exp(expt)
+
+    def _eval_power_exp_is_pow(self, arg):
+        if arg.is_Number:
+            if arg is oo:
+                return oo
+            elif arg == -oo:
+                return S.Zero
+        from sympy.functions.elementary.exponential import log
+        if isinstance(arg, log):
+            return arg.args[0]
+
+        # don't autoexpand Pow or Mul (see the issue 3351):
+        elif not arg.is_Add:
+            Ioo = I*oo
+            if arg in [Ioo, -Ioo]:
+                return nan
+
+            coeff = arg.coeff(pi*I)
+            if coeff:
+                if (2*coeff).is_integer:
+                    if coeff.is_even:
+                        return S.One
+                    elif coeff.is_odd:
+                        return S.NegativeOne
+                    elif (coeff + S.Half).is_even:
+                        return -I
+                    elif (coeff + S.Half).is_odd:
+                        return I
+                elif coeff.is_Rational:
+                    ncoeff = coeff % 2 # restrict to [0, 2pi)
+                    if ncoeff > 1: # restrict to (-pi, pi]
+                        ncoeff -= 2
+                    if ncoeff != coeff:
+                        return S.Exp1**(ncoeff*S.Pi*S.ImaginaryUnit)
+
+            # Warning: code in risch.py will be very sensitive to changes
+            # in this (see DifferentialExtension).
+
+            # look for a single log factor
+
+            coeff, terms = arg.as_coeff_Mul()
+
+            # but it can't be multiplied by oo
+            if coeff in (oo, -oo):
+                return
+
+            coeffs, log_term = [coeff], None
+            for term in Mul.make_args(terms):
+                if isinstance(term, log):
+                    if log_term is None:
+                        log_term = term.args[0]
+                    else:
+                        return
+                elif term.is_comparable:
+                    coeffs.append(term)
+                else:
+                    return
+
+            return log_term**Mul(*coeffs) if log_term else None
+        elif arg.is_Add:
+            out = []
+            add = []
+            argchanged = False
+            for a in arg.args:
+                if a is S.One:
+                    add.append(a)
+                    continue
+                newa = self**a
+                if isinstance(newa, Pow) and newa.base is self:
+                    if newa.exp != a:
+                        add.append(newa.exp)
+                        argchanged = True
+                    else:
+                        add.append(a)
+                else:
+                    out.append(newa)
+            if out or argchanged:
+                return Mul(*out)*Pow(self, Add(*add), evaluate=False)
+        elif arg.is_Matrix:
+            return arg.exp()
+
+    def _eval_rewrite_as_sin(self, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin
+        return sin(I + S.Pi/2) - I*sin(I)
+
+    def _eval_rewrite_as_cos(self, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        return cos(I) + I*cos(I + S.Pi/2)
+
+E = S.Exp1
+
+
+class Pi(NumberSymbol, metaclass=Singleton):
+    r"""The `\pi` constant.
+
+    Explanation
+    ===========
+
+    The transcendental number `\pi = 3.141592654\ldots` represents the ratio
+    of a circle's circumference to its diameter, the area of the unit circle,
+    the half-period of trigonometric functions, and many other things
+    in mathematics.
+
+    Pi is a singleton, and can be accessed by ``S.Pi``, or can
+    be imported as ``pi``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, pi, oo, sin, exp, integrate, Symbol
+    >>> S.Pi
+    pi
+    >>> pi > 3
+    True
+    >>> pi.is_irrational
+    True
+    >>> x = Symbol('x')
+    >>> sin(x + 2*pi)
+    sin(x)
+    >>> integrate(exp(-x**2), (x, -oo, oo))
+    sqrt(pi)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Pi
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = True
+    is_number = True
+    is_algebraic = False
+    is_transcendental = True
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return r"\pi"
+
+    @staticmethod
+    def __abs__():
+        return S.Pi
+
+    def __int__(self):
+        return 3
+
+    def _as_mpf_val(self, prec):
+        return mpf_pi(prec)
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (Integer(3), Integer(4))
+        elif issubclass(number_cls, Rational):
+            return (Rational(223, 71, 1), Rational(22, 7, 1))
+
+pi = S.Pi
+
+
+class GoldenRatio(NumberSymbol, metaclass=Singleton):
+    r"""The golden ratio, `\phi`.
+
+    Explanation
+    ===========
+
+    `\phi = \frac{1 + \sqrt{5}}{2}` is an algebraic number.  Two quantities
+    are in the golden ratio if their ratio is the same as the ratio of
+    their sum to the larger of the two quantities, i.e. their maximum.
+
+    GoldenRatio is a singleton, and can be accessed by ``S.GoldenRatio``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> S.GoldenRatio > 1
+    True
+    >>> S.GoldenRatio.expand(func=True)
+    1/2 + sqrt(5)/2
+    >>> S.GoldenRatio.is_irrational
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Golden_ratio
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = True
+    is_number = True
+    is_algebraic = True
+    is_transcendental = False
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return r"\phi"
+
+    def __int__(self):
+        return 1
+
+    def _as_mpf_val(self, prec):
+         # XXX track down why this has to be increased
+        rv = mlib.from_man_exp(phi_fixed(prec + 10), -prec - 10)
+        return mpf_norm(rv, prec)
+
+    def _eval_expand_func(self, **hints):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        return S.Half + S.Half*sqrt(5)
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (S.One, Rational(2))
+        elif issubclass(number_cls, Rational):
+            pass
+
+    _eval_rewrite_as_sqrt = _eval_expand_func
+
+
+class TribonacciConstant(NumberSymbol, metaclass=Singleton):
+    r"""The tribonacci constant.
+
+    Explanation
+    ===========
+
+    The tribonacci numbers are like the Fibonacci numbers, but instead
+    of starting with two predetermined terms, the sequence starts with
+    three predetermined terms and each term afterwards is the sum of the
+    preceding three terms.
+
+    The tribonacci constant is the ratio toward which adjacent tribonacci
+    numbers tend. It is a root of the polynomial `x^3 - x^2 - x - 1 = 0`,
+    and also satisfies the equation `x + x^{-3} = 2`.
+
+    TribonacciConstant is a singleton, and can be accessed
+    by ``S.TribonacciConstant``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> S.TribonacciConstant > 1
+    True
+    >>> S.TribonacciConstant.expand(func=True)
+    1/3 + (19 - 3*sqrt(33))**(1/3)/3 + (3*sqrt(33) + 19)**(1/3)/3
+    >>> S.TribonacciConstant.is_irrational
+    True
+    >>> S.TribonacciConstant.n(20)
+    1.8392867552141611326
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = True
+    is_number = True
+    is_algebraic = True
+    is_transcendental = False
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return r"\text{TribonacciConstant}"
+
+    def __int__(self):
+        return 1
+
+    def _as_mpf_val(self, prec):
+        return self._eval_evalf(prec)._mpf_
+
+    def _eval_evalf(self, prec):
+        rv = self._eval_expand_func(function=True)._eval_evalf(prec + 4)
+        return Float(rv, precision=prec)
+
+    def _eval_expand_func(self, **hints):
+        from sympy.functions.elementary.miscellaneous import cbrt, sqrt
+        return (1 + cbrt(19 - 3*sqrt(33)) + cbrt(19 + 3*sqrt(33))) / 3
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (S.One, Rational(2))
+        elif issubclass(number_cls, Rational):
+            pass
+
+    _eval_rewrite_as_sqrt = _eval_expand_func
+
+
+class EulerGamma(NumberSymbol, metaclass=Singleton):
+    r"""The Euler-Mascheroni constant.
+
+    Explanation
+    ===========
+
+    `\gamma = 0.5772157\ldots` (also called Euler's constant) is a mathematical
+    constant recurring in analysis and number theory.  It is defined as the
+    limiting difference between the harmonic series and the
+    natural logarithm:
+
+    .. math:: \gamma = \lim\limits_{n\to\infty}
+              \left(\sum\limits_{k=1}^n\frac{1}{k} - \ln n\right)
+
+    EulerGamma is a singleton, and can be accessed by ``S.EulerGamma``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> S.EulerGamma.is_irrational
+    >>> S.EulerGamma > 0
+    True
+    >>> S.EulerGamma > 1
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%E2%80%93Mascheroni_constant
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = None
+    is_number = True
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return r"\gamma"
+
+    def __int__(self):
+        return 0
+
+    def _as_mpf_val(self, prec):
+         # XXX track down why this has to be increased
+        v = mlib.libhyper.euler_fixed(prec + 10)
+        rv = mlib.from_man_exp(v, -prec - 10)
+        return mpf_norm(rv, prec)
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (S.Zero, S.One)
+        elif issubclass(number_cls, Rational):
+            return (S.Half, Rational(3, 5, 1))
+
+
+class Catalan(NumberSymbol, metaclass=Singleton):
+    r"""Catalan's constant.
+
+    Explanation
+    ===========
+
+    $G = 0.91596559\ldots$ is given by the infinite series
+
+    .. math:: G = \sum_{k=0}^{\infty} \frac{(-1)^k}{(2k+1)^2}
+
+    Catalan is a singleton, and can be accessed by ``S.Catalan``.
+
+    Examples
+    ========
+
+    >>> from sympy import S
+    >>> S.Catalan.is_irrational
+    >>> S.Catalan > 0
+    True
+    >>> S.Catalan > 1
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Catalan%27s_constant
+    """
+
+    is_real = True
+    is_positive = True
+    is_negative = False
+    is_irrational = None
+    is_number = True
+
+    __slots__ = ()
+
+    def __int__(self):
+        return 0
+
+    def _as_mpf_val(self, prec):
+        # XXX track down why this has to be increased
+        v = mlib.catalan_fixed(prec + 10)
+        rv = mlib.from_man_exp(v, -prec - 10)
+        return mpf_norm(rv, prec)
+
+    def approximation_interval(self, number_cls):
+        if issubclass(number_cls, Integer):
+            return (S.Zero, S.One)
+        elif issubclass(number_cls, Rational):
+            return (Rational(9, 10, 1), S.One)
+
+    def _eval_rewrite_as_Sum(self, k_sym=None, symbols=None, **hints):
+        if (k_sym is not None) or (symbols is not None):
+            return self
+        from .symbol import Dummy
+        from sympy.concrete.summations import Sum
+        k = Dummy('k', integer=True, nonnegative=True)
+        return Sum(S.NegativeOne**k / (2*k+1)**2, (k, 0, S.Infinity))
+
+    def _latex(self, printer):
+        return "G"
+
+
+class ImaginaryUnit(AtomicExpr, metaclass=Singleton):
+    r"""The imaginary unit, `i = \sqrt{-1}`.
+
+    I is a singleton, and can be accessed by ``S.I``, or can be
+    imported as ``I``.
+
+    Examples
+    ========
+
+    >>> from sympy import I, sqrt
+    >>> sqrt(-1)
+    I
+    >>> I*I
+    -1
+    >>> 1/I
+    -I
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Imaginary_unit
+    """
+
+    is_commutative = True
+    is_imaginary = True
+    is_finite = True
+    is_number = True
+    is_algebraic = True
+    is_transcendental = False
+
+    kind = NumberKind
+
+    __slots__ = ()
+
+    def _latex(self, printer):
+        return printer._settings['imaginary_unit_latex']
+
+    @staticmethod
+    def __abs__():
+        return S.One
+
+    def _eval_evalf(self, prec):
+        return self
+
+    def _eval_conjugate(self):
+        return -S.ImaginaryUnit
+
+    def _eval_power(self, expt):
+        """
+        b is I = sqrt(-1)
+        e is symbolic object but not equal to 0, 1
+
+        I**r -> (-1)**(r/2) -> exp(r/2*Pi*I) -> sin(Pi*r/2) + cos(Pi*r/2)*I, r is decimal
+        I**0 mod 4 -> 1
+        I**1 mod 4 -> I
+        I**2 mod 4 -> -1
+        I**3 mod 4 -> -I
+        """
+
+        if isinstance(expt, Integer):
+            expt = expt % 4
+            if expt == 0:
+                return S.One
+            elif expt == 1:
+                return S.ImaginaryUnit
+            elif expt == 2:
+                return S.NegativeOne
+            elif expt == 3:
+                return -S.ImaginaryUnit
+        if isinstance(expt, Rational):
+            i, r = divmod(expt, 2)
+            rv = Pow(S.ImaginaryUnit, r, evaluate=False)
+            if i % 2:
+                return Mul(S.NegativeOne, rv, evaluate=False)
+            return rv
+
+    def as_base_exp(self):
+        return S.NegativeOne, S.Half
+
+    @property
+    def _mpc_(self):
+        return (Float(0)._mpf_, Float(1)._mpf_)
+
+
+I = S.ImaginaryUnit
+
+
+def int_valued(x):
+    """return True only for a literal Number whose internal
+    representation as a fraction has a denominator of 1,
+    else False, i.e. integer, with no fractional part.
+    """
+    if isinstance(x, (SYMPY_INTS, int)):
+        return True
+    if type(x) is float:
+        return x.is_integer()
+    if isinstance(x, Integer):
+        return True
+    if isinstance(x, Float):
+        # x = s*m*2**p; _mpf_ = s,m,e,p
+        return x._mpf_[2] >= 0
+    return False  # or add new types to recognize
+
+
+def equal_valued(x, y):
+    """Compare expressions treating plain floats as rationals.
+
+    Examples
+    ========
+
+    >>> from sympy import S, symbols, Rational, Float
+    >>> from sympy.core.numbers import equal_valued
+    >>> equal_valued(1, 2)
+    False
+    >>> equal_valued(1, 1)
+    True
+
+    In SymPy expressions with Floats compare unequal to corresponding
+    expressions with rationals:
+
+    >>> x = symbols('x')
+    >>> x**2 == x**2.0
+    False
+
+    However an individual Float compares equal to a Rational:
+
+    >>> Rational(1, 2) == Float(0.5)
+    False
+
+    In a future version of SymPy this might change so that Rational and Float
+    compare unequal. This function provides the behavior currently expected of
+    ``==`` so that it could still be used if the behavior of ``==`` were to
+    change in future.
+
+    >>> equal_valued(1, 1.0) # Float vs Rational
+    True
+    >>> equal_valued(S(1).n(3), S(1).n(5)) # Floats of different precision
+    True
+
+    Explanation
+    ===========
+
+    In future SymPy versions Float and Rational might compare unequal and floats
+    with different precisions might compare unequal. In that context a function
+    is needed that can check if a number is equal to 1 or 0 etc. The idea is
+    that instead of testing ``if x == 1:`` if we want to accept floats like
+    ``1.0`` as well then the test can be written as ``if equal_valued(x, 1):``
+    or ``if equal_valued(x, 2):``. Since this function is intended to be used
+    in situations where one or both operands are expected to be concrete
+    numbers like 1 or 0 the function does not recurse through the args of any
+    compound expression to compare any nested floats.
+
+    References
+    ==========
+
+    .. [1] https://github.com/sympy/sympy/pull/20033
+    """
+    x = _sympify(x)
+    y = _sympify(y)
+
+    # Handle everything except Float/Rational first
+    if not x.is_Float and not y.is_Float:
+        return x == y
+    elif x.is_Float and y.is_Float:
+        # Compare values without regard for precision
+        return x._mpf_ == y._mpf_
+    elif x.is_Float:
+        x, y = y, x
+    if not x.is_Rational:
+        return False
+
+    # Now y is Float and x is Rational. A simple approach at this point would
+    # just be x == Rational(y) but if y has a large exponent creating a
+    # Rational could be prohibitively expensive.
+
+    sign, man, exp, _ = y._mpf_
+    p, q = x.p, x.q
+
+    if sign:
+        man = -man
+
+    if exp == 0:
+        # y odd integer
+        return q == 1 and man == p
+    elif exp > 0:
+        # y even integer
+        if q != 1:
+            return False
+        if p.bit_length() != man.bit_length() + exp:
+            return False
+        return man << exp == p
+    else:
+        # y non-integer. Need p == man and q == 2**-exp
+        if p != man:
+            return False
+        neg_exp = -exp
+        if q.bit_length() - 1 != neg_exp:
+            return False
+        return (1 << neg_exp) == q
+
+
+def all_close(expr1, expr2, rtol=1e-5, atol=1e-8):
+    """Return True if expr1 and expr2 are numerically close.
+
+    The expressions must have the same structure, but any Rational, Integer, or
+    Float numbers they contain are compared approximately using rtol and atol.
+    Any other parts of expressions are compared exactly. However, allowance is
+    made to allow for the additive and multiplicative identities.
+
+    Relative tolerance is measured with respect to expr2 so when used in
+    testing expr2 should be the expected correct answer.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.abc import x, y
+    >>> from sympy.core.numbers import all_close
+    >>> expr1 = 0.1*exp(x - y)
+    >>> expr2 = exp(x - y)/10
+    >>> expr1
+    0.1*exp(x - y)
+    >>> expr2
+    exp(x - y)/10
+    >>> expr1 == expr2
+    False
+    >>> all_close(expr1, expr2)
+    True
+
+    Identities are automatically supplied:
+
+    >>> all_close(x, x + 1e-10)
+    True
+    >>> all_close(x, 1.0*x)
+    True
+    >>> all_close(x, 1.0*x + 1e-10)
+    True
+
+    """
+    NUM_TYPES = (Rational, Float)
+
+    def _all_close(obj1, obj2):
+        if type(obj1) == type(obj2) and isinstance(obj1, (list, tuple)):
+            if len(obj1) != len(obj2):
+                return False
+            return all(_all_close(e1, e2) for e1, e2 in zip(obj1, obj2))
+        else:
+            return _all_close_expr(_sympify(obj1), _sympify(obj2))
+
+    def _all_close_expr(expr1, expr2):
+        num1 = isinstance(expr1, NUM_TYPES)
+        num2 = isinstance(expr2, NUM_TYPES)
+        if num1 != num2:
+            return False
+        elif num1:
+            return _close_num(expr1, expr2)
+        if expr1.is_Add or expr1.is_Mul or expr2.is_Add or expr2.is_Mul:
+            return _all_close_ac(expr1, expr2)
+        if expr1.func != expr2.func or len(expr1.args) != len(expr2.args):
+            return False
+        args = zip(expr1.args, expr2.args)
+        return all(_all_close_expr(a1, a2) for a1, a2 in args)
+
+    def _close_num(num1, num2):
+        return bool(abs(num1 - num2) <= atol + rtol*abs(num2))
+
+    def _all_close_ac(expr1, expr2):
+        # compare expressions with associative commutative operators for
+        # approximate equality by seeing that all terms have equivalent
+        # coefficients (which are always Rational or Float)
+        if expr1.is_Mul or expr2.is_Mul:
+            # as_coeff_mul automatically will supply coeff of 1
+            c1, e1 = expr1.as_coeff_mul(rational=False)
+            c2, e2 = expr2.as_coeff_mul(rational=False)
+            if not _close_num(c1, c2):
+                return False
+            s1 = set(e1)
+            s2 = set(e2)
+            common = s1 & s2
+            s1 -= common
+            s2 -= common
+            if not s1:
+                return True
+            if not any(i.has(Float) for j in (s1, s2) for i in j):
+                return False
+            # factors might not be matching, e.g.
+            # x != x**1.0, exp(x) != exp(1.0*x), etc...
+            s1 = [i.as_base_exp() for i in ordered(s1)]
+            s2 = [i.as_base_exp() for i in ordered(s2)]
+            unmatched = list(range(len(s1)))
+            for be1 in s1:
+                for i in unmatched:
+                    be2 = s2[i]
+                    if _all_close(be1, be2):
+                        unmatched.remove(i)
+                        break
+                else:
+                    return False
+            return not(unmatched)
+        assert expr1.is_Add or expr2.is_Add
+        cd1 = expr1.as_coefficients_dict()
+        cd2 = expr2.as_coefficients_dict()
+        # this test will assure that the key of 1 is in
+        # each dict and that they have equal values
+        if not _close_num(cd1[1], cd2[1]):
+            return False
+        if len(cd1) != len(cd2):
+            return False
+        for k in list(cd1):
+            if k in cd2:
+                if not _close_num(cd1.pop(k), cd2.pop(k)):
+                    return False
+            # k (or a close version in cd2) might have
+            # Floats in a factor of the term which will
+            # be handled below
+        else:
+            if not cd1:
+                return True
+        for k1 in cd1:
+            for k2 in cd2:
+                if _all_close_expr(k1, k2):
+                    # found a matching key
+                    # XXX there could be a corner case where
+                    # more than 1 might match and the numbers are
+                    # such that one is better than the other
+                    # that is not being considered here
+                    if not _close_num(cd1[k1], cd2[k2]):
+                        return False
+                    break
+            else:
+                # no key matched
+                return False
+        return True
+
+    return _all_close(expr1, expr2)
+
+
+@dispatch(Tuple, Number) # type:ignore
+def _eval_is_eq(self, other): # noqa: F811
+    return False
+
+
+def sympify_fractions(f):
+    return Rational._new(f.numerator, f.denominator, 1)
+
+_sympy_converter[fractions.Fraction] = sympify_fractions
+
+
+if gmpy is not None:
+
+    def sympify_mpz(x):
+        return Integer(int(x))
+
+    def sympify_mpq(x):
+        return Rational(int(x.numerator), int(x.denominator))
+
+    _sympy_converter[type(gmpy.mpz(1))] = sympify_mpz
+    _sympy_converter[type(gmpy.mpq(1, 2))] = sympify_mpq
+
+
+if flint is not None:
+
+    def sympify_fmpz(x):
+        return Integer(int(x))
+
+    def sympify_fmpq(x):
+        return Rational(int(x.numerator), int(x.denominator))
+
+    _sympy_converter[type(flint.fmpz(1))] = sympify_fmpz
+    _sympy_converter[type(flint.fmpq(1, 2))] = sympify_fmpq
+
+
+def sympify_mpmath(x):
+    return Expr._from_mpmath(x, x.context.prec)
+
+_sympy_converter[mpnumeric] = sympify_mpmath
+
+
+def sympify_complex(a):
+    real, imag = list(map(sympify, (a.real, a.imag)))
+    return real + S.ImaginaryUnit*imag
+
+_sympy_converter[complex] = sympify_complex
+
+from .power import Pow
+from .mul import Mul
+Mul.identity = One()
+from .add import Add
+Add.identity = Zero()
+
+
+def _register_classes():
+    numbers.Number.register(Number)
+    numbers.Real.register(Float)
+    numbers.Rational.register(Rational)
+    numbers.Integral.register(Integer)
+
+_register_classes()
+
+_illegal = (S.NaN, S.Infinity, S.NegativeInfinity, S.ComplexInfinity)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/operations.py b/.venv/lib/python3.12/site-packages/sympy/core/operations.py
new file mode 100644
index 0000000000000000000000000000000000000000..70d22127eb4d3f69fc5e304ab38f5cce9c4bb551
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/operations.py
@@ -0,0 +1,741 @@
+from __future__ import annotations
+
+from typing import overload, TYPE_CHECKING
+
+from operator import attrgetter
+from collections import defaultdict
+
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+from .sympify import _sympify as _sympify_, sympify
+from .basic import Basic
+from .cache import cacheit
+from .sorting import ordered
+from .logic import fuzzy_and
+from .parameters import global_parameters
+from sympy.utilities.iterables import sift
+from sympy.multipledispatch.dispatcher import (Dispatcher,
+    ambiguity_register_error_ignore_dup,
+    str_signature, RaiseNotImplementedError)
+
+
+if TYPE_CHECKING:
+    from sympy.core.expr import Expr
+    from sympy.core.add import Add
+    from sympy.core.mul import Mul
+    from sympy.logic.boolalg import Boolean, And, Or
+
+
+class AssocOp(Basic):
+    """ Associative operations, can separate noncommutative and
+    commutative parts.
+
+    (a op b) op c == a op (b op c) == a op b op c.
+
+    Base class for Add and Mul.
+
+    This is an abstract base class, concrete derived classes must define
+    the attribute `identity`.
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Parameters
+    ==========
+
+    *args :
+        Arguments which are operated
+
+    evaluate : bool, optional
+        Evaluate the operation. If not passed, refer to ``global_parameters.evaluate``.
+    """
+
+    # for performance reason, we don't let is_commutative go to assumptions,
+    # and keep it right here
+    __slots__: tuple[str, ...] = ('is_commutative',)
+
+    _args_type: type[Basic] | None = None
+
+    @cacheit
+    def __new__(cls, *args, evaluate=None, _sympify=True):
+        # Allow faster processing by passing ``_sympify=False``, if all arguments
+        # are already sympified.
+        if _sympify:
+            args = list(map(_sympify_, args))
+
+        # Disallow non-Expr args in Add/Mul
+        typ = cls._args_type
+        if typ is not None:
+            from .relational import Relational
+            if any(isinstance(arg, Relational) for arg in args):
+                raise TypeError("Relational cannot be used in %s" % cls.__name__)
+
+            # This should raise TypeError once deprecation period is over:
+            for arg in args:
+                if not isinstance(arg, typ):
+                    sympy_deprecation_warning(
+                        f"""
+
+Using non-Expr arguments in {cls.__name__} is deprecated (in this case, one of
+the arguments has type {type(arg).__name__!r}).
+
+If you really did intend to use a multiplication or addition operation with
+this object, use the * or + operator instead.
+
+                        """,
+                        deprecated_since_version="1.7",
+                        active_deprecations_target="non-expr-args-deprecated",
+                        stacklevel=4,
+                    )
+
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+        if not evaluate:
+            obj = cls._from_args(args)
+            obj = cls._exec_constructor_postprocessors(obj)
+            return obj
+
+        args = [a for a in args if a is not cls.identity]
+
+        if len(args) == 0:
+            return cls.identity
+        if len(args) == 1:
+            return args[0]
+
+        c_part, nc_part, order_symbols = cls.flatten(args)
+        is_commutative = not nc_part
+        obj = cls._from_args(c_part + nc_part, is_commutative)
+        obj = cls._exec_constructor_postprocessors(obj)
+
+        if order_symbols is not None:
+            from sympy.series.order import Order
+            return Order(obj, *order_symbols)
+        return obj
+
+    @classmethod
+    def _from_args(cls, args, is_commutative=None):
+        """Create new instance with already-processed args.
+        If the args are not in canonical order, then a non-canonical
+        result will be returned, so use with caution. The order of
+        args may change if the sign of the args is changed."""
+        if len(args) == 0:
+            return cls.identity
+        elif len(args) == 1:
+            return args[0]
+
+        obj = super().__new__(cls, *args)
+        if is_commutative is None:
+            is_commutative = fuzzy_and(a.is_commutative for a in args)
+        obj.is_commutative = is_commutative
+        return obj
+
+    def _new_rawargs(self, *args, reeval=True, **kwargs):
+        """Create new instance of own class with args exactly as provided by
+        caller but returning the self class identity if args is empty.
+
+        Examples
+        ========
+
+           This is handy when we want to optimize things, e.g.
+
+               >>> from sympy import Mul, S
+               >>> from sympy.abc import x, y
+               >>> e = Mul(3, x, y)
+               >>> e.args
+               (3, x, y)
+               >>> Mul(*e.args[1:])
+               x*y
+               >>> e._new_rawargs(*e.args[1:])  # the same as above, but faster
+               x*y
+
+           Note: use this with caution. There is no checking of arguments at
+           all. This is best used when you are rebuilding an Add or Mul after
+           simply removing one or more args. If, for example, modifications,
+           result in extra 1s being inserted they will show up in the result:
+
+               >>> m = (x*y)._new_rawargs(S.One, x); m
+               1*x
+               >>> m == x
+               False
+               >>> m.is_Mul
+               True
+
+           Another issue to be aware of is that the commutativity of the result
+           is based on the commutativity of self. If you are rebuilding the
+           terms that came from a commutative object then there will be no
+           problem, but if self was non-commutative then what you are
+           rebuilding may now be commutative.
+
+           Although this routine tries to do as little as possible with the
+           input, getting the commutativity right is important, so this level
+           of safety is enforced: commutativity will always be recomputed if
+           self is non-commutative and kwarg `reeval=False` has not been
+           passed.
+        """
+        if reeval and self.is_commutative is False:
+            is_commutative = None
+        else:
+            is_commutative = self.is_commutative
+        return self._from_args(args, is_commutative)
+
+    @classmethod
+    def flatten(cls, seq):
+        """Return seq so that none of the elements are of type `cls`. This is
+        the vanilla routine that will be used if a class derived from AssocOp
+        does not define its own flatten routine."""
+        # apply associativity, no commutativity property is used
+        new_seq = []
+        while seq:
+            o = seq.pop()
+            if o.__class__ is cls:  # classes must match exactly
+                seq.extend(o.args)
+            else:
+                new_seq.append(o)
+        new_seq.reverse()
+
+        # c_part, nc_part, order_symbols
+        return [], new_seq, None
+
+    def _matches_commutative(self, expr, repl_dict=None, old=False):
+        """
+        Matches Add/Mul "pattern" to an expression "expr".
+
+        repl_dict ... a dictionary of (wild: expression) pairs, that get
+                      returned with the results
+
+        This function is the main workhorse for Add/Mul.
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Wild, sin
+        >>> a = Wild("a")
+        >>> b = Wild("b")
+        >>> c = Wild("c")
+        >>> x, y, z = symbols("x y z")
+        >>> (a+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {a_: x, b_: y, c_: z}
+
+        In the example above, "a+sin(b)*c" is the pattern, and "x+sin(y)*z" is
+        the expression.
+
+        The repl_dict contains parts that were already matched. For example
+        here:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z, repl_dict={a: x})
+        {a_: x, b_: y, c_: z}
+
+        the only function of the repl_dict is to return it in the
+        result, e.g. if you omit it:
+
+        >>> (x+sin(b)*c)._matches_commutative(x+sin(y)*z)
+        {b_: y, c_: z}
+
+        the "a: x" is not returned in the result, but otherwise it is
+        equivalent.
+
+        """
+        from .function import _coeff_isneg
+        # make sure expr is Expr if pattern is Expr
+        from .expr import Expr
+        if isinstance(self, Expr) and not isinstance(expr, Expr):
+            return None
+
+        if repl_dict is None:
+            repl_dict = {}
+
+        # handle simple patterns
+        if self == expr:
+            return repl_dict
+
+        d = self._matches_simple(expr, repl_dict)
+        if d is not None:
+            return d
+
+        # eliminate exact part from pattern: (2+a+w1+w2).matches(expr) -> (w1+w2).matches(expr-a-2)
+        from .function import WildFunction
+        from .symbol import Wild
+        wild_part, exact_part = sift(self.args, lambda p:
+            p.has(Wild, WildFunction) and not expr.has(p),
+            binary=True)
+        if not exact_part:
+            wild_part = list(ordered(wild_part))
+            if self.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                wild_part = sorted(wild_part, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0)
+        else:
+            exact = self._new_rawargs(*exact_part)
+            free = expr.free_symbols
+            if free and (exact.free_symbols - free):
+                # there are symbols in the exact part that are not
+                # in the expr; but if there are no free symbols, let
+                # the matching continue
+                return None
+            newexpr = self._combine_inverse(expr, exact)
+            if not old and (expr.is_Add or expr.is_Mul):
+                check = newexpr
+                if _coeff_isneg(check):
+                    check = -check
+                if check.count_ops() > expr.count_ops():
+                    return None
+            newpattern = self._new_rawargs(*wild_part)
+            return newpattern.matches(newexpr, repl_dict)
+
+        # now to real work ;)
+        i = 0
+        saw = set()
+        while expr not in saw:
+            saw.add(expr)
+            args = tuple(ordered(self.make_args(expr)))
+            if self.is_Add and expr.is_Add:
+                # in addition to normal ordered keys, impose
+                # sorting on Muls with leading Number to put
+                # them in order
+                args = tuple(sorted(args, key=lambda x:
+                    x.args[0] if x.is_Mul and x.args[0].is_Number else
+                    0))
+            expr_list = (self.identity,) + args
+            for last_op in reversed(expr_list):
+                for w in reversed(wild_part):
+                    d1 = w.matches(last_op, repl_dict)
+                    if d1 is not None:
+                        d2 = self.xreplace(d1).matches(expr, d1)
+                        if d2 is not None:
+                            return d2
+
+            if i == 0:
+                if self.is_Mul:
+                    # make e**i look like Mul
+                    if expr.is_Pow and expr.exp.is_Integer:
+                        from .mul import Mul
+                        if expr.exp > 0:
+                            expr = Mul(*[expr.base, expr.base**(expr.exp - 1)], evaluate=False)
+                        else:
+                            expr = Mul(*[1/expr.base, expr.base**(expr.exp + 1)], evaluate=False)
+                        i += 1
+                        continue
+
+                elif self.is_Add:
+                    # make i*e look like Add
+                    c, e = expr.as_coeff_Mul()
+                    if abs(c) > 1:
+                        from .add import Add
+                        if c > 0:
+                            expr = Add(*[e, (c - 1)*e], evaluate=False)
+                        else:
+                            expr = Add(*[-e, (c + 1)*e], evaluate=False)
+                        i += 1
+                        continue
+
+                    # try collection on non-Wild symbols
+                    from sympy.simplify.radsimp import collect
+                    was = expr
+                    did = set()
+                    for w in reversed(wild_part):
+                        c, w = w.as_coeff_mul(Wild)
+                        free = c.free_symbols - did
+                        if free:
+                            did.update(free)
+                            expr = collect(expr, free)
+                    if expr != was:
+                        i += 0
+                        continue
+
+                break  # if we didn't continue, there is nothing more to do
+
+        return
+
+    def _has_matcher(self):
+        """Helper for .has() that checks for containment of
+        subexpressions within an expr by using sets of args
+        of similar nodes, e.g. x + 1 in x + y + 1 checks
+        to see that {x, 1} & {x, y, 1} == {x, 1}
+        """
+        def _ncsplit(expr):
+            # this is not the same as args_cnc because here
+            # we don't assume expr is a Mul -- hence deal with args --
+            # and always return a set.
+            cpart, ncpart = sift(expr.args,
+                lambda arg: arg.is_commutative is True, binary=True)
+            return set(cpart), ncpart
+
+        c, nc = _ncsplit(self)
+        cls = self.__class__
+
+        def is_in(expr):
+            if isinstance(expr, cls):
+                if expr == self:
+                    return True
+                _c, _nc = _ncsplit(expr)
+                if (c & _c) == c:
+                    if not nc:
+                        return True
+                    elif len(nc) <= len(_nc):
+                        for i in range(len(_nc) - len(nc) + 1):
+                            if _nc[i:i + len(nc)] == nc:
+                                return True
+            return False
+        return is_in
+
+    def _eval_evalf(self, prec):
+        """
+        Evaluate the parts of self that are numbers; if the whole thing
+        was a number with no functions it would have been evaluated, but
+        it wasn't so we must judiciously extract the numbers and reconstruct
+        the object. This is *not* simply replacing numbers with evaluated
+        numbers. Numbers should be handled in the largest pure-number
+        expression as possible. So the code below separates ``self`` into
+        number and non-number parts and evaluates the number parts and
+        walks the args of the non-number part recursively (doing the same
+        thing).
+        """
+        from .add import Add
+        from .mul import Mul
+        from .symbol import Symbol
+        from .function import AppliedUndef
+        if isinstance(self, (Mul, Add)):
+            x, tail = self.as_independent(Symbol, AppliedUndef)
+            # if x is an AssocOp Function then the _evalf below will
+            # call _eval_evalf (here) so we must break the recursion
+            if not (tail is self.identity or
+                    isinstance(x, AssocOp) and x.is_Function or
+                    x is self.identity and isinstance(tail, AssocOp)):
+                # here, we have a number so we just call to _evalf with prec;
+                # prec is not the same as n, it is the binary precision so
+                # that's why we don't call to evalf.
+                x = x._evalf(prec) if x is not self.identity else self.identity
+                args = []
+                tail_args = tuple(self.func.make_args(tail))
+                for a in tail_args:
+                    # here we call to _eval_evalf since we don't know what we
+                    # are dealing with and all other _eval_evalf routines should
+                    # be doing the same thing (i.e. taking binary prec and
+                    # finding the evalf-able args)
+                    newa = a._eval_evalf(prec)
+                    if newa is None:
+                        args.append(a)
+                    else:
+                        args.append(newa)
+                return self.func(x, *args)
+
+        # this is the same as above, but there were no pure-number args to
+        # deal with
+        args = []
+        for a in self.args:
+            newa = a._eval_evalf(prec)
+            if newa is None:
+                args.append(a)
+            else:
+                args.append(newa)
+        return self.func(*args)
+
+    @overload
+    @classmethod
+    def make_args(cls: type[Add], expr: Expr) -> tuple[Expr, ...]: ... # type: ignore
+    @overload
+    @classmethod
+    def make_args(cls: type[Mul], expr: Expr) -> tuple[Expr, ...]: ... # type: ignore
+    @overload
+    @classmethod
+    def make_args(cls: type[And], expr: Boolean) -> tuple[Boolean, ...]: ... # type: ignore
+    @overload
+    @classmethod
+    def make_args(cls: type[Or], expr: Boolean) -> tuple[Boolean, ...]: ... # type: ignore
+
+    @classmethod
+    def make_args(cls: type[Basic], expr: Basic) -> tuple[Basic, ...]:
+        """
+        Return a sequence of elements `args` such that cls(*args) == expr
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Mul, Add
+        >>> x, y = map(Symbol, 'xy')
+
+        >>> Mul.make_args(x*y)
+        (x, y)
+        >>> Add.make_args(x*y)
+        (x*y,)
+        >>> set(Add.make_args(x*y + y)) == set([y, x*y])
+        True
+
+        """
+        if isinstance(expr, cls):
+            return expr.args
+        else:
+            return (sympify(expr),)
+
+    def doit(self, **hints):
+        if hints.get('deep', True):
+            terms = [term.doit(**hints) for term in self.args]
+        else:
+            terms = self.args
+        return self.func(*terms, evaluate=True)
+
+class ShortCircuit(Exception):
+    pass
+
+
+class LatticeOp(AssocOp):
+    """
+    Join/meet operations of an algebraic lattice[1].
+
+    Explanation
+    ===========
+
+    These binary operations are associative (op(op(a, b), c) = op(a, op(b, c))),
+    commutative (op(a, b) = op(b, a)) and idempotent (op(a, a) = op(a) = a).
+    Common examples are AND, OR, Union, Intersection, max or min. They have an
+    identity element (op(identity, a) = a) and an absorbing element
+    conventionally called zero (op(zero, a) = zero).
+
+    This is an abstract base class, concrete derived classes must declare
+    attributes zero and identity. All defining properties are then respected.
+
+    Examples
+    ========
+
+    >>> from sympy import Integer
+    >>> from sympy.core.operations import LatticeOp
+    >>> class my_join(LatticeOp):
+    ...     zero = Integer(0)
+    ...     identity = Integer(1)
+    >>> my_join(2, 3) == my_join(3, 2)
+    True
+    >>> my_join(2, my_join(3, 4)) == my_join(2, 3, 4)
+    True
+    >>> my_join(0, 1, 4, 2, 3, 4)
+    0
+    >>> my_join(1, 2)
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lattice_%28order%29
+    """
+
+    is_commutative = True
+
+    def __new__(cls, *args, **options):
+        args = (_sympify_(arg) for arg in args)
+
+        try:
+            # /!\ args is a generator and _new_args_filter
+            # must be careful to handle as such; this
+            # is done so short-circuiting can be done
+            # without having to sympify all values
+            _args = frozenset(cls._new_args_filter(args))
+        except ShortCircuit:
+            return sympify(cls.zero)
+        if not _args:
+            return sympify(cls.identity)
+        elif len(_args) == 1:
+            return set(_args).pop()
+        else:
+            # XXX in almost every other case for __new__, *_args is
+            # passed along, but the expectation here is for _args
+            obj = super(AssocOp, cls).__new__(cls, *ordered(_args))
+            obj._argset = _args
+            return obj
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence, call_cls=None):
+        """Generator filtering args"""
+        ncls = call_cls or cls
+        for arg in arg_sequence:
+            if arg == ncls.zero:
+                raise ShortCircuit(arg)
+            elif arg == ncls.identity:
+                continue
+            elif arg.func == ncls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def make_args(cls, expr):
+        """
+        Return a set of args such that cls(*arg_set) == expr.
+        """
+        if isinstance(expr, cls):
+            return expr._argset
+        else:
+            return frozenset([sympify(expr)])
+
+
+class AssocOpDispatcher:
+    """
+    Handler dispatcher for associative operators
+
+    .. notes::
+       This approach is experimental, and can be replaced or deleted in the future.
+       See https://github.com/sympy/sympy/pull/19463.
+
+    Explanation
+    ===========
+
+    If arguments of different types are passed, the classes which handle the operation for each type
+    are collected. Then, a class which performs the operation is selected by recursive binary dispatching.
+    Dispatching relation can be registered by ``register_handlerclass`` method.
+
+    Priority registration is unordered. You cannot make ``A*B`` and ``B*A`` refer to
+    different handler classes. All logic dealing with the order of arguments must be implemented
+    in the handler class.
+
+    Examples
+    ========
+
+    >>> from sympy import Add, Expr, Symbol
+    >>> from sympy.core.add import add
+
+    >>> class NewExpr(Expr):
+    ...     @property
+    ...     def _add_handler(self):
+    ...         return NewAdd
+    >>> class NewAdd(NewExpr, Add):
+    ...     pass
+    >>> add.register_handlerclass((Add, NewAdd), NewAdd)
+
+    >>> a, b = Symbol('a'), NewExpr()
+    >>> add(a, b) == NewAdd(a, b)
+    True
+
+    """
+    def __init__(self, name, doc=None):
+        self.name = name
+        self.doc = doc
+        self.handlerattr = "_%s_handler" % name
+        self._handlergetter = attrgetter(self.handlerattr)
+        self._dispatcher = Dispatcher(name)
+
+    def __repr__(self):
+        return "" % self.name
+
+    def register_handlerclass(self, classes, typ, on_ambiguity=ambiguity_register_error_ignore_dup):
+        """
+        Register the handler class for two classes, in both straight and reversed order.
+
+        Paramteters
+        ===========
+
+        classes : tuple of two types
+            Classes who are compared with each other.
+
+        typ:
+            Class which is registered to represent *cls1* and *cls2*.
+            Handler method of *self* must be implemented in this class.
+        """
+        if not len(classes) == 2:
+            raise RuntimeError(
+                "Only binary dispatch is supported, but got %s types: <%s>." % (
+                len(classes), str_signature(classes)
+            ))
+        if len(set(classes)) == 1:
+            raise RuntimeError(
+                "Duplicate types <%s> cannot be dispatched." % str_signature(classes)
+            )
+        self._dispatcher.add(tuple(classes), typ, on_ambiguity=on_ambiguity)
+        self._dispatcher.add(tuple(reversed(classes)), typ, on_ambiguity=on_ambiguity)
+
+    @cacheit
+    def __call__(self, *args, _sympify=True, **kwargs):
+        """
+        Parameters
+        ==========
+
+        *args :
+            Arguments which are operated
+        """
+        if _sympify:
+            args = tuple(map(_sympify_, args))
+        handlers = frozenset(map(self._handlergetter, args))
+
+        # no need to sympify again
+        return self.dispatch(handlers)(*args, _sympify=False, **kwargs)
+
+    @cacheit
+    def dispatch(self, handlers):
+        """
+        Select the handler class, and return its handler method.
+        """
+
+        # Quick exit for the case where all handlers are same
+        if len(handlers) == 1:
+            h, = handlers
+            if not isinstance(h, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(h))
+            return h
+
+        # Recursively select with registered binary priority
+        for i, typ in enumerate(handlers):
+
+            if not isinstance(typ, type):
+                raise RuntimeError("Handler {!r} is not a type.".format(typ))
+
+            if i == 0:
+                handler = typ
+            else:
+                prev_handler = handler
+                handler = self._dispatcher.dispatch(prev_handler, typ)
+
+                if not isinstance(handler, type):
+                    raise RuntimeError(
+                        "Dispatcher for {!r} and {!r} must return a type, but got {!r}".format(
+                        prev_handler, typ, handler
+                    ))
+
+        # return handler class
+        return handler
+
+    @property
+    def __doc__(self):
+        docs = [
+            "Multiply dispatched associative operator: %s" % self.name,
+            "Note that support for this is experimental, see the docs for :class:`AssocOpDispatcher` for details"
+        ]
+
+        if self.doc:
+            docs.append(self.doc)
+
+        s = "Registered handler classes\n"
+        s += '=' * len(s)
+        docs.append(s)
+
+        amb_sigs = []
+
+        typ_sigs = defaultdict(list)
+        for sigs in self._dispatcher.ordering[::-1]:
+            key = self._dispatcher.funcs[sigs]
+            typ_sigs[key].append(sigs)
+
+        for typ, sigs in typ_sigs.items():
+
+            sigs_str = ', '.join('<%s>' % str_signature(sig) for sig in sigs)
+
+            if isinstance(typ, RaiseNotImplementedError):
+                amb_sigs.append(sigs_str)
+                continue
+
+            s = 'Inputs: %s\n' % sigs_str
+            s += '-' * len(s) + '\n'
+            s += typ.__name__
+            docs.append(s)
+
+        if amb_sigs:
+            s = "Ambiguous handler classes\n"
+            s += '=' * len(s)
+            docs.append(s)
+
+            s = '\n'.join(amb_sigs)
+            docs.append(s)
+
+        return '\n\n'.join(docs)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/parameters.py b/.venv/lib/python3.12/site-packages/sympy/core/parameters.py
new file mode 100644
index 0000000000000000000000000000000000000000..d911a3652bf02fa5b24c43b138035a57be687228
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/parameters.py
@@ -0,0 +1,161 @@
+"""Thread-safe global parameters"""
+
+from .cache import clear_cache
+from contextlib import contextmanager
+from threading import local
+
+class _global_parameters(local):
+    """
+    Thread-local global parameters.
+
+    Explanation
+    ===========
+
+    This class generates thread-local container for SymPy's global parameters.
+    Every global parameters must be passed as keyword argument when generating
+    its instance.
+    A variable, `global_parameters` is provided as default instance for this class.
+
+    WARNING! Although the global parameters are thread-local, SymPy's cache is not
+    by now.
+    This may lead to undesired result in multi-threading operations.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.core.cache import clear_cache
+    >>> from sympy.core.parameters import global_parameters as gp
+
+    >>> gp.evaluate
+    True
+    >>> x+x
+    2*x
+
+    >>> log = []
+    >>> def f():
+    ...     clear_cache()
+    ...     gp.evaluate = False
+    ...     log.append(x+x)
+    ...     clear_cache()
+    >>> import threading
+    >>> thread = threading.Thread(target=f)
+    >>> thread.start()
+    >>> thread.join()
+
+    >>> print(log)
+    [x + x]
+
+    >>> gp.evaluate
+    True
+    >>> x+x
+    2*x
+
+    References
+    ==========
+
+    .. [1] https://docs.python.org/3/library/threading.html
+
+    """
+    def __init__(self, **kwargs):
+        self.__dict__.update(kwargs)
+
+    def __setattr__(self, name, value):
+        if getattr(self, name) != value:
+            clear_cache()
+        return super().__setattr__(name, value)
+
+global_parameters = _global_parameters(evaluate=True, distribute=True, exp_is_pow=False)
+
+class evaluate:
+    """ Control automatic evaluation
+
+    Explanation
+    ===========
+
+    This context manager controls whether or not all SymPy functions evaluate
+    by default.
+
+    Note that much of SymPy expects evaluated expressions.  This functionality
+    is experimental and is unlikely to function as intended on large
+    expressions.
+
+    Examples
+    ========
+
+    >>> from sympy import evaluate
+    >>> from sympy.abc import x
+    >>> print(x + x)
+    2*x
+    >>> with evaluate(False):
+    ...     print(x + x)
+    x + x
+    """
+    def __init__(self, x):
+        self.x = x
+        self.old = []
+
+    def __enter__(self):
+        self.old.append(global_parameters.evaluate)
+        global_parameters.evaluate = self.x
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        global_parameters.evaluate = self.old.pop()
+
+@contextmanager
+def distribute(x):
+    """ Control automatic distribution of Number over Add
+
+    Explanation
+    ===========
+
+    This context manager controls whether or not Mul distribute Number over
+    Add. Plan is to avoid distributing Number over Add in all of sympy. Once
+    that is done, this contextmanager will be removed.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x
+    >>> from sympy.core.parameters import distribute
+    >>> print(2*(x + 1))
+    2*x + 2
+    >>> with distribute(False):
+    ...     print(2*(x + 1))
+    2*(x + 1)
+    """
+
+    old = global_parameters.distribute
+
+    try:
+        global_parameters.distribute = x
+        yield
+    finally:
+        global_parameters.distribute = old
+
+
+@contextmanager
+def _exp_is_pow(x):
+    """
+    Control whether `e^x` should be represented as ``exp(x)`` or a ``Pow(E, x)``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.abc import x
+    >>> from sympy.core.parameters import _exp_is_pow
+    >>> with _exp_is_pow(True): print(type(exp(x)))
+    
+    >>> with _exp_is_pow(False): print(type(exp(x)))
+    exp
+    """
+    old = global_parameters.exp_is_pow
+
+    clear_cache()
+    try:
+        global_parameters.exp_is_pow = x
+        yield
+    finally:
+        clear_cache()
+        global_parameters.exp_is_pow = old
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/power.py b/.venv/lib/python3.12/site-packages/sympy/core/power.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f257d030553ecc7b887ca9d1199ccc19b9a642f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/power.py
@@ -0,0 +1,1847 @@
+from __future__ import annotations
+from typing import Callable, TYPE_CHECKING
+from itertools import product
+
+from .sympify import _sympify
+from .cache import cacheit
+from .singleton import S
+from .expr import Expr
+from .evalf import PrecisionExhausted
+from .function import (expand_complex, expand_multinomial,
+    expand_mul, _mexpand, PoleError)
+from .logic import fuzzy_bool, fuzzy_not, fuzzy_and, fuzzy_or
+from .parameters import global_parameters
+from .relational import is_gt, is_lt
+from .kind import NumberKind, UndefinedKind
+from sympy.utilities.iterables import sift
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.misc import as_int
+from sympy.multipledispatch import Dispatcher
+
+
+class Pow(Expr):
+    """
+    Defines the expression x**y as "x raised to a power y"
+
+    .. deprecated:: 1.7
+
+       Using arguments that aren't subclasses of :class:`~.Expr` in core
+       operators (:class:`~.Mul`, :class:`~.Add`, and :class:`~.Pow`) is
+       deprecated. See :ref:`non-expr-args-deprecated` for details.
+
+    Singleton definitions involving (0, 1, -1, oo, -oo, I, -I):
+
+    +--------------+---------+-----------------------------------------------+
+    | expr         | value   | reason                                        |
+    +==============+=========+===============================================+
+    | z**0         | 1       | Although arguments over 0**0 exist, see [2].  |
+    +--------------+---------+-----------------------------------------------+
+    | z**1         | z       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-oo)**(-1)  | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-1)**-1     | -1      |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | S.Zero**-1   | zoo     | This is not strictly true, as 0**-1 may be    |
+    |              |         | undefined, but is convenient in some contexts |
+    |              |         | where the base is assumed to be positive.     |
+    +--------------+---------+-----------------------------------------------+
+    | 1**-1        | 1       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**-1       | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | 0**oo        | 0       | Because for all complex numbers z near        |
+    |              |         | 0, z**oo -> 0.                                |
+    +--------------+---------+-----------------------------------------------+
+    | 0**-oo       | zoo     | This is not strictly true, as 0**oo may be    |
+    |              |         | oscillating between positive and negative     |
+    |              |         | values or rotating in the complex plane.      |
+    |              |         | It is convenient, however, when the base      |
+    |              |         | is positive.                                  |
+    +--------------+---------+-----------------------------------------------+
+    | 1**oo        | nan     | Because there are various cases where         |
+    | 1**-oo       |         | lim(x(t),t)=1, lim(y(t),t)=oo (or -oo),       |
+    |              |         | but lim( x(t)**y(t), t) != 1.  See [3].       |
+    +--------------+---------+-----------------------------------------------+
+    | b**zoo       | nan     | Because b**z has no limit as z -> zoo         |
+    +--------------+---------+-----------------------------------------------+
+    | (-1)**oo     | nan     | Because of oscillations in the limit.         |
+    | (-1)**(-oo)  |         |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**oo       | oo      |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**-oo      | 0       |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | (-oo)**oo    | nan     |                                               |
+    | (-oo)**-oo   |         |                                               |
+    +--------------+---------+-----------------------------------------------+
+    | oo**I        | nan     | oo**e could probably be best thought of as    |
+    | (-oo)**I     |         | the limit of x**e for real x as x tends to    |
+    |              |         | oo. If e is I, then the limit does not exist  |
+    |              |         | and nan is used to indicate that.             |
+    +--------------+---------+-----------------------------------------------+
+    | oo**(1+I)    | zoo     | If the real part of e is positive, then the   |
+    | (-oo)**(1+I) |         | limit of abs(x**e) is oo. So the limit value  |
+    |              |         | is zoo.                                       |
+    +--------------+---------+-----------------------------------------------+
+    | oo**(-1+I)   | 0       | If the real part of e is negative, then the   |
+    | -oo**(-1+I)  |         | limit is 0.                                   |
+    +--------------+---------+-----------------------------------------------+
+
+    Because symbolic computations are more flexible than floating point
+    calculations and we prefer to never return an incorrect answer,
+    we choose not to conform to all IEEE 754 conventions.  This helps
+    us avoid extra test-case code in the calculation of limits.
+
+    See Also
+    ========
+
+    sympy.core.numbers.Infinity
+    sympy.core.numbers.NegativeInfinity
+    sympy.core.numbers.NaN
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Exponentiation
+    .. [2] https://en.wikipedia.org/wiki/Zero_to_the_power_of_zero
+    .. [3] https://en.wikipedia.org/wiki/Indeterminate_forms
+
+    """
+    is_Pow = True
+
+    __slots__ = ('is_commutative',)
+
+    if TYPE_CHECKING:
+
+        @property
+        def args(self) -> tuple[Expr, Expr]:
+            ...
+
+    @property
+    def base(self) -> Expr:
+        return self.args[0]
+
+    @property
+    def exp(self) -> Expr:
+        return self.args[1]
+
+    @property
+    def kind(self):
+        if self.exp.kind is NumberKind:
+            return self.base.kind
+        else:
+            return UndefinedKind
+
+    @cacheit
+    def __new__(cls, b: Expr | complex, e: Expr | complex, evaluate=None) -> Expr: # type: ignore
+        if evaluate is None:
+            evaluate = global_parameters.evaluate
+
+        base = _sympify(b)
+        exp = _sympify(e)
+
+        # XXX: This can be removed when non-Expr args are disallowed rather
+        # than deprecated.
+        from .relational import Relational
+        if isinstance(base, Relational) or isinstance(exp, Relational):
+            raise TypeError('Relational cannot be used in Pow')
+
+        # XXX: This should raise TypeError once deprecation period is over:
+        for arg in [base, exp]:
+            if not isinstance(arg, Expr):
+                sympy_deprecation_warning(
+                    f"""
+    Using non-Expr arguments in Pow is deprecated (in this case, one of the
+    arguments is of type {type(arg).__name__!r}).
+
+    If you really did intend to construct a power with this base, use the **
+    operator instead.""",
+                    deprecated_since_version="1.7",
+                    active_deprecations_target="non-expr-args-deprecated",
+                    stacklevel=4,
+                )
+
+        if evaluate:
+            if exp is S.ComplexInfinity:
+                return S.NaN
+            if exp is S.Infinity:
+                if is_gt(base, S.One):
+                    return S.Infinity
+                if is_gt(base, S.NegativeOne) and is_lt(base, S.One):
+                    return S.Zero
+                if is_lt(base, S.NegativeOne):
+                    if base.is_finite:
+                        return S.ComplexInfinity
+                    if base.is_finite is False:
+                        return S.NaN
+            if exp is S.Zero:
+                return S.One
+            elif exp is S.One:
+                return base
+            elif exp == -1 and not base:
+                return S.ComplexInfinity
+            elif exp.__class__.__name__ == "AccumulationBounds":
+                if base == S.Exp1:
+                    from sympy.calculus.accumulationbounds import AccumBounds
+                    return AccumBounds(Pow(base, exp.min), Pow(base, exp.max))
+            # autosimplification if base is a number and exp odd/even
+            # if base is Number then the base will end up positive; we
+            # do not do this with arbitrary expressions since symbolic
+            # cancellation might occur as in (x - 1)/(1 - x) -> -1. If
+            # we returned Piecewise((-1, Ne(x, 1))) for such cases then
+            # we could do this...but we don't
+            elif (exp.is_Symbol and exp.is_integer or exp.is_Integer
+                    ) and (base.is_number and base.is_Mul or base.is_Number
+                    ) and base.could_extract_minus_sign():
+                if exp.is_even:
+                    base = -base
+                elif exp.is_odd:
+                    return -Pow(-base, exp)
+            if S.NaN in (base, exp):  # XXX S.NaN**x -> S.NaN under assumption that x != 0
+                return S.NaN
+            elif base is S.One:
+                if abs(exp).is_infinite:
+                    return S.NaN
+                return S.One
+            else:
+                # recognize base as E
+                from sympy.functions.elementary.exponential import exp_polar
+                if not exp.is_Atom and base is not S.Exp1 and not isinstance(base, exp_polar):
+                    from .exprtools import factor_terms
+                    from sympy.functions.elementary.exponential import log
+                    from sympy.simplify.radsimp import fraction
+                    c, ex = factor_terms(exp, sign=False).as_coeff_Mul()
+                    num, den = fraction(ex)
+                    if isinstance(den, log) and den.args[0] == base:
+                        return S.Exp1**(c*num)
+                    elif den.is_Add:
+                        from sympy.functions.elementary.complexes import sign, im
+                        s = sign(im(base))
+                        if s.is_Number and s and den == \
+                                log(-factor_terms(base, sign=False)) + s*S.ImaginaryUnit*S.Pi:
+                            return S.Exp1**(c*num)
+
+                obj = base._eval_power(exp)
+                if obj is not None:
+                    return obj
+        obj = Expr.__new__(cls, base, exp)
+        obj = cls._exec_constructor_postprocessors(obj)
+        if not isinstance(obj, Pow):
+            return obj
+        obj.is_commutative = (base.is_commutative and exp.is_commutative)
+        return obj
+
+    def inverse(self, argindex=1):
+        if self.base == S.Exp1:
+            from sympy.functions.elementary.exponential import log
+            return log
+        return None
+
+    @classmethod
+    def class_key(cls):
+        return 3, 2, cls.__name__
+
+    def _eval_refine(self, assumptions):
+        from sympy.assumptions.ask import ask, Q
+        b, e = self.as_base_exp()
+        if ask(Q.integer(e), assumptions) and b.could_extract_minus_sign():
+            if ask(Q.even(e), assumptions):
+                return Pow(-b, e)
+            elif ask(Q.odd(e), assumptions):
+                return -Pow(-b, e)
+
+    def _eval_power(self, expt):
+        b, e = self.as_base_exp()
+        if b is S.NaN:
+            return (b**e)**expt  # let __new__ handle it
+
+        s = None
+        if expt.is_integer:
+            s = 1
+        elif b.is_polar:  # e.g. exp_polar, besselj, var('p', polar=True)...
+            s = 1
+        elif e.is_extended_real is not None:
+            from sympy.functions.elementary.complexes import arg, im, re, sign
+            from sympy.functions.elementary.exponential import exp, log
+            from sympy.functions.elementary.integers import floor
+            # helper functions ===========================
+            def _half(e):
+                """Return True if the exponent has a literal 2 as the
+                denominator, else None."""
+                if getattr(e, 'q', None) == 2:
+                    return True
+                n, d = e.as_numer_denom()
+                if n.is_integer and d == 2:
+                    return True
+            def _n2(e):
+                """Return ``e`` evaluated to a Number with 2 significant
+                digits, else None."""
+                try:
+                    rv = e.evalf(2, strict=True)
+                    if rv.is_Number:
+                        return rv
+                except PrecisionExhausted:
+                    pass
+            # ===================================================
+            if e.is_extended_real:
+                # we need _half(expt) with constant floor or
+                # floor(S.Half - e*arg(b)/2/pi) == 0
+
+
+                # handle -1 as special case
+                if e == -1:
+                    # floor arg. is 1/2 + arg(b)/2/pi
+                    if _half(expt):
+                        if b.is_negative is True:
+                            return S.NegativeOne**expt*Pow(-b, e*expt)
+                        elif b.is_negative is False:  # XXX ok if im(b) != 0?
+                            return Pow(b, -expt)
+                elif e.is_even:
+                    if b.is_extended_real:
+                        b = abs(b)
+                    if b.is_imaginary:
+                        b = abs(im(b))*S.ImaginaryUnit
+
+                if (abs(e) < 1) == True or e == 1:
+                    s = 1  # floor = 0
+                elif b.is_extended_nonnegative:
+                    s = 1  # floor = 0
+                elif re(b).is_extended_nonnegative and (abs(e) < 2) == True:
+                    s = 1  # floor = 0
+                elif _half(expt):
+                    s = exp(2*S.Pi*S.ImaginaryUnit*expt*floor(
+                        S.Half - e*arg(b)/(2*S.Pi)))
+                    if s.is_extended_real and _n2(sign(s) - s) == 0:
+                        s = sign(s)
+                    else:
+                        s = None
+            else:
+                # e.is_extended_real is False requires:
+                #     _half(expt) with constant floor or
+                #     floor(S.Half - im(e*log(b))/2/pi) == 0
+                try:
+                    s = exp(2*S.ImaginaryUnit*S.Pi*expt*
+                        floor(S.Half - im(e*log(b))/2/S.Pi))
+                    # be careful to test that s is -1 or 1 b/c sign(I) == I:
+                    # so check that s is real
+                    if s.is_extended_real and _n2(sign(s) - s) == 0:
+                        s = sign(s)
+                    else:
+                        s = None
+                except PrecisionExhausted:
+                    s = None
+
+        if s is not None:
+            return s*Pow(b, e*expt)
+
+    def _eval_Mod(self, q):
+        r"""A dispatched function to compute `b^e \bmod q`, dispatched
+        by ``Mod``.
+
+        Notes
+        =====
+
+        Algorithms:
+
+        1. For unevaluated integer power, use built-in ``pow`` function
+        with 3 arguments, if powers are not too large wrt base.
+
+        2. For very large powers, use totient reduction if $e \ge \log(m)$.
+        Bound on m, is for safe factorization memory wise i.e. $m^{1/4}$.
+        For pollard-rho to be faster than built-in pow $\log(e) > m^{1/4}$
+        check is added.
+
+        3. For any unevaluated power found in `b` or `e`, the step 2
+        will be recursed down to the base and the exponent
+        such that the $b \bmod q$ becomes the new base and
+        $\phi(q) + e \bmod \phi(q)$ becomes the new exponent, and then
+        the computation for the reduced expression can be done.
+        """
+
+        base, exp = self.base, self.exp
+
+        if exp.is_integer and exp.is_positive:
+            if q.is_integer and base % q == 0:
+                return S.Zero
+
+            from sympy.functions.combinatorial.numbers import totient
+
+            if base.is_Integer and exp.is_Integer and q.is_Integer:
+                b, e, m = int(base), int(exp), int(q)
+                mb = m.bit_length()
+                if mb <= 80 and e >= mb and e.bit_length()**4 >= m:
+                    phi = int(totient(m))
+                    return Integer(pow(b, phi + e%phi, m))
+                return Integer(pow(b, e, m))
+
+            from .mod import Mod
+
+            if isinstance(base, Pow) and base.is_integer and base.is_number:
+                base = Mod(base, q)
+                return Mod(Pow(base, exp, evaluate=False), q)
+
+            if isinstance(exp, Pow) and exp.is_integer and exp.is_number:
+                bit_length = int(q).bit_length()
+                # XXX Mod-Pow actually attempts to do a hanging evaluation
+                # if this dispatched function returns None.
+                # May need some fixes in the dispatcher itself.
+                if bit_length <= 80:
+                    phi = totient(q)
+                    exp = phi + Mod(exp, phi)
+                    return Mod(Pow(base, exp, evaluate=False), q)
+
+    def _eval_is_even(self):
+        if self.exp.is_integer and self.exp.is_positive:
+            return self.base.is_even
+
+    def _eval_is_negative(self):
+        ext_neg = Pow._eval_is_extended_negative(self)
+        if ext_neg is True:
+            return self.is_finite
+        return ext_neg
+
+    def _eval_is_extended_positive(self):
+        if self.base == self.exp:
+            if self.base.is_extended_nonnegative:
+                return True
+        elif self.base.is_positive:
+            if self.exp.is_real:
+                return True
+        elif self.base.is_extended_negative:
+            if self.exp.is_even:
+                return True
+            if self.exp.is_odd:
+                return False
+        elif self.base.is_zero:
+            if self.exp.is_extended_real:
+                return self.exp.is_zero
+        elif self.base.is_extended_nonpositive:
+            if self.exp.is_odd:
+                return False
+        elif self.base.is_imaginary:
+            if self.exp.is_integer:
+                m = self.exp % 4
+                if m.is_zero:
+                    return True
+                if m.is_integer and m.is_zero is False:
+                    return False
+            if self.exp.is_imaginary:
+                from sympy.functions.elementary.exponential import log
+                return log(self.base).is_imaginary
+
+    def _eval_is_extended_negative(self):
+        if self.exp is S.Half:
+            if self.base.is_complex or self.base.is_extended_real:
+                return False
+        if self.base.is_extended_negative:
+            if self.exp.is_odd and self.base.is_finite:
+                return True
+            if self.exp.is_even:
+                return False
+        elif self.base.is_extended_positive:
+            if self.exp.is_extended_real:
+                return False
+        elif self.base.is_zero:
+            if self.exp.is_extended_real:
+                return False
+        elif self.base.is_extended_nonnegative:
+            if self.exp.is_extended_nonnegative:
+                return False
+        elif self.base.is_extended_nonpositive:
+            if self.exp.is_even:
+                return False
+        elif self.base.is_extended_real:
+            if self.exp.is_even:
+                return False
+
+    def _eval_is_zero(self):
+        if self.base.is_zero:
+            if self.exp.is_extended_positive:
+                return True
+            elif self.exp.is_extended_nonpositive:
+                return False
+        elif self.base == S.Exp1:
+            return self.exp is S.NegativeInfinity
+        elif self.base.is_zero is False:
+            if self.base.is_finite and self.exp.is_finite:
+                return False
+            elif self.exp.is_negative:
+                return self.base.is_infinite
+            elif self.exp.is_nonnegative:
+                return False
+            elif self.exp.is_infinite and self.exp.is_extended_real:
+                if (1 - abs(self.base)).is_extended_positive:
+                    return self.exp.is_extended_positive
+                elif (1 - abs(self.base)).is_extended_negative:
+                    return self.exp.is_extended_negative
+        elif self.base.is_finite and self.exp.is_negative:
+            # when self.base.is_zero is None
+            return False
+
+    def _eval_is_integer(self):
+        b, e = self.args
+        if b.is_rational:
+            if b.is_integer is False and e.is_positive:
+                return False  # rat**nonneg
+        if b.is_integer and e.is_integer:
+            if b is S.NegativeOne:
+                return True
+            if e.is_nonnegative or e.is_positive:
+                return True
+        if b.is_integer and e.is_negative and (e.is_finite or e.is_integer):
+            if fuzzy_not((b - 1).is_zero) and fuzzy_not((b + 1).is_zero):
+                return False
+        if b.is_Number and e.is_Number:
+            check = self.func(*self.args)
+            return check.is_Integer
+        if e.is_negative and b.is_positive and (b - 1).is_positive:
+            return False
+        if e.is_negative and b.is_negative and (b + 1).is_negative:
+            return False
+
+    def _eval_is_extended_real(self):
+        if self.base is S.Exp1:
+            if self.exp.is_extended_real:
+                return True
+            elif self.exp.is_imaginary:
+                return (2*S.ImaginaryUnit*self.exp/S.Pi).is_even
+
+        from sympy.functions.elementary.exponential import log, exp
+        real_b = self.base.is_extended_real
+        if real_b is None:
+            if self.base.func == exp and self.base.exp.is_imaginary:
+                return self.exp.is_imaginary
+            if self.base.func == Pow and self.base.base is S.Exp1 and self.base.exp.is_imaginary:
+                return self.exp.is_imaginary
+            return
+        real_e = self.exp.is_extended_real
+        if real_e is None:
+            return
+        if real_b and real_e:
+            if self.base.is_extended_positive:
+                return True
+            elif self.base.is_extended_nonnegative and self.exp.is_extended_nonnegative:
+                return True
+            elif self.exp.is_integer and self.base.is_extended_nonzero:
+                return True
+            elif self.exp.is_integer and self.exp.is_nonnegative:
+                return True
+            elif self.base.is_extended_negative:
+                if self.exp.is_Rational:
+                    return False
+        if real_e and self.exp.is_extended_negative and self.base.is_zero is False:
+            return Pow(self.base, -self.exp).is_extended_real
+        im_b = self.base.is_imaginary
+        im_e = self.exp.is_imaginary
+        if im_b:
+            if self.exp.is_integer:
+                if self.exp.is_even:
+                    return True
+                elif self.exp.is_odd:
+                    return False
+            elif im_e and log(self.base).is_imaginary:
+                return True
+            elif self.exp.is_Add:
+                c, a = self.exp.as_coeff_Add()
+                if c and c.is_Integer:
+                    return Mul(
+                        self.base**c, self.base**a, evaluate=False).is_extended_real
+            elif self.base in (-S.ImaginaryUnit, S.ImaginaryUnit):
+                if (self.exp/2).is_integer is False:
+                    return False
+        if real_b and im_e:
+            if self.base is S.NegativeOne:
+                return True
+            c = self.exp.coeff(S.ImaginaryUnit)
+            if c:
+                if self.base.is_rational and c.is_rational:
+                    if self.base.is_nonzero and (self.base - 1).is_nonzero and c.is_nonzero:
+                        return False
+                ok = (c*log(self.base)/S.Pi).is_integer
+                if ok is not None:
+                    return ok
+
+        if real_b is False and real_e: # we already know it's not imag
+            if isinstance(self.exp, Rational) and self.exp.p == 1:
+                return False
+            from sympy.functions.elementary.complexes import arg
+            i = arg(self.base)*self.exp/S.Pi
+            if i.is_complex: # finite
+                return i.is_integer
+
+    def _eval_is_complex(self):
+
+        if self.base == S.Exp1:
+            return fuzzy_or([self.exp.is_complex, self.exp.is_extended_negative])
+
+        if all(a.is_complex for a in self.args) and self._eval_is_finite():
+            return True
+
+    def _eval_is_imaginary(self):
+        if self.base.is_commutative is False:
+            return False
+
+        if self.base.is_imaginary:
+            if self.exp.is_integer:
+                odd = self.exp.is_odd
+                if odd is not None:
+                    return odd
+                return
+
+        if self.base == S.Exp1:
+            f = 2 * self.exp / (S.Pi*S.ImaginaryUnit)
+            # exp(pi*integer) = 1 or -1, so not imaginary
+            if f.is_even:
+                return False
+            # exp(pi*integer + pi/2) = I or -I, so it is imaginary
+            if f.is_odd:
+                return True
+            return None
+
+        if self.exp.is_imaginary:
+            from sympy.functions.elementary.exponential import log
+            imlog = log(self.base).is_imaginary
+            if imlog is not None:
+                return False  # I**i -> real; (2*I)**i -> complex ==> not imaginary
+
+        if self.base.is_extended_real and self.exp.is_extended_real:
+            if self.base.is_positive:
+                return False
+            else:
+                rat = self.exp.is_rational
+                if not rat:
+                    return rat
+                if self.exp.is_integer:
+                    return False
+                else:
+                    half = (2*self.exp).is_integer
+                    if half:
+                        return self.base.is_negative
+                    return half
+
+        if self.base.is_extended_real is False:  # we already know it's not imag
+            from sympy.functions.elementary.complexes import arg
+            i = arg(self.base)*self.exp/S.Pi
+            isodd = (2*i).is_odd
+            if isodd is not None:
+                return isodd
+
+    def _eval_is_odd(self):
+        if self.exp.is_integer:
+            if self.exp.is_positive:
+                return self.base.is_odd
+            elif self.exp.is_nonnegative and self.base.is_odd:
+                return True
+            elif self.base is S.NegativeOne:
+                return True
+
+    def _eval_is_finite(self):
+        if self.exp.is_negative:
+            if self.base.is_zero:
+                return False
+            if self.base.is_infinite or self.base.is_nonzero:
+                return True
+        c1 = self.base.is_finite
+        if c1 is None:
+            return
+        c2 = self.exp.is_finite
+        if c2 is None:
+            return
+        if c1 and c2:
+            if self.exp.is_nonnegative or fuzzy_not(self.base.is_zero):
+                return True
+
+    def _eval_is_prime(self):
+        '''
+        An integer raised to the n(>=2)-th power cannot be a prime.
+        '''
+        if self.base.is_integer and self.exp.is_integer and (self.exp - 1).is_positive:
+            return False
+
+    def _eval_is_composite(self):
+        """
+        A power is composite if both base and exponent are greater than 1
+        """
+        if (self.base.is_integer and self.exp.is_integer and
+            ((self.base - 1).is_positive and (self.exp - 1).is_positive or
+            (self.base + 1).is_negative and self.exp.is_positive and self.exp.is_even)):
+            return True
+
+    def _eval_is_polar(self):
+        return self.base.is_polar
+
+    def _eval_subs(self, old, new):
+        from sympy.calculus.accumulationbounds import AccumBounds
+
+        if isinstance(self.exp, AccumBounds):
+            b = self.base.subs(old, new)
+            e = self.exp.subs(old, new)
+            if isinstance(e, AccumBounds):
+                return e.__rpow__(b)
+            return self.func(b, e)
+
+        from sympy.functions.elementary.exponential import exp, log
+
+        def _check(ct1, ct2, old):
+            """Return (bool, pow, remainder_pow) where, if bool is True, then the
+            exponent of Pow `old` will combine with `pow` so the substitution
+            is valid, otherwise bool will be False.
+
+            For noncommutative objects, `pow` will be an integer, and a factor
+            `Pow(old.base, remainder_pow)` needs to be included. If there is
+            no such factor, None is returned. For commutative objects,
+            remainder_pow is always None.
+
+            cti are the coefficient and terms of an exponent of self or old
+            In this _eval_subs routine a change like (b**(2*x)).subs(b**x, y)
+            will give y**2 since (b**x)**2 == b**(2*x); if that equality does
+            not hold then the substitution should not occur so `bool` will be
+            False.
+
+            """
+            coeff1, terms1 = ct1
+            coeff2, terms2 = ct2
+            if terms1 == terms2:
+                if old.is_commutative:
+                    # Allow fractional powers for commutative objects
+                    pow = coeff1/coeff2
+                    try:
+                        as_int(pow, strict=False)
+                        combines = True
+                    except ValueError:
+                        b, e = old.as_base_exp()
+                        # These conditions ensure that (b**e)**f == b**(e*f) for any f
+                        combines = b.is_positive and e.is_real or b.is_nonnegative and e.is_nonnegative
+
+                    return combines, pow, None
+                else:
+                    # With noncommutative symbols, substitute only integer powers
+                    if not isinstance(terms1, tuple):
+                        terms1 = (terms1,)
+                    if not all(term.is_integer for term in terms1):
+                        return False, None, None
+
+                    try:
+                        # Round pow toward zero
+                        pow, remainder = divmod(as_int(coeff1), as_int(coeff2))
+                        if pow < 0 and remainder != 0:
+                            pow += 1
+                            remainder -= as_int(coeff2)
+
+                        if remainder == 0:
+                            remainder_pow = None
+                        else:
+                            remainder_pow = Mul(remainder, *terms1)
+
+                        return True, pow, remainder_pow
+                    except ValueError:
+                        # Can't substitute
+                        pass
+
+            return False, None, None
+
+        if old == self.base or (old == exp and self.base == S.Exp1):
+            if new.is_Function and isinstance(new, Callable):
+                return new(self.exp._subs(old, new))
+            else:
+                return new**self.exp._subs(old, new)
+
+        # issue 10829: (4**x - 3*y + 2).subs(2**x, y) -> y**2 - 3*y + 2
+        if isinstance(old, self.func) and self.exp == old.exp:
+            l = log(self.base, old.base)
+            if l.is_Number:
+                return Pow(new, l)
+
+        if isinstance(old, self.func) and self.base == old.base:
+            if self.exp.is_Add is False:
+                ct1 = self.exp.as_independent(Symbol, as_Add=False)
+                ct2 = old.exp.as_independent(Symbol, as_Add=False)
+                ok, pow, remainder_pow = _check(ct1, ct2, old)
+                if ok:
+                    # issue 5180: (x**(6*y)).subs(x**(3*y),z)->z**2
+                    result = self.func(new, pow)
+                    if remainder_pow is not None:
+                        result = Mul(result, Pow(old.base, remainder_pow))
+                    return result
+            else:  # b**(6*x + a).subs(b**(3*x), y) -> y**2 * b**a
+                # exp(exp(x) + exp(x**2)).subs(exp(exp(x)), w) -> w * exp(exp(x**2))
+                oarg = old.exp
+                new_l = []
+                o_al = []
+                ct2 = oarg.as_coeff_mul()
+                for a in self.exp.args:
+                    newa = a._subs(old, new)
+                    ct1 = newa.as_coeff_mul()
+                    ok, pow, remainder_pow = _check(ct1, ct2, old)
+                    if ok:
+                        new_l.append(new**pow)
+                        if remainder_pow is not None:
+                            o_al.append(remainder_pow)
+                        continue
+                    elif not old.is_commutative and not newa.is_integer:
+                        # If any term in the exponent is non-integer,
+                        # we do not do any substitutions in the noncommutative case
+                        return
+                    o_al.append(newa)
+                if new_l:
+                    expo = Add(*o_al)
+                    new_l.append(Pow(self.base, expo, evaluate=False) if expo != 1 else self.base)
+                    return Mul(*new_l)
+
+        if (isinstance(old, exp) or (old.is_Pow and old.base is S.Exp1)) and self.exp.is_extended_real and self.base.is_positive:
+            ct1 = old.exp.as_independent(Symbol, as_Add=False)
+            ct2 = (self.exp*log(self.base)).as_independent(
+                Symbol, as_Add=False)
+            ok, pow, remainder_pow = _check(ct1, ct2, old)
+            if ok:
+                result = self.func(new, pow)  # (2**x).subs(exp(x*log(2)), z) -> z
+                if remainder_pow is not None:
+                    result = Mul(result, Pow(old.base, remainder_pow))
+                return result
+
+    def as_base_exp(self):
+        """Return base and exp of self.
+
+        Explanation
+        ===========
+
+        If base a Rational less than 1, then return 1/Rational, -exp.
+        If this extra processing is not needed, the base and exp
+        properties will give the raw arguments.
+
+        Examples
+        ========
+
+        >>> from sympy import Pow, S
+        >>> p = Pow(S.Half, 2, evaluate=False)
+        >>> p.as_base_exp()
+        (2, -2)
+        >>> p.args
+        (1/2, 2)
+        >>> p.base, p.exp
+        (1/2, 2)
+
+        """
+        b, e = self.args
+        if b.is_Rational and b.p == 1 and b.q != 1:
+            return Integer(b.q), -e
+        return b, e
+
+    def _eval_adjoint(self):
+        from sympy.functions.elementary.complexes import adjoint
+        i, p = self.exp.is_integer, self.base.is_positive
+        if i:
+            return adjoint(self.base)**self.exp
+        if p:
+            return self.base**adjoint(self.exp)
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return adjoint(expanded)
+
+    def _eval_conjugate(self):
+        from sympy.functions.elementary.complexes import conjugate as c
+        i, p = self.exp.is_integer, self.base.is_positive
+        if i:
+            return c(self.base)**self.exp
+        if p:
+            return self.base**c(self.exp)
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return c(expanded)
+        if self.is_extended_real:
+            return self
+
+    def _eval_transpose(self):
+        from sympy.functions.elementary.complexes import transpose
+        if self.base == S.Exp1:
+            return self.func(S.Exp1, self.exp.transpose())
+        i, p = self.exp.is_integer, (self.base.is_complex or self.base.is_infinite)
+        if p:
+            return self.base**self.exp
+        if i:
+            return transpose(self.base)**self.exp
+        if i is False and p is False:
+            expanded = expand_complex(self)
+            if expanded != self:
+                return transpose(expanded)
+
+    def _eval_expand_power_exp(self, **hints):
+        """a**(n + m) -> a**n*a**m"""
+        b = self.base
+        e = self.exp
+        if b == S.Exp1:
+            from sympy.concrete.summations import Sum
+            if isinstance(e, Sum) and e.is_commutative:
+                from sympy.concrete.products import Product
+                return Product(self.func(b, e.function), *e.limits)
+        if e.is_Add and (hints.get('force', False) or
+                b.is_zero is False or e._all_nonneg_or_nonppos()):
+            if e.is_commutative:
+                return Mul(*[self.func(b, x) for x in e.args])
+            if b.is_commutative:
+                c, nc = sift(e.args, lambda x: x.is_commutative, binary=True)
+                if c:
+                    return Mul(*[self.func(b, x) for x in c]
+                        )*b**Add._from_args(nc)
+        return self
+
+    def _eval_expand_power_base(self, **hints):
+        """(a*b)**n -> a**n * b**n"""
+        force = hints.get('force', False)
+
+        b = self.base
+        e = self.exp
+        if not b.is_Mul:
+            return self
+
+        cargs, nc = b.args_cnc(split_1=False)
+
+        # expand each term - this is top-level-only
+        # expansion but we have to watch out for things
+        # that don't have an _eval_expand method
+        if nc:
+            nc = [i._eval_expand_power_base(**hints)
+                if hasattr(i, '_eval_expand_power_base') else i
+                for i in nc]
+
+            if e.is_Integer:
+                if e.is_positive:
+                    rv = Mul(*nc*e)
+                else:
+                    rv = Mul(*[i**-1 for i in nc[::-1]]*-e)
+                if cargs:
+                    rv *= Mul(*cargs)**e
+                return rv
+
+            if not cargs:
+                return self.func(Mul(*nc), e, evaluate=False)
+
+            nc = [Mul(*nc)]
+
+        # sift the commutative bases
+        other, maybe_real = sift(cargs, lambda x: x.is_extended_real is False,
+            binary=True)
+        def pred(x):
+            if x is S.ImaginaryUnit:
+                return S.ImaginaryUnit
+            polar = x.is_polar
+            if polar:
+                return True
+            if polar is None:
+                return fuzzy_bool(x.is_extended_nonnegative)
+        sifted = sift(maybe_real, pred)
+        nonneg = sifted[True]
+        other += sifted[None]
+        neg = sifted[False]
+        imag = sifted[S.ImaginaryUnit]
+        if imag:
+            I = S.ImaginaryUnit
+            i = len(imag) % 4
+            if i == 0:
+                pass
+            elif i == 1:
+                other.append(I)
+            elif i == 2:
+                if neg:
+                    nonn = -neg.pop()
+                    if nonn is not S.One:
+                        nonneg.append(nonn)
+                else:
+                    neg.append(S.NegativeOne)
+            else:
+                if neg:
+                    nonn = -neg.pop()
+                    if nonn is not S.One:
+                        nonneg.append(nonn)
+                else:
+                    neg.append(S.NegativeOne)
+                other.append(I)
+            del imag
+
+        # bring out the bases that can be separated from the base
+
+        if force or e.is_integer:
+            # treat all commutatives the same and put nc in other
+            cargs = nonneg + neg + other
+            other = nc
+        else:
+            # this is just like what is happening automatically, except
+            # that now we are doing it for an arbitrary exponent for which
+            # no automatic expansion is done
+
+            assert not e.is_Integer
+
+            # handle negatives by making them all positive and putting
+            # the residual -1 in other
+            if len(neg) > 1:
+                o = S.One
+                if not other and neg[0].is_Number:
+                    o *= neg.pop(0)
+                if len(neg) % 2:
+                    o = -o
+                for n in neg:
+                    nonneg.append(-n)
+                if o is not S.One:
+                    other.append(o)
+            elif neg and other:
+                if neg[0].is_Number and neg[0] is not S.NegativeOne:
+                    other.append(S.NegativeOne)
+                    nonneg.append(-neg[0])
+                else:
+                    other.extend(neg)
+            else:
+                other.extend(neg)
+            del neg
+
+            cargs = nonneg
+            other += nc
+
+        rv = S.One
+        if cargs:
+            if e.is_Rational:
+                npow, cargs = sift(cargs, lambda x: x.is_Pow and
+                    x.exp.is_Rational and x.base.is_number,
+                    binary=True)
+                rv = Mul(*[self.func(b.func(*b.args), e) for b in npow])
+            rv *= Mul(*[self.func(b, e, evaluate=False) for b in cargs])
+        if other:
+            rv *= self.func(Mul(*other), e, evaluate=False)
+        return rv
+
+    def _eval_expand_multinomial(self, **hints):
+        """(a + b + ..)**n -> a**n + n*a**(n-1)*b + .., n is nonzero integer"""
+
+        base, exp = self.args
+        result = self
+
+        if exp.is_Rational and exp.p > 0 and base.is_Add:
+            if not exp.is_Integer:
+                n = Integer(exp.p // exp.q)
+
+                if not n:
+                    return result
+                else:
+                    radical, result = self.func(base, exp - n), []
+
+                    expanded_base_n = self.func(base, n)
+                    if expanded_base_n.is_Pow:
+                        expanded_base_n = \
+                            expanded_base_n._eval_expand_multinomial()
+                    for term in Add.make_args(expanded_base_n):
+                        result.append(term*radical)
+
+                    return Add(*result)
+
+            n = int(exp)
+
+            if base.is_commutative:
+                order_terms, other_terms = [], []
+
+                for b in base.args:
+                    if b.is_Order:
+                        order_terms.append(b)
+                    else:
+                        other_terms.append(b)
+
+                if order_terms:
+                    # (f(x) + O(x^n))^m -> f(x)^m + m*f(x)^{m-1} *O(x^n)
+                    f = Add(*other_terms)
+                    o = Add(*order_terms)
+
+                    if n == 2:
+                        return expand_multinomial(f**n, deep=False) + n*f*o
+                    else:
+                        g = expand_multinomial(f**(n - 1), deep=False)
+                        return expand_mul(f*g, deep=False) + n*g*o
+
+                if base.is_number:
+                    # Efficiently expand expressions of the form (a + b*I)**n
+                    # where 'a' and 'b' are real numbers and 'n' is integer.
+                    a, b = base.as_real_imag()
+
+                    if a.is_Rational and b.is_Rational:
+                        if not a.is_Integer:
+                            if not b.is_Integer:
+                                k = self.func(a.q * b.q, n)
+                                a, b = a.p*b.q, a.q*b.p
+                            else:
+                                k = self.func(a.q, n)
+                                a, b = a.p, a.q*b
+                        elif not b.is_Integer:
+                            k = self.func(b.q, n)
+                            a, b = a*b.q, b.p
+                        else:
+                            k = 1
+
+                        a, b, c, d = int(a), int(b), 1, 0
+
+                        while n:
+                            if n & 1:
+                                c, d = a*c - b*d, b*c + a*d
+                                n -= 1
+                            a, b = a*a - b*b, 2*a*b
+                            n //= 2
+
+                        I = S.ImaginaryUnit
+
+                        if k == 1:
+                            return c + I*d
+                        else:
+                            return Integer(c)/k + I*d/k
+
+                p = other_terms
+                # (x + y)**3 -> x**3 + 3*x**2*y + 3*x*y**2 + y**3
+                # in this particular example:
+                # p = [x,y]; n = 3
+                # so now it's easy to get the correct result -- we get the
+                # coefficients first:
+                from sympy.ntheory.multinomial import multinomial_coefficients
+                from sympy.polys.polyutils import basic_from_dict
+                expansion_dict = multinomial_coefficients(len(p), n)
+                # in our example: {(3, 0): 1, (1, 2): 3, (0, 3): 1, (2, 1): 3}
+                # and now construct the expression.
+                return basic_from_dict(expansion_dict, *p)
+            else:
+                if n == 2:
+                    return Add(*[f*g for f in base.args for g in base.args])
+                else:
+                    multi = (base**(n - 1))._eval_expand_multinomial()
+                    if multi.is_Add:
+                        return Add(*[f*g for f in base.args
+                            for g in multi.args])
+                    else:
+                        # XXX can this ever happen if base was an Add?
+                        return Add(*[f*multi for f in base.args])
+        elif (exp.is_Rational and exp.p < 0 and base.is_Add and
+                abs(exp.p) > exp.q):
+            return 1 / self.func(base, -exp)._eval_expand_multinomial()
+        elif exp.is_Add and base.is_Number and (hints.get('force', False) or
+                base.is_zero is False or exp._all_nonneg_or_nonppos()):
+            #  a + b      a  b
+            #  n      --> n  n, where n, a, b are Numbers
+            # XXX should be in expand_power_exp?
+            coeff, tail = [], []
+            for term in exp.args:
+                if term.is_Number:
+                    coeff.append(self.func(base, term))
+                else:
+                    tail.append(term)
+            return Mul(*(coeff + [self.func(base, Add._from_args(tail))]))
+        else:
+            return result
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.exp.is_Integer:
+            from sympy.polys.polytools import poly
+
+            exp = self.exp
+            re_e, im_e = self.base.as_real_imag(deep=deep)
+            if not im_e:
+                return self, S.Zero
+            a, b = symbols('a b', cls=Dummy)
+            if exp >= 0:
+                if re_e.is_Number and im_e.is_Number:
+                    # We can be more efficient in this case
+                    expr = expand_multinomial(self.base**exp)
+                    if expr != self:
+                        return expr.as_real_imag()
+
+                expr = poly(
+                    (a + b)**exp)  # a = re, b = im; expr = (a + b*I)**exp
+            else:
+                mag = re_e**2 + im_e**2
+                re_e, im_e = re_e/mag, -im_e/mag
+                if re_e.is_Number and im_e.is_Number:
+                    # We can be more efficient in this case
+                    expr = expand_multinomial((re_e + im_e*S.ImaginaryUnit)**-exp)
+                    if expr != self:
+                        return expr.as_real_imag()
+
+                expr = poly((a + b)**-exp)
+
+            # Terms with even b powers will be real
+            r = [i for i in expr.terms() if not i[0][1] % 2]
+            re_part = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+            # Terms with odd b powers will be imaginary
+            r = [i for i in expr.terms() if i[0][1] % 4 == 1]
+            im_part1 = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+            r = [i for i in expr.terms() if i[0][1] % 4 == 3]
+            im_part3 = Add(*[cc*a**aa*b**bb for (aa, bb), cc in r])
+
+            return (re_part.subs({a: re_e, b: S.ImaginaryUnit*im_e}),
+            im_part1.subs({a: re_e, b: im_e}) + im_part3.subs({a: re_e, b: -im_e}))
+
+        from sympy.functions.elementary.trigonometric import atan2, cos, sin
+
+        if self.exp.is_Rational:
+            re_e, im_e = self.base.as_real_imag(deep=deep)
+
+            if im_e.is_zero and self.exp is S.Half:
+                if re_e.is_extended_nonnegative:
+                    return self, S.Zero
+                if re_e.is_extended_nonpositive:
+                    return S.Zero, (-self.base)**self.exp
+
+            # XXX: This is not totally correct since for x**(p/q) with
+            #      x being imaginary there are actually q roots, but
+            #      only a single one is returned from here.
+            r = self.func(self.func(re_e, 2) + self.func(im_e, 2), S.Half)
+
+            t = atan2(im_e, re_e)
+
+            rp, tp = self.func(r, self.exp), t*self.exp
+
+            return rp*cos(tp), rp*sin(tp)
+        elif self.base is S.Exp1:
+            from sympy.functions.elementary.exponential import exp
+            re_e, im_e = self.exp.as_real_imag()
+            if deep:
+                re_e = re_e.expand(deep, **hints)
+                im_e = im_e.expand(deep, **hints)
+            c, s = cos(im_e), sin(im_e)
+            return exp(re_e)*c, exp(re_e)*s
+        else:
+            from sympy.functions.elementary.complexes import im, re
+            if deep:
+                hints['complex'] = False
+
+                expanded = self.expand(deep, **hints)
+                if hints.get('ignore') == expanded:
+                    return None
+                else:
+                    return (re(expanded), im(expanded))
+            else:
+                return re(self), im(self)
+
+    def _eval_derivative(self, s):
+        from sympy.functions.elementary.exponential import log
+        dbase = self.base.diff(s)
+        dexp = self.exp.diff(s)
+        return self * (dexp * log(self.base) + dbase * self.exp/self.base)
+
+    def _eval_evalf(self, prec):
+        base, exp = self.as_base_exp()
+        if base == S.Exp1:
+            # Use mpmath function associated to class "exp":
+            from sympy.functions.elementary.exponential import exp as exp_function
+            return exp_function(self.exp, evaluate=False)._eval_evalf(prec)
+        base = base._evalf(prec)
+        if not exp.is_Integer:
+            exp = exp._evalf(prec)
+        if exp.is_negative and base.is_number and base.is_extended_real is False:
+            base = base.conjugate() / (base * base.conjugate())._evalf(prec)
+            exp = -exp
+            return self.func(base, exp).expand()
+        return self.func(base, exp)
+
+    def _eval_is_polynomial(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return bool(self.base._eval_is_polynomial(syms) and
+                self.exp.is_Integer and (self.exp >= 0))
+        else:
+            return True
+
+    def _eval_is_rational(self):
+        # The evaluation of self.func below can be very expensive in the case
+        # of integer**integer if the exponent is large.  We should try to exit
+        # before that if possible:
+        if (self.exp.is_integer and self.base.is_rational
+                and fuzzy_not(fuzzy_and([self.exp.is_negative, self.base.is_zero]))):
+            return True
+        p = self.func(*self.as_base_exp())  # in case it's unevaluated
+        if not p.is_Pow:
+            return p.is_rational
+        b, e = p.as_base_exp()
+        if e.is_Rational and b.is_Rational:
+            # we didn't check that e is not an Integer
+            # because Rational**Integer autosimplifies
+            return False
+        if e.is_integer:
+            if b.is_rational:
+                if fuzzy_not(b.is_zero) or e.is_nonnegative:
+                    return True
+                if b == e:  # always rational, even for 0**0
+                    return True
+            elif b.is_irrational:
+                return e.is_zero
+        if b is S.Exp1:
+            if e.is_rational and e.is_nonzero:
+                return False
+
+    def _eval_is_algebraic(self):
+        def _is_one(expr):
+            try:
+                return (expr - 1).is_zero
+            except ValueError:
+                # when the operation is not allowed
+                return False
+
+        if self.base.is_zero or _is_one(self.base):
+            return True
+        elif self.base is S.Exp1:
+            s = self.func(*self.args)
+            if s.func == self.func:
+                if self.exp.is_nonzero:
+                    if self.exp.is_algebraic:
+                        return False
+                    elif (self.exp/S.Pi).is_rational:
+                        return False
+                    elif (self.exp/(S.ImaginaryUnit*S.Pi)).is_rational:
+                        return True
+            else:
+                return s.is_algebraic
+        elif self.exp.is_rational:
+            if self.base.is_algebraic is False:
+                return self.exp.is_zero
+            if self.base.is_zero is False:
+                if self.exp.is_nonzero:
+                    return self.base.is_algebraic
+                elif self.base.is_algebraic:
+                    return True
+            if self.exp.is_positive:
+                return self.base.is_algebraic
+        elif self.base.is_algebraic and self.exp.is_algebraic:
+            if ((fuzzy_not(self.base.is_zero)
+                and fuzzy_not(_is_one(self.base)))
+                or self.base.is_integer is False
+                or self.base.is_irrational):
+                return self.exp.is_rational
+
+    def _eval_is_rational_function(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return self.base._eval_is_rational_function(syms) and \
+                self.exp.is_Integer
+        else:
+            return True
+
+    def _eval_is_meromorphic(self, x, a):
+        # f**g is meromorphic if g is an integer and f is meromorphic.
+        # E**(log(f)*g) is meromorphic if log(f)*g is meromorphic
+        # and finite.
+        base_merom = self.base._eval_is_meromorphic(x, a)
+        exp_integer = self.exp.is_Integer
+        if exp_integer:
+            return base_merom
+
+        exp_merom = self.exp._eval_is_meromorphic(x, a)
+        if base_merom is False:
+            # f**g = E**(log(f)*g) may be meromorphic if the
+            # singularities of log(f) and g cancel each other,
+            # for example, if g = 1/log(f). Hence,
+            return False if exp_merom else None
+        elif base_merom is None:
+            return None
+
+        b = self.base.subs(x, a)
+        # b is extended complex as base is meromorphic.
+        # log(base) is finite and meromorphic when b != 0, zoo.
+        b_zero = b.is_zero
+        if b_zero:
+            log_defined = False
+        else:
+            log_defined = fuzzy_and((b.is_finite, fuzzy_not(b_zero)))
+
+        if log_defined is False: # zero or pole of base
+            return exp_integer  # False or None
+        elif log_defined is None:
+            return None
+
+        if not exp_merom:
+            return exp_merom  # False or None
+
+        return self.exp.subs(x, a).is_finite
+
+    def _eval_is_algebraic_expr(self, syms):
+        if self.exp.has(*syms):
+            return False
+
+        if self.base.has(*syms):
+            return self.base._eval_is_algebraic_expr(syms) and \
+                self.exp.is_Rational
+        else:
+            return True
+
+    def _eval_rewrite_as_exp(self, base, expo, **kwargs):
+        from sympy.functions.elementary.exponential import exp, log
+
+        if base.is_zero or base.has(exp) or expo.has(exp):
+            return base**expo
+
+        evaluate = expo.has(Symbol)
+
+        if base.has(Symbol):
+            # delay evaluation if expo is non symbolic
+            # (as exp(x*log(5)) automatically reduces to x**5)
+            if global_parameters.exp_is_pow:
+                return Pow(S.Exp1, log(base)*expo, evaluate=evaluate)
+            else:
+                return exp(log(base)*expo, evaluate=evaluate)
+
+        else:
+            from sympy.functions.elementary.complexes import arg, Abs
+            return exp((log(Abs(base)) + S.ImaginaryUnit*arg(base))*expo)
+
+    def as_numer_denom(self):
+        if not self.is_commutative:
+            return self, S.One
+        base, exp = self.as_base_exp()
+        n, d = base.as_numer_denom()
+        # this should be the same as ExpBase.as_numer_denom wrt
+        # exponent handling
+        neg_exp = exp.is_negative
+        if exp.is_Mul and not neg_exp and not exp.is_positive:
+            neg_exp = exp.could_extract_minus_sign()
+        int_exp = exp.is_integer
+        # the denominator cannot be separated from the numerator if
+        # its sign is unknown unless the exponent is an integer, e.g.
+        # sqrt(a/b) != sqrt(a)/sqrt(b) when a=1 and b=-1. But if the
+        # denominator is negative the numerator and denominator can
+        # be negated and the denominator (now positive) separated.
+        if not (d.is_extended_real or int_exp):
+            n = base
+            d = S.One
+        dnonpos = d.is_nonpositive
+        if dnonpos:
+            n, d = -n, -d
+        elif dnonpos is None and not int_exp:
+            n = base
+            d = S.One
+        if neg_exp:
+            n, d = d, n
+            exp = -exp
+        if exp.is_infinite:
+            if n is S.One and d is not S.One:
+                return n, self.func(d, exp)
+            if n is not S.One and d is S.One:
+                return self.func(n, exp), d
+        return self.func(n, exp), self.func(d, exp)
+
+    def matches(self, expr, repl_dict=None, old=False):
+        expr = _sympify(expr)
+        if repl_dict is None:
+            repl_dict = {}
+
+        # special case, pattern = 1 and expr.exp can match to 0
+        if expr is S.One:
+            d = self.exp.matches(S.Zero, repl_dict)
+            if d is not None:
+                return d
+
+        # make sure the expression to be matched is an Expr
+        if not isinstance(expr, Expr):
+            return None
+
+        b, e = expr.as_base_exp()
+
+        # special case number
+        sb, se = self.as_base_exp()
+        if sb.is_Symbol and se.is_Integer and expr:
+            if e.is_rational:
+                return sb.matches(b**(e/se), repl_dict)
+            return sb.matches(expr**(1/se), repl_dict)
+
+        d = repl_dict.copy()
+        d = self.base.matches(b, d)
+        if d is None:
+            return None
+
+        d = self.exp.xreplace(d).matches(e, d)
+        if d is None:
+            return Expr.matches(self, expr, repl_dict)
+        return d
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE! This function is an important part of the gruntz algorithm
+        #       for computing limits. It has to return a generalized power
+        #       series with coefficients in C(log, log(x)). In more detail:
+        # It has to return an expression
+        #     c_0*x**e_0 + c_1*x**e_1 + ... (finitely many terms)
+        # where e_i are numbers (not necessarily integers) and c_i are
+        # expressions involving only numbers, the log function, and log(x).
+        # The series expansion of b**e is computed as follows:
+        # 1) We express b as f*(1 + g) where f is the leading term of b.
+        #    g has order O(x**d) where d is strictly positive.
+        # 2) Then b**e = (f**e)*((1 + g)**e).
+        #    (1 + g)**e is computed using binomial series.
+        from sympy.functions.elementary.exponential import exp, log
+        from sympy.series.limits import limit
+        from sympy.series.order import Order
+        from sympy.core.sympify import sympify
+        if self.base is S.Exp1:
+            e_series = self.exp.nseries(x, n=n, logx=logx)
+            if e_series.is_Order:
+                return 1 + e_series
+            e0 = limit(e_series.removeO(), x, 0)
+            if e0 is S.NegativeInfinity:
+                return Order(x**n, x)
+            if e0 is S.Infinity:
+                return self
+            t = e_series - e0
+            exp_series = term = exp(e0)
+            # series of exp(e0 + t) in t
+            for i in range(1, n):
+                term *= t/i
+                term = term.nseries(x, n=n, logx=logx)
+                exp_series += term
+            exp_series += Order(t**n, x)
+            from sympy.simplify.powsimp import powsimp
+            return powsimp(exp_series, deep=True, combine='exp')
+        from sympy.simplify.powsimp import powdenest
+        from .numbers import _illegal
+        self = powdenest(self, force=True).trigsimp()
+        b, e = self.as_base_exp()
+
+        if e.has(*_illegal):
+            raise PoleError()
+
+        if e.has(x):
+            return exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+        if logx is not None and b.has(log):
+            from .symbol import Wild
+            c, ex = symbols('c, ex', cls=Wild, exclude=[x])
+            b = b.replace(log(c*x**ex), log(c) + ex*logx)
+            self = b**e
+
+        b = b.removeO()
+        try:
+            from sympy.functions.special.gamma_functions import polygamma
+            if b.has(polygamma, S.EulerGamma) and logx is not None:
+                raise ValueError()
+            _, m = b.leadterm(x)
+        except (ValueError, NotImplementedError, PoleError):
+            b = b._eval_nseries(x, n=max(2, n), logx=logx, cdir=cdir).removeO()
+            if b.has(S.NaN, S.ComplexInfinity):
+                raise NotImplementedError()
+            _, m = b.leadterm(x)
+
+        if e.has(log):
+            from sympy.simplify.simplify import logcombine
+            e = logcombine(e).cancel()
+
+        if not (m.is_zero or e.is_number and e.is_real):
+            if self == self._eval_as_leading_term(x, logx=logx, cdir=cdir):
+                res = exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+                if res == exp(e*log(b)):
+                    return self
+                return res
+
+        f = b.as_leading_term(x, logx=logx)
+        g = (_mexpand(b) - f).cancel()
+        g = g/f
+        if not m.is_number:
+            raise NotImplementedError()
+        maxpow = n - m*e
+        if maxpow.has(Symbol):
+            maxpow = sympify(n)
+
+        if maxpow.is_negative:
+            return Order(x**(m*e), x)
+
+        if g.is_zero:
+            r = f**e
+            if r != self:
+                r += Order(x**n, x)
+            return r
+
+        def coeff_exp(term, x):
+            coeff, exp = S.One, S.Zero
+            for factor in Mul.make_args(term):
+                if factor.has(x):
+                    base, exp = factor.as_base_exp()
+                    if base != x:
+                        try:
+                            return term.leadterm(x)
+                        except ValueError:
+                            return term, S.Zero
+                else:
+                    coeff *= factor
+            return coeff, exp
+
+        def mul(d1, d2):
+            res = {}
+            for e1, e2 in product(d1, d2):
+                ex = e1 + e2
+                if ex < maxpow:
+                    res[ex] = res.get(ex, S.Zero) + d1[e1]*d2[e2]
+            return res
+
+        try:
+            c, d = g.leadterm(x, logx=logx)
+        except (ValueError, NotImplementedError):
+            if limit(g/x**maxpow, x, 0) == 0:
+                # g has higher order zero
+                return f**e + e*f**e*g  # first term of binomial series
+            else:
+                raise NotImplementedError()
+        if c.is_Float and d == S.Zero:
+            # Convert floats like 0.5 to exact SymPy numbers like S.Half, to
+            # prevent rounding errors which can induce wrong values of d leading
+            # to a NotImplementedError being returned from the block below.
+            g = g.replace(lambda x: x.is_Float, lambda x: Rational(x))
+            _, d = g.leadterm(x, logx=logx)
+        if not d.is_positive:
+            g = g.simplify()
+            if g.is_zero:
+                return f**e
+            _, d = g.leadterm(x, logx=logx)
+            if not d.is_positive:
+                g = ((b - f)/f).expand()
+                _, d = g.leadterm(x, logx=logx)
+                if not d.is_positive:
+                    raise NotImplementedError()
+
+        from sympy.functions.elementary.integers import ceiling
+        gpoly = g._eval_nseries(x, n=ceiling(maxpow), logx=logx, cdir=cdir).removeO()
+        gterms = {}
+
+        for term in Add.make_args(gpoly):
+            co1, e1 = coeff_exp(term, x)
+            gterms[e1] = gterms.get(e1, S.Zero) + co1
+
+        k = S.One
+        terms = {S.Zero: S.One}
+        tk = gterms
+
+        from sympy.functions.combinatorial.factorials import factorial, ff
+
+        while (k*d - maxpow).is_negative:
+            coeff = ff(e, k)/factorial(k)
+            for ex in tk:
+                terms[ex] = terms.get(ex, S.Zero) + coeff*tk[ex]
+            tk = mul(tk, gterms)
+            k += S.One
+
+        from sympy.functions.elementary.complexes import im
+
+        if not e.is_integer and m.is_zero and f.is_negative:
+            ndir = (b - f).dir(x, cdir)
+            if im(ndir).is_negative:
+                inco, inex = coeff_exp(f**e*(-1)**(-2*e), x)
+            elif im(ndir).is_zero:
+                inco, inex = coeff_exp(exp(e*log(b)).as_leading_term(x, logx=logx, cdir=cdir), x)
+            else:
+                inco, inex = coeff_exp(f**e, x)
+        else:
+            inco, inex = coeff_exp(f**e, x)
+        res = S.Zero
+
+        for e1 in terms:
+            ex = e1 + inex
+            res += terms[e1]*inco*x**(ex)
+
+        if not (e.is_integer and e.is_positive and (e*d - n).is_nonpositive and
+                res == _mexpand(self)):
+            try:
+                res += Order(x**n, x)
+            except NotImplementedError:
+                return exp(e*log(b))._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.functions.elementary.exponential import exp, log
+        e = self.exp
+        b = self.base
+        if self.base is S.Exp1:
+            arg = e.as_leading_term(x, logx=logx)
+            arg0 = arg.subs(x, 0)
+            if arg0 is S.NaN:
+                arg0 = arg.limit(x, 0)
+            if arg0.is_infinite is False:
+                return S.Exp1**arg0
+            raise PoleError("Cannot expand %s around 0" % (self))
+        elif e.has(x):
+            lt = exp(e * log(b))
+            return lt.as_leading_term(x, logx=logx, cdir=cdir)
+        else:
+            from sympy.functions.elementary.complexes import im
+            try:
+                f = b.as_leading_term(x, logx=logx, cdir=cdir)
+            except PoleError:
+                return self
+            if not e.is_integer and f.is_negative and not f.has(x):
+                ndir = (b - f).dir(x, cdir)
+                if im(ndir).is_negative:
+                    # Normally, f**e would evaluate to exp(e*log(f)) but on branch cuts
+                    # an other value is expected through the following computation
+                    # exp(e*(log(f) - 2*pi*I)) == f**e*exp(-2*e*pi*I) == f**e*(-1)**(-2*e).
+                    return self.func(f, e) * (-1)**(-2*e)
+                elif im(ndir).is_zero:
+                    log_leadterm = log(b)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+                    if log_leadterm.is_infinite is False:
+                        return exp(e*log_leadterm)
+            return self.func(f, e)
+
+    @cacheit
+    def _taylor_term(self, n, x, *previous_terms): # of (1 + x)**e
+        from sympy.functions.combinatorial.factorials import binomial
+        return binomial(self.exp, n) * self.func(x, n)
+
+    def taylor_term(self, n, x, *previous_terms):
+        if self.base is not S.Exp1:
+            return super().taylor_term(n, x, *previous_terms)
+        if n < 0:
+            return S.Zero
+        if n == 0:
+            return S.One
+        from .sympify import sympify
+        x = sympify(x)
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return p * x / n
+        from sympy.functions.combinatorial.factorials import factorial
+        return x**n/factorial(n)
+
+    def _eval_rewrite_as_sin(self, base, exp, **hints):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.trigonometric import sin
+            return sin(S.ImaginaryUnit*self.exp + S.Pi/2) - S.ImaginaryUnit*sin(S.ImaginaryUnit*self.exp)
+
+    def _eval_rewrite_as_cos(self, base, exp, **hints):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.trigonometric import cos
+            return cos(S.ImaginaryUnit*self.exp) + S.ImaginaryUnit*cos(S.ImaginaryUnit*self.exp + S.Pi/2)
+
+    def _eval_rewrite_as_tanh(self, base, exp, **hints):
+        if self.base is S.Exp1:
+            from sympy.functions.elementary.hyperbolic import tanh
+            return (1 + tanh(self.exp/2))/(1 - tanh(self.exp/2))
+
+    def _eval_rewrite_as_sqrt(self, base, exp, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin, cos
+        if base is not S.Exp1:
+            return None
+        if exp.is_Mul:
+            coeff = exp.coeff(S.Pi * S.ImaginaryUnit)
+            if coeff and coeff.is_number:
+                cosine, sine = cos(S.Pi*coeff), sin(S.Pi*coeff)
+                if not isinstance(cosine, cos) and not isinstance (sine, sin):
+                    return cosine + S.ImaginaryUnit*sine
+
+    def as_content_primitive(self, radical=False, clear=True):
+        """Return the tuple (R, self/R) where R is the positive Rational
+        extracted from self.
+
+        Examples
+        ========
+
+        >>> from sympy import sqrt
+        >>> sqrt(4 + 4*sqrt(2)).as_content_primitive()
+        (2, sqrt(1 + sqrt(2)))
+        >>> sqrt(3 + 3*sqrt(2)).as_content_primitive()
+        (1, sqrt(3)*sqrt(1 + sqrt(2)))
+
+        >>> from sympy import expand_power_base, powsimp, Mul
+        >>> from sympy.abc import x, y
+
+        >>> ((2*x + 2)**2).as_content_primitive()
+        (4, (x + 1)**2)
+        >>> (4**((1 + y)/2)).as_content_primitive()
+        (2, 4**(y/2))
+        >>> (3**((1 + y)/2)).as_content_primitive()
+        (1, 3**((y + 1)/2))
+        >>> (3**((5 + y)/2)).as_content_primitive()
+        (9, 3**((y + 1)/2))
+        >>> eq = 3**(2 + 2*x)
+        >>> powsimp(eq) == eq
+        True
+        >>> eq.as_content_primitive()
+        (9, 3**(2*x))
+        >>> powsimp(Mul(*_))
+        3**(2*x + 2)
+
+        >>> eq = (2 + 2*x)**y
+        >>> s = expand_power_base(eq); s.is_Mul, s
+        (False, (2*x + 2)**y)
+        >>> eq.as_content_primitive()
+        (1, (2*(x + 1))**y)
+        >>> s = expand_power_base(_[1]); s.is_Mul, s
+        (True, 2**y*(x + 1)**y)
+
+        See docstring of Expr.as_content_primitive for more examples.
+        """
+
+        b, e = self.as_base_exp()
+        b = _keep_coeff(*b.as_content_primitive(radical=radical, clear=clear))
+        ce, pe = e.as_content_primitive(radical=radical, clear=clear)
+        if b.is_Rational:
+            #e
+            #= ce*pe
+            #= ce*(h + t)
+            #= ce*h + ce*t
+            #=> self
+            #= b**(ce*h)*b**(ce*t)
+            #= b**(cehp/cehq)*b**(ce*t)
+            #= b**(iceh + r/cehq)*b**(ce*t)
+            #= b**(iceh)*b**(r/cehq)*b**(ce*t)
+            #= b**(iceh)*b**(ce*t + r/cehq)
+            h, t = pe.as_coeff_Add()
+            if h.is_Rational and b != S.Zero:
+                ceh = ce*h
+                c = self.func(b, ceh)
+                r = S.Zero
+                if not c.is_Rational:
+                    iceh, r = divmod(ceh.p, ceh.q)
+                    c = self.func(b, iceh)
+                return c, self.func(b, _keep_coeff(ce, t + r/ce/ceh.q))
+        e = _keep_coeff(ce, pe)
+        # b**e = (h*t)**e = h**e*t**e = c*m*t**e
+        if e.is_Rational and b.is_Mul:
+            h, t = b.as_content_primitive(radical=radical, clear=clear)  # h is positive
+            c, m = self.func(h, e).as_coeff_Mul()  # so c is positive
+            m, me = m.as_base_exp()
+            if m is S.One or me == e:  # probably always true
+                # return the following, not return c, m*Pow(t, e)
+                # which would change Pow into Mul; we let SymPy
+                # decide what to do by using the unevaluated Mul, e.g
+                # should it stay as sqrt(2 + 2*sqrt(5)) or become
+                # sqrt(2)*sqrt(1 + sqrt(5))
+                return c, self.func(_keep_coeff(m, t), e)
+        return S.One, self.func(b, e)
+
+    def is_constant(self, *wrt, **flags):
+        expr = self
+        if flags.get('simplify', True):
+            expr = expr.simplify()
+        b, e = expr.as_base_exp()
+        bz = b.equals(0)
+        if bz:  # recalculate with assumptions in case it's unevaluated
+            new = b**e
+            if new != expr:
+                return new.is_constant()
+        econ = e.is_constant(*wrt)
+        bcon = b.is_constant(*wrt)
+        if bcon:
+            if econ:
+                return True
+            bz = b.equals(0)
+            if bz is False:
+                return False
+        elif bcon is None:
+            return None
+
+        return e.equals(0)
+
+    def _eval_difference_delta(self, n, step):
+        b, e = self.args
+        if e.has(n) and not b.has(n):
+            new_e = e.subs(n, n + step)
+            return (b**(new_e - e) - 1) * self
+
+power = Dispatcher('power')
+power.add((object, object), Pow)
+
+from .add import Add
+from .numbers import Integer, Rational
+from .mul import Mul, _keep_coeff
+from .symbol import Symbol, Dummy, symbols
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/random.py b/.venv/lib/python3.12/site-packages/sympy/core/random.py
new file mode 100644
index 0000000000000000000000000000000000000000..c02986283523b39462a1e2c0b97e3fb230cff100
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/random.py
@@ -0,0 +1,227 @@
+"""
+When you need to use random numbers in SymPy library code, import from here
+so there is only one generator working for SymPy. Imports from here should
+behave the same as if they were being imported from Python's random module.
+But only the routines currently used in SymPy are included here. To use others
+import ``rng`` and access the method directly. For example, to capture the
+current state of the generator use ``rng.getstate()``.
+
+There is intentionally no Random to import from here. If you want
+to control the state of the generator, import ``seed`` and call it
+with or without an argument to set the state.
+
+Examples
+========
+
+>>> from sympy.core.random import random, seed
+>>> assert random() < 1
+>>> seed(1); a = random()
+>>> b = random()
+>>> seed(1); c = random()
+>>> assert a == c
+>>> assert a != b  # remote possibility this will fail
+
+"""
+from sympy.utilities.iterables import is_sequence
+from sympy.utilities.misc import as_int
+
+import random as _random
+rng = _random.Random()
+
+choice = rng.choice
+random = rng.random
+randint = rng.randint
+randrange = rng.randrange
+sample = rng.sample
+# seed = rng.seed
+shuffle = rng.shuffle
+uniform = rng.uniform
+
+_assumptions_rng = _random.Random()
+_assumptions_shuffle = _assumptions_rng.shuffle
+
+
+def seed(a=None, version=2):
+    rng.seed(a=a, version=version)
+    _assumptions_rng.seed(a=a, version=version)
+
+
+def random_complex_number(a=2, b=-1, c=3, d=1, rational=False, tolerance=None):
+    """
+    Return a random complex number.
+
+    To reduce chance of hitting branch cuts or anything, we guarantee
+    b <= Im z <= d, a <= Re z <= c
+
+    When rational is True, a rational approximation to a random number
+    is obtained within specified tolerance, if any.
+    """
+    from sympy.core.numbers import I
+    from sympy.simplify.simplify import nsimplify
+    A, B = uniform(a, c), uniform(b, d)
+    if not rational:
+        return A + I*B
+    return (nsimplify(A, rational=True, tolerance=tolerance) +
+        I*nsimplify(B, rational=True, tolerance=tolerance))
+
+
+def verify_numerically(f, g, z=None, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that f and g agree when evaluated in the argument z.
+
+    If z is None, all symbols will be tested. This routine does not test
+    whether there are Floats present with precision higher than 15 digits
+    so if there are, your results may not be what you expect due to round-
+    off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, cos
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import verify_numerically as tn
+    >>> tn(sin(x)**2 + cos(x)**2, 1, x)
+    True
+    """
+    from sympy.core.symbol import Symbol
+    from sympy.core.sympify import sympify
+    from sympy.core.numbers import comp
+    f, g = (sympify(i) for i in (f, g))
+    if z is None:
+        z = f.free_symbols | g.free_symbols
+    elif isinstance(z, Symbol):
+        z = [z]
+    reps = list(zip(z, [random_complex_number(a, b, c, d) for _ in z]))
+    z1 = f.subs(reps).n()
+    z2 = g.subs(reps).n()
+    return comp(z1, z2, tol)
+
+
+def test_derivative_numerically(f, z, tol=1.0e-6, a=2, b=-1, c=3, d=1):
+    """
+    Test numerically that the symbolically computed derivative of f
+    with respect to z is correct.
+
+    This routine does not test whether there are Floats present with
+    precision higher than 15 digits so if there are, your results may
+    not be what you expect due to round-off errors.
+
+    Examples
+    ========
+
+    >>> from sympy import sin
+    >>> from sympy.abc import x
+    >>> from sympy.core.random import test_derivative_numerically as td
+    >>> td(sin(x), x)
+    True
+    """
+    from sympy.core.numbers import comp
+    from sympy.core.function import Derivative
+    z0 = random_complex_number(a, b, c, d)
+    f1 = f.diff(z).subs(z, z0)
+    f2 = Derivative(f, z).doit_numerically(z0)
+    return comp(f1.n(), f2.n(), tol)
+
+
+def _randrange(seed=None):
+    """Return a randrange generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randrange
+    >>> rr = _randrange()
+    >>> rr(1000) # doctest: +SKIP
+    999
+    >>> rr = _randrange(3)
+    >>> rr(1000) # doctest: +SKIP
+    238
+    >>> rr = _randrange([0, 5, 1, 3, 4])
+    >>> rr(3), rr(3)
+    (0, 1)
+    """
+    if seed is None:
+        return randrange
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randrange
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b=None, seq=seed):
+            if b is None:
+                a, b = 0, a
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 1:
+                raise ValueError('_randrange got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randrange sequence was too short')
+            if a <= x < b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randrange got an unexpected seed')
+
+
+def _randint(seed=None):
+    """Return a randint generator.
+
+    ``seed`` can be
+
+    * None - return randomly seeded generator
+    * int - return a generator seeded with the int
+    * list - the values to be returned will be taken from the list
+      in the order given; the provided list is not modified.
+
+    Examples
+    ========
+
+    >>> from sympy.core.random import _randint
+    >>> ri = _randint()
+    >>> ri(1, 1000) # doctest: +SKIP
+    999
+    >>> ri = _randint(3)
+    >>> ri(1, 1000) # doctest: +SKIP
+    238
+    >>> ri = _randint([0, 5, 1, 2, 4])
+    >>> ri(1, 3), ri(1, 3)
+    (1, 2)
+    """
+    if seed is None:
+        return randint
+    elif isinstance(seed, int):
+        rng.seed(seed)
+        return randint
+    elif is_sequence(seed):
+        seed = list(seed)  # make a copy
+        seed.reverse()
+
+        def give(a, b, seq=seed):
+            a, b = as_int(a), as_int(b)
+            w = b - a
+            if w < 0:
+                raise ValueError('_randint got empty range')
+            try:
+                x = seq.pop()
+            except IndexError:
+                raise ValueError('_randint sequence was too short')
+            if a <= x <= b:
+                return x
+            else:
+                return give(a, b, seq)
+        return give
+    else:
+        raise ValueError('_randint got an unexpected seed')
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/relational.py b/.venv/lib/python3.12/site-packages/sympy/core/relational.py
new file mode 100644
index 0000000000000000000000000000000000000000..28bf039c9be67a6f5cd6f11df1968961c0760373
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/relational.py
@@ -0,0 +1,1622 @@
+from __future__ import annotations
+
+from .basic import Atom, Basic
+from .coreerrors import LazyExceptionMessage
+from .sorting import ordered
+from .evalf import EvalfMixin
+from .function import AppliedUndef
+from .numbers import int_valued
+from .singleton import S
+from .sympify import _sympify, SympifyError
+from .parameters import global_parameters
+from .logic import fuzzy_bool, fuzzy_xor, fuzzy_and, fuzzy_not
+from sympy.logic.boolalg import Boolean, BooleanAtom
+from sympy.utilities.iterables import sift
+from sympy.utilities.misc import filldedent
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+
+__all__ = (
+    'Rel', 'Eq', 'Ne', 'Lt', 'Le', 'Gt', 'Ge',
+    'Relational', 'Equality', 'Unequality', 'StrictLessThan', 'LessThan',
+    'StrictGreaterThan', 'GreaterThan',
+)
+
+from .expr import Expr
+from sympy.multipledispatch import dispatch
+from .containers import Tuple
+from .symbol import Symbol
+
+
+def _nontrivBool(side):
+    return isinstance(side, Boolean) and \
+           not isinstance(side, Atom)
+
+
+# Note, see issue 4986.  Ideally, we wouldn't want to subclass both Boolean
+# and Expr.
+# from .. import Expr
+
+
+def _canonical(cond):
+    # return a condition in which all relationals are canonical
+    reps = {r: r.canonical for r in cond.atoms(Relational)}
+    return cond.xreplace(reps)
+    # XXX: AttributeError was being caught here but it wasn't triggered by any of
+    # the tests so I've removed it...
+
+
+def _canonical_coeff(rel):
+    # return -2*x + 1 < 0 as x > 1/2
+    # XXX make this part of Relational.canonical?
+    rel = rel.canonical
+    if not rel.is_Relational or rel.rhs.is_Boolean:
+        return rel  # Eq(x, True)
+    if not isinstance(rel.lhs, Expr):
+        return rel.reversed  # e.g.: Eq(True, x) -> Eq(x, True)
+    b, l = rel.lhs.as_coeff_Add(rational=True)
+    m, lhs = l.as_coeff_Mul(rational=True)
+    rhs = (rel.rhs - b)/m
+    if m < 0:
+        return rel.reversed.func(lhs, rhs)
+    return rel.func(lhs, rhs)
+
+
+class Relational(Boolean, EvalfMixin):
+    """Base class for all relation types.
+
+    Explanation
+    ===========
+
+    Subclasses of Relational should generally be instantiated directly, but
+    Relational can be instantiated with a valid ``rop`` value to dispatch to
+    the appropriate subclass.
+
+    Parameters
+    ==========
+
+    rop : str or None
+        Indicates what subclass to instantiate.  Valid values can be found
+        in the keys of Relational.ValidRelationOperator.
+
+    Examples
+    ========
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> Rel(y, x + x**2, '==')
+    Eq(y, x**2 + x)
+
+    A relation's type can be defined upon creation using ``rop``.
+    The relation type of an existing expression can be obtained
+    using its ``rel_op`` property.
+    Here is a table of all the relation types, along with their
+    ``rop`` and ``rel_op`` values:
+
+    +---------------------+----------------------------+------------+
+    |Relation             |``rop``                     |``rel_op``  |
+    +=====================+============================+============+
+    |``Equality``         |``==`` or ``eq`` or ``None``|``==``      |
+    +---------------------+----------------------------+------------+
+    |``Unequality``       |``!=`` or ``ne``            |``!=``      |
+    +---------------------+----------------------------+------------+
+    |``GreaterThan``      |``>=`` or ``ge``            |``>=``      |
+    +---------------------+----------------------------+------------+
+    |``LessThan``         |``<=`` or ``le``            |``<=``      |
+    +---------------------+----------------------------+------------+
+    |``StrictGreaterThan``|``>`` or ``gt``             |``>``       |
+    +---------------------+----------------------------+------------+
+    |``StrictLessThan``   |``<`` or ``lt``             |``<``       |
+    +---------------------+----------------------------+------------+
+
+    For example, setting ``rop`` to ``==`` produces an
+    ``Equality`` relation, ``Eq()``.
+    So does setting ``rop`` to ``eq``, or leaving ``rop`` unspecified.
+    That is, the first three ``Rel()`` below all produce the same result.
+    Using a ``rop`` from a different row in the table produces a
+    different relation type.
+    For example, the fourth ``Rel()`` below using ``lt`` for ``rop``
+    produces a ``StrictLessThan`` inequality:
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> Rel(y, x + x**2, '==')
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2, 'eq')
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2)
+        Eq(y, x**2 + x)
+    >>> Rel(y, x + x**2, 'lt')
+        y < x**2 + x
+
+    To obtain the relation type of an existing expression,
+    get its ``rel_op`` property.
+    For example, ``rel_op`` is ``==`` for the ``Equality`` relation above,
+    and ``<`` for the strict less than inequality above:
+
+    >>> from sympy import Rel
+    >>> from sympy.abc import x, y
+    >>> my_equality = Rel(y, x + x**2, '==')
+    >>> my_equality.rel_op
+        '=='
+    >>> my_inequality = Rel(y, x + x**2, 'lt')
+    >>> my_inequality.rel_op
+        '<'
+
+    """
+    __slots__ = ()
+
+    ValidRelationOperator: dict[str | None, type[Relational]] = {}
+
+    is_Relational = True
+
+    # ValidRelationOperator - Defined below, because the necessary classes
+    #   have not yet been defined
+
+    def __new__(cls, lhs, rhs, rop=None, **assumptions):
+        # If called by a subclass, do nothing special and pass on to Basic.
+        if cls is not Relational:
+            return Basic.__new__(cls, lhs, rhs, **assumptions)
+
+        # XXX: Why do this? There should be a separate function to make a
+        # particular subclass of Relational from a string.
+        #
+        # If called directly with an operator, look up the subclass
+        # corresponding to that operator and delegate to it
+        cls = cls.ValidRelationOperator.get(rop, None)
+        if cls is None:
+            raise ValueError("Invalid relational operator symbol: %r" % rop)
+
+        if not issubclass(cls, (Eq, Ne)):
+            # validate that Booleans are not being used in a relational
+            # other than Eq/Ne;
+            # Note: Symbol is a subclass of Boolean but is considered
+            # acceptable here.
+            if any(map(_nontrivBool, (lhs, rhs))):
+                raise TypeError(filldedent('''
+                    A Boolean argument can only be used in
+                    Eq and Ne; all other relationals expect
+                    real expressions.
+                '''))
+
+        return cls(lhs, rhs, **assumptions)
+
+    @property
+    def lhs(self):
+        """The left-hand side of the relation."""
+        return self._args[0]
+
+    @property
+    def rhs(self):
+        """The right-hand side of the relation."""
+        return self._args[1]
+
+    @property
+    def reversed(self):
+        """Return the relationship with sides reversed.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.reversed
+        Eq(1, x)
+        >>> x < 1
+        x < 1
+        >>> _.reversed
+        1 > x
+        """
+        ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne}
+        a, b = self.args
+        return Relational.__new__(ops.get(self.func, self.func), b, a)
+
+    @property
+    def reversedsign(self):
+        """Return the relationship with signs reversed.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.reversedsign
+        Eq(-x, -1)
+        >>> x < 1
+        x < 1
+        >>> _.reversedsign
+        -x > -1
+        """
+        a, b = self.args
+        if not (isinstance(a, BooleanAtom) or isinstance(b, BooleanAtom)):
+            ops = {Eq: Eq, Gt: Lt, Ge: Le, Lt: Gt, Le: Ge, Ne: Ne}
+            return Relational.__new__(ops.get(self.func, self.func), -a, -b)
+        else:
+            return self
+
+    @property
+    def negated(self):
+        """Return the negated relationship.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x, 1)
+        Eq(x, 1)
+        >>> _.negated
+        Ne(x, 1)
+        >>> x < 1
+        x < 1
+        >>> _.negated
+        x >= 1
+
+        Notes
+        =====
+
+        This works more or less identical to ``~``/``Not``. The difference is
+        that ``negated`` returns the relationship even if ``evaluate=False``.
+        Hence, this is useful in code when checking for e.g. negated relations
+        to existing ones as it will not be affected by the `evaluate` flag.
+
+        """
+        ops = {Eq: Ne, Ge: Lt, Gt: Le, Le: Gt, Lt: Ge, Ne: Eq}
+        # If there ever will be new Relational subclasses, the following line
+        # will work until it is properly sorted out
+        # return ops.get(self.func, lambda a, b, evaluate=False: ~(self.func(a,
+        #      b, evaluate=evaluate)))(*self.args, evaluate=False)
+        return Relational.__new__(ops.get(self.func), *self.args)
+
+    @property
+    def weak(self):
+        """return the non-strict version of the inequality or self
+
+        EXAMPLES
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x < 1).weak
+        x <= 1
+        >>> _.weak
+        x <= 1
+        """
+        return self
+
+    @property
+    def strict(self):
+        """return the strict version of the inequality or self
+
+        EXAMPLES
+        ========
+
+        >>> from sympy.abc import x
+        >>> (x <= 1).strict
+        x < 1
+        >>> _.strict
+        x < 1
+        """
+        return self
+
+    def _eval_evalf(self, prec):
+        return self.func(*[s._evalf(prec) for s in self.args])
+
+    @property
+    def canonical(self):
+        """Return a canonical form of the relational by putting a
+        number on the rhs, canonically removing a sign or else
+        ordering the args canonically. No other simplification is
+        attempted.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import x, y
+        >>> x < 2
+        x < 2
+        >>> _.reversed.canonical
+        x < 2
+        >>> (-y < x).canonical
+        x > -y
+        >>> (-y > x).canonical
+        x < -y
+        >>> (-y < -x).canonical
+        x < y
+
+        The canonicalization is recursively applied:
+
+        >>> from sympy import Eq
+        >>> Eq(x < y, y > x).canonical
+        True
+        """
+        args = tuple([i.canonical if isinstance(i, Relational) else i for i in self.args])
+        if args != self.args:
+            r = self.func(*args)
+            if not isinstance(r, Relational):
+                return r
+        else:
+            r = self
+        if r.rhs.is_number:
+            if r.rhs.is_Number and r.lhs.is_Number and r.lhs > r.rhs:
+                r = r.reversed
+        elif r.lhs.is_number:
+            r = r.reversed
+        elif tuple(ordered(args)) != args:
+            r = r.reversed
+
+        LHS_CEMS = getattr(r.lhs, 'could_extract_minus_sign', None)
+        RHS_CEMS = getattr(r.rhs, 'could_extract_minus_sign', None)
+
+        if isinstance(r.lhs, BooleanAtom) or isinstance(r.rhs, BooleanAtom):
+            return r
+
+        # Check if first value has negative sign
+        if LHS_CEMS and LHS_CEMS():
+            return r.reversedsign
+        elif not r.rhs.is_number and RHS_CEMS and RHS_CEMS():
+            # Right hand side has a minus, but not lhs.
+            # How does the expression with reversed signs behave?
+            # This is so that expressions of the type
+            # Eq(x, -y) and Eq(-x, y)
+            # have the same canonical representation
+            expr1, _ = ordered([r.lhs, -r.rhs])
+            if expr1 != r.lhs:
+                return r.reversed.reversedsign
+
+        return r
+
+    def equals(self, other, failing_expression=False):
+        """Return True if the sides of the relationship are mathematically
+        identical and the type of relationship is the same.
+        If failing_expression is True, return the expression whose truth value
+        was unknown."""
+        if isinstance(other, Relational):
+            if other in (self, self.reversed):
+                return True
+            a, b = self, other
+            if a.func in (Eq, Ne) or b.func in (Eq, Ne):
+                if a.func != b.func:
+                    return False
+                left, right = [i.equals(j,
+                                        failing_expression=failing_expression)
+                               for i, j in zip(a.args, b.args)]
+                if left is True:
+                    return right
+                if right is True:
+                    return left
+                lr, rl = [i.equals(j, failing_expression=failing_expression)
+                          for i, j in zip(a.args, b.reversed.args)]
+                if lr is True:
+                    return rl
+                if rl is True:
+                    return lr
+                e = (left, right, lr, rl)
+                if all(i is False for i in e):
+                    return False
+                for i in e:
+                    if i not in (True, False):
+                        return i
+            else:
+                if b.func != a.func:
+                    b = b.reversed
+                if a.func != b.func:
+                    return False
+                left = a.lhs.equals(b.lhs,
+                                    failing_expression=failing_expression)
+                if left is False:
+                    return False
+                right = a.rhs.equals(b.rhs,
+                                     failing_expression=failing_expression)
+                if right is False:
+                    return False
+                if left is True:
+                    return right
+                return left
+
+    def _eval_simplify(self, **kwargs):
+        from .add import Add
+        from .expr import Expr
+        r = self
+        r = r.func(*[i.simplify(**kwargs) for i in r.args])
+        if r.is_Relational:
+            if not isinstance(r.lhs, Expr) or not isinstance(r.rhs, Expr):
+                return r
+            dif = r.lhs - r.rhs
+            # replace dif with a valid Number that will
+            # allow a definitive comparison with 0
+            v = None
+            if dif.is_comparable:
+                v = dif.n(2)
+                if any(i._prec == 1 for i in v.as_real_imag()):
+                    rv, iv = [i.n(2) for i in dif.as_real_imag()]
+                    v = rv + S.ImaginaryUnit*iv
+            elif dif.equals(0):  # XXX this is expensive
+                v = S.Zero
+            if v is not None:
+                r = r.func._eval_relation(v, S.Zero)
+            r = r.canonical
+            # If there is only one symbol in the expression,
+            # try to write it on a simplified form
+            free = list(filter(lambda x: x.is_real is not False, r.free_symbols))
+            if len(free) == 1:
+                try:
+                    from sympy.solvers.solveset import linear_coeffs
+                    x = free.pop()
+                    dif = r.lhs - r.rhs
+                    m, b = linear_coeffs(dif, x)
+                    if m.is_zero is False:
+                        if m.is_negative:
+                            # Dividing with a negative number, so change order of arguments
+                            # canonical will put the symbol back on the lhs later
+                            r = r.func(-b / m, x)
+                        else:
+                            r = r.func(x, -b / m)
+                    else:
+                        r = r.func(b, S.Zero)
+                except ValueError:
+                    # maybe not a linear function, try polynomial
+                    from sympy.polys.polyerrors import PolynomialError
+                    from sympy.polys.polytools import gcd, Poly, poly
+                    try:
+                        p = poly(dif, x)
+                        c = p.all_coeffs()
+                        constant = c[-1]
+                        c[-1] = 0
+                        scale = gcd(c)
+                        c = [ctmp / scale for ctmp in c]
+                        r = r.func(Poly.from_list(c, x).as_expr(), -constant / scale)
+                    except PolynomialError:
+                        pass
+            elif len(free) >= 2:
+                try:
+                    from sympy.solvers.solveset import linear_coeffs
+                    from sympy.polys.polytools import gcd
+                    free = list(ordered(free))
+                    dif = r.lhs - r.rhs
+                    m = linear_coeffs(dif, *free)
+                    constant = m[-1]
+                    del m[-1]
+                    scale = gcd(m)
+                    m = [mtmp / scale for mtmp in m]
+                    nzm = list(filter(lambda f: f[0] != 0, list(zip(m, free))))
+                    if scale.is_zero is False:
+                        if constant != 0:
+                            # lhs: expression, rhs: constant
+                            newexpr = Add(*[i * j for i, j in nzm])
+                            r = r.func(newexpr, -constant / scale)
+                        else:
+                            # keep first term on lhs
+                            lhsterm = nzm[0][0] * nzm[0][1]
+                            del nzm[0]
+                            newexpr = Add(*[i * j for i, j in nzm])
+                            r = r.func(lhsterm, -newexpr)
+
+                    else:
+                        r = r.func(constant, S.Zero)
+                except ValueError:
+                    pass
+        # Did we get a simplified result?
+        r = r.canonical
+        measure = kwargs['measure']
+        if measure(r) < kwargs['ratio'] * measure(self):
+            return r
+        else:
+            return self
+
+    def _eval_trigsimp(self, **opts):
+        from sympy.simplify.trigsimp import trigsimp
+        return self.func(trigsimp(self.lhs, **opts), trigsimp(self.rhs, **opts))
+
+    def expand(self, **kwargs):
+        args = (arg.expand(**kwargs) for arg in self.args)
+        return self.func(*args)
+
+    def __bool__(self) -> bool:
+        raise TypeError(
+            LazyExceptionMessage(
+                lambda: f"cannot determine truth value of Relational: {self}"
+            )
+        )
+
+    def _eval_as_set(self):
+        # self is univariate and periodicity(self, x) in (0, None)
+        from sympy.solvers.inequalities import solve_univariate_inequality
+        from sympy.sets.conditionset import ConditionSet
+        syms = self.free_symbols
+        assert len(syms) == 1
+        x = syms.pop()
+        try:
+            xset = solve_univariate_inequality(self, x, relational=False)
+        except NotImplementedError:
+            # solve_univariate_inequality raises NotImplementedError for
+            # unsolvable equations/inequalities.
+            xset = ConditionSet(x, self, S.Reals)
+        return xset
+
+    @property
+    def binary_symbols(self):
+        # override where necessary
+        return set()
+
+
+Rel = Relational
+
+
+class Equality(Relational):
+    """
+    An equal relation between two objects.
+
+    Explanation
+    ===========
+
+    Represents that two objects are equal.  If they can be easily shown
+    to be definitively equal (or unequal), this will reduce to True (or
+    False).  Otherwise, the relation is maintained as an unevaluated
+    Equality object.  Use the ``simplify`` function on this object for
+    more nontrivial evaluation of the equality relation.
+
+    As usual, the keyword argument ``evaluate=False`` can be used to
+    prevent any evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import Eq, simplify, exp, cos
+    >>> from sympy.abc import x, y
+    >>> Eq(y, x + x**2)
+    Eq(y, x**2 + x)
+    >>> Eq(2, 5)
+    False
+    >>> Eq(2, 5, evaluate=False)
+    Eq(2, 5)
+    >>> _.doit()
+    False
+    >>> Eq(exp(x), exp(x).rewrite(cos))
+    Eq(exp(x), sinh(x) + cosh(x))
+    >>> simplify(_)
+    True
+
+    See Also
+    ========
+
+    sympy.logic.boolalg.Equivalent : for representing equality between two
+        boolean expressions
+
+    Notes
+    =====
+
+    Python treats 1 and True (and 0 and False) as being equal; SymPy
+    does not. And integer will always compare as unequal to a Boolean:
+
+    >>> Eq(True, 1), True == 1
+    (False, True)
+
+    This class is not the same as the == operator.  The == operator tests
+    for exact structural equality between two expressions; this class
+    compares expressions mathematically.
+
+    If either object defines an ``_eval_Eq`` method, it can be used in place of
+    the default algorithm.  If ``lhs._eval_Eq(rhs)`` or ``rhs._eval_Eq(lhs)``
+    returns anything other than None, that return value will be substituted for
+    the Equality.  If None is returned by ``_eval_Eq``, an Equality object will
+    be created as usual.
+
+    Since this object is already an expression, it does not respond to
+    the method ``as_expr`` if one tries to create `x - y` from ``Eq(x, y)``.
+    If ``eq = Eq(x, y)`` then write `eq.lhs - eq.rhs` to get ``x - y``.
+
+    .. deprecated:: 1.5
+
+       ``Eq(expr)`` with a single argument is a shorthand for ``Eq(expr, 0)``,
+       but this behavior is deprecated and will be removed in a future version
+       of SymPy.
+
+    """
+    rel_op = '=='
+
+    __slots__ = ()
+
+    is_Equality = True
+
+    def __new__(cls, lhs, rhs, **options):
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+        if evaluate:
+            val = is_eq(lhs, rhs)
+            if val is None:
+                return cls(lhs, rhs, evaluate=False)
+            else:
+                return _sympify(val)
+
+        return Relational.__new__(cls, lhs, rhs)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs):
+        return _sympify(lhs == rhs)
+
+    def _eval_rewrite_as_Add(self, L, R, evaluate=True, **kwargs):
+        """
+        return Eq(L, R) as L - R. To control the evaluation of
+        the result set pass `evaluate=True` to give L - R;
+        if `evaluate=None` then terms in L and R will not cancel
+        but they will be listed in canonical order; otherwise
+        non-canonical args will be returned. If one side is 0, the
+        non-zero side will be returned.
+
+        .. deprecated:: 1.13
+
+           The method ``Eq.rewrite(Add)`` is deprecated.
+           See :ref:`eq-rewrite-Add` for details.
+
+        Examples
+        ========
+
+        >>> from sympy import Eq, Add
+        >>> from sympy.abc import b, x
+        >>> eq = Eq(x + b, x - b)
+        >>> eq.rewrite(Add)  #doctest: +SKIP
+        2*b
+        >>> eq.rewrite(Add, evaluate=None).args  #doctest: +SKIP
+        (b, b, x, -x)
+        >>> eq.rewrite(Add, evaluate=False).args  #doctest: +SKIP
+        (b, x, b, -x)
+        """
+        sympy_deprecation_warning("""
+        Eq.rewrite(Add) is deprecated.
+
+        For ``eq = Eq(a, b)`` use ``eq.lhs - eq.rhs`` to obtain
+        ``a - b``.
+        """,
+            deprecated_since_version="1.13",
+            active_deprecations_target="eq-rewrite-Add",
+            stacklevel=5,
+        )
+        from .add import _unevaluated_Add, Add
+        if L == 0:
+            return R
+        if R == 0:
+            return L
+        if evaluate:
+            # allow cancellation of args
+            return L - R
+        args = Add.make_args(L) + Add.make_args(-R)
+        if evaluate is None:
+            # no cancellation, but canonical
+            return _unevaluated_Add(*args)
+        # no cancellation, not canonical
+        return Add._from_args(args)
+
+    @property
+    def binary_symbols(self):
+        if S.true in self.args or S.false in self.args:
+            if self.lhs.is_Symbol:
+                return {self.lhs}
+            elif self.rhs.is_Symbol:
+                return {self.rhs}
+        return set()
+
+    def _eval_simplify(self, **kwargs):
+        # standard simplify
+        e = super()._eval_simplify(**kwargs)
+        if not isinstance(e, Equality):
+            return e
+        from .expr import Expr
+        if not isinstance(e.lhs, Expr) or not isinstance(e.rhs, Expr):
+            return e
+        free = self.free_symbols
+        if len(free) == 1:
+            try:
+                from .add import Add
+                from sympy.solvers.solveset import linear_coeffs
+                x = free.pop()
+                m, b = linear_coeffs(
+                    Add(e.lhs, -e.rhs, evaluate=False), x)
+                if m.is_zero is False:
+                    enew = e.func(x, -b / m)
+                else:
+                    enew = e.func(m * x, -b)
+                measure = kwargs['measure']
+                if measure(enew) <= kwargs['ratio'] * measure(e):
+                    e = enew
+            except ValueError:
+                pass
+        return e.canonical
+
+    def integrate(self, *args, **kwargs):
+        """See the integrate function in sympy.integrals"""
+        from sympy.integrals.integrals import integrate
+        return integrate(self, *args, **kwargs)
+
+    def as_poly(self, *gens, **kwargs):
+        '''Returns lhs-rhs as a Poly
+
+        Examples
+        ========
+
+        >>> from sympy import Eq
+        >>> from sympy.abc import x
+        >>> Eq(x**2, 1).as_poly(x)
+        Poly(x**2 - 1, x, domain='ZZ')
+        '''
+        return (self.lhs - self.rhs).as_poly(*gens, **kwargs)
+
+
+Eq = Equality
+
+
+class Unequality(Relational):
+    """An unequal relation between two objects.
+
+    Explanation
+    ===========
+
+    Represents that two objects are not equal.  If they can be shown to be
+    definitively equal, this will reduce to False; if definitively unequal,
+    this will reduce to True.  Otherwise, the relation is maintained as an
+    Unequality object.
+
+    Examples
+    ========
+
+    >>> from sympy import Ne
+    >>> from sympy.abc import x, y
+    >>> Ne(y, x+x**2)
+    Ne(y, x**2 + x)
+
+    See Also
+    ========
+    Equality
+
+    Notes
+    =====
+    This class is not the same as the != operator.  The != operator tests
+    for exact structural equality between two expressions; this class
+    compares expressions mathematically.
+
+    This class is effectively the inverse of Equality.  As such, it uses the
+    same algorithms, including any available `_eval_Eq` methods.
+
+    """
+    rel_op = '!='
+
+    __slots__ = ()
+
+    def __new__(cls, lhs, rhs, **options):
+        lhs = _sympify(lhs)
+        rhs = _sympify(rhs)
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        if evaluate:
+            val = is_neq(lhs, rhs)
+            if val is None:
+                return cls(lhs, rhs, evaluate=False)
+            else:
+                return _sympify(val)
+
+        return Relational.__new__(cls, lhs, rhs, **options)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs):
+        return _sympify(lhs != rhs)
+
+    @property
+    def binary_symbols(self):
+        if S.true in self.args or S.false in self.args:
+            if self.lhs.is_Symbol:
+                return {self.lhs}
+            elif self.rhs.is_Symbol:
+                return {self.rhs}
+        return set()
+
+    def _eval_simplify(self, **kwargs):
+        # simplify as an equality
+        eq = Equality(*self.args)._eval_simplify(**kwargs)
+        if isinstance(eq, Equality):
+            # send back Ne with the new args
+            return self.func(*eq.args)
+        return eq.negated  # result of Ne is the negated Eq
+
+
+Ne = Unequality
+
+
+class _Inequality(Relational):
+    """Internal base class for all *Than types.
+
+    Each subclass must implement _eval_relation to provide the method for
+    comparing two real numbers.
+
+    """
+    __slots__ = ()
+
+    def __new__(cls, lhs, rhs, **options):
+
+        try:
+            lhs = _sympify(lhs)
+            rhs = _sympify(rhs)
+        except SympifyError:
+            return NotImplemented
+
+        evaluate = options.pop('evaluate', global_parameters.evaluate)
+        if evaluate:
+            for me in (lhs, rhs):
+                if me.is_extended_real is False:
+                    raise TypeError("Invalid comparison of non-real %s" % me)
+                if me is S.NaN:
+                    raise TypeError("Invalid NaN comparison")
+            # First we invoke the appropriate inequality method of `lhs`
+            # (e.g., `lhs.__lt__`).  That method will try to reduce to
+            # boolean or raise an exception.  It may keep calling
+            # superclasses until it reaches `Expr` (e.g., `Expr.__lt__`).
+            # In some cases, `Expr` will just invoke us again (if neither it
+            # nor a subclass was able to reduce to boolean or raise an
+            # exception).  In that case, it must call us with
+            # `evaluate=False` to prevent infinite recursion.
+            return cls._eval_relation(lhs, rhs, **options)
+
+        # make a "non-evaluated" Expr for the inequality
+        return Relational.__new__(cls, lhs, rhs, **options)
+
+    @classmethod
+    def _eval_relation(cls, lhs, rhs, **options):
+        val = cls._eval_fuzzy_relation(lhs, rhs)
+        if val is None:
+            return cls(lhs, rhs, evaluate=False)
+        else:
+            return _sympify(val)
+
+
+class _Greater(_Inequality):
+    """Not intended for general use
+
+    _Greater is only used so that GreaterThan and StrictGreaterThan may
+    subclass it for the .gts and .lts properties.
+
+    """
+    __slots__ = ()
+
+    @property
+    def gts(self):
+        return self._args[0]
+
+    @property
+    def lts(self):
+        return self._args[1]
+
+
+class _Less(_Inequality):
+    """Not intended for general use.
+
+    _Less is only used so that LessThan and StrictLessThan may subclass it for
+    the .gts and .lts properties.
+
+    """
+    __slots__ = ()
+
+    @property
+    def gts(self):
+        return self._args[1]
+
+    @property
+    def lts(self):
+        return self._args[0]
+
+
+class GreaterThan(_Greater):
+    r"""Class representations of inequalities.
+
+    Explanation
+    ===========
+
+    The ``*Than`` classes represent inequal relationships, where the left-hand
+    side is generally bigger or smaller than the right-hand side.  For example,
+    the GreaterThan class represents an inequal relationship where the
+    left-hand side is at least as big as the right side, if not bigger.  In
+    mathematical notation:
+
+    lhs $\ge$ rhs
+
+    In total, there are four ``*Than`` classes, to represent the four
+    inequalities:
+
+    +-----------------+--------+
+    |Class Name       | Symbol |
+    +=================+========+
+    |GreaterThan      | ``>=`` |
+    +-----------------+--------+
+    |LessThan         | ``<=`` |
+    +-----------------+--------+
+    |StrictGreaterThan| ``>``  |
+    +-----------------+--------+
+    |StrictLessThan   | ``<``  |
+    +-----------------+--------+
+
+    All classes take two arguments, lhs and rhs.
+
+    +----------------------------+-----------------+
+    |Signature Example           | Math Equivalent |
+    +============================+=================+
+    |GreaterThan(lhs, rhs)       |   lhs $\ge$ rhs |
+    +----------------------------+-----------------+
+    |LessThan(lhs, rhs)          |   lhs $\le$ rhs |
+    +----------------------------+-----------------+
+    |StrictGreaterThan(lhs, rhs) |   lhs $>$ rhs   |
+    +----------------------------+-----------------+
+    |StrictLessThan(lhs, rhs)    |   lhs $<$ rhs   |
+    +----------------------------+-----------------+
+
+    In addition to the normal .lhs and .rhs of Relations, ``*Than`` inequality
+    objects also have the .lts and .gts properties, which represent the "less
+    than side" and "greater than side" of the operator.  Use of .lts and .gts
+    in an algorithm rather than .lhs and .rhs as an assumption of inequality
+    direction will make more explicit the intent of a certain section of code,
+    and will make it similarly more robust to client code changes:
+
+    >>> from sympy import GreaterThan, StrictGreaterThan
+    >>> from sympy import LessThan, StrictLessThan
+    >>> from sympy import And, Ge, Gt, Le, Lt, Rel, S
+    >>> from sympy.abc import x, y, z
+    >>> from sympy.core.relational import Relational
+
+    >>> e = GreaterThan(x, 1)
+    >>> e
+    x >= 1
+    >>> '%s >= %s is the same as %s <= %s' % (e.gts, e.lts, e.lts, e.gts)
+    'x >= 1 is the same as 1 <= x'
+
+    Examples
+    ========
+
+    One generally does not instantiate these classes directly, but uses various
+    convenience methods:
+
+    >>> for f in [Ge, Gt, Le, Lt]:  # convenience wrappers
+    ...     print(f(x, 2))
+    x >= 2
+    x > 2
+    x <= 2
+    x < 2
+
+    Another option is to use the Python inequality operators (``>=``, ``>``,
+    ``<=``, ``<``) directly.  Their main advantage over the ``Ge``, ``Gt``,
+    ``Le``, and ``Lt`` counterparts, is that one can write a more
+    "mathematical looking" statement rather than littering the math with
+    oddball function calls.  However there are certain (minor) caveats of
+    which to be aware (search for 'gotcha', below).
+
+    >>> x >= 2
+    x >= 2
+    >>> _ == Ge(x, 2)
+    True
+
+    However, it is also perfectly valid to instantiate a ``*Than`` class less
+    succinctly and less conveniently:
+
+    >>> Rel(x, 1, ">")
+    x > 1
+    >>> Relational(x, 1, ">")
+    x > 1
+
+    >>> StrictGreaterThan(x, 1)
+    x > 1
+    >>> GreaterThan(x, 1)
+    x >= 1
+    >>> LessThan(x, 1)
+    x <= 1
+    >>> StrictLessThan(x, 1)
+    x < 1
+
+    Notes
+    =====
+
+    There are a couple of "gotchas" to be aware of when using Python's
+    operators.
+
+    The first is that what your write is not always what you get:
+
+        >>> 1 < x
+        x > 1
+
+        Due to the order that Python parses a statement, it may
+        not immediately find two objects comparable.  When ``1 < x``
+        is evaluated, Python recognizes that the number 1 is a native
+        number and that x is *not*.  Because a native Python number does
+        not know how to compare itself with a SymPy object
+        Python will try the reflective operation, ``x > 1`` and that is the
+        form that gets evaluated, hence returned.
+
+        If the order of the statement is important (for visual output to
+        the console, perhaps), one can work around this annoyance in a
+        couple ways:
+
+        (1) "sympify" the literal before comparison
+
+        >>> S(1) < x
+        1 < x
+
+        (2) use one of the wrappers or less succinct methods described
+        above
+
+        >>> Lt(1, x)
+        1 < x
+        >>> Relational(1, x, "<")
+        1 < x
+
+    The second gotcha involves writing equality tests between relationals
+    when one or both sides of the test involve a literal relational:
+
+        >>> e = x < 1; e
+        x < 1
+        >>> e == e  # neither side is a literal
+        True
+        >>> e == x < 1  # expecting True, too
+        False
+        >>> e != x < 1  # expecting False
+        x < 1
+        >>> x < 1 != x < 1  # expecting False or the same thing as before
+        Traceback (most recent call last):
+        ...
+        TypeError: cannot determine truth value of Relational
+
+        The solution for this case is to wrap literal relationals in
+        parentheses:
+
+        >>> e == (x < 1)
+        True
+        >>> e != (x < 1)
+        False
+        >>> (x < 1) != (x < 1)
+        False
+
+    The third gotcha involves chained inequalities not involving
+    ``==`` or ``!=``. Occasionally, one may be tempted to write:
+
+        >>> e = x < y < z
+        Traceback (most recent call last):
+        ...
+        TypeError: symbolic boolean expression has no truth value.
+
+        Due to an implementation detail or decision of Python [1]_,
+        there is no way for SymPy to create a chained inequality with
+        that syntax so one must use And:
+
+        >>> e = And(x < y, y < z)
+        >>> type( e )
+        And
+        >>> e
+        (x < y) & (y < z)
+
+        Although this can also be done with the '&' operator, it cannot
+        be done with the 'and' operarator:
+
+        >>> (x < y) & (y < z)
+        (x < y) & (y < z)
+        >>> (x < y) and (y < z)
+        Traceback (most recent call last):
+        ...
+        TypeError: cannot determine truth value of Relational
+
+    .. [1] This implementation detail is that Python provides no reliable
+       method to determine that a chained inequality is being built.
+       Chained comparison operators are evaluated pairwise, using "and"
+       logic (see
+       https://docs.python.org/3/reference/expressions.html#not-in). This
+       is done in an efficient way, so that each object being compared
+       is only evaluated once and the comparison can short-circuit. For
+       example, ``1 > 2 > 3`` is evaluated by Python as ``(1 > 2) and (2
+       > 3)``. The ``and`` operator coerces each side into a bool,
+       returning the object itself when it short-circuits. The bool of
+       the --Than operators will raise TypeError on purpose, because
+       SymPy cannot determine the mathematical ordering of symbolic
+       expressions. Thus, if we were to compute ``x > y > z``, with
+       ``x``, ``y``, and ``z`` being Symbols, Python converts the
+       statement (roughly) into these steps:
+
+        (1) x > y > z
+        (2) (x > y) and (y > z)
+        (3) (GreaterThanObject) and (y > z)
+        (4) (GreaterThanObject.__bool__()) and (y > z)
+        (5) TypeError
+
+       Because of the ``and`` added at step 2, the statement gets turned into a
+       weak ternary statement, and the first object's ``__bool__`` method will
+       raise TypeError.  Thus, creating a chained inequality is not possible.
+
+           In Python, there is no way to override the ``and`` operator, or to
+           control how it short circuits, so it is impossible to make something
+           like ``x > y > z`` work.  There was a PEP to change this,
+           :pep:`335`, but it was officially closed in March, 2012.
+
+    """
+    __slots__ = ()
+
+    rel_op = '>='
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_ge(lhs, rhs)
+
+    @property
+    def strict(self):
+        return Gt(*self.args)
+
+Ge = GreaterThan
+
+
+class LessThan(_Less):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '<='
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_le(lhs, rhs)
+
+    @property
+    def strict(self):
+        return Lt(*self.args)
+
+Le = LessThan
+
+
+class StrictGreaterThan(_Greater):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '>'
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_gt(lhs, rhs)
+
+    @property
+    def weak(self):
+        return Ge(*self.args)
+
+
+Gt = StrictGreaterThan
+
+
+class StrictLessThan(_Less):
+    __doc__ = GreaterThan.__doc__
+    __slots__ = ()
+
+    rel_op = '<'
+
+    @classmethod
+    def _eval_fuzzy_relation(cls, lhs, rhs):
+        return is_lt(lhs, rhs)
+
+    @property
+    def weak(self):
+        return Le(*self.args)
+
+Lt = StrictLessThan
+
+# A class-specific (not object-specific) data item used for a minor speedup.
+# It is defined here, rather than directly in the class, because the classes
+# that it references have not been defined until now (e.g. StrictLessThan).
+Relational.ValidRelationOperator = {
+    None: Equality,
+    '==': Equality,
+    'eq': Equality,
+    '!=': Unequality,
+    '<>': Unequality,
+    'ne': Unequality,
+    '>=': GreaterThan,
+    'ge': GreaterThan,
+    '<=': LessThan,
+    'le': LessThan,
+    '>': StrictGreaterThan,
+    'gt': StrictGreaterThan,
+    '<': StrictLessThan,
+    'lt': StrictLessThan,
+}
+
+
+def _n2(a, b):
+    """Return (a - b).evalf(2) if a and b are comparable, else None.
+    This should only be used when a and b are already sympified.
+    """
+    # /!\ it is very important (see issue 8245) not to
+    # use a re-evaluated number in the calculation of dif
+    if a.is_comparable and b.is_comparable:
+        dif = (a - b).evalf(2)
+        if dif.is_comparable:
+            return dif
+
+
+@dispatch(Expr, Expr)
+def _eval_is_ge(lhs, rhs):
+    return None
+
+
+@dispatch(Basic, Basic)
+def _eval_is_eq(lhs, rhs):
+    return None
+
+
+@dispatch(Tuple, Expr) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return False
+
+
+@dispatch(Tuple, AppliedUndef) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return None
+
+
+@dispatch(Tuple, Symbol) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    return None
+
+
+@dispatch(Tuple, Tuple) # type: ignore
+def _eval_is_eq(lhs, rhs):  # noqa:F811
+    if len(lhs) != len(rhs):
+        return False
+
+    return fuzzy_and(fuzzy_bool(is_eq(s, o)) for s, o in zip(lhs, rhs))
+
+
+def is_lt(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is strictly less than rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return fuzzy_not(is_ge(lhs, rhs, assumptions))
+
+
+def is_gt(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is strictly greater than rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return fuzzy_not(is_le(lhs, rhs, assumptions))
+
+
+def is_le(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs is less than or equal to rhs.
+
+    See the docstring for :func:`~.is_ge` for more.
+    """
+    return is_ge(rhs, lhs, assumptions)
+
+
+def is_ge(lhs, rhs, assumptions=None):
+    """
+    Fuzzy bool for *lhs* is greater than or equal to *rhs*.
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        The left-hand side of the expression, must be sympified,
+        and an instance of expression. Throws an exception if
+        lhs is not an instance of expression.
+
+    rhs : Expr
+        The right-hand side of the expression, must be sympified
+        and an instance of expression. Throws an exception if
+        lhs is not an instance of expression.
+
+    assumptions: Boolean, optional
+        Assumptions taken to evaluate the inequality.
+
+    Returns
+    =======
+
+    ``True`` if *lhs* is greater than or equal to *rhs*, ``False`` if *lhs*
+    is less than *rhs*, and ``None`` if the comparison between *lhs* and
+    *rhs* is indeterminate.
+
+    Explanation
+    ===========
+
+    This function is intended to give a relatively fast determination and
+    deliberately does not attempt slow calculations that might help in
+    obtaining a determination of True or False in more difficult cases.
+
+    The four comparison functions ``is_le``, ``is_lt``, ``is_ge``, and ``is_gt`` are
+    each implemented in terms of ``is_ge`` in the following way:
+
+    is_ge(x, y) := is_ge(x, y)
+    is_le(x, y) := is_ge(y, x)
+    is_lt(x, y) := fuzzy_not(is_ge(x, y))
+    is_gt(x, y) := fuzzy_not(is_ge(y, x))
+
+    Therefore, supporting new type with this function will ensure behavior for
+    other three functions as well.
+
+    To maintain these equivalences in fuzzy logic it is important that in cases where
+    either x or y is non-real all comparisons will give None.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Q
+    >>> from sympy.core.relational import is_ge, is_le, is_gt, is_lt
+    >>> from sympy.abc import x
+    >>> is_ge(S(2), S(0))
+    True
+    >>> is_ge(S(0), S(2))
+    False
+    >>> is_le(S(0), S(2))
+    True
+    >>> is_gt(S(0), S(2))
+    False
+    >>> is_lt(S(2), S(0))
+    False
+
+    Assumptions can be passed to evaluate the quality which is otherwise
+    indeterminate.
+
+    >>> print(is_ge(x, S(0)))
+    None
+    >>> is_ge(x, S(0), assumptions=Q.positive(x))
+    True
+
+    New types can be supported by dispatching to ``_eval_is_ge``.
+
+    >>> from sympy import Expr, sympify
+    >>> from sympy.multipledispatch import dispatch
+    >>> class MyExpr(Expr):
+    ...     def __new__(cls, arg):
+    ...         return super().__new__(cls, sympify(arg))
+    ...     @property
+    ...     def value(self):
+    ...         return self.args[0]
+    >>> @dispatch(MyExpr, MyExpr)
+    ... def _eval_is_ge(a, b):
+    ...     return is_ge(a.value, b.value)
+    >>> a = MyExpr(1)
+    >>> b = MyExpr(2)
+    >>> is_ge(b, a)
+    True
+    >>> is_le(a, b)
+    True
+    """
+    from sympy.assumptions.wrapper import AssumptionsWrapper, is_extended_nonnegative
+
+    if not (isinstance(lhs, Expr) and isinstance(rhs, Expr)):
+        raise TypeError("Can only compare inequalities with Expr")
+
+    retval = _eval_is_ge(lhs, rhs)
+
+    if retval is not None:
+        return retval
+    else:
+        n2 = _n2(lhs, rhs)
+        if n2 is not None:
+            # use float comparison for infinity.
+            # otherwise get stuck in infinite recursion
+            if n2 in (S.Infinity, S.NegativeInfinity):
+                n2 = float(n2)
+            return n2 >= 0
+
+        _lhs = AssumptionsWrapper(lhs, assumptions)
+        _rhs = AssumptionsWrapper(rhs, assumptions)
+        if _lhs.is_extended_real and _rhs.is_extended_real:
+            if (_lhs.is_infinite and _lhs.is_extended_positive) or (_rhs.is_infinite and _rhs.is_extended_negative):
+                return True
+            diff = lhs - rhs
+            if diff is not S.NaN:
+                rv = is_extended_nonnegative(diff, assumptions)
+                if rv is not None:
+                    return rv
+
+
+def is_neq(lhs, rhs, assumptions=None):
+    """Fuzzy bool for lhs does not equal rhs.
+
+    See the docstring for :func:`~.is_eq` for more.
+    """
+    return fuzzy_not(is_eq(lhs, rhs, assumptions))
+
+
+def is_eq(lhs, rhs, assumptions=None):
+    """
+    Fuzzy bool representing mathematical equality between *lhs* and *rhs*.
+
+    Parameters
+    ==========
+
+    lhs : Expr
+        The left-hand side of the expression, must be sympified.
+
+    rhs : Expr
+        The right-hand side of the expression, must be sympified.
+
+    assumptions: Boolean, optional
+        Assumptions taken to evaluate the equality.
+
+    Returns
+    =======
+
+    ``True`` if *lhs* is equal to *rhs*, ``False`` is *lhs* is not equal to *rhs*,
+    and ``None`` if the comparison between *lhs* and *rhs* is indeterminate.
+
+    Explanation
+    ===========
+
+    This function is intended to give a relatively fast determination and
+    deliberately does not attempt slow calculations that might help in
+    obtaining a determination of True or False in more difficult cases.
+
+    :func:`~.is_neq` calls this function to return its value, so supporting
+    new type with this function will ensure correct behavior for ``is_neq``
+    as well.
+
+    Examples
+    ========
+
+    >>> from sympy import Q, S
+    >>> from sympy.core.relational import is_eq, is_neq
+    >>> from sympy.abc import x
+    >>> is_eq(S(0), S(0))
+    True
+    >>> is_neq(S(0), S(0))
+    False
+    >>> is_eq(S(0), S(2))
+    False
+    >>> is_neq(S(0), S(2))
+    True
+
+    Assumptions can be passed to evaluate the equality which is otherwise
+    indeterminate.
+
+    >>> print(is_eq(x, S(0)))
+    None
+    >>> is_eq(x, S(0), assumptions=Q.zero(x))
+    True
+
+    New types can be supported by dispatching to ``_eval_is_eq``.
+
+    >>> from sympy import Basic, sympify
+    >>> from sympy.multipledispatch import dispatch
+    >>> class MyBasic(Basic):
+    ...     def __new__(cls, arg):
+    ...         return Basic.__new__(cls, sympify(arg))
+    ...     @property
+    ...     def value(self):
+    ...         return self.args[0]
+    ...
+    >>> @dispatch(MyBasic, MyBasic)
+    ... def _eval_is_eq(a, b):
+    ...     return is_eq(a.value, b.value)
+    ...
+    >>> a = MyBasic(1)
+    >>> b = MyBasic(1)
+    >>> is_eq(a, b)
+    True
+    >>> is_neq(a, b)
+    False
+
+    """
+    # here, _eval_Eq is only called for backwards compatibility
+    # new code should use is_eq with multiple dispatch as
+    # outlined in the docstring
+    for side1, side2 in (lhs, rhs), (rhs, lhs):
+        eval_func = getattr(side1, '_eval_Eq', None)
+        if eval_func is not None:
+            retval = eval_func(side2)
+            if retval is not None:
+                return retval
+
+    retval = _eval_is_eq(lhs, rhs)
+    if retval is not None:
+        return retval
+
+    if dispatch(type(lhs), type(rhs)) != dispatch(type(rhs), type(lhs)):
+        retval = _eval_is_eq(rhs, lhs)
+        if retval is not None:
+            return retval
+
+    # retval is still None, so go through the equality logic
+    # If expressions have the same structure, they must be equal.
+    if lhs == rhs:
+        return True  # e.g. True == True
+    elif all(isinstance(i, BooleanAtom) for i in (rhs, lhs)):
+        return False  # True != False
+    elif not (lhs.is_Symbol or rhs.is_Symbol) and (
+        isinstance(lhs, Boolean) !=
+        isinstance(rhs, Boolean)):
+        return False  # only Booleans can equal Booleans
+
+    from sympy.assumptions.wrapper import (AssumptionsWrapper,
+        is_infinite, is_extended_real)
+    from .add import Add
+
+    _lhs = AssumptionsWrapper(lhs, assumptions)
+    _rhs = AssumptionsWrapper(rhs, assumptions)
+
+    if _lhs.is_infinite or _rhs.is_infinite:
+        if fuzzy_xor([_lhs.is_infinite, _rhs.is_infinite]):
+            return False
+        if fuzzy_xor([_lhs.is_extended_real, _rhs.is_extended_real]):
+            return False
+        if fuzzy_and([_lhs.is_extended_real, _rhs.is_extended_real]):
+            return fuzzy_xor([_lhs.is_extended_positive, fuzzy_not(_rhs.is_extended_positive)])
+
+        # Try to split real/imaginary parts and equate them
+        I = S.ImaginaryUnit
+
+        def split_real_imag(expr):
+            real_imag = lambda t: (
+                'real' if is_extended_real(t, assumptions) else
+                'imag' if is_extended_real(I*t, assumptions) else None)
+            return sift(Add.make_args(expr), real_imag)
+
+        lhs_ri = split_real_imag(lhs)
+        if not lhs_ri[None]:
+            rhs_ri = split_real_imag(rhs)
+            if not rhs_ri[None]:
+                eq_real = is_eq(Add(*lhs_ri['real']), Add(*rhs_ri['real']), assumptions)
+                eq_imag = is_eq(I * Add(*lhs_ri['imag']), I * Add(*rhs_ri['imag']), assumptions)
+                return fuzzy_and(map(fuzzy_bool, [eq_real, eq_imag]))
+
+        from sympy.functions.elementary.complexes import arg
+        # Compare e.g. zoo with 1+I*oo by comparing args
+        arglhs = arg(lhs)
+        argrhs = arg(rhs)
+        # Guard against Eq(nan, nan) -> False
+        if not (arglhs == S.NaN and argrhs == S.NaN):
+            return fuzzy_bool(is_eq(arglhs, argrhs, assumptions))
+
+    if all(isinstance(i, Expr) for i in (lhs, rhs)):
+        # see if the difference evaluates
+        dif = lhs - rhs
+        _dif = AssumptionsWrapper(dif, assumptions)
+        z = _dif.is_zero
+        if z is not None:
+            if z is False and _dif.is_commutative:  # issue 10728
+                return False
+            if z:
+                return True
+
+        # is_zero cannot help decide integer/rational with Float
+        c, t = dif.as_coeff_Add()
+        if c.is_Float:
+            if int_valued(c):
+                if t.is_integer is False:
+                    return False
+            elif t.is_rational is False:
+                return False
+
+        n2 = _n2(lhs, rhs)
+        if n2 is not None:
+            return _sympify(n2 == 0)
+
+        # see if the ratio evaluates
+        n, d = dif.as_numer_denom()
+        rv = None
+        _n = AssumptionsWrapper(n, assumptions)
+        _d = AssumptionsWrapper(d, assumptions)
+        if _n.is_zero:
+            rv = _d.is_nonzero
+        elif _n.is_finite:
+            if _d.is_infinite:
+                rv = True
+            elif _n.is_zero is False:
+                rv = _d.is_infinite
+                if rv is None:
+                    # if the condition that makes the denominator
+                    # infinite does not make the original expression
+                    # True then False can be returned
+                    from sympy.simplify.simplify import clear_coefficients
+                    l, r = clear_coefficients(d, S.Infinity)
+                    args = [_.subs(l, r) for _ in (lhs, rhs)]
+                    if args != [lhs, rhs]:
+                        rv = fuzzy_bool(is_eq(*args, assumptions))
+                        if rv is True:
+                            rv = None
+        elif any(is_infinite(a, assumptions) for a in Add.make_args(n)):
+            # (inf or nan)/x != 0
+            rv = False
+        if rv is not None:
+            return rv
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/rules.py b/.venv/lib/python3.12/site-packages/sympy/core/rules.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ae331f71b21c8a6ef35f499c5c5c89239349e9c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/rules.py
@@ -0,0 +1,66 @@
+"""
+Replacement rules.
+"""
+
+class Transform:
+    """
+    Immutable mapping that can be used as a generic transformation rule.
+
+    Parameters
+    ==========
+
+    transform : callable
+        Computes the value corresponding to any key.
+
+    filter : callable, optional
+        If supplied, specifies which objects are in the mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.core.rules import Transform
+    >>> from sympy.abc import x
+
+    This Transform will return, as a value, one more than the key:
+
+    >>> add1 = Transform(lambda x: x + 1)
+    >>> add1[1]
+    2
+    >>> add1[x]
+    x + 1
+
+    By default, all values are considered to be in the dictionary. If a filter
+    is supplied, only the objects for which it returns True are considered as
+    being in the dictionary:
+
+    >>> add1_odd = Transform(lambda x: x + 1, lambda x: x%2 == 1)
+    >>> 2 in add1_odd
+    False
+    >>> add1_odd.get(2, 0)
+    0
+    >>> 3 in add1_odd
+    True
+    >>> add1_odd[3]
+    4
+    >>> add1_odd.get(3, 0)
+    4
+    """
+
+    def __init__(self, transform, filter=lambda x: True):
+        self._transform = transform
+        self._filter = filter
+
+    def __contains__(self, item):
+        return self._filter(item)
+
+    def __getitem__(self, key):
+        if self._filter(key):
+            return self._transform(key)
+        else:
+            raise KeyError(key)
+
+    def get(self, item, default=None):
+        if item in self:
+            return self[item]
+        else:
+            return default
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/singleton.py b/.venv/lib/python3.12/site-packages/sympy/core/singleton.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8b9df959393270140bc3ef11b3d9a4e948c5e80
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/singleton.py
@@ -0,0 +1,199 @@
+"""Singleton mechanism"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .core import Registry
+from .sympify import sympify
+
+
+if TYPE_CHECKING:
+    from sympy.core.numbers import (
+        Zero as _Zero,
+        One as _One,
+        NegativeOne as _NegativeOne,
+        Half as _Half,
+        Infinity as _Infinity,
+        NegativeInfinity as _NegativeInfinity,
+        ComplexInfinity as _ComplexInfinity,
+        NaN as _NaN,
+    )
+
+
+class SingletonRegistry(Registry):
+    """
+    The registry for the singleton classes (accessible as ``S``).
+
+    Explanation
+    ===========
+
+    This class serves as two separate things.
+
+    The first thing it is is the ``SingletonRegistry``. Several classes in
+    SymPy appear so often that they are singletonized, that is, using some
+    metaprogramming they are made so that they can only be instantiated once
+    (see the :class:`sympy.core.singleton.Singleton` class for details). For
+    instance, every time you create ``Integer(0)``, this will return the same
+    instance, :class:`sympy.core.numbers.Zero`. All singleton instances are
+    attributes of the ``S`` object, so ``Integer(0)`` can also be accessed as
+    ``S.Zero``.
+
+    Singletonization offers two advantages: it saves memory, and it allows
+    fast comparison. It saves memory because no matter how many times the
+    singletonized objects appear in expressions in memory, they all point to
+    the same single instance in memory. The fast comparison comes from the
+    fact that you can use ``is`` to compare exact instances in Python
+    (usually, you need to use ``==`` to compare things). ``is`` compares
+    objects by memory address, and is very fast.
+
+    Examples
+    ========
+
+    >>> from sympy import S, Integer
+    >>> a = Integer(0)
+    >>> a is S.Zero
+    True
+
+    For the most part, the fact that certain objects are singletonized is an
+    implementation detail that users should not need to worry about. In SymPy
+    library code, ``is`` comparison is often used for performance purposes
+    The primary advantage of ``S`` for end users is the convenient access to
+    certain instances that are otherwise difficult to type, like ``S.Half``
+    (instead of ``Rational(1, 2)``).
+
+    When using ``is`` comparison, make sure the argument is sympified. For
+    instance,
+
+    >>> x = 0
+    >>> x is S.Zero
+    False
+
+    This problem is not an issue when using ``==``, which is recommended for
+    most use-cases:
+
+    >>> 0 == S.Zero
+    True
+
+    The second thing ``S`` is is a shortcut for
+    :func:`sympy.core.sympify.sympify`. :func:`sympy.core.sympify.sympify` is
+    the function that converts Python objects such as ``int(1)`` into SymPy
+    objects such as ``Integer(1)``. It also converts the string form of an
+    expression into a SymPy expression, like ``sympify("x**2")`` ->
+    ``Symbol("x")**2``. ``S(1)`` is the same thing as ``sympify(1)``
+    (basically, ``S.__call__`` has been defined to call ``sympify``).
+
+    This is for convenience, since ``S`` is a single letter. It's mostly
+    useful for defining rational numbers. Consider an expression like ``x +
+    1/2``. If you enter this directly in Python, it will evaluate the ``1/2``
+    and give ``0.5``, because both arguments are ints (see also
+    :ref:`tutorial-gotchas-final-notes`). However, in SymPy, you usually want
+    the quotient of two integers to give an exact rational number. The way
+    Python's evaluation works, at least one side of an operator needs to be a
+    SymPy object for the SymPy evaluation to take over. You could write this
+    as ``x + Rational(1, 2)``, but this is a lot more typing. A shorter
+    version is ``x + S(1)/2``. Since ``S(1)`` returns ``Integer(1)``, the
+    division will return a ``Rational`` type, since it will call
+    ``Integer.__truediv__``, which knows how to return a ``Rational``.
+
+    """
+    __slots__ = ()
+
+    Zero: _Zero
+    One: _One
+    NegativeOne: _NegativeOne
+    Half: _Half
+    Infinity: _Infinity
+    NegativeInfinity: _NegativeInfinity
+    ComplexInfinity: _ComplexInfinity
+    NaN: _NaN
+
+    # Also allow things like S(5)
+    __call__ = staticmethod(sympify)
+
+    def __init__(self):
+        self._classes_to_install = {}
+        # Dict of classes that have been registered, but that have not have been
+        # installed as an attribute of this SingletonRegistry.
+        # Installation automatically happens at the first attempt to access the
+        # attribute.
+        # The purpose of this is to allow registration during class
+        # initialization during import, but not trigger object creation until
+        # actual use (which should not happen until after all imports are
+        # finished).
+
+    def register(self, cls):
+        # Make sure a duplicate class overwrites the old one
+        if hasattr(self, cls.__name__):
+            delattr(self, cls.__name__)
+        self._classes_to_install[cls.__name__] = cls
+
+    def __getattr__(self, name):
+        """Python calls __getattr__ if no attribute of that name was installed
+        yet.
+
+        Explanation
+        ===========
+
+        This __getattr__ checks whether a class with the requested name was
+        already registered but not installed; if no, raises an AttributeError.
+        Otherwise, retrieves the class, calculates its singleton value, installs
+        it as an attribute of the given name, and unregisters the class."""
+        if name not in self._classes_to_install:
+            raise AttributeError(
+                "Attribute '%s' was not installed on SymPy registry %s" % (
+                name, self))
+        class_to_install = self._classes_to_install[name]
+        value_to_install = class_to_install()
+        self.__setattr__(name, value_to_install)
+        del self._classes_to_install[name]
+        return value_to_install
+
+    def __repr__(self):
+        return "S"
+
+S = SingletonRegistry()
+
+
+class Singleton(type):
+    """
+    Metaclass for singleton classes.
+
+    Explanation
+    ===========
+
+    A singleton class has only one instance which is returned every time the
+    class is instantiated. Additionally, this instance can be accessed through
+    the global registry object ``S`` as ``S.``.
+
+    Examples
+    ========
+
+        >>> from sympy import S, Basic
+        >>> from sympy.core.singleton import Singleton
+        >>> class MySingleton(Basic, metaclass=Singleton):
+        ...     pass
+        >>> Basic() is Basic()
+        False
+        >>> MySingleton() is MySingleton()
+        True
+        >>> S.MySingleton is MySingleton()
+        True
+
+    Notes
+    =====
+
+    Instance creation is delayed until the first time the value is accessed.
+    (SymPy versions before 1.0 would create the instance during class
+    creation time, which would be prone to import cycles.)
+    """
+    def __init__(cls, *args, **kwargs):
+        cls._instance = obj = Basic.__new__(cls)
+        cls.__new__ = lambda cls: obj
+        cls.__getnewargs__ = lambda obj: ()
+        cls.__getstate__ = lambda obj: None
+        S.register(cls)
+
+
+# Delayed to avoid cyclic import
+from .basic import Basic
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/sorting.py b/.venv/lib/python3.12/site-packages/sympy/core/sorting.py
new file mode 100644
index 0000000000000000000000000000000000000000..399a7efa1f6cbe1ebdf6307c14b411df36fc7de0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/sorting.py
@@ -0,0 +1,312 @@
+from collections import defaultdict
+
+from .sympify import sympify, SympifyError
+from sympy.utilities.iterables import iterable, uniq
+
+
+__all__ = ['default_sort_key', 'ordered']
+
+
+def default_sort_key(item, order=None):
+    """Return a key that can be used for sorting.
+
+    The key has the structure:
+
+    (class_key, (len(args), args), exponent.sort_key(), coefficient)
+
+    This key is supplied by the sort_key routine of Basic objects when
+    ``item`` is a Basic object or an object (other than a string) that
+    sympifies to a Basic object. Otherwise, this function produces the
+    key.
+
+    The ``order`` argument is passed along to the sort_key routine and is
+    used to determine how the terms *within* an expression are ordered.
+    (See examples below) ``order`` options are: 'lex', 'grlex', 'grevlex',
+    and reversed values of the same (e.g. 'rev-lex'). The default order
+    value is None (which translates to 'lex').
+
+    Examples
+    ========
+
+    >>> from sympy import S, I, default_sort_key, sin, cos, sqrt
+    >>> from sympy.core.function import UndefinedFunction
+    >>> from sympy.abc import x
+
+    The following are equivalent ways of getting the key for an object:
+
+    >>> x.sort_key() == default_sort_key(x)
+    True
+
+    Here are some examples of the key that is produced:
+
+    >>> default_sort_key(UndefinedFunction('f'))
+    ((0, 0, 'UndefinedFunction'), (1, ('f',)), ((1, 0, 'Number'),
+        (0, ()), (), 1), 1)
+    >>> default_sort_key('1')
+    ((0, 0, 'str'), (1, ('1',)), ((1, 0, 'Number'), (0, ()), (), 1), 1)
+    >>> default_sort_key(S.One)
+    ((1, 0, 'Number'), (0, ()), (), 1)
+    >>> default_sort_key(2)
+    ((1, 0, 'Number'), (0, ()), (), 2)
+
+    While sort_key is a method only defined for SymPy objects,
+    default_sort_key will accept anything as an argument so it is
+    more robust as a sorting key. For the following, using key=
+    lambda i: i.sort_key() would fail because 2 does not have a sort_key
+    method; that's why default_sort_key is used. Note, that it also
+    handles sympification of non-string items likes ints:
+
+    >>> a = [2, I, -I]
+    >>> sorted(a, key=default_sort_key)
+    [2, -I, I]
+
+    The returned key can be used anywhere that a key can be specified for
+    a function, e.g. sort, min, max, etc...:
+
+    >>> a.sort(key=default_sort_key); a[0]
+    2
+    >>> min(a, key=default_sort_key)
+    2
+
+    Notes
+    =====
+
+    The key returned is useful for getting items into a canonical order
+    that will be the same across platforms. It is not directly useful for
+    sorting lists of expressions:
+
+    >>> a, b = x, 1/x
+
+    Since ``a`` has only 1 term, its value of sort_key is unaffected by
+    ``order``:
+
+    >>> a.sort_key() == a.sort_key('rev-lex')
+    True
+
+    If ``a`` and ``b`` are combined then the key will differ because there
+    are terms that can be ordered:
+
+    >>> eq = a + b
+    >>> eq.sort_key() == eq.sort_key('rev-lex')
+    False
+    >>> eq.as_ordered_terms()
+    [x, 1/x]
+    >>> eq.as_ordered_terms('rev-lex')
+    [1/x, x]
+
+    But since the keys for each of these terms are independent of ``order``'s
+    value, they do not sort differently when they appear separately in a list:
+
+    >>> sorted(eq.args, key=default_sort_key)
+    [1/x, x]
+    >>> sorted(eq.args, key=lambda i: default_sort_key(i, order='rev-lex'))
+    [1/x, x]
+
+    The order of terms obtained when using these keys is the order that would
+    be obtained if those terms were *factors* in a product.
+
+    Although it is useful for quickly putting expressions in canonical order,
+    it does not sort expressions based on their complexity defined by the
+    number of operations, power of variables and others:
+
+    >>> sorted([sin(x)*cos(x), sin(x)], key=default_sort_key)
+    [sin(x)*cos(x), sin(x)]
+    >>> sorted([x, x**2, sqrt(x), x**3], key=default_sort_key)
+    [sqrt(x), x, x**2, x**3]
+
+    See Also
+    ========
+
+    ordered, sympy.core.expr.Expr.as_ordered_factors, sympy.core.expr.Expr.as_ordered_terms
+
+    """
+    from .basic import Basic
+    from .singleton import S
+
+    if isinstance(item, Basic):
+        return item.sort_key(order=order)
+
+    if iterable(item, exclude=str):
+        if isinstance(item, dict):
+            args = item.items()
+            unordered = True
+        elif isinstance(item, set):
+            args = item
+            unordered = True
+        else:
+            # e.g. tuple, list
+            args = list(item)
+            unordered = False
+
+        args = [default_sort_key(arg, order=order) for arg in args]
+
+        if unordered:
+            # e.g. dict, set
+            args = sorted(args)
+
+        cls_index, args = 10, (len(args), tuple(args))
+    else:
+        if not isinstance(item, str):
+            try:
+                item = sympify(item, strict=True)
+            except SympifyError:
+                # e.g. lambda x: x
+                pass
+            else:
+                if isinstance(item, Basic):
+                    # e.g int -> Integer
+                    return default_sort_key(item)
+                # e.g. UndefinedFunction
+
+        # e.g. str
+        cls_index, args = 0, (1, (str(item),))
+
+    return (cls_index, 0, item.__class__.__name__
+            ), args, S.One.sort_key(), S.One
+
+
+def _node_count(e):
+    # this not only counts nodes, it affirms that the
+    # args are Basic (i.e. have an args property). If
+    # some object has a non-Basic arg, it needs to be
+    # fixed since it is intended that all Basic args
+    # are of Basic type (though this is not easy to enforce).
+    if e.is_Float:
+        return 0.5
+    return 1 + sum(map(_node_count, e.args))
+
+
+def _nodes(e):
+    """
+    A helper for ordered() which returns the node count of ``e`` which
+    for Basic objects is the number of Basic nodes in the expression tree
+    but for other objects is 1 (unless the object is an iterable or dict
+    for which the sum of nodes is returned).
+    """
+    from .basic import Basic
+    from .function import Derivative
+
+    if isinstance(e, Basic):
+        if isinstance(e, Derivative):
+            return _nodes(e.expr) + sum(i[1] if i[1].is_Number else
+                _nodes(i[1]) for i in e.variable_count)
+        return _node_count(e)
+    elif iterable(e):
+        return 1 + sum(_nodes(ei) for ei in e)
+    elif isinstance(e, dict):
+        return 1 + sum(_nodes(k) + _nodes(v) for k, v in e.items())
+    else:
+        return 1
+
+
+def ordered(seq, keys=None, default=True, warn=False):
+    """Return an iterator of the seq where keys are used to break ties
+    in a conservative fashion: if, after applying a key, there are no
+    ties then no other keys will be computed.
+
+    Two default keys will be applied if 1) keys are not provided or
+    2) the given keys do not resolve all ties (but only if ``default``
+    is True). The two keys are ``_nodes`` (which places smaller
+    expressions before large) and ``default_sort_key`` which (if the
+    ``sort_key`` for an object is defined properly) should resolve
+    any ties. This strategy is similar to sorting done by
+    ``Basic.compare``, but differs in that ``ordered`` never makes a
+    decision based on an objects name.
+
+    If ``warn`` is True then an error will be raised if there were no
+    keys remaining to break ties. This can be used if it was expected that
+    there should be no ties between items that are not identical.
+
+    Examples
+    ========
+
+    >>> from sympy import ordered, count_ops
+    >>> from sympy.abc import x, y
+
+    The count_ops is not sufficient to break ties in this list and the first
+    two items appear in their original order (i.e. the sorting is stable):
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3],
+    ...    count_ops, default=False, warn=False))
+    ...
+    [y + 2, x + 2, x**2 + y + 3]
+
+    The default_sort_key allows the tie to be broken:
+
+    >>> list(ordered([y + 2, x + 2, x**2 + y + 3]))
+    ...
+    [x + 2, y + 2, x**2 + y + 3]
+
+    Here, sequences are sorted by length, then sum:
+
+    >>> seq, keys = [[[1, 2, 1], [0, 3, 1], [1, 1, 3], [2], [1]], [
+    ...    lambda x: len(x),
+    ...    lambda x: sum(x)]]
+    ...
+    >>> list(ordered(seq, keys, default=False, warn=False))
+    [[1], [2], [1, 2, 1], [0, 3, 1], [1, 1, 3]]
+
+    If ``warn`` is True, an error will be raised if there were not
+    enough keys to break ties:
+
+    >>> list(ordered(seq, keys, default=False, warn=True))
+    Traceback (most recent call last):
+    ...
+    ValueError: not enough keys to break ties
+
+
+    Notes
+    =====
+
+    The decorated sort is one of the fastest ways to sort a sequence for
+    which special item comparison is desired: the sequence is decorated,
+    sorted on the basis of the decoration (e.g. making all letters lower
+    case) and then undecorated. If one wants to break ties for items that
+    have the same decorated value, a second key can be used. But if the
+    second key is expensive to compute then it is inefficient to decorate
+    all items with both keys: only those items having identical first key
+    values need to be decorated. This function applies keys successively
+    only when needed to break ties. By yielding an iterator, use of the
+    tie-breaker is delayed as long as possible.
+
+    This function is best used in cases when use of the first key is
+    expected to be a good hashing function; if there are no unique hashes
+    from application of a key, then that key should not have been used. The
+    exception, however, is that even if there are many collisions, if the
+    first group is small and one does not need to process all items in the
+    list then time will not be wasted sorting what one was not interested
+    in. For example, if one were looking for the minimum in a list and
+    there were several criteria used to define the sort order, then this
+    function would be good at returning that quickly if the first group
+    of candidates is small relative to the number of items being processed.
+
+    """
+
+    d = defaultdict(list)
+    if keys:
+        if isinstance(keys, (list, tuple)):
+            keys = list(keys)
+            f = keys.pop(0)
+        else:
+            f = keys
+            keys = []
+        for a in seq:
+            d[f(a)].append(a)
+    else:
+        if not default:
+            raise ValueError('if default=False then keys must be provided')
+        d[None].extend(seq)
+
+    for k, value in sorted(d.items()):
+        if len(value) > 1:
+            if keys:
+                value = ordered(value, keys, default, warn)
+            elif default:
+                value = ordered(value, (_nodes, default_sort_key,),
+                               default=False, warn=warn)
+            elif warn:
+                u = list(uniq(value))
+                if len(u) > 1:
+                    raise ValueError(
+                        'not enough keys to break ties: %s' % u)
+        yield from value
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/symbol.py b/.venv/lib/python3.12/site-packages/sympy/core/symbol.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e03ff0c84c1668b70ec5b3d7f8bc854a2e5e4ac
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/symbol.py
@@ -0,0 +1,993 @@
+from __future__ import annotations
+
+
+from .assumptions import StdFactKB, _assume_defined
+from .basic import Basic, Atom
+from .cache import cacheit
+from .containers import Tuple
+from .expr import Expr, AtomicExpr
+from .function import AppliedUndef, FunctionClass
+from .kind import NumberKind, UndefinedKind
+from .logic import fuzzy_bool
+from .singleton import S
+from .sorting import ordered
+from .sympify import sympify
+from sympy.logic.boolalg import Boolean
+from sympy.utilities.iterables import sift, is_sequence
+from sympy.utilities.misc import filldedent
+
+import string
+import re as _re
+import random
+from itertools import product
+from typing import Any
+
+
+class Str(Atom):
+    """
+    Represents string in SymPy.
+
+    Explanation
+    ===========
+
+    Previously, ``Symbol`` was used where string is needed in ``args`` of SymPy
+    objects, e.g. denoting the name of the instance. However, since ``Symbol``
+    represents mathematical scalar, this class should be used instead.
+
+    """
+    __slots__ = ('name',)
+
+    def __new__(cls, name, **kwargs):
+        if not isinstance(name, str):
+            raise TypeError("name should be a string, not %s" % repr(type(name)))
+        obj = Expr.__new__(cls, **kwargs)
+        obj.name = name
+        return obj
+
+    def __getnewargs__(self):
+        return (self.name,)
+
+    def _hashable_content(self):
+        return (self.name,)
+
+
+def _filter_assumptions(kwargs):
+    """Split the given dict into assumptions and non-assumptions.
+    Keys are taken as assumptions if they correspond to an
+    entry in ``_assume_defined``.
+    """
+    assumptions, nonassumptions = map(dict, sift(kwargs.items(),
+        lambda i: i[0] in _assume_defined,
+        binary=True))
+    Symbol._sanitize(assumptions)
+    return assumptions, nonassumptions
+
+def _symbol(s, matching_symbol=None, **assumptions):
+    """Return s if s is a Symbol, else if s is a string, return either
+    the matching_symbol if the names are the same or else a new symbol
+    with the same assumptions as the matching symbol (or the
+    assumptions as provided).
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> from sympy.core.symbol import _symbol
+    >>> _symbol('y')
+    y
+    >>> _.is_real is None
+    True
+    >>> _symbol('y', real=True).is_real
+    True
+
+    >>> x = Symbol('x')
+    >>> _symbol(x, real=True)
+    x
+    >>> _.is_real is None  # ignore attribute if s is a Symbol
+    True
+
+    Below, the variable sym has the name 'foo':
+
+    >>> sym = Symbol('foo', real=True)
+
+    Since 'x' is not the same as sym's name, a new symbol is created:
+
+    >>> _symbol('x', sym).name
+    'x'
+
+    It will acquire any assumptions give:
+
+    >>> _symbol('x', sym, real=False).is_real
+    False
+
+    Since 'foo' is the same as sym's name, sym is returned
+
+    >>> _symbol('foo', sym)
+    foo
+
+    Any assumptions given are ignored:
+
+    >>> _symbol('foo', sym, real=False).is_real
+    True
+
+    NB: the symbol here may not be the same as a symbol with the same
+    name defined elsewhere as a result of different assumptions.
+
+    See Also
+    ========
+
+    sympy.core.symbol.Symbol
+
+    """
+    if isinstance(s, str):
+        if matching_symbol and matching_symbol.name == s:
+            return matching_symbol
+        return Symbol(s, **assumptions)
+    elif isinstance(s, Symbol):
+        return s
+    else:
+        raise ValueError('symbol must be string for symbol name or Symbol')
+
+def uniquely_named_symbol(xname, exprs=(), compare=str, modify=None, **assumptions):
+    """
+    Return a symbol whose name is derivated from *xname* but is unique
+    from any other symbols in *exprs*.
+
+    *xname* and symbol names in *exprs* are passed to *compare* to be
+    converted to comparable forms. If ``compare(xname)`` is not unique,
+    it is recursively passed to *modify* until unique name is acquired.
+
+    Parameters
+    ==========
+
+    xname : str or Symbol
+        Base name for the new symbol.
+
+    exprs : Expr or iterable of Expr
+        Expressions whose symbols are compared to *xname*.
+
+    compare : function
+        Unary function which transforms *xname* and symbol names from
+        *exprs* to comparable form.
+
+    modify : function
+        Unary function which modifies the string. Default is appending
+        the number, or increasing the number if exists.
+
+    Examples
+    ========
+
+    By default, a number is appended to *xname* to generate unique name.
+    If the number already exists, it is recursively increased.
+
+    >>> from sympy.core.symbol import uniquely_named_symbol, Symbol
+    >>> uniquely_named_symbol('x', Symbol('x'))
+    x0
+    >>> uniquely_named_symbol('x', (Symbol('x'), Symbol('x0')))
+    x1
+    >>> uniquely_named_symbol('x0', (Symbol('x1'), Symbol('x0')))
+    x2
+
+    Name generation can be controlled by passing *modify* parameter.
+
+    >>> from sympy.abc import x
+    >>> uniquely_named_symbol('x', x, modify=lambda s: 2*s)
+    xx
+
+    """
+    def numbered_string_incr(s, start=0):
+        if not s:
+            return str(start)
+        i = len(s) - 1
+        while i != -1:
+            if not s[i].isdigit():
+                break
+            i -= 1
+        n = str(int(s[i + 1:] or start - 1) + 1)
+        return s[:i + 1] + n
+
+    default = None
+    if is_sequence(xname):
+        xname, default = xname
+    x = compare(xname)
+    if not exprs:
+        return _symbol(x, default, **assumptions)
+    if not is_sequence(exprs):
+        exprs = [exprs]
+    names = set().union(
+        [i.name for e in exprs for i in e.atoms(Symbol)] +
+        [i.func.name for e in exprs for i in e.atoms(AppliedUndef)])
+    if modify is None:
+        modify = numbered_string_incr
+    while any(x == compare(s) for s in names):
+        x = modify(x)
+    return _symbol(x, default, **assumptions)
+_uniquely_named_symbol = uniquely_named_symbol
+
+
+# XXX: We need type: ignore below because Expr and Boolean are incompatible as
+# superclasses. Really Symbol should not be a subclass of Boolean.
+
+
+class Symbol(AtomicExpr, Boolean): # type: ignore
+    """
+    Symbol class is used to create symbolic variables.
+
+    Explanation
+    ===========
+
+    Symbolic variables are placeholders for mathematical symbols that can represent numbers, constants, or any other mathematical entities and can be used in mathematical expressions and to perform symbolic computations.
+
+    Assumptions:
+
+    commutative = True
+    positive = True
+    real = True
+    imaginary = True
+    complex = True
+    complete list of more assumptions- :ref:`predicates`
+
+    You can override the default assumptions in the constructor.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol
+    >>> x = Symbol("x", positive=True)
+    >>> x.is_positive
+    True
+    >>> x.is_negative
+    False
+
+    passing in greek letters:
+
+    >>> from sympy import Symbol
+    >>> alpha = Symbol('alpha')
+    >>> alpha #doctest: +SKIP
+    α
+
+    Trailing digits are automatically treated like subscripts of what precedes them in the name.
+    General format to add subscript to a symbol :
+    `` = Symbol('_')``
+
+    >>> from sympy import Symbol
+    >>> alpha_i = Symbol('alpha_i')
+    >>> alpha_i #doctest: +SKIP
+    αᵢ
+
+    Parameters
+    ==========
+
+    AtomicExpr: variable name
+    Boolean: Assumption with a boolean value(True or False)
+    """
+
+    is_comparable = False
+
+    __slots__ = ('name', '_assumptions_orig', '_assumptions0')
+
+    name: str
+
+    is_Symbol = True
+    is_symbol = True
+
+    @property
+    def kind(self):
+        if self.is_commutative:
+            return NumberKind
+        return UndefinedKind
+
+    @property
+    def _diff_wrt(self):
+        """Allow derivatives wrt Symbols.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> x = Symbol('x')
+        >>> x._diff_wrt
+        True
+        """
+        return True
+
+    @staticmethod
+    def _sanitize(assumptions, obj=None):
+        """Remove None, convert values to bool, check commutativity *in place*.
+        """
+
+        # be strict about commutativity: cannot be None
+        is_commutative = fuzzy_bool(assumptions.get('commutative', True))
+        if is_commutative is None:
+            whose = '%s ' % obj.__name__ if obj else ''
+            raise ValueError(
+                '%scommutativity must be True or False.' % whose)
+
+        # sanitize other assumptions so 1 -> True and 0 -> False
+        for key in list(assumptions.keys()):
+            v = assumptions[key]
+            if v is None:
+                assumptions.pop(key)
+                continue
+            assumptions[key] = bool(v)
+
+    def _merge(self, assumptions):
+        base = self.assumptions0
+        for k in set(assumptions) & set(base):
+            if assumptions[k] != base[k]:
+                raise ValueError(filldedent('''
+                    non-matching assumptions for %s: existing value
+                    is %s and new value is %s''' % (
+                    k, base[k], assumptions[k])))
+        base.update(assumptions)
+        return base
+
+    def __new__(cls, name, **assumptions):
+        """Symbols are identified by name and assumptions::
+
+        >>> from sympy import Symbol
+        >>> Symbol("x") == Symbol("x")
+        True
+        >>> Symbol("x", real=True) == Symbol("x", real=False)
+        False
+
+        """
+        cls._sanitize(assumptions, cls)
+        return Symbol.__xnew_cached_(cls, name, **assumptions)
+
+
+    @staticmethod
+    @cacheit
+    def _canonical_assumptions(**assumptions):
+        # This is retained purely so that srepr can include commutative=True if
+        # that was explicitly specified but not if it was not. Ideally srepr
+        # should not distinguish these cases because the symbols otherwise
+        # compare equal and are considered equivalent.
+        #
+        # See https://github.com/sympy/sympy/issues/8873
+        #
+        assumptions_orig = assumptions.copy()
+
+        # The only assumption that is assumed by default is commutative=True:
+        assumptions.setdefault('commutative', True)
+
+        assumptions_kb = StdFactKB(assumptions)
+        assumptions0 = dict(assumptions_kb)
+
+        return assumptions_kb, assumptions_orig, assumptions0
+
+    @staticmethod
+    def __xnew__(cls, name, **assumptions):  # never cached (e.g. dummy)
+        if not isinstance(name, str):
+            raise TypeError("name should be a string, not %s" % repr(type(name)))
+
+
+        obj = Expr.__new__(cls)
+        obj.name = name
+
+        assumptions_kb, assumptions_orig, assumptions0 = Symbol._canonical_assumptions(**assumptions)
+
+        obj._assumptions = assumptions_kb
+        obj._assumptions_orig = assumptions_orig
+        obj._assumptions0 = tuple(sorted(assumptions0.items()))
+
+        # The three assumptions dicts are all a little different:
+        #
+        #   >>> from sympy import Symbol
+        #   >>> x = Symbol('x', finite=True)
+        #   >>> x.is_positive  # query an assumption
+        #   >>> x._assumptions
+        #   {'finite': True, 'infinite': False, 'commutative': True, 'positive': None}
+        #   >>> x._assumptions0
+        #   {'finite': True, 'infinite': False, 'commutative': True}
+        #   >>> x._assumptions_orig
+        #   {'finite': True}
+        #
+        # Two symbols with the same name are equal if their _assumptions0 are
+        # the same. Arguably it should be _assumptions_orig that is being
+        # compared because that is more transparent to the user (it is
+        # what was passed to the constructor modulo changes made by _sanitize).
+
+        return obj
+
+    @staticmethod
+    @cacheit
+    def __xnew_cached_(cls, name, **assumptions):  # symbols are always cached
+        return Symbol.__xnew__(cls, name, **assumptions)
+
+    def __getnewargs_ex__(self):
+        return ((self.name,), self._assumptions_orig)
+
+    # NOTE: __setstate__ is not needed for pickles created by __getnewargs_ex__
+    # but was used before Symbol was changed to use __getnewargs_ex__ in v1.9.
+    # Pickles created in previous SymPy versions will still need __setstate__
+    # so that they can be unpickled in SymPy > v1.9.
+
+    def __setstate__(self, state):
+        for name, value in state.items():
+            setattr(self, name, value)
+
+    def _hashable_content(self):
+        return (self.name,) + self._assumptions0
+
+    def _eval_subs(self, old, new):
+        if old.is_Pow:
+            from sympy.core.power import Pow
+            return Pow(self, S.One, evaluate=False)._eval_subs(old, new)
+
+    def _eval_refine(self, assumptions):
+        return self
+
+    @property
+    def assumptions0(self):
+        return dict(self._assumptions0)
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (1, (self.name,)), S.One.sort_key(), S.One
+
+    def as_dummy(self):
+        # only put commutativity in explicitly if it is False
+        return Dummy(self.name) if self.is_commutative is not False \
+            else Dummy(self.name, commutative=self.is_commutative)
+
+    def as_real_imag(self, deep=True, **hints):
+        if hints.get('ignore') == self:
+            return None
+        else:
+            from sympy.functions.elementary.complexes import im, re
+            return (re(self), im(self))
+
+    def is_constant(self, *wrt, **flags):
+        if not wrt:
+            return False
+        return self not in wrt
+
+    @property
+    def free_symbols(self):
+        return {self}
+
+    binary_symbols = free_symbols  # in this case, not always
+
+    def as_set(self):
+        return S.UniversalSet
+
+
+class Dummy(Symbol):
+    """Dummy symbols are each unique, even if they have the same name:
+
+    Examples
+    ========
+
+    >>> from sympy import Dummy
+    >>> Dummy("x") == Dummy("x")
+    False
+
+    If a name is not supplied then a string value of an internal count will be
+    used. This is useful when a temporary variable is needed and the name
+    of the variable used in the expression is not important.
+
+    >>> Dummy() #doctest: +SKIP
+    _Dummy_10
+
+    """
+
+    # In the rare event that a Dummy object needs to be recreated, both the
+    # `name` and `dummy_index` should be passed.  This is used by `srepr` for
+    # example:
+    # >>> d1 = Dummy()
+    # >>> d2 = eval(srepr(d1))
+    # >>> d2 == d1
+    # True
+    #
+    # If a new session is started between `srepr` and `eval`, there is a very
+    # small chance that `d2` will be equal to a previously-created Dummy.
+
+    _count = 0
+    _prng = random.Random()
+    _base_dummy_index = _prng.randint(10**6, 9*10**6)
+
+    __slots__ = ('dummy_index',)
+
+    is_Dummy = True
+
+    def __new__(cls, name=None, dummy_index=None, **assumptions):
+        if dummy_index is not None:
+            assert name is not None, "If you specify a dummy_index, you must also provide a name"
+
+        if name is None:
+            name = "Dummy_" + str(Dummy._count)
+
+        if dummy_index is None:
+            dummy_index = Dummy._base_dummy_index + Dummy._count
+            Dummy._count += 1
+
+        cls._sanitize(assumptions, cls)
+        obj = Symbol.__xnew__(cls, name, **assumptions)
+
+        obj.dummy_index = dummy_index
+
+        return obj
+
+    def __getnewargs_ex__(self):
+        return ((self.name, self.dummy_index), self._assumptions_orig)
+
+    @cacheit
+    def sort_key(self, order=None):
+        return self.class_key(), (
+            2, (self.name, self.dummy_index)), S.One.sort_key(), S.One
+
+    def _hashable_content(self):
+        return Symbol._hashable_content(self) + (self.dummy_index,)
+
+
+class Wild(Symbol):
+    """
+    A Wild symbol matches anything, or anything
+    without whatever is explicitly excluded.
+
+    Parameters
+    ==========
+
+    name : str
+        Name of the Wild instance.
+
+    exclude : iterable, optional
+        Instances in ``exclude`` will not be matched.
+
+    properties : iterable of functions, optional
+        Functions, each taking an expressions as input
+        and returns a ``bool``. All functions in ``properties``
+        need to return ``True`` in order for the Wild instance
+        to match the expression.
+
+    Examples
+    ========
+
+    >>> from sympy import Wild, WildFunction, cos, pi
+    >>> from sympy.abc import x, y, z
+    >>> a = Wild('a')
+    >>> x.match(a)
+    {a_: x}
+    >>> pi.match(a)
+    {a_: pi}
+    >>> (3*x**2).match(a*x)
+    {a_: 3*x}
+    >>> cos(x).match(a)
+    {a_: cos(x)}
+    >>> b = Wild('b', exclude=[x])
+    >>> (3*x**2).match(b*x)
+    >>> b.match(a)
+    {a_: b_}
+    >>> A = WildFunction('A')
+    >>> A.match(a)
+    {a_: A_}
+
+    Tips
+    ====
+
+    When using Wild, be sure to use the exclude
+    keyword to make the pattern more precise.
+    Without the exclude pattern, you may get matches
+    that are technically correct, but not what you
+    wanted. For example, using the above without
+    exclude:
+
+    >>> from sympy import symbols
+    >>> a, b = symbols('a b', cls=Wild)
+    >>> (2 + 3*y).match(a*x + b*y)
+    {a_: 2/x, b_: 3}
+
+    This is technically correct, because
+    (2/x)*x + 3*y == 2 + 3*y, but you probably
+    wanted it to not match at all. The issue is that
+    you really did not want a and b to include x and y,
+    and the exclude parameter lets you specify exactly
+    this.  With the exclude parameter, the pattern will
+    not match.
+
+    >>> a = Wild('a', exclude=[x, y])
+    >>> b = Wild('b', exclude=[x, y])
+    >>> (2 + 3*y).match(a*x + b*y)
+
+    Exclude also helps remove ambiguity from matches.
+
+    >>> E = 2*x**3*y*z
+    >>> a, b = symbols('a b', cls=Wild)
+    >>> E.match(a*b)
+    {a_: 2*y*z, b_: x**3}
+    >>> a = Wild('a', exclude=[x, y])
+    >>> E.match(a*b)
+    {a_: z, b_: 2*x**3*y}
+    >>> a = Wild('a', exclude=[x, y, z])
+    >>> E.match(a*b)
+    {a_: 2, b_: x**3*y*z}
+
+    Wild also accepts a ``properties`` parameter:
+
+    >>> a = Wild('a', properties=[lambda k: k.is_Integer])
+    >>> E.match(a*b)
+    {a_: 2, b_: x**3*y*z}
+
+    """
+    is_Wild = True
+
+    __slots__ = ('exclude', 'properties')
+
+    def __new__(cls, name, exclude=(), properties=(), **assumptions):
+        exclude = tuple([sympify(x) for x in exclude])
+        properties = tuple(properties)
+        cls._sanitize(assumptions, cls)
+        return Wild.__xnew__(cls, name, exclude, properties, **assumptions)
+
+    def __getnewargs__(self):
+        return (self.name, self.exclude, self.properties)
+
+    @staticmethod
+    @cacheit
+    def __xnew__(cls, name, exclude, properties, **assumptions):
+        obj = Symbol.__xnew__(cls, name, **assumptions)
+        obj.exclude = exclude
+        obj.properties = properties
+        return obj
+
+    def _hashable_content(self):
+        return super()._hashable_content() + (self.exclude, self.properties)
+
+    # TODO add check against another Wild
+    def matches(self, expr, repl_dict=None, old=False):
+        if any(expr.has(x) for x in self.exclude):
+            return None
+        if not all(f(expr) for f in self.properties):
+            return None
+        if repl_dict is None:
+            repl_dict = {}
+        else:
+            repl_dict = repl_dict.copy()
+        repl_dict[self] = expr
+        return repl_dict
+
+
+_range = _re.compile('([0-9]*:[0-9]+|[a-zA-Z]?:[a-zA-Z])')
+
+
+def symbols(names, *, cls=Symbol, **args) -> Any:
+    r"""
+    Transform strings into instances of :class:`Symbol` class.
+
+    :func:`symbols` function returns a sequence of symbols with names taken
+    from ``names`` argument, which can be a comma or whitespace delimited
+    string, or a sequence of strings::
+
+        >>> from sympy import symbols, Function
+
+        >>> x, y, z = symbols('x,y,z')
+        >>> a, b, c = symbols('a b c')
+
+    The type of output is dependent on the properties of input arguments::
+
+        >>> symbols('x')
+        x
+        >>> symbols('x,')
+        (x,)
+        >>> symbols('x,y')
+        (x, y)
+        >>> symbols(('a', 'b', 'c'))
+        (a, b, c)
+        >>> symbols(['a', 'b', 'c'])
+        [a, b, c]
+        >>> symbols({'a', 'b', 'c'})
+        {a, b, c}
+
+    If an iterable container is needed for a single symbol, set the ``seq``
+    argument to ``True`` or terminate the symbol name with a comma::
+
+        >>> symbols('x', seq=True)
+        (x,)
+
+    To reduce typing, range syntax is supported to create indexed symbols.
+    Ranges are indicated by a colon and the type of range is determined by
+    the character to the right of the colon. If the character is a digit
+    then all contiguous digits to the left are taken as the nonnegative
+    starting value (or 0 if there is no digit left of the colon) and all
+    contiguous digits to the right are taken as 1 greater than the ending
+    value::
+
+        >>> symbols('x:10')
+        (x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)
+
+        >>> symbols('x5:10')
+        (x5, x6, x7, x8, x9)
+        >>> symbols('x5(:2)')
+        (x50, x51)
+
+        >>> symbols('x5:10,y:5')
+        (x5, x6, x7, x8, x9, y0, y1, y2, y3, y4)
+
+        >>> symbols(('x5:10', 'y:5'))
+        ((x5, x6, x7, x8, x9), (y0, y1, y2, y3, y4))
+
+    If the character to the right of the colon is a letter, then the single
+    letter to the left (or 'a' if there is none) is taken as the start
+    and all characters in the lexicographic range *through* the letter to
+    the right are used as the range::
+
+        >>> symbols('x:z')
+        (x, y, z)
+        >>> symbols('x:c')  # null range
+        ()
+        >>> symbols('x(:c)')
+        (xa, xb, xc)
+
+        >>> symbols(':c')
+        (a, b, c)
+
+        >>> symbols('a:d, x:z')
+        (a, b, c, d, x, y, z)
+
+        >>> symbols(('a:d', 'x:z'))
+        ((a, b, c, d), (x, y, z))
+
+    Multiple ranges are supported; contiguous numerical ranges should be
+    separated by parentheses to disambiguate the ending number of one
+    range from the starting number of the next::
+
+        >>> symbols('x:2(1:3)')
+        (x01, x02, x11, x12)
+        >>> symbols(':3:2')  # parsing is from left to right
+        (00, 01, 10, 11, 20, 21)
+
+    Only one pair of parentheses surrounding ranges are removed, so to
+    include parentheses around ranges, double them. And to include spaces,
+    commas, or colons, escape them with a backslash::
+
+        >>> symbols('x((a:b))')
+        (x(a), x(b))
+        >>> symbols(r'x(:1\,:2)')  # or r'x((:1)\,(:2))'
+        (x(0,0), x(0,1))
+
+    All newly created symbols have assumptions set according to ``args``::
+
+        >>> a = symbols('a', integer=True)
+        >>> a.is_integer
+        True
+
+        >>> x, y, z = symbols('x,y,z', real=True)
+        >>> x.is_real and y.is_real and z.is_real
+        True
+
+    Despite its name, :func:`symbols` can create symbol-like objects like
+    instances of Function or Wild classes. To achieve this, set ``cls``
+    keyword argument to the desired type::
+
+        >>> symbols('f,g,h', cls=Function)
+        (f, g, h)
+
+        >>> type(_[0])
+        
+
+    """
+    result = []
+
+    if isinstance(names, str):
+        marker = 0
+        splitters = r'\,', r'\:', r'\ '
+        literals: list[tuple[str, str]] = []
+        for splitter in splitters:
+            if splitter in names:
+                while chr(marker) in names:
+                    marker += 1
+                lit_char = chr(marker)
+                marker += 1
+                names = names.replace(splitter, lit_char)
+                literals.append((lit_char, splitter[1:]))
+        def literal(s):
+            if literals:
+                for c, l in literals:
+                    s = s.replace(c, l)
+            return s
+
+        names = names.strip()
+        as_seq = names.endswith(',')
+        if as_seq:
+            names = names[:-1].rstrip()
+        if not names:
+            raise ValueError('no symbols given')
+
+        # split on commas
+        names = [n.strip() for n in names.split(',')]
+        if not all(n for n in names):
+            raise ValueError('missing symbol between commas')
+        # split on spaces
+        for i in range(len(names) - 1, -1, -1):
+            names[i: i + 1] = names[i].split()
+
+        seq = args.pop('seq', as_seq)
+
+        for name in names:
+            if not name:
+                raise ValueError('missing symbol')
+
+            if ':' not in name:
+                symbol = cls(literal(name), **args)
+                result.append(symbol)
+                continue
+
+            split: list[str] = _range.split(name)
+            split_list: list[list[str]] = []
+            # remove 1 layer of bounding parentheses around ranges
+            for i in range(len(split) - 1):
+                if i and ':' in split[i] and split[i] != ':' and \
+                        split[i - 1].endswith('(') and \
+                        split[i + 1].startswith(')'):
+                    split[i - 1] = split[i - 1][:-1]
+                    split[i + 1] = split[i + 1][1:]
+            for s in split:
+                if ':' in s:
+                    if s.endswith(':'):
+                        raise ValueError('missing end range')
+                    a, b = s.split(':')
+                    if b[-1] in string.digits:
+                        a_i = 0 if not a else int(a)
+                        b_i = int(b)
+                        split_list.append([str(c) for c in range(a_i, b_i)])
+                    else:
+                        a = a or 'a'
+                        split_list.append([string.ascii_letters[c] for c in range(
+                            string.ascii_letters.index(a),
+                            string.ascii_letters.index(b) + 1)])  # inclusive
+                    if not split_list[-1]:
+                        break
+                else:
+                    split_list.append([s])
+            else:
+                seq = True
+                if len(split_list) == 1:
+                    names = split_list[0]
+                else:
+                    names = [''.join(s) for s in product(*split_list)]
+                if literals:
+                    result.extend([cls(literal(s), **args) for s in names])
+                else:
+                    result.extend([cls(s, **args) for s in names])
+
+        if not seq and len(result) <= 1:
+            if not result:
+                return ()
+            return result[0]
+
+        return tuple(result)
+    else:
+        for name in names:
+            result.append(symbols(name, cls=cls, **args))
+
+        return type(names)(result)
+
+
+def var(names, **args):
+    """
+    Create symbols and inject them into the global namespace.
+
+    Explanation
+    ===========
+
+    This calls :func:`symbols` with the same arguments and puts the results
+    into the *global* namespace. It's recommended not to use :func:`var` in
+    library code, where :func:`symbols` has to be used::
+
+    Examples
+    ========
+
+    >>> from sympy import var
+
+    >>> var('x')
+    x
+    >>> x # noqa: F821
+    x
+
+    >>> var('a,ab,abc')
+    (a, ab, abc)
+    >>> abc # noqa: F821
+    abc
+
+    >>> var('x,y', real=True)
+    (x, y)
+    >>> x.is_real and y.is_real # noqa: F821
+    True
+
+    See :func:`symbols` documentation for more details on what kinds of
+    arguments can be passed to :func:`var`.
+
+    """
+    def traverse(symbols, frame):
+        """Recursively inject symbols to the global namespace. """
+        for symbol in symbols:
+            if isinstance(symbol, Basic):
+                frame.f_globals[symbol.name] = symbol
+            elif isinstance(symbol, FunctionClass):
+                frame.f_globals[symbol.__name__] = symbol
+            else:
+                traverse(symbol, frame)
+
+    from inspect import currentframe
+    frame = currentframe().f_back
+
+    try:
+        syms = symbols(names, **args)
+
+        if syms is not None:
+            if isinstance(syms, Basic):
+                frame.f_globals[syms.name] = syms
+            elif isinstance(syms, FunctionClass):
+                frame.f_globals[syms.__name__] = syms
+            else:
+                traverse(syms, frame)
+    finally:
+        del frame  # break cyclic dependencies as stated in inspect docs
+
+    return syms
+
+def disambiguate(*iter):
+    """
+    Return a Tuple containing the passed expressions with symbols
+    that appear the same when printed replaced with numerically
+    subscripted symbols, and all Dummy symbols replaced with Symbols.
+
+    Parameters
+    ==========
+
+    iter: list of symbols or expressions.
+
+    Examples
+    ========
+
+    >>> from sympy.core.symbol import disambiguate
+    >>> from sympy import Dummy, Symbol, Tuple
+    >>> from sympy.abc import y
+
+    >>> tup = Symbol('_x'), Dummy('x'), Dummy('x')
+    >>> disambiguate(*tup)
+    (x_2, x, x_1)
+
+    >>> eqs = Tuple(Symbol('x')/y, Dummy('x')/y)
+    >>> disambiguate(*eqs)
+    (x_1/y, x/y)
+
+    >>> ix = Symbol('x', integer=True)
+    >>> vx = Symbol('x')
+    >>> disambiguate(vx + ix)
+    (x + x_1,)
+
+    To make your own mapping of symbols to use, pass only the free symbols
+    of the expressions and create a dictionary:
+
+    >>> free = eqs.free_symbols
+    >>> mapping = dict(zip(free, disambiguate(*free)))
+    >>> eqs.xreplace(mapping)
+    (x_1/y, x/y)
+
+    """
+    new_iter = Tuple(*iter)
+    key = lambda x:tuple(sorted(x.assumptions0.items()))
+    syms = ordered(new_iter.free_symbols, keys=key)
+    mapping = {}
+    for s in syms:
+        mapping.setdefault(str(s).lstrip('_'), []).append(s)
+    reps = {}
+    for k in mapping:
+        # the first or only symbol doesn't get subscripted but make
+        # sure that it's a Symbol, not a Dummy
+        mapk0 = Symbol("%s" % (k), **mapping[k][0].assumptions0)
+        if mapping[k][0] != mapk0:
+            reps[mapping[k][0]] = mapk0
+        # the others get subscripts (and are made into Symbols)
+        skip = 0
+        for i in range(1, len(mapping[k])):
+            while True:
+                name = "%s_%i" % (k, i + skip)
+                if name not in mapping:
+                    break
+                skip += 1
+            ki = mapping[k][i]
+            reps[ki] = Symbol(name, **ki.assumptions0)
+    return new_iter.xreplace(reps)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/sympify.py b/.venv/lib/python3.12/site-packages/sympy/core/sympify.py
new file mode 100644
index 0000000000000000000000000000000000000000..df30fbb85d5f160540312de4eef1d0e6702fc974
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/sympify.py
@@ -0,0 +1,646 @@
+"""sympify -- convert objects SymPy internal format"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, overload, TYPE_CHECKING, TypeVar
+
+import mpmath.libmp as mlib
+
+from inspect import getmro
+import string
+from sympy.core.random import choice
+
+from .parameters import global_parameters
+
+from sympy.utilities.iterables import iterable
+
+
+if TYPE_CHECKING:
+
+    from sympy.core.basic import Basic
+    from sympy.core.expr import Expr
+    from sympy.core.numbers import Integer, Float
+
+    Tbasic = TypeVar('Tbasic', bound=Basic)
+
+
+class SympifyError(ValueError):
+    def __init__(self, expr, base_exc=None):
+        self.expr = expr
+        self.base_exc = base_exc
+
+    def __str__(self):
+        if self.base_exc is None:
+            return "SympifyError: %r" % (self.expr,)
+
+        return ("Sympify of expression '%s' failed, because of exception being "
+            "raised:\n%s: %s" % (self.expr, self.base_exc.__class__.__name__,
+            str(self.base_exc)))
+
+
+converter: dict[type[Any], Callable[[Any], Basic]] = {}
+
+#holds the conversions defined in SymPy itself, i.e. non-user defined conversions
+_sympy_converter: dict[type[Any], Callable[[Any], Basic]] = {}
+
+#alias for clearer use in the library
+_external_converter = converter
+
+class CantSympify:
+    """
+    Mix in this trait to a class to disallow sympification of its instances.
+
+    Examples
+    ========
+
+    >>> from sympy import sympify
+    >>> from sympy.core.sympify import CantSympify
+
+    >>> class Something(dict):
+    ...     pass
+    ...
+    >>> sympify(Something())
+    {}
+
+    >>> class Something(dict, CantSympify):
+    ...     pass
+    ...
+    >>> sympify(Something())
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: {}
+
+    """
+
+    __slots__ = ()
+
+
+def _is_numpy_instance(a):
+    """
+    Checks if an object is an instance of a type from the numpy module.
+    """
+    # This check avoids unnecessarily importing NumPy.  We check the whole
+    # __mro__ in case any base type is a numpy type.
+    return any(type_.__module__ == 'numpy'
+               for type_ in type(a).__mro__)
+
+
+def _convert_numpy_types(a, **sympify_args):
+    """
+    Converts a numpy datatype input to an appropriate SymPy type.
+    """
+    import numpy as np
+    if not isinstance(a, np.floating):
+        if np.iscomplex(a):
+            return _sympy_converter[complex](a.item())
+        else:
+            return sympify(a.item(), **sympify_args)
+    else:
+        from .numbers import Float
+        prec = np.finfo(a).nmant + 1
+        # E.g. double precision means prec=53 but nmant=52
+        # Leading bit of mantissa is always 1, so is not stored
+        if np.isposinf(a):
+            return Float('inf')
+        elif np.isneginf(a):
+            return Float('-inf')
+        else:
+            p, q = a.as_integer_ratio()
+            a = mlib.from_rational(p, q, prec)
+            return Float(a, precision=prec)
+
+
+@overload
+def sympify(a: int, *, strict: bool = False) -> Integer: ... # type: ignore
+@overload
+def sympify(a: float, *, strict: bool = False) -> Float: ...
+@overload
+def sympify(a: Expr | complex, *, strict: bool = False) -> Expr: ...
+@overload
+def sympify(a: Tbasic, *, strict: bool = False) -> Tbasic: ...
+@overload
+def sympify(a: Any, *, strict: bool = False) -> Basic: ...
+
+def sympify(a, locals=None, convert_xor=True, strict=False, rational=False,
+        evaluate=None):
+    """
+    Converts an arbitrary expression to a type that can be used inside SymPy.
+
+    Explanation
+    ===========
+
+    It will convert Python ints into instances of :class:`~.Integer`, floats
+    into instances of :class:`~.Float`, etc. It is also able to coerce
+    symbolic expressions which inherit from :class:`~.Basic`. This can be
+    useful in cooperation with SAGE.
+
+    .. warning::
+        Note that this function uses ``eval``, and thus shouldn't be used on
+        unsanitized input.
+
+    If the argument is already a type that SymPy understands, it will do
+    nothing but return that value. This can be used at the beginning of a
+    function to ensure you are working with the correct type.
+
+    Examples
+    ========
+
+    >>> from sympy import sympify
+
+    >>> sympify(2).is_integer
+    True
+    >>> sympify(2).is_real
+    True
+
+    >>> sympify(2.0).is_real
+    True
+    >>> sympify("2.0").is_real
+    True
+    >>> sympify("2e-45").is_real
+    True
+
+    If the expression could not be converted, a SympifyError is raised.
+
+    >>> sympify("x***2")
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: "could not parse 'x***2'"
+
+    When attempting to parse non-Python syntax using ``sympify``, it raises a
+    ``SympifyError``:
+
+    >>> sympify("2x+1")
+    Traceback (most recent call last):
+    ...
+    SympifyError: Sympify of expression 'could not parse '2x+1'' failed
+
+    To parse non-Python syntax, use ``parse_expr`` from ``sympy.parsing.sympy_parser``.
+
+    >>> from sympy.parsing.sympy_parser import parse_expr
+    >>> parse_expr("2x+1", transformations="all")
+    2*x + 1
+
+    For more details about ``transformations``: see :func:`~sympy.parsing.sympy_parser.parse_expr`
+
+    Locals
+    ------
+
+    The sympification happens with access to everything that is loaded
+    by ``from sympy import *``; anything used in a string that is not
+    defined by that import will be converted to a symbol. In the following,
+    the ``bitcount`` function is treated as a symbol and the ``O`` is
+    interpreted as the :class:`~.Order` object (used with series) and it raises
+    an error when used improperly:
+
+    >>> s = 'bitcount(42)'
+    >>> sympify(s)
+    bitcount(42)
+    >>> sympify("O(x)")
+    O(x)
+    >>> sympify("O + 1")
+    Traceback (most recent call last):
+    ...
+    TypeError: unbound method...
+
+    In order to have ``bitcount`` be recognized it can be imported into a
+    namespace dictionary and passed as locals:
+
+    >>> ns = {}
+    >>> exec('from sympy.core.evalf import bitcount', ns)
+    >>> sympify(s, locals=ns)
+    6
+
+    In order to have the ``O`` interpreted as a Symbol, identify it as such
+    in the namespace dictionary. This can be done in a variety of ways; all
+    three of the following are possibilities:
+
+    >>> from sympy import Symbol
+    >>> ns["O"] = Symbol("O")  # method 1
+    >>> exec('from sympy.abc import O', ns)  # method 2
+    >>> ns.update(dict(O=Symbol("O")))  # method 3
+    >>> sympify("O + 1", locals=ns)
+    O + 1
+
+    If you want *all* single-letter and Greek-letter variables to be symbols
+    then you can use the clashing-symbols dictionaries that have been defined
+    there as private variables: ``_clash1`` (single-letter variables),
+    ``_clash2`` (the multi-letter Greek names) or ``_clash`` (both single and
+    multi-letter names that are defined in ``abc``).
+
+    >>> from sympy.abc import _clash1
+    >>> set(_clash1)  # if this fails, see issue #23903
+    {'E', 'I', 'N', 'O', 'Q', 'S'}
+    >>> sympify('I & Q', _clash1)
+    I & Q
+
+    Strict
+    ------
+
+    If the option ``strict`` is set to ``True``, only the types for which an
+    explicit conversion has been defined are converted. In the other
+    cases, a SympifyError is raised.
+
+    >>> print(sympify(None))
+    None
+    >>> sympify(None, strict=True)
+    Traceback (most recent call last):
+    ...
+    SympifyError: SympifyError: None
+
+    .. deprecated:: 1.6
+
+       ``sympify(obj)`` automatically falls back to ``str(obj)`` when all
+       other conversion methods fail, but this is deprecated. ``strict=True``
+       will disable this deprecated behavior. See
+       :ref:`deprecated-sympify-string-fallback`.
+
+    Evaluation
+    ----------
+
+    If the option ``evaluate`` is set to ``False``, then arithmetic and
+    operators will be converted into their SymPy equivalents and the
+    ``evaluate=False`` option will be added. Nested ``Add`` or ``Mul`` will
+    be denested first. This is done via an AST transformation that replaces
+    operators with their SymPy equivalents, so if an operand redefines any
+    of those operations, the redefined operators will not be used. If
+    argument a is not a string, the mathematical expression is evaluated
+    before being passed to sympify, so adding ``evaluate=False`` will still
+    return the evaluated result of expression.
+
+    >>> sympify('2**2 / 3 + 5')
+    19/3
+    >>> sympify('2**2 / 3 + 5', evaluate=False)
+    2**2/3 + 5
+    >>> sympify('4/2+7', evaluate=True)
+    9
+    >>> sympify('4/2+7', evaluate=False)
+    4/2 + 7
+    >>> sympify(4/2+7, evaluate=False)
+    9.00000000000000
+
+    Extending
+    ---------
+
+    To extend ``sympify`` to convert custom objects (not derived from ``Basic``),
+    just define a ``_sympy_`` method to your class. You can do that even to
+    classes that you do not own by subclassing or adding the method at runtime.
+
+    >>> from sympy import Matrix
+    >>> class MyList1(object):
+    ...     def __iter__(self):
+    ...         yield 1
+    ...         yield 2
+    ...         return
+    ...     def __getitem__(self, i): return list(self)[i]
+    ...     def _sympy_(self): return Matrix(self)
+    >>> sympify(MyList1())
+    Matrix([
+    [1],
+    [2]])
+
+    If you do not have control over the class definition you could also use the
+    ``converter`` global dictionary. The key is the class and the value is a
+    function that takes a single argument and returns the desired SymPy
+    object, e.g. ``converter[MyList] = lambda x: Matrix(x)``.
+
+    >>> class MyList2(object):   # XXX Do not do this if you control the class!
+    ...     def __iter__(self):  #     Use _sympy_!
+    ...         yield 1
+    ...         yield 2
+    ...         return
+    ...     def __getitem__(self, i): return list(self)[i]
+    >>> from sympy.core.sympify import converter
+    >>> converter[MyList2] = lambda x: Matrix(x)
+    >>> sympify(MyList2())
+    Matrix([
+    [1],
+    [2]])
+
+    Notes
+    =====
+
+    The keywords ``rational`` and ``convert_xor`` are only used
+    when the input is a string.
+
+    convert_xor
+    -----------
+
+    >>> sympify('x^y',convert_xor=True)
+    x**y
+    >>> sympify('x^y',convert_xor=False)
+    x ^ y
+
+    rational
+    --------
+
+    >>> sympify('0.1',rational=False)
+    0.1
+    >>> sympify('0.1',rational=True)
+    1/10
+
+    Sometimes autosimplification during sympification results in expressions
+    that are very different in structure than what was entered. Until such
+    autosimplification is no longer done, the ``kernS`` function might be of
+    some use. In the example below you can see how an expression reduces to
+    $-1$ by autosimplification, but does not do so when ``kernS`` is used.
+
+    >>> from sympy.core.sympify import kernS
+    >>> from sympy.abc import x
+    >>> -2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1
+    -1
+    >>> s = '-2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1'
+    >>> sympify(s)
+    -1
+    >>> kernS(s)
+    -2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) - 1
+
+    Parameters
+    ==========
+
+    a :
+        - any object defined in SymPy
+        - standard numeric Python types: ``int``, ``long``, ``float``, ``Decimal``
+        - strings (like ``"0.09"``, ``"2e-19"`` or ``'sin(x)'``)
+        - booleans, including ``None`` (will leave ``None`` unchanged)
+        - dicts, lists, sets or tuples containing any of the above
+
+    convert_xor : bool, optional
+        If true, treats ``^`` as exponentiation.
+        If False, treats ``^`` as XOR itself.
+        Used only when input is a string.
+
+    locals : any object defined in SymPy, optional
+        In order to have strings be recognized it can be imported
+        into a namespace dictionary and passed as locals.
+
+    strict : bool, optional
+        If the option strict is set to ``True``, only the types for which
+        an explicit conversion has been defined are converted. In the
+        other cases, a SympifyError is raised.
+
+    rational : bool, optional
+        If ``True``, converts floats into :class:`~.Rational`.
+        If ``False``, it lets floats remain as it is.
+        Used only when input is a string.
+
+    evaluate : bool, optional
+        If False, then arithmetic and operators will be converted into
+        their SymPy equivalents. If True the expression will be evaluated
+        and the result will be returned.
+
+    """
+    # XXX: If a is a Basic subclass rather than instance (e.g. sin rather than
+    # sin(x)) then a.__sympy__ will be the property. Only on the instance will
+    # a.__sympy__ give the *value* of the property (True). Since sympify(sin)
+    # was used for a long time we allow it to pass. However if strict=True as
+    # is the case in internal calls to _sympify then we only allow
+    # is_sympy=True.
+    #
+    # https://github.com/sympy/sympy/issues/20124
+    is_sympy = getattr(a, '__sympy__', None)
+    if is_sympy is True:
+        return a
+    elif is_sympy is not None:
+        if not strict:
+            return a
+        else:
+            raise SympifyError(a)
+
+    if isinstance(a, CantSympify):
+        raise SympifyError(a)
+
+    cls = getattr(a, "__class__", None)
+
+    #Check if there exists a converter for any of the types in the mro
+    for superclass in getmro(cls):
+        #First check for user defined converters
+        conv = _external_converter.get(superclass)
+        if conv is None:
+            #if none exists, check for SymPy defined converters
+            conv = _sympy_converter.get(superclass)
+        if conv is not None:
+            return conv(a)
+
+    if cls is type(None):
+        if strict:
+            raise SympifyError(a)
+        else:
+            return a
+
+    if evaluate is None:
+        evaluate = global_parameters.evaluate
+
+    # Support for basic numpy datatypes
+    if _is_numpy_instance(a):
+        import numpy as np
+        if np.isscalar(a):
+            return _convert_numpy_types(a, locals=locals,
+                convert_xor=convert_xor, strict=strict, rational=rational,
+                evaluate=evaluate)
+
+    _sympy_ = getattr(a, "_sympy_", None)
+    if _sympy_ is not None:
+        return a._sympy_()
+
+    if not strict:
+        # Put numpy array conversion _before_ float/int, see
+        # .
+        flat = getattr(a, "flat", None)
+        if flat is not None:
+            shape = getattr(a, "shape", None)
+            if shape is not None:
+                from sympy.tensor.array import Array
+                return Array(a.flat, a.shape)  # works with e.g. NumPy arrays
+
+    if not isinstance(a, str):
+        if _is_numpy_instance(a):
+            import numpy as np
+            assert not isinstance(a, np.number)
+            if isinstance(a, np.ndarray):
+                # Scalar arrays (those with zero dimensions) have sympify
+                # called on the scalar element.
+                if a.ndim == 0:
+                    try:
+                        return sympify(a.item(),
+                                       locals=locals,
+                                       convert_xor=convert_xor,
+                                       strict=strict,
+                                       rational=rational,
+                                       evaluate=evaluate)
+                    except SympifyError:
+                        pass
+        elif hasattr(a, '__float__'):
+            # float and int can coerce size-one numpy arrays to their lone
+            # element.  See issue https://github.com/numpy/numpy/issues/10404.
+            return sympify(float(a))
+        elif hasattr(a, '__int__'):
+            return sympify(int(a))
+
+    if strict:
+        raise SympifyError(a)
+
+    if iterable(a):
+        try:
+            return type(a)([sympify(x, locals=locals, convert_xor=convert_xor,
+                rational=rational, evaluate=evaluate) for x in a])
+        except TypeError:
+            # Not all iterables are rebuildable with their type.
+            pass
+
+    if not isinstance(a, str):
+        raise SympifyError('cannot sympify object of type %r' % type(a))
+
+    from sympy.parsing.sympy_parser import (parse_expr, TokenError,
+                                            standard_transformations)
+    from sympy.parsing.sympy_parser import convert_xor as t_convert_xor
+    from sympy.parsing.sympy_parser import rationalize as t_rationalize
+
+    transformations = standard_transformations
+
+    if rational:
+        transformations += (t_rationalize,)
+    if convert_xor:
+        transformations += (t_convert_xor,)
+
+    try:
+        a = a.replace('\n', '')
+        expr = parse_expr(a, local_dict=locals, transformations=transformations, evaluate=evaluate)
+    except (TokenError, SyntaxError) as exc:
+        raise SympifyError('could not parse %r' % a, exc)
+
+    return expr
+
+
+def _sympify(a):
+    """
+    Short version of :func:`~.sympify` for internal usage for ``__add__`` and
+    ``__eq__`` methods where it is ok to allow some things (like Python
+    integers and floats) in the expression. This excludes things (like strings)
+    that are unwise to allow into such an expression.
+
+    >>> from sympy import Integer
+    >>> Integer(1) == 1
+    True
+
+    >>> Integer(1) == '1'
+    False
+
+    >>> from sympy.abc import x
+    >>> x + 1
+    x + 1
+
+    >>> x + '1'
+    Traceback (most recent call last):
+    ...
+    TypeError: unsupported operand type(s) for +: 'Symbol' and 'str'
+
+    see: sympify
+
+    """
+    return sympify(a, strict=True)
+
+
+def kernS(s):
+    """Use a hack to try keep autosimplification from distributing a
+    a number into an Add; this modification does not
+    prevent the 2-arg Mul from becoming an Add, however.
+
+    Examples
+    ========
+
+    >>> from sympy.core.sympify import kernS
+    >>> from sympy.abc import x, y
+
+    The 2-arg Mul distributes a number (or minus sign) across the terms
+    of an expression, but kernS will prevent that:
+
+    >>> 2*(x + y), -(x + 1)
+    (2*x + 2*y, -x - 1)
+    >>> kernS('2*(x + y)')
+    2*(x + y)
+    >>> kernS('-(x + 1)')
+    -(x + 1)
+
+    If use of the hack fails, the un-hacked string will be passed to sympify...
+    and you get what you get.
+
+    XXX This hack should not be necessary once issue 4596 has been resolved.
+    """
+    hit = False
+    quoted = '"' in s or "'" in s
+    if '(' in s and not quoted:
+        if s.count('(') != s.count(")"):
+            raise SympifyError('unmatched left parenthesis')
+
+        # strip all space from s
+        s = ''.join(s.split())
+        olds = s
+        # now use space to represent a symbol that
+        # will
+        # step 1. turn potential 2-arg Muls into 3-arg versions
+        # 1a. *( -> * *(
+        s = s.replace('*(', '* *(')
+        # 1b. close up exponentials
+        s = s.replace('** *', '**')
+        # 2. handle the implied multiplication of a negated
+        # parenthesized expression in two steps
+        # 2a:  -(...)  -->  -( *(...)
+        target = '-( *('
+        s = s.replace('-(', target)
+        # 2b: double the matching closing parenthesis
+        # -( *(...)  -->  -( *(...))
+        i = nest = 0
+        assert target.endswith('(')  # assumption below
+        while True:
+            j = s.find(target, i)
+            if j == -1:
+                break
+            j += len(target) - 1
+            for j in range(j, len(s)):
+                if s[j] == "(":
+                    nest += 1
+                elif s[j] == ")":
+                    nest -= 1
+                if nest == 0:
+                    break
+            s = s[:j] + ")" + s[j:]
+            i = j + 2  # the first char after 2nd )
+        if ' ' in s:
+            # get a unique kern
+            kern = '_'
+            while kern in s:
+                kern += choice(string.ascii_letters + string.digits)
+            s = s.replace(' ', kern)
+            hit = kern in s
+        else:
+            hit = False
+
+    for i in range(2):
+        try:
+            expr = sympify(s)
+            break
+        except TypeError:  # the kern might cause unknown errors...
+            if hit:
+                s = olds  # maybe it didn't like the kern; use un-kerned s
+                hit = False
+                continue
+            expr = sympify(s)  # let original error raise
+
+    if not hit:
+        return expr
+
+    from .symbol import Symbol
+    rep = {Symbol(kern): 1}
+    def _clear(expr):
+        if isinstance(expr, (list, tuple, set)):
+            return type(expr)([_clear(e) for e in expr])
+        if hasattr(expr, 'subs'):
+            return expr.subs(rep, hack2=True)
+        return expr
+    expr = _clear(expr)
+    # hope that kern is not there anymore
+    return expr
+
+
+# Avoid circular import
+from .basic import Basic
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8e8af106ea72cbf84bba423c9b6e74cff5e94ef0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_args.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_args.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e8161115a2a1d80b7820601ba0aaa9b097bbc435
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_args.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d25f0fa8adb822d593173e5fe8cde6992c46cbc10205288fbab7eaf17d311296
+size 305532
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b007db7a28ee55386790748d83911f0de3f0e214
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_arit.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c5985feb142949cc7d9e91494740c99897ddf192a9ec1e1c70005e5eb355036d
+size 144641
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_assumptions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_assumptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46b0a64ddec1e8cb4e59eeb76f74a689c6658cae
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_assumptions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_basic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_basic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1bf0aa95f4218cc8c27d0a612a114d66171ed2c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_basic.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_cache.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_cache.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..36545e8fc04446dd7fd9119193750e9f8c8ccf17
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_cache.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_compatibility.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_compatibility.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..21a43cd5854d3102364ceaff2f5ed57cb8ddda59
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_compatibility.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_complex.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_complex.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..40990782e3882d2f41b4884903c452437dad3f25
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_complex.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_constructor_postprocessor.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_constructor_postprocessor.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cde126302f38c9e0361b2950b422f2c3c33c50a7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_constructor_postprocessor.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_containers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_containers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5f49246cf440b495ccb26e2f5e8509787698d77
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_containers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_count_ops.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_count_ops.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c9e5fb489976bbd8121ee3242ed46f0fff715f5c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_count_ops.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_diff.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_diff.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8015d752202920a38fa636029a1f445c37df3bd1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_diff.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_equal.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_equal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2622a51f48522b4209706941252d9bd61f8d1099
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_equal.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_eval.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_eval.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1316e9f71f4662774a9a6d1ecf4960556a57d73e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_eval.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_evalf.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_evalf.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7f7a65e3118d164568f8e74cd5eca0e0f478c26c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_evalf.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expand.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expand.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64ddc6a4d0202e556da939f2f4935c6cc3fc3c54
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expand.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expr.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expr.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c13c032b0c193485dc6b79fc3653215eaecb2f67
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_expr.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1d1e8306c68b6d82262f76c6f2a4d206adb12c3efcee6c0372f03c13be408b0
+size 192835
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ce2ee8d919ed7b4e08133dbeb0ab05073909bb6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_exprtools.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_facts.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_facts.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2010dd387dc613bd2015af779449da99d3167d17
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_facts.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_function.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_function.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..881edd979d71699db428a63105f6de4189a7a59e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_function.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:602265098b52a260acd799604fc73d2ebd39d6249a12401daedd0493e48848f1
+size 138887
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_kind.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_kind.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1599973130db56ae7c2c5f67b0f188a56b7b7052
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_kind.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3474203c63baec9a5e9527e5074729f95b805fa9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_logic.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_match.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_match.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d63b80b3725f8405c34bca1324c46ea0ad9cd7e2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_match.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60dae8085cb6744d41560e836a0ee2e764e8ecb8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_multidimensional.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_noncommutative.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_noncommutative.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a82c6a38eb470ee275da217a901d0accac4809c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_noncommutative.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bdee4d6b9485ca0e7ee11a7ff5516bd35b186b3a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_numbers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4aff02f353dad63ef06ccca0e4ad0fe2c842810fadd3e34670c81322bf0a8a84
+size 171039
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_operations.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_operations.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..354ea6e99a87e233ac720824d0cd8355dc383e42
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_operations.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_parameters.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_parameters.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a50405332136f8655143784b3073a41babde53f3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_parameters.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_power.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_power.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9448a31713986be65d5b60cf2f0da787cba08ae2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_power.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_priority.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_priority.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..726b04ed4dd8999bf8d63ae63b0547e265b7cbf0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_priority.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_random.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_random.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..923899facbdbe013315df29188c3af86336632a9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_random.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b109d4f225d44a62ab6372a932311b3d778171be
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_relational.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:37d7692e796ceff7a0312a29617a5582399ef9cdf4e2c8c669887855066307b8
+size 100989
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_rules.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_rules.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4a7befb20b6aa0b3aa6cabb6bf32e0249948baca
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_rules.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97c4cc36e11eb131591176ef3d55155305d08a31
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_singleton.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sorting.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sorting.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..392f41174ea1d9a70fc155208f5f1c73efb72343
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sorting.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_subs.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_subs.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c79b9f6588e1a9df7c53d65516727356bf82d42
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_subs.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_symbol.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_symbol.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecb16e3d37782ea15ef92a61103ccd6c66c7dca0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_symbol.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9831f94a17742c1cbc3edfe4f0c9d09fdb96b7f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_sympify.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_traversal.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_traversal.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2c32afabb75176112e36d0530e6074ab8be69a9b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_traversal.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_truediv.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_truediv.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5fd5c9adeade3d3beeb1738bc3dd342f815d657a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_truediv.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_var.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_var.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ae29d34fc011e2cf8e49a7973751ecd75f3d3a4
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/core/tests/__pycache__/test_var.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_args.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_args.py
new file mode 100644
index 0000000000000000000000000000000000000000..75b326146e1cc645a27e26ba13d44c92d56d5efb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_args.py
@@ -0,0 +1,5517 @@
+"""Test whether all elements of cls.args are instances of Basic. """
+
+# NOTE: keep tests sorted by (module, class name) key. If a class can't
+# be instantiated, add it here anyway with @SKIP("abstract class) (see
+# e.g. Function).
+
+import os
+import re
+from pathlib import Path
+
+from sympy.assumptions.ask import Q
+from sympy.core.basic import Basic
+from sympy.core.function import (Function, Lambda)
+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.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin
+
+from sympy.testing.pytest import SKIP, warns_deprecated_sympy
+
+a, b, c, x, y, z, s = symbols('a,b,c,x,y,z,s')
+
+
+whitelist = [
+     "sympy.assumptions.predicates",    # tested by test_predicates()
+     "sympy.assumptions.relation.equality",    # tested by test_predicates()
+]
+
+def test_all_classes_are_tested():
+    this = os.path.split(__file__)[0]
+    path = os.path.join(this, os.pardir, os.pardir)
+    sympy_path = os.path.abspath(path)
+    prefix = os.path.split(sympy_path)[0] + os.sep
+
+    re_cls = re.compile(r"^class ([A-Za-z][A-Za-z0-9_]*)\s*\(", re.MULTILINE)
+
+    modules = {}
+
+    for root, dirs, files in os.walk(sympy_path):
+        module = root.replace(prefix, "").replace(os.sep, ".")
+
+        for file in files:
+            if file.startswith(("_", "test_", "bench_")):
+                continue
+            if not file.endswith(".py"):
+                continue
+
+            text = Path(os.path.join(root, file)).read_text(encoding='utf-8')
+
+            submodule = module + '.' + file[:-3]
+
+            if any(submodule.startswith(wpath) for wpath in whitelist):
+                continue
+
+            names = re_cls.findall(text)
+
+            if not names:
+                continue
+
+            try:
+                mod = __import__(submodule, fromlist=names)
+            except ImportError:
+                continue
+
+            def is_Basic(name):
+                cls = getattr(mod, name)
+                if hasattr(cls, '_sympy_deprecated_func'):
+                    cls = cls._sympy_deprecated_func
+                if not isinstance(cls, type):
+                    # check instance of singleton class with same name
+                    cls = type(cls)
+                return issubclass(cls, Basic)
+
+            names = list(filter(is_Basic, names))
+
+            if names:
+                modules[submodule] = names
+
+    ns = globals()
+    failed = []
+
+    for module, names in modules.items():
+        mod = module.replace('.', '__')
+
+        for name in names:
+            test = 'test_' + mod + '__' + name
+
+            if test not in ns:
+                failed.append(module + '.' + name)
+
+    assert not failed, "Missing classes: %s.  Please add tests for these to sympy/core/tests/test_args.py." % ", ".join(failed)
+
+
+def _test_args(obj):
+    all_basic = all(isinstance(arg, Basic) for arg in obj.args)
+    # Ideally obj.func(*obj.args) would always recreate the object, but for
+    # now, we only require it for objects with non-empty .args
+    recreatable = not obj.args or obj.func(*obj.args) == obj
+    return all_basic and recreatable
+
+
+def test_sympy__algebras__quaternion__Quaternion():
+    from sympy.algebras.quaternion import Quaternion
+    assert _test_args(Quaternion(x, 1, 2, 3))
+
+
+def test_sympy__assumptions__assume__AppliedPredicate():
+    from sympy.assumptions.assume import AppliedPredicate, Predicate
+    assert _test_args(AppliedPredicate(Predicate("test"), 2))
+    assert _test_args(Q.is_true(True))
+
+@SKIP("abstract class")
+def test_sympy__assumptions__assume__Predicate():
+    pass
+
+def test_predicates():
+    predicates = [
+        getattr(Q, attr)
+        for attr in Q.__class__.__dict__
+        if not attr.startswith('__')]
+    for p in predicates:
+        assert _test_args(p)
+
+def test_sympy__assumptions__assume__UndefinedPredicate():
+    from sympy.assumptions.assume import Predicate
+    assert _test_args(Predicate("test"))
+
+@SKIP('abstract class')
+def test_sympy__assumptions__relation__binrel__BinaryRelation():
+    pass
+
+def test_sympy__assumptions__relation__binrel__AppliedBinaryRelation():
+    assert _test_args(Q.eq(1, 2))
+
+def test_sympy__assumptions__wrapper__AssumptionsWrapper():
+    from sympy.assumptions.wrapper import AssumptionsWrapper
+    assert _test_args(AssumptionsWrapper(x, Q.positive(x)))
+
+@SKIP("abstract Class")
+def test_sympy__codegen__ast__CodegenAST():
+    from sympy.codegen.ast import CodegenAST
+    assert _test_args(CodegenAST())
+
+@SKIP("abstract Class")
+def test_sympy__codegen__ast__AssignmentBase():
+    from sympy.codegen.ast import AssignmentBase
+    assert _test_args(AssignmentBase(x, 1))
+
+@SKIP("abstract Class")
+def test_sympy__codegen__ast__AugmentedAssignment():
+    from sympy.codegen.ast import AugmentedAssignment
+    assert _test_args(AugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__AddAugmentedAssignment():
+    from sympy.codegen.ast import AddAugmentedAssignment
+    assert _test_args(AddAugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__SubAugmentedAssignment():
+    from sympy.codegen.ast import SubAugmentedAssignment
+    assert _test_args(SubAugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__MulAugmentedAssignment():
+    from sympy.codegen.ast import MulAugmentedAssignment
+    assert _test_args(MulAugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__DivAugmentedAssignment():
+    from sympy.codegen.ast import DivAugmentedAssignment
+    assert _test_args(DivAugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__ModAugmentedAssignment():
+    from sympy.codegen.ast import ModAugmentedAssignment
+    assert _test_args(ModAugmentedAssignment(x, 1))
+
+def test_sympy__codegen__ast__CodeBlock():
+    from sympy.codegen.ast import CodeBlock, Assignment
+    assert _test_args(CodeBlock(Assignment(x, 1), Assignment(y, 2)))
+
+def test_sympy__codegen__ast__For():
+    from sympy.codegen.ast import For, CodeBlock, AddAugmentedAssignment
+    from sympy.sets import Range
+    assert _test_args(For(x, Range(10), CodeBlock(AddAugmentedAssignment(y, 1))))
+
+
+def test_sympy__codegen__ast__Token():
+    from sympy.codegen.ast import Token
+    assert _test_args(Token())
+
+
+def test_sympy__codegen__ast__ContinueToken():
+    from sympy.codegen.ast import ContinueToken
+    assert _test_args(ContinueToken())
+
+def test_sympy__codegen__ast__BreakToken():
+    from sympy.codegen.ast import BreakToken
+    assert _test_args(BreakToken())
+
+def test_sympy__codegen__ast__NoneToken():
+    from sympy.codegen.ast import NoneToken
+    assert _test_args(NoneToken())
+
+def test_sympy__codegen__ast__String():
+    from sympy.codegen.ast import String
+    assert _test_args(String('foobar'))
+
+def test_sympy__codegen__ast__QuotedString():
+    from sympy.codegen.ast import QuotedString
+    assert _test_args(QuotedString('foobar'))
+
+def test_sympy__codegen__ast__Comment():
+    from sympy.codegen.ast import Comment
+    assert _test_args(Comment('this is a comment'))
+
+def test_sympy__codegen__ast__Node():
+    from sympy.codegen.ast import Node
+    assert _test_args(Node())
+    assert _test_args(Node(attrs={1, 2, 3}))
+
+
+def test_sympy__codegen__ast__Type():
+    from sympy.codegen.ast import Type
+    assert _test_args(Type('float128'))
+
+
+def test_sympy__codegen__ast__IntBaseType():
+    from sympy.codegen.ast import IntBaseType
+    assert _test_args(IntBaseType('bigint'))
+
+
+def test_sympy__codegen__ast___SizedIntType():
+    from sympy.codegen.ast import _SizedIntType
+    assert _test_args(_SizedIntType('int128', 128))
+
+
+def test_sympy__codegen__ast__SignedIntType():
+    from sympy.codegen.ast import SignedIntType
+    assert _test_args(SignedIntType('int128_with_sign', 128))
+
+
+def test_sympy__codegen__ast__UnsignedIntType():
+    from sympy.codegen.ast import UnsignedIntType
+    assert _test_args(UnsignedIntType('unt128', 128))
+
+
+def test_sympy__codegen__ast__FloatBaseType():
+    from sympy.codegen.ast import FloatBaseType
+    assert _test_args(FloatBaseType('positive_real'))
+
+
+def test_sympy__codegen__ast__FloatType():
+    from sympy.codegen.ast import FloatType
+    assert _test_args(FloatType('float242', 242, nmant=142, nexp=99))
+
+
+def test_sympy__codegen__ast__ComplexBaseType():
+    from sympy.codegen.ast import ComplexBaseType
+    assert _test_args(ComplexBaseType('positive_cmplx'))
+
+def test_sympy__codegen__ast__ComplexType():
+    from sympy.codegen.ast import ComplexType
+    assert _test_args(ComplexType('complex42', 42, nmant=15, nexp=5))
+
+
+def test_sympy__codegen__ast__Attribute():
+    from sympy.codegen.ast import Attribute
+    assert _test_args(Attribute('noexcept'))
+
+
+def test_sympy__codegen__ast__Variable():
+    from sympy.codegen.ast import Variable, Type, value_const
+    assert _test_args(Variable(x))
+    assert _test_args(Variable(y, Type('float32'), {value_const}))
+    assert _test_args(Variable(z, type=Type('float64')))
+
+
+def test_sympy__codegen__ast__Pointer():
+    from sympy.codegen.ast import Pointer, Type, pointer_const
+    assert _test_args(Pointer(x))
+    assert _test_args(Pointer(y, type=Type('float32')))
+    assert _test_args(Pointer(z, Type('float64'), {pointer_const}))
+
+
+def test_sympy__codegen__ast__Declaration():
+    from sympy.codegen.ast import Declaration, Variable, Type
+    vx = Variable(x, type=Type('float'))
+    assert _test_args(Declaration(vx))
+
+
+def test_sympy__codegen__ast__While():
+    from sympy.codegen.ast import While, AddAugmentedAssignment
+    assert _test_args(While(abs(x) < 1, [AddAugmentedAssignment(x, -1)]))
+
+
+def test_sympy__codegen__ast__Scope():
+    from sympy.codegen.ast import Scope, AddAugmentedAssignment
+    assert _test_args(Scope([AddAugmentedAssignment(x, -1)]))
+
+
+def test_sympy__codegen__ast__Stream():
+    from sympy.codegen.ast import Stream
+    assert _test_args(Stream('stdin'))
+
+def test_sympy__codegen__ast__Print():
+    from sympy.codegen.ast import Print
+    assert _test_args(Print([x, y]))
+    assert _test_args(Print([x, y], "%d %d"))
+
+
+def test_sympy__codegen__ast__FunctionPrototype():
+    from sympy.codegen.ast import FunctionPrototype, real, Declaration, Variable
+    inp_x = Declaration(Variable(x, type=real))
+    assert _test_args(FunctionPrototype(real, 'pwer', [inp_x]))
+
+
+def test_sympy__codegen__ast__FunctionDefinition():
+    from sympy.codegen.ast import FunctionDefinition, real, Declaration, Variable, Assignment
+    inp_x = Declaration(Variable(x, type=real))
+    assert _test_args(FunctionDefinition(real, 'pwer', [inp_x], [Assignment(x, x**2)]))
+
+
+def test_sympy__codegen__ast__Raise():
+    from sympy.codegen.ast import Raise
+    assert _test_args(Raise(x))
+
+
+def test_sympy__codegen__ast__Return():
+    from sympy.codegen.ast import Return
+    assert _test_args(Return(x))
+
+
+def test_sympy__codegen__ast__RuntimeError_():
+    from sympy.codegen.ast import RuntimeError_
+    assert _test_args(RuntimeError_('"message"'))
+
+
+def test_sympy__codegen__ast__FunctionCall():
+    from sympy.codegen.ast import FunctionCall
+    assert _test_args(FunctionCall('pwer', [x]))
+
+
+def test_sympy__codegen__ast__Element():
+    from sympy.codegen.ast import Element
+    assert _test_args(Element('x', range(3)))
+
+
+def test_sympy__codegen__cnodes__CommaOperator():
+    from sympy.codegen.cnodes import CommaOperator
+    assert _test_args(CommaOperator(1, 2))
+
+
+def test_sympy__codegen__cnodes__goto():
+    from sympy.codegen.cnodes import goto
+    assert _test_args(goto('early_exit'))
+
+
+def test_sympy__codegen__cnodes__Label():
+    from sympy.codegen.cnodes import Label
+    assert _test_args(Label('early_exit'))
+
+
+def test_sympy__codegen__cnodes__PreDecrement():
+    from sympy.codegen.cnodes import PreDecrement
+    assert _test_args(PreDecrement(x))
+
+
+def test_sympy__codegen__cnodes__PostDecrement():
+    from sympy.codegen.cnodes import PostDecrement
+    assert _test_args(PostDecrement(x))
+
+
+def test_sympy__codegen__cnodes__PreIncrement():
+    from sympy.codegen.cnodes import PreIncrement
+    assert _test_args(PreIncrement(x))
+
+
+def test_sympy__codegen__cnodes__PostIncrement():
+    from sympy.codegen.cnodes import PostIncrement
+    assert _test_args(PostIncrement(x))
+
+
+def test_sympy__codegen__cnodes__struct():
+    from sympy.codegen.ast import real, Variable
+    from sympy.codegen.cnodes import struct
+    assert _test_args(struct(declarations=[
+        Variable(x, type=real),
+        Variable(y, type=real)
+    ]))
+
+
+def test_sympy__codegen__cnodes__union():
+    from sympy.codegen.ast import float32, int32, Variable
+    from sympy.codegen.cnodes import union
+    assert _test_args(union(declarations=[
+        Variable(x, type=float32),
+        Variable(y, type=int32)
+    ]))
+
+
+def test_sympy__codegen__cxxnodes__using():
+    from sympy.codegen.cxxnodes import using
+    assert _test_args(using('std::vector'))
+    assert _test_args(using('std::vector', 'vec'))
+
+
+def test_sympy__codegen__fnodes__Program():
+    from sympy.codegen.fnodes import Program
+    assert _test_args(Program('foobar', []))
+
+def test_sympy__codegen__fnodes__Module():
+    from sympy.codegen.fnodes import Module
+    assert _test_args(Module('foobar', [], []))
+
+
+def test_sympy__codegen__fnodes__Subroutine():
+    from sympy.codegen.fnodes import Subroutine
+    x = symbols('x', real=True)
+    assert _test_args(Subroutine('foo', [x], []))
+
+
+def test_sympy__codegen__fnodes__GoTo():
+    from sympy.codegen.fnodes import GoTo
+    assert _test_args(GoTo([10]))
+    assert _test_args(GoTo([10, 20], x > 1))
+
+
+def test_sympy__codegen__fnodes__FortranReturn():
+    from sympy.codegen.fnodes import FortranReturn
+    assert _test_args(FortranReturn(10))
+
+
+def test_sympy__codegen__fnodes__Extent():
+    from sympy.codegen.fnodes import Extent
+    assert _test_args(Extent())
+    assert _test_args(Extent(None))
+    assert _test_args(Extent(':'))
+    assert _test_args(Extent(-3, 4))
+    assert _test_args(Extent(x, y))
+
+
+def test_sympy__codegen__fnodes__use_rename():
+    from sympy.codegen.fnodes import use_rename
+    assert _test_args(use_rename('loc', 'glob'))
+
+
+def test_sympy__codegen__fnodes__use():
+    from sympy.codegen.fnodes import use
+    assert _test_args(use('modfoo', only='bar'))
+
+
+def test_sympy__codegen__fnodes__SubroutineCall():
+    from sympy.codegen.fnodes import SubroutineCall
+    assert _test_args(SubroutineCall('foo', ['bar', 'baz']))
+
+
+def test_sympy__codegen__fnodes__Do():
+    from sympy.codegen.fnodes import Do
+    assert _test_args(Do([], 'i', 1, 42))
+
+
+def test_sympy__codegen__fnodes__ImpliedDoLoop():
+    from sympy.codegen.fnodes import ImpliedDoLoop
+    assert _test_args(ImpliedDoLoop('i', 'i', 1, 42))
+
+
+def test_sympy__codegen__fnodes__ArrayConstructor():
+    from sympy.codegen.fnodes import ArrayConstructor
+    assert _test_args(ArrayConstructor([1, 2, 3]))
+    from sympy.codegen.fnodes import ImpliedDoLoop
+    idl = ImpliedDoLoop('i', 'i', 1, 42)
+    assert _test_args(ArrayConstructor([1, idl, 3]))
+
+
+def test_sympy__codegen__fnodes__sum_():
+    from sympy.codegen.fnodes import sum_
+    assert _test_args(sum_('arr'))
+
+
+def test_sympy__codegen__fnodes__product_():
+    from sympy.codegen.fnodes import product_
+    assert _test_args(product_('arr'))
+
+
+def test_sympy__codegen__numpy_nodes__logaddexp():
+    from sympy.codegen.numpy_nodes import logaddexp
+    assert _test_args(logaddexp(x, y))
+
+
+def test_sympy__codegen__numpy_nodes__logaddexp2():
+    from sympy.codegen.numpy_nodes import logaddexp2
+    assert _test_args(logaddexp2(x, y))
+
+
+def test_sympy__codegen__numpy_nodes__amin():
+    from sympy.codegen.numpy_nodes import amin
+    assert _test_args(amin(x))
+
+
+def test_sympy__codegen__numpy_nodes__amax():
+    from sympy.codegen.numpy_nodes import amax
+    assert _test_args(amax(x))
+
+
+def test_sympy__codegen__numpy_nodes__minimum():
+    from sympy.codegen.numpy_nodes import minimum
+    assert _test_args(minimum(x, y, z))
+
+
+def test_sympy__codegen__numpy_nodes__maximum():
+    from sympy.codegen.numpy_nodes import maximum
+    assert _test_args(maximum(x, y, z))
+
+
+def test_sympy__codegen__pynodes__List():
+    from sympy.codegen.pynodes import List
+    assert _test_args(List(1, 2, 3))
+
+
+def test_sympy__codegen__pynodes__NumExprEvaluate():
+    from sympy.codegen.pynodes import NumExprEvaluate
+    assert _test_args(NumExprEvaluate(x))
+
+
+def test_sympy__codegen__scipy_nodes__cosm1():
+    from sympy.codegen.scipy_nodes import cosm1
+    assert _test_args(cosm1(x))
+
+
+def test_sympy__codegen__scipy_nodes__powm1():
+    from sympy.codegen.scipy_nodes import powm1
+    assert _test_args(powm1(x, y))
+
+
+def test_sympy__codegen__abstract_nodes__List():
+    from sympy.codegen.abstract_nodes import List
+    assert _test_args(List(1, 2, 3))
+
+def test_sympy__combinatorics__graycode__GrayCode():
+    from sympy.combinatorics.graycode import GrayCode
+    # an integer is given and returned from GrayCode as the arg
+    assert _test_args(GrayCode(3, start='100'))
+    assert _test_args(GrayCode(3, rank=1))
+
+
+def test_sympy__combinatorics__permutations__Permutation():
+    from sympy.combinatorics.permutations import Permutation
+    assert _test_args(Permutation([0, 1, 2, 3]))
+
+def test_sympy__combinatorics__permutations__AppliedPermutation():
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.permutations import AppliedPermutation
+    p = Permutation([0, 1, 2, 3])
+    assert _test_args(AppliedPermutation(p, x))
+
+def test_sympy__combinatorics__perm_groups__PermutationGroup():
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.perm_groups import PermutationGroup
+    assert _test_args(PermutationGroup([Permutation([0, 1])]))
+
+
+def test_sympy__combinatorics__polyhedron__Polyhedron():
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.polyhedron import Polyhedron
+    from sympy.abc import w, x, y, z
+    pgroup = [Permutation([[0, 1, 2], [3]]),
+              Permutation([[0, 1, 3], [2]]),
+              Permutation([[0, 2, 3], [1]]),
+              Permutation([[1, 2, 3], [0]]),
+              Permutation([[0, 1], [2, 3]]),
+              Permutation([[0, 2], [1, 3]]),
+              Permutation([[0, 3], [1, 2]]),
+              Permutation([[0, 1, 2, 3]])]
+    corners = [w, x, y, z]
+    faces = [(w, x, y), (w, y, z), (w, z, x), (x, y, z)]
+    assert _test_args(Polyhedron(corners, faces, pgroup))
+
+
+def test_sympy__combinatorics__prufer__Prufer():
+    from sympy.combinatorics.prufer import Prufer
+    assert _test_args(Prufer([[0, 1], [0, 2], [0, 3]], 4))
+
+
+def test_sympy__combinatorics__partitions__Partition():
+    from sympy.combinatorics.partitions import Partition
+    assert _test_args(Partition([1]))
+
+
+def test_sympy__combinatorics__partitions__IntegerPartition():
+    from sympy.combinatorics.partitions import IntegerPartition
+    assert _test_args(IntegerPartition([1]))
+
+
+def test_sympy__concrete__products__Product():
+    from sympy.concrete.products import Product
+    assert _test_args(Product(x, (x, 0, 10)))
+    assert _test_args(Product(x, (x, 0, y), (y, 0, 10)))
+
+
+@SKIP("abstract Class")
+def test_sympy__concrete__expr_with_limits__ExprWithLimits():
+    from sympy.concrete.expr_with_limits import ExprWithLimits
+    assert _test_args(ExprWithLimits(x, (x, 0, 10)))
+    assert _test_args(ExprWithLimits(x*y, (x, 0, 10.),(y,1.,3)))
+
+
+@SKIP("abstract Class")
+def test_sympy__concrete__expr_with_limits__AddWithLimits():
+    from sympy.concrete.expr_with_limits import AddWithLimits
+    assert _test_args(AddWithLimits(x, (x, 0, 10)))
+    assert _test_args(AddWithLimits(x*y, (x, 0, 10),(y,1,3)))
+
+
+@SKIP("abstract Class")
+def test_sympy__concrete__expr_with_intlimits__ExprWithIntLimits():
+    from sympy.concrete.expr_with_intlimits import ExprWithIntLimits
+    assert _test_args(ExprWithIntLimits(x, (x, 0, 10)))
+    assert _test_args(ExprWithIntLimits(x*y, (x, 0, 10),(y,1,3)))
+
+
+def test_sympy__concrete__summations__Sum():
+    from sympy.concrete.summations import Sum
+    assert _test_args(Sum(x, (x, 0, 10)))
+    assert _test_args(Sum(x, (x, 0, y), (y, 0, 10)))
+
+
+def test_sympy__core__add__Add():
+    from sympy.core.add import Add
+    assert _test_args(Add(x, y, z, 2))
+
+
+def test_sympy__core__basic__Atom():
+    from sympy.core.basic import Atom
+    assert _test_args(Atom())
+
+
+def test_sympy__core__basic__Basic():
+    from sympy.core.basic import Basic
+    assert _test_args(Basic())
+
+
+def test_sympy__core__containers__Dict():
+    from sympy.core.containers import Dict
+    assert _test_args(Dict({x: y, y: z}))
+
+
+def test_sympy__core__containers__Tuple():
+    from sympy.core.containers import Tuple
+    assert _test_args(Tuple(x, y, z, 2))
+
+
+def test_sympy__core__expr__AtomicExpr():
+    from sympy.core.expr import AtomicExpr
+    assert _test_args(AtomicExpr())
+
+
+def test_sympy__core__expr__Expr():
+    from sympy.core.expr import Expr
+    assert _test_args(Expr())
+
+
+def test_sympy__core__expr__UnevaluatedExpr():
+    from sympy.core.expr import UnevaluatedExpr
+    from sympy.abc import x
+    assert _test_args(UnevaluatedExpr(x))
+
+
+def test_sympy__core__function__Application():
+    from sympy.core.function import Application
+    assert _test_args(Application(1, 2, 3))
+
+
+def test_sympy__core__function__AppliedUndef():
+    from sympy.core.function import AppliedUndef
+    assert _test_args(AppliedUndef(1, 2, 3))
+
+
+def test_sympy__core__function__DefinedFunction():
+    from sympy.core.function import DefinedFunction
+    assert _test_args(DefinedFunction(1, 2, 3))
+
+
+def test_sympy__core__function__Derivative():
+    from sympy.core.function import Derivative
+    assert _test_args(Derivative(2, x, y, 3))
+
+
+@SKIP("abstract class")
+def test_sympy__core__function__Function():
+    pass
+
+
+def test_sympy__core__function__Lambda():
+    assert _test_args(Lambda((x, y), x + y + z))
+
+
+def test_sympy__core__function__Subs():
+    from sympy.core.function import Subs
+    assert _test_args(Subs(x + y, x, 2))
+
+
+def test_sympy__core__function__WildFunction():
+    from sympy.core.function import WildFunction
+    assert _test_args(WildFunction('f'))
+
+
+def test_sympy__core__mod__Mod():
+    from sympy.core.mod import Mod
+    assert _test_args(Mod(x, 2))
+
+
+def test_sympy__core__mul__Mul():
+    from sympy.core.mul import Mul
+    assert _test_args(Mul(2, x, y, z))
+
+
+def test_sympy__core__numbers__Catalan():
+    from sympy.core.numbers import Catalan
+    assert _test_args(Catalan())
+
+
+def test_sympy__core__numbers__ComplexInfinity():
+    from sympy.core.numbers import ComplexInfinity
+    assert _test_args(ComplexInfinity())
+
+
+def test_sympy__core__numbers__EulerGamma():
+    from sympy.core.numbers import EulerGamma
+    assert _test_args(EulerGamma())
+
+
+def test_sympy__core__numbers__Exp1():
+    from sympy.core.numbers import Exp1
+    assert _test_args(Exp1())
+
+
+def test_sympy__core__numbers__Float():
+    from sympy.core.numbers import Float
+    assert _test_args(Float(1.23))
+
+
+def test_sympy__core__numbers__GoldenRatio():
+    from sympy.core.numbers import GoldenRatio
+    assert _test_args(GoldenRatio())
+
+
+def test_sympy__core__numbers__TribonacciConstant():
+    from sympy.core.numbers import TribonacciConstant
+    assert _test_args(TribonacciConstant())
+
+
+def test_sympy__core__numbers__Half():
+    from sympy.core.numbers import Half
+    assert _test_args(Half())
+
+
+def test_sympy__core__numbers__ImaginaryUnit():
+    from sympy.core.numbers import ImaginaryUnit
+    assert _test_args(ImaginaryUnit())
+
+
+def test_sympy__core__numbers__Infinity():
+    from sympy.core.numbers import Infinity
+    assert _test_args(Infinity())
+
+
+def test_sympy__core__numbers__Integer():
+    from sympy.core.numbers import Integer
+    assert _test_args(Integer(7))
+
+
+@SKIP("abstract class")
+def test_sympy__core__numbers__IntegerConstant():
+    pass
+
+
+def test_sympy__core__numbers__NaN():
+    from sympy.core.numbers import NaN
+    assert _test_args(NaN())
+
+
+def test_sympy__core__numbers__NegativeInfinity():
+    from sympy.core.numbers import NegativeInfinity
+    assert _test_args(NegativeInfinity())
+
+
+def test_sympy__core__numbers__NegativeOne():
+    from sympy.core.numbers import NegativeOne
+    assert _test_args(NegativeOne())
+
+
+def test_sympy__core__numbers__Number():
+    from sympy.core.numbers import Number
+    assert _test_args(Number(1, 7))
+
+
+def test_sympy__core__numbers__NumberSymbol():
+    from sympy.core.numbers import NumberSymbol
+    assert _test_args(NumberSymbol())
+
+
+def test_sympy__core__numbers__One():
+    from sympy.core.numbers import One
+    assert _test_args(One())
+
+
+def test_sympy__core__numbers__Pi():
+    from sympy.core.numbers import Pi
+    assert _test_args(Pi())
+
+
+def test_sympy__core__numbers__Rational():
+    from sympy.core.numbers import Rational
+    assert _test_args(Rational(1, 7))
+
+
+@SKIP("abstract class")
+def test_sympy__core__numbers__RationalConstant():
+    pass
+
+
+def test_sympy__core__numbers__Zero():
+    from sympy.core.numbers import Zero
+    assert _test_args(Zero())
+
+
+@SKIP("abstract class")
+def test_sympy__core__operations__AssocOp():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__core__operations__LatticeOp():
+    pass
+
+
+def test_sympy__core__power__Pow():
+    from sympy.core.power import Pow
+    assert _test_args(Pow(x, 2))
+
+
+def test_sympy__core__relational__Equality():
+    from sympy.core.relational import Equality
+    assert _test_args(Equality(x, 2))
+
+
+def test_sympy__core__relational__GreaterThan():
+    from sympy.core.relational import GreaterThan
+    assert _test_args(GreaterThan(x, 2))
+
+
+def test_sympy__core__relational__LessThan():
+    from sympy.core.relational import LessThan
+    assert _test_args(LessThan(x, 2))
+
+
+@SKIP("abstract class")
+def test_sympy__core__relational__Relational():
+    pass
+
+
+def test_sympy__core__relational__StrictGreaterThan():
+    from sympy.core.relational import StrictGreaterThan
+    assert _test_args(StrictGreaterThan(x, 2))
+
+
+def test_sympy__core__relational__StrictLessThan():
+    from sympy.core.relational import StrictLessThan
+    assert _test_args(StrictLessThan(x, 2))
+
+
+def test_sympy__core__relational__Unequality():
+    from sympy.core.relational import Unequality
+    assert _test_args(Unequality(x, 2))
+
+
+def test_sympy__sandbox__indexed_integrals__IndexedIntegral():
+    from sympy.tensor import IndexedBase, Idx
+    from sympy.sandbox.indexed_integrals import IndexedIntegral
+    A = IndexedBase('A')
+    i, j = symbols('i j', integer=True)
+    a1, a2 = symbols('a1:3', cls=Idx)
+    assert _test_args(IndexedIntegral(A[a1], A[a2]))
+    assert _test_args(IndexedIntegral(A[i], A[j]))
+
+
+def test_sympy__calculus__accumulationbounds__AccumulationBounds():
+    from sympy.calculus.accumulationbounds import AccumulationBounds
+    assert _test_args(AccumulationBounds(0, 1))
+
+
+def test_sympy__sets__ordinals__OmegaPower():
+    from sympy.sets.ordinals import OmegaPower
+    assert _test_args(OmegaPower(1, 1))
+
+def test_sympy__sets__ordinals__Ordinal():
+    from sympy.sets.ordinals import Ordinal, OmegaPower
+    assert _test_args(Ordinal(OmegaPower(2, 1)))
+
+def test_sympy__sets__ordinals__OrdinalOmega():
+    from sympy.sets.ordinals import OrdinalOmega
+    assert _test_args(OrdinalOmega())
+
+def test_sympy__sets__ordinals__OrdinalZero():
+    from sympy.sets.ordinals import OrdinalZero
+    assert _test_args(OrdinalZero())
+
+
+def test_sympy__sets__powerset__PowerSet():
+    from sympy.sets.powerset import PowerSet
+    from sympy.core.singleton import S
+    assert _test_args(PowerSet(S.EmptySet))
+
+
+def test_sympy__sets__sets__EmptySet():
+    from sympy.sets.sets import EmptySet
+    assert _test_args(EmptySet())
+
+
+def test_sympy__sets__sets__UniversalSet():
+    from sympy.sets.sets import UniversalSet
+    assert _test_args(UniversalSet())
+
+
+def test_sympy__sets__sets__FiniteSet():
+    from sympy.sets.sets import FiniteSet
+    assert _test_args(FiniteSet(x, y, z))
+
+
+def test_sympy__sets__sets__Interval():
+    from sympy.sets.sets import Interval
+    assert _test_args(Interval(0, 1))
+
+
+def test_sympy__sets__sets__ProductSet():
+    from sympy.sets.sets import ProductSet, Interval
+    assert _test_args(ProductSet(Interval(0, 1), Interval(0, 1)))
+
+
+@SKIP("does it make sense to test this?")
+def test_sympy__sets__sets__Set():
+    from sympy.sets.sets import Set
+    assert _test_args(Set())
+
+
+def test_sympy__sets__sets__Intersection():
+    from sympy.sets.sets import Intersection, Interval
+    from sympy.core.symbol import Symbol
+    x = Symbol('x')
+    y = Symbol('y')
+    S = Intersection(Interval(0, x), Interval(y, 1))
+    assert isinstance(S, Intersection)
+    assert _test_args(S)
+
+
+def test_sympy__sets__sets__Union():
+    from sympy.sets.sets import Union, Interval
+    assert _test_args(Union(Interval(0, 1), Interval(2, 3)))
+
+
+def test_sympy__sets__sets__Complement():
+    from sympy.sets.sets import Complement, Interval
+    assert _test_args(Complement(Interval(0, 2), Interval(0, 1)))
+
+
+def test_sympy__sets__sets__SymmetricDifference():
+    from sympy.sets.sets import FiniteSet, SymmetricDifference
+    assert _test_args(SymmetricDifference(FiniteSet(1, 2, 3), \
+           FiniteSet(2, 3, 4)))
+
+def test_sympy__sets__sets__DisjointUnion():
+    from sympy.sets.sets import FiniteSet, DisjointUnion
+    assert _test_args(DisjointUnion(FiniteSet(1, 2, 3), \
+           FiniteSet(2, 3, 4)))
+
+
+def test_sympy__physics__quantum__trace__Tr():
+    from sympy.physics.quantum.trace import Tr
+    a, b = symbols('a b', commutative=False)
+    assert _test_args(Tr(a + b))
+
+
+def test_sympy__sets__setexpr__SetExpr():
+    from sympy.sets.setexpr import SetExpr
+    from sympy.sets.sets import Interval
+    assert _test_args(SetExpr(Interval(0, 1)))
+
+
+def test_sympy__sets__fancysets__Rationals():
+    from sympy.sets.fancysets import Rationals
+    assert _test_args(Rationals())
+
+
+def test_sympy__sets__fancysets__Naturals():
+    from sympy.sets.fancysets import Naturals
+    assert _test_args(Naturals())
+
+
+def test_sympy__sets__fancysets__Naturals0():
+    from sympy.sets.fancysets import Naturals0
+    assert _test_args(Naturals0())
+
+
+def test_sympy__sets__fancysets__Integers():
+    from sympy.sets.fancysets import Integers
+    assert _test_args(Integers())
+
+
+def test_sympy__sets__fancysets__Reals():
+    from sympy.sets.fancysets import Reals
+    assert _test_args(Reals())
+
+
+def test_sympy__sets__fancysets__Complexes():
+    from sympy.sets.fancysets import Complexes
+    assert _test_args(Complexes())
+
+
+def test_sympy__sets__fancysets__ComplexRegion():
+    from sympy.sets.fancysets import ComplexRegion
+    from sympy.core.singleton import S
+    from sympy.sets import Interval
+    a = Interval(0, 1)
+    b = Interval(2, 3)
+    theta = Interval(0, 2*S.Pi)
+    assert _test_args(ComplexRegion(a*b))
+    assert _test_args(ComplexRegion(a*theta, polar=True))
+
+
+def test_sympy__sets__fancysets__CartesianComplexRegion():
+    from sympy.sets.fancysets import CartesianComplexRegion
+    from sympy.sets import Interval
+    a = Interval(0, 1)
+    b = Interval(2, 3)
+    assert _test_args(CartesianComplexRegion(a*b))
+
+
+def test_sympy__sets__fancysets__PolarComplexRegion():
+    from sympy.sets.fancysets import PolarComplexRegion
+    from sympy.core.singleton import S
+    from sympy.sets import Interval
+    a = Interval(0, 1)
+    theta = Interval(0, 2*S.Pi)
+    assert _test_args(PolarComplexRegion(a*theta))
+
+
+def test_sympy__sets__fancysets__ImageSet():
+    from sympy.sets.fancysets import ImageSet
+    from sympy.core.singleton import S
+    from sympy.core.symbol import Symbol
+    x = Symbol('x')
+    assert _test_args(ImageSet(Lambda(x, x**2), S.Naturals))
+
+
+def test_sympy__sets__fancysets__Range():
+    from sympy.sets.fancysets import Range
+    assert _test_args(Range(1, 5, 1))
+
+
+def test_sympy__sets__conditionset__ConditionSet():
+    from sympy.sets.conditionset import ConditionSet
+    from sympy.core.singleton import S
+    from sympy.core.symbol import Symbol
+    x = Symbol('x')
+    assert _test_args(ConditionSet(x, Eq(x**2, 1), S.Reals))
+
+
+def test_sympy__sets__contains__Contains():
+    from sympy.sets.fancysets import Range
+    from sympy.sets.contains import Contains
+    assert _test_args(Contains(x, Range(0, 10, 2)))
+
+
+# STATS
+
+
+from sympy.stats.crv_types import NormalDistribution
+nd = NormalDistribution(0, 1)
+from sympy.stats.frv_types import DieDistribution
+die = DieDistribution(6)
+
+
+def test_sympy__stats__crv__ContinuousDomain():
+    from sympy.sets.sets import Interval
+    from sympy.stats.crv import ContinuousDomain
+    assert _test_args(ContinuousDomain({x}, Interval(-oo, oo)))
+
+
+def test_sympy__stats__crv__SingleContinuousDomain():
+    from sympy.sets.sets import Interval
+    from sympy.stats.crv import SingleContinuousDomain
+    assert _test_args(SingleContinuousDomain(x, Interval(-oo, oo)))
+
+
+def test_sympy__stats__crv__ProductContinuousDomain():
+    from sympy.sets.sets import Interval
+    from sympy.stats.crv import SingleContinuousDomain, ProductContinuousDomain
+    D = SingleContinuousDomain(x, Interval(-oo, oo))
+    E = SingleContinuousDomain(y, Interval(0, oo))
+    assert _test_args(ProductContinuousDomain(D, E))
+
+
+def test_sympy__stats__crv__ConditionalContinuousDomain():
+    from sympy.sets.sets import Interval
+    from sympy.stats.crv import (SingleContinuousDomain,
+            ConditionalContinuousDomain)
+    D = SingleContinuousDomain(x, Interval(-oo, oo))
+    assert _test_args(ConditionalContinuousDomain(D, x > 0))
+
+
+def test_sympy__stats__crv__ContinuousPSpace():
+    from sympy.sets.sets import Interval
+    from sympy.stats.crv import ContinuousPSpace, SingleContinuousDomain
+    D = SingleContinuousDomain(x, Interval(-oo, oo))
+    assert _test_args(ContinuousPSpace(D, nd))
+
+
+def test_sympy__stats__crv__SingleContinuousPSpace():
+    from sympy.stats.crv import SingleContinuousPSpace
+    assert _test_args(SingleContinuousPSpace(x, nd))
+
+@SKIP("abstract class")
+def test_sympy__stats__rv__Distribution():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__stats__crv__SingleContinuousDistribution():
+    pass
+
+
+def test_sympy__stats__drv__SingleDiscreteDomain():
+    from sympy.stats.drv import SingleDiscreteDomain
+    assert _test_args(SingleDiscreteDomain(x, S.Naturals))
+
+
+def test_sympy__stats__drv__ProductDiscreteDomain():
+    from sympy.stats.drv import SingleDiscreteDomain, ProductDiscreteDomain
+    X = SingleDiscreteDomain(x, S.Naturals)
+    Y = SingleDiscreteDomain(y, S.Integers)
+    assert _test_args(ProductDiscreteDomain(X, Y))
+
+
+def test_sympy__stats__drv__SingleDiscretePSpace():
+    from sympy.stats.drv import SingleDiscretePSpace
+    from sympy.stats.drv_types import PoissonDistribution
+    assert _test_args(SingleDiscretePSpace(x, PoissonDistribution(1)))
+
+def test_sympy__stats__drv__DiscretePSpace():
+    from sympy.stats.drv import DiscretePSpace, SingleDiscreteDomain
+    density = Lambda(x, 2**(-x))
+    domain = SingleDiscreteDomain(x, S.Naturals)
+    assert _test_args(DiscretePSpace(domain, density))
+
+def test_sympy__stats__drv__ConditionalDiscreteDomain():
+    from sympy.stats.drv import ConditionalDiscreteDomain, SingleDiscreteDomain
+    X = SingleDiscreteDomain(x, S.Naturals0)
+    assert _test_args(ConditionalDiscreteDomain(X, x > 2))
+
+def test_sympy__stats__joint_rv__JointPSpace():
+    from sympy.stats.joint_rv import JointPSpace, JointDistribution
+    assert _test_args(JointPSpace('X', JointDistribution(1)))
+
+def test_sympy__stats__joint_rv__JointRandomSymbol():
+    from sympy.stats.joint_rv import JointRandomSymbol
+    assert _test_args(JointRandomSymbol(x))
+
+def test_sympy__stats__joint_rv_types__JointDistributionHandmade():
+    from sympy.tensor.indexed import Indexed
+    from sympy.stats.joint_rv_types import JointDistributionHandmade
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    assert _test_args(JointDistributionHandmade(x1 + x2, S.Reals**2))
+
+
+def test_sympy__stats__joint_rv__MarginalDistribution():
+    from sympy.stats.rv import RandomSymbol
+    from sympy.stats.joint_rv import MarginalDistribution
+    r = RandomSymbol(S('r'))
+    assert _test_args(MarginalDistribution(r, (r,)))
+
+
+def test_sympy__stats__compound_rv__CompoundDistribution():
+    from sympy.stats.compound_rv import CompoundDistribution
+    from sympy.stats.drv_types import PoissonDistribution, Poisson
+    r = Poisson('r', 10)
+    assert _test_args(CompoundDistribution(PoissonDistribution(r)))
+
+
+def test_sympy__stats__compound_rv__CompoundPSpace():
+    from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
+    from sympy.stats.drv_types import PoissonDistribution, Poisson
+    r = Poisson('r', 5)
+    C = CompoundDistribution(PoissonDistribution(r))
+    assert _test_args(CompoundPSpace('C', C))
+
+
+@SKIP("abstract class")
+def test_sympy__stats__drv__SingleDiscreteDistribution():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__stats__drv__DiscreteDistribution():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__stats__drv__DiscreteDomain():
+    pass
+
+
+def test_sympy__stats__rv__RandomDomain():
+    from sympy.stats.rv import RandomDomain
+    from sympy.sets.sets import FiniteSet
+    assert _test_args(RandomDomain(FiniteSet(x), FiniteSet(1, 2, 3)))
+
+
+def test_sympy__stats__rv__SingleDomain():
+    from sympy.stats.rv import SingleDomain
+    from sympy.sets.sets import FiniteSet
+    assert _test_args(SingleDomain(x, FiniteSet(1, 2, 3)))
+
+
+def test_sympy__stats__rv__ConditionalDomain():
+    from sympy.stats.rv import ConditionalDomain, RandomDomain
+    from sympy.sets.sets import FiniteSet
+    D = RandomDomain(FiniteSet(x), FiniteSet(1, 2))
+    assert _test_args(ConditionalDomain(D, x > 1))
+
+def test_sympy__stats__rv__MatrixDomain():
+    from sympy.stats.rv import MatrixDomain
+    from sympy.matrices import MatrixSet
+    from sympy.core.singleton import S
+    assert _test_args(MatrixDomain(x, MatrixSet(2, 2, S.Reals)))
+
+def test_sympy__stats__rv__PSpace():
+    from sympy.stats.rv import PSpace, RandomDomain
+    from sympy.sets.sets import FiniteSet
+    D = RandomDomain(FiniteSet(x), FiniteSet(1, 2, 3, 4, 5, 6))
+    assert _test_args(PSpace(D, die))
+
+
+@SKIP("abstract Class")
+def test_sympy__stats__rv__SinglePSpace():
+    pass
+
+
+def test_sympy__stats__rv__RandomSymbol():
+    from sympy.stats.rv import RandomSymbol
+    from sympy.stats.crv import SingleContinuousPSpace
+    A = SingleContinuousPSpace(x, nd)
+    assert _test_args(RandomSymbol(x, A))
+
+
+@SKIP("abstract Class")
+def test_sympy__stats__rv__ProductPSpace():
+    pass
+
+
+def test_sympy__stats__rv__IndependentProductPSpace():
+    from sympy.stats.rv import IndependentProductPSpace
+    from sympy.stats.crv import SingleContinuousPSpace
+    A = SingleContinuousPSpace(x, nd)
+    B = SingleContinuousPSpace(y, nd)
+    assert _test_args(IndependentProductPSpace(A, B))
+
+
+def test_sympy__stats__rv__ProductDomain():
+    from sympy.sets.sets import Interval
+    from sympy.stats.rv import ProductDomain, SingleDomain
+    D = SingleDomain(x, Interval(-oo, oo))
+    E = SingleDomain(y, Interval(0, oo))
+    assert _test_args(ProductDomain(D, E))
+
+
+def test_sympy__stats__symbolic_probability__Probability():
+    from sympy.stats.symbolic_probability import Probability
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    assert _test_args(Probability(X > 0))
+
+
+def test_sympy__stats__symbolic_probability__Expectation():
+    from sympy.stats.symbolic_probability import Expectation
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    assert _test_args(Expectation(X > 0))
+
+
+def test_sympy__stats__symbolic_probability__Covariance():
+    from sympy.stats.symbolic_probability import Covariance
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    Y = Normal('Y', 0, 3)
+    assert _test_args(Covariance(X, Y))
+
+
+def test_sympy__stats__symbolic_probability__Variance():
+    from sympy.stats.symbolic_probability import Variance
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    assert _test_args(Variance(X))
+
+
+def test_sympy__stats__symbolic_probability__Moment():
+    from sympy.stats.symbolic_probability import Moment
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    assert _test_args(Moment(X, 3, 2, X > 3))
+
+
+def test_sympy__stats__symbolic_probability__CentralMoment():
+    from sympy.stats.symbolic_probability import CentralMoment
+    from sympy.stats import Normal
+    X = Normal('X', 0, 1)
+    assert _test_args(CentralMoment(X, 2, X > 1))
+
+
+def test_sympy__stats__frv_types__DiscreteUniformDistribution():
+    from sympy.stats.frv_types import DiscreteUniformDistribution
+    from sympy.core.containers import Tuple
+    assert _test_args(DiscreteUniformDistribution(Tuple(*list(range(6)))))
+
+
+def test_sympy__stats__frv_types__DieDistribution():
+    assert _test_args(die)
+
+
+def test_sympy__stats__frv_types__BernoulliDistribution():
+    from sympy.stats.frv_types import BernoulliDistribution
+    assert _test_args(BernoulliDistribution(S.Half, 0, 1))
+
+
+def test_sympy__stats__frv_types__BinomialDistribution():
+    from sympy.stats.frv_types import BinomialDistribution
+    assert _test_args(BinomialDistribution(5, S.Half, 1, 0))
+
+def test_sympy__stats__frv_types__BetaBinomialDistribution():
+    from sympy.stats.frv_types import BetaBinomialDistribution
+    assert _test_args(BetaBinomialDistribution(5, 1, 1))
+
+
+def test_sympy__stats__frv_types__HypergeometricDistribution():
+    from sympy.stats.frv_types import HypergeometricDistribution
+    assert _test_args(HypergeometricDistribution(10, 5, 3))
+
+
+def test_sympy__stats__frv_types__RademacherDistribution():
+    from sympy.stats.frv_types import RademacherDistribution
+    assert _test_args(RademacherDistribution())
+
+def test_sympy__stats__frv_types__IdealSolitonDistribution():
+    from sympy.stats.frv_types import IdealSolitonDistribution
+    assert _test_args(IdealSolitonDistribution(10))
+
+def test_sympy__stats__frv_types__RobustSolitonDistribution():
+    from sympy.stats.frv_types import RobustSolitonDistribution
+    assert _test_args(RobustSolitonDistribution(1000, 0.5, 0.1))
+
+def test_sympy__stats__frv__FiniteDomain():
+    from sympy.stats.frv import FiniteDomain
+    assert _test_args(FiniteDomain({(x, 1), (x, 2)}))  # x can be 1 or 2
+
+
+def test_sympy__stats__frv__SingleFiniteDomain():
+    from sympy.stats.frv import SingleFiniteDomain
+    assert _test_args(SingleFiniteDomain(x, {1, 2}))  # x can be 1 or 2
+
+
+def test_sympy__stats__frv__ProductFiniteDomain():
+    from sympy.stats.frv import SingleFiniteDomain, ProductFiniteDomain
+    xd = SingleFiniteDomain(x, {1, 2})
+    yd = SingleFiniteDomain(y, {1, 2})
+    assert _test_args(ProductFiniteDomain(xd, yd))
+
+
+def test_sympy__stats__frv__ConditionalFiniteDomain():
+    from sympy.stats.frv import SingleFiniteDomain, ConditionalFiniteDomain
+    xd = SingleFiniteDomain(x, {1, 2})
+    assert _test_args(ConditionalFiniteDomain(xd, x > 1))
+
+
+def test_sympy__stats__frv__FinitePSpace():
+    from sympy.stats.frv import FinitePSpace, SingleFiniteDomain
+    xd = SingleFiniteDomain(x, {1, 2, 3, 4, 5, 6})
+    assert _test_args(FinitePSpace(xd, {(x, 1): S.Half, (x, 2): S.Half}))
+
+    xd = SingleFiniteDomain(x, {1, 2})
+    assert _test_args(FinitePSpace(xd, {(x, 1): S.Half, (x, 2): S.Half}))
+
+
+def test_sympy__stats__frv__SingleFinitePSpace():
+    from sympy.stats.frv import SingleFinitePSpace
+    from sympy.core.symbol import Symbol
+
+    assert _test_args(SingleFinitePSpace(Symbol('x'), die))
+
+
+def test_sympy__stats__frv__ProductFinitePSpace():
+    from sympy.stats.frv import SingleFinitePSpace, ProductFinitePSpace
+    from sympy.core.symbol import Symbol
+    xp = SingleFinitePSpace(Symbol('x'), die)
+    yp = SingleFinitePSpace(Symbol('y'), die)
+    assert _test_args(ProductFinitePSpace(xp, yp))
+
+@SKIP("abstract class")
+def test_sympy__stats__frv__SingleFiniteDistribution():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__stats__crv__ContinuousDistribution():
+    pass
+
+
+def test_sympy__stats__frv_types__FiniteDistributionHandmade():
+    from sympy.stats.frv_types import FiniteDistributionHandmade
+    from sympy.core.containers import Dict
+    assert _test_args(FiniteDistributionHandmade(Dict({1: 1})))
+
+
+def test_sympy__stats__crv_types__ContinuousDistributionHandmade():
+    from sympy.stats.crv_types import ContinuousDistributionHandmade
+    from sympy.core.function import Lambda
+    from sympy.sets.sets import Interval
+    from sympy.abc import x
+    assert _test_args(ContinuousDistributionHandmade(Lambda(x, 2*x),
+                                                     Interval(0, 1)))
+
+
+def test_sympy__stats__drv_types__DiscreteDistributionHandmade():
+    from sympy.stats.drv_types import DiscreteDistributionHandmade
+    from sympy.core.function import Lambda
+    from sympy.sets.sets import FiniteSet
+    from sympy.abc import x
+    assert _test_args(DiscreteDistributionHandmade(Lambda(x, Rational(1, 10)),
+                                                    FiniteSet(*range(10))))
+
+
+def test_sympy__stats__rv__Density():
+    from sympy.stats.rv import Density
+    from sympy.stats.crv_types import Normal
+    assert _test_args(Density(Normal('x', 0, 1)))
+
+
+def test_sympy__stats__crv_types__ArcsinDistribution():
+    from sympy.stats.crv_types import ArcsinDistribution
+    assert _test_args(ArcsinDistribution(0, 1))
+
+
+def test_sympy__stats__crv_types__BeniniDistribution():
+    from sympy.stats.crv_types import BeniniDistribution
+    assert _test_args(BeniniDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__BetaDistribution():
+    from sympy.stats.crv_types import BetaDistribution
+    assert _test_args(BetaDistribution(1, 1))
+
+def test_sympy__stats__crv_types__BetaNoncentralDistribution():
+    from sympy.stats.crv_types import BetaNoncentralDistribution
+    assert _test_args(BetaNoncentralDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__BetaPrimeDistribution():
+    from sympy.stats.crv_types import BetaPrimeDistribution
+    assert _test_args(BetaPrimeDistribution(1, 1))
+
+def test_sympy__stats__crv_types__BoundedParetoDistribution():
+    from sympy.stats.crv_types import BoundedParetoDistribution
+    assert _test_args(BoundedParetoDistribution(1, 1, 2))
+
+def test_sympy__stats__crv_types__CauchyDistribution():
+    from sympy.stats.crv_types import CauchyDistribution
+    assert _test_args(CauchyDistribution(0, 1))
+
+
+def test_sympy__stats__crv_types__ChiDistribution():
+    from sympy.stats.crv_types import ChiDistribution
+    assert _test_args(ChiDistribution(1))
+
+
+def test_sympy__stats__crv_types__ChiNoncentralDistribution():
+    from sympy.stats.crv_types import ChiNoncentralDistribution
+    assert _test_args(ChiNoncentralDistribution(1,1))
+
+
+def test_sympy__stats__crv_types__ChiSquaredDistribution():
+    from sympy.stats.crv_types import ChiSquaredDistribution
+    assert _test_args(ChiSquaredDistribution(1))
+
+
+def test_sympy__stats__crv_types__DagumDistribution():
+    from sympy.stats.crv_types import DagumDistribution
+    assert _test_args(DagumDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__DavisDistribution():
+    from sympy.stats.crv_types import DavisDistribution
+    assert _test_args(DavisDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__ExGaussianDistribution():
+    from sympy.stats.crv_types import ExGaussianDistribution
+    assert _test_args(ExGaussianDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__ExponentialDistribution():
+    from sympy.stats.crv_types import ExponentialDistribution
+    assert _test_args(ExponentialDistribution(1))
+
+
+def test_sympy__stats__crv_types__ExponentialPowerDistribution():
+    from sympy.stats.crv_types import ExponentialPowerDistribution
+    assert _test_args(ExponentialPowerDistribution(0, 1, 1))
+
+
+def test_sympy__stats__crv_types__FDistributionDistribution():
+    from sympy.stats.crv_types import FDistributionDistribution
+    assert _test_args(FDistributionDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__FisherZDistribution():
+    from sympy.stats.crv_types import FisherZDistribution
+    assert _test_args(FisherZDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__FrechetDistribution():
+    from sympy.stats.crv_types import FrechetDistribution
+    assert _test_args(FrechetDistribution(1, 1, 1))
+
+
+def test_sympy__stats__crv_types__GammaInverseDistribution():
+    from sympy.stats.crv_types import GammaInverseDistribution
+    assert _test_args(GammaInverseDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__GammaDistribution():
+    from sympy.stats.crv_types import GammaDistribution
+    assert _test_args(GammaDistribution(1, 1))
+
+def test_sympy__stats__crv_types__GumbelDistribution():
+    from sympy.stats.crv_types import GumbelDistribution
+    assert _test_args(GumbelDistribution(1, 1, False))
+
+def test_sympy__stats__crv_types__GompertzDistribution():
+    from sympy.stats.crv_types import GompertzDistribution
+    assert _test_args(GompertzDistribution(1, 1))
+
+def test_sympy__stats__crv_types__KumaraswamyDistribution():
+    from sympy.stats.crv_types import KumaraswamyDistribution
+    assert _test_args(KumaraswamyDistribution(1, 1))
+
+def test_sympy__stats__crv_types__LaplaceDistribution():
+    from sympy.stats.crv_types import LaplaceDistribution
+    assert _test_args(LaplaceDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LevyDistribution():
+    from sympy.stats.crv_types import LevyDistribution
+    assert _test_args(LevyDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LogCauchyDistribution():
+    from sympy.stats.crv_types import LogCauchyDistribution
+    assert _test_args(LogCauchyDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LogisticDistribution():
+    from sympy.stats.crv_types import LogisticDistribution
+    assert _test_args(LogisticDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LogLogisticDistribution():
+    from sympy.stats.crv_types import LogLogisticDistribution
+    assert _test_args(LogLogisticDistribution(1, 1))
+
+def test_sympy__stats__crv_types__LogitNormalDistribution():
+    from sympy.stats.crv_types import LogitNormalDistribution
+    assert _test_args(LogitNormalDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LogNormalDistribution():
+    from sympy.stats.crv_types import LogNormalDistribution
+    assert _test_args(LogNormalDistribution(0, 1))
+
+def test_sympy__stats__crv_types__LomaxDistribution():
+    from sympy.stats.crv_types import LomaxDistribution
+    assert _test_args(LomaxDistribution(1, 2))
+
+def test_sympy__stats__crv_types__MaxwellDistribution():
+    from sympy.stats.crv_types import MaxwellDistribution
+    assert _test_args(MaxwellDistribution(1))
+
+def test_sympy__stats__crv_types__MoyalDistribution():
+    from sympy.stats.crv_types import MoyalDistribution
+    assert _test_args(MoyalDistribution(1,2))
+
+def test_sympy__stats__crv_types__NakagamiDistribution():
+    from sympy.stats.crv_types import NakagamiDistribution
+    assert _test_args(NakagamiDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__NormalDistribution():
+    from sympy.stats.crv_types import NormalDistribution
+    assert _test_args(NormalDistribution(0, 1))
+
+def test_sympy__stats__crv_types__GaussianInverseDistribution():
+    from sympy.stats.crv_types import GaussianInverseDistribution
+    assert _test_args(GaussianInverseDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__ParetoDistribution():
+    from sympy.stats.crv_types import ParetoDistribution
+    assert _test_args(ParetoDistribution(1, 1))
+
+def test_sympy__stats__crv_types__PowerFunctionDistribution():
+    from sympy.stats.crv_types import PowerFunctionDistribution
+    assert _test_args(PowerFunctionDistribution(2,0,1))
+
+def test_sympy__stats__crv_types__QuadraticUDistribution():
+    from sympy.stats.crv_types import QuadraticUDistribution
+    assert _test_args(QuadraticUDistribution(1, 2))
+
+def test_sympy__stats__crv_types__RaisedCosineDistribution():
+    from sympy.stats.crv_types import RaisedCosineDistribution
+    assert _test_args(RaisedCosineDistribution(1, 1))
+
+def test_sympy__stats__crv_types__RayleighDistribution():
+    from sympy.stats.crv_types import RayleighDistribution
+    assert _test_args(RayleighDistribution(1))
+
+def test_sympy__stats__crv_types__ReciprocalDistribution():
+    from sympy.stats.crv_types import ReciprocalDistribution
+    assert _test_args(ReciprocalDistribution(5, 30))
+
+def test_sympy__stats__crv_types__ShiftedGompertzDistribution():
+    from sympy.stats.crv_types import ShiftedGompertzDistribution
+    assert _test_args(ShiftedGompertzDistribution(1, 1))
+
+def test_sympy__stats__crv_types__StudentTDistribution():
+    from sympy.stats.crv_types import StudentTDistribution
+    assert _test_args(StudentTDistribution(1))
+
+def test_sympy__stats__crv_types__TrapezoidalDistribution():
+    from sympy.stats.crv_types import TrapezoidalDistribution
+    assert _test_args(TrapezoidalDistribution(1, 2, 3, 4))
+
+def test_sympy__stats__crv_types__TriangularDistribution():
+    from sympy.stats.crv_types import TriangularDistribution
+    assert _test_args(TriangularDistribution(-1, 0, 1))
+
+
+def test_sympy__stats__crv_types__UniformDistribution():
+    from sympy.stats.crv_types import UniformDistribution
+    assert _test_args(UniformDistribution(0, 1))
+
+
+def test_sympy__stats__crv_types__UniformSumDistribution():
+    from sympy.stats.crv_types import UniformSumDistribution
+    assert _test_args(UniformSumDistribution(1))
+
+
+def test_sympy__stats__crv_types__VonMisesDistribution():
+    from sympy.stats.crv_types import VonMisesDistribution
+    assert _test_args(VonMisesDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__WeibullDistribution():
+    from sympy.stats.crv_types import WeibullDistribution
+    assert _test_args(WeibullDistribution(1, 1))
+
+
+def test_sympy__stats__crv_types__WignerSemicircleDistribution():
+    from sympy.stats.crv_types import WignerSemicircleDistribution
+    assert _test_args(WignerSemicircleDistribution(1))
+
+
+def test_sympy__stats__drv_types__GeometricDistribution():
+    from sympy.stats.drv_types import GeometricDistribution
+    assert _test_args(GeometricDistribution(.5))
+
+def test_sympy__stats__drv_types__HermiteDistribution():
+    from sympy.stats.drv_types import HermiteDistribution
+    assert _test_args(HermiteDistribution(1, 2))
+
+def test_sympy__stats__drv_types__LogarithmicDistribution():
+    from sympy.stats.drv_types import LogarithmicDistribution
+    assert _test_args(LogarithmicDistribution(.5))
+
+
+def test_sympy__stats__drv_types__NegativeBinomialDistribution():
+    from sympy.stats.drv_types import NegativeBinomialDistribution
+    assert _test_args(NegativeBinomialDistribution(.5, .5))
+
+def test_sympy__stats__drv_types__FlorySchulzDistribution():
+    from sympy.stats.drv_types import FlorySchulzDistribution
+    assert _test_args(FlorySchulzDistribution(.5))
+
+def test_sympy__stats__drv_types__PoissonDistribution():
+    from sympy.stats.drv_types import PoissonDistribution
+    assert _test_args(PoissonDistribution(1))
+
+
+def test_sympy__stats__drv_types__SkellamDistribution():
+    from sympy.stats.drv_types import SkellamDistribution
+    assert _test_args(SkellamDistribution(1, 1))
+
+
+def test_sympy__stats__drv_types__YuleSimonDistribution():
+    from sympy.stats.drv_types import YuleSimonDistribution
+    assert _test_args(YuleSimonDistribution(.5))
+
+
+def test_sympy__stats__drv_types__ZetaDistribution():
+    from sympy.stats.drv_types import ZetaDistribution
+    assert _test_args(ZetaDistribution(1.5))
+
+
+def test_sympy__stats__joint_rv__JointDistribution():
+    from sympy.stats.joint_rv import JointDistribution
+    assert _test_args(JointDistribution(1, 2, 3, 4))
+
+
+def test_sympy__stats__joint_rv_types__MultivariateNormalDistribution():
+    from sympy.stats.joint_rv_types import MultivariateNormalDistribution
+    assert _test_args(
+        MultivariateNormalDistribution([0, 1], [[1, 0],[0, 1]]))
+
+def test_sympy__stats__joint_rv_types__MultivariateLaplaceDistribution():
+    from sympy.stats.joint_rv_types import MultivariateLaplaceDistribution
+    assert _test_args(MultivariateLaplaceDistribution([0, 1], [[1, 0],[0, 1]]))
+
+
+def test_sympy__stats__joint_rv_types__MultivariateTDistribution():
+    from sympy.stats.joint_rv_types import MultivariateTDistribution
+    assert _test_args(MultivariateTDistribution([0, 1], [[1, 0],[0, 1]], 1))
+
+
+def test_sympy__stats__joint_rv_types__NormalGammaDistribution():
+    from sympy.stats.joint_rv_types import NormalGammaDistribution
+    assert _test_args(NormalGammaDistribution(1, 2, 3, 4))
+
+def test_sympy__stats__joint_rv_types__GeneralizedMultivariateLogGammaDistribution():
+    from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaDistribution
+    v, l, mu = (4, [1, 2, 3, 4], [1, 2, 3, 4])
+    assert _test_args(GeneralizedMultivariateLogGammaDistribution(S.Half, v, l, mu))
+
+def test_sympy__stats__joint_rv_types__MultivariateBetaDistribution():
+    from sympy.stats.joint_rv_types import MultivariateBetaDistribution
+    assert _test_args(MultivariateBetaDistribution([1, 2, 3]))
+
+def test_sympy__stats__joint_rv_types__MultivariateEwensDistribution():
+    from sympy.stats.joint_rv_types import MultivariateEwensDistribution
+    assert _test_args(MultivariateEwensDistribution(5, 1))
+
+def test_sympy__stats__joint_rv_types__MultinomialDistribution():
+    from sympy.stats.joint_rv_types import MultinomialDistribution
+    assert _test_args(MultinomialDistribution(5, [0.5, 0.1, 0.3]))
+
+def test_sympy__stats__joint_rv_types__NegativeMultinomialDistribution():
+    from sympy.stats.joint_rv_types import NegativeMultinomialDistribution
+    assert _test_args(NegativeMultinomialDistribution(5, [0.5, 0.1, 0.3]))
+
+def test_sympy__stats__rv__RandomIndexedSymbol():
+    from sympy.stats.rv import RandomIndexedSymbol, pspace
+    from sympy.stats.stochastic_process_types import DiscreteMarkovChain
+    X = DiscreteMarkovChain("X")
+    assert _test_args(RandomIndexedSymbol(X[0].symbol, pspace(X[0])))
+
+def test_sympy__stats__rv__RandomMatrixSymbol():
+    from sympy.stats.rv import RandomMatrixSymbol
+    from sympy.stats.random_matrix import RandomMatrixPSpace
+    pspace = RandomMatrixPSpace('P')
+    assert _test_args(RandomMatrixSymbol('M', 3, 3, pspace))
+
+def test_sympy__stats__stochastic_process__StochasticPSpace():
+    from sympy.stats.stochastic_process import StochasticPSpace
+    from sympy.stats.stochastic_process_types import StochasticProcess
+    from sympy.stats.frv_types import BernoulliDistribution
+    assert _test_args(StochasticPSpace("Y", StochasticProcess("Y", [1, 2, 3]), BernoulliDistribution(S.Half, 1, 0)))
+
+def test_sympy__stats__stochastic_process_types__StochasticProcess():
+    from sympy.stats.stochastic_process_types import StochasticProcess
+    assert _test_args(StochasticProcess("Y", [1, 2, 3]))
+
+def test_sympy__stats__stochastic_process_types__MarkovProcess():
+    from sympy.stats.stochastic_process_types import MarkovProcess
+    assert _test_args(MarkovProcess("Y", [1, 2, 3]))
+
+def test_sympy__stats__stochastic_process_types__DiscreteTimeStochasticProcess():
+    from sympy.stats.stochastic_process_types import DiscreteTimeStochasticProcess
+    assert _test_args(DiscreteTimeStochasticProcess("Y", [1, 2, 3]))
+
+def test_sympy__stats__stochastic_process_types__ContinuousTimeStochasticProcess():
+    from sympy.stats.stochastic_process_types import ContinuousTimeStochasticProcess
+    assert _test_args(ContinuousTimeStochasticProcess("Y", [1, 2, 3]))
+
+def test_sympy__stats__stochastic_process_types__TransitionMatrixOf():
+    from sympy.stats.stochastic_process_types import TransitionMatrixOf, DiscreteMarkovChain
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    DMC = DiscreteMarkovChain("Y")
+    assert _test_args(TransitionMatrixOf(DMC, MatrixSymbol('T', 3, 3)))
+
+def test_sympy__stats__stochastic_process_types__GeneratorMatrixOf():
+    from sympy.stats.stochastic_process_types import GeneratorMatrixOf, ContinuousMarkovChain
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    DMC = ContinuousMarkovChain("Y")
+    assert _test_args(GeneratorMatrixOf(DMC, MatrixSymbol('T', 3, 3)))
+
+def test_sympy__stats__stochastic_process_types__StochasticStateSpaceOf():
+    from sympy.stats.stochastic_process_types import StochasticStateSpaceOf, DiscreteMarkovChain
+    DMC = DiscreteMarkovChain("Y")
+    assert _test_args(StochasticStateSpaceOf(DMC, [0, 1, 2]))
+
+def test_sympy__stats__stochastic_process_types__DiscreteMarkovChain():
+    from sympy.stats.stochastic_process_types import DiscreteMarkovChain
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    assert _test_args(DiscreteMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3)))
+
+def test_sympy__stats__stochastic_process_types__ContinuousMarkovChain():
+    from sympy.stats.stochastic_process_types import ContinuousMarkovChain
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    assert _test_args(ContinuousMarkovChain("Y", [0, 1, 2], MatrixSymbol('T', 3, 3)))
+
+def test_sympy__stats__stochastic_process_types__BernoulliProcess():
+    from sympy.stats.stochastic_process_types import BernoulliProcess
+    assert _test_args(BernoulliProcess("B", 0.5, 1, 0))
+
+def test_sympy__stats__stochastic_process_types__CountingProcess():
+    from sympy.stats.stochastic_process_types import CountingProcess
+    assert _test_args(CountingProcess("C"))
+
+def test_sympy__stats__stochastic_process_types__PoissonProcess():
+    from sympy.stats.stochastic_process_types import PoissonProcess
+    assert _test_args(PoissonProcess("X", 2))
+
+def test_sympy__stats__stochastic_process_types__WienerProcess():
+    from sympy.stats.stochastic_process_types import WienerProcess
+    assert _test_args(WienerProcess("X"))
+
+def test_sympy__stats__stochastic_process_types__GammaProcess():
+    from sympy.stats.stochastic_process_types import GammaProcess
+    assert _test_args(GammaProcess("X", 1, 2))
+
+def test_sympy__stats__random_matrix__RandomMatrixPSpace():
+    from sympy.stats.random_matrix import RandomMatrixPSpace
+    from sympy.stats.random_matrix_models import RandomMatrixEnsembleModel
+    model = RandomMatrixEnsembleModel('R', 3)
+    assert _test_args(RandomMatrixPSpace('P', model=model))
+
+def test_sympy__stats__random_matrix_models__RandomMatrixEnsembleModel():
+    from sympy.stats.random_matrix_models import RandomMatrixEnsembleModel
+    assert _test_args(RandomMatrixEnsembleModel('R', 3))
+
+def test_sympy__stats__random_matrix_models__GaussianEnsembleModel():
+    from sympy.stats.random_matrix_models import GaussianEnsembleModel
+    assert _test_args(GaussianEnsembleModel('G', 3))
+
+def test_sympy__stats__random_matrix_models__GaussianUnitaryEnsembleModel():
+    from sympy.stats.random_matrix_models import GaussianUnitaryEnsembleModel
+    assert _test_args(GaussianUnitaryEnsembleModel('U', 3))
+
+def test_sympy__stats__random_matrix_models__GaussianOrthogonalEnsembleModel():
+    from sympy.stats.random_matrix_models import GaussianOrthogonalEnsembleModel
+    assert _test_args(GaussianOrthogonalEnsembleModel('U', 3))
+
+def test_sympy__stats__random_matrix_models__GaussianSymplecticEnsembleModel():
+    from sympy.stats.random_matrix_models import GaussianSymplecticEnsembleModel
+    assert _test_args(GaussianSymplecticEnsembleModel('U', 3))
+
+def test_sympy__stats__random_matrix_models__CircularEnsembleModel():
+    from sympy.stats.random_matrix_models import CircularEnsembleModel
+    assert _test_args(CircularEnsembleModel('C', 3))
+
+def test_sympy__stats__random_matrix_models__CircularUnitaryEnsembleModel():
+    from sympy.stats.random_matrix_models import CircularUnitaryEnsembleModel
+    assert _test_args(CircularUnitaryEnsembleModel('U', 3))
+
+def test_sympy__stats__random_matrix_models__CircularOrthogonalEnsembleModel():
+    from sympy.stats.random_matrix_models import CircularOrthogonalEnsembleModel
+    assert _test_args(CircularOrthogonalEnsembleModel('O', 3))
+
+def test_sympy__stats__random_matrix_models__CircularSymplecticEnsembleModel():
+    from sympy.stats.random_matrix_models import CircularSymplecticEnsembleModel
+    assert _test_args(CircularSymplecticEnsembleModel('S', 3))
+
+def test_sympy__stats__symbolic_multivariate_probability__ExpectationMatrix():
+    from sympy.stats import ExpectationMatrix
+    from sympy.stats.rv import RandomMatrixSymbol
+    assert _test_args(ExpectationMatrix(RandomMatrixSymbol('R', 2, 1)))
+
+def test_sympy__stats__symbolic_multivariate_probability__VarianceMatrix():
+    from sympy.stats import VarianceMatrix
+    from sympy.stats.rv import RandomMatrixSymbol
+    assert _test_args(VarianceMatrix(RandomMatrixSymbol('R', 3, 1)))
+
+def test_sympy__stats__symbolic_multivariate_probability__CrossCovarianceMatrix():
+    from sympy.stats import CrossCovarianceMatrix
+    from sympy.stats.rv import RandomMatrixSymbol
+    assert _test_args(CrossCovarianceMatrix(RandomMatrixSymbol('R', 3, 1),
+                        RandomMatrixSymbol('X', 3, 1)))
+
+def test_sympy__stats__matrix_distributions__MatrixPSpace():
+    from sympy.stats.matrix_distributions import MatrixDistribution, MatrixPSpace
+    from sympy.matrices.dense import Matrix
+    M = MatrixDistribution(1, Matrix([[1, 0], [0, 1]]))
+    assert _test_args(MatrixPSpace('M', M, 2, 2))
+
+def test_sympy__stats__matrix_distributions__MatrixDistribution():
+    from sympy.stats.matrix_distributions import MatrixDistribution
+    from sympy.matrices.dense import Matrix
+    assert _test_args(MatrixDistribution(1, Matrix([[1, 0], [0, 1]])))
+
+def test_sympy__stats__matrix_distributions__MatrixGammaDistribution():
+    from sympy.stats.matrix_distributions import MatrixGammaDistribution
+    from sympy.matrices.dense import Matrix
+    assert _test_args(MatrixGammaDistribution(3, 4, Matrix([[1, 0], [0, 1]])))
+
+def test_sympy__stats__matrix_distributions__WishartDistribution():
+    from sympy.stats.matrix_distributions import WishartDistribution
+    from sympy.matrices.dense import Matrix
+    assert _test_args(WishartDistribution(3, Matrix([[1, 0], [0, 1]])))
+
+def test_sympy__stats__matrix_distributions__MatrixNormalDistribution():
+    from sympy.stats.matrix_distributions import MatrixNormalDistribution
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    L = MatrixSymbol('L', 1, 2)
+    S1 = MatrixSymbol('S1', 1, 1)
+    S2 = MatrixSymbol('S2', 2, 2)
+    assert _test_args(MatrixNormalDistribution(L, S1, S2))
+
+def test_sympy__stats__matrix_distributions__MatrixStudentTDistribution():
+    from sympy.stats.matrix_distributions import MatrixStudentTDistribution
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    v = symbols('v', positive=True)
+    Omega = MatrixSymbol('Omega', 3, 3)
+    Sigma = MatrixSymbol('Sigma', 1, 1)
+    Location = MatrixSymbol('Location', 1, 3)
+    assert _test_args(MatrixStudentTDistribution(v, Location, Omega, Sigma))
+
+def test_sympy__utilities__matchpy_connector__WildDot():
+    from sympy.utilities.matchpy_connector import WildDot
+    assert _test_args(WildDot("w_"))
+
+
+def test_sympy__utilities__matchpy_connector__WildPlus():
+    from sympy.utilities.matchpy_connector import WildPlus
+    assert _test_args(WildPlus("w__"))
+
+
+def test_sympy__utilities__matchpy_connector__WildStar():
+    from sympy.utilities.matchpy_connector import WildStar
+    assert _test_args(WildStar("w___"))
+
+
+def test_sympy__core__symbol__Str():
+    from sympy.core.symbol import Str
+    assert _test_args(Str('t'))
+
+def test_sympy__core__symbol__Dummy():
+    from sympy.core.symbol import Dummy
+    assert _test_args(Dummy('t'))
+
+
+def test_sympy__core__symbol__Symbol():
+    from sympy.core.symbol import Symbol
+    assert _test_args(Symbol('t'))
+
+
+def test_sympy__core__symbol__Wild():
+    from sympy.core.symbol import Wild
+    assert _test_args(Wild('x', exclude=[x]))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__combinatorial__factorials__CombinatorialFunction():
+    pass
+
+
+def test_sympy__functions__combinatorial__factorials__FallingFactorial():
+    from sympy.functions.combinatorial.factorials import FallingFactorial
+    assert _test_args(FallingFactorial(2, x))
+
+
+def test_sympy__functions__combinatorial__factorials__MultiFactorial():
+    from sympy.functions.combinatorial.factorials import MultiFactorial
+    assert _test_args(MultiFactorial(x))
+
+
+def test_sympy__functions__combinatorial__factorials__RisingFactorial():
+    from sympy.functions.combinatorial.factorials import RisingFactorial
+    assert _test_args(RisingFactorial(2, x))
+
+
+def test_sympy__functions__combinatorial__factorials__binomial():
+    from sympy.functions.combinatorial.factorials import binomial
+    assert _test_args(binomial(2, x))
+
+
+def test_sympy__functions__combinatorial__factorials__subfactorial():
+    from sympy.functions.combinatorial.factorials import subfactorial
+    assert _test_args(subfactorial(x))
+
+
+def test_sympy__functions__combinatorial__factorials__factorial():
+    from sympy.functions.combinatorial.factorials import factorial
+    assert _test_args(factorial(x))
+
+
+def test_sympy__functions__combinatorial__factorials__factorial2():
+    from sympy.functions.combinatorial.factorials import factorial2
+    assert _test_args(factorial2(x))
+
+
+def test_sympy__functions__combinatorial__numbers__bell():
+    from sympy.functions.combinatorial.numbers import bell
+    assert _test_args(bell(x, y))
+
+
+def test_sympy__functions__combinatorial__numbers__bernoulli():
+    from sympy.functions.combinatorial.numbers import bernoulli
+    assert _test_args(bernoulli(x))
+
+
+def test_sympy__functions__combinatorial__numbers__catalan():
+    from sympy.functions.combinatorial.numbers import catalan
+    assert _test_args(catalan(x))
+
+
+def test_sympy__functions__combinatorial__numbers__genocchi():
+    from sympy.functions.combinatorial.numbers import genocchi
+    assert _test_args(genocchi(x))
+
+
+def test_sympy__functions__combinatorial__numbers__euler():
+    from sympy.functions.combinatorial.numbers import euler
+    assert _test_args(euler(x))
+
+
+def test_sympy__functions__combinatorial__numbers__andre():
+    from sympy.functions.combinatorial.numbers import andre
+    assert _test_args(andre(x))
+
+
+def test_sympy__functions__combinatorial__numbers__carmichael():
+    from sympy.functions.combinatorial.numbers import carmichael
+    assert _test_args(carmichael(x))
+
+
+def test_sympy__functions__combinatorial__numbers__divisor_sigma():
+    from sympy.functions.combinatorial.numbers import divisor_sigma
+    k = symbols('k', integer=True)
+    n = symbols('n', integer=True)
+    t = divisor_sigma(n, k)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__fibonacci():
+    from sympy.functions.combinatorial.numbers import fibonacci
+    assert _test_args(fibonacci(x))
+
+
+def test_sympy__functions__combinatorial__numbers__jacobi_symbol():
+    from sympy.functions.combinatorial.numbers import jacobi_symbol
+    assert _test_args(jacobi_symbol(2, 3))
+
+
+def test_sympy__functions__combinatorial__numbers__kronecker_symbol():
+    from sympy.functions.combinatorial.numbers import kronecker_symbol
+    assert _test_args(kronecker_symbol(2, 3))
+
+
+def test_sympy__functions__combinatorial__numbers__legendre_symbol():
+    from sympy.functions.combinatorial.numbers import legendre_symbol
+    assert _test_args(legendre_symbol(2, 3))
+
+
+def test_sympy__functions__combinatorial__numbers__mobius():
+    from sympy.functions.combinatorial.numbers import mobius
+    assert _test_args(mobius(2))
+
+
+def test_sympy__functions__combinatorial__numbers__motzkin():
+    from sympy.functions.combinatorial.numbers import motzkin
+    assert _test_args(motzkin(5))
+
+
+def test_sympy__functions__combinatorial__numbers__partition():
+    from sympy.core.symbol import Symbol
+    from sympy.functions.combinatorial.numbers import partition
+    assert _test_args(partition(Symbol('a', integer=True)))
+
+
+def test_sympy__functions__combinatorial__numbers__primenu():
+    from sympy.functions.combinatorial.numbers import primenu
+    n = symbols('n', integer=True)
+    t = primenu(n)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__primeomega():
+    from sympy.functions.combinatorial.numbers import primeomega
+    n = symbols('n', integer=True)
+    t = primeomega(n)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__primepi():
+    from sympy.functions.combinatorial.numbers import primepi
+    n = symbols('n')
+    t = primepi(n)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__reduced_totient():
+    from sympy.functions.combinatorial.numbers import reduced_totient
+    k = symbols('k', integer=True)
+    t = reduced_totient(k)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__totient():
+    from sympy.functions.combinatorial.numbers import totient
+    k = symbols('k', integer=True)
+    t = totient(k)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__tribonacci():
+    from sympy.functions.combinatorial.numbers import tribonacci
+    assert _test_args(tribonacci(x))
+
+
+def test_sympy__functions__combinatorial__numbers__udivisor_sigma():
+    from sympy.functions.combinatorial.numbers import udivisor_sigma
+    k = symbols('k', integer=True)
+    n = symbols('n', integer=True)
+    t = udivisor_sigma(n, k)
+    assert _test_args(t)
+
+
+def test_sympy__functions__combinatorial__numbers__harmonic():
+    from sympy.functions.combinatorial.numbers import harmonic
+    assert _test_args(harmonic(x, 2))
+
+
+def test_sympy__functions__combinatorial__numbers__lucas():
+    from sympy.functions.combinatorial.numbers import lucas
+    assert _test_args(lucas(x))
+
+
+def test_sympy__functions__elementary__complexes__Abs():
+    from sympy.functions.elementary.complexes import Abs
+    assert _test_args(Abs(x))
+
+
+def test_sympy__functions__elementary__complexes__adjoint():
+    from sympy.functions.elementary.complexes import adjoint
+    assert _test_args(adjoint(x))
+
+
+def test_sympy__functions__elementary__complexes__arg():
+    from sympy.functions.elementary.complexes import arg
+    assert _test_args(arg(x))
+
+
+def test_sympy__functions__elementary__complexes__conjugate():
+    from sympy.functions.elementary.complexes import conjugate
+    assert _test_args(conjugate(x))
+
+
+def test_sympy__functions__elementary__complexes__im():
+    from sympy.functions.elementary.complexes import im
+    assert _test_args(im(x))
+
+
+def test_sympy__functions__elementary__complexes__re():
+    from sympy.functions.elementary.complexes import re
+    assert _test_args(re(x))
+
+
+def test_sympy__functions__elementary__complexes__sign():
+    from sympy.functions.elementary.complexes import sign
+    assert _test_args(sign(x))
+
+
+def test_sympy__functions__elementary__complexes__polar_lift():
+    from sympy.functions.elementary.complexes import polar_lift
+    assert _test_args(polar_lift(x))
+
+
+def test_sympy__functions__elementary__complexes__periodic_argument():
+    from sympy.functions.elementary.complexes import periodic_argument
+    assert _test_args(periodic_argument(x, y))
+
+
+def test_sympy__functions__elementary__complexes__principal_branch():
+    from sympy.functions.elementary.complexes import principal_branch
+    assert _test_args(principal_branch(x, y))
+
+
+def test_sympy__functions__elementary__complexes__transpose():
+    from sympy.functions.elementary.complexes import transpose
+    assert _test_args(transpose(x))
+
+
+def test_sympy__functions__elementary__exponential__LambertW():
+    from sympy.functions.elementary.exponential import LambertW
+    assert _test_args(LambertW(2))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__exponential__ExpBase():
+    pass
+
+
+def test_sympy__functions__elementary__exponential__exp():
+    from sympy.functions.elementary.exponential import exp
+    assert _test_args(exp(2))
+
+
+def test_sympy__functions__elementary__exponential__exp_polar():
+    from sympy.functions.elementary.exponential import exp_polar
+    assert _test_args(exp_polar(2))
+
+
+def test_sympy__functions__elementary__exponential__log():
+    from sympy.functions.elementary.exponential import log
+    assert _test_args(log(2))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__hyperbolic__HyperbolicFunction():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__hyperbolic__ReciprocalHyperbolicFunction():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__hyperbolic__InverseHyperbolicFunction():
+    pass
+
+
+def test_sympy__functions__elementary__hyperbolic__acosh():
+    from sympy.functions.elementary.hyperbolic import acosh
+    assert _test_args(acosh(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__acoth():
+    from sympy.functions.elementary.hyperbolic import acoth
+    assert _test_args(acoth(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__asinh():
+    from sympy.functions.elementary.hyperbolic import asinh
+    assert _test_args(asinh(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__atanh():
+    from sympy.functions.elementary.hyperbolic import atanh
+    assert _test_args(atanh(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__asech():
+    from sympy.functions.elementary.hyperbolic import asech
+    assert _test_args(asech(x))
+
+def test_sympy__functions__elementary__hyperbolic__acsch():
+    from sympy.functions.elementary.hyperbolic import acsch
+    assert _test_args(acsch(x))
+
+def test_sympy__functions__elementary__hyperbolic__cosh():
+    from sympy.functions.elementary.hyperbolic import cosh
+    assert _test_args(cosh(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__coth():
+    from sympy.functions.elementary.hyperbolic import coth
+    assert _test_args(coth(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__csch():
+    from sympy.functions.elementary.hyperbolic import csch
+    assert _test_args(csch(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__sech():
+    from sympy.functions.elementary.hyperbolic import sech
+    assert _test_args(sech(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__sinh():
+    from sympy.functions.elementary.hyperbolic import sinh
+    assert _test_args(sinh(2))
+
+
+def test_sympy__functions__elementary__hyperbolic__tanh():
+    from sympy.functions.elementary.hyperbolic import tanh
+    assert _test_args(tanh(2))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__integers__RoundFunction():
+    pass
+
+
+def test_sympy__functions__elementary__integers__ceiling():
+    from sympy.functions.elementary.integers import ceiling
+    assert _test_args(ceiling(x))
+
+
+def test_sympy__functions__elementary__integers__floor():
+    from sympy.functions.elementary.integers import floor
+    assert _test_args(floor(x))
+
+
+def test_sympy__functions__elementary__integers__frac():
+    from sympy.functions.elementary.integers import frac
+    assert _test_args(frac(x))
+
+
+def test_sympy__functions__elementary__miscellaneous__IdentityFunction():
+    from sympy.functions.elementary.miscellaneous import IdentityFunction
+    assert _test_args(IdentityFunction())
+
+
+def test_sympy__functions__elementary__miscellaneous__Max():
+    from sympy.functions.elementary.miscellaneous import Max
+    assert _test_args(Max(x, 2))
+
+
+def test_sympy__functions__elementary__miscellaneous__Min():
+    from sympy.functions.elementary.miscellaneous import Min
+    assert _test_args(Min(x, 2))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__miscellaneous__MinMaxBase():
+    pass
+
+
+def test_sympy__functions__elementary__miscellaneous__Rem():
+    from sympy.functions.elementary.miscellaneous import Rem
+    assert _test_args(Rem(x, 2))
+
+
+def test_sympy__functions__elementary__piecewise__ExprCondPair():
+    from sympy.functions.elementary.piecewise import ExprCondPair
+    assert _test_args(ExprCondPair(1, True))
+
+
+def test_sympy__functions__elementary__piecewise__Piecewise():
+    from sympy.functions.elementary.piecewise import Piecewise
+    assert _test_args(Piecewise((1, x >= 0), (0, True)))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__trigonometric__TrigonometricFunction():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__trigonometric__ReciprocalTrigonometricFunction():
+    pass
+
+@SKIP("abstract class")
+def test_sympy__functions__elementary__trigonometric__InverseTrigonometricFunction():
+    pass
+
+def test_sympy__functions__elementary__trigonometric__acos():
+    from sympy.functions.elementary.trigonometric import acos
+    assert _test_args(acos(2))
+
+
+def test_sympy__functions__elementary__trigonometric__acot():
+    from sympy.functions.elementary.trigonometric import acot
+    assert _test_args(acot(2))
+
+
+def test_sympy__functions__elementary__trigonometric__asin():
+    from sympy.functions.elementary.trigonometric import asin
+    assert _test_args(asin(2))
+
+
+def test_sympy__functions__elementary__trigonometric__asec():
+    from sympy.functions.elementary.trigonometric import asec
+    assert _test_args(asec(x))
+
+
+def test_sympy__functions__elementary__trigonometric__acsc():
+    from sympy.functions.elementary.trigonometric import acsc
+    assert _test_args(acsc(x))
+
+
+def test_sympy__functions__elementary__trigonometric__atan():
+    from sympy.functions.elementary.trigonometric import atan
+    assert _test_args(atan(2))
+
+
+def test_sympy__functions__elementary__trigonometric__atan2():
+    from sympy.functions.elementary.trigonometric import atan2
+    assert _test_args(atan2(2, 3))
+
+
+def test_sympy__functions__elementary__trigonometric__cos():
+    from sympy.functions.elementary.trigonometric import cos
+    assert _test_args(cos(2))
+
+
+def test_sympy__functions__elementary__trigonometric__csc():
+    from sympy.functions.elementary.trigonometric import csc
+    assert _test_args(csc(2))
+
+
+def test_sympy__functions__elementary__trigonometric__cot():
+    from sympy.functions.elementary.trigonometric import cot
+    assert _test_args(cot(2))
+
+
+def test_sympy__functions__elementary__trigonometric__sin():
+    assert _test_args(sin(2))
+
+
+def test_sympy__functions__elementary__trigonometric__sinc():
+    from sympy.functions.elementary.trigonometric import sinc
+    assert _test_args(sinc(2))
+
+
+def test_sympy__functions__elementary__trigonometric__sec():
+    from sympy.functions.elementary.trigonometric import sec
+    assert _test_args(sec(2))
+
+
+def test_sympy__functions__elementary__trigonometric__tan():
+    from sympy.functions.elementary.trigonometric import tan
+    assert _test_args(tan(2))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__bessel__BesselBase():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__bessel__SphericalBesselBase():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__bessel__SphericalHankelBase():
+    pass
+
+
+def test_sympy__functions__special__bessel__besseli():
+    from sympy.functions.special.bessel import besseli
+    assert _test_args(besseli(x, 1))
+
+
+def test_sympy__functions__special__bessel__besselj():
+    from sympy.functions.special.bessel import besselj
+    assert _test_args(besselj(x, 1))
+
+
+def test_sympy__functions__special__bessel__besselk():
+    from sympy.functions.special.bessel import besselk
+    assert _test_args(besselk(x, 1))
+
+
+def test_sympy__functions__special__bessel__bessely():
+    from sympy.functions.special.bessel import bessely
+    assert _test_args(bessely(x, 1))
+
+
+def test_sympy__functions__special__bessel__hankel1():
+    from sympy.functions.special.bessel import hankel1
+    assert _test_args(hankel1(x, 1))
+
+
+def test_sympy__functions__special__bessel__hankel2():
+    from sympy.functions.special.bessel import hankel2
+    assert _test_args(hankel2(x, 1))
+
+
+def test_sympy__functions__special__bessel__jn():
+    from sympy.functions.special.bessel import jn
+    assert _test_args(jn(0, x))
+
+
+def test_sympy__functions__special__bessel__yn():
+    from sympy.functions.special.bessel import yn
+    assert _test_args(yn(0, x))
+
+
+def test_sympy__functions__special__bessel__hn1():
+    from sympy.functions.special.bessel import hn1
+    assert _test_args(hn1(0, x))
+
+
+def test_sympy__functions__special__bessel__hn2():
+    from sympy.functions.special.bessel import hn2
+    assert _test_args(hn2(0, x))
+
+
+def test_sympy__functions__special__bessel__AiryBase():
+    pass
+
+
+def test_sympy__functions__special__bessel__airyai():
+    from sympy.functions.special.bessel import airyai
+    assert _test_args(airyai(2))
+
+
+def test_sympy__functions__special__bessel__airybi():
+    from sympy.functions.special.bessel import airybi
+    assert _test_args(airybi(2))
+
+
+def test_sympy__functions__special__bessel__airyaiprime():
+    from sympy.functions.special.bessel import airyaiprime
+    assert _test_args(airyaiprime(2))
+
+
+def test_sympy__functions__special__bessel__airybiprime():
+    from sympy.functions.special.bessel import airybiprime
+    assert _test_args(airybiprime(2))
+
+
+def test_sympy__functions__special__bessel__marcumq():
+    from sympy.functions.special.bessel import marcumq
+    assert _test_args(marcumq(x, y, z))
+
+
+def test_sympy__functions__special__elliptic_integrals__elliptic_k():
+    from sympy.functions.special.elliptic_integrals import elliptic_k as K
+    assert _test_args(K(x))
+
+
+def test_sympy__functions__special__elliptic_integrals__elliptic_f():
+    from sympy.functions.special.elliptic_integrals import elliptic_f as F
+    assert _test_args(F(x, y))
+
+
+def test_sympy__functions__special__elliptic_integrals__elliptic_e():
+    from sympy.functions.special.elliptic_integrals import elliptic_e as E
+    assert _test_args(E(x))
+    assert _test_args(E(x, y))
+
+
+def test_sympy__functions__special__elliptic_integrals__elliptic_pi():
+    from sympy.functions.special.elliptic_integrals import elliptic_pi as P
+    assert _test_args(P(x, y))
+    assert _test_args(P(x, y, z))
+
+
+def test_sympy__functions__special__delta_functions__DiracDelta():
+    from sympy.functions.special.delta_functions import DiracDelta
+    assert _test_args(DiracDelta(x, 1))
+
+
+def test_sympy__functions__special__singularity_functions__SingularityFunction():
+    from sympy.functions.special.singularity_functions import SingularityFunction
+    assert _test_args(SingularityFunction(x, y, z))
+
+
+def test_sympy__functions__special__delta_functions__Heaviside():
+    from sympy.functions.special.delta_functions import Heaviside
+    assert _test_args(Heaviside(x))
+
+
+def test_sympy__functions__special__error_functions__erf():
+    from sympy.functions.special.error_functions import erf
+    assert _test_args(erf(2))
+
+def test_sympy__functions__special__error_functions__erfc():
+    from sympy.functions.special.error_functions import erfc
+    assert _test_args(erfc(2))
+
+def test_sympy__functions__special__error_functions__erfi():
+    from sympy.functions.special.error_functions import erfi
+    assert _test_args(erfi(2))
+
+def test_sympy__functions__special__error_functions__erf2():
+    from sympy.functions.special.error_functions import erf2
+    assert _test_args(erf2(2, 3))
+
+def test_sympy__functions__special__error_functions__erfinv():
+    from sympy.functions.special.error_functions import erfinv
+    assert _test_args(erfinv(2))
+
+def test_sympy__functions__special__error_functions__erfcinv():
+    from sympy.functions.special.error_functions import erfcinv
+    assert _test_args(erfcinv(2))
+
+def test_sympy__functions__special__error_functions__erf2inv():
+    from sympy.functions.special.error_functions import erf2inv
+    assert _test_args(erf2inv(2, 3))
+
+@SKIP("abstract class")
+def test_sympy__functions__special__error_functions__FresnelIntegral():
+    pass
+
+
+def test_sympy__functions__special__error_functions__fresnels():
+    from sympy.functions.special.error_functions import fresnels
+    assert _test_args(fresnels(2))
+
+
+def test_sympy__functions__special__error_functions__fresnelc():
+    from sympy.functions.special.error_functions import fresnelc
+    assert _test_args(fresnelc(2))
+
+
+def test_sympy__functions__special__error_functions__erfs():
+    from sympy.functions.special.error_functions import _erfs
+    assert _test_args(_erfs(2))
+
+
+def test_sympy__functions__special__error_functions__Ei():
+    from sympy.functions.special.error_functions import Ei
+    assert _test_args(Ei(2))
+
+
+def test_sympy__functions__special__error_functions__li():
+    from sympy.functions.special.error_functions import li
+    assert _test_args(li(2))
+
+
+def test_sympy__functions__special__error_functions__Li():
+    from sympy.functions.special.error_functions import Li
+    assert _test_args(Li(5))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__error_functions__TrigonometricIntegral():
+    pass
+
+
+def test_sympy__functions__special__error_functions__Si():
+    from sympy.functions.special.error_functions import Si
+    assert _test_args(Si(2))
+
+
+def test_sympy__functions__special__error_functions__Ci():
+    from sympy.functions.special.error_functions import Ci
+    assert _test_args(Ci(2))
+
+
+def test_sympy__functions__special__error_functions__Shi():
+    from sympy.functions.special.error_functions import Shi
+    assert _test_args(Shi(2))
+
+
+def test_sympy__functions__special__error_functions__Chi():
+    from sympy.functions.special.error_functions import Chi
+    assert _test_args(Chi(2))
+
+
+def test_sympy__functions__special__error_functions__expint():
+    from sympy.functions.special.error_functions import expint
+    assert _test_args(expint(y, x))
+
+
+def test_sympy__functions__special__gamma_functions__gamma():
+    from sympy.functions.special.gamma_functions import gamma
+    assert _test_args(gamma(x))
+
+
+def test_sympy__functions__special__gamma_functions__loggamma():
+    from sympy.functions.special.gamma_functions import loggamma
+    assert _test_args(loggamma(x))
+
+
+def test_sympy__functions__special__gamma_functions__lowergamma():
+    from sympy.functions.special.gamma_functions import lowergamma
+    assert _test_args(lowergamma(x, 2))
+
+
+def test_sympy__functions__special__gamma_functions__polygamma():
+    from sympy.functions.special.gamma_functions import polygamma
+    assert _test_args(polygamma(x, 2))
+
+def test_sympy__functions__special__gamma_functions__digamma():
+    from sympy.functions.special.gamma_functions import digamma
+    assert _test_args(digamma(x))
+
+def test_sympy__functions__special__gamma_functions__trigamma():
+    from sympy.functions.special.gamma_functions import trigamma
+    assert _test_args(trigamma(x))
+
+def test_sympy__functions__special__gamma_functions__uppergamma():
+    from sympy.functions.special.gamma_functions import uppergamma
+    assert _test_args(uppergamma(x, 2))
+
+def test_sympy__functions__special__gamma_functions__multigamma():
+    from sympy.functions.special.gamma_functions import multigamma
+    assert _test_args(multigamma(x, 1))
+
+
+def test_sympy__functions__special__beta_functions__beta():
+    from sympy.functions.special.beta_functions import beta
+    assert _test_args(beta(x))
+    assert _test_args(beta(x, x))
+
+def test_sympy__functions__special__beta_functions__betainc():
+    from sympy.functions.special.beta_functions import betainc
+    assert _test_args(betainc(a, b, x, y))
+
+def test_sympy__functions__special__beta_functions__betainc_regularized():
+    from sympy.functions.special.beta_functions import betainc_regularized
+    assert _test_args(betainc_regularized(a, b, x, y))
+
+
+def test_sympy__functions__special__mathieu_functions__MathieuBase():
+    pass
+
+
+def test_sympy__functions__special__mathieu_functions__mathieus():
+    from sympy.functions.special.mathieu_functions import mathieus
+    assert _test_args(mathieus(1, 1, 1))
+
+
+def test_sympy__functions__special__mathieu_functions__mathieuc():
+    from sympy.functions.special.mathieu_functions import mathieuc
+    assert _test_args(mathieuc(1, 1, 1))
+
+
+def test_sympy__functions__special__mathieu_functions__mathieusprime():
+    from sympy.functions.special.mathieu_functions import mathieusprime
+    assert _test_args(mathieusprime(1, 1, 1))
+
+
+def test_sympy__functions__special__mathieu_functions__mathieucprime():
+    from sympy.functions.special.mathieu_functions import mathieucprime
+    assert _test_args(mathieucprime(1, 1, 1))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__hyper__TupleParametersBase():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__hyper__TupleArg():
+    pass
+
+
+def test_sympy__functions__special__hyper__hyper():
+    from sympy.functions.special.hyper import hyper
+    assert _test_args(hyper([1, 2, 3], [4, 5], x))
+
+
+def test_sympy__functions__special__hyper__meijerg():
+    from sympy.functions.special.hyper import meijerg
+    assert _test_args(meijerg([1, 2, 3], [4, 5], [6], [], x))
+
+
+@SKIP("abstract class")
+def test_sympy__functions__special__hyper__HyperRep():
+    pass
+
+
+def test_sympy__functions__special__hyper__HyperRep_power1():
+    from sympy.functions.special.hyper import HyperRep_power1
+    assert _test_args(HyperRep_power1(x, y))
+
+
+def test_sympy__functions__special__hyper__HyperRep_power2():
+    from sympy.functions.special.hyper import HyperRep_power2
+    assert _test_args(HyperRep_power2(x, y))
+
+
+def test_sympy__functions__special__hyper__HyperRep_log1():
+    from sympy.functions.special.hyper import HyperRep_log1
+    assert _test_args(HyperRep_log1(x))
+
+
+def test_sympy__functions__special__hyper__HyperRep_atanh():
+    from sympy.functions.special.hyper import HyperRep_atanh
+    assert _test_args(HyperRep_atanh(x))
+
+
+def test_sympy__functions__special__hyper__HyperRep_asin1():
+    from sympy.functions.special.hyper import HyperRep_asin1
+    assert _test_args(HyperRep_asin1(x))
+
+
+def test_sympy__functions__special__hyper__HyperRep_asin2():
+    from sympy.functions.special.hyper import HyperRep_asin2
+    assert _test_args(HyperRep_asin2(x))
+
+
+def test_sympy__functions__special__hyper__HyperRep_sqrts1():
+    from sympy.functions.special.hyper import HyperRep_sqrts1
+    assert _test_args(HyperRep_sqrts1(x, y))
+
+
+def test_sympy__functions__special__hyper__HyperRep_sqrts2():
+    from sympy.functions.special.hyper import HyperRep_sqrts2
+    assert _test_args(HyperRep_sqrts2(x, y))
+
+
+def test_sympy__functions__special__hyper__HyperRep_log2():
+    from sympy.functions.special.hyper import HyperRep_log2
+    assert _test_args(HyperRep_log2(x))
+
+
+def test_sympy__functions__special__hyper__HyperRep_cosasin():
+    from sympy.functions.special.hyper import HyperRep_cosasin
+    assert _test_args(HyperRep_cosasin(x, y))
+
+
+def test_sympy__functions__special__hyper__HyperRep_sinasin():
+    from sympy.functions.special.hyper import HyperRep_sinasin
+    assert _test_args(HyperRep_sinasin(x, y))
+
+def test_sympy__functions__special__hyper__appellf1():
+    from sympy.functions.special.hyper import appellf1
+    a, b1, b2, c, x, y = symbols('a b1 b2 c x y')
+    assert _test_args(appellf1(a, b1, b2, c, x, y))
+
+@SKIP("abstract class")
+def test_sympy__functions__special__polynomials__OrthogonalPolynomial():
+    pass
+
+
+def test_sympy__functions__special__polynomials__jacobi():
+    from sympy.functions.special.polynomials import jacobi
+    assert _test_args(jacobi(x, y, 2, 2))
+
+
+def test_sympy__functions__special__polynomials__gegenbauer():
+    from sympy.functions.special.polynomials import gegenbauer
+    assert _test_args(gegenbauer(x, 2, 2))
+
+
+def test_sympy__functions__special__polynomials__chebyshevt():
+    from sympy.functions.special.polynomials import chebyshevt
+    assert _test_args(chebyshevt(x, 2))
+
+
+def test_sympy__functions__special__polynomials__chebyshevt_root():
+    from sympy.functions.special.polynomials import chebyshevt_root
+    assert _test_args(chebyshevt_root(3, 2))
+
+
+def test_sympy__functions__special__polynomials__chebyshevu():
+    from sympy.functions.special.polynomials import chebyshevu
+    assert _test_args(chebyshevu(x, 2))
+
+
+def test_sympy__functions__special__polynomials__chebyshevu_root():
+    from sympy.functions.special.polynomials import chebyshevu_root
+    assert _test_args(chebyshevu_root(3, 2))
+
+
+def test_sympy__functions__special__polynomials__hermite():
+    from sympy.functions.special.polynomials import hermite
+    assert _test_args(hermite(x, 2))
+
+
+def test_sympy__functions__special__polynomials__hermite_prob():
+    from sympy.functions.special.polynomials import hermite_prob
+    assert _test_args(hermite_prob(x, 2))
+
+
+def test_sympy__functions__special__polynomials__legendre():
+    from sympy.functions.special.polynomials import legendre
+    assert _test_args(legendre(x, 2))
+
+
+def test_sympy__functions__special__polynomials__assoc_legendre():
+    from sympy.functions.special.polynomials import assoc_legendre
+    assert _test_args(assoc_legendre(x, 0, y))
+
+
+def test_sympy__functions__special__polynomials__laguerre():
+    from sympy.functions.special.polynomials import laguerre
+    assert _test_args(laguerre(x, 2))
+
+
+def test_sympy__functions__special__polynomials__assoc_laguerre():
+    from sympy.functions.special.polynomials import assoc_laguerre
+    assert _test_args(assoc_laguerre(x, 0, y))
+
+
+def test_sympy__functions__special__spherical_harmonics__Ynm():
+    from sympy.functions.special.spherical_harmonics import Ynm
+    assert _test_args(Ynm(1, 1, x, y))
+
+
+def test_sympy__functions__special__spherical_harmonics__Znm():
+    from sympy.functions.special.spherical_harmonics import Znm
+    assert _test_args(Znm(x, y, 1, 1))
+
+
+def test_sympy__functions__special__tensor_functions__LeviCivita():
+    from sympy.functions.special.tensor_functions import LeviCivita
+    assert _test_args(LeviCivita(x, y, 2))
+
+
+def test_sympy__functions__special__tensor_functions__KroneckerDelta():
+    from sympy.functions.special.tensor_functions import KroneckerDelta
+    assert _test_args(KroneckerDelta(x, y))
+
+
+def test_sympy__functions__special__zeta_functions__dirichlet_eta():
+    from sympy.functions.special.zeta_functions import dirichlet_eta
+    assert _test_args(dirichlet_eta(x))
+
+
+def test_sympy__functions__special__zeta_functions__riemann_xi():
+    from sympy.functions.special.zeta_functions import riemann_xi
+    assert _test_args(riemann_xi(x))
+
+
+def test_sympy__functions__special__zeta_functions__zeta():
+    from sympy.functions.special.zeta_functions import zeta
+    assert _test_args(zeta(101))
+
+
+def test_sympy__functions__special__zeta_functions__lerchphi():
+    from sympy.functions.special.zeta_functions import lerchphi
+    assert _test_args(lerchphi(x, y, z))
+
+
+def test_sympy__functions__special__zeta_functions__polylog():
+    from sympy.functions.special.zeta_functions import polylog
+    assert _test_args(polylog(x, y))
+
+
+def test_sympy__functions__special__zeta_functions__stieltjes():
+    from sympy.functions.special.zeta_functions import stieltjes
+    assert _test_args(stieltjes(x, y))
+
+
+def test_sympy__integrals__integrals__Integral():
+    from sympy.integrals.integrals import Integral
+    assert _test_args(Integral(2, (x, 0, 1)))
+
+
+def test_sympy__integrals__risch__NonElementaryIntegral():
+    from sympy.integrals.risch import NonElementaryIntegral
+    assert _test_args(NonElementaryIntegral(exp(-x**2), x))
+
+
+@SKIP("abstract class")
+def test_sympy__integrals__transforms__IntegralTransform():
+    pass
+
+
+def test_sympy__integrals__transforms__MellinTransform():
+    from sympy.integrals.transforms import MellinTransform
+    assert _test_args(MellinTransform(2, x, y))
+
+
+def test_sympy__integrals__transforms__InverseMellinTransform():
+    from sympy.integrals.transforms import InverseMellinTransform
+    assert _test_args(InverseMellinTransform(2, x, y, 0, 1))
+
+
+def test_sympy__integrals__laplace__LaplaceTransform():
+    from sympy.integrals.laplace import LaplaceTransform
+    assert _test_args(LaplaceTransform(2, x, y))
+
+
+def test_sympy__integrals__laplace__InverseLaplaceTransform():
+    from sympy.integrals.laplace import InverseLaplaceTransform
+    assert _test_args(InverseLaplaceTransform(2, x, y, 0))
+
+
+@SKIP("abstract class")
+def test_sympy__integrals__transforms__FourierTypeTransform():
+    pass
+
+
+def test_sympy__integrals__transforms__InverseFourierTransform():
+    from sympy.integrals.transforms import InverseFourierTransform
+    assert _test_args(InverseFourierTransform(2, x, y))
+
+
+def test_sympy__integrals__transforms__FourierTransform():
+    from sympy.integrals.transforms import FourierTransform
+    assert _test_args(FourierTransform(2, x, y))
+
+
+@SKIP("abstract class")
+def test_sympy__integrals__transforms__SineCosineTypeTransform():
+    pass
+
+
+def test_sympy__integrals__transforms__InverseSineTransform():
+    from sympy.integrals.transforms import InverseSineTransform
+    assert _test_args(InverseSineTransform(2, x, y))
+
+
+def test_sympy__integrals__transforms__SineTransform():
+    from sympy.integrals.transforms import SineTransform
+    assert _test_args(SineTransform(2, x, y))
+
+
+def test_sympy__integrals__transforms__InverseCosineTransform():
+    from sympy.integrals.transforms import InverseCosineTransform
+    assert _test_args(InverseCosineTransform(2, x, y))
+
+
+def test_sympy__integrals__transforms__CosineTransform():
+    from sympy.integrals.transforms import CosineTransform
+    assert _test_args(CosineTransform(2, x, y))
+
+
+@SKIP("abstract class")
+def test_sympy__integrals__transforms__HankelTypeTransform():
+    pass
+
+
+def test_sympy__integrals__transforms__InverseHankelTransform():
+    from sympy.integrals.transforms import InverseHankelTransform
+    assert _test_args(InverseHankelTransform(2, x, y, 0))
+
+
+def test_sympy__integrals__transforms__HankelTransform():
+    from sympy.integrals.transforms import HankelTransform
+    assert _test_args(HankelTransform(2, x, y, 0))
+
+
+def test_sympy__liealgebras__cartan_type__Standard_Cartan():
+    from sympy.liealgebras.cartan_type import Standard_Cartan
+    assert _test_args(Standard_Cartan("A", 2))
+
+def test_sympy__liealgebras__weyl_group__WeylGroup():
+    from sympy.liealgebras.weyl_group import WeylGroup
+    assert _test_args(WeylGroup("B4"))
+
+def test_sympy__liealgebras__root_system__RootSystem():
+    from sympy.liealgebras.root_system import RootSystem
+    assert _test_args(RootSystem("A2"))
+
+def test_sympy__liealgebras__type_a__TypeA():
+    from sympy.liealgebras.type_a import TypeA
+    assert _test_args(TypeA(2))
+
+def test_sympy__liealgebras__type_b__TypeB():
+    from sympy.liealgebras.type_b import TypeB
+    assert _test_args(TypeB(4))
+
+def test_sympy__liealgebras__type_c__TypeC():
+    from sympy.liealgebras.type_c import TypeC
+    assert _test_args(TypeC(4))
+
+def test_sympy__liealgebras__type_d__TypeD():
+    from sympy.liealgebras.type_d import TypeD
+    assert _test_args(TypeD(4))
+
+def test_sympy__liealgebras__type_e__TypeE():
+    from sympy.liealgebras.type_e import TypeE
+    assert _test_args(TypeE(6))
+
+def test_sympy__liealgebras__type_f__TypeF():
+    from sympy.liealgebras.type_f import TypeF
+    assert _test_args(TypeF(4))
+
+def test_sympy__liealgebras__type_g__TypeG():
+    from sympy.liealgebras.type_g import TypeG
+    assert _test_args(TypeG(2))
+
+
+def test_sympy__logic__boolalg__And():
+    from sympy.logic.boolalg import And
+    assert _test_args(And(x, y, 1))
+
+
+@SKIP("abstract class")
+def test_sympy__logic__boolalg__Boolean():
+    pass
+
+
+def test_sympy__logic__boolalg__BooleanFunction():
+    from sympy.logic.boolalg import BooleanFunction
+    assert _test_args(BooleanFunction(1, 2, 3))
+
+@SKIP("abstract class")
+def test_sympy__logic__boolalg__BooleanAtom():
+    pass
+
+def test_sympy__logic__boolalg__BooleanTrue():
+    from sympy.logic.boolalg import true
+    assert _test_args(true)
+
+def test_sympy__logic__boolalg__BooleanFalse():
+    from sympy.logic.boolalg import false
+    assert _test_args(false)
+
+def test_sympy__logic__boolalg__Equivalent():
+    from sympy.logic.boolalg import Equivalent
+    assert _test_args(Equivalent(x, 2))
+
+
+def test_sympy__logic__boolalg__ITE():
+    from sympy.logic.boolalg import ITE
+    assert _test_args(ITE(x, y, 1))
+
+
+def test_sympy__logic__boolalg__Implies():
+    from sympy.logic.boolalg import Implies
+    assert _test_args(Implies(x, y))
+
+
+def test_sympy__logic__boolalg__Nand():
+    from sympy.logic.boolalg import Nand
+    assert _test_args(Nand(x, y, 1))
+
+
+def test_sympy__logic__boolalg__Nor():
+    from sympy.logic.boolalg import Nor
+    assert _test_args(Nor(x, y))
+
+
+def test_sympy__logic__boolalg__Not():
+    from sympy.logic.boolalg import Not
+    assert _test_args(Not(x))
+
+
+def test_sympy__logic__boolalg__Or():
+    from sympy.logic.boolalg import Or
+    assert _test_args(Or(x, y))
+
+
+def test_sympy__logic__boolalg__Xor():
+    from sympy.logic.boolalg import Xor
+    assert _test_args(Xor(x, y, 2))
+
+def test_sympy__logic__boolalg__Xnor():
+    from sympy.logic.boolalg import Xnor
+    assert _test_args(Xnor(x, y, 2))
+
+def test_sympy__logic__boolalg__Exclusive():
+    from sympy.logic.boolalg import Exclusive
+    assert _test_args(Exclusive(x, y, z))
+
+
+def test_sympy__matrices__matrixbase__DeferredVector():
+    from sympy.matrices.matrixbase import DeferredVector
+    assert _test_args(DeferredVector("X"))
+
+
+@SKIP("abstract class")
+def test_sympy__matrices__expressions__matexpr__MatrixBase():
+    pass
+
+
+@SKIP("abstract class")
+def test_sympy__matrices__immutable__ImmutableRepMatrix():
+    pass
+
+
+def test_sympy__matrices__immutable__ImmutableDenseMatrix():
+    from sympy.matrices.immutable import ImmutableDenseMatrix
+    m = ImmutableDenseMatrix([[1, 2], [3, 4]])
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+    m = ImmutableDenseMatrix(1, 1, [1])
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+    m = ImmutableDenseMatrix(2, 2, lambda i, j: 1)
+    assert m[0, 0] is S.One
+    m = ImmutableDenseMatrix(2, 2, lambda i, j: 1/(1 + i) + 1/(1 + j))
+    assert m[1, 1] is S.One  # true div. will give 1.0 if i,j not sympified
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+
+
+def test_sympy__matrices__immutable__ImmutableSparseMatrix():
+    from sympy.matrices.immutable import ImmutableSparseMatrix
+    m = ImmutableSparseMatrix([[1, 2], [3, 4]])
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+    m = ImmutableSparseMatrix(1, 1, {(0, 0): 1})
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+    m = ImmutableSparseMatrix(1, 1, [1])
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+    m = ImmutableSparseMatrix(2, 2, lambda i, j: 1)
+    assert m[0, 0] is S.One
+    m = ImmutableSparseMatrix(2, 2, lambda i, j: 1/(1 + i) + 1/(1 + j))
+    assert m[1, 1] is S.One  # true div. will give 1.0 if i,j not sympified
+    assert _test_args(m)
+    assert _test_args(Basic(*list(m)))
+
+
+def test_sympy__matrices__expressions__slice__MatrixSlice():
+    from sympy.matrices.expressions.slice import MatrixSlice
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', 4, 4)
+    assert _test_args(MatrixSlice(X, (0, 2), (0, 2)))
+
+
+def test_sympy__matrices__expressions__applyfunc__ElementwiseApplyFunction():
+    from sympy.matrices.expressions.applyfunc import ElementwiseApplyFunction
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol("X", x, x)
+    func = Lambda(x, x**2)
+    assert _test_args(ElementwiseApplyFunction(func, X))
+
+
+def test_sympy__matrices__expressions__blockmatrix__BlockDiagMatrix():
+    from sympy.matrices.expressions.blockmatrix import BlockDiagMatrix
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, x)
+    Y = MatrixSymbol('Y', y, y)
+    assert _test_args(BlockDiagMatrix(X, Y))
+
+
+def test_sympy__matrices__expressions__blockmatrix__BlockMatrix():
+    from sympy.matrices.expressions.blockmatrix import BlockMatrix
+    from sympy.matrices.expressions import MatrixSymbol, ZeroMatrix
+    X = MatrixSymbol('X', x, x)
+    Y = MatrixSymbol('Y', y, y)
+    Z = MatrixSymbol('Z', x, y)
+    O = ZeroMatrix(y, x)
+    assert _test_args(BlockMatrix([[X, Z], [O, Y]]))
+
+
+def test_sympy__matrices__expressions__inverse__Inverse():
+    from sympy.matrices.expressions.inverse import Inverse
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Inverse(MatrixSymbol('A', 3, 3)))
+
+
+def test_sympy__matrices__expressions__matadd__MatAdd():
+    from sympy.matrices.expressions.matadd import MatAdd
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, y)
+    Y = MatrixSymbol('Y', x, y)
+    assert _test_args(MatAdd(X, Y))
+
+
+@SKIP("abstract class")
+def test_sympy__matrices__expressions__matexpr__MatrixExpr():
+    pass
+
+def test_sympy__matrices__expressions__matexpr__MatrixElement():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol, MatrixElement
+    from sympy.core.singleton import S
+    assert _test_args(MatrixElement(MatrixSymbol('A', 3, 5), S(2), S(3)))
+
+def test_sympy__matrices__expressions__matexpr__MatrixSymbol():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    assert _test_args(MatrixSymbol('A', 3, 5))
+
+
+def test_sympy__matrices__expressions__special__OneMatrix():
+    from sympy.matrices.expressions.special import OneMatrix
+    assert _test_args(OneMatrix(3, 5))
+
+
+def test_sympy__matrices__expressions__special__ZeroMatrix():
+    from sympy.matrices.expressions.special import ZeroMatrix
+    assert _test_args(ZeroMatrix(3, 5))
+
+
+def test_sympy__matrices__expressions__special__GenericZeroMatrix():
+    from sympy.matrices.expressions.special import GenericZeroMatrix
+    assert _test_args(GenericZeroMatrix())
+
+
+def test_sympy__matrices__expressions__special__Identity():
+    from sympy.matrices.expressions.special import Identity
+    assert _test_args(Identity(3))
+
+
+def test_sympy__matrices__expressions__special__GenericIdentity():
+    from sympy.matrices.expressions.special import GenericIdentity
+    assert _test_args(GenericIdentity())
+
+
+def test_sympy__matrices__expressions__sets__MatrixSet():
+    from sympy.matrices.expressions.sets import MatrixSet
+    from sympy.core.singleton import S
+    assert _test_args(MatrixSet(2, 2, S.Reals))
+
+def test_sympy__matrices__expressions__matmul__MatMul():
+    from sympy.matrices.expressions.matmul import MatMul
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, y)
+    Y = MatrixSymbol('Y', y, x)
+    assert _test_args(MatMul(X, Y))
+
+
+def test_sympy__matrices__expressions__dotproduct__DotProduct():
+    from sympy.matrices.expressions.dotproduct import DotProduct
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, 1)
+    Y = MatrixSymbol('Y', x, 1)
+    assert _test_args(DotProduct(X, Y))
+
+def test_sympy__matrices__expressions__diagonal__DiagonalMatrix():
+    from sympy.matrices.expressions.diagonal import DiagonalMatrix
+    from sympy.matrices.expressions import MatrixSymbol
+    x = MatrixSymbol('x', 10, 1)
+    assert _test_args(DiagonalMatrix(x))
+
+def test_sympy__matrices__expressions__diagonal__DiagonalOf():
+    from sympy.matrices.expressions.diagonal import DiagonalOf
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('x', 10, 10)
+    assert _test_args(DiagonalOf(X))
+
+def test_sympy__matrices__expressions__diagonal__DiagMatrix():
+    from sympy.matrices.expressions.diagonal import DiagMatrix
+    from sympy.matrices.expressions import MatrixSymbol
+    x = MatrixSymbol('x', 10, 1)
+    assert _test_args(DiagMatrix(x))
+
+def test_sympy__matrices__expressions__hadamard__HadamardProduct():
+    from sympy.matrices.expressions.hadamard import HadamardProduct
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, y)
+    Y = MatrixSymbol('Y', x, y)
+    assert _test_args(HadamardProduct(X, Y))
+
+def test_sympy__matrices__expressions__hadamard__HadamardPower():
+    from sympy.matrices.expressions.hadamard import HadamardPower
+    from sympy.matrices.expressions import MatrixSymbol
+    from sympy.core.symbol import Symbol
+    X = MatrixSymbol('X', x, y)
+    n = Symbol("n")
+    assert _test_args(HadamardPower(X, n))
+
+def test_sympy__matrices__expressions__kronecker__KroneckerProduct():
+    from sympy.matrices.expressions.kronecker import KroneckerProduct
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, y)
+    Y = MatrixSymbol('Y', x, y)
+    assert _test_args(KroneckerProduct(X, Y))
+
+
+def test_sympy__matrices__expressions__matpow__MatPow():
+    from sympy.matrices.expressions.matpow import MatPow
+    from sympy.matrices.expressions import MatrixSymbol
+    X = MatrixSymbol('X', x, x)
+    assert _test_args(MatPow(X, 2))
+
+
+def test_sympy__matrices__expressions__transpose__Transpose():
+    from sympy.matrices.expressions.transpose import Transpose
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Transpose(MatrixSymbol('A', 3, 5)))
+
+
+def test_sympy__matrices__expressions__adjoint__Adjoint():
+    from sympy.matrices.expressions.adjoint import Adjoint
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Adjoint(MatrixSymbol('A', 3, 5)))
+
+
+def test_sympy__matrices__expressions__trace__Trace():
+    from sympy.matrices.expressions.trace import Trace
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Trace(MatrixSymbol('A', 3, 3)))
+
+def test_sympy__matrices__expressions__determinant__Determinant():
+    from sympy.matrices.expressions.determinant import Determinant
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Determinant(MatrixSymbol('A', 3, 3)))
+
+def test_sympy__matrices__expressions__determinant__Permanent():
+    from sympy.matrices.expressions.determinant import Permanent
+    from sympy.matrices.expressions import MatrixSymbol
+    assert _test_args(Permanent(MatrixSymbol('A', 3, 4)))
+
+def test_sympy__matrices__expressions__funcmatrix__FunctionMatrix():
+    from sympy.matrices.expressions.funcmatrix import FunctionMatrix
+    from sympy.core.symbol import symbols
+    i, j = symbols('i,j')
+    assert _test_args(FunctionMatrix(3, 3, Lambda((i, j), i - j) ))
+
+def test_sympy__matrices__expressions__fourier__DFT():
+    from sympy.matrices.expressions.fourier import DFT
+    from sympy.core.singleton import S
+    assert _test_args(DFT(S(2)))
+
+def test_sympy__matrices__expressions__fourier__IDFT():
+    from sympy.matrices.expressions.fourier import IDFT
+    from sympy.core.singleton import S
+    assert _test_args(IDFT(S(2)))
+
+from sympy.matrices.expressions import MatrixSymbol
+X = MatrixSymbol('X', 10, 10)
+
+def test_sympy__matrices__expressions__factorizations__LofLU():
+    from sympy.matrices.expressions.factorizations import LofLU
+    assert _test_args(LofLU(X))
+
+def test_sympy__matrices__expressions__factorizations__UofLU():
+    from sympy.matrices.expressions.factorizations import UofLU
+    assert _test_args(UofLU(X))
+
+def test_sympy__matrices__expressions__factorizations__QofQR():
+    from sympy.matrices.expressions.factorizations import QofQR
+    assert _test_args(QofQR(X))
+
+def test_sympy__matrices__expressions__factorizations__RofQR():
+    from sympy.matrices.expressions.factorizations import RofQR
+    assert _test_args(RofQR(X))
+
+def test_sympy__matrices__expressions__factorizations__LofCholesky():
+    from sympy.matrices.expressions.factorizations import LofCholesky
+    assert _test_args(LofCholesky(X))
+
+def test_sympy__matrices__expressions__factorizations__UofCholesky():
+    from sympy.matrices.expressions.factorizations import UofCholesky
+    assert _test_args(UofCholesky(X))
+
+def test_sympy__matrices__expressions__factorizations__EigenVectors():
+    from sympy.matrices.expressions.factorizations import EigenVectors
+    assert _test_args(EigenVectors(X))
+
+def test_sympy__matrices__expressions__factorizations__EigenValues():
+    from sympy.matrices.expressions.factorizations import EigenValues
+    assert _test_args(EigenValues(X))
+
+def test_sympy__matrices__expressions__factorizations__UofSVD():
+    from sympy.matrices.expressions.factorizations import UofSVD
+    assert _test_args(UofSVD(X))
+
+def test_sympy__matrices__expressions__factorizations__VofSVD():
+    from sympy.matrices.expressions.factorizations import VofSVD
+    assert _test_args(VofSVD(X))
+
+def test_sympy__matrices__expressions__factorizations__SofSVD():
+    from sympy.matrices.expressions.factorizations import SofSVD
+    assert _test_args(SofSVD(X))
+
+@SKIP("abstract class")
+def test_sympy__matrices__expressions__factorizations__Factorization():
+    pass
+
+def test_sympy__matrices__expressions__permutation__PermutationMatrix():
+    from sympy.combinatorics import Permutation
+    from sympy.matrices.expressions.permutation import PermutationMatrix
+    assert _test_args(PermutationMatrix(Permutation([2, 0, 1])))
+
+def test_sympy__matrices__expressions__permutation__MatrixPermute():
+    from sympy.combinatorics import Permutation
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    from sympy.matrices.expressions.permutation import MatrixPermute
+    A = MatrixSymbol('A', 3, 3)
+    assert _test_args(MatrixPermute(A, Permutation([2, 0, 1])))
+
+def test_sympy__matrices__expressions__companion__CompanionMatrix():
+    from sympy.core.symbol import Symbol
+    from sympy.matrices.expressions.companion import CompanionMatrix
+    from sympy.polys.polytools import Poly
+
+    x = Symbol('x')
+    p = Poly([1, 2, 3], x)
+    assert _test_args(CompanionMatrix(p))
+
+def test_sympy__physics__vector__frame__CoordinateSym():
+    from sympy.physics.vector import CoordinateSym
+    from sympy.physics.vector import ReferenceFrame
+    assert _test_args(CoordinateSym('R_x', ReferenceFrame('R'), 0))
+
+
+@SKIP("abstract class")
+def test_sympy__physics__biomechanics__curve__CharacteristicCurveFunction():
+    pass
+
+
+def test_sympy__physics__biomechanics__curve__TendonForceLengthDeGroote2016():
+    from sympy.physics.biomechanics import TendonForceLengthDeGroote2016
+    l_T_tilde, c0, c1, c2, c3 = symbols('l_T_tilde, c0, c1, c2, c3')
+    assert _test_args(TendonForceLengthDeGroote2016(l_T_tilde, c0, c1, c2, c3))
+
+
+def test_sympy__physics__biomechanics__curve__TendonForceLengthInverseDeGroote2016():
+    from sympy.physics.biomechanics import TendonForceLengthInverseDeGroote2016
+    fl_T, c0, c1, c2, c3 = symbols('fl_T, c0, c1, c2, c3')
+    assert _test_args(TendonForceLengthInverseDeGroote2016(fl_T, c0, c1, c2, c3))
+
+
+def test_sympy__physics__biomechanics__curve__FiberForceLengthPassiveDeGroote2016():
+    from sympy.physics.biomechanics import FiberForceLengthPassiveDeGroote2016
+    l_M_tilde, c0, c1 = symbols('l_M_tilde, c0, c1')
+    assert _test_args(FiberForceLengthPassiveDeGroote2016(l_M_tilde, c0, c1))
+
+
+def test_sympy__physics__biomechanics__curve__FiberForceLengthPassiveInverseDeGroote2016():
+    from sympy.physics.biomechanics import FiberForceLengthPassiveInverseDeGroote2016
+    fl_M_pas, c0, c1 = symbols('fl_M_pas, c0, c1')
+    assert _test_args(FiberForceLengthPassiveInverseDeGroote2016(fl_M_pas, c0, c1))
+
+
+def test_sympy__physics__biomechanics__curve__FiberForceLengthActiveDeGroote2016():
+    from sympy.physics.biomechanics import FiberForceLengthActiveDeGroote2016
+    l_M_tilde, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11 = symbols('l_M_tilde, c0:12')
+    assert _test_args(FiberForceLengthActiveDeGroote2016(l_M_tilde, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11))
+
+
+def test_sympy__physics__biomechanics__curve__FiberForceVelocityDeGroote2016():
+    from sympy.physics.biomechanics import FiberForceVelocityDeGroote2016
+    v_M_tilde, c0, c1, c2, c3 = symbols('v_M_tilde, c0, c1, c2, c3')
+    assert _test_args(FiberForceVelocityDeGroote2016(v_M_tilde, c0, c1, c2, c3))
+
+
+def test_sympy__physics__biomechanics__curve__FiberForceVelocityInverseDeGroote2016():
+    from sympy.physics.biomechanics import FiberForceVelocityInverseDeGroote2016
+    fv_M, c0, c1, c2, c3 = symbols('fv_M, c0, c1, c2, c3')
+    assert _test_args(FiberForceVelocityInverseDeGroote2016(fv_M, c0, c1, c2, c3))
+
+
+def test_sympy__physics__paulialgebra__Pauli():
+    from sympy.physics.paulialgebra import Pauli
+    assert _test_args(Pauli(1))
+
+
+def test_sympy__physics__quantum__anticommutator__AntiCommutator():
+    from sympy.physics.quantum.anticommutator import AntiCommutator
+    assert _test_args(AntiCommutator(x, y))
+
+
+def test_sympy__physics__quantum__cartesian__PositionBra3D():
+    from sympy.physics.quantum.cartesian import PositionBra3D
+    assert _test_args(PositionBra3D(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__PositionKet3D():
+    from sympy.physics.quantum.cartesian import PositionKet3D
+    assert _test_args(PositionKet3D(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__PositionState3D():
+    from sympy.physics.quantum.cartesian import PositionState3D
+    assert _test_args(PositionState3D(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__PxBra():
+    from sympy.physics.quantum.cartesian import PxBra
+    assert _test_args(PxBra(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__PxKet():
+    from sympy.physics.quantum.cartesian import PxKet
+    assert _test_args(PxKet(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__PxOp():
+    from sympy.physics.quantum.cartesian import PxOp
+    assert _test_args(PxOp(x, y, z))
+
+
+def test_sympy__physics__quantum__cartesian__XBra():
+    from sympy.physics.quantum.cartesian import XBra
+    assert _test_args(XBra(x))
+
+
+def test_sympy__physics__quantum__cartesian__XKet():
+    from sympy.physics.quantum.cartesian import XKet
+    assert _test_args(XKet(x))
+
+
+def test_sympy__physics__quantum__cartesian__XOp():
+    from sympy.physics.quantum.cartesian import XOp
+    assert _test_args(XOp(x))
+
+
+def test_sympy__physics__quantum__cartesian__YOp():
+    from sympy.physics.quantum.cartesian import YOp
+    assert _test_args(YOp(x))
+
+
+def test_sympy__physics__quantum__cartesian__ZOp():
+    from sympy.physics.quantum.cartesian import ZOp
+    assert _test_args(ZOp(x))
+
+
+def test_sympy__physics__quantum__cg__CG():
+    from sympy.physics.quantum.cg import CG
+    from sympy.core.singleton import S
+    assert _test_args(CG(Rational(3, 2), Rational(3, 2), S.Half, Rational(-1, 2), 1, 1))
+
+
+def test_sympy__physics__quantum__cg__Wigner3j():
+    from sympy.physics.quantum.cg import Wigner3j
+    assert _test_args(Wigner3j(6, 0, 4, 0, 2, 0))
+
+
+def test_sympy__physics__quantum__cg__Wigner6j():
+    from sympy.physics.quantum.cg import Wigner6j
+    assert _test_args(Wigner6j(1, 2, 3, 2, 1, 2))
+
+
+def test_sympy__physics__quantum__cg__Wigner9j():
+    from sympy.physics.quantum.cg import Wigner9j
+    assert _test_args(Wigner9j(2, 1, 1, Rational(3, 2), S.Half, 1, S.Half, S.Half, 0))
+
+def test_sympy__physics__quantum__circuitplot__Mz():
+    from sympy.physics.quantum.circuitplot import Mz
+    assert _test_args(Mz(0))
+
+def test_sympy__physics__quantum__circuitplot__Mx():
+    from sympy.physics.quantum.circuitplot import Mx
+    assert _test_args(Mx(0))
+
+def test_sympy__physics__quantum__commutator__Commutator():
+    from sympy.physics.quantum.commutator import Commutator
+    A, B = symbols('A,B', commutative=False)
+    assert _test_args(Commutator(A, B))
+
+
+def test_sympy__physics__quantum__constants__HBar():
+    from sympy.physics.quantum.constants import HBar
+    assert _test_args(HBar())
+
+
+def test_sympy__physics__quantum__dagger__Dagger():
+    from sympy.physics.quantum.dagger import Dagger
+    from sympy.physics.quantum.state import Ket
+    assert _test_args(Dagger(Dagger(Ket('psi'))))
+
+
+def test_sympy__physics__quantum__gate__CGate():
+    from sympy.physics.quantum.gate import CGate, Gate
+    assert _test_args(CGate((0, 1), Gate(2)))
+
+
+def test_sympy__physics__quantum__gate__CGateS():
+    from sympy.physics.quantum.gate import CGateS, Gate
+    assert _test_args(CGateS((0, 1), Gate(2)))
+
+
+def test_sympy__physics__quantum__gate__CNotGate():
+    from sympy.physics.quantum.gate import CNotGate
+    assert _test_args(CNotGate(0, 1))
+
+
+def test_sympy__physics__quantum__gate__Gate():
+    from sympy.physics.quantum.gate import Gate
+    assert _test_args(Gate(0))
+
+
+def test_sympy__physics__quantum__gate__HadamardGate():
+    from sympy.physics.quantum.gate import HadamardGate
+    assert _test_args(HadamardGate(0))
+
+
+def test_sympy__physics__quantum__gate__IdentityGate():
+    from sympy.physics.quantum.gate import IdentityGate
+    assert _test_args(IdentityGate(0))
+
+
+def test_sympy__physics__quantum__gate__OneQubitGate():
+    from sympy.physics.quantum.gate import OneQubitGate
+    assert _test_args(OneQubitGate(0))
+
+
+def test_sympy__physics__quantum__gate__PhaseGate():
+    from sympy.physics.quantum.gate import PhaseGate
+    assert _test_args(PhaseGate(0))
+
+
+def test_sympy__physics__quantum__gate__SwapGate():
+    from sympy.physics.quantum.gate import SwapGate
+    assert _test_args(SwapGate(0, 1))
+
+
+def test_sympy__physics__quantum__gate__TGate():
+    from sympy.physics.quantum.gate import TGate
+    assert _test_args(TGate(0))
+
+
+def test_sympy__physics__quantum__gate__TwoQubitGate():
+    from sympy.physics.quantum.gate import TwoQubitGate
+    assert _test_args(TwoQubitGate(0))
+
+
+def test_sympy__physics__quantum__gate__UGate():
+    from sympy.physics.quantum.gate import UGate
+    from sympy.matrices.immutable import ImmutableDenseMatrix
+    from sympy.core.containers import Tuple
+    from sympy.core.numbers import Integer
+    assert _test_args(
+        UGate(Tuple(Integer(1)), ImmutableDenseMatrix([[1, 0], [0, 2]])))
+
+
+def test_sympy__physics__quantum__gate__XGate():
+    from sympy.physics.quantum.gate import XGate
+    assert _test_args(XGate(0))
+
+
+def test_sympy__physics__quantum__gate__YGate():
+    from sympy.physics.quantum.gate import YGate
+    assert _test_args(YGate(0))
+
+
+def test_sympy__physics__quantum__gate__ZGate():
+    from sympy.physics.quantum.gate import ZGate
+    assert _test_args(ZGate(0))
+
+
+def test_sympy__physics__quantum__grover__OracleGateFunction():
+    from sympy.physics.quantum.grover import OracleGateFunction
+    @OracleGateFunction
+    def f(qubit):
+        return
+    assert _test_args(f)
+
+def test_sympy__physics__quantum__grover__OracleGate():
+    from sympy.physics.quantum.grover import OracleGate
+    def f(qubit):
+        return
+    assert _test_args(OracleGate(1,f))
+
+
+def test_sympy__physics__quantum__grover__WGate():
+    from sympy.physics.quantum.grover import WGate
+    assert _test_args(WGate(1))
+
+
+def test_sympy__physics__quantum__hilbert__ComplexSpace():
+    from sympy.physics.quantum.hilbert import ComplexSpace
+    assert _test_args(ComplexSpace(x))
+
+
+def test_sympy__physics__quantum__hilbert__DirectSumHilbertSpace():
+    from sympy.physics.quantum.hilbert import DirectSumHilbertSpace, ComplexSpace, FockSpace
+    c = ComplexSpace(2)
+    f = FockSpace()
+    assert _test_args(DirectSumHilbertSpace(c, f))
+
+
+def test_sympy__physics__quantum__hilbert__FockSpace():
+    from sympy.physics.quantum.hilbert import FockSpace
+    assert _test_args(FockSpace())
+
+
+def test_sympy__physics__quantum__hilbert__HilbertSpace():
+    from sympy.physics.quantum.hilbert import HilbertSpace
+    assert _test_args(HilbertSpace())
+
+
+def test_sympy__physics__quantum__hilbert__L2():
+    from sympy.physics.quantum.hilbert import L2
+    from sympy.core.numbers import oo
+    from sympy.sets.sets import Interval
+    assert _test_args(L2(Interval(0, oo)))
+
+
+def test_sympy__physics__quantum__hilbert__TensorPowerHilbertSpace():
+    from sympy.physics.quantum.hilbert import TensorPowerHilbertSpace, FockSpace
+    f = FockSpace()
+    assert _test_args(TensorPowerHilbertSpace(f, 2))
+
+
+def test_sympy__physics__quantum__hilbert__TensorProductHilbertSpace():
+    from sympy.physics.quantum.hilbert import TensorProductHilbertSpace, FockSpace, ComplexSpace
+    c = ComplexSpace(2)
+    f = FockSpace()
+    assert _test_args(TensorProductHilbertSpace(f, c))
+
+
+def test_sympy__physics__quantum__innerproduct__InnerProduct():
+    from sympy.physics.quantum import Bra, Ket, InnerProduct
+    b = Bra('b')
+    k = Ket('k')
+    assert _test_args(InnerProduct(b, k))
+
+
+def test_sympy__physics__quantum__operator__DifferentialOperator():
+    from sympy.physics.quantum.operator import DifferentialOperator
+    from sympy.core.function import (Derivative, Function)
+    f = Function('f')
+    assert _test_args(DifferentialOperator(1/x*Derivative(f(x), x), f(x)))
+
+
+def test_sympy__physics__quantum__operator__HermitianOperator():
+    from sympy.physics.quantum.operator import HermitianOperator
+    assert _test_args(HermitianOperator('H'))
+
+
+def test_sympy__physics__quantum__operator__IdentityOperator():
+    with warns_deprecated_sympy():
+        from sympy.physics.quantum.operator import IdentityOperator
+        assert _test_args(IdentityOperator(5))
+
+
+def test_sympy__physics__quantum__operator__Operator():
+    from sympy.physics.quantum.operator import Operator
+    assert _test_args(Operator('A'))
+
+
+def test_sympy__physics__quantum__operator__OuterProduct():
+    from sympy.physics.quantum.operator import OuterProduct
+    from sympy.physics.quantum import Ket, Bra
+    b = Bra('b')
+    k = Ket('k')
+    assert _test_args(OuterProduct(k, b))
+
+
+def test_sympy__physics__quantum__operator__UnitaryOperator():
+    from sympy.physics.quantum.operator import UnitaryOperator
+    assert _test_args(UnitaryOperator('U'))
+
+
+def test_sympy__physics__quantum__piab__PIABBra():
+    from sympy.physics.quantum.piab import PIABBra
+    assert _test_args(PIABBra('B'))
+
+
+def test_sympy__physics__quantum__boson__BosonOp():
+    from sympy.physics.quantum.boson import BosonOp
+    assert _test_args(BosonOp('a'))
+    assert _test_args(BosonOp('a', False))
+
+
+def test_sympy__physics__quantum__boson__BosonFockKet():
+    from sympy.physics.quantum.boson import BosonFockKet
+    assert _test_args(BosonFockKet(1))
+
+
+def test_sympy__physics__quantum__boson__BosonFockBra():
+    from sympy.physics.quantum.boson import BosonFockBra
+    assert _test_args(BosonFockBra(1))
+
+
+def test_sympy__physics__quantum__boson__BosonCoherentKet():
+    from sympy.physics.quantum.boson import BosonCoherentKet
+    assert _test_args(BosonCoherentKet(1))
+
+
+def test_sympy__physics__quantum__boson__BosonCoherentBra():
+    from sympy.physics.quantum.boson import BosonCoherentBra
+    assert _test_args(BosonCoherentBra(1))
+
+
+def test_sympy__physics__quantum__fermion__FermionOp():
+    from sympy.physics.quantum.fermion import FermionOp
+    assert _test_args(FermionOp('c'))
+    assert _test_args(FermionOp('c', False))
+
+
+def test_sympy__physics__quantum__fermion__FermionFockKet():
+    from sympy.physics.quantum.fermion import FermionFockKet
+    assert _test_args(FermionFockKet(1))
+
+
+def test_sympy__physics__quantum__fermion__FermionFockBra():
+    from sympy.physics.quantum.fermion import FermionFockBra
+    assert _test_args(FermionFockBra(1))
+
+
+def test_sympy__physics__quantum__pauli__SigmaOpBase():
+    from sympy.physics.quantum.pauli import SigmaOpBase
+    assert _test_args(SigmaOpBase())
+
+
+def test_sympy__physics__quantum__pauli__SigmaX():
+    from sympy.physics.quantum.pauli import SigmaX
+    assert _test_args(SigmaX())
+
+
+def test_sympy__physics__quantum__pauli__SigmaY():
+    from sympy.physics.quantum.pauli import SigmaY
+    assert _test_args(SigmaY())
+
+
+def test_sympy__physics__quantum__pauli__SigmaZ():
+    from sympy.physics.quantum.pauli import SigmaZ
+    assert _test_args(SigmaZ())
+
+
+def test_sympy__physics__quantum__pauli__SigmaMinus():
+    from sympy.physics.quantum.pauli import SigmaMinus
+    assert _test_args(SigmaMinus())
+
+
+def test_sympy__physics__quantum__pauli__SigmaPlus():
+    from sympy.physics.quantum.pauli import SigmaPlus
+    assert _test_args(SigmaPlus())
+
+
+def test_sympy__physics__quantum__pauli__SigmaZKet():
+    from sympy.physics.quantum.pauli import SigmaZKet
+    assert _test_args(SigmaZKet(0))
+
+
+def test_sympy__physics__quantum__pauli__SigmaZBra():
+    from sympy.physics.quantum.pauli import SigmaZBra
+    assert _test_args(SigmaZBra(0))
+
+
+def test_sympy__physics__quantum__piab__PIABHamiltonian():
+    from sympy.physics.quantum.piab import PIABHamiltonian
+    assert _test_args(PIABHamiltonian('P'))
+
+
+def test_sympy__physics__quantum__piab__PIABKet():
+    from sympy.physics.quantum.piab import PIABKet
+    assert _test_args(PIABKet('K'))
+
+
+def test_sympy__physics__quantum__qexpr__QExpr():
+    from sympy.physics.quantum.qexpr import QExpr
+    assert _test_args(QExpr(0))
+
+
+def test_sympy__physics__quantum__qft__Fourier():
+    from sympy.physics.quantum.qft import Fourier
+    assert _test_args(Fourier(0, 1))
+
+
+def test_sympy__physics__quantum__qft__IQFT():
+    from sympy.physics.quantum.qft import IQFT
+    assert _test_args(IQFT(0, 1))
+
+
+def test_sympy__physics__quantum__qft__QFT():
+    from sympy.physics.quantum.qft import QFT
+    assert _test_args(QFT(0, 1))
+
+
+def test_sympy__physics__quantum__qft__RkGate():
+    from sympy.physics.quantum.qft import RkGate
+    assert _test_args(RkGate(0, 1))
+
+
+def test_sympy__physics__quantum__qubit__IntQubit():
+    from sympy.physics.quantum.qubit import IntQubit
+    assert _test_args(IntQubit(0))
+
+
+def test_sympy__physics__quantum__qubit__IntQubitBra():
+    from sympy.physics.quantum.qubit import IntQubitBra
+    assert _test_args(IntQubitBra(0))
+
+
+def test_sympy__physics__quantum__qubit__IntQubitState():
+    from sympy.physics.quantum.qubit import IntQubitState, QubitState
+    assert _test_args(IntQubitState(QubitState(0, 1)))
+
+
+def test_sympy__physics__quantum__qubit__Qubit():
+    from sympy.physics.quantum.qubit import Qubit
+    assert _test_args(Qubit(0, 0, 0))
+
+
+def test_sympy__physics__quantum__qubit__QubitBra():
+    from sympy.physics.quantum.qubit import QubitBra
+    assert _test_args(QubitBra('1', 0))
+
+
+def test_sympy__physics__quantum__qubit__QubitState():
+    from sympy.physics.quantum.qubit import QubitState
+    assert _test_args(QubitState(0, 1))
+
+
+def test_sympy__physics__quantum__density__Density():
+    from sympy.physics.quantum.density import Density
+    from sympy.physics.quantum.state import Ket
+    assert _test_args(Density([Ket(0), 0.5], [Ket(1), 0.5]))
+
+
+@SKIP("TODO: sympy.physics.quantum.shor: Cmod Not Implemented")
+def test_sympy__physics__quantum__shor__CMod():
+    from sympy.physics.quantum.shor import CMod
+    assert _test_args(CMod())
+
+
+def test_sympy__physics__quantum__spin__CoupledSpinState():
+    from sympy.physics.quantum.spin import CoupledSpinState
+    assert _test_args(CoupledSpinState(1, 0, (1, 1)))
+    assert _test_args(CoupledSpinState(1, 0, (1, S.Half, S.Half)))
+    assert _test_args(CoupledSpinState(
+        1, 0, (1, S.Half, S.Half), ((2, 3, S.Half), (1, 2, 1)) ))
+    j, m, j1, j2, j3, j12, x = symbols('j m j1:4 j12 x')
+    assert CoupledSpinState(
+        j, m, (j1, j2, j3)).subs(j2, x) == CoupledSpinState(j, m, (j1, x, j3))
+    assert CoupledSpinState(j, m, (j1, j2, j3), ((1, 3, j12), (1, 2, j)) ).subs(j12, x) == \
+        CoupledSpinState(j, m, (j1, j2, j3), ((1, 3, x), (1, 2, j)) )
+
+
+def test_sympy__physics__quantum__spin__J2Op():
+    from sympy.physics.quantum.spin import J2Op
+    assert _test_args(J2Op('J'))
+
+
+def test_sympy__physics__quantum__spin__JminusOp():
+    from sympy.physics.quantum.spin import JminusOp
+    assert _test_args(JminusOp('J'))
+
+
+def test_sympy__physics__quantum__spin__JplusOp():
+    from sympy.physics.quantum.spin import JplusOp
+    assert _test_args(JplusOp('J'))
+
+
+def test_sympy__physics__quantum__spin__JxBra():
+    from sympy.physics.quantum.spin import JxBra
+    assert _test_args(JxBra(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JxBraCoupled():
+    from sympy.physics.quantum.spin import JxBraCoupled
+    assert _test_args(JxBraCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JxKet():
+    from sympy.physics.quantum.spin import JxKet
+    assert _test_args(JxKet(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JxKetCoupled():
+    from sympy.physics.quantum.spin import JxKetCoupled
+    assert _test_args(JxKetCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JxOp():
+    from sympy.physics.quantum.spin import JxOp
+    assert _test_args(JxOp('J'))
+
+
+def test_sympy__physics__quantum__spin__JyBra():
+    from sympy.physics.quantum.spin import JyBra
+    assert _test_args(JyBra(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JyBraCoupled():
+    from sympy.physics.quantum.spin import JyBraCoupled
+    assert _test_args(JyBraCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JyKet():
+    from sympy.physics.quantum.spin import JyKet
+    assert _test_args(JyKet(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JyKetCoupled():
+    from sympy.physics.quantum.spin import JyKetCoupled
+    assert _test_args(JyKetCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JyOp():
+    from sympy.physics.quantum.spin import JyOp
+    assert _test_args(JyOp('J'))
+
+
+def test_sympy__physics__quantum__spin__JzBra():
+    from sympy.physics.quantum.spin import JzBra
+    assert _test_args(JzBra(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JzBraCoupled():
+    from sympy.physics.quantum.spin import JzBraCoupled
+    assert _test_args(JzBraCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JzKet():
+    from sympy.physics.quantum.spin import JzKet
+    assert _test_args(JzKet(1, 0))
+
+
+def test_sympy__physics__quantum__spin__JzKetCoupled():
+    from sympy.physics.quantum.spin import JzKetCoupled
+    assert _test_args(JzKetCoupled(1, 0, (1, 1)))
+
+
+def test_sympy__physics__quantum__spin__JzOp():
+    from sympy.physics.quantum.spin import JzOp
+    assert _test_args(JzOp('J'))
+
+
+def test_sympy__physics__quantum__spin__Rotation():
+    from sympy.physics.quantum.spin import Rotation
+    assert _test_args(Rotation(pi, 0, pi/2))
+
+
+def test_sympy__physics__quantum__spin__SpinState():
+    from sympy.physics.quantum.spin import SpinState
+    assert _test_args(SpinState(1, 0))
+
+
+def test_sympy__physics__quantum__spin__WignerD():
+    from sympy.physics.quantum.spin import WignerD
+    assert _test_args(WignerD(0, 1, 2, 3, 4, 5))
+
+
+def test_sympy__physics__quantum__state__Bra():
+    from sympy.physics.quantum.state import Bra
+    assert _test_args(Bra(0))
+
+
+def test_sympy__physics__quantum__state__BraBase():
+    from sympy.physics.quantum.state import BraBase
+    assert _test_args(BraBase(0))
+
+
+def test_sympy__physics__quantum__state__Ket():
+    from sympy.physics.quantum.state import Ket
+    assert _test_args(Ket(0))
+
+
+def test_sympy__physics__quantum__state__KetBase():
+    from sympy.physics.quantum.state import KetBase
+    assert _test_args(KetBase(0))
+
+
+def test_sympy__physics__quantum__state__State():
+    from sympy.physics.quantum.state import State
+    assert _test_args(State(0))
+
+
+def test_sympy__physics__quantum__state__StateBase():
+    from sympy.physics.quantum.state import StateBase
+    assert _test_args(StateBase(0))
+
+
+def test_sympy__physics__quantum__state__OrthogonalBra():
+    from sympy.physics.quantum.state import OrthogonalBra
+    assert _test_args(OrthogonalBra(0))
+
+
+def test_sympy__physics__quantum__state__OrthogonalKet():
+    from sympy.physics.quantum.state import OrthogonalKet
+    assert _test_args(OrthogonalKet(0))
+
+
+def test_sympy__physics__quantum__state__OrthogonalState():
+    from sympy.physics.quantum.state import OrthogonalState
+    assert _test_args(OrthogonalState(0))
+
+
+def test_sympy__physics__quantum__state__TimeDepBra():
+    from sympy.physics.quantum.state import TimeDepBra
+    assert _test_args(TimeDepBra('psi', 't'))
+
+
+def test_sympy__physics__quantum__state__TimeDepKet():
+    from sympy.physics.quantum.state import TimeDepKet
+    assert _test_args(TimeDepKet('psi', 't'))
+
+
+def test_sympy__physics__quantum__state__TimeDepState():
+    from sympy.physics.quantum.state import TimeDepState
+    assert _test_args(TimeDepState('psi', 't'))
+
+
+def test_sympy__physics__quantum__state__Wavefunction():
+    from sympy.physics.quantum.state import Wavefunction
+    from sympy.functions import sin
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = 1
+    L = 1
+    g = Piecewise((0, x < 0), (0, x > L), (sqrt(2//L)*sin(n*pi*x/L), True))
+    assert _test_args(Wavefunction(g, x))
+
+
+def test_sympy__physics__quantum__tensorproduct__TensorProduct():
+    from sympy.physics.quantum.tensorproduct import TensorProduct
+    x, y = symbols("x y", commutative=False)
+    assert _test_args(TensorProduct(x, y))
+
+
+def test_sympy__physics__quantum__identitysearch__GateIdentity():
+    from sympy.physics.quantum.gate import X
+    from sympy.physics.quantum.identitysearch import GateIdentity
+    assert _test_args(GateIdentity(X(0), X(0)))
+
+
+def test_sympy__physics__quantum__sho1d__SHOOp():
+    from sympy.physics.quantum.sho1d import SHOOp
+    assert _test_args(SHOOp('a'))
+
+
+def test_sympy__physics__quantum__sho1d__RaisingOp():
+    from sympy.physics.quantum.sho1d import RaisingOp
+    assert _test_args(RaisingOp('a'))
+
+
+def test_sympy__physics__quantum__sho1d__LoweringOp():
+    from sympy.physics.quantum.sho1d import LoweringOp
+    assert _test_args(LoweringOp('a'))
+
+
+def test_sympy__physics__quantum__sho1d__NumberOp():
+    from sympy.physics.quantum.sho1d import NumberOp
+    assert _test_args(NumberOp('N'))
+
+
+def test_sympy__physics__quantum__sho1d__Hamiltonian():
+    from sympy.physics.quantum.sho1d import Hamiltonian
+    assert _test_args(Hamiltonian('H'))
+
+
+def test_sympy__physics__quantum__sho1d__SHOState():
+    from sympy.physics.quantum.sho1d import SHOState
+    assert _test_args(SHOState(0))
+
+
+def test_sympy__physics__quantum__sho1d__SHOKet():
+    from sympy.physics.quantum.sho1d import SHOKet
+    assert _test_args(SHOKet(0))
+
+
+def test_sympy__physics__quantum__sho1d__SHOBra():
+    from sympy.physics.quantum.sho1d import SHOBra
+    assert _test_args(SHOBra(0))
+
+
+def test_sympy__physics__secondquant__AnnihilateBoson():
+    from sympy.physics.secondquant import AnnihilateBoson
+    assert _test_args(AnnihilateBoson(0))
+
+
+def test_sympy__physics__secondquant__AnnihilateFermion():
+    from sympy.physics.secondquant import AnnihilateFermion
+    assert _test_args(AnnihilateFermion(0))
+
+
+@SKIP("abstract class")
+def test_sympy__physics__secondquant__Annihilator():
+    pass
+
+
+def test_sympy__physics__secondquant__AntiSymmetricTensor():
+    from sympy.physics.secondquant import AntiSymmetricTensor
+    i, j = symbols('i j', below_fermi=True)
+    a, b = symbols('a b', above_fermi=True)
+    assert _test_args(AntiSymmetricTensor('v', (a, i), (b, j)))
+
+
+def test_sympy__physics__secondquant__BosonState():
+    from sympy.physics.secondquant import BosonState
+    assert _test_args(BosonState((0, 1)))
+
+
+@SKIP("abstract class")
+def test_sympy__physics__secondquant__BosonicOperator():
+    pass
+
+
+def test_sympy__physics__secondquant__Commutator():
+    from sympy.physics.secondquant import Commutator
+    x, y = symbols('x y', commutative=False)
+    assert _test_args(Commutator(x, y))
+
+
+def test_sympy__physics__secondquant__CreateBoson():
+    from sympy.physics.secondquant import CreateBoson
+    assert _test_args(CreateBoson(0))
+
+
+def test_sympy__physics__secondquant__CreateFermion():
+    from sympy.physics.secondquant import CreateFermion
+    assert _test_args(CreateFermion(0))
+
+
+@SKIP("abstract class")
+def test_sympy__physics__secondquant__Creator():
+    pass
+
+
+def test_sympy__physics__secondquant__Dagger():
+    from sympy.physics.secondquant import Dagger
+    assert _test_args(Dagger(x))
+
+
+def test_sympy__physics__secondquant__FermionState():
+    from sympy.physics.secondquant import FermionState
+    assert _test_args(FermionState((0, 1)))
+
+
+def test_sympy__physics__secondquant__FermionicOperator():
+    from sympy.physics.secondquant import FermionicOperator
+    assert _test_args(FermionicOperator(0))
+
+
+def test_sympy__physics__secondquant__FockState():
+    from sympy.physics.secondquant import FockState
+    assert _test_args(FockState((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateBosonBra():
+    from sympy.physics.secondquant import FockStateBosonBra
+    assert _test_args(FockStateBosonBra((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateBosonKet():
+    from sympy.physics.secondquant import FockStateBosonKet
+    assert _test_args(FockStateBosonKet((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateBra():
+    from sympy.physics.secondquant import FockStateBra
+    assert _test_args(FockStateBra((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateFermionBra():
+    from sympy.physics.secondquant import FockStateFermionBra
+    assert _test_args(FockStateFermionBra((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateFermionKet():
+    from sympy.physics.secondquant import FockStateFermionKet
+    assert _test_args(FockStateFermionKet((0, 1)))
+
+
+def test_sympy__physics__secondquant__FockStateKet():
+    from sympy.physics.secondquant import FockStateKet
+    assert _test_args(FockStateKet((0, 1)))
+
+
+def test_sympy__physics__secondquant__InnerProduct():
+    from sympy.physics.secondquant import InnerProduct
+    from sympy.physics.secondquant import FockStateKet, FockStateBra
+    assert _test_args(InnerProduct(FockStateBra((0, 1)), FockStateKet((0, 1))))
+
+
+def test_sympy__physics__secondquant__NO():
+    from sympy.physics.secondquant import NO, F, Fd
+    assert _test_args(NO(Fd(x)*F(y)))
+
+
+def test_sympy__physics__secondquant__PermutationOperator():
+    from sympy.physics.secondquant import PermutationOperator
+    assert _test_args(PermutationOperator(0, 1))
+
+
+def test_sympy__physics__secondquant__SqOperator():
+    from sympy.physics.secondquant import SqOperator
+    assert _test_args(SqOperator(0))
+
+
+def test_sympy__physics__secondquant__TensorSymbol():
+    from sympy.physics.secondquant import TensorSymbol
+    assert _test_args(TensorSymbol(x))
+
+
+def test_sympy__physics__control__lti__LinearTimeInvariant():
+    # Direct instances of LinearTimeInvariant class are not allowed.
+    # func(*args) tests for its derived classes (TransferFunction,
+    # Series, Parallel and TransferFunctionMatrix) should pass.
+    pass
+
+
+def test_sympy__physics__control__lti__SISOLinearTimeInvariant():
+    # Direct instances of SISOLinearTimeInvariant class are not allowed.
+    pass
+
+
+def test_sympy__physics__control__lti__MIMOLinearTimeInvariant():
+    # Direct instances of MIMOLinearTimeInvariant class are not allowed.
+    pass
+
+
+def test_sympy__physics__control__lti__TransferFunction():
+    from sympy.physics.control.lti import TransferFunction
+    assert _test_args(TransferFunction(2, 3, x))
+
+
+def _test_args_PIDController(obj):
+    from sympy.physics.control.lti import PIDController
+    if isinstance(obj, PIDController):
+        kp, ki, kd, tf = obj.kp, obj.ki, obj.kd, obj.tf
+        recreated_pid = PIDController(kp, ki, kd, tf, s)
+        return recreated_pid == obj
+    return False
+
+
+def test_sympy__physics__control__lti__PIDController():
+    from sympy.physics.control.lti import PIDController
+    kp, ki, kd, tf = 1, 0.1, 0.01, 0
+    assert _test_args_PIDController(PIDController(kp, ki, kd, tf, s))
+
+
+def test_sympy__physics__control__lti__Series():
+    from sympy.physics.control import Series, TransferFunction
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    assert _test_args(Series(tf1, tf2))
+
+
+def test_sympy__physics__control__lti__MIMOSeries():
+    from sympy.physics.control import MIMOSeries, TransferFunction, TransferFunctionMatrix
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    tfm_1 = TransferFunctionMatrix([[tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_3 = TransferFunctionMatrix([[tf1], [tf2]])
+    assert _test_args(MIMOSeries(tfm_3, tfm_2, tfm_1))
+
+
+def test_sympy__physics__control__lti__Parallel():
+    from sympy.physics.control import Parallel, TransferFunction
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    assert _test_args(Parallel(tf1, tf2))
+
+
+def test_sympy__physics__control__lti__MIMOParallel():
+    from sympy.physics.control import MIMOParallel, TransferFunction, TransferFunctionMatrix
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    tfm_1 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    tfm_2 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    assert _test_args(MIMOParallel(tfm_1, tfm_2))
+
+
+def test_sympy__physics__control__lti__Feedback():
+    from sympy.physics.control import TransferFunction, Feedback
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    assert _test_args(Feedback(tf1, tf2))
+    assert _test_args(Feedback(tf1, tf2, 1))
+
+
+def test_sympy__physics__control__lti__MIMOFeedback():
+    from sympy.physics.control import TransferFunction, MIMOFeedback, TransferFunctionMatrix
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    tfm_1 = TransferFunctionMatrix([[tf2, tf1], [tf1, tf2]])
+    tfm_2 = TransferFunctionMatrix([[tf1, tf2], [tf2, tf1]])
+    assert _test_args(MIMOFeedback(tfm_1, tfm_2))
+    assert _test_args(MIMOFeedback(tfm_1, tfm_2, 1))
+
+
+def test_sympy__physics__control__lti__TransferFunctionMatrix():
+    from sympy.physics.control import TransferFunction, TransferFunctionMatrix
+    tf1 = TransferFunction(x**2 - y**3, y - z, x)
+    tf2 = TransferFunction(y - x, z + y, x)
+    assert _test_args(TransferFunctionMatrix([[tf1, tf2]]))
+
+
+def test_sympy__physics__control__lti__StateSpace():
+    from sympy.matrices.dense import Matrix
+    from sympy.physics.control import StateSpace
+    A = Matrix([[-5, -1], [3, -1]])
+    B = Matrix([2, 5])
+    C = Matrix([[1, 2]])
+    D = Matrix([0])
+    assert _test_args(StateSpace(A, B, C, D))
+
+
+def test_sympy__physics__units__dimensions__Dimension():
+    from sympy.physics.units.dimensions import Dimension
+    assert _test_args(Dimension("length", "L"))
+
+
+def test_sympy__physics__units__dimensions__DimensionSystem():
+    from sympy.physics.units.dimensions import DimensionSystem
+    from sympy.physics.units.definitions.dimension_definitions import length, time, velocity
+    assert _test_args(DimensionSystem((length, time), (velocity,)))
+
+
+def test_sympy__physics__units__quantities__Quantity():
+    from sympy.physics.units.quantities import Quantity
+    assert _test_args(Quantity("dam"))
+
+
+def test_sympy__physics__units__quantities__PhysicalConstant():
+    from sympy.physics.units.quantities import PhysicalConstant
+    assert _test_args(PhysicalConstant("foo"))
+
+
+def test_sympy__physics__units__prefixes__Prefix():
+    from sympy.physics.units.prefixes import Prefix
+    assert _test_args(Prefix('kilo', 'k', 3))
+
+
+def test_sympy__core__numbers__AlgebraicNumber():
+    from sympy.core.numbers import AlgebraicNumber
+    assert _test_args(AlgebraicNumber(sqrt(2), [1, 2, 3]))
+
+
+def test_sympy__polys__polytools__GroebnerBasis():
+    from sympy.polys.polytools import GroebnerBasis
+    assert _test_args(GroebnerBasis([x, y, z], x, y, z))
+
+
+def test_sympy__polys__polytools__Poly():
+    from sympy.polys.polytools import Poly
+    assert _test_args(Poly(2, x, y))
+
+
+def test_sympy__polys__polytools__PurePoly():
+    from sympy.polys.polytools import PurePoly
+    assert _test_args(PurePoly(2, x, y))
+
+
+@SKIP('abstract class')
+def test_sympy__polys__rootoftools__RootOf():
+    pass
+
+
+def test_sympy__polys__rootoftools__ComplexRootOf():
+    from sympy.polys.rootoftools import ComplexRootOf
+    assert _test_args(ComplexRootOf(x**3 + x + 1, 0))
+
+
+def test_sympy__polys__rootoftools__RootSum():
+    from sympy.polys.rootoftools import RootSum
+    assert _test_args(RootSum(x**3 + x + 1, sin))
+
+
+def test_sympy__series__limits__Limit():
+    from sympy.series.limits import Limit
+    assert _test_args(Limit(x, x, 0, dir='-'))
+
+
+def test_sympy__series__order__Order():
+    from sympy.series.order import Order
+    assert _test_args(Order(1, x, y))
+
+
+@SKIP('Abstract Class')
+def test_sympy__series__sequences__SeqBase():
+    pass
+
+
+def test_sympy__series__sequences__EmptySequence():
+    # Need to import the instance from series not the class from
+    # series.sequence
+    from sympy.series import EmptySequence
+    assert _test_args(EmptySequence)
+
+
+@SKIP('Abstract Class')
+def test_sympy__series__sequences__SeqExpr():
+    pass
+
+
+def test_sympy__series__sequences__SeqPer():
+    from sympy.series.sequences import SeqPer
+    assert _test_args(SeqPer((1, 2, 3), (0, 10)))
+
+
+def test_sympy__series__sequences__SeqFormula():
+    from sympy.series.sequences import SeqFormula
+    assert _test_args(SeqFormula(x**2, (0, 10)))
+
+
+def test_sympy__series__sequences__RecursiveSeq():
+    from sympy.series.sequences import RecursiveSeq
+    y = Function("y")
+    n = symbols("n")
+    assert _test_args(RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, (0, 1)))
+    assert _test_args(RecursiveSeq(y(n - 1) + y(n - 2), y(n), n))
+
+
+def test_sympy__series__sequences__SeqExprOp():
+    from sympy.series.sequences import SeqExprOp, sequence
+    s1 = sequence((1, 2, 3))
+    s2 = sequence(x**2)
+    assert _test_args(SeqExprOp(s1, s2))
+
+
+def test_sympy__series__sequences__SeqAdd():
+    from sympy.series.sequences import SeqAdd, sequence
+    s1 = sequence((1, 2, 3))
+    s2 = sequence(x**2)
+    assert _test_args(SeqAdd(s1, s2))
+
+
+def test_sympy__series__sequences__SeqMul():
+    from sympy.series.sequences import SeqMul, sequence
+    s1 = sequence((1, 2, 3))
+    s2 = sequence(x**2)
+    assert _test_args(SeqMul(s1, s2))
+
+
+@SKIP('Abstract Class')
+def test_sympy__series__series_class__SeriesBase():
+    pass
+
+
+def test_sympy__series__fourier__FourierSeries():
+    from sympy.series.fourier import fourier_series
+    assert _test_args(fourier_series(x, (x, -pi, pi)))
+
+def test_sympy__series__fourier__FiniteFourierSeries():
+    from sympy.series.fourier import fourier_series
+    assert _test_args(fourier_series(sin(pi*x), (x, -1, 1)))
+
+
+def test_sympy__series__formal__FormalPowerSeries():
+    from sympy.series.formal import fps
+    assert _test_args(fps(log(1 + x), x))
+
+
+def test_sympy__series__formal__Coeff():
+    from sympy.series.formal import fps
+    assert _test_args(fps(x**2 + x + 1, x))
+
+
+@SKIP('Abstract Class')
+def test_sympy__series__formal__FiniteFormalPowerSeries():
+    pass
+
+
+def test_sympy__series__formal__FormalPowerSeriesProduct():
+    from sympy.series.formal import fps
+    f1, f2 = fps(sin(x)), fps(exp(x))
+    assert _test_args(f1.product(f2, x))
+
+
+def test_sympy__series__formal__FormalPowerSeriesCompose():
+    from sympy.series.formal import fps
+    f1, f2 = fps(exp(x)), fps(sin(x))
+    assert _test_args(f1.compose(f2, x))
+
+
+def test_sympy__series__formal__FormalPowerSeriesInverse():
+    from sympy.series.formal import fps
+    f1 = fps(exp(x))
+    assert _test_args(f1.inverse(x))
+
+
+def test_sympy__simplify__hyperexpand__Hyper_Function():
+    from sympy.simplify.hyperexpand import Hyper_Function
+    assert _test_args(Hyper_Function([2], [1]))
+
+
+def test_sympy__simplify__hyperexpand__G_Function():
+    from sympy.simplify.hyperexpand import G_Function
+    assert _test_args(G_Function([2], [1], [], []))
+
+
+@SKIP("abstract class")
+def test_sympy__tensor__array__ndim_array__ImmutableNDimArray():
+    pass
+
+
+def test_sympy__tensor__array__dense_ndim_array__ImmutableDenseNDimArray():
+    from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+    densarr = ImmutableDenseNDimArray(range(10, 34), (2, 3, 4))
+    assert _test_args(densarr)
+
+
+def test_sympy__tensor__array__sparse_ndim_array__ImmutableSparseNDimArray():
+    from sympy.tensor.array.sparse_ndim_array import ImmutableSparseNDimArray
+    sparr = ImmutableSparseNDimArray(range(10, 34), (2, 3, 4))
+    assert _test_args(sparr)
+
+
+def test_sympy__tensor__array__array_comprehension__ArrayComprehension():
+    from sympy.tensor.array.array_comprehension import ArrayComprehension
+    arrcom = ArrayComprehension(x, (x, 1, 5))
+    assert _test_args(arrcom)
+
+def test_sympy__tensor__array__array_comprehension__ArrayComprehensionMap():
+    from sympy.tensor.array.array_comprehension import ArrayComprehensionMap
+    arrcomma = ArrayComprehensionMap(lambda: 0, (x, 1, 5))
+    assert _test_args(arrcomma)
+
+
+def test_sympy__tensor__array__array_derivatives__ArrayDerivative():
+    from sympy.tensor.array.array_derivatives import ArrayDerivative
+    A = MatrixSymbol("A", 2, 2)
+    arrder = ArrayDerivative(A, A, evaluate=False)
+    assert _test_args(arrder)
+
+def test_sympy__tensor__array__expressions__array_expressions__ArraySymbol():
+    from sympy.tensor.array.expressions.array_expressions import ArraySymbol
+    m, n, k = symbols("m n k")
+    array = ArraySymbol("A", (m, n, k, 2))
+    assert _test_args(array)
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayElement():
+    from sympy.tensor.array.expressions.array_expressions import ArrayElement
+    m, n, k = symbols("m n k")
+    ae = ArrayElement("A", (m, n, k, 2))
+    assert _test_args(ae)
+
+def test_sympy__tensor__array__expressions__array_expressions__ZeroArray():
+    from sympy.tensor.array.expressions.array_expressions import ZeroArray
+    m, n, k = symbols("m n k")
+    za = ZeroArray(m, n, k, 2)
+    assert _test_args(za)
+
+def test_sympy__tensor__array__expressions__array_expressions__OneArray():
+    from sympy.tensor.array.expressions.array_expressions import OneArray
+    m, n, k = symbols("m n k")
+    za = OneArray(m, n, k, 2)
+    assert _test_args(za)
+
+def test_sympy__tensor__functions__TensorProduct():
+    from sympy.tensor.functions import TensorProduct
+    A = MatrixSymbol('A', 3, 3)
+    B = MatrixSymbol('B', 3, 3)
+    tp = TensorProduct(A, B)
+    assert _test_args(tp)
+
+
+def test_sympy__tensor__indexed__Idx():
+    from sympy.tensor.indexed import Idx
+    assert _test_args(Idx('test'))
+    assert _test_args(Idx('test', (0, 10)))
+    assert _test_args(Idx('test', 2))
+    assert _test_args(Idx('test', x))
+
+
+def test_sympy__tensor__indexed__Indexed():
+    from sympy.tensor.indexed import Indexed, Idx
+    assert _test_args(Indexed('A', Idx('i'), Idx('j')))
+
+
+def test_sympy__tensor__indexed__IndexedBase():
+    from sympy.tensor.indexed import IndexedBase
+    assert _test_args(IndexedBase('A', shape=(x, y)))
+    assert _test_args(IndexedBase('A', 1))
+    assert _test_args(IndexedBase('A')[0, 1])
+
+
+def test_sympy__tensor__tensor__TensorIndexType():
+    from sympy.tensor.tensor import TensorIndexType
+    assert _test_args(TensorIndexType('Lorentz'))
+
+
+@SKIP("deprecated class")
+def test_sympy__tensor__tensor__TensorType():
+    pass
+
+
+def test_sympy__tensor__tensor__TensorSymmetry():
+    from sympy.tensor.tensor import TensorSymmetry, get_symmetric_group_sgs
+    assert _test_args(TensorSymmetry(get_symmetric_group_sgs(2)))
+
+
+def test_sympy__tensor__tensor__TensorHead():
+    from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, TensorHead
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    sym = TensorSymmetry(get_symmetric_group_sgs(1))
+    assert _test_args(TensorHead('p', [Lorentz], sym, 0))
+
+
+def test_sympy__tensor__tensor__TensorIndex():
+    from sympy.tensor.tensor import TensorIndexType, TensorIndex
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    assert _test_args(TensorIndex('i', Lorentz))
+
+@SKIP("abstract class")
+def test_sympy__tensor__tensor__TensExpr():
+    pass
+
+def test_sympy__tensor__tensor__TensAdd():
+    from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, tensor_indices, TensAdd, tensor_heads
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b = tensor_indices('a,b', Lorentz)
+    sym = TensorSymmetry(get_symmetric_group_sgs(1))
+    p, q = tensor_heads('p,q', [Lorentz], sym)
+    t1 = p(a)
+    t2 = q(a)
+    assert _test_args(TensAdd(t1, t2))
+
+
+def test_sympy__tensor__tensor__Tensor():
+    from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, tensor_indices, TensorHead
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b = tensor_indices('a,b', Lorentz)
+    sym = TensorSymmetry(get_symmetric_group_sgs(1))
+    p = TensorHead('p', [Lorentz], sym)
+    assert _test_args(p(a))
+
+
+def test_sympy__tensor__tensor__TensMul():
+    from sympy.tensor.tensor import TensorIndexType, TensorSymmetry, get_symmetric_group_sgs, tensor_indices, tensor_heads
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b = tensor_indices('a,b', Lorentz)
+    sym = TensorSymmetry(get_symmetric_group_sgs(1))
+    p, q = tensor_heads('p, q', [Lorentz], sym)
+    assert _test_args(3*p(a)*q(b))
+
+
+def test_sympy__tensor__tensor__TensorElement():
+    from sympy.tensor.tensor import TensorIndexType, TensorHead, TensorElement
+    L = TensorIndexType("L")
+    A = TensorHead("A", [L, L])
+    telem = TensorElement(A(x, y), {x: 1})
+    assert _test_args(telem)
+
+def test_sympy__tensor__tensor__WildTensor():
+    from sympy.tensor.tensor import TensorIndexType, WildTensorHead, TensorIndex
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a = TensorIndex('a', Lorentz)
+    p = WildTensorHead('p')
+    assert _test_args(p(a))
+
+def test_sympy__tensor__tensor__WildTensorHead():
+    from sympy.tensor.tensor import WildTensorHead
+    assert _test_args(WildTensorHead('p'))
+
+def test_sympy__tensor__tensor__WildTensorIndex():
+    from sympy.tensor.tensor import TensorIndexType, WildTensorIndex
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    assert _test_args(WildTensorIndex('i', Lorentz))
+
+def test_sympy__tensor__toperators__PartialDerivative():
+    from sympy.tensor.tensor import TensorIndexType, tensor_indices, TensorHead
+    from sympy.tensor.toperators import PartialDerivative
+    Lorentz = TensorIndexType('Lorentz', dummy_name='L')
+    a, b = tensor_indices('a,b', Lorentz)
+    A = TensorHead("A", [Lorentz])
+    assert _test_args(PartialDerivative(A(a), A(b)))
+
+
+def test_as_coeff_add():
+    assert (7, (3*x, 4*x**2)) == (7 + 3*x + 4*x**2).as_coeff_add()
+
+
+def test_sympy__geometry__curve__Curve():
+    from sympy.geometry.curve import Curve
+    assert _test_args(Curve((x, 1), (x, 0, 1)))
+
+
+def test_sympy__geometry__point__Point():
+    from sympy.geometry.point import Point
+    assert _test_args(Point(0, 1))
+
+
+def test_sympy__geometry__point__Point2D():
+    from sympy.geometry.point import Point2D
+    assert _test_args(Point2D(0, 1))
+
+
+def test_sympy__geometry__point__Point3D():
+    from sympy.geometry.point import Point3D
+    assert _test_args(Point3D(0, 1, 2))
+
+
+def test_sympy__geometry__ellipse__Ellipse():
+    from sympy.geometry.ellipse import Ellipse
+    assert _test_args(Ellipse((0, 1), 2, 3))
+
+
+def test_sympy__geometry__ellipse__Circle():
+    from sympy.geometry.ellipse import Circle
+    assert _test_args(Circle((0, 1), 2))
+
+
+def test_sympy__geometry__parabola__Parabola():
+    from sympy.geometry.parabola import Parabola
+    from sympy.geometry.line import Line
+    assert _test_args(Parabola((0, 0), Line((2, 3), (4, 3))))
+
+
+@SKIP("abstract class")
+def test_sympy__geometry__line__LinearEntity():
+    pass
+
+
+def test_sympy__geometry__line__Line():
+    from sympy.geometry.line import Line
+    assert _test_args(Line((0, 1), (2, 3)))
+
+
+def test_sympy__geometry__line__Ray():
+    from sympy.geometry.line import Ray
+    assert _test_args(Ray((0, 1), (2, 3)))
+
+
+def test_sympy__geometry__line__Segment():
+    from sympy.geometry.line import Segment
+    assert _test_args(Segment((0, 1), (2, 3)))
+
+@SKIP("abstract class")
+def test_sympy__geometry__line__LinearEntity2D():
+    pass
+
+
+def test_sympy__geometry__line__Line2D():
+    from sympy.geometry.line import Line2D
+    assert _test_args(Line2D((0, 1), (2, 3)))
+
+
+def test_sympy__geometry__line__Ray2D():
+    from sympy.geometry.line import Ray2D
+    assert _test_args(Ray2D((0, 1), (2, 3)))
+
+
+def test_sympy__geometry__line__Segment2D():
+    from sympy.geometry.line import Segment2D
+    assert _test_args(Segment2D((0, 1), (2, 3)))
+
+
+@SKIP("abstract class")
+def test_sympy__geometry__line__LinearEntity3D():
+    pass
+
+
+def test_sympy__geometry__line__Line3D():
+    from sympy.geometry.line import Line3D
+    assert _test_args(Line3D((0, 1, 1), (2, 3, 4)))
+
+
+def test_sympy__geometry__line__Segment3D():
+    from sympy.geometry.line import Segment3D
+    assert _test_args(Segment3D((0, 1, 1), (2, 3, 4)))
+
+
+def test_sympy__geometry__line__Ray3D():
+    from sympy.geometry.line import Ray3D
+    assert _test_args(Ray3D((0, 1, 1), (2, 3, 4)))
+
+
+def test_sympy__geometry__plane__Plane():
+    from sympy.geometry.plane import Plane
+    assert _test_args(Plane((1, 1, 1), (-3, 4, -2), (1, 2, 3)))
+
+
+def test_sympy__geometry__polygon__Polygon():
+    from sympy.geometry.polygon import Polygon
+    assert _test_args(Polygon((0, 1), (2, 3), (4, 5), (6, 7)))
+
+
+def test_sympy__geometry__polygon__RegularPolygon():
+    from sympy.geometry.polygon import RegularPolygon
+    assert _test_args(RegularPolygon((0, 1), 2, 3, 4))
+
+
+def test_sympy__geometry__polygon__Triangle():
+    from sympy.geometry.polygon import Triangle
+    assert _test_args(Triangle((0, 1), (2, 3), (4, 5)))
+
+
+def test_sympy__geometry__entity__GeometryEntity():
+    from sympy.geometry.entity import GeometryEntity
+    from sympy.geometry.point import Point
+    assert _test_args(GeometryEntity(Point(1, 0), 1, [1, 2]))
+
+@SKIP("abstract class")
+def test_sympy__geometry__entity__GeometrySet():
+    pass
+
+def test_sympy__diffgeom__diffgeom__Manifold():
+    from sympy.diffgeom import Manifold
+    assert _test_args(Manifold('name', 3))
+
+
+def test_sympy__diffgeom__diffgeom__Patch():
+    from sympy.diffgeom import Manifold, Patch
+    assert _test_args(Patch('name', Manifold('name', 3)))
+
+
+def test_sympy__diffgeom__diffgeom__CoordSystem():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem
+    assert _test_args(CoordSystem('name', Patch('name', Manifold('name', 3))))
+    assert _test_args(CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c]))
+
+
+def test_sympy__diffgeom__diffgeom__CoordinateSymbol():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, CoordinateSymbol
+    assert _test_args(CoordinateSymbol(CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c]), 0))
+
+
+def test_sympy__diffgeom__diffgeom__Point():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, Point
+    assert _test_args(Point(
+        CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c]), [x, y]))
+
+
+def test_sympy__diffgeom__diffgeom__BaseScalarField():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    assert _test_args(BaseScalarField(cs, 0))
+
+
+def test_sympy__diffgeom__diffgeom__BaseVectorField():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseVectorField
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    assert _test_args(BaseVectorField(cs, 0))
+
+
+def test_sympy__diffgeom__diffgeom__Differential():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField, Differential
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    assert _test_args(Differential(BaseScalarField(cs, 0)))
+
+
+def test_sympy__diffgeom__diffgeom__Commutator():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseVectorField, Commutator
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    cs1 = CoordSystem('name1', Patch('name', Manifold('name', 3)), [a, b, c])
+    v = BaseVectorField(cs, 0)
+    v1 = BaseVectorField(cs1, 0)
+    assert _test_args(Commutator(v, v1))
+
+
+def test_sympy__diffgeom__diffgeom__TensorProduct():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField, Differential, TensorProduct
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    d = Differential(BaseScalarField(cs, 0))
+    assert _test_args(TensorProduct(d, d))
+
+
+def test_sympy__diffgeom__diffgeom__WedgeProduct():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField, Differential, WedgeProduct
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    d = Differential(BaseScalarField(cs, 0))
+    d1 = Differential(BaseScalarField(cs, 1))
+    assert _test_args(WedgeProduct(d, d1))
+
+
+def test_sympy__diffgeom__diffgeom__LieDerivative():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseScalarField, Differential, BaseVectorField, LieDerivative
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    d = Differential(BaseScalarField(cs, 0))
+    v = BaseVectorField(cs, 0)
+    assert _test_args(LieDerivative(v, d))
+
+
+def test_sympy__diffgeom__diffgeom__BaseCovarDerivativeOp():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseCovarDerivativeOp
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    assert _test_args(BaseCovarDerivativeOp(cs, 0, [[[0, ]*3, ]*3, ]*3))
+
+
+def test_sympy__diffgeom__diffgeom__CovarDerivativeOp():
+    from sympy.diffgeom import Manifold, Patch, CoordSystem, BaseVectorField, CovarDerivativeOp
+    cs = CoordSystem('name', Patch('name', Manifold('name', 3)), [a, b, c])
+    v = BaseVectorField(cs, 0)
+    _test_args(CovarDerivativeOp(v, [[[0, ]*3, ]*3, ]*3))
+
+
+def test_sympy__categories__baseclasses__Class():
+    from sympy.categories.baseclasses import Class
+    assert _test_args(Class())
+
+
+def test_sympy__categories__baseclasses__Object():
+    from sympy.categories import Object
+    assert _test_args(Object("A"))
+
+
+@SKIP("abstract class")
+def test_sympy__categories__baseclasses__Morphism():
+    pass
+
+
+def test_sympy__categories__baseclasses__IdentityMorphism():
+    from sympy.categories import Object, IdentityMorphism
+    assert _test_args(IdentityMorphism(Object("A")))
+
+
+def test_sympy__categories__baseclasses__NamedMorphism():
+    from sympy.categories import Object, NamedMorphism
+    assert _test_args(NamedMorphism(Object("A"), Object("B"), "f"))
+
+
+def test_sympy__categories__baseclasses__CompositeMorphism():
+    from sympy.categories import Object, NamedMorphism, CompositeMorphism
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    assert _test_args(CompositeMorphism(f, g))
+
+
+def test_sympy__categories__baseclasses__Diagram():
+    from sympy.categories import Object, NamedMorphism, Diagram
+    A = Object("A")
+    B = Object("B")
+    f = NamedMorphism(A, B, "f")
+    d = Diagram([f])
+    assert _test_args(d)
+
+
+def test_sympy__categories__baseclasses__Category():
+    from sympy.categories import Object, NamedMorphism, Diagram, Category
+    A = Object("A")
+    B = Object("B")
+    C = Object("C")
+    f = NamedMorphism(A, B, "f")
+    g = NamedMorphism(B, C, "g")
+    d1 = Diagram([f, g])
+    d2 = Diagram([f])
+    K = Category("K", commutative_diagrams=[d1, d2])
+    assert _test_args(K)
+
+
+def test_sympy__physics__optics__waves__TWave():
+    from sympy.physics.optics import TWave
+    A, f, phi = symbols('A, f, phi')
+    assert _test_args(TWave(A, f, phi))
+
+
+def test_sympy__physics__optics__gaussopt__BeamParameter():
+    from sympy.physics.optics import BeamParameter
+    assert _test_args(BeamParameter(530e-9, 1, w=1e-3, n=1))
+
+
+def test_sympy__physics__optics__medium__Medium():
+    from sympy.physics.optics import Medium
+    assert _test_args(Medium('m'))
+
+
+def test_sympy__physics__optics__medium__MediumN():
+    from sympy.physics.optics.medium import Medium
+    assert _test_args(Medium('m', n=2))
+
+
+def test_sympy__physics__optics__medium__MediumPP():
+    from sympy.physics.optics.medium import Medium
+    assert _test_args(Medium('m', permittivity=2, permeability=2))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayContraction():
+    from sympy.tensor.array.expressions.array_expressions import ArrayContraction
+    from sympy.tensor.indexed import IndexedBase
+    A = symbols("A", cls=IndexedBase)
+    assert _test_args(ArrayContraction(A, (0, 1)))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayDiagonal():
+    from sympy.tensor.array.expressions.array_expressions import ArrayDiagonal
+    from sympy.tensor.indexed import IndexedBase
+    A = symbols("A", cls=IndexedBase)
+    assert _test_args(ArrayDiagonal(A, (0, 1)))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayTensorProduct():
+    from sympy.tensor.array.expressions.array_expressions import ArrayTensorProduct
+    from sympy.tensor.indexed import IndexedBase
+    A, B = symbols("A B", cls=IndexedBase)
+    assert _test_args(ArrayTensorProduct(A, B))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayAdd():
+    from sympy.tensor.array.expressions.array_expressions import ArrayAdd
+    from sympy.tensor.indexed import IndexedBase
+    A, B = symbols("A B", cls=IndexedBase)
+    assert _test_args(ArrayAdd(A, B))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__PermuteDims():
+    from sympy.tensor.array.expressions.array_expressions import PermuteDims
+    A = MatrixSymbol("A", 4, 4)
+    assert _test_args(PermuteDims(A, (1, 0)))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__ArrayElementwiseApplyFunc():
+    from sympy.tensor.array.expressions.array_expressions import ArraySymbol, ArrayElementwiseApplyFunc
+    A = ArraySymbol("A", (4,))
+    assert _test_args(ArrayElementwiseApplyFunc(exp, A))
+
+
+def test_sympy__tensor__array__expressions__array_expressions__Reshape():
+    from sympy.tensor.array.expressions.array_expressions import ArraySymbol, Reshape
+    A = ArraySymbol("A", (4,))
+    assert _test_args(Reshape(A, (2, 2)))
+
+
+def test_sympy__codegen__ast__Assignment():
+    from sympy.codegen.ast import Assignment
+    assert _test_args(Assignment(x, y))
+
+
+def test_sympy__codegen__cfunctions__expm1():
+    from sympy.codegen.cfunctions import expm1
+    assert _test_args(expm1(x))
+
+
+def test_sympy__codegen__cfunctions__log1p():
+    from sympy.codegen.cfunctions import log1p
+    assert _test_args(log1p(x))
+
+
+def test_sympy__codegen__cfunctions__exp2():
+    from sympy.codegen.cfunctions import exp2
+    assert _test_args(exp2(x))
+
+
+def test_sympy__codegen__cfunctions__log2():
+    from sympy.codegen.cfunctions import log2
+    assert _test_args(log2(x))
+
+
+def test_sympy__codegen__cfunctions__fma():
+    from sympy.codegen.cfunctions import fma
+    assert _test_args(fma(x, y, z))
+
+
+def test_sympy__codegen__cfunctions__log10():
+    from sympy.codegen.cfunctions import log10
+    assert _test_args(log10(x))
+
+
+def test_sympy__codegen__cfunctions__Sqrt():
+    from sympy.codegen.cfunctions import Sqrt
+    assert _test_args(Sqrt(x))
+
+def test_sympy__codegen__cfunctions__Cbrt():
+    from sympy.codegen.cfunctions import Cbrt
+    assert _test_args(Cbrt(x))
+
+def test_sympy__codegen__cfunctions__hypot():
+    from sympy.codegen.cfunctions import hypot
+    assert _test_args(hypot(x, y))
+
+
+def test_sympy__codegen__cfunctions__isnan():
+    from sympy.codegen.cfunctions import isnan
+    assert _test_args(isnan(x))
+
+
+def test_sympy__codegen__cfunctions__isinf():
+    from sympy.codegen.cfunctions import isinf
+    assert _test_args(isinf(x))
+
+
+def test_sympy__codegen__fnodes__FFunction():
+    from sympy.codegen.fnodes import FFunction
+    assert _test_args(FFunction('f'))
+
+
+def test_sympy__codegen__fnodes__F95Function():
+    from sympy.codegen.fnodes import F95Function
+    assert _test_args(F95Function('f'))
+
+
+def test_sympy__codegen__fnodes__isign():
+    from sympy.codegen.fnodes import isign
+    assert _test_args(isign(1, x))
+
+
+def test_sympy__codegen__fnodes__dsign():
+    from sympy.codegen.fnodes import dsign
+    assert _test_args(dsign(1, x))
+
+
+def test_sympy__codegen__fnodes__cmplx():
+    from sympy.codegen.fnodes import cmplx
+    assert _test_args(cmplx(x, y))
+
+
+def test_sympy__codegen__fnodes__kind():
+    from sympy.codegen.fnodes import kind
+    assert _test_args(kind(x))
+
+
+def test_sympy__codegen__fnodes__merge():
+    from sympy.codegen.fnodes import merge
+    assert _test_args(merge(1, 2, Eq(x, 0)))
+
+
+def test_sympy__codegen__fnodes___literal():
+    from sympy.codegen.fnodes import _literal
+    assert _test_args(_literal(1))
+
+
+def test_sympy__codegen__fnodes__literal_sp():
+    from sympy.codegen.fnodes import literal_sp
+    assert _test_args(literal_sp(1))
+
+
+def test_sympy__codegen__fnodes__literal_dp():
+    from sympy.codegen.fnodes import literal_dp
+    assert _test_args(literal_dp(1))
+
+
+def test_sympy__codegen__matrix_nodes__MatrixSolve():
+    from sympy.matrices import MatrixSymbol
+    from sympy.codegen.matrix_nodes import MatrixSolve
+    A = MatrixSymbol('A', 3, 3)
+    v = MatrixSymbol('x', 3, 1)
+    assert _test_args(MatrixSolve(A, v))
+
+
+def test_sympy__printing__rust__TypeCast():
+    from sympy.printing.rust import TypeCast
+    from sympy.codegen.ast import real
+    assert _test_args(TypeCast(x, real))
+
+
+def test_sympy__printing__rust__float_floor():
+    from sympy.printing.rust import float_floor
+    assert _test_args(float_floor(x))
+
+
+def test_sympy__printing__rust__float_ceiling():
+    from sympy.printing.rust import float_ceiling
+    assert _test_args(float_ceiling(x))
+
+
+def test_sympy__vector__coordsysrect__CoordSys3D():
+    from sympy.vector.coordsysrect import CoordSys3D
+    assert _test_args(CoordSys3D('C'))
+
+
+def test_sympy__vector__point__Point():
+    from sympy.vector.point import Point
+    assert _test_args(Point('P'))
+
+
+def test_sympy__vector__basisdependent__BasisDependent():
+    #from sympy.vector.basisdependent import BasisDependent
+    #These classes have been created to maintain an OOP hierarchy
+    #for Vectors and Dyadics. Are NOT meant to be initialized
+    pass
+
+
+def test_sympy__vector__basisdependent__BasisDependentMul():
+    #from sympy.vector.basisdependent import BasisDependentMul
+    #These classes have been created to maintain an OOP hierarchy
+    #for Vectors and Dyadics. Are NOT meant to be initialized
+    pass
+
+
+def test_sympy__vector__basisdependent__BasisDependentAdd():
+    #from sympy.vector.basisdependent import BasisDependentAdd
+    #These classes have been created to maintain an OOP hierarchy
+    #for Vectors and Dyadics. Are NOT meant to be initialized
+    pass
+
+
+def test_sympy__vector__basisdependent__BasisDependentZero():
+    #from sympy.vector.basisdependent import BasisDependentZero
+    #These classes have been created to maintain an OOP hierarchy
+    #for Vectors and Dyadics. Are NOT meant to be initialized
+    pass
+
+
+def test_sympy__vector__vector__BaseVector():
+    from sympy.vector.vector import BaseVector
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(BaseVector(0, C, ' ', ' '))
+
+
+def test_sympy__vector__vector__VectorAdd():
+    from sympy.vector.vector import VectorAdd, VectorMul
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    from sympy.abc import a, b, c, x, y, z
+    v1 = a*C.i + b*C.j + c*C.k
+    v2 = x*C.i + y*C.j + z*C.k
+    assert _test_args(VectorAdd(v1, v2))
+    assert _test_args(VectorMul(x, v1))
+
+
+def test_sympy__vector__vector__VectorMul():
+    from sympy.vector.vector import VectorMul
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    from sympy.abc import a
+    assert _test_args(VectorMul(a, C.i))
+
+
+def test_sympy__vector__vector__VectorZero():
+    from sympy.vector.vector import VectorZero
+    assert _test_args(VectorZero())
+
+
+def test_sympy__vector__vector__Vector():
+    #from sympy.vector.vector import Vector
+    #Vector is never to be initialized using args
+    pass
+
+
+def test_sympy__vector__vector__Cross():
+    from sympy.vector.vector import Cross
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    _test_args(Cross(C.i, C.j))
+
+
+def test_sympy__vector__vector__Dot():
+    from sympy.vector.vector import Dot
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    _test_args(Dot(C.i, C.j))
+
+
+def test_sympy__vector__dyadic__Dyadic():
+    #from sympy.vector.dyadic import Dyadic
+    #Dyadic is never to be initialized using args
+    pass
+
+
+def test_sympy__vector__dyadic__BaseDyadic():
+    from sympy.vector.dyadic import BaseDyadic
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(BaseDyadic(C.i, C.j))
+
+
+def test_sympy__vector__dyadic__DyadicMul():
+    from sympy.vector.dyadic import BaseDyadic, DyadicMul
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(DyadicMul(3, BaseDyadic(C.i, C.j)))
+
+
+def test_sympy__vector__dyadic__DyadicAdd():
+    from sympy.vector.dyadic import BaseDyadic, DyadicAdd
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(2 * DyadicAdd(BaseDyadic(C.i, C.i),
+                                    BaseDyadic(C.i, C.j)))
+
+
+def test_sympy__vector__dyadic__DyadicZero():
+    from sympy.vector.dyadic import DyadicZero
+    assert _test_args(DyadicZero())
+
+
+def test_sympy__vector__deloperator__Del():
+    from sympy.vector.deloperator import Del
+    assert _test_args(Del())
+
+
+def test_sympy__vector__implicitregion__ImplicitRegion():
+    from sympy.vector.implicitregion import ImplicitRegion
+    from sympy.abc import x, y
+    assert _test_args(ImplicitRegion((x, y), y**3 - 4*x))
+
+
+def test_sympy__vector__integrals__ParametricIntegral():
+    from sympy.vector.integrals import ParametricIntegral
+    from sympy.vector.parametricregion import ParametricRegion
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(ParametricIntegral(C.y*C.i - 10*C.j,\
+                    ParametricRegion((x, y), (x, 1, 3), (y, -2, 2))))
+
+def test_sympy__vector__operators__Curl():
+    from sympy.vector.operators import Curl
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(Curl(C.i))
+
+
+def test_sympy__vector__operators__Laplacian():
+    from sympy.vector.operators import Laplacian
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(Laplacian(C.i))
+
+
+def test_sympy__vector__operators__Divergence():
+    from sympy.vector.operators import Divergence
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(Divergence(C.i))
+
+
+def test_sympy__vector__operators__Gradient():
+    from sympy.vector.operators import Gradient
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(Gradient(C.x))
+
+
+def test_sympy__vector__orienters__Orienter():
+    #from sympy.vector.orienters import Orienter
+    #Not to be initialized
+    pass
+
+
+def test_sympy__vector__orienters__ThreeAngleOrienter():
+    #from sympy.vector.orienters import ThreeAngleOrienter
+    #Not to be initialized
+    pass
+
+
+def test_sympy__vector__orienters__AxisOrienter():
+    from sympy.vector.orienters import AxisOrienter
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(AxisOrienter(x, C.i))
+
+
+def test_sympy__vector__orienters__BodyOrienter():
+    from sympy.vector.orienters import BodyOrienter
+    assert _test_args(BodyOrienter(x, y, z, '123'))
+
+
+def test_sympy__vector__orienters__SpaceOrienter():
+    from sympy.vector.orienters import SpaceOrienter
+    assert _test_args(SpaceOrienter(x, y, z, '123'))
+
+
+def test_sympy__vector__orienters__QuaternionOrienter():
+    from sympy.vector.orienters import QuaternionOrienter
+    a, b, c, d = symbols('a b c d')
+    assert _test_args(QuaternionOrienter(a, b, c, d))
+
+
+def test_sympy__vector__parametricregion__ParametricRegion():
+    from sympy.abc import t
+    from sympy.vector.parametricregion import ParametricRegion
+    assert _test_args(ParametricRegion((t, t**3), (t, 0, 2)))
+
+
+def test_sympy__vector__scalar__BaseScalar():
+    from sympy.vector.scalar import BaseScalar
+    from sympy.vector.coordsysrect import CoordSys3D
+    C = CoordSys3D('C')
+    assert _test_args(BaseScalar(0, C, ' ', ' '))
+
+
+def test_sympy__physics__wigner__Wigner3j():
+    from sympy.physics.wigner import Wigner3j
+    assert _test_args(Wigner3j(0, 0, 0, 0, 0, 0))
+
+
+def test_sympy__combinatorics__schur_number__SchurNumber():
+    from sympy.combinatorics.schur_number import SchurNumber
+    assert _test_args(SchurNumber(x))
+
+
+def test_sympy__combinatorics__perm_groups__SymmetricPermutationGroup():
+    from sympy.combinatorics.perm_groups import SymmetricPermutationGroup
+    assert _test_args(SymmetricPermutationGroup(5))
+
+
+def test_sympy__combinatorics__perm_groups__Coset():
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.combinatorics.perm_groups import PermutationGroup, Coset
+    a = Permutation(1, 2)
+    b = Permutation(0, 1)
+    G = PermutationGroup([a, b])
+    assert _test_args(Coset(a, G))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_arit.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_arit.py
new file mode 100644
index 0000000000000000000000000000000000000000..251fc4c4234cbd6e82adc9a24ccea536ed6a37b7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_arit.py
@@ -0,0 +1,2489 @@
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, comp, nan,
+    oo, pi, zoo)
+from sympy.core.power import Pow
+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 factorial
+from sympy.functions.elementary.complexes import (im, re, sign)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (atan, cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.polys.polytools import Poly
+from sympy.sets.sets import FiniteSet
+
+from sympy.core.parameters import distribute, evaluate
+from sympy.core.expr import unchanged
+from sympy.utilities.iterables import permutations
+from sympy.testing.pytest import XFAIL, raises, warns
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+from sympy.core.random import verify_numerically
+from sympy.functions.elementary.trigonometric import asin
+
+from itertools import product
+
+a, c, x, y, z = symbols('a,c,x,y,z')
+b = Symbol("b", positive=True)
+
+
+def same_and_same_prec(a, b):
+    # stricter matching for Floats
+    return a == b and a._prec == b._prec
+
+
+def test_bug1():
+    assert re(x) != x
+    x.series(x, 0, 1)
+    assert re(x) != x
+
+
+def test_Symbol():
+    e = a*b
+    assert e == a*b
+    assert a*b*b == a*b**2
+    assert a*b*b + c == c + a*b**2
+    assert a*b*b - c == -c + a*b**2
+
+    x = Symbol('x', complex=True, real=False)
+    assert x.is_imaginary is None  # could be I or 1 + I
+    x = Symbol('x', complex=True, imaginary=False)
+    assert x.is_real is None  # could be 1 or 1 + I
+    x = Symbol('x', real=True)
+    assert x.is_complex
+    x = Symbol('x', imaginary=True)
+    assert x.is_complex
+    x = Symbol('x', real=False, imaginary=False)
+    assert x.is_complex is None  # might be a non-number
+
+
+def test_arit0():
+    p = Rational(5)
+    e = a*b
+    assert e == a*b
+    e = a*b + b*a
+    assert e == 2*a*b
+    e = a*b + b*a + a*b + p*b*a
+    assert e == 8*a*b
+    e = a*b + b*a + a*b + p*b*a + a
+    assert e == a + 8*a*b
+    e = a + a
+    assert e == 2*a
+    e = a + b + a
+    assert e == b + 2*a
+    e = a + b*b + a + b*b
+    assert e == 2*a + 2*b**2
+    e = a + Rational(2) + b*b + a + b*b + p
+    assert e == 7 + 2*a + 2*b**2
+    e = (a + b*b + a + b*b)*p
+    assert e == 5*(2*a + 2*b**2)
+    e = (a*b*c + c*b*a + b*a*c)*p
+    assert e == 15*a*b*c
+    e = (a*b*c + c*b*a + b*a*c)*p - Rational(15)*a*b*c
+    assert e == Rational(0)
+    e = Rational(50)*(a - a)
+    assert e == Rational(0)
+    e = b*a - b - a*b + b
+    assert e == Rational(0)
+    e = a*b + c**p
+    assert e == a*b + c**5
+    e = a/b
+    assert e == a*b**(-1)
+    e = a*2*2
+    assert e == 4*a
+    e = 2 + a*2/2
+    assert e == 2 + a
+    e = 2 - a - 2
+    assert e == -a
+    e = 2*a*2
+    assert e == 4*a
+    e = 2/a/2
+    assert e == a**(-1)
+    e = 2**a**2
+    assert e == 2**(a**2)
+    e = -(1 + a)
+    assert e == -1 - a
+    e = S.Half*(1 + a)
+    assert e == S.Half + a/2
+
+
+def test_div():
+    e = a/b
+    assert e == a*b**(-1)
+    e = a/b + c/2
+    assert e == a*b**(-1) + Rational(1)/2*c
+    e = (1 - b)/(b - 1)
+    assert e == (1 + -b)*((-1) + b)**(-1)
+
+
+def test_pow_arit():
+    n1 = Rational(1)
+    n2 = Rational(2)
+    n5 = Rational(5)
+    e = a*a
+    assert e == a**2
+    e = a*a*a
+    assert e == a**3
+    e = a*a*a*a**Rational(6)
+    assert e == a**9
+    e = a*a*a*a**Rational(6) - a**Rational(9)
+    assert e == Rational(0)
+    e = a**(b - b)
+    assert e == Rational(1)
+    e = (a + Rational(1) - a)**b
+    assert e == Rational(1)
+
+    e = (a + b + c)**n2
+    assert e == (a + b + c)**2
+    assert e.expand() == 2*b*c + 2*a*c + 2*a*b + a**2 + c**2 + b**2
+
+    e = (a + b)**n2
+    assert e == (a + b)**2
+    assert e.expand() == 2*a*b + a**2 + b**2
+
+    e = (a + b)**(n1/n2)
+    assert e == sqrt(a + b)
+    assert e.expand() == sqrt(a + b)
+
+    n = n5**(n1/n2)
+    assert n == sqrt(5)
+    e = n*a*b - n*b*a
+    assert e == Rational(0)
+    e = n*a*b + n*b*a
+    assert e == 2*a*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    assert e.diff(a) == 2*b*sqrt(5)
+    e = a/b**2
+    assert e == a*b**(-2)
+
+    assert sqrt(2*(1 + sqrt(2))) == (2*(1 + 2**S.Half))**S.Half
+
+    x = Symbol('x')
+    y = Symbol('y')
+
+    assert ((x*y)**3).expand() == y**3 * x**3
+    assert ((x*y)**-3).expand() == y**-3 * x**-3
+
+    assert (x**5*(3*x)**(3)).expand() == 27 * x**8
+    assert (x**5*(-3*x)**(3)).expand() == -27 * x**8
+    assert (x**5*(3*x)**(-3)).expand() == x**2 * Rational(1, 27)
+    assert (x**5*(-3*x)**(-3)).expand() == x**2 * Rational(-1, 27)
+
+    # expand_power_exp
+    _x = Symbol('x', zero=False)
+    _y = Symbol('y', zero=False)
+    assert (_x**(y**(x + exp(x + y)) + z)).expand(deep=False) == \
+        _x**z*_x**(y**(x + exp(x + y)))
+    assert (_x**(_y**(x + exp(x + y)) + z)).expand() == \
+        _x**z*_x**(_y**x*_y**(exp(x)*exp(y)))
+
+    n = Symbol('n', even=False)
+    k = Symbol('k', even=True)
+    o = Symbol('o', odd=True)
+
+    assert unchanged(Pow, -1, x)
+    assert unchanged(Pow, -1, n)
+    assert (-2)**k == 2**k
+    assert (-1)**k == 1
+    assert (-1)**o == -1
+
+
+def test_pow2():
+    # x**(2*y) is always (x**y)**2 but is only (x**2)**y if
+    #                                  x.is_positive or y.is_integer
+    # let x = 1 to see why the following are not true.
+    assert (-x)**Rational(2, 3) != x**Rational(2, 3)
+    assert (-x)**Rational(5, 7) != -x**Rational(5, 7)
+    assert ((-x)**2)**Rational(1, 3) != ((-x)**Rational(1, 3))**2
+    assert sqrt(x**2) != x
+
+
+def test_pow3():
+    assert sqrt(2)**3 == 2 * sqrt(2)
+    assert sqrt(2)**3 == sqrt(8)
+
+
+def test_mod_pow():
+    for s, t, u, v in [(4, 13, 497, 445), (4, -3, 497, 365),
+            (3.2, 2.1, 1.9, 0.1031015682350942), (S(3)/2, 5, S(5)/6, S(3)/32)]:
+        assert pow(S(s), t, u) == v
+        assert pow(S(s), S(t), u) == v
+        assert pow(S(s), t, S(u)) == v
+        assert pow(S(s), S(t), S(u)) == v
+    assert pow(S(2), S(10000000000), S(3)) == 1
+    assert pow(x, y, z) == x**y%z
+    raises(TypeError, lambda: pow(S(4), "13", 497))
+    raises(TypeError, lambda: pow(S(4), 13, "497"))
+
+
+def test_pow_E():
+    assert 2**(y/log(2)) == S.Exp1**y
+    assert 2**(y/log(2)/3) == S.Exp1**(y/3)
+    assert 3**(1/log(-3)) != S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I) + I*pi)) == S.Exp1
+    assert (4 + 2*I)**(1/(log(-4 - 2*I) + I*pi)) == S.Exp1
+    assert (3 + 2*I)**(1/(log(-3 - 2*I, 3)/2 + I*pi/log(3)/2)) == 9
+    assert (3 + 2*I)**(1/(log(3 + 2*I, 3)/2)) == 9
+    # every time tests are run they will affirm with a different random
+    # value that this identity holds
+    while 1:
+        b = x._random()
+        r, i = b.as_real_imag()
+        if i:
+            break
+    assert verify_numerically(b**(1/(log(-b) + sign(i)*I*pi).n()), S.Exp1)
+
+
+def test_pow_issue_3516():
+    assert 4**Rational(1, 4) == sqrt(2)
+
+
+def test_pow_im():
+    for m in (-2, -1, 2):
+        for d in (3, 4, 5):
+            b = m*I
+            for i in range(1, 4*d + 1):
+                e = Rational(i, d)
+                assert (b**e - b.n()**e.n()).n(2, chop=1e-10) == 0
+
+    e = Rational(7, 3)
+    assert (2*x*I)**e == 4*2**Rational(1, 3)*(I*x)**e  # same as Wolfram Alpha
+    im = symbols('im', imaginary=True)
+    assert (2*im*I)**e == 4*2**Rational(1, 3)*(I*im)**e
+
+    args = [I, I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args = [I, I, I, 2]
+    e = Rational(1, 3)
+    ans = 2**e*(-I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6*I)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+
+    args = [I, I, 2]
+    e = Rational(1, 3)
+    ans = (-2)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-3)
+    ans = (6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    args.append(-1)
+    ans = (-6)**e
+    assert Mul(*args, evaluate=False)**e == ans
+    assert Mul(*args)**e == ans
+    assert Mul(Pow(-1, Rational(3, 2), evaluate=False), I, I) == I
+    assert Mul(I*Pow(I, S.Half, evaluate=False)) == sqrt(I)*I
+
+
+def test_real_mul():
+    assert Float(0) * pi * x == 0
+    assert set((Float(1) * pi * x).args) == {Float(1), pi, x}
+
+
+def test_ncmul():
+    A = Symbol("A", commutative=False)
+    B = Symbol("B", commutative=False)
+    C = Symbol("C", commutative=False)
+    assert A*B != B*A
+    assert A*B*C != C*B*A
+    assert A*b*B*3*C == 3*b*A*B*C
+    assert A*b*B*3*C != 3*b*B*A*C
+    assert A*b*B*3*C == 3*A*B*C*b
+
+    assert A + B == B + A
+    assert (A + B)*C != C*(A + B)
+
+    assert C*(A + B)*C != C*C*(A + B)
+
+    assert A*A == A**2
+    assert (A + B)*(A + B) == (A + B)**2
+
+    assert A**-1 * A == 1
+    assert A/A == 1
+    assert A/(A**2) == 1/A
+
+    assert A/(1 + A) == A/(1 + A)
+
+    assert set((A + B + 2*(A + B)).args) == \
+        {A, B, 2*(A + B)}
+
+
+def test_mul_add_identity():
+    m = Mul(1, 2)
+    assert isinstance(m, Rational) and m.p == 2 and m.q == 1
+    m = Mul(1, 2, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (1, 2)
+    m = Mul(0, 1)
+    assert m is S.Zero
+    m = Mul(0, 1, evaluate=False)
+    assert isinstance(m, Mul) and m.args == (0, 1)
+    m = Add(0, 1)
+    assert m is S.One
+    m = Add(0, 1, evaluate=False)
+    assert isinstance(m, Add) and m.args == (0, 1)
+
+
+def test_ncpow():
+    x = Symbol('x', commutative=False)
+    y = Symbol('y', commutative=False)
+    z = Symbol('z', commutative=False)
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+
+    assert (x**2)*(y**2) != (y**2)*(x**2)
+    assert (x**-2)*y != y*(x**2)
+    assert 2**x*2**y != 2**(x + y)
+    assert 2**x*2**y*2**z != 2**(x + y + z)
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert 2**x*2**(2*x)*2**x == 2**(4*x)
+    assert exp(x)*exp(y) != exp(y)*exp(x)
+    assert exp(x)*exp(y)*exp(z) != exp(y)*exp(x)*exp(z)
+    assert exp(x)*exp(y)*exp(z) != exp(x + y + z)
+    assert x**a*x**b != x**(a + b)
+    assert x**a*x**b*x**c != x**(a + b + c)
+    assert x**3*x**4 == x**7
+    assert x**3*x**4*x**2 == x**9
+    assert x**a*x**(4*a) == x**(5*a)
+    assert x**a*x**(4*a)*x**a == x**(6*a)
+
+
+def test_powerbug():
+    x = Symbol("x")
+    assert x**1 != (-x)**1
+    assert x**2 == (-x)**2
+    assert x**3 != (-x)**3
+    assert x**4 == (-x)**4
+    assert x**5 != (-x)**5
+    assert x**6 == (-x)**6
+
+    assert x**128 == (-x)**128
+    assert x**129 != (-x)**129
+
+    assert (2*x)**2 == (-2*x)**2
+
+
+def test_Mul_doesnt_expand_exp():
+    x = Symbol('x')
+    y = Symbol('y')
+    assert unchanged(Mul, exp(x), exp(y))
+    assert unchanged(Mul, 2**x, 2**y)
+    assert x**2*x**3 == x**5
+    assert 2**x*3**x == 6**x
+    assert x**(y)*x**(2*y) == x**(3*y)
+    assert sqrt(2)*sqrt(2) == 2
+    assert 2**x*2**(2*x) == 2**(3*x)
+    assert sqrt(2)*2**Rational(1, 4)*5**Rational(3, 4) == 10**Rational(3, 4)
+    assert (x**(-log(5)/log(3))*x)/(x*x**( - log(5)/log(3))) == sympify(1)
+
+
+def test_Mul_is_integer():
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nr = Symbol('nr', rational=False)
+    ir = Symbol('ir', irrational=True)
+    nz = Symbol('nz', integer=True, zero=False)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    i2 = Symbol('2', prime=True, even=True)
+
+    assert (k/3).is_integer is None
+    assert (nz/3).is_integer is None
+    assert (nr/3).is_integer is False
+    assert (ir/3).is_integer is False
+    assert (x*k*n).is_integer is None
+    assert (e/2).is_integer is True
+    assert (e**2/2).is_integer is True
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is None
+    assert ((-1)**k*n).is_integer is True
+    assert (3*k*e/2).is_integer is True
+    assert (2*k*e/3).is_integer is None
+    assert (e/o).is_integer is None
+    assert (o/e).is_integer is False
+    assert (o/i2).is_integer is False
+    assert Mul(k, 1/k, evaluate=False).is_integer is None
+    assert Mul(2., S.Half, evaluate=False).is_integer is None
+    assert (2*sqrt(k)).is_integer is None
+    assert (2*k**n).is_integer is None
+
+    s = 2**2**2**Pow(2, 1000, evaluate=False)
+    m = Mul(s, s, evaluate=False)
+    assert m.is_integer
+
+    # broken in 1.6 and before, see #20161
+    xq = Symbol('xq', rational=True)
+    yq = Symbol('yq', rational=True)
+    assert (xq*yq).is_integer is None
+    e_20161 = Mul(-1,Mul(1,Pow(2,-1,evaluate=False),evaluate=False),evaluate=False)
+    assert e_20161.is_integer is not True # expand(e_20161) -> -1/2, but no need to see that in the assumption without evaluation
+
+
+def test_Add_Mul_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True)
+    nk = Symbol('nk', integer=False)
+    nr = Symbol('nr', rational=False)
+    nz = Symbol('nz', integer=True, zero=False)
+
+    assert (-nk).is_integer is None
+    assert (-nr).is_integer is False
+    assert (2*k).is_integer is True
+    assert (-k).is_integer is True
+
+    assert (k + nk).is_integer is False
+    assert (k + n).is_integer is True
+    assert (k + x).is_integer is None
+    assert (k + n*x).is_integer is None
+    assert (k + n/3).is_integer is None
+    assert (k + nz/3).is_integer is None
+    assert (k + nr/3).is_integer is False
+
+    assert ((1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+    assert (1 + (1 + sqrt(3))*(-sqrt(3) + 1)).is_integer is not False
+
+
+def test_Add_Mul_is_finite():
+    x = Symbol('x', extended_real=True, finite=False)
+
+    assert sin(x).is_finite is True
+    assert (x*sin(x)).is_finite is None
+    assert (x*atan(x)).is_finite is False
+    assert (1024*sin(x)).is_finite is True
+    assert (sin(x)*exp(x)).is_finite is None
+    assert (sin(x)*cos(x)).is_finite is True
+    assert (x*sin(x)*exp(x)).is_finite is None
+
+    assert (sin(x) - 67).is_finite is True
+    assert (sin(x) + exp(x)).is_finite is not True
+    assert (1 + x).is_finite is False
+    assert (1 + x**2 + (1 + x)*(1 - x)).is_finite is None
+    assert (sqrt(2)*(1 + x)).is_finite is False
+    assert (sqrt(2)*(1 + x)*(1 - x)).is_finite is False
+
+
+def test_Mul_is_even_odd():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (2*x).is_even is True
+    assert (2*x).is_odd is False
+
+    assert (3*x).is_even is None
+    assert (3*x).is_odd is None
+
+    assert (k/3).is_integer is None
+    assert (k/3).is_even is None
+    assert (k/3).is_odd is None
+
+    assert (2*n).is_even is True
+    assert (2*n).is_odd is False
+
+    assert (2*m).is_even is True
+    assert (2*m).is_odd is False
+
+    assert (-n).is_even is False
+    assert (-n).is_odd is True
+
+    assert (k*n).is_even is False
+    assert (k*n).is_odd is True
+
+    assert (k*m).is_even is True
+    assert (k*m).is_odd is False
+
+    assert (k*n*m).is_even is True
+    assert (k*n*m).is_odd is False
+
+    assert (k*m*x).is_even is True
+    assert (k*m*x).is_odd is False
+
+    # issue 6791:
+    assert (x/2).is_integer is None
+    assert (k/2).is_integer is False
+    assert (m/2).is_integer is True
+
+    assert (x*y).is_even is None
+    assert (x*x).is_even is None
+    assert (x*(x + k)).is_even is True
+    assert (x*(x + m)).is_even is None
+
+    assert (x*y).is_odd is None
+    assert (x*x).is_odd is None
+    assert (x*(x + k)).is_odd is False
+    assert (x*(x + m)).is_odd is None
+
+    # issue 8648
+    assert (m**2/2).is_even
+    assert (m**2/3).is_even is False
+    assert (2/m**2).is_odd is False
+    assert (2/m).is_odd is None
+
+
+@XFAIL
+def test_evenness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_even is True
+    assert (y*x*(x + k)).is_even is True
+
+
+def test_evenness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_even is None
+
+
+@XFAIL
+def test_oddness_in_ternary_integer_product_with_odd():
+    # Tests that oddness inference is independent of term ordering.
+    # Term ordering at the point of testing depends on SymPy's symbol order, so
+    # we try to force a different order by modifying symbol names.
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    k = Symbol('k', odd=True)
+    assert (x*y*(y + k)).is_odd is False
+    assert (y*x*(x + k)).is_odd is False
+
+
+def test_oddness_in_ternary_integer_product_with_even():
+    x = Symbol('x', integer=True)
+    y = Symbol('y', integer=True)
+    m = Symbol('m', even=True)
+    assert (x*y*(y + m)).is_odd is None
+
+
+def test_Mul_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, nonzero=True)
+
+    assert (n/m).is_rational is True
+    assert (x/pi).is_rational is None
+    assert (x/n).is_rational is None
+    assert (m/pi).is_rational is False
+
+    r = Symbol('r', rational=True)
+    assert (pi*r).is_rational is None
+
+    # issue 8008
+    z = Symbol('z', zero=True)
+    i = Symbol('i', imaginary=True)
+    assert (z*i).is_rational is True
+    bi = Symbol('i', imaginary=True, finite=True)
+    assert (z*bi).is_zero is True
+
+
+def test_Add_is_rational():
+    x = Symbol('x')
+    n = Symbol('n', rational=True)
+    m = Symbol('m', rational=True)
+
+    assert (n + m).is_rational is True
+    assert (x + pi).is_rational is None
+    assert (x + n).is_rational is None
+    assert (n + pi).is_rational is False
+
+
+def test_Add_is_even_odd():
+    x = Symbol('x', integer=True)
+
+    k = Symbol('k', odd=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', even=True)
+
+    assert (k + 7).is_even is True
+    assert (k + 7).is_odd is False
+
+    assert (-k + 7).is_even is True
+    assert (-k + 7).is_odd is False
+
+    assert (k - 12).is_even is False
+    assert (k - 12).is_odd is True
+
+    assert (-k - 12).is_even is False
+    assert (-k - 12).is_odd is True
+
+    assert (k + n).is_even is True
+    assert (k + n).is_odd is False
+
+    assert (k + m).is_even is False
+    assert (k + m).is_odd is True
+
+    assert (k + n + m).is_even is True
+    assert (k + n + m).is_odd is False
+
+    assert (k + n + x + m).is_even is None
+    assert (k + n + x + m).is_odd is None
+
+
+def test_Mul_is_negative_positive():
+    x = Symbol('x', real=True)
+    y = Symbol('y', extended_real=False, complex=True)
+    z = Symbol('z', zero=True)
+
+    e = 2*z
+    assert e.is_Mul and e.is_positive is False and e.is_negative is False
+
+    neg = Symbol('neg', negative=True)
+    pos = Symbol('pos', positive=True)
+    nneg = Symbol('nneg', nonnegative=True)
+    npos = Symbol('npos', nonpositive=True)
+
+    assert neg.is_negative is True
+    assert (-neg).is_negative is False
+    assert (2*neg).is_negative is True
+
+    assert (2*pos)._eval_is_extended_negative() is False
+    assert (2*pos).is_negative is False
+
+    assert pos.is_negative is False
+    assert (-pos).is_negative is True
+    assert (2*pos).is_negative is False
+
+    assert (pos*neg).is_negative is True
+    assert (2*pos*neg).is_negative is True
+    assert (-pos*neg).is_negative is False
+    assert (pos*neg*y).is_negative is False     # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_negative is False
+    assert (-nneg).is_negative is None
+    assert (2*nneg).is_negative is False
+
+    assert npos.is_negative is None
+    assert (-npos).is_negative is False
+    assert (2*npos).is_negative is None
+
+    assert (nneg*npos).is_negative is None
+
+    assert (neg*nneg).is_negative is None
+    assert (neg*npos).is_negative is False
+
+    assert (pos*nneg).is_negative is False
+    assert (pos*npos).is_negative is None
+
+    assert (npos*neg*nneg).is_negative is False
+    assert (npos*pos*nneg).is_negative is None
+
+    assert (-npos*neg*nneg).is_negative is None
+    assert (-npos*pos*nneg).is_negative is False
+
+    assert (17*npos*neg*nneg).is_negative is False
+    assert (17*npos*pos*nneg).is_negative is None
+
+    assert (neg*npos*pos*nneg).is_negative is False
+
+    assert (x*neg).is_negative is None
+    assert (nneg*npos*pos*x*neg).is_negative is None
+
+    assert neg.is_positive is False
+    assert (-neg).is_positive is True
+    assert (2*neg).is_positive is False
+
+    assert pos.is_positive is True
+    assert (-pos).is_positive is False
+    assert (2*pos).is_positive is True
+
+    assert (pos*neg).is_positive is False
+    assert (2*pos*neg).is_positive is False
+    assert (-pos*neg).is_positive is True
+    assert (-pos*neg*y).is_positive is False    # y.is_real=F;  !real -> !neg
+
+    assert nneg.is_positive is None
+    assert (-nneg).is_positive is False
+    assert (2*nneg).is_positive is None
+
+    assert npos.is_positive is False
+    assert (-npos).is_positive is None
+    assert (2*npos).is_positive is False
+
+    assert (nneg*npos).is_positive is False
+
+    assert (neg*nneg).is_positive is False
+    assert (neg*npos).is_positive is None
+
+    assert (pos*nneg).is_positive is None
+    assert (pos*npos).is_positive is False
+
+    assert (npos*neg*nneg).is_positive is None
+    assert (npos*pos*nneg).is_positive is False
+
+    assert (-npos*neg*nneg).is_positive is False
+    assert (-npos*pos*nneg).is_positive is None
+
+    assert (17*npos*neg*nneg).is_positive is None
+    assert (17*npos*pos*nneg).is_positive is False
+
+    assert (neg*npos*pos*nneg).is_positive is None
+
+    assert (x*neg).is_positive is None
+    assert (nneg*npos*pos*x*neg).is_positive is None
+
+
+def test_Mul_is_negative_positive_2():
+    a = Symbol('a', nonnegative=True)
+    b = Symbol('b', nonnegative=True)
+    c = Symbol('c', nonpositive=True)
+    d = Symbol('d', nonpositive=True)
+
+    assert (a*b).is_nonnegative is True
+    assert (a*b).is_negative is False
+    assert (a*b).is_zero is None
+    assert (a*b).is_positive is None
+
+    assert (c*d).is_nonnegative is True
+    assert (c*d).is_negative is False
+    assert (c*d).is_zero is None
+    assert (c*d).is_positive is None
+
+    assert (a*c).is_nonpositive is True
+    assert (a*c).is_positive is False
+    assert (a*c).is_zero is None
+    assert (a*c).is_negative is None
+
+
+def test_Mul_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert k.is_nonpositive is True
+    assert (-k).is_nonpositive is False
+    assert (2*k).is_nonpositive is True
+
+    assert n.is_nonpositive is False
+    assert (-n).is_nonpositive is True
+    assert (2*n).is_nonpositive is False
+
+    assert (n*k).is_nonpositive is True
+    assert (2*n*k).is_nonpositive is True
+    assert (-n*k).is_nonpositive is False
+
+    assert u.is_nonpositive is None
+    assert (-u).is_nonpositive is True
+    assert (2*u).is_nonpositive is None
+
+    assert v.is_nonpositive is True
+    assert (-v).is_nonpositive is None
+    assert (2*v).is_nonpositive is True
+
+    assert (u*v).is_nonpositive is True
+
+    assert (k*u).is_nonpositive is True
+    assert (k*v).is_nonpositive is None
+
+    assert (n*u).is_nonpositive is None
+    assert (n*v).is_nonpositive is True
+
+    assert (v*k*u).is_nonpositive is None
+    assert (v*n*u).is_nonpositive is True
+
+    assert (-v*k*u).is_nonpositive is True
+    assert (-v*n*u).is_nonpositive is None
+
+    assert (17*v*k*u).is_nonpositive is None
+    assert (17*v*n*u).is_nonpositive is True
+
+    assert (k*v*n*u).is_nonpositive is None
+
+    assert (x*k).is_nonpositive is None
+    assert (u*v*n*x*k).is_nonpositive is None
+
+    assert k.is_nonnegative is False
+    assert (-k).is_nonnegative is True
+    assert (2*k).is_nonnegative is False
+
+    assert n.is_nonnegative is True
+    assert (-n).is_nonnegative is False
+    assert (2*n).is_nonnegative is True
+
+    assert (n*k).is_nonnegative is False
+    assert (2*n*k).is_nonnegative is False
+    assert (-n*k).is_nonnegative is True
+
+    assert u.is_nonnegative is True
+    assert (-u).is_nonnegative is None
+    assert (2*u).is_nonnegative is True
+
+    assert v.is_nonnegative is None
+    assert (-v).is_nonnegative is True
+    assert (2*v).is_nonnegative is None
+
+    assert (u*v).is_nonnegative is None
+
+    assert (k*u).is_nonnegative is None
+    assert (k*v).is_nonnegative is True
+
+    assert (n*u).is_nonnegative is True
+    assert (n*v).is_nonnegative is None
+
+    assert (v*k*u).is_nonnegative is True
+    assert (v*n*u).is_nonnegative is None
+
+    assert (-v*k*u).is_nonnegative is None
+    assert (-v*n*u).is_nonnegative is True
+
+    assert (17*v*k*u).is_nonnegative is True
+    assert (17*v*n*u).is_nonnegative is None
+
+    assert (k*v*n*u).is_nonnegative is True
+
+    assert (x*k).is_nonnegative is None
+    assert (u*v*n*x*k).is_nonnegative is None
+
+
+def test_Add_is_negative_positive():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (k - 2).is_negative is True
+    assert (k + 17).is_negative is None
+    assert (-k - 5).is_negative is None
+    assert (-k + 123).is_negative is False
+
+    assert (k - n).is_negative is True
+    assert (k + n).is_negative is None
+    assert (-k - n).is_negative is None
+    assert (-k + n).is_negative is False
+
+    assert (k - n - 2).is_negative is True
+    assert (k + n + 17).is_negative is None
+    assert (-k - n - 5).is_negative is None
+    assert (-k + n + 123).is_negative is False
+
+    assert (-2*k + 123*n + 17).is_negative is False
+
+    assert (k + u).is_negative is None
+    assert (k + v).is_negative is True
+    assert (n + u).is_negative is False
+    assert (n + v).is_negative is None
+
+    assert (u - v).is_negative is False
+    assert (u + v).is_negative is None
+    assert (-u - v).is_negative is None
+    assert (-u + v).is_negative is None
+
+    assert (u - v + n + 2).is_negative is False
+    assert (u + v + n + 2).is_negative is None
+    assert (-u - v + n + 2).is_negative is None
+    assert (-u + v + n + 2).is_negative is None
+
+    assert (k + x).is_negative is None
+    assert (k + x - n).is_negative is None
+
+    assert (k - 2).is_positive is False
+    assert (k + 17).is_positive is None
+    assert (-k - 5).is_positive is None
+    assert (-k + 123).is_positive is True
+
+    assert (k - n).is_positive is False
+    assert (k + n).is_positive is None
+    assert (-k - n).is_positive is None
+    assert (-k + n).is_positive is True
+
+    assert (k - n - 2).is_positive is False
+    assert (k + n + 17).is_positive is None
+    assert (-k - n - 5).is_positive is None
+    assert (-k + n + 123).is_positive is True
+
+    assert (-2*k + 123*n + 17).is_positive is True
+
+    assert (k + u).is_positive is None
+    assert (k + v).is_positive is False
+    assert (n + u).is_positive is True
+    assert (n + v).is_positive is None
+
+    assert (u - v).is_positive is None
+    assert (u + v).is_positive is None
+    assert (-u - v).is_positive is None
+    assert (-u + v).is_positive is False
+
+    assert (u - v - n - 2).is_positive is None
+    assert (u + v - n - 2).is_positive is None
+    assert (-u - v - n - 2).is_positive is None
+    assert (-u + v - n - 2).is_positive is False
+
+    assert (n + x).is_positive is None
+    assert (n + x - k).is_positive is None
+
+    z = (-3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2)
+    assert z.is_zero
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_zero
+
+
+def test_Add_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', negative=True)
+    n = Symbol('n', positive=True)
+    u = Symbol('u', nonnegative=True)
+    v = Symbol('v', nonpositive=True)
+
+    assert (u - 2).is_nonpositive is None
+    assert (u + 17).is_nonpositive is False
+    assert (-u - 5).is_nonpositive is True
+    assert (-u + 123).is_nonpositive is None
+
+    assert (u - v).is_nonpositive is None
+    assert (u + v).is_nonpositive is None
+    assert (-u - v).is_nonpositive is None
+    assert (-u + v).is_nonpositive is True
+
+    assert (u - v - 2).is_nonpositive is None
+    assert (u + v + 17).is_nonpositive is None
+    assert (-u - v - 5).is_nonpositive is None
+    assert (-u + v - 123).is_nonpositive is True
+
+    assert (-2*u + 123*v - 17).is_nonpositive is True
+
+    assert (k + u).is_nonpositive is None
+    assert (k + v).is_nonpositive is True
+    assert (n + u).is_nonpositive is False
+    assert (n + v).is_nonpositive is None
+
+    assert (k - n).is_nonpositive is True
+    assert (k + n).is_nonpositive is None
+    assert (-k - n).is_nonpositive is None
+    assert (-k + n).is_nonpositive is False
+
+    assert (k - n + u + 2).is_nonpositive is None
+    assert (k + n + u + 2).is_nonpositive is None
+    assert (-k - n + u + 2).is_nonpositive is None
+    assert (-k + n + u + 2).is_nonpositive is False
+
+    assert (u + x).is_nonpositive is None
+    assert (v - x - n).is_nonpositive is None
+
+    assert (u - 2).is_nonnegative is None
+    assert (u + 17).is_nonnegative is True
+    assert (-u - 5).is_nonnegative is False
+    assert (-u + 123).is_nonnegative is None
+
+    assert (u - v).is_nonnegative is True
+    assert (u + v).is_nonnegative is None
+    assert (-u - v).is_nonnegative is None
+    assert (-u + v).is_nonnegative is None
+
+    assert (u - v + 2).is_nonnegative is True
+    assert (u + v + 17).is_nonnegative is None
+    assert (-u - v - 5).is_nonnegative is None
+    assert (-u + v - 123).is_nonnegative is False
+
+    assert (2*u - 123*v + 17).is_nonnegative is True
+
+    assert (k + u).is_nonnegative is None
+    assert (k + v).is_nonnegative is False
+    assert (n + u).is_nonnegative is True
+    assert (n + v).is_nonnegative is None
+
+    assert (k - n).is_nonnegative is False
+    assert (k + n).is_nonnegative is None
+    assert (-k - n).is_nonnegative is None
+    assert (-k + n).is_nonnegative is True
+
+    assert (k - n - u - 2).is_nonnegative is False
+    assert (k + n - u - 2).is_nonnegative is None
+    assert (-k - n - u - 2).is_nonnegative is None
+    assert (-k + n - u - 2).is_nonnegative is None
+
+    assert (u - x).is_nonnegative is None
+    assert (v + x + n).is_nonnegative is None
+
+
+def test_Pow_is_integer():
+    x = Symbol('x')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', integer=True, nonnegative=True)
+    m = Symbol('m', integer=True, positive=True)
+
+    assert (k**2).is_integer is True
+    assert (k**(-2)).is_integer is None
+    assert ((m + 1)**(-2)).is_integer is False
+    assert (m**(-1)).is_integer is None  # issue 8580
+
+    assert (2**k).is_integer is None
+    assert (2**(-k)).is_integer is None
+
+    assert (2**n).is_integer is True
+    assert (2**(-n)).is_integer is None
+
+    assert (2**m).is_integer is True
+    assert (2**(-m)).is_integer is False
+
+    assert (x**2).is_integer is None
+    assert (2**x).is_integer is None
+
+    assert (k**n).is_integer is True
+    assert (k**(-n)).is_integer is None
+
+    assert (k**x).is_integer is None
+    assert (x**k).is_integer is None
+
+    assert (k**(n*m)).is_integer is True
+    assert (k**(-n*m)).is_integer is None
+
+    assert sqrt(3).is_integer is False
+    assert sqrt(.3).is_integer is False
+    assert Pow(3, 2, evaluate=False).is_integer is True
+    assert Pow(3, 0, evaluate=False).is_integer is True
+    assert Pow(3, -2, evaluate=False).is_integer is False
+    assert Pow(S.Half, 3, evaluate=False).is_integer is False
+    # decided by re-evaluating
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(3, S.Half, evaluate=False).is_integer is False
+    assert Pow(4, S.Half, evaluate=False).is_integer is True
+    assert Pow(S.Half, -2, evaluate=False).is_integer is True
+
+    assert ((-1)**k).is_integer
+
+    # issue 8641
+    x = Symbol('x', real=True, integer=False)
+    assert (x**2).is_integer is None
+
+    # issue 10458
+    x = Symbol('x', positive=True)
+    assert (1/(x + 1)).is_integer is False
+    assert (1/(-x - 1)).is_integer is False
+    assert (-1/(x + 1)).is_integer is False
+    # issue 23287
+    assert (x**2/2).is_integer is None
+
+    # issue 8648-like
+    k = Symbol('k', even=True)
+    assert (k**3/2).is_integer
+    assert (k**3/8).is_integer
+    assert (k**3/16).is_integer is None
+    assert (2/k).is_integer is None
+    assert (2/k**2).is_integer is False
+    o = Symbol('o', odd=True)
+    assert (k/o).is_integer is None
+    o = Symbol('o', odd=True, prime=True)
+    assert (k/o).is_integer is False
+
+
+def test_Pow_is_real():
+    x = Symbol('x', real=True)
+    y = Symbol('y', positive=True)
+
+    assert (x**2).is_real is True
+    assert (x**3).is_real is True
+    assert (x**x).is_real is None
+    assert (y**x).is_real is True
+
+    assert (x**Rational(1, 3)).is_real is None
+    assert (y**Rational(1, 3)).is_real is True
+
+    assert sqrt(-1 - sqrt(2)).is_real is False
+
+    i = Symbol('i', imaginary=True)
+    assert (i**i).is_real is None
+    assert (I**i).is_extended_real is True
+    assert ((-I)**i).is_extended_real is True
+    assert (2**i).is_real is None  # (2**(pi/log(2) * I)) is real, 2**I is not
+    assert (2**I).is_real is False
+    assert (2**-I).is_real is False
+    assert (i**2).is_extended_real is True
+    assert (i**3).is_extended_real is False
+    assert (i**x).is_real is None  # could be (-I)**(2/3)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+    k = Symbol('k', integer=True)
+    assert (i**e).is_extended_real is True
+    assert (i**o).is_extended_real is False
+    assert (i**k).is_real is None
+    assert (i**(4*k)).is_extended_real is True
+
+    x = Symbol("x", nonnegative=True)
+    y = Symbol("y", nonnegative=True)
+    assert im(x**y).expand(complex=True) is S.Zero
+    assert (x**y).is_real is True
+    i = Symbol('i', imaginary=True)
+    assert (exp(i)**I).is_extended_real is True
+    assert log(exp(i)).is_imaginary is None  # i could be 2*pi*I
+    c = Symbol('c', complex=True)
+    assert log(c).is_real is None  # c could be 0 or 2, too
+    assert log(exp(c)).is_real is None  # log(0), log(E), ...
+    n = Symbol('n', negative=False)
+    assert log(n).is_real is None
+    n = Symbol('n', nonnegative=True)
+    assert log(n).is_real is None
+
+    assert sqrt(-I).is_real is False  # issue 7843
+
+    i = Symbol('i', integer=True)
+    assert (1/(i-1)).is_real is None
+    assert (1/(i-1)).is_extended_real is None
+
+    # test issue 20715
+    from sympy.core.parameters import evaluate
+    x = S(-1)
+    with evaluate(False):
+        assert x.is_negative is True
+
+    f = Pow(x, -1)
+    with evaluate(False):
+        assert f.is_imaginary is False
+
+
+def test_real_Pow():
+    k = Symbol('k', integer=True, nonzero=True)
+    assert (k**(I*pi/log(k))).is_real
+
+
+def test_Pow_is_finite():
+    xe = Symbol('xe', extended_real=True)
+    xr = Symbol('xr', real=True)
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    i = Symbol('i', integer=True)
+
+    assert (xe**2).is_finite is None  # xe could be oo
+    assert (xr**2).is_finite is True
+
+    assert (xe**xe).is_finite is None
+    assert (xr**xe).is_finite is None
+    assert (xe**xr).is_finite is None
+    # FIXME: The line below should be True rather than None
+    # assert (xr**xr).is_finite is True
+    assert (xr**xr).is_finite is None
+
+    assert (p**xe).is_finite is None
+    assert (p**xr).is_finite is True
+
+    assert (n**xe).is_finite is None
+    assert (n**xr).is_finite is True
+
+    assert (sin(xe)**2).is_finite is True
+    assert (sin(xr)**2).is_finite is True
+
+    assert (sin(xe)**xe).is_finite is None  # xe, xr could be -pi
+    assert (sin(xr)**xr).is_finite is None
+
+    # FIXME: Should the line below be True rather than None?
+    assert (sin(xe)**exp(xe)).is_finite is None
+    assert (sin(xr)**exp(xr)).is_finite is True
+
+    assert (1/sin(xe)).is_finite is None  # if zero, no, otherwise yes
+    assert (1/sin(xr)).is_finite is None
+
+    assert (1/exp(xe)).is_finite is None  # xe could be -oo
+    assert (1/exp(xr)).is_finite is True
+
+    assert (1/S.Pi).is_finite is True
+
+    assert (1/(i-1)).is_finite is None
+
+
+def test_Pow_is_even_odd():
+    x = Symbol('x')
+
+    k = Symbol('k', even=True)
+    n = Symbol('n', odd=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    p = Symbol('p', integer=True, positive=True)
+
+    assert ((-1)**n).is_odd
+    assert ((-1)**k).is_odd
+    assert ((-1)**(m - p)).is_odd
+
+    assert (k**2).is_even is True
+    assert (n**2).is_even is False
+    assert (2**k).is_even is None
+    assert (x**2).is_even is None
+
+    assert (k**m).is_even is None
+    assert (n**m).is_even is False
+
+    assert (k**p).is_even is True
+    assert (n**p).is_even is False
+
+    assert (m**k).is_even is None
+    assert (p**k).is_even is None
+
+    assert (m**n).is_even is None
+    assert (p**n).is_even is None
+
+    assert (k**x).is_even is None
+    assert (n**x).is_even is None
+
+    assert (k**2).is_odd is False
+    assert (n**2).is_odd is True
+    assert (3**k).is_odd is None
+
+    assert (k**m).is_odd is None
+    assert (n**m).is_odd is True
+
+    assert (k**p).is_odd is False
+    assert (n**p).is_odd is True
+
+    assert (m**k).is_odd is None
+    assert (p**k).is_odd is None
+
+    assert (m**n).is_odd is None
+    assert (p**n).is_odd is None
+
+    assert (k**x).is_odd is None
+    assert (n**x).is_odd is None
+
+
+def test_Pow_is_negative_positive():
+    r = Symbol('r', real=True)
+
+    k = Symbol('k', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    x = Symbol('x')
+
+    assert (2**r).is_positive is True
+    assert ((-2)**r).is_positive is None
+    assert ((-2)**n).is_positive is True
+    assert ((-2)**m).is_positive is False
+
+    assert (k**2).is_positive is True
+    assert (k**(-2)).is_positive is True
+
+    assert (k**r).is_positive is True
+    assert ((-k)**r).is_positive is None
+    assert ((-k)**n).is_positive is True
+    assert ((-k)**m).is_positive is False
+
+    assert (2**r).is_negative is False
+    assert ((-2)**r).is_negative is None
+    assert ((-2)**n).is_negative is False
+    assert ((-2)**m).is_negative is True
+
+    assert (k**2).is_negative is False
+    assert (k**(-2)).is_negative is False
+
+    assert (k**r).is_negative is False
+    assert ((-k)**r).is_negative is None
+    assert ((-k)**n).is_negative is False
+    assert ((-k)**m).is_negative is True
+
+    assert (2**x).is_positive is None
+    assert (2**x).is_negative is None
+
+
+def test_Pow_is_zero():
+    z = Symbol('z', zero=True)
+    e = z**2
+    assert e.is_zero
+    assert e.is_positive is False
+    assert e.is_negative is False
+
+    assert Pow(0, 0, evaluate=False).is_zero is False
+    assert Pow(0, 3, evaluate=False).is_zero
+    assert Pow(0, oo, evaluate=False).is_zero
+    assert Pow(0, -3, evaluate=False).is_zero is False
+    assert Pow(0, -oo, evaluate=False).is_zero is False
+    assert Pow(2, 2, evaluate=False).is_zero is False
+
+    a = Symbol('a', zero=False)
+    assert Pow(a, 3).is_zero is False  # issue 7965
+
+    assert Pow(2, oo, evaluate=False).is_zero is False
+    assert Pow(2, -oo, evaluate=False).is_zero
+    assert Pow(S.Half, oo, evaluate=False).is_zero
+    assert Pow(S.Half, -oo, evaluate=False).is_zero is False
+
+    # All combinations of real/complex base/exponent
+    h = S.Half
+    T = True
+    F = False
+    N = None
+
+    pow_iszero = [
+        ['**',  0,  h,  1,  2, -h, -1,-2,-2*I,-I/2,I/2,1+I,oo,-oo,zoo],
+        [   0,  F,  T,  T,  T,  F,  F,  F,  F,  F,  F,  N,  T,  F,  N],
+        [   h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [   1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [   2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  -h,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [  -1,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  N],
+        [  -2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-2*I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [-I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ I/2,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  F,  N],
+        [ 1+I,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  F,  T,  N],
+        [  oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ -oo,  F,  F,  F,  F,  T,  T,  T,  F,  F,  F,  F,  F,  T,  N],
+        [ zoo,  F,  F,  F,  F,  T,  T,  T,  N,  N,  N,  N,  F,  T,  N]
+    ]
+
+    def test_table(table):
+        n = len(table[0])
+        for row in range(1, n):
+            base = table[row][0]
+            for col in range(1, n):
+                exp = table[0][col]
+                is_zero = table[row][col]
+                # The actual test here:
+                assert Pow(base, exp, evaluate=False).is_zero is is_zero
+
+    test_table(pow_iszero)
+
+    # A zero symbol...
+    zo, zo2 = symbols('zo, zo2', zero=True)
+
+    # All combinations of finite symbols
+    zf, zf2 = symbols('zf, zf2', finite=True)
+    wf, wf2 = symbols('wf, wf2', nonzero=True)
+    xf, xf2 = symbols('xf, xf2', real=True)
+    yf, yf2 = symbols('yf, yf2', nonzero=True)
+    af, af2 = symbols('af, af2', positive=True)
+    bf, bf2 = symbols('bf, bf2', nonnegative=True)
+    cf, cf2 = symbols('cf, cf2', negative=True)
+    df, df2 = symbols('df, df2', nonpositive=True)
+
+    # Without finiteness:
+    zi, zi2 = symbols('zi, zi2')
+    wi, wi2 = symbols('wi, wi2', zero=False)
+    xi, xi2 = symbols('xi, xi2', extended_real=True)
+    yi, yi2 = symbols('yi, yi2', zero=False, extended_real=True)
+    ai, ai2 = symbols('ai, ai2', extended_positive=True)
+    bi, bi2 = symbols('bi, bi2', extended_nonnegative=True)
+    ci, ci2 = symbols('ci, ci2', extended_negative=True)
+    di, di2 = symbols('di, di2', extended_nonpositive=True)
+
+    pow_iszero_sym = [
+        ['**',zo,wf,yf,af,cf,zf,xf,bf,df,zi,wi,xi,yi,ai,bi,ci,di],
+        [ zo2, F, N, N, T, F, N, N, N, F, N, N, N, N, T, N, F, F],
+        [ wf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ yf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ af2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ cf2, F, F, F, F, F, F, F, F, F, N, N, N, N, N, N, N, N],
+        [ zf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ xf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ bf2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ df2, N, N, N, N, F, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ zi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ wi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ xi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ yi2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ ai2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ bi2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N],
+        [ ci2, F, N, N, F, N, N, N, F, N, N, N, N, N, N, N, N, N],
+        [ di2, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N]
+    ]
+
+    test_table(pow_iszero_sym)
+
+    # In some cases (x**x).is_zero is different from (x**y).is_zero even if y
+    # has the same assumptions as x.
+    assert (zo ** zo).is_zero is False
+    assert (wf ** wf).is_zero is False
+    assert (yf ** yf).is_zero is False
+    assert (af ** af).is_zero is False
+    assert (cf ** cf).is_zero is False
+    assert (zf ** zf).is_zero is None
+    assert (xf ** xf).is_zero is None
+    assert (bf ** bf).is_zero is False # None in table
+    assert (df ** df).is_zero is None
+    assert (zi ** zi).is_zero is None
+    assert (wi ** wi).is_zero is None
+    assert (xi ** xi).is_zero is None
+    assert (yi ** yi).is_zero is None
+    assert (ai ** ai).is_zero is False # None in table
+    assert (bi ** bi).is_zero is False # None in table
+    assert (ci ** ci).is_zero is None
+    assert (di ** di).is_zero is None
+
+
+def test_Pow_is_nonpositive_nonnegative():
+    x = Symbol('x', real=True)
+
+    k = Symbol('k', integer=True, nonnegative=True)
+    l = Symbol('l', integer=True, positive=True)
+    n = Symbol('n', even=True)
+    m = Symbol('m', odd=True)
+
+    assert (x**(4*k)).is_nonnegative is True
+    assert (2**x).is_nonnegative is True
+    assert ((-2)**x).is_nonnegative is None
+    assert ((-2)**n).is_nonnegative is True
+    assert ((-2)**m).is_nonnegative is False
+
+    assert (k**2).is_nonnegative is True
+    assert (k**(-2)).is_nonnegative is None
+    assert (k**k).is_nonnegative is True
+
+    assert (k**x).is_nonnegative is None    # NOTE (0**x).is_real = U
+    assert (l**x).is_nonnegative is True
+    assert (l**x).is_positive is True
+    assert ((-k)**x).is_nonnegative is None
+
+    assert ((-k)**m).is_nonnegative is None
+
+    assert (2**x).is_nonpositive is False
+    assert ((-2)**x).is_nonpositive is None
+    assert ((-2)**n).is_nonpositive is False
+    assert ((-2)**m).is_nonpositive is True
+
+    assert (k**2).is_nonpositive is None
+    assert (k**(-2)).is_nonpositive is None
+
+    assert (k**x).is_nonpositive is None
+    assert ((-k)**x).is_nonpositive is None
+    assert ((-k)**n).is_nonpositive is None
+
+
+    assert (x**2).is_nonnegative is True
+    i = symbols('i', imaginary=True)
+    assert (i**2).is_nonpositive is True
+    assert (i**4).is_nonpositive is False
+    assert (i**3).is_nonpositive is False
+    assert (I**i).is_nonnegative is True
+    assert (exp(I)**i).is_nonnegative is True
+
+    assert ((-l)**n).is_nonnegative is True
+    assert ((-l)**m).is_nonpositive is True
+    assert ((-k)**n).is_nonnegative is None
+    assert ((-k)**m).is_nonpositive is None
+
+
+def test_Mul_is_imaginary_real():
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    i1 = Symbol('i1', imaginary=True)
+    i2 = Symbol('i2', imaginary=True)
+    x = Symbol('x')
+
+    assert I.is_imaginary is True
+    assert I.is_real is False
+    assert (-I).is_imaginary is True
+    assert (-I).is_real is False
+    assert (3*I).is_imaginary is True
+    assert (3*I).is_real is False
+    assert (I*I).is_imaginary is False
+    assert (I*I).is_real is True
+
+    e = (p + p*I)
+    j = Symbol('j', integer=True, zero=False)
+    assert (e**j).is_real is None
+    assert (e**(2*j)).is_real is None
+    assert (e**j).is_imaginary is None
+    assert (e**(2*j)).is_imaginary is None
+
+    assert (e**-1).is_imaginary is False
+    assert (e**2).is_imaginary
+    assert (e**3).is_imaginary is False
+    assert (e**4).is_imaginary is False
+    assert (e**5).is_imaginary is False
+    assert (e**-1).is_real is False
+    assert (e**2).is_real is False
+    assert (e**3).is_real is False
+    assert (e**4).is_real is True
+    assert (e**5).is_real is False
+    assert (e**3).is_complex
+
+    assert (r*i1).is_imaginary is None
+    assert (r*i1).is_real is None
+
+    assert (x*i1).is_imaginary is None
+    assert (x*i1).is_real is None
+
+    assert (i1*i2).is_imaginary is False
+    assert (i1*i2).is_real is True
+
+    assert (r*i1*i2).is_imaginary is False
+    assert (r*i1*i2).is_real is True
+
+    # Github's issue 5874:
+    nr = Symbol('nr', real=False, complex=True)  # e.g. I or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*nr).is_real is None
+    assert (a*nr).is_real is False
+    assert (b*nr).is_real is None
+
+    ni = Symbol('ni', imaginary=False, complex=True)  # e.g. 2 or 1 + I
+    a = Symbol('a', real=True, nonzero=True)
+    b = Symbol('b', real=True)
+    assert (i1*ni).is_real is False
+    assert (a*ni).is_real is None
+    assert (b*ni).is_real is None
+
+
+def test_Mul_hermitian_antihermitian():
+    xz, yz = symbols('xz, yz', zero=True, antihermitian=True)
+    xf, yf = symbols('xf, yf', hermitian=False, antihermitian=False, finite=True)
+    xh, yh = symbols('xh, yh', hermitian=True, antihermitian=False, nonzero=True)
+    xa, ya = symbols('xa, ya', hermitian=False, antihermitian=True, zero=False, finite=True)
+    assert (xz*xh).is_hermitian is True
+    assert (xz*xh).is_antihermitian is True
+    assert (xz*xa).is_hermitian is True
+    assert (xz*xa).is_antihermitian is True
+    assert (xf*yf).is_hermitian is None
+    assert (xf*yf).is_antihermitian is None
+    assert (xh*yh).is_hermitian is True
+    assert (xh*yh).is_antihermitian is False
+    assert (xh*ya).is_hermitian is False
+    assert (xh*ya).is_antihermitian is True
+    assert (xa*ya).is_hermitian is True
+    assert (xa*ya).is_antihermitian is False
+
+    a = Symbol('a', hermitian=True, zero=False)
+    b = Symbol('b', hermitian=True)
+    c = Symbol('c', hermitian=False)
+    d = Symbol('d', antihermitian=True)
+    e1 = Mul(a, b, c, evaluate=False)
+    e2 = Mul(b, a, c, evaluate=False)
+    e3 = Mul(a, b, c, d, evaluate=False)
+    e4 = Mul(b, a, c, d, evaluate=False)
+    e5 = Mul(a, c, evaluate=False)
+    e6 = Mul(a, c, d, evaluate=False)
+    assert e1.is_hermitian is None
+    assert e2.is_hermitian is None
+    assert e1.is_antihermitian is None
+    assert e2.is_antihermitian is None
+    assert e3.is_antihermitian is None
+    assert e4.is_antihermitian is None
+    assert e5.is_antihermitian is None
+    assert e6.is_antihermitian is None
+
+
+def test_Add_is_comparable():
+    assert (x + y).is_comparable is False
+    assert (x + 1).is_comparable is False
+    assert (Rational(1, 3) - sqrt(8)).is_comparable is True
+
+
+def test_Mul_is_comparable():
+    assert (x*y).is_comparable is False
+    assert (x*2).is_comparable is False
+    assert (sqrt(2)*Rational(1, 3)).is_comparable is True
+
+
+def test_Pow_is_comparable():
+    assert (x**y).is_comparable is False
+    assert (x**2).is_comparable is False
+    assert (sqrt(Rational(1, 3))).is_comparable is True
+
+
+def test_Add_is_positive_2():
+    e = Rational(1, 3) - sqrt(8)
+    assert e.is_positive is False
+    assert e.is_negative is True
+
+    e = pi - 1
+    assert e.is_positive is True
+    assert e.is_negative is False
+
+
+def test_Add_is_irrational():
+    i = Symbol('i', irrational=True)
+
+    assert i.is_irrational is True
+    assert i.is_rational is False
+
+    assert (i + 1).is_irrational is True
+    assert (i + 1).is_rational is False
+
+
+def test_Mul_is_irrational():
+    expr = Mul(1, 2, 3, evaluate=False)
+    assert expr.is_irrational is False
+    expr = Mul(1, I, I, evaluate=False)
+    assert expr.is_rational is None # I * I = -1 but *no evaluation allowed*
+    # sqrt(2) * I * I = -sqrt(2) is irrational but
+    # this can't be determined without evaluating the
+    # expression and the eval_is routines shouldn't do that
+    expr = Mul(sqrt(2), I, I, evaluate=False)
+    assert expr.is_irrational is None
+
+
+def test_issue_3531():
+    # https://github.com/sympy/sympy/issues/3531
+    # https://github.com/sympy/sympy/pull/18116
+    class MightyNumeric(tuple):
+        __slots__ = ()
+
+        def __rtruediv__(self, other):
+            return "something"
+
+    assert sympify(1)/MightyNumeric((1, 2)) == "something"
+
+
+def test_issue_3531b():
+    class Foo:
+        def __init__(self):
+            self.field = 1.0
+
+        def __mul__(self, other):
+            self.field = self.field * other
+
+        def __rmul__(self, other):
+            self.field = other * self.field
+    f = Foo()
+    x = Symbol("x")
+    assert f*x == x*f
+
+
+def test_bug3():
+    a = Symbol("a")
+    b = Symbol("b", positive=True)
+    e = 2*a + b
+    f = b + 2*a
+    assert e == f
+
+
+def test_suppressed_evaluation():
+    a = Add(0, 3, 2, evaluate=False)
+    b = Mul(1, 3, 2, evaluate=False)
+    c = Pow(3, 2, evaluate=False)
+    assert a != 6
+    assert a.func is Add
+    assert a.args == (0, 3, 2)
+    assert b != 6
+    assert b.func is Mul
+    assert b.args == (1, 3, 2)
+    assert c != 9
+    assert c.func is Pow
+    assert c.args == (3, 2)
+
+
+def test_AssocOp_doit():
+    a = Add(x,x, evaluate=False)
+    b = Mul(y,y, evaluate=False)
+    c = Add(b,b, evaluate=False)
+    d = Mul(a,a, evaluate=False)
+    assert c.doit(deep=False).func == Mul
+    assert c.doit(deep=False).args == (2,y,y)
+    assert c.doit().func == Mul
+    assert c.doit().args == (2, Pow(y,2))
+    assert d.doit(deep=False).func == Pow
+    assert d.doit(deep=False).args == (a, 2*S.One)
+    assert d.doit().func == Mul
+    assert d.doit().args == (4*S.One, Pow(x,2))
+
+
+def test_Add_Mul_Expr_args():
+    nonexpr = [Basic(), Poly(x, x), FiniteSet(x)]
+    for typ in [Add, Mul]:
+        for obj in nonexpr:
+            # The cache can mess with the stacklevel check
+            with warns(SymPyDeprecationWarning, test_stacklevel=False):
+                typ(obj, 1)
+
+
+def test_Add_as_coeff_mul():
+    # issue 5524.  These should all be (1, self)
+    assert (x + 1).as_coeff_mul() == (1, (x + 1,))
+    assert (x + 2).as_coeff_mul() == (1, (x + 2,))
+    assert (x + 3).as_coeff_mul() == (1, (x + 3,))
+
+    assert (x - 1).as_coeff_mul() == (1, (x - 1,))
+    assert (x - 2).as_coeff_mul() == (1, (x - 2,))
+    assert (x - 3).as_coeff_mul() == (1, (x - 3,))
+
+    n = Symbol('n', integer=True)
+    assert (n + 1).as_coeff_mul() == (1, (n + 1,))
+    assert (n + 2).as_coeff_mul() == (1, (n + 2,))
+    assert (n + 3).as_coeff_mul() == (1, (n + 3,))
+
+    assert (n - 1).as_coeff_mul() == (1, (n - 1,))
+    assert (n - 2).as_coeff_mul() == (1, (n - 2,))
+    assert (n - 3).as_coeff_mul() == (1, (n - 3,))
+
+
+def test_Pow_as_coeff_mul_doesnt_expand():
+    assert exp(x + y).as_coeff_mul() == (1, (exp(x + y),))
+    assert exp(x + exp(x + y)) != exp(x + exp(x)*exp(y))
+
+def test_issue_24751():
+    expr = Add(-2, -3, evaluate=False)
+    expr1 = Add(-1, expr, evaluate=False)
+    assert int(expr1) == int((-3 - 2) - 1)
+
+
+def test_issue_3514_18626():
+    assert sqrt(S.Half) * sqrt(6) == 2 * sqrt(3)/2
+    assert S.Half*sqrt(6)*sqrt(2) == sqrt(3)
+    assert sqrt(6)/2*sqrt(2) == sqrt(3)
+    assert sqrt(6)*sqrt(2)/2 == sqrt(3)
+    assert sqrt(8)**Rational(2, 3) == 2
+
+
+def test_make_args():
+    assert Add.make_args(x) == (x,)
+    assert Mul.make_args(x) == (x,)
+
+    assert Add.make_args(x*y*z) == (x*y*z,)
+    assert Mul.make_args(x*y*z) == (x*y*z).args
+
+    assert Add.make_args(x + y + z) == (x + y + z).args
+    assert Mul.make_args(x + y + z) == (x + y + z,)
+
+    assert Add.make_args((x + y)**z) == ((x + y)**z,)
+    assert Mul.make_args((x + y)**z) == ((x + y)**z,)
+
+
+def test_issue_5126():
+    assert (-2)**x*(-3)**x != 6**x
+    i = Symbol('i', integer=1)
+    assert (-2)**i*(-3)**i == 6**i
+
+
+def test_Rational_as_content_primitive():
+    c, p = S.One, S.Zero
+    assert (c*p).as_content_primitive() == (c, p)
+    c, p = S.Half, S.One
+    assert (c*p).as_content_primitive() == (c, p)
+
+
+def test_Add_as_content_primitive():
+    assert (x + 2).as_content_primitive() == (1, x + 2)
+
+    assert (3*x + 2).as_content_primitive() == (1, 3*x + 2)
+    assert (3*x + 3).as_content_primitive() == (3, x + 1)
+    assert (3*x + 6).as_content_primitive() == (3, x + 2)
+
+    assert (3*x + 2*y).as_content_primitive() == (1, 3*x + 2*y)
+    assert (3*x + 3*y).as_content_primitive() == (3, x + y)
+    assert (3*x + 6*y).as_content_primitive() == (3, x + 2*y)
+
+    assert (3/x + 2*x*y*z**2).as_content_primitive() == (1, 3/x + 2*x*y*z**2)
+    assert (3/x + 3*x*y*z**2).as_content_primitive() == (3, 1/x + x*y*z**2)
+    assert (3/x + 6*x*y*z**2).as_content_primitive() == (3, 1/x + 2*x*y*z**2)
+
+    assert (2*x/3 + 4*y/9).as_content_primitive() == \
+        (Rational(2, 9), 3*x + 2*y)
+    assert (2*x/3 + 2.5*y).as_content_primitive() == \
+        (Rational(1, 3), 2*x + 7.5*y)
+
+    # the coefficient may sort to a position other than 0
+    p = 3 + x + y
+    assert (2*p).expand().as_content_primitive() == (2, p)
+    assert (2.0*p).expand().as_content_primitive() == (1, 2.*p)
+    p *= -1
+    assert (2*p).expand().as_content_primitive() == (2, p)
+
+
+def test_Mul_as_content_primitive():
+    assert (2*x).as_content_primitive() == (2, x)
+    assert (x*(2 + 2*x)).as_content_primitive() == (2, x*(1 + x))
+    assert (x*(2 + 2*y)*(3*x + 3)**2).as_content_primitive() == \
+        (18, x*(1 + y)*(x + 1)**2)
+    assert ((2 + 2*x)**2*(3 + 6*x) + S.Half).as_content_primitive() == \
+        (S.Half, 24*(x + 1)**2*(2*x + 1) + 1)
+
+
+def test_Pow_as_content_primitive():
+    assert (x**y).as_content_primitive() == (1, x**y)
+    assert ((2*x + 2)**y).as_content_primitive() == \
+        (1, (Mul(2, (x + 1), evaluate=False))**y)
+    assert ((2*x + 2)**3).as_content_primitive() == (8, (x + 1)**3)
+
+
+def test_issue_5460():
+    u = Mul(2, (1 + x), evaluate=False)
+    assert (2 + u).args == (2, u)
+
+
+def test_product_irrational():
+    assert (I*pi).is_irrational is False
+    # The following used to be deduced from the above bug:
+    assert (I*pi).is_positive is False
+
+
+def test_issue_5919():
+    assert (x/(y*(1 + y))).expand() == x/(y**2 + y)
+
+
+def test_Mod():
+    assert Mod(x, 1).func is Mod
+    assert pi % pi is S.Zero
+    assert Mod(5, 3) == 2
+    assert Mod(-5, 3) == 1
+    assert Mod(5, -3) == -1
+    assert Mod(-5, -3) == -2
+    assert type(Mod(3.2, 2, evaluate=False)) == Mod
+    assert 5 % x == Mod(5, x)
+    assert x % 5 == Mod(x, 5)
+    assert x % y == Mod(x, y)
+    assert (x % y).subs({x: 5, y: 3}) == 2
+    assert Mod(nan, 1) is nan
+    assert Mod(1, nan) is nan
+    assert Mod(nan, nan) is nan
+
+    assert Mod(0, x) == 0
+    with raises(ZeroDivisionError):
+        Mod(x, 0)
+
+    k = Symbol('k', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    assert (x**m % x).func is Mod
+    assert (k**(-m) % k).func is Mod
+    assert k**m % k == 0
+    assert (-2*k)**m % k == 0
+
+    # Float handling
+    point3 = Float(3.3) % 1
+    assert (x - 3.3) % 1 == Mod(1.*x + 1 - point3, 1)
+    assert Mod(-3.3, 1) == 1 - point3
+    assert Mod(0.7, 1) == Float(0.7)
+    e = Mod(1.3, 1)
+    assert comp(e, .3) and e.is_Float
+    e = Mod(1.3, .7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(1.3, Rational(7, 10))
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), 0.7)
+    assert comp(e, .6) and e.is_Float
+    e = Mod(Rational(13, 10), Rational(7, 10))
+    assert comp(e, .6) and e.is_Rational
+
+    # check that sign is right
+    r2 = sqrt(2)
+    r3 = sqrt(3)
+    for i in [-r3, -r2, r2, r3]:
+        for j in [-r3, -r2, r2, r3]:
+            assert verify_numerically(i % j, i.n() % j.n())
+    for _x in range(4):
+        for _y in range(9):
+            reps = [(x, _x), (y, _y)]
+            assert Mod(3*x + y, 9).subs(reps) == (3*_x + _y) % 9
+
+    # denesting
+    t = Symbol('t', real=True)
+    assert Mod(Mod(x, t), t) == Mod(x, t)
+    assert Mod(-Mod(x, t), t) == Mod(-x, t)
+    assert Mod(Mod(x, 2*t), t) == Mod(x, t)
+    assert Mod(-Mod(x, 2*t), t) == Mod(-x, t)
+    assert Mod(Mod(x, t), 2*t) == Mod(x, t)
+    assert Mod(-Mod(x, t), -2*t) == -Mod(x, t)
+    for i in [-4, -2, 2, 4]:
+        for j in [-4, -2, 2, 4]:
+            for k in range(4):
+                assert Mod(Mod(x, i), j).subs({x: k}) == (k % i) % j
+                assert Mod(-Mod(x, i), j).subs({x: k}) == -(k % i) % j
+
+    # known difference
+    assert Mod(5*sqrt(2), sqrt(5)) == 5*sqrt(2) - 3*sqrt(5)
+    p = symbols('p', positive=True)
+    assert Mod(2, p + 3) == 2
+    assert Mod(-2, p + 3) == p + 1
+    assert Mod(2, -p - 3) == -p - 1
+    assert Mod(-2, -p - 3) == -2
+    assert Mod(p + 5, p + 3) == 2
+    assert Mod(-p - 5, p + 3) == p + 1
+    assert Mod(p + 5, -p - 3) == -p - 1
+    assert Mod(-p - 5, -p - 3) == -2
+    assert Mod(p + 1, p - 1).func is Mod
+
+    # issue 27749
+    n = symbols('n', integer=True, positive=True)
+    assert unchanged(Mod, 1, n)
+    n = symbols('n', prime=True)
+    assert Mod(1, n) == 1
+
+    # handling sums
+    assert (x + 3) % 1 == Mod(x, 1)
+    assert (x + 3.0) % 1 == Mod(1.*x, 1)
+    assert (x - S(33)/10) % 1 == Mod(x + S(7)/10, 1)
+
+    a = Mod(.6*x + y, .3*y)
+    b = Mod(0.1*y + 0.6*x, 0.3*y)
+    # Test that a, b are equal, with 1e-14 accuracy in coefficients
+    eps = 1e-14
+    assert abs((a.args[0] - b.args[0]).subs({x: 1, y: 1})) < eps
+    assert abs((a.args[1] - b.args[1]).subs({x: 1, y: 1})) < eps
+
+    assert (x + 1) % x == 1 % x
+    assert (x + y) % x == y % x
+    assert (x + y + 2) % x == (y + 2) % x
+    assert (a + 3*x + 1) % (2*x) == Mod(a + x + 1, 2*x)
+    assert (12*x + 18*y) % (3*x) == 3*Mod(6*y, x)
+
+    # gcd extraction
+    assert (-3*x) % (-2*y) == -Mod(3*x, 2*y)
+    assert (.6*pi) % (.3*x*pi) == 0.3*pi*Mod(2, x)
+    assert (.6*pi) % (.31*x*pi) == pi*Mod(0.6, 0.31*x)
+    assert (6*pi) % (.3*x*pi) == 0.3*pi*Mod(20, x)
+    assert (6*pi) % (.31*x*pi) == pi*Mod(6, 0.31*x)
+    assert (6*pi) % (.42*x*pi) == pi*Mod(6, 0.42*x)
+    assert (12*x) % (2*y) == 2*Mod(6*x, y)
+    assert (12*x) % (3*5*y) == 3*Mod(4*x, 5*y)
+    assert (12*x) % (15*x*y) == 3*x*Mod(4, 5*y)
+    assert (-2*pi) % (3*pi) == pi
+    assert (2*x + 2) % (x + 1) == 0
+    assert (x*(x + 1)) % (x + 1) == (x + 1)*Mod(x, 1)
+    assert Mod(5.0*x, 0.1*y) == 0.1*Mod(50*x, y)
+    i = Symbol('i', integer=True)
+    assert (3*i*x) % (2*i*y) == i*Mod(3*x, 2*y)
+    assert Mod(4*i, 4) == 0
+
+    # issue 8677
+    n = Symbol('n', integer=True, positive=True)
+    assert factorial(n) % n == 0
+    assert factorial(n + 2) % n == 0
+    assert (factorial(n + 4) % (n + 5)).func is Mod
+
+    # Wilson's theorem
+    assert factorial(18042, evaluate=False) % 18043 == 18042
+    p = Symbol('n', prime=True)
+    assert factorial(p - 1) % p == p - 1
+    assert factorial(p - 1) % -p == -1
+    assert (factorial(3, evaluate=False) % 4).doit() == 2
+    n = Symbol('n', composite=True, odd=True)
+    assert factorial(n - 1) % n == 0
+
+    # symbolic with known parity
+    n = Symbol('n', even=True)
+    assert Mod(n, 2) == 0
+    n = Symbol('n', odd=True)
+    assert Mod(n, 2) == 1
+
+    # issue 10963
+    assert (x**6000%400).args[1] == 400
+
+    #issue 13543
+    assert Mod(Mod(x + 1, 2) + 1, 2) == Mod(x, 2)
+
+    x1 = Symbol('x1', integer=True)
+    assert Mod(Mod(x1 + 2, 4)*(x1 + 4), 4) == Mod(x1*(x1 + 2), 4)
+    assert Mod(Mod(x1 + 2, 4)*4, 4) == 0
+
+    # issue 15493
+    i, j = symbols('i j', integer=True, positive=True)
+    assert Mod(3*i, 2) == Mod(i, 2)
+    assert Mod(8*i/j, 4) == 4*Mod(2*i/j, 1)
+    assert Mod(8*i, 4) == 0
+
+    # rewrite
+    assert Mod(x, y).rewrite(floor) == x - y*floor(x/y)
+    assert ((x - Mod(x, y))/y).rewrite(floor) == floor(x/y)
+
+    # issue 21373
+    from sympy.functions.elementary.hyperbolic import sinh
+    from sympy.functions.elementary.piecewise import Piecewise
+
+    x_r, y_r = symbols('x_r y_r', real=True)
+    assert (Piecewise((x_r, y_r > x_r), (y_r, True)) / z) % 1
+    expr = exp(sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) / z))
+    expr.subs({1: 1.0})
+    sinh(Piecewise((x_r, y_r > x_r), (y_r, True)) * z ** -1.0).is_zero
+
+    # issue 24215
+    from sympy.abc import phi
+    assert Mod(4.0*Mod(phi, 1) , 2) == 2.0*(Mod(2*(Mod(phi, 1)), 1))
+
+    xi = symbols('x', integer=True)
+    assert unchanged(Mod, xi, 2)
+    assert Mod(3*xi, 2) == Mod(xi, 2)
+    assert unchanged(Mod, 3*x, 2)
+
+
+def test_Mod_Pow():
+    # modular exponentiation
+    assert isinstance(Mod(Pow(2, 2, evaluate=False), 3), Integer)
+
+    assert Mod(Pow(4, 13, evaluate=False), 497) == Mod(Pow(4, 13), 497)
+    assert Mod(Pow(2, 10000000000, evaluate=False), 3) == 1
+    assert Mod(Pow(32131231232, 9**10**6, evaluate=False),10**12) == \
+        pow(32131231232,9**10**6,10**12)
+    assert Mod(Pow(33284959323, 123**999, evaluate=False),11**13) == \
+        pow(33284959323,123**999,11**13)
+    assert Mod(Pow(78789849597, 333**555, evaluate=False),12**9) == \
+        pow(78789849597,333**555,12**9)
+
+    # modular nested exponentiation
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 32191
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 18016
+    expr = Pow(2, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 5137
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 16
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 6487
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 38281
+    expr = Pow(expr, 2, evaluate=False)
+    assert Mod(expr, 3**10) == 15928
+
+    expr = Pow(2, 2, evaluate=False)
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 256
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 9229
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 25708
+    expr = Pow(expr, expr, evaluate=False)
+    assert Mod(expr, 3**10) == 26608
+    expr = Pow(expr, expr, evaluate=False)
+    # XXX This used to fail in a nondeterministic way because of overflow
+    # error.
+    assert Mod(expr, 3**10) == 1966
+
+
+def test_Mod_is_integer():
+    p = Symbol('p', integer=True)
+    q1 = Symbol('q1', integer=True)
+    q2 = Symbol('q2', integer=True, nonzero=True)
+    assert Mod(x, y).is_integer is None
+    assert Mod(p, q1).is_integer is None
+    assert Mod(x, q2).is_integer is None
+    assert Mod(p, q2).is_integer
+
+
+def test_Mod_is_nonposneg():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert (n%3).is_nonnegative
+    assert Mod(n, -3).is_nonpositive
+    assert Mod(n, k).is_nonnegative
+    assert Mod(n, -k).is_nonpositive
+    assert Mod(k, n).is_nonnegative is None
+
+
+def test_issue_6001():
+    A = Symbol("A", commutative=False)
+    eq = A + A**2
+    # it doesn't matter whether it's True or False; they should
+    # just all be the same
+    assert (
+        eq.is_commutative ==
+        (eq + 1).is_commutative ==
+        (A + 1).is_commutative)
+
+    B = Symbol("B", commutative=False)
+    # Although commutative terms could cancel we return True
+    # meaning "there are non-commutative symbols; aftersubstitution
+    # that definition can change, e.g. (A*B).subs(B,A**-1) -> 1
+    assert (sqrt(2)*A).is_commutative is False
+    assert (sqrt(2)*A*B).is_commutative is False
+
+
+def test_polar():
+    from sympy.functions.elementary.complexes import polar_lift
+    p = Symbol('p', polar=True)
+    x = Symbol('x')
+    assert p.is_polar
+    assert x.is_polar is None
+    assert S.One.is_polar is None
+    assert (p**x).is_polar is True
+    assert (x**p).is_polar is None
+    assert ((2*p)**x).is_polar is True
+    assert (2*p).is_polar is True
+    assert (-2*p).is_polar is not True
+    assert (polar_lift(-2)*p).is_polar is True
+
+    q = Symbol('q', polar=True)
+    assert (p*q)**2 == p**2 * q**2
+    assert (2*q)**2 == 4 * q**2
+    assert ((p*q)**x).expand() == p**x * q**x
+
+
+def test_issue_6040():
+    a, b = Pow(1, 2, evaluate=False), S.One
+    assert a != b
+    assert b != a
+    assert not (a == b)
+    assert not (b == a)
+
+
+def test_issue_6082():
+    # Comparison is symmetric
+    assert Basic.compare(Max(x, 1), Max(x, 2)) == \
+      - Basic.compare(Max(x, 2), Max(x, 1))
+    # Equal expressions compare equal
+    assert Basic.compare(Max(x, 1), Max(x, 1)) == 0
+    # Basic subtypes (such as Max) compare different than standard types
+    assert Basic.compare(Max(1, x), frozenset((1, x))) != 0
+
+
+def test_issue_6077():
+    assert x**2.0/x == x**1.0
+    assert x/x**2.0 == x**-1.0
+    assert x*x**2.0 == x**3.0
+    assert x**1.5*x**2.5 == x**4.0
+
+    assert 2**(2.0*x)/2**x == 2**(1.0*x)
+    assert 2**x/2**(2.0*x) == 2**(-1.0*x)
+    assert 2**x*2**(2.0*x) == 2**(3.0*x)
+    assert 2**(1.5*x)*2**(2.5*x) == 2**(4.0*x)
+
+
+def test_mul_flatten_oo():
+    p = symbols('p', positive=True)
+    n, m = symbols('n,m', negative=True)
+    x_im = symbols('x_im', imaginary=True)
+    assert n*oo is -oo
+    assert n*m*oo is oo
+    assert p*oo is oo
+    assert x_im*oo != I*oo  # i could be +/- 3*I -> +/-oo
+
+
+def test_add_flatten():
+    # see https://github.com/sympy/sympy/issues/2633#issuecomment-29545524
+    a = oo + I*oo
+    b = oo - I*oo
+    assert a + b is nan
+    assert a - b is nan
+    # FIXME: This evaluates as:
+    #   >>> 1/a
+    #   0*(oo + oo*I)
+    # which should not simplify to 0. Should be fixed in Pow.eval
+    #assert (1/a).simplify() == (1/b).simplify() == 0
+
+    a = Pow(2, 3, evaluate=False)
+    assert a + a == 16
+
+
+def test_issue_5160_6087_6089_6090():
+    # issue 6087
+    assert ((-2*x*y**y)**3.2).n(2) == (2**3.2*(-x*y**y)**3.2).n(2)
+    # issue 6089
+    A, B, C = symbols('A,B,C', commutative=False)
+    assert (2.*B*C)**3 == 8.0*(B*C)**3
+    assert (-2.*B*C)**3 == -8.0*(B*C)**3
+    assert (-2*B*C)**2 == 4*(B*C)**2
+    # issue 5160
+    assert sqrt(-1.0*x) == 1.0*sqrt(-x)
+    assert sqrt(1.0*x) == 1.0*sqrt(x)
+    # issue 6090
+    assert (-2*x*y*A*B)**2 == 4*x**2*y**2*(A*B)**2
+
+
+def test_float_int_round():
+    assert int(float(sqrt(10))) == int(sqrt(10))
+    assert int(pi**1000) % 10 == 2
+    assert int(Float('1.123456789012345678901234567890e20', '')) == \
+        int(112345678901234567890)
+    assert int(Float('1.123456789012345678901234567890e25', '')) == \
+        int(11234567890123456789012345)
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert int(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert int(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert Integer(Float('1.123456789012345678901234567890e20', '')) == \
+        112345678901234567890
+    assert Integer(Float('1.123456789012345678901234567890e25', '')) == \
+        11234567890123456789012345
+    # decimal forces float so it's not an exact integer ending in 000000
+    assert Integer(Float('1.123456789012345678901234567890e35', '')) == \
+        112345678901234567890123456789000192
+    assert Integer(Float('123456789012345678901234567890e5', '')) == \
+        12345678901234567890123456789000000
+    assert same_and_same_prec(Float('123000e-2',''), Float('1230.00', ''))
+    assert same_and_same_prec(Float('123000e2',''), Float('12300000', ''))
+
+    assert int(1 + Rational('.9999999999999999999999999')) == 1
+    assert int(pi/1e20) == 0
+    assert int(1 + pi/1e20) == 1
+    assert int(Add(1.2, -2, evaluate=False)) == int(1.2 - 2)
+    assert int(Add(1.2, +2, evaluate=False)) == int(1.2 + 2)
+    assert int(Add(1 + Float('.99999999999999999', ''), evaluate=False)) == 1
+    raises(TypeError, lambda: float(x))
+    raises(TypeError, lambda: float(sqrt(-1)))
+
+    assert int(12345678901234567890 + cos(1)**2 + sin(1)**2) == \
+        12345678901234567891
+
+
+def test_issue_6611a():
+    assert Mul.flatten([3**Rational(1, 3),
+        Pow(-Rational(1, 9), Rational(2, 3), evaluate=False)]) == \
+        ([Rational(1, 3), (-1)**Rational(2, 3)], [], None)
+
+
+def test_denest_add_mul():
+    # when working with evaluated expressions make sure they denest
+    eq = x + 1
+    eq = Add(eq, 2, evaluate=False)
+    eq = Add(eq, 2, evaluate=False)
+    assert Add(*eq.args) == x + 5
+    eq = x*2
+    eq = Mul(eq, 2, evaluate=False)
+    eq = Mul(eq, 2, evaluate=False)
+    assert Mul(*eq.args) == 8*x
+    # but don't let them denest unnecessarily
+    eq = Mul(-2, x - 2, evaluate=False)
+    assert 2*eq == Mul(-4, x - 2, evaluate=False)
+    assert -eq == Mul(2, x - 2, evaluate=False)
+
+
+def test_mul_coeff():
+    # It is important that all Numbers be removed from the seq;
+    # This can be tricky when powers combine to produce those numbers
+    p = exp(I*pi/3)
+    assert p**2*x*p*y*p*x*p**2 == x**2*y
+
+
+def test_mul_zero_detection():
+    nz = Dummy(real=True, zero=False)
+    r = Dummy(extended_real=True)
+    c = Dummy(real=False, complex=True)
+    c2 = Dummy(real=False, complex=True)
+    i = Dummy(imaginary=True)
+    e = nz*r*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+    e = nz*c
+    assert e.is_imaginary is None
+    assert e.is_extended_real is False
+    e = nz*i*c
+    assert e.is_imaginary is False
+    assert e.is_extended_real is None
+    # check for more than one complex; it is important to use
+    # uniquely named Symbols to ensure that two factors appear
+    # e.g. if the symbols have the same name they just become
+    # a single factor, a power.
+    e = nz*i*c*c2
+    assert e.is_imaginary is None
+    assert e.is_extended_real is None
+
+    # _eval_is_extended_real and _eval_is_zero both employ trapping of the
+    # zero value so args should be tested in both directions and
+    # TO AVOID GETTING THE CACHED RESULT, Dummy MUST BE USED
+
+    # real is unknown
+    def test(z, b, e):
+        if z.is_zero and b.is_finite:
+            assert e.is_extended_real and e.is_zero
+        else:
+            assert e.is_extended_real is None
+            if b.is_finite:
+                if z.is_zero:
+                    assert e.is_zero
+                else:
+                    assert e.is_zero is None
+            elif b.is_finite is False:
+                if z.is_zero is None:
+                    assert e.is_zero is None
+                else:
+                    assert e.is_zero is False
+
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('nz', nonzero=iz)
+        b = Dummy('f', finite=ib)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+    # real is True
+    def test(z, b, e):
+        if z.is_zero and not b.is_finite:
+            assert e.is_extended_real is None
+        else:
+            assert e.is_extended_real is True
+
+    for iz, ib in product(*[[True, False, None]]*2):
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(z, b, evaluate=False)
+        test(z, b, e)
+        z = Dummy('z', nonzero=iz, extended_real=True)
+        b = Dummy('b', finite=ib, extended_real=True)
+        e = Mul(b, z, evaluate=False)
+        test(z, b, e)
+
+
+def test_Mul_with_zero_infinite():
+    zer = Dummy(zero=True)
+    inf = Dummy(finite=False)
+
+    e = Mul(zer, inf, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+    e = Mul(inf, zer, evaluate=False)
+    assert e.is_extended_positive is None
+    assert e.is_hermitian is None
+
+
+def test_Mul_does_not_cancel_infinities():
+    a, b = symbols('a b')
+    assert ((zoo + 3*a)/(3*a + zoo)) is nan
+    assert ((b - oo)/(b - oo)) is nan
+    # issue 13904
+    expr = (1/(a+b) + 1/(a-b))/(1/(a+b) - 1/(a-b))
+    assert expr.subs(b, a) is nan
+
+
+def test_Mul_does_not_distribute_infinity():
+    a, b = symbols('a b')
+    assert ((1 + I)*oo).is_Mul
+    assert ((a + b)*(-oo)).is_Mul
+    assert ((a + 1)*zoo).is_Mul
+    assert ((1 + I)*oo).is_finite is False
+    z = (1 + I)*oo
+    assert ((1 - I)*z).expand() is oo
+
+
+def test_Mul_does_not_let_0_trump_inf():
+    assert Mul(*[0, a + zoo]) is S.NaN
+    assert Mul(*[0, a + oo]) is S.NaN
+    assert Mul(*[0, a + Integral(1/x**2, (x, 1, oo))]) is S.Zero
+    # Integral is treated like an unknown like 0*x -> 0
+    assert Mul(*[0, a + Integral(x, (x, 1, oo))]) is S.Zero
+
+
+def test_issue_8247_8354():
+    from sympy.functions.elementary.trigonometric import tan
+    z = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert z.is_positive is False  # it's 0
+    z = S('''-2**(1/3)*(3*sqrt(93) + 29)**2 - 4*(3*sqrt(93) + 29)**(4/3) +
+        12*sqrt(93)*(3*sqrt(93) + 29)**(1/3) + 116*(3*sqrt(93) + 29)**(1/3) +
+        174*2**(1/3)*sqrt(93) + 1678*2**(1/3)''')
+    assert z.is_positive is False  # it's 0
+    z = 2*(-3*tan(19*pi/90) + sqrt(3))*cos(11*pi/90)*cos(19*pi/90) - \
+        sqrt(3)*(-3 + 4*cos(19*pi/90)**2)
+    assert z.is_positive is not True  # it's zero and it shouldn't hang
+    z = S('''9*(3*sqrt(93) + 29)**(2/3)*((3*sqrt(93) +
+        29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) - 2) - 2*2**(1/3))**3 +
+        72*(3*sqrt(93) + 29)**(2/3)*(81*sqrt(93) + 783) + (162*sqrt(93) +
+        1566)*((3*sqrt(93) + 29)**(1/3)*(-2**(2/3)*(3*sqrt(93) + 29)**(1/3) -
+        2) - 2*2**(1/3))**2''')
+    assert z.is_positive is False  # it's 0 (and a single _mexpand isn't enough)
+
+
+def test_Add_is_zero():
+    x, y = symbols('x y', zero=True)
+    assert (x + y).is_zero
+
+    # Issue 15873
+    e = -2*I + (1 + I)**2
+    assert e.is_zero is None
+
+
+def test_issue_14392():
+    assert (sin(zoo)**2).as_real_imag() == (nan, nan)
+
+
+def test_divmod():
+    assert divmod(x, y) == (x//y, x % y)
+    assert divmod(x, 3) == (x//3, x % 3)
+    assert divmod(3, x) == (3//x, 3 % x)
+
+
+def test__neg__():
+    assert -(x*y) == -x*y
+    assert -(-x*y) == x*y
+    assert -(1.*x) == -1.*x
+    assert -(-1.*x) == 1.*x
+    assert -(2.*x) == -2.*x
+    assert -(-2.*x) == 2.*x
+    with distribute(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+    with evaluate(False):
+        eq = -(x + y)
+        assert eq.is_Mul and eq.args == (-1, x + y)
+
+
+def test_issue_18507():
+    assert Mul(zoo, zoo, 0) is nan
+
+
+def test_issue_17130():
+    e = Add(b, -b, I, -I, evaluate=False)
+    assert e.is_zero is None # ideally this would be True
+
+
+def test_issue_21034():
+    e = -I*log((re(asin(5)) + I*im(asin(5)))/sqrt(re(asin(5))**2 + im(asin(5))**2))/pi
+    assert e.round(2)
+
+
+def test_issue_22021():
+    from sympy.calculus.accumulationbounds import AccumBounds
+    # these objects are special cases in Mul
+    from sympy.tensor.tensor import TensorIndexType, tensor_indices, tensor_heads
+    L = TensorIndexType("L")
+    i = tensor_indices("i", L)
+    A, B = tensor_heads("A B", [L])
+    e = A(i) + B(i)
+    assert -e == -1*e
+    e = zoo + x
+    assert -e == -1*e
+    a = AccumBounds(1, 2)
+    e = a + x
+    assert -e == -1*e
+    for args in permutations((zoo, a, x)):
+        e = Add(*args, evaluate=False)
+        assert -e == -1*e
+    assert 2*Add(1, x, x, evaluate=False) == 4*x + 2
+
+
+def test_issue_22244():
+    assert -(zoo*x) == zoo*x
+
+
+def test_issue_22453():
+    from sympy.utilities.iterables import cartes
+    e = Symbol('e', extended_positive=True)
+    for a, b in cartes(*[[oo, -oo, 3]]*2):
+        if a == b == 3:
+            continue
+        i = a + I*b
+        assert i**(1 + e) is S.ComplexInfinity
+        assert i**-e is S.Zero
+        assert unchanged(Pow, i, e)
+    assert 1/(oo + I*oo) is S.Zero
+    r, i = [Dummy(infinite=True, extended_real=True) for _ in range(2)]
+    assert 1/(r + I*i) is S.Zero
+    assert 1/(3 + I*i) is S.Zero
+    assert 1/(r + I*3) is S.Zero
+
+
+def test_issue_22613():
+    assert (0**(x - 2)).as_content_primitive() == (1, 0**(x - 2))
+    assert (0**(x + 2)).as_content_primitive() == (1, 0**(x + 2))
+
+
+def test_issue_25176():
+    assert sqrt(-4*3**(S(3)/4)*I/3) == 2*3**(S(7)/8)*sqrt(-I)/3
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_assumptions.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_assumptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..574e90178fb489fe99c99ea0c72df57ceec4b249
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_assumptions.py
@@ -0,0 +1,1335 @@
+from sympy.core.mod import Mod
+from sympy.core.numbers import (I, oo, pi)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, sin)
+from sympy.simplify.simplify import simplify
+from sympy.core import Symbol, S, Rational, Integer, Dummy, Wild, Pow
+from sympy.core.assumptions import (assumptions, check_assumptions,
+    failing_assumptions, common_assumptions, _generate_assumption_rules,
+    _load_pre_generated_assumption_rules)
+from sympy.core.facts import InconsistentAssumptions
+from sympy.core.random import seed
+from sympy.combinatorics import Permutation
+from sympy.combinatorics.perm_groups import PermutationGroup
+
+from sympy.testing.pytest import raises, XFAIL
+
+
+def test_symbol_unset():
+    x = Symbol('x', real=True, integer=True)
+    assert x.is_real is True
+    assert x.is_integer is True
+    assert x.is_imaginary is False
+    assert x.is_noninteger is False
+    assert x.is_number is False
+
+
+def test_zero():
+    z = Integer(0)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is True
+    assert z.is_even is True
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_one():
+    z = Integer(1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_number is True
+    assert z.is_composite is False  # issue 8807
+
+
+def test_negativeone():
+    z = Integer(-1)
+    assert z.is_commutative is True
+    assert z.is_integer is True
+    assert z.is_rational is True
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is False
+    assert z.is_positive is False
+    assert z.is_negative is True
+    assert z.is_nonpositive is True
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is True
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+    assert z.is_number is True
+
+
+def test_infinity():
+    oo = S.Infinity
+
+    assert oo.is_commutative is True
+    assert oo.is_integer is False
+    assert oo.is_rational is False
+    assert oo.is_algebraic is False
+    assert oo.is_transcendental is False
+    assert oo.is_extended_real is True
+    assert oo.is_real is False
+    assert oo.is_complex is False
+    assert oo.is_noninteger is True
+    assert oo.is_irrational is False
+    assert oo.is_imaginary is False
+    assert oo.is_nonzero is False
+    assert oo.is_positive is False
+    assert oo.is_negative is False
+    assert oo.is_nonpositive is False
+    assert oo.is_nonnegative is False
+    assert oo.is_extended_nonzero is True
+    assert oo.is_extended_positive is True
+    assert oo.is_extended_negative is False
+    assert oo.is_extended_nonpositive is False
+    assert oo.is_extended_nonnegative is True
+    assert oo.is_even is False
+    assert oo.is_odd is False
+    assert oo.is_finite is False
+    assert oo.is_infinite is True
+    assert oo.is_comparable is True
+    assert oo.is_prime is False
+    assert oo.is_composite is False
+    assert oo.is_number is True
+
+
+def test_neg_infinity():
+    mm = S.NegativeInfinity
+
+    assert mm.is_commutative is True
+    assert mm.is_integer is False
+    assert mm.is_rational is False
+    assert mm.is_algebraic is False
+    assert mm.is_transcendental is False
+    assert mm.is_extended_real is True
+    assert mm.is_real is False
+    assert mm.is_complex is False
+    assert mm.is_noninteger is True
+    assert mm.is_irrational is False
+    assert mm.is_imaginary is False
+    assert mm.is_nonzero is False
+    assert mm.is_positive is False
+    assert mm.is_negative is False
+    assert mm.is_nonpositive is False
+    assert mm.is_nonnegative is False
+    assert mm.is_extended_nonzero is True
+    assert mm.is_extended_positive is False
+    assert mm.is_extended_negative is True
+    assert mm.is_extended_nonpositive is True
+    assert mm.is_extended_nonnegative is False
+    assert mm.is_even is False
+    assert mm.is_odd is False
+    assert mm.is_finite is False
+    assert mm.is_infinite is True
+    assert mm.is_comparable is True
+    assert mm.is_prime is False
+    assert mm.is_composite is False
+    assert mm.is_number is True
+
+
+def test_zoo():
+    zoo = S.ComplexInfinity
+    assert zoo.is_complex is False
+    assert zoo.is_real is False
+    assert zoo.is_prime is False
+
+
+def test_nan():
+    nan = S.NaN
+
+    assert nan.is_commutative is True
+    assert nan.is_integer is None
+    assert nan.is_rational is None
+    assert nan.is_algebraic is None
+    assert nan.is_transcendental is None
+    assert nan.is_real is None
+    assert nan.is_complex is None
+    assert nan.is_noninteger is None
+    assert nan.is_irrational is None
+    assert nan.is_imaginary is None
+    assert nan.is_positive is None
+    assert nan.is_negative is None
+    assert nan.is_nonpositive is None
+    assert nan.is_nonnegative is None
+    assert nan.is_even is None
+    assert nan.is_odd is None
+    assert nan.is_finite is None
+    assert nan.is_infinite is None
+    assert nan.is_comparable is False
+    assert nan.is_prime is None
+    assert nan.is_composite is None
+    assert nan.is_number is True
+
+
+def test_pos_rational():
+    r = Rational(3, 4)
+    assert r.is_commutative is True
+    assert r.is_integer is False
+    assert r.is_rational is True
+    assert r.is_algebraic is True
+    assert r.is_transcendental is False
+    assert r.is_real is True
+    assert r.is_complex is True
+    assert r.is_noninteger is True
+    assert r.is_irrational is False
+    assert r.is_imaginary is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    assert r.is_even is False
+    assert r.is_odd is False
+    assert r.is_finite is True
+    assert r.is_infinite is False
+    assert r.is_comparable is True
+    assert r.is_prime is False
+    assert r.is_composite is False
+
+    r = Rational(1, 4)
+    assert r.is_nonpositive is False
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 4)
+    assert r.is_negative is False
+    assert r.is_positive is True
+    assert r.is_nonpositive is False
+    assert r.is_nonnegative is True
+    r = Rational(5, 3)
+    assert r.is_nonnegative is True
+    assert r.is_positive is True
+    assert r.is_negative is False
+    assert r.is_nonpositive is False
+
+
+def test_neg_rational():
+    r = Rational(-3, 4)
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-1, 4)
+    assert r.is_nonpositive is True
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 4)
+    assert r.is_negative is True
+    assert r.is_positive is False
+    assert r.is_nonpositive is True
+    assert r.is_nonnegative is False
+    r = Rational(-5, 3)
+    assert r.is_nonnegative is False
+    assert r.is_positive is False
+    assert r.is_negative is True
+    assert r.is_nonpositive is True
+
+
+def test_pi():
+    z = S.Pi
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_E():
+    z = S.Exp1
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is False
+    assert z.is_transcendental is True
+    assert z.is_real is True
+    assert z.is_complex is True
+    assert z.is_noninteger is True
+    assert z.is_irrational is True
+    assert z.is_imaginary is False
+    assert z.is_positive is True
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is True
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is True
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_I():
+    z = S.ImaginaryUnit
+    assert z.is_commutative is True
+    assert z.is_integer is False
+    assert z.is_rational is False
+    assert z.is_algebraic is True
+    assert z.is_transcendental is False
+    assert z.is_real is False
+    assert z.is_complex is True
+    assert z.is_noninteger is False
+    assert z.is_irrational is False
+    assert z.is_imaginary is True
+    assert z.is_positive is False
+    assert z.is_negative is False
+    assert z.is_nonpositive is False
+    assert z.is_nonnegative is False
+    assert z.is_even is False
+    assert z.is_odd is False
+    assert z.is_finite is True
+    assert z.is_infinite is False
+    assert z.is_comparable is False
+    assert z.is_prime is False
+    assert z.is_composite is False
+
+
+def test_symbol_real_false():
+    # issue 3848
+    a = Symbol('a', real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is None
+    assert a.is_extended_positive is None
+    assert a.is_extended_nonnegative is None
+    assert a.is_extended_nonpositive is None
+    assert a.is_extended_nonzero is None
+
+
+def test_symbol_extended_real_false():
+    # issue 3848
+    a = Symbol('a', extended_real=False)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_zero is False
+
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_nonzero is False
+
+    assert a.is_extended_negative is False
+    assert a.is_extended_positive is False
+    assert a.is_extended_nonnegative is False
+    assert a.is_extended_nonpositive is False
+    assert a.is_extended_nonzero is False
+
+
+def test_symbol_imaginary():
+    a = Symbol('a', imaginary=True)
+
+    assert a.is_real is False
+    assert a.is_integer is False
+    assert a.is_negative is False
+    assert a.is_positive is False
+    assert a.is_nonnegative is False
+    assert a.is_nonpositive is False
+    assert a.is_zero is False
+    assert a.is_nonzero is False  # since nonzero -> real
+
+
+def test_symbol_zero():
+    x = Symbol('x', zero=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive
+    assert x.is_negative is False
+    assert x.is_nonnegative
+    assert x.is_zero is True
+    # TODO Change to x.is_nonzero is None
+    # See https://github.com/sympy/sympy/pull/9583
+    assert x.is_nonzero is False
+    assert x.is_finite is True
+
+
+def test_symbol_positive():
+    x = Symbol('x', positive=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_positive():
+    x = -Symbol('x', positive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_symbol_nonpositive():
+    x = Symbol('x', nonpositive=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_nonpositive():
+    x = -Symbol('x', nonpositive=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive():
+    x = Symbol('x', positive=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_mul():
+    # To test pull request 9379
+    # Explicit handling of arg.is_positive=False was added to Mul._eval_is_positive
+    x = 2*Symbol('x', positive=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_symbol_infinitereal_mul():
+    ix = Symbol('ix', infinite=True, extended_real=True)
+    assert (-ix).is_extended_positive is None
+
+
+def test_neg_symbol_falsepositive():
+    x = -Symbol('x', positive=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsenegative():
+    # To test pull request 9379
+    # Explicit handling of arg.is_negative=False was added to Mul._eval_is_positive
+    x = -Symbol('x', negative=False)
+    assert x.is_positive is False  # This was None before
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsepositive_real():
+    x = Symbol('x', positive=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is None
+    assert x.is_nonnegative is None
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_neg_symbol_falsepositive_real():
+    x = -Symbol('x', positive=False, real=True)
+    assert x.is_positive is None
+    assert x.is_nonpositive is None
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is None
+    assert x.is_nonzero is None
+
+
+def test_symbol_falsenonnegative():
+    x = Symbol('x', nonnegative=False)
+    assert x.is_positive is False
+    assert x.is_nonpositive is None
+    assert x.is_negative is None
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is None
+
+
+@XFAIL
+def test_neg_symbol_falsenonnegative():
+    x = -Symbol('x', nonnegative=False)
+    assert x.is_positive is None
+    assert x.is_nonpositive is False  # this currently returns None
+    assert x.is_negative is False  # this currently returns None
+    assert x.is_nonnegative is None
+    assert x.is_zero is False  # this currently returns None
+    assert x.is_nonzero is True  # this currently returns None
+
+
+def test_symbol_falsenonnegative_real():
+    x = Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is False
+    assert x.is_nonpositive is True
+    assert x.is_negative is True
+    assert x.is_nonnegative is False
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_neg_symbol_falsenonnegative_real():
+    x = -Symbol('x', nonnegative=False, real=True)
+    assert x.is_positive is True
+    assert x.is_nonpositive is False
+    assert x.is_negative is False
+    assert x.is_nonnegative is True
+    assert x.is_zero is False
+    assert x.is_nonzero is True
+
+
+def test_prime():
+    assert S.NegativeOne.is_prime is False
+    assert S(-2).is_prime is False
+    assert S(-4).is_prime is False
+    assert S.Zero.is_prime is False
+    assert S.One.is_prime is False
+    assert S(2).is_prime is True
+    assert S(17).is_prime is True
+    assert S(4).is_prime is False
+
+
+def test_composite():
+    assert S.NegativeOne.is_composite is False
+    assert S(-2).is_composite is False
+    assert S(-4).is_composite is False
+    assert S.Zero.is_composite is False
+    assert S(2).is_composite is False
+    assert S(17).is_composite is False
+    assert S(4).is_composite is True
+    x = Dummy(integer=True, positive=True, prime=False)
+    assert x.is_composite is None # x could be 1
+    assert (x + 1).is_composite is None
+    x = Dummy(positive=True, even=True, prime=False)
+    assert x.is_integer is True
+    assert x.is_composite is True
+
+
+def test_prime_symbol():
+    x = Symbol('x', prime=True)
+    assert x.is_prime is True
+    assert x.is_integer is True
+    assert x.is_positive is True
+    assert x.is_negative is False
+    assert x.is_nonpositive is False
+    assert x.is_nonnegative is True
+
+    x = Symbol('x', prime=False)
+    assert x.is_prime is False
+    assert x.is_integer is None
+    assert x.is_positive is None
+    assert x.is_negative is None
+    assert x.is_nonpositive is None
+    assert x.is_nonnegative is None
+
+
+def test_symbol_noncommutative():
+    x = Symbol('x', commutative=True)
+    assert x.is_complex is None
+
+    x = Symbol('x', commutative=False)
+    assert x.is_integer is False
+    assert x.is_rational is False
+    assert x.is_algebraic is False
+    assert x.is_irrational is False
+    assert x.is_real is False
+    assert x.is_complex is False
+
+
+def test_other_symbol():
+    x = Symbol('x', integer=True)
+    assert x.is_integer is True
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_negative is False
+    assert x.is_positive is None
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_positive is False
+    assert x.is_negative is None
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=True)
+    assert x.is_odd is True
+    assert x.is_even is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', odd=False)
+    assert x.is_odd is False
+    assert x.is_even is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', even=True)
+    assert x.is_even is True
+    assert x.is_odd is False
+    assert x.is_integer is True
+    assert x.is_finite is True
+
+    x = Symbol('x', even=False)
+    assert x.is_even is False
+    assert x.is_odd is None
+    assert x.is_integer is None
+    assert x.is_finite is None
+
+    x = Symbol('x', integer=True, nonnegative=True)
+    assert x.is_integer is True
+    assert x.is_nonnegative is True
+    assert x.is_finite is True
+
+    x = Symbol('x', integer=True, nonpositive=True)
+    assert x.is_integer is True
+    assert x.is_nonpositive is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', rational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    x = Symbol('x', irrational=True)
+    assert x.is_real is True
+    assert x.is_finite is True
+
+    x = Symbol('x', irrational=False)
+    assert x.is_real is None
+    assert x.is_finite is None
+
+    with raises(AttributeError):
+        x.is_real = False
+
+    x = Symbol('x', algebraic=True)
+    assert x.is_transcendental is False
+    x = Symbol('x', transcendental=True)
+    assert x.is_algebraic is False
+    assert x.is_rational is False
+    assert x.is_integer is False
+
+
+def test_evaluate_false():
+    # Previously this failed because the assumptions query would make new
+    # expressions and some of the evaluation logic would fail under
+    # evaluate(False).
+    from sympy.core.parameters import evaluate
+    from sympy.abc import x, h
+    f = 2**x**7
+    with evaluate(False):
+        fh = f.xreplace({x: x+h})
+        assert fh.exp.is_rational is None
+
+
+def test_issue_3825():
+    """catch: hash instability"""
+    x = Symbol("x")
+    y = Symbol("y")
+    a1 = x + y
+    a2 = y + x
+    a2.is_comparable
+
+    h1 = hash(a1)
+    h2 = hash(a2)
+    assert h1 == h2
+
+
+def test_issue_4822():
+    z = (-1)**Rational(1, 3)*(1 - I*sqrt(3))
+    assert z.is_real in [True, None]
+
+
+def test_hash_vs_typeinfo():
+    """seemingly different typeinfo, but in fact equal"""
+
+    # the following two are semantically equal
+    x1 = Symbol('x', even=True)
+    x2 = Symbol('x', integer=True, odd=False)
+
+    assert hash(x1) == hash(x2)
+    assert x1 == x2
+
+
+def test_hash_vs_typeinfo_2():
+    """different typeinfo should mean !eq"""
+    # the following two are semantically different
+    x = Symbol('x')
+    x1 = Symbol('x', even=True)
+
+    assert x != x1
+    assert hash(x) != hash(x1)  # This might fail with very low probability
+
+
+def test_hash_vs_eq():
+    """catch: different hash for equal objects"""
+    a = 1 + S.Pi    # important: do not fold it into a Number instance
+    ha = hash(a)  # it should be Add/Mul/... to trigger the bug
+
+    a.is_positive   # this uses .evalf() and deduces it is positive
+    assert a.is_positive is True
+
+    # be sure that hash stayed the same
+    assert ha == hash(a)
+
+    # now b should be the same expression
+    b = a.expand(trig=True)
+    hb = hash(b)
+
+    assert a == b
+    assert ha == hb
+
+
+def test_Add_is_pos_neg():
+    # these cover lines not covered by the rest of tests in core
+    n = Symbol('n', extended_negative=True, infinite=True)
+    nn = Symbol('n', extended_nonnegative=True, infinite=True)
+    np = Symbol('n', extended_nonpositive=True, infinite=True)
+    p = Symbol('p', extended_positive=True, infinite=True)
+    r = Dummy(extended_real=True, finite=False)
+    x = Symbol('x')
+    xf = Symbol('xf', finite=True)
+    assert (n + p).is_extended_positive is None
+    assert (n + x).is_extended_positive is None
+    assert (p + x).is_extended_positive is None
+    assert (n + p).is_extended_negative is None
+    assert (n + x).is_extended_negative is None
+    assert (p + x).is_extended_negative is None
+
+    assert (n + xf).is_extended_positive is False
+    assert (p + xf).is_extended_positive is True
+    assert (n + xf).is_extended_negative is True
+    assert (p + xf).is_extended_negative is False
+
+    assert (x - S.Infinity).is_extended_negative is None  # issue 7798
+    # issue 8046, 16.2
+    assert (p + nn).is_extended_positive
+    assert (n + np).is_extended_negative
+    assert (p + r).is_extended_positive is None
+
+
+def test_Add_is_imaginary():
+    nn = Dummy(nonnegative=True)
+    assert (I*nn + I).is_imaginary  # issue 8046, 17
+
+
+def test_Add_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('a', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a + b).is_algebraic
+    assert (na + nb).is_algebraic is None
+    assert (a + na).is_algebraic is False
+    assert (a + x).is_algebraic is None
+    assert (na + x).is_algebraic is None
+
+
+def test_Mul_is_algebraic():
+    a = Symbol('a', algebraic=True)
+    b = Symbol('b', algebraic=True)
+    na = Symbol('na', algebraic=False)
+    an = Symbol('an', algebraic=True, nonzero=True)
+    nb = Symbol('nb', algebraic=False)
+    x = Symbol('x')
+    assert (a*b).is_algebraic is True
+    assert (na*nb).is_algebraic is None
+    assert (a*na).is_algebraic is None
+    assert (an*na).is_algebraic is False
+    assert (a*x).is_algebraic is None
+    assert (na*x).is_algebraic is None
+
+
+def test_Pow_is_algebraic():
+    e = Symbol('e', algebraic=True)
+
+    assert Pow(1, e, evaluate=False).is_algebraic
+    assert Pow(0, e, evaluate=False).is_algebraic
+
+    a = Symbol('a', algebraic=True)
+    azf = Symbol('azf', algebraic=True, zero=False)
+    na = Symbol('na', algebraic=False)
+    ia = Symbol('ia', algebraic=True, irrational=True)
+    ib = Symbol('ib', algebraic=True, irrational=True)
+    r = Symbol('r', rational=True)
+    x = Symbol('x')
+    assert (a**2).is_algebraic is True
+    assert (a**r).is_algebraic is None
+    assert (azf**r).is_algebraic is True
+    assert (a**x).is_algebraic is None
+    assert (na**r).is_algebraic is None
+    assert (ia**r).is_algebraic is True
+    assert (ia**ib).is_algebraic is False
+
+    assert (a**e).is_algebraic is None
+
+    # Gelfond-Schneider constant:
+    assert Pow(2, sqrt(2), evaluate=False).is_algebraic is False
+
+    assert Pow(S.GoldenRatio, sqrt(3), evaluate=False).is_algebraic is False
+
+    # issue 8649
+    t = Symbol('t', real=True, transcendental=True)
+    n = Symbol('n', integer=True)
+    assert (t**n).is_algebraic is None
+    assert (t**n).is_integer is None
+
+    assert (pi**3).is_algebraic is False
+    r = Symbol('r', zero=True)
+    assert (pi**r).is_algebraic is True
+
+
+def test_Mul_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x*y).is_prime is None
+    assert ( (x+1)*(y+1) ).is_prime is False
+    assert ( (x+1)*(y+1) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert ( (x+1)*(y+1) ).is_prime is None
+    assert ( (x+1)*(y+1) ).is_composite is None
+
+
+def test_Pow_is_pos_neg():
+    z = Symbol('z', real=True)
+    w = Symbol('w', nonpositive=True)
+
+    assert (S.NegativeOne**S(2)).is_positive is True
+    assert (S.One**z).is_positive is True
+    assert (S.NegativeOne**S(3)).is_positive is False
+    assert (S.Zero**S.Zero).is_positive is True  # 0**0 is 1
+    assert (w**S(3)).is_positive is False
+    assert (w**S(2)).is_positive is None
+    assert (I**2).is_positive is False
+    assert (I**4).is_positive is True
+
+    # tests emerging from #16332 issue
+    p = Symbol('p', zero=True)
+    q = Symbol('q', zero=False, real=True)
+    j = Symbol('j', zero=False, even=True)
+    x = Symbol('x', zero=True)
+    y = Symbol('y', zero=True)
+    assert (p**q).is_positive is False
+    assert (p**q).is_negative is False
+    assert (p**j).is_positive is False
+    assert (x**y).is_positive is True   # 0**0
+    assert (x**y).is_negative is False
+
+
+def test_Pow_is_prime_composite():
+    x = Symbol('x', positive=True, integer=True)
+    y = Symbol('y', positive=True, integer=True)
+    assert (x**y).is_prime is None
+    assert ( x**(y+1) ).is_prime is False
+    assert ( x**(y+1) ).is_composite is None
+    assert ( (x+1)**(y+1) ).is_composite is True
+    assert ( (-x-1)**(2*y) ).is_composite is True
+
+    x = Symbol('x', positive=True)
+    assert (x**y).is_prime is None
+
+
+def test_Mul_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.mul import Mul
+    assert (x*f).is_finite is None
+    assert (x*i).is_finite is None
+    assert (f*i).is_finite is None
+    assert (x*f*i).is_finite is None
+    assert (z*i).is_finite is None
+    assert (nzf*i).is_finite is False
+    assert (z*f).is_finite is True
+    assert Mul(0, f, evaluate=False).is_finite is True
+    assert Mul(0, i, evaluate=False).is_finite is None
+
+    assert (x*f).is_infinite is None
+    assert (x*i).is_infinite is None
+    assert (f*i).is_infinite is None
+    assert (x*f*i).is_infinite is None
+    assert (z*i).is_infinite is S.NaN.is_infinite
+    assert (nzf*i).is_infinite is True
+    assert (z*f).is_infinite is False
+    assert Mul(0, f, evaluate=False).is_infinite is False
+    assert Mul(0, i, evaluate=False).is_infinite is S.NaN.is_infinite
+
+
+def test_Add_is_infinite():
+    x = Symbol('x')
+    f = Symbol('f', finite=True)
+    i = Symbol('i', infinite=True)
+    i2 = Symbol('i2', infinite=True)
+    z = Dummy(zero=True)
+    nzf = Dummy(finite=True, zero=False)
+    from sympy.core.add import Add
+    assert (x+f).is_finite is None
+    assert (x+i).is_finite is None
+    assert (f+i).is_finite is False
+    assert (x+f+i).is_finite is None
+    assert (z+i).is_finite is False
+    assert (nzf+i).is_finite is False
+    assert (z+f).is_finite is True
+    assert (i+i2).is_finite is None
+    assert Add(0, f, evaluate=False).is_finite is True
+    assert Add(0, i, evaluate=False).is_finite is False
+
+    assert (x+f).is_infinite is None
+    assert (x+i).is_infinite is None
+    assert (f+i).is_infinite is True
+    assert (x+f+i).is_infinite is None
+    assert (z+i).is_infinite is True
+    assert (nzf+i).is_infinite is True
+    assert (z+f).is_infinite is False
+    assert (i+i2).is_infinite is None
+    assert Add(0, f, evaluate=False).is_infinite is False
+    assert Add(0, i, evaluate=False).is_infinite is True
+
+
+def test_special_is_rational():
+    i = Symbol('i', integer=True)
+    i2 = Symbol('i2', integer=True)
+    ni = Symbol('ni', integer=True, nonzero=True)
+    r = Symbol('r', rational=True)
+    rn = Symbol('r', rational=True, nonzero=True)
+    nr = Symbol('nr', irrational=True)
+    x = Symbol('x')
+    assert sqrt(3).is_rational is False
+    assert (3 + sqrt(3)).is_rational is False
+    assert (3*sqrt(3)).is_rational is False
+    assert exp(3).is_rational is False
+    assert exp(ni).is_rational is False
+    assert exp(rn).is_rational is False
+    assert exp(x).is_rational is None
+    assert exp(log(3), evaluate=False).is_rational is True
+    assert log(exp(3), evaluate=False).is_rational is True
+    assert log(3).is_rational is False
+    assert log(ni + 1).is_rational is False
+    assert log(rn + 1).is_rational is False
+    assert log(x).is_rational is None
+    assert (sqrt(3) + sqrt(5)).is_rational is None
+    assert (sqrt(3) + S.Pi).is_rational is False
+    assert (x**i).is_rational is None
+    assert (i**i).is_rational is True
+    assert (i**i2).is_rational is None
+    assert (r**i).is_rational is None
+    assert (r**r).is_rational is None
+    assert (r**x).is_rational is None
+    assert (nr**i).is_rational is None  # issue 8598
+    assert (nr**Symbol('z', zero=True)).is_rational
+    assert sin(1).is_rational is False
+    assert sin(ni).is_rational is False
+    assert sin(rn).is_rational is False
+    assert sin(x).is_rational is None
+    assert asin(r).is_rational is False
+    assert sin(asin(3), evaluate=False).is_rational is True
+
+
+@XFAIL
+def test_issue_6275():
+    x = Symbol('x')
+    # both zero or both Muls...but neither "change would be very appreciated.
+    # This is similar to x/x => 1 even though if x = 0, it is really nan.
+    assert isinstance(x*0, type(0*S.Infinity))
+    if 0*S.Infinity is S.NaN:
+        b = Symbol('b', finite=None)
+        assert (b*0).is_zero is None
+
+
+def test_sanitize_assumptions():
+    # issue 6666
+    for cls in (Symbol, Dummy, Wild):
+        x = cls('x', real=1, positive=0)
+        assert x.is_real is True
+        assert x.is_positive is False
+        assert cls('', real=True, positive=None).is_positive is None
+        raises(ValueError, lambda: cls('', commutative=None))
+    raises(ValueError, lambda: Symbol._sanitize({"commutative": None}))
+
+
+def test_special_assumptions():
+    e = -3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2
+    assert simplify(e < 0) is S.false
+    assert simplify(e > 0) is S.false
+    assert (e == 0) is False  # it's not a literal 0
+    assert e.equals(0) is True
+
+
+def test_inconsistent():
+    # cf. issues 5795 and 5545
+    raises(InconsistentAssumptions, lambda: Symbol('x', real=True,
+           commutative=False))
+
+
+def test_issue_6631():
+    assert ((-1)**(I)).is_real is True
+    assert ((-1)**(I*2)).is_real is True
+    assert ((-1)**(I/2)).is_real is True
+    assert ((-1)**(I*S.Pi)).is_real is True
+    assert (I**(I + 2)).is_real is True
+
+
+def test_issue_2730():
+    assert (1/(1 + I)).is_real is False
+
+
+def test_issue_4149():
+    assert (3 + I).is_complex
+    assert (3 + I).is_imaginary is False
+    assert (3*I + S.Pi*I).is_imaginary
+    # as Zero.is_imaginary is False, see issue 7649
+    y = Symbol('y', real=True)
+    assert (3*I + S.Pi*I + y*I).is_imaginary is None
+    p = Symbol('p', positive=True)
+    assert (3*I + S.Pi*I + p*I).is_imaginary
+    n = Symbol('n', negative=True)
+    assert (-3*I - S.Pi*I + n*I).is_imaginary
+
+    i = Symbol('i', imaginary=True)
+    assert ([(i**a).is_imaginary for a in range(4)] ==
+            [False, True, False, True])
+
+    # tests from the PR #7887:
+    e = S("-sqrt(3)*I/2 + 0.866025403784439*I")
+    assert e.is_real is False
+    assert e.is_imaginary
+
+
+def test_issue_2920():
+    n = Symbol('n', negative=True)
+    assert sqrt(n).is_imaginary
+
+
+def test_issue_7899():
+    x = Symbol('x', real=True)
+    assert (I*x).is_real is None
+    assert ((x - I)*(x - 1)).is_zero is None
+    assert ((x - I)*(x - 1)).is_real is None
+
+
+@XFAIL
+def test_issue_7993():
+    x = Dummy(integer=True)
+    y = Dummy(noninteger=True)
+    assert (x - y).is_zero is False
+
+
+def test_issue_8075():
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, finite=False))
+    raises(InconsistentAssumptions, lambda: Dummy(zero=True, infinite=True))
+
+
+def test_issue_8642():
+    x = Symbol('x', real=True, integer=False)
+    assert (x*2).is_integer is None, (x*2).is_integer
+
+
+def test_issues_8632_8633_8638_8675_8992():
+    p = Dummy(integer=True, positive=True)
+    nn = Dummy(integer=True, nonnegative=True)
+    assert (p - S.Half).is_positive
+    assert (p - 1).is_nonnegative
+    assert (nn + 1).is_positive
+    assert (-p + 1).is_nonpositive
+    assert (-nn - 1).is_negative
+    prime = Dummy(prime=True)
+    assert (prime - 2).is_nonnegative
+    assert (prime - 3).is_nonnegative is None
+    even = Dummy(positive=True, even=True)
+    assert (even - 2).is_nonnegative
+
+    p = Dummy(positive=True)
+    assert (p/(p + 1) - 1).is_negative
+    assert ((p + 2)**3 - S.Half).is_positive
+    n = Dummy(negative=True)
+    assert (n - 3).is_nonpositive
+
+
+def test_issue_9115_9150():
+    n = Dummy('n', integer=True, nonnegative=True)
+    assert (factorial(n) >= 1) == True
+    assert (factorial(n) < 1) == False
+
+    assert factorial(n + 1).is_even is None
+    assert factorial(n + 2).is_even is True
+    assert factorial(n + 2) >= 2
+
+
+def test_issue_9165():
+    z = Symbol('z', zero=True)
+    f = Symbol('f', finite=False)
+    assert 0/z is S.NaN
+    assert 0*(1/z) is S.NaN
+    assert 0*f is S.NaN
+
+
+def test_issue_10024():
+    x = Dummy('x')
+    assert Mod(x, 2*pi).is_zero is None
+
+
+def test_issue_10302():
+    x = Symbol('x')
+    r = Symbol('r', real=True)
+    u = -(3*2**pi)**(1/pi) + 2*3**(1/pi)
+    i = u + u*I
+
+    assert i.is_real is None  # w/o simplification this should fail
+    assert (u + i).is_zero is None
+    assert (1 + i).is_zero is False
+
+    a = Dummy('a', zero=True)
+    assert (a + I).is_zero is False
+    assert (a + r*I).is_zero is None
+    assert (a + I).is_imaginary
+    assert (a + x + I).is_imaginary is None
+    assert (a + r*I + I).is_imaginary is None
+
+
+def test_complex_reciprocal_imaginary():
+    assert (1 / (4 + 3*I)).is_imaginary is False
+
+
+def test_issue_16313():
+    x = Symbol('x', extended_real=False)
+    k = Symbol('k', real=True)
+    l = Symbol('l', real=True, zero=False)
+    assert (-x).is_real is False
+    assert (k*x).is_real is None  # k can be zero also
+    assert (l*x).is_real is False
+    assert (l*x*x).is_real is None  # since x*x can be a real number
+    assert (-x).is_positive is False
+
+
+def test_issue_16579():
+    # extended_real -> finite | infinite
+    x = Symbol('x', extended_real=True, infinite=False)
+    y = Symbol('y', extended_real=True, finite=False)
+    assert x.is_finite is True
+    assert y.is_infinite is True
+
+    # With PR 16978, complex now implies finite
+    c = Symbol('c', complex=True)
+    assert c.is_finite is True
+    raises(InconsistentAssumptions, lambda: Dummy(complex=True, finite=False))
+
+    # Now infinite == !finite
+    nf = Symbol('nf', finite=False)
+    assert nf.is_infinite is True
+
+
+def test_issue_17556():
+    z = I*oo
+    assert z.is_imaginary is False
+    assert z.is_finite is False
+
+
+def test_issue_21651():
+    k = Symbol('k', positive=True, integer=True)
+    exp = 2*2**(-k)
+    assert exp.is_integer is None
+
+
+def test_assumptions_copy():
+    assert assumptions(Symbol('x'), {"commutative": True}
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x'), ['integer']) == {}
+    assert assumptions(Symbol('x'), ['commutative']
+        ) == {'commutative': True}
+    assert assumptions(Symbol('x')) == {'commutative': True}
+    assert assumptions(1)['positive']
+    assert assumptions(3 + I) == {
+        'algebraic': True,
+        'commutative': True,
+        'complex': True,
+        'composite': False,
+        'even': False,
+        'extended_negative': False,
+        'extended_nonnegative': False,
+        'extended_nonpositive': False,
+        'extended_nonzero': False,
+        'extended_positive': False,
+        'extended_real': False,
+        'finite': True,
+        'imaginary': False,
+        'infinite': False,
+        'integer': False,
+        'irrational': False,
+        'negative': False,
+        'noninteger': False,
+        'nonnegative': False,
+        'nonpositive': False,
+        'nonzero': False,
+        'odd': False,
+        'positive': False,
+        'prime': False,
+        'rational': False,
+        'real': False,
+        'transcendental': False,
+        'zero': False}
+
+
+def test_check_assumptions():
+    assert check_assumptions(1, 0) is False
+    x = Symbol('x', positive=True)
+    assert check_assumptions(1, x) is True
+    assert check_assumptions(1, 1) is True
+    assert check_assumptions(-1, 1) is False
+    i = Symbol('i', integer=True)
+    # don't know if i is positive (or prime, etc...)
+    assert check_assumptions(i, 1) is None
+    assert check_assumptions(Dummy(integer=None), integer=True) is None
+    assert check_assumptions(Dummy(integer=None), integer=False) is None
+    assert check_assumptions(Dummy(integer=False), integer=True) is False
+    assert check_assumptions(Dummy(integer=True), integer=False) is False
+    # no T/F assumptions to check
+    assert check_assumptions(Dummy(integer=False), integer=None) is True
+    raises(ValueError, lambda: check_assumptions(2*x, x, positive=True))
+
+
+def test_failing_assumptions():
+    x = Symbol('x', positive=True)
+    y = Symbol('y')
+    assert failing_assumptions(6*x + y, **x.assumptions0) == \
+    {'real': None, 'imaginary': None, 'complex': None, 'hermitian': None,
+    'positive': None, 'nonpositive': None, 'nonnegative': None, 'nonzero': None,
+    'negative': None, 'zero': None, 'extended_real': None, 'finite': None,
+    'infinite': None, 'extended_negative': None, 'extended_nonnegative': None,
+    'extended_nonpositive': None, 'extended_nonzero': None,
+    'extended_positive': None }
+
+
+def test_common_assumptions():
+    assert common_assumptions([0, 1, 2]
+        ) == {'algebraic': True, 'irrational': False, 'hermitian':
+        True, 'extended_real': True, 'real': True, 'extended_negative':
+        False, 'extended_nonnegative': True, 'integer': True,
+        'rational': True, 'imaginary': False, 'complex': True,
+        'commutative': True,'noninteger': False, 'composite': False,
+        'infinite': False, 'nonnegative': True, 'finite': True,
+        'transcendental': False,'negative': False}
+    assert common_assumptions([0, 1, 2], 'positive integer'.split()
+        ) == {'integer': True}
+    assert common_assumptions([0, 1, 2], []) == {}
+    assert common_assumptions([], ['integer']) == {}
+    assert common_assumptions([0], ['integer']) == {'integer': True}
+
+def test_pre_generated_assumption_rules_are_valid():
+    # check the pre-generated assumptions match freshly generated assumptions
+    # if this check fails, consider updating the assumptions
+    # see sympy.core.assumptions._generate_assumption_rules
+    pre_generated_assumptions =_load_pre_generated_assumption_rules()
+    generated_assumptions =_generate_assumption_rules()
+    assert pre_generated_assumptions._to_python() == generated_assumptions._to_python(), "pre-generated assumptions are invalid, see sympy.core.assumptions._generate_assumption_rules"
+
+
+def test_ask_shuffle():
+    grp = PermutationGroup(Permutation(1, 0, 2), Permutation(2, 1, 3))
+
+    seed(123)
+    first = grp.random()
+    seed(123)
+    simplify(I)
+    second = grp.random()
+    seed(123)
+    simplify(-I)
+    third = grp.random()
+
+    assert first == second == third
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_basic.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_basic.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a7adbb5dcf0d70089ff79028afa943b24ee0c42
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_basic.py
@@ -0,0 +1,343 @@
+"""This tests sympy/core/basic.py with (ideally) no reference to subclasses
+of Basic or Atom."""
+import collections
+from typing import TypeVar, Generic
+
+from sympy.assumptions.ask import Q
+from sympy.core.basic import (Basic, Atom, as_Basic,
+    _atomic, _aresame)
+from sympy.core.containers import Tuple
+from sympy.core.function import Function, Lambda
+from sympy.core.numbers import I, pi, Float
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Symbol, Dummy
+from sympy.concrete.summations import Sum
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import Integral
+from sympy.functions.elementary.exponential import exp
+from sympy.testing.pytest import raises, warns_deprecated_sympy
+from sympy.functions.elementary.complexes import Abs, sign
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.core.relational import Eq
+
+b1 = Basic()
+b2 = Basic(b1)
+b3 = Basic(b2)
+b21 = Basic(b2, b1)
+T = TypeVar('T')
+
+
+def test__aresame():
+    assert not _aresame(Basic(Tuple()), Basic())
+    for i, j in [(S(2), S(2.)), (1., Float(1))]:
+        for do in range(2):
+            assert not _aresame(Basic(i), Basic(j))
+            assert not _aresame(i, j)
+            i, j = j, i
+
+
+def test_structure():
+    assert b21.args == (b2, b1)
+    assert b21.func(*b21.args) == b21
+    assert bool(b1)
+
+
+def test_immutable():
+    assert not hasattr(b1, '__dict__')
+    with raises(AttributeError):
+        b1.x = 1
+
+
+def test_equality():
+    instances = [b1, b2, b3, b21, Basic(b1, b1, b1), Basic]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            assert (b_i == b_j) == (i == j)
+            assert (b_i != b_j) == (i != j)
+
+    assert Basic() != []
+    assert not(Basic() == [])
+    assert Basic() != 0
+    assert not(Basic() == 0)
+
+    class Foo:
+        """
+        Class that is unaware of Basic, and relies on both classes returning
+        the NotImplemented singleton for equivalence to evaluate to False.
+
+        """
+
+    b = Basic()
+    foo = Foo()
+
+    assert b != foo
+    assert foo != b
+    assert not b == foo
+    assert not foo == b
+
+    class Bar:
+        """
+        Class that considers itself equal to any instance of Basic, and relies
+        on Basic returning the NotImplemented singleton in order to achieve
+        a symmetric equivalence relation.
+
+        """
+        def __eq__(self, other):
+            if isinstance(other, Basic):
+                return True
+            return NotImplemented
+
+        def __ne__(self, other):
+            return not self == other
+
+    bar = Bar()
+
+    assert b == bar
+    assert bar == b
+    assert not b != bar
+    assert not bar != b
+
+
+def test_matches_basic():
+    instances = [Basic(b1, b1, b2), Basic(b1, b2, b1), Basic(b2, b1, b1),
+                 Basic(b1, b2), Basic(b2, b1), b2, b1]
+    for i, b_i in enumerate(instances):
+        for j, b_j in enumerate(instances):
+            if i == j:
+                assert b_i.matches(b_j) == {}
+            else:
+                assert b_i.matches(b_j) is None
+    assert b1.match(b1) == {}
+
+
+def test_has():
+    assert b21.has(b1)
+    assert b21.has(b3, b1)
+    assert b21.has(Basic)
+    assert not b1.has(b21, b3)
+    assert not b21.has()
+    assert not b21.has(str)
+    assert not Symbol("x").has("x")
+
+
+def test_subs():
+    assert b21.subs(b2, b1) == Basic(b1, b1)
+    assert b21.subs(b2, b21) == Basic(b21, b1)
+    assert b3.subs(b2, b1) == b2
+
+    assert b21.subs([(b2, b1), (b1, b2)]) == Basic(b2, b2)
+
+    assert b21.subs({b1: b2, b2: b1}) == Basic(b2, b2)
+    assert b21.subs(collections.ChainMap({b1: b2}, {b2: b1})) == Basic(b2, b2)
+    assert b21.subs(collections.OrderedDict([(b2, b1), (b1, b2)])) == Basic(b2, b2)
+
+    raises(ValueError, lambda: b21.subs('bad arg'))
+    raises(TypeError, lambda: b21.subs(b1, b2, b3))
+    # dict(b1=foo) creates a string 'b1' but leaves foo unchanged; subs
+    # will convert the first to a symbol but will raise an error if foo
+    # cannot be sympified; sympification is strict if foo is not string
+    raises(TypeError, lambda: b21.subs(b1='bad arg'))
+
+    assert Symbol("text").subs({"text": b1}) == b1
+    assert Symbol("s").subs({"s": 1}) == 1
+
+
+def test_subs_with_unicode_symbols():
+    expr = Symbol('var1')
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+    replaced = expr.subs('var1', 'x')
+    assert replaced.name == 'x'
+
+
+def test_atoms():
+    assert b21.atoms() == {Basic()}
+
+
+def test_free_symbols_empty():
+    assert b21.free_symbols == set()
+
+
+def test_doit():
+    assert b21.doit() == b21
+    assert b21.doit(deep=False) == b21
+
+
+def test_S():
+    assert repr(S) == 'S'
+
+
+def test_xreplace():
+    assert b21.xreplace({b2: b1}) == Basic(b1, b1)
+    assert b21.xreplace({b2: b21}) == Basic(b21, b1)
+    assert b3.xreplace({b2: b1}) == b2
+    assert Basic(b1, b2).xreplace({b1: b2, b2: b1}) == Basic(b2, b1)
+    assert Atom(b1).xreplace({b1: b2}) == Atom(b1)
+    assert Atom(b1).xreplace({Atom(b1): b2}) == b2
+    raises(TypeError, lambda: b1.xreplace())
+    raises(TypeError, lambda: b1.xreplace([b1, b2]))
+    for f in (exp, Function('f')):
+        assert f.xreplace({}) == f
+        assert f.xreplace({}, hack2=True) == f
+        assert f.xreplace({f: b1}) == b1
+        assert f.xreplace({f: b1}, hack2=True) == b1
+
+
+def test_sorted_args():
+    x = symbols('x')
+    assert b21._sorted_args == b21.args
+    raises(AttributeError, lambda: x._sorted_args)
+
+def test_call():
+    x, y = symbols('x y')
+    # See the long history of this in issues 5026 and 5105.
+
+    raises(TypeError, lambda: sin(x)({ x : 1, sin(x) : 2}))
+    raises(TypeError, lambda: sin(x)(1))
+
+    # No effect as there are no callables
+    assert sin(x).rcall(1) == sin(x)
+    assert (1 + sin(x)).rcall(1) == 1 + sin(x)
+
+    # Effect in the presence of callables
+    l = Lambda(x, 2*x)
+    assert (l + x).rcall(y) == 2*y + x
+    assert (x**l).rcall(2) == x**4
+    # TODO UndefinedFunction does not subclass Expr
+    #f = Function('f')
+    #assert (2*f)(x) == 2*f(x)
+
+    assert (Q.real & Q.positive).rcall(x) == Q.real(x) & Q.positive(x)
+
+
+def test_rewrite():
+    x, y, z = symbols('x y z')
+    a, b = symbols('a b')
+    f1 = sin(x) + cos(x)
+    assert f1.rewrite(cos,exp) == exp(I*x)/2 + sin(x) + exp(-I*x)/2
+    assert f1.rewrite([cos],sin) == sin(x) + sin(x + pi/2, evaluate=False)
+    f2 = sin(x) + cos(y)/gamma(z)
+    assert f2.rewrite(sin,exp) == -I*(exp(I*x) - exp(-I*x))/2 + cos(y)/gamma(z)
+
+    assert f1.rewrite() == f1
+
+def test_literal_evalf_is_number_is_zero_is_comparable():
+    x = symbols('x')
+    f = Function('f')
+
+    # issue 5033
+    assert f.is_number is False
+    # issue 6646
+    assert f(1).is_number is False
+    i = Integral(0, (x, x, x))
+    # expressions that are symbolically 0 can be difficult to prove
+    # so in case there is some easy way to know if something is 0
+    # it should appear in the is_zero property for that object;
+    # if is_zero is true evalf should always be able to compute that
+    # zero
+    assert i.n() == 0
+    assert i.is_zero
+    assert i.is_number is False
+    assert i.evalf(2, strict=False) == 0
+
+    # issue 10268
+    n = sin(1)**2 + cos(1)**2 - 1
+    assert n.is_comparable is False
+    assert n.n(2).is_comparable is False
+    assert n.n(2).n(2).is_comparable
+
+
+def test_as_Basic():
+    assert as_Basic(1) is S.One
+    assert as_Basic(()) == Tuple()
+    raises(TypeError, lambda: as_Basic([]))
+
+
+def test_atomic():
+    g, h = map(Function, 'gh')
+    x = symbols('x')
+    assert _atomic(g(x + h(x))) == {g(x + h(x))}
+    assert _atomic(g(x + h(x)), recursive=True) == {h(x), x, g(x + h(x))}
+    assert _atomic(1) == set()
+    assert _atomic(Basic(S(1), S(2))) == set()
+
+
+def test_as_dummy():
+    u, v, x, y, z, _0, _1 = symbols('u v x y z _0 _1')
+    assert Lambda(x, x + 1).as_dummy() == Lambda(_0, _0 + 1)
+    assert Lambda(x, x + _0).as_dummy() == Lambda(_1, _0 + _1)
+    eq = (1 + Sum(x, (x, 1, x)))
+    ans = 1 + Sum(_0, (_0, 1, x))
+    once = eq.as_dummy()
+    assert once == ans
+    twice = once.as_dummy()
+    assert twice == ans
+    assert Integral(x + _0, (x, x + 1), (_0, 1, 2)
+        ).as_dummy() == Integral(_0 + _1, (_0, x + 1), (_1, 1, 2))
+    for T in (Symbol, Dummy):
+        d = T('x', real=True)
+        D = d.as_dummy()
+        assert D != d and D.func == Dummy and D.is_real is None
+    assert Dummy().as_dummy().is_commutative
+    assert Dummy(commutative=False).as_dummy().is_commutative is False
+
+
+def test_canonical_variables():
+    x, i0, i1 = symbols('x _:2')
+    assert Integral(x, (x, x + 1)).canonical_variables == {x: i0}
+    assert Integral(x, (x, x + 1), (i0, 1, 2)).canonical_variables == {
+        x: i0, i0: i1}
+    assert Integral(x, (x, x + i0)).canonical_variables == {x: i1}
+
+
+def test_replace_exceptions():
+    from sympy.core.symbol import Wild
+    x, y = symbols('x y')
+    e = (x**2 + x*y)
+    raises(TypeError, lambda: e.replace(sin, 2))
+    b = Wild('b')
+    c = Wild('c')
+    raises(TypeError, lambda: e.replace(b*c, c.is_real))
+    raises(TypeError, lambda: e.replace(b.is_real, 1))
+    raises(TypeError, lambda: e.replace(lambda d: d.is_Number, 1))
+
+
+def test_ManagedProperties():
+    # ManagedProperties is now deprecated. Here we do our best to check that if
+    # someone is using it then it does work in the way that it previously did
+    # but gives a deprecation warning.
+    from sympy.core.assumptions import ManagedProperties
+
+    myclasses = []
+
+    class MyMeta(ManagedProperties):
+        def __init__(cls, *args, **kwargs):
+            myclasses.append('executed')
+            super().__init__(*args, **kwargs)
+
+    code = """
+class MySubclass(Basic, metaclass=MyMeta):
+    pass
+"""
+    with warns_deprecated_sympy():
+        exec(code)
+
+    assert myclasses == ['executed']
+
+
+def test_generic():
+    # https://github.com/sympy/sympy/issues/25399
+    class A(Symbol, Generic[T]):
+        pass
+
+    class B(A[T]):
+        pass
+
+
+def test_rewrite_abs():
+    # https://github.com/sympy/sympy/issues/27323
+    x = Symbol('x')
+    assert sign(x).rewrite(abs) == sign(x).rewrite(Abs)
+    assert sign(x).rewrite(abs) == Piecewise((0, Eq(x, 0)), (x / Abs(x), True))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_cache.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..9124fca70718299252929a9923f335dde25256eb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_cache.py
@@ -0,0 +1,91 @@
+import sys
+from sympy.core.cache import cacheit, cached_property, lazy_function
+from sympy.testing.pytest import raises
+
+def test_cacheit_doc():
+    @cacheit
+    def testfn():
+        "test docstring"
+        pass
+
+    assert testfn.__doc__ == "test docstring"
+    assert testfn.__name__ == "testfn"
+
+def test_cacheit_unhashable():
+    @cacheit
+    def testit(x):
+        return x
+
+    assert testit(1) == 1
+    assert testit(1) == 1
+    a = {}
+    assert testit(a) == {}
+    a[1] = 2
+    assert testit(a) == {1: 2}
+
+def test_cachit_exception():
+    # Make sure the cache doesn't call functions multiple times when they
+    # raise TypeError
+
+    a = []
+
+    @cacheit
+    def testf(x):
+        a.append(0)
+        raise TypeError
+
+    raises(TypeError, lambda: testf(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf([]))
+    assert len(a) == 1
+
+    @cacheit
+    def testf2(x):
+        a.append(0)
+        raise TypeError("Error")
+
+    a.clear()
+    raises(TypeError, lambda: testf2(1))
+    assert len(a) == 1
+
+    a.clear()
+    # Unhashable type
+    raises(TypeError, lambda: testf2([]))
+    assert len(a) == 1
+
+def test_cached_property():
+    class A:
+        def __init__(self, value):
+            self.value = value
+            self.calls = 0
+
+        @cached_property
+        def prop(self):
+            self.calls = self.calls + 1
+            return self.value
+
+    a = A(2)
+    assert a.calls == 0
+    assert a.prop == 2
+    assert a.calls == 1
+    assert a.prop == 2
+    assert a.calls == 1
+    b = A(None)
+    assert b.prop == None
+
+
+def test_lazy_function():
+    module_name='xmlrpc.client'
+    function_name = 'gzip_decode'
+    lazy = lazy_function(module_name, function_name)
+    assert lazy(b'') == b''
+    assert module_name in sys.modules
+    assert function_name in str(lazy)
+    repr_lazy = repr(lazy)
+    assert 'LazyFunction' in repr_lazy
+    assert function_name in repr_lazy
+
+    lazy = lazy_function('sympy.core.cache', 'cheap')
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_compatibility.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_compatibility.py
new file mode 100644
index 0000000000000000000000000000000000000000..31d2bed07b21aa2fa489273dca9edfc9993cfd86
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_compatibility.py
@@ -0,0 +1,6 @@
+from sympy.testing.pytest import warns_deprecated_sympy
+
+def test_compatibility_submodule():
+    # Test the sympy.core.compatibility deprecation warning
+    with warns_deprecated_sympy():
+        import sympy.core.compatibility # noqa:F401
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_complex.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_complex.py
new file mode 100644
index 0000000000000000000000000000000000000000..a607e0bdb4db859336aa30aa61f43bfb57d5df88
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_complex.py
@@ -0,0 +1,226 @@
+from sympy.core.function import expand_complex
+from sympy.core.numbers import (I, Integer, Rational, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re, sign)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.hyperbolic import (cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+
+def test_complex():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    e = (a + I*b)*(a - I*b)
+    assert e.expand() == a**2 + b**2
+    assert sqrt(I) == Pow(I, S.Half)
+
+
+def test_conjugate():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    c = Symbol("c", imaginary=True)
+    d = Symbol("d", imaginary=True)
+    x = Symbol('x')
+    z = a + I*b + c + I*d
+    zc = a - I*b - c + I*d
+    assert conjugate(z) == zc
+    assert conjugate(exp(z)) == exp(zc)
+    assert conjugate(exp(I*x)) == exp(-I*conjugate(x))
+    assert conjugate(z**5) == zc**5
+    assert conjugate(abs(x)) == abs(x)
+    assert conjugate(sign(z)) == sign(zc)
+    assert conjugate(sin(z)) == sin(zc)
+    assert conjugate(cos(z)) == cos(zc)
+    assert conjugate(tan(z)) == tan(zc)
+    assert conjugate(cot(z)) == cot(zc)
+    assert conjugate(sinh(z)) == sinh(zc)
+    assert conjugate(cosh(z)) == cosh(zc)
+    assert conjugate(tanh(z)) == tanh(zc)
+    assert conjugate(coth(z)) == coth(zc)
+
+
+def test_abs1():
+    a = Symbol("a", real=True)
+    b = Symbol("b", real=True)
+    assert abs(a) == Abs(a)
+    assert abs(-a) == abs(a)
+    assert abs(a + I*b) == sqrt(a**2 + b**2)
+
+
+def test_abs2():
+    a = Symbol("a", real=False)
+    b = Symbol("b", real=False)
+    assert abs(a) != a
+    assert abs(-a) != a
+    assert abs(a + I*b) != sqrt(a**2 + b**2)
+
+
+def test_evalc():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    z = Symbol("z")
+    assert ((x + I*y)**2).expand(complex=True) == x**2 + 2*I*x*y - y**2
+    assert expand_complex(z**(2*I)) == (re((re(z) + I*im(z))**(2*I)) +
+        I*im((re(z) + I*im(z))**(2*I)))
+    assert expand_complex(
+        z**(2*I), deep=False) == I*im(z**(2*I)) + re(z**(2*I))
+
+    assert exp(I*x) != cos(x) + I*sin(x)
+    assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
+    assert exp(I*x + y).expand(complex=True) == exp(y)*cos(x) + I*sin(x)*exp(y)
+
+    assert sin(I*x).expand(complex=True) == I * sinh(x)
+    assert sin(x + I*y).expand(complex=True) == sin(x)*cosh(y) + \
+        I * sinh(y) * cos(x)
+
+    assert cos(I*x).expand(complex=True) == cosh(x)
+    assert cos(x + I*y).expand(complex=True) == cos(x)*cosh(y) - \
+        I * sinh(y) * sin(x)
+
+    assert tan(I*x).expand(complex=True) == tanh(x) * I
+    assert tan(x + I*y).expand(complex=True) == (
+        sin(2*x)/(cos(2*x) + cosh(2*y)) +
+        I*sinh(2*y)/(cos(2*x) + cosh(2*y)))
+
+    assert sinh(I*x).expand(complex=True) == I * sin(x)
+    assert sinh(x + I*y).expand(complex=True) == sinh(x)*cos(y) + \
+        I * sin(y) * cosh(x)
+
+    assert cosh(I*x).expand(complex=True) == cos(x)
+    assert cosh(x + I*y).expand(complex=True) == cosh(x)*cos(y) + \
+        I * sin(y) * sinh(x)
+
+    assert tanh(I*x).expand(complex=True) == tan(x) * I
+    assert tanh(x + I*y).expand(complex=True) == (
+        (sinh(x)*cosh(x) + I*cos(y)*sin(y)) /
+        (sinh(x)**2 + cos(y)**2)).expand()
+
+
+def test_pythoncomplex():
+    x = Symbol("x")
+    assert 4j*x != 4*x*I
+    assert 4j*x == 4.0*x*I
+    assert 4.1j*x != 4*x*I
+
+
+def test_rootcomplex():
+    R = Rational
+    assert ((+1 + I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(  pi/8) + 2**R(1, 4)*sin(  pi/8)*I
+    assert ((-1 - I)**R(1, 2)).expand(
+        complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I
+    assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
+
+
+def test_expand_inverse():
+    assert (1/(1 + I)).expand(complex=True) == (1 - I)/2
+    assert ((1 + 2*I)**(-2)).expand(complex=True) == (-3 - 4*I)/25
+    assert ((1 + I)**(-8)).expand(complex=True) == Rational(1, 16)
+
+
+def test_expand_complex():
+    assert ((2 + 3*I)**10).expand(complex=True) == -341525 - 145668*I
+    # the following two tests are to ensure the SymPy uses an efficient
+    # algorithm for calculating powers of complex numbers. They should execute
+    # in something like 0.01s.
+    assert ((2 + 3*I)**1000).expand(complex=True) == \
+        -81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999 + \
+        46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I
+    assert ((2 + 3*I/4)**1000).expand(complex=True) == \
+        Integer(1)*37079892761199059751745775382463070250205990218394308874593455293485167797989691280095867197640410033222367257278387021789651672598831503296531725827158233077451476545928116965316544607115843772405184272449644892857783761260737279675075819921259597776770965829089907990486964515784097181964312256560561065607846661496055417619388874421218472707497847700629822858068783288579581649321248495739224020822198695759609598745114438265083593711851665996586461937988748911532242908776883696631067311443171682974330675406616373422505939887984366289623091300746049101284856530270685577940283077888955692921951247230006346681086274961362500646889925803654263491848309446197554307105991537357310209426736453173441104334496173618419659521888945605315751089087820455852582920963561495787655250624781448951403353654348109893478206364632640344111022531861683064175862889459084900614967785405977231549003280842218501570429860550379522498497412180001/114813069527425452423283320117768198402231770208869520047764273682576626139237031385665948631650626991844596463898746277344711896086305533142593135616665318539129989145312280000688779148240044871428926990063486244781615463646388363947317026040466353970904996558162398808944629605623311649536164221970332681344168908984458505602379484807914058900934776500429002716706625830522008132236281291761267883317206598995396418127021779858404042159853183251540889433902091920554957783589672039160081957216630582755380425583726015528348786419432054508915275783882625175435528800822842770817965453762184851149029376 + \
+        I*421638390580169706973991429333213477486930178424989246669892530737775352519112934278994501272111385966211392610029433824534634841747911783746811994443436271013377059560245191441549885048056920190833693041257216263519792201852046825443439142932464031501882145407459174948712992271510309541474392303461939389368955986650538525895866713074543004916049550090364398070215427272240155060576252568700906004691224321432509053286859100920489253598392100207663785243368195857086816912514025693453058403158416856847185079684216151337200057494966741268925263085619240941610301610538225414050394612058339070756009433535451561664522479191267503989904464718368605684297071150902631208673621618217106272361061676184840810762902463998065947687814692402219182668782278472952758690939877465065070481351343206840649517150634973307937551168752642148704904383991876969408056379195860410677814566225456558230131911142229028179902418223009651437985670625/1793954211366022694113801876840128100034871409513586250746316776290259783425578615401030447369541046747571819748417910583511123376348523955353017744010395602173906080395504375010762174191250701116076984219741972574712741619474818186676828531882286780795390571221287481389759837587864244524002565968286448146002639202882164150037179450123657170327105882819203167448541028601906377066191895183769810676831353109303069033234715310287563158747705988305326397404720186258671215368588625611876280581509852855552819149745718992630449787803625851701801184123166018366180137512856918294030710215034138299203584
+    assert ((2 + 3*I)**-1000).expand(complex=True) == \
+        Integer(1)*-81079464736246615951519029367296227340216902563389546989376269312984127074385455204551402940331021387412262494620336565547972162814110386834027871072723273110439771695255662375718498785908345629702081336606863762777939617745464755635193139022811989314881997210583159045854968310911252660312523907616129080027594310008539817935736331124833163907518549408018652090650537035647520296539436440394920287688149200763245475036722326561143851304795139005599209239350981457301460233967137708519975586996623552182807311159141501424576682074392689622074945519232029999/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001 - Integer(1)*46938745946789557590804551905243206242164799136976022474337918748798900569942573265747576032611189047943842446167719177749107138603040963603119861476016947257034472364028585381714774667326478071264878108114128915685688115488744955550920239128462489496563930809677159214598114273887061533057125164518549173898349061972857446844052995037423459472376202251620778517659247970283904820245958198842631651569984310559418135975795868314764489884749573052997832686979294085577689571149679540256349988338406458116270429842222666345146926395233040564229555893248370000*I/8777125472973511649630750050295188683351430110097915876250894978429797369155961290321829625004920141758416719066805645579710744290541337680113772670040386863849283653078324415471816788604945889094925784900885812724984087843737442111926413818245854362613018058774368703971604921858023116665586358870612944209398056562604561248859926344335598822815885851096698226775053153403320782439987679978321289537645645163767251396759519805603090332694449553371530571613352311006350058217982509738362083094920649452123351717366337410243853659113315547584871655479914439219520157174729130746351059075207407866012574386726064196992865627149566238044625779078186624347183905913357718850537058578084932880569701242598663149911276357125355850792073635533676541250531086757377369962506979378337216411188347761901006460813413505861461267545723590468627854202034450569581626648934062198718362303420281555886394558137408159453103395918783625713213314350531051312551733021627153081075080140680608080529736975658786227362251632725009435866547613598753584705455955419696609282059191031962604169242974038517575645939316377801594539335940001
+    assert ((2 + 3*I/4)**-1000).expand(complex=True) == \
+        Integer(1)*4257256305661027385394552848555894604806501409793288342610746813288539790051927148781268212212078237301273165351052934681382567968787279534591114913777456610214738290619922068269909423637926549603264174216950025398244509039145410016404821694746262142525173737175066432954496592560621330313807235750500564940782099283410261748370262433487444897446779072067625787246390824312580440138770014838135245148574339248259670887549732495841810961088930810608893772914812838358159009303794863047635845688453859317690488124382253918725010358589723156019888846606295866740117645571396817375322724096486161308083462637370825829567578309445855481578518239186117686659177284332344643124760453112513611749309168470605289172320376911472635805822082051716625171429727162039621902266619821870482519063133136820085579315127038372190224739238686708451840610064871885616258831386810233957438253532027049148030157164346719204500373766157143311767338973363806106967439378604898250533766359989107510507493549529158818602327525235240510049484816090584478644771183158342479140194633579061295740839490629457435283873180259847394582069479062820225159699506175855369539201399183443253793905149785994830358114153241481884290274629611529758663543080724574566578220908907477622643689220814376054314972190402285121776593824615083669045183404206291739005554569305329760211752815718335731118664756831942466773261465213581616104242113894521054475516019456867271362053692785300826523328020796670205463390909136593859765912483565093461468865534470710132881677639651348709376/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001 - Integer(1)*3098214262599218784594285246258841485430681674561917573155883806818465520660668045042109232930382494608383663464454841313154390741655282039877410154577448327874989496074260116195788919037407420625081798124301494353693248757853222257918294662198297114746822817460991242508743651430439120439020484502408313310689912381846149597061657483084652685283853595100434135149479564507015504022249330340259111426799121454516345905101620532787348293877485702600390665276070250119465888154331218827342488849948540687659846652377277250614246402784754153678374932540789808703029043827352976139228402417432199779415751301480406673762521987999573209628597459357964214510139892316208670927074795773830798600837815329291912002136924506221066071242281626618211060464126372574400100990746934953437169840312584285942093951405864225230033279614235191326102697164613004299868695519642598882914862568516635347204441042798206770888274175592401790040170576311989738272102077819127459014286741435419468254146418098278519775722104890854275995510700298782146199325790002255362719776098816136732897323406228294203133323296591166026338391813696715894870956511298793595675308998014158717167429941371979636895553724830981754579086664608880698350866487717403917070872269853194118364230971216854931998642990452908852258008095741042117326241406479532880476938937997238098399302185675832474590293188864060116934035867037219176916416481757918864533515526389079998129329045569609325290897577497835388451456680707076072624629697883854217331728051953671643278797380171857920000*I/2103100954337624833663208713697737151593634525061637972297915388685604042449504336765884978184588688426595940401280828953096857809292320006227881797146858511436638446932833617514351442216409828605662238790280753075176269765767010004889778647709740770757817960711900340755635772183674511158570690702969774966791073165467918123298694584729211212414462628433370481195120564586361368504153395406845170075275051749019600057116719726628746724489572189061061036426955163696859127711110719502594479795200686212257570291758725259007379710596548777812659422174199194837355646482046783616494013289495563083118517507178847555801163089723056310287760875135196081975602765511153122381201303871673391366630940702817360340900568748719988954847590748960761446218262344767250783946365392689256634180417145926390656439421745644011831124277463643383712803287985472471755648426749842410972650924240795946699346613614779460399530274263580007672855851663196114585312432954432654691485867618908420370875753749297487803461900447407917655296784879220450937110470920633595689721819488638484547259978337741496090602390463594556401615298457456112485536498177883358587125449801777718900375736758266215245325999241624148841915093787519330809347240990363802360596034171167818310322276373120180985148650099673289383722502488957717848531612020897298448601714154586319660314294591620415272119454982220034319689607295960162971300417552364254983071768070124456169427638371140064235083443242844616326538396503937972586505546495649094344512270582463639152160238137952390380581401171977159154009407415523525096743009110916334144716516647041176989758534635251844947906038080852185583742296318878233394998111078843229681030277039104786225656992262073797524057992347971177720807155842376332851559276430280477639539393920006008737472164850104411971830120295750221200029811143140323763349636629725073624360001
+
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    assert exp(a*(2 + I*b)).expand(complex=True) == \
+        I*exp(2*a)*sin(a*b) + exp(2*a)*cos(a*b)
+
+
+def test_expand():
+    f = (16 - 2*sqrt(29))**2
+    assert f.expand() == 372 - 64*sqrt(29)
+    f = (Integer(1)/2 + I/2)**10
+    assert f.expand() == I/32
+    f = (Integer(1)/2 + I)**10
+    assert f.expand() == Integer(237)/1024 - 779*I/256
+
+
+def test_re_im1652():
+    x = Symbol('x')
+    assert re(x) == re(conjugate(x))
+    assert im(x) == - im(conjugate(x))
+    assert im(x)*re(conjugate(x)) + im(conjugate(x)) * re(x) == 0
+
+
+def test_issue_5084():
+    x = Symbol('x')
+    assert ((x + x*I)/(1 + I)).as_real_imag() == (re((x + I*x)/(1 + I)
+            ), im((x + I*x)/(1 + I)))
+
+
+def test_issue_5236():
+    assert (cos(1 + I)**3).as_real_imag() == (-3*sin(1)**2*sinh(1)**2*cos(1)*cosh(1) +
+        cos(1)**3*cosh(1)**3, -3*cos(1)**2*cosh(1)**2*sin(1)*sinh(1) + sin(1)**3*sinh(1)**3)
+
+
+def test_real_imag():
+    x, y, z = symbols('x, y, z')
+    X, Y, Z = symbols('X, Y, Z', commutative=False)
+    a = Symbol('a', real=True)
+    assert (2*a*x).as_real_imag() == (2*a*re(x), 2*a*im(x))
+
+    # issue 5395:
+    assert (x*x.conjugate()).as_real_imag() == (Abs(x)**2, 0)
+    assert im(x*x.conjugate()) == 0
+    assert im(x*y.conjugate()*z*y) == im(x*z)*Abs(y)**2
+    assert im(x*y.conjugate()*x*y) == im(x**2)*Abs(y)**2
+    assert im(Z*y.conjugate()*X*y) == im(Z*X)*Abs(y)**2
+    assert im(X*X.conjugate()) == im(X*X.conjugate(), evaluate=False)
+    assert (sin(x)*sin(x).conjugate()).as_real_imag() == \
+        (Abs(sin(x))**2, 0)
+
+    # issue 6573:
+    assert (x**2).as_real_imag() == (re(x)**2 - im(x)**2, 2*re(x)*im(x))
+
+    # issue 6428:
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    assert (i*r*x).as_real_imag() == (I*i*r*im(x), -I*i*r*re(x))
+    assert (i*r*x*(y + 2)).as_real_imag() == (
+        I*i*r*(re(y) + 2)*im(x) + I*i*r*re(x)*im(y),
+        -I*i*r*(re(y) + 2)*re(x) + I*i*r*im(x)*im(y))
+
+    # issue 7106:
+    assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
+    assert ((1 + 2*I)*(1 + 3*I)).as_real_imag() == (-5, 5)
+
+
+def test_pow_issue_1724():
+    e = ((S.NegativeOne)**(S.One/3))
+    assert e.conjugate().n() == e.n().conjugate()
+    e = S('-2/3 - (-29/54 + sqrt(93)/18)**(1/3) - 1/(9*(-29/54 + sqrt(93)/18)**(1/3))')
+    assert e.conjugate().n() == e.n().conjugate()
+    e = 2**I
+    assert e.conjugate().n() == e.n().conjugate()
+
+
+def test_issue_5429():
+    assert sqrt(I).conjugate() != sqrt(I)
+
+def test_issue_4124():
+    from sympy.core.numbers import oo
+    assert expand_complex(I*oo) == oo*I
+
+def test_issue_11518():
+    x = Symbol("x", real=True)
+    y = Symbol("y", real=True)
+    r = sqrt(x**2 + y**2)
+    assert conjugate(r) == r
+    s = abs(x + I * y)
+    assert conjugate(s) == r
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_constructor_postprocessor.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_constructor_postprocessor.py
new file mode 100644
index 0000000000000000000000000000000000000000..c199e24eddf8ef7c2a14e38d1ad2dc95e4acc0cc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_constructor_postprocessor.py
@@ -0,0 +1,87 @@
+from sympy.core.basic import Basic
+from sympy.core.mul import Mul
+from sympy.core.symbol import (Symbol, symbols)
+
+from sympy.testing.pytest import XFAIL
+
+class SymbolInMulOnce(Symbol):
+    # Test class for a symbol that can only appear once in a `Mul` expression.
+    pass
+
+
+Basic._constructor_postprocessor_mapping[SymbolInMulOnce] = {
+    "Mul": [lambda x: x],
+    "Pow": [lambda x: x.base if isinstance(x.base, SymbolInMulOnce) else x],
+    "Add": [lambda x: x],
+}
+
+
+def _postprocess_SymbolRemovesOtherSymbols(expr):
+    args = tuple(i for i in expr.args if not isinstance(i, Symbol) or isinstance(i, SymbolRemovesOtherSymbols))
+    if args == expr.args:
+        return expr
+    return Mul.fromiter(args)
+
+
+class SymbolRemovesOtherSymbols(Symbol):
+    # Test class for a symbol that removes other symbols in `Mul`.
+    pass
+
+Basic._constructor_postprocessor_mapping[SymbolRemovesOtherSymbols] = {
+    "Mul": [_postprocess_SymbolRemovesOtherSymbols],
+}
+
+class SubclassSymbolInMulOnce(SymbolInMulOnce):
+    pass
+
+class SubclassSymbolRemovesOtherSymbols(SymbolRemovesOtherSymbols):
+    pass
+
+
+def test_constructor_postprocessors1():
+    x = SymbolInMulOnce("x")
+    y = SymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+def test_constructor_postprocessors2():
+    x = SubclassSymbolInMulOnce("x")
+    y = SubclassSymbolInMulOnce("y")
+    assert isinstance(3*x, Mul)
+    assert (3*x).args == (3, x)
+    assert x*x == x
+    assert 3*x*x == 3*x
+    assert 2*x*x + x == 3*x
+    assert x**3*y*y == x*y
+    assert x**5 + y*x**3 == x + x*y
+
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert x*w == w
+    assert (3*w).args == (3, w)
+    assert set((w + x).args) == {x, w}
+
+
+@XFAIL
+def test_subexpression_postprocessors():
+    # The postprocessors used to work with subexpressions, but the
+    # functionality was removed. See #15948.
+    a = symbols("a")
+    x = SymbolInMulOnce("x")
+    w = SymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2
+
+    x = SubclassSymbolInMulOnce("x")
+    w = SubclassSymbolRemovesOtherSymbols("w")
+    assert 3*a*w**2 == 3*w**2
+    assert 3*a*x**3*w**2 == 3*w**2
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_containers.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_containers.py
new file mode 100644
index 0000000000000000000000000000000000000000..23357b9f667fffc82d93b2b1adb42b495114c67e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_containers.py
@@ -0,0 +1,217 @@
+from collections import defaultdict
+
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.numbers import Integer
+from sympy.core.kind import NumberKind
+from sympy.matrices.kind import MatrixKind
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.core.sympify import sympify
+from sympy.matrices.dense import Matrix
+from sympy.sets.sets import FiniteSet
+from sympy.core.containers import tuple_wrapper, TupleKind
+from sympy.core.expr import unchanged
+from sympy.core.function import Function, Lambda
+from sympy.core.relational import Eq
+from sympy.testing.pytest import raises
+from sympy.utilities.iterables import is_sequence, iterable
+
+from sympy.abc import x, y
+
+
+def test_Tuple():
+    t = (1, 2, 3, 4)
+    st = Tuple(*t)
+    assert set(sympify(t)) == set(st)
+    assert len(t) == len(st)
+    assert set(sympify(t[:2])) == set(st[:2])
+    assert isinstance(st[:], Tuple)
+    assert st == Tuple(1, 2, 3, 4)
+    assert st.func(*st.args) == st
+    p, q, r, s = symbols('p q r s')
+    t2 = (p, q, r, s)
+    st2 = Tuple(*t2)
+    assert st2.atoms() == set(t2)
+    assert st == st2.subs({p: 1, q: 2, r: 3, s: 4})
+    # issue 5505
+    assert all(isinstance(arg, Basic) for arg in st.args)
+    assert Tuple(p, 1).subs(p, 0) == Tuple(0, 1)
+    assert Tuple(p, Tuple(p, 1)).subs(p, 0) == Tuple(0, Tuple(0, 1))
+
+    assert Tuple(t2) == Tuple(Tuple(*t2))
+    assert Tuple.fromiter(t2) == Tuple(*t2)
+    assert Tuple.fromiter(x for x in range(4)) == Tuple(0, 1, 2, 3)
+    assert st2.fromiter(st2.args) == st2
+
+
+def test_Tuple_contains():
+    t1, t2 = Tuple(1), Tuple(2)
+    assert t1 in Tuple(1, 2, 3, t1, Tuple(t2))
+    assert t2 not in Tuple(1, 2, 3, t1, Tuple(t2))
+
+
+def test_Tuple_concatenation():
+    assert Tuple(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert (1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+    assert Tuple(1, 2) + (3, 4) == Tuple(1, 2, 3, 4)
+    raises(TypeError, lambda: Tuple(1, 2) + 3)
+    raises(TypeError, lambda: 1 + Tuple(2, 3))
+
+    #the Tuple case in __radd__ is only reached when a subclass is involved
+    class Tuple2(Tuple):
+        def __radd__(self, other):
+            return Tuple.__radd__(self, other + other)
+    assert Tuple(1, 2) + Tuple2(3, 4) == Tuple(1, 2, 1, 2, 3, 4)
+    assert Tuple2(1, 2) + Tuple(3, 4) == Tuple(1, 2, 3, 4)
+
+
+def test_Tuple_equality():
+    assert not isinstance(Tuple(1, 2), tuple)
+    assert (Tuple(1, 2) == (1, 2)) is True
+    assert (Tuple(1, 2) != (1, 2)) is False
+    assert (Tuple(1, 2) == (1, 3)) is False
+    assert (Tuple(1, 2) != (1, 3)) is True
+    assert (Tuple(1, 2) == Tuple(1, 2)) is True
+    assert (Tuple(1, 2) != Tuple(1, 2)) is False
+    assert (Tuple(1, 2) == Tuple(1, 3)) is False
+    assert (Tuple(1, 2) != Tuple(1, 3)) is True
+
+
+def test_Tuple_Eq():
+    assert Eq(Tuple(), Tuple()) is S.true
+    assert Eq(Tuple(1), 1) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1)) is S.false
+    assert Eq(Tuple(1), Tuple(1)) is S.true
+    assert Eq(Tuple(1, 2), Tuple(1, 3)) is S.false
+    assert Eq(Tuple(1, 2), Tuple(1, 2)) is S.true
+    assert unchanged(Eq, Tuple(1, x), Tuple(1, 2))
+    assert Eq(Tuple(1, x), Tuple(1, 2)).subs(x, 2) is S.true
+    assert unchanged(Eq, Tuple(1, 2), x)
+    f = Function('f')
+    assert unchanged(Eq, Tuple(1), f(x))
+    assert Eq(Tuple(1), f(x)).subs(x, 1).subs(f, Lambda(y, (y,))) is S.true
+
+
+def test_Tuple_comparision():
+    assert (Tuple(1, 3) >= Tuple(-10, 30)) is S.true
+    assert (Tuple(1, 3) <= Tuple(-10, 30)) is S.false
+    assert (Tuple(1, 3) >= Tuple(1, 3)) is S.true
+    assert (Tuple(1, 3) <= Tuple(1, 3)) is S.true
+
+
+def test_Tuple_tuple_count():
+    assert Tuple(0, 1, 2, 3).tuple_count(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).tuple_count(4) == 1
+    assert Tuple(0, 4, 1, 4, 2, 3).tuple_count(4) == 2
+    assert Tuple(0, 4, 1, 4, 2, 4, 3).tuple_count(4) == 3
+
+
+def test_Tuple_index():
+    assert Tuple(4, 0, 1, 2, 3).index(4) == 0
+    assert Tuple(0, 4, 1, 2, 3).index(4) == 1
+    assert Tuple(0, 1, 4, 2, 3).index(4) == 2
+    assert Tuple(0, 1, 2, 4, 3).index(4) == 3
+    assert Tuple(0, 1, 2, 3, 4).index(4) == 4
+
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3).index(4))
+    raises(ValueError, lambda: Tuple(4, 0, 1, 2, 3).index(4, 1))
+    raises(ValueError, lambda: Tuple(0, 1, 2, 3, 4).index(4, 1, 4))
+
+
+def test_Tuple_mul():
+    assert Tuple(1, 2, 3)*2 == Tuple(1, 2, 3, 1, 2, 3)
+    assert 2*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Tuple(1, 2, 3)*Integer(2) == Tuple(1, 2, 3, 1, 2, 3)
+    assert Integer(2)*Tuple(1, 2, 3) == Tuple(1, 2, 3, 1, 2, 3)
+
+    raises(TypeError, lambda: Tuple(1, 2, 3)*S.Half)
+    raises(TypeError, lambda: S.Half*Tuple(1, 2, 3))
+
+
+def test_tuple_wrapper():
+
+    @tuple_wrapper
+    def wrap_tuples_and_return(*t):
+        return t
+
+    p = symbols('p')
+    assert wrap_tuples_and_return(p, 1) == (p, 1)
+    assert wrap_tuples_and_return((p, 1)) == (Tuple(p, 1),)
+    assert wrap_tuples_and_return(1, (p, 2), 3) == (1, Tuple(p, 2), 3)
+
+
+def test_iterable_is_sequence():
+    ordered = [[], (), Tuple(), Matrix([[]])]
+    unordered = [set()]
+    not_sympy_iterable = [{}, '', '']
+    assert all(is_sequence(i) for i in ordered)
+    assert all(not is_sequence(i) for i in unordered)
+    assert all(iterable(i) for i in ordered + unordered)
+    assert all(not iterable(i) for i in not_sympy_iterable)
+    assert all(iterable(i, exclude=None) for i in not_sympy_iterable)
+
+
+def test_TupleKind():
+    kind = TupleKind(NumberKind, MatrixKind(NumberKind))
+    assert Tuple(1, Matrix([1, 2])).kind is kind
+    assert Tuple(1, 2).kind is TupleKind(NumberKind, NumberKind)
+    assert Tuple(1, 2).kind.element_kind == (NumberKind, NumberKind)
+
+
+def test_Dict():
+    x, y, z = symbols('x y z')
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d[x] == 1
+    assert d[y] == 2
+    raises(KeyError, lambda: d[2])
+    raises(KeyError, lambda: d['2'])
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.One, S(2), S(3)}
+    assert d.get(5, 'default') == 'default'
+    assert d.get('5', 'default') == 'default'
+    assert x in d and z in d and 5 not in d and '5' not in d
+    assert d.has(x) and d.has(1)  # SymPy Basic .has method
+
+    # Test input types
+    # input - a Python dict
+    # input - items as args - SymPy style
+    assert (Dict({x: 1, y: 2, z: 3}) ==
+            Dict((x, 1), (y, 2), (z, 3)))
+
+    raises(TypeError, lambda: Dict(((x, 1), (y, 2), (z, 3))))
+    with raises(NotImplementedError):
+        d[5] = 6  # assert immutability
+
+    assert set(
+        d.items()) == {Tuple(x, S.One), Tuple(y, S(2)), Tuple(z, S(3))}
+    assert set(d) == {x, y, z}
+    assert str(d) == '{x: 1, y: 2, z: 3}'
+    assert d.__repr__() == '{x: 1, y: 2, z: 3}'
+
+    # Test creating a Dict from a Dict.
+    d = Dict({x: 1, y: 2, z: 3})
+    assert d == Dict(d)
+
+    # Test for supporting defaultdict
+    d = defaultdict(int)
+    assert d[x] == 0
+    assert d[y] == 0
+    assert d[z] == 0
+    assert Dict(d)
+    d = Dict(d)
+    assert len(d) == 3
+    assert set(d.keys()) == {x, y, z}
+    assert set(d.values()) == {S.Zero, S.Zero, S.Zero}
+
+
+def test_issue_5788():
+    args = [(1, 2), (2, 1)]
+    for o in [Dict, Tuple, FiniteSet]:
+        # __eq__ and arg handling
+        if o != Tuple:
+            assert o(*args) == o(*reversed(args))
+        pair = [o(*args), o(*reversed(args))]
+        assert sorted(pair) == sorted(pair)
+        assert set(o(*args))  # doesn't fail
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_count_ops.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_count_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc95004ef5ba4421927289a049a9197d208c30d0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_count_ops.py
@@ -0,0 +1,155 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic
+from sympy.core.function import (Derivative, Function, count_ops)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import (Eq, Rel)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.logic.boolalg import (And, Equivalent, ITE, Implies, Nand,
+    Nor, Not, Or, Xor)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.core.containers import Tuple
+
+x, y, z = symbols('x,y,z')
+a, b, c = symbols('a,b,c')
+
+def test_count_ops_non_visual():
+    def count(val):
+        return count_ops(val, visual=False)
+    assert count(x) == 0
+    assert count(x) is not S.Zero
+    assert count(x + y) == 1
+    assert count(x + y) is not S.One
+    assert count(x + y*x + 2*y) == 4
+    assert count({x + y: x}) == 1
+    assert count({x + y: S(2) + x}) is not S.One
+    assert count(x < y) == 1
+    assert count(Or(x,y)) == 1
+    assert count(And(x,y)) == 1
+    assert count(Not(x)) == 1
+    assert count(Nor(x,y)) == 2
+    assert count(Nand(x,y)) == 2
+    assert count(Xor(x,y)) == 1
+    assert count(Implies(x,y)) == 1
+    assert count(Equivalent(x,y)) == 1
+    assert count(ITE(x,y,z)) == 1
+    assert count(ITE(True,x,y)) == 0
+
+
+def test_count_ops_visual():
+    ADD, MUL, POW, SIN, COS, EXP, AND, D, G, M = symbols(
+        'Add Mul Pow sin cos exp And Derivative Integral Sum'.upper())
+    DIV, SUB, NEG = symbols('DIV SUB NEG')
+    LT, LE, GT, GE, EQ, NE = symbols('LT LE GT GE EQ NE')
+    NOT, OR, AND, XOR, IMPLIES, EQUIVALENT, _ITE, BASIC, TUPLE = symbols(
+        'Not Or And Xor Implies Equivalent ITE Basic Tuple'.upper())
+
+    def count(val):
+        return count_ops(val, visual=True)
+
+    assert count(7) is S.Zero
+    assert count(S(7)) is S.Zero
+    assert count(-1) == NEG
+    assert count(-2) == NEG
+    assert count(S(2)/3) == DIV
+    assert count(Rational(2, 3)) == DIV
+    assert count(pi/3) == DIV
+    assert count(-pi/3) == DIV + NEG
+    assert count(I - 1) == SUB
+    assert count(1 - I) == SUB
+    assert count(1 - 2*I) == SUB + MUL
+
+    assert count(x) is S.Zero
+    assert count(-x) == NEG
+    assert count(-2*x/3) == NEG + DIV + MUL
+    assert count(Rational(-2, 3)*x) == NEG + DIV + MUL
+    assert count(1/x) == DIV
+    assert count(1/(x*y)) == DIV + MUL
+    assert count(-1/x) == NEG + DIV
+    assert count(-2/x) == NEG + DIV
+    assert count(x/y) == DIV
+    assert count(-x/y) == NEG + DIV
+
+    assert count(x**2) == POW
+    assert count(-x**2) == POW + NEG
+    assert count(-2*x**2) == POW + MUL + NEG
+
+    assert count(x + pi/3) == ADD + DIV
+    assert count(x + S.One/3) == ADD + DIV
+    assert count(x + Rational(1, 3)) == ADD + DIV
+    assert count(x + y) == ADD
+    assert count(x - y) == SUB
+    assert count(y - x) == SUB
+    assert count(-1/(x - y)) == DIV + NEG + SUB
+    assert count(-1/(y - x)) == DIV + NEG + SUB
+    assert count(1 + x**y) == ADD + POW
+    assert count(1 + x + y) == 2*ADD
+    assert count(1 + x + y + z) == 3*ADD
+    assert count(1 + x**y + 2*x*y + y**2) == 3*ADD + 2*POW + 2*MUL
+    assert count(2*z + y + x + 1) == 3*ADD + MUL
+    assert count(2*z + y**17 + x + 1) == 3*ADD + MUL + POW
+    assert count(2*z + y**17 + x + sin(x)) == 3*ADD + POW + MUL + SIN
+    assert count(2*z + y**17 + x + sin(x**2)) == 3*ADD + MUL + 2*POW + SIN
+    assert count(2*z + y**17 + x + sin(
+        x**2) + exp(cos(x))) == 4*ADD + MUL + 2*POW + EXP + COS + SIN
+
+    assert count(Derivative(x, x)) == D
+    assert count(Integral(x, x) + 2*x/(1 + x)) == G + DIV + MUL + 2*ADD
+    assert count(Sum(x, (x, 1, x + 1)) + 2*x/(1 + x)) == M + DIV + MUL + 3*ADD
+    assert count(Basic()) is S.Zero
+
+    assert count({x + 1: sin(x)}) == ADD + SIN
+    assert count([x + 1, sin(x) + y, None]) == ADD + SIN + ADD
+    assert count({x + 1: sin(x), y: cos(x) + 1}) == SIN + COS + 2*ADD
+    assert count({}) is S.Zero
+    assert count([x + 1, sin(x)*y, None]) == SIN + ADD + MUL
+    assert count([]) is S.Zero
+
+    assert count(Basic()) == 0
+    assert count(Basic(Basic(),Basic(x,x+y))) == ADD + 2*BASIC
+    assert count(Basic(x, x + y)) == ADD + BASIC
+    assert [count(Rel(x, y, op)) for op in '< <= > >= == <> !='.split()
+        ] == [LT, LE, GT, GE, EQ, NE, NE]
+    assert count(Or(x, y)) == OR
+    assert count(And(x, y)) == AND
+    assert count(Or(x, Or(y, And(z, a)))) == AND + OR
+    assert count(Nor(x, y)) == NOT + OR
+    assert count(Nand(x, y)) == NOT + AND
+    assert count(Xor(x, y)) == XOR
+    assert count(Implies(x, y)) == IMPLIES
+    assert count(Equivalent(x, y)) == EQUIVALENT
+    assert count(ITE(x, y, z)) == _ITE
+    assert count([Or(x, y), And(x, y), Basic(x + y)]
+        ) == ADD + AND + BASIC + OR
+
+    assert count(Basic(Tuple(x))) == BASIC + TUPLE
+    #It checks that TUPLE is counted as an operation.
+
+    assert count(Eq(x + y, S(2))) == ADD + EQ
+
+
+def test_issue_9324():
+    def count(val):
+        return count_ops(val, visual=False)
+
+    M = MatrixSymbol('M', 10, 10)
+    assert count(M[0, 0]) == 0
+    assert count(2 * M[0, 0] + M[5, 7]) == 2
+    P = MatrixSymbol('P', 3, 3)
+    Q = MatrixSymbol('Q', 3, 3)
+    assert count(P + Q) == 1
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True)
+    M = MatrixSymbol('M', m + n, m * m)
+    assert count(M[0, 1]) == 2
+
+
+def test_issue_21532():
+    f = Function('f')
+    g = Function('g')
+    FUNC_F, FUNC_G = symbols('FUNC_F, FUNC_G')
+    assert f(x).count_ops(visual=True) == FUNC_F
+    assert g(x).count_ops(visual=True) == FUNC_G
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_diff.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_diff.py
new file mode 100644
index 0000000000000000000000000000000000000000..effc9cd91d2e7b6f8f8e5fd04bb667ed71c0ffaf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_diff.py
@@ -0,0 +1,160 @@
+from sympy.concrete.summations import Sum
+from sympy.core.expr import Expr
+from sympy.core.function import (Derivative, Function, diff, Subs)
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (cos, cot, sin, tan)
+from sympy.tensor.array.ndim_array import NDimArray
+from sympy.testing.pytest import raises
+from sympy.abc import a, b, c, x, y, z
+
+def test_diff():
+    assert Rational(1, 3).diff(x) is S.Zero
+    assert I.diff(x) is S.Zero
+    assert pi.diff(x) is S.Zero
+    assert x.diff(x, 0) == x
+    assert (x**2).diff(x, 2, x) == 0
+    assert (x**2).diff((x, 2), x) == 0
+    assert (x**2).diff((x, 1), x) == 2
+    assert (x**2).diff((x, 1), (x, 1)) == 2
+    assert (x**2).diff((x, 2)) == 2
+    assert (x**2).diff(x, y, 0) == 2*x
+    assert (x**2).diff(x, (y, 0)) == 2*x
+    assert (x**2).diff(x, y) == 0
+    raises(ValueError, lambda: x.diff(1, x))
+
+    p = Rational(5)
+    e = a*b + b**p
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4
+    assert e.diff(b).diff(a) == Rational(1)
+    e = a*(b + c)
+    assert e.diff(a) == b + c
+    assert e.diff(b) == a
+    assert e.diff(b).diff(a) == Rational(1)
+    e = c**p
+    assert e.diff(c, 6) == Rational(0)
+    assert e.diff(c, 5) == Rational(120)
+    e = c**Rational(2)
+    assert e.diff(c) == 2*c
+    e = a*b*c
+    assert e.diff(c) == a*b
+
+
+def test_diff2():
+    n3 = Rational(3)
+    n2 = Rational(2)
+    n6 = Rational(6)
+
+    e = n3*(-n2 + x**n2)*cos(x) + x*(-n6 + x**n2)*sin(x)
+    assert e == 3*(-2 + x**2)*cos(x) + x*(-6 + x**2)*sin(x)
+    assert e.diff(x).expand() == x**3*cos(x)
+
+    e = (x + 1)**3
+    assert e.diff(x) == 3*(x + 1)**2
+    e = x*(x + 1)**3
+    assert e.diff(x) == (x + 1)**3 + 3*x*(x + 1)**2
+    e = 2*exp(x*x)*x
+    assert e.diff(x) == 2*exp(x**2) + 4*x**2*exp(x**2)
+
+
+def test_diff3():
+    p = Rational(5)
+    e = a*b + sin(b**p)
+    assert e == a*b + sin(b**5)
+    assert e.diff(a) == b
+    assert e.diff(b) == a + 5*b**4*cos(b**5)
+    e = tan(c)
+    assert e == tan(c)
+    assert e.diff(c) in [cos(c)**(-2), 1 + sin(c)**2/cos(c)**2, 1 + tan(c)**2]
+    e = c*log(c) - c
+    assert e == -c + c*log(c)
+    assert e.diff(c) == log(c)
+    e = log(sin(c))
+    assert e == log(sin(c))
+    assert e.diff(c) in [sin(c)**(-1)*cos(c), cot(c)]
+    e = (Rational(2)**a/log(Rational(2)))
+    assert e == 2**a*log(Rational(2))**(-1)
+    assert e.diff(a) == 2**a
+
+
+def test_diff_no_eval_derivative():
+    class My(Expr):
+        def __new__(cls, x):
+            return Expr.__new__(cls, x)
+
+    # My doesn't have its own _eval_derivative method
+    assert My(x).diff(x).func is Derivative
+    assert My(x).diff(x, 3).func is Derivative
+    assert re(x).diff(x, 2) == Derivative(re(x), (x, 2))  # issue 15518
+    assert diff(NDimArray([re(x), im(x)]), (x, 2)) == NDimArray(
+        [Derivative(re(x), (x, 2)), Derivative(im(x), (x, 2))])
+    # it doesn't have y so it shouldn't need a method for this case
+    assert My(x).diff(y) == 0
+
+
+def test_speed():
+    # this should return in 0.0s. If it takes forever, it's wrong.
+    assert x.diff(x, 10**8) == 0
+
+
+def test_deriv_noncommutative():
+    A = Symbol("A", commutative=False)
+    f = Function("f")
+    assert A*f(x)*A == f(x)*A**2
+    assert A*f(x).diff(x)*A == f(x).diff(x) * A**2
+
+
+def test_diff_nth_derivative():
+    f =  Function("f")
+    n = Symbol("n", integer=True)
+
+    expr = diff(sin(x), (x, n))
+    expr2 = diff(f(x), (x, 2))
+    expr3 = diff(f(x), (x, n))
+
+    assert expr.subs(sin(x), cos(-x)) == Derivative(cos(-x), (x, n))
+    assert expr.subs(n, 1).doit() == cos(x)
+    assert expr.subs(n, 2).doit() == -sin(x)
+
+    assert expr2.subs(Derivative(f(x), x), y) == Derivative(y, x)
+    # Currently not supported (cannot determine if `n > 1`):
+    #assert expr3.subs(Derivative(f(x), x), y) == Derivative(y, (x, n-1))
+    assert expr3 == Derivative(f(x), (x, n))
+
+    assert diff(x, (x, n)) == Piecewise((x, Eq(n, 0)), (1, Eq(n, 1)), (0, True))
+    assert diff(2*x, (x, n)).dummy_eq(
+        Sum(Piecewise((2*x*factorial(n)/(factorial(y)*factorial(-y + n)),
+        Eq(y, 0) & Eq(Max(0, -y + n), 0)),
+        (2*factorial(n)/(factorial(y)*factorial(-y + n)), Eq(y, 0) & Eq(Max(0,
+        -y + n), 1)), (0, True)), (y, 0, n)))
+    # TODO: assert diff(x**2, (x, n)) == x**(2-n)*ff(2, n)
+    exprm = x*sin(x)
+    mul_diff = diff(exprm, (x, n))
+    assert isinstance(mul_diff, Sum)
+    for i in range(5):
+        assert mul_diff.subs(n, i).doit() == exprm.diff((x, i)).expand()
+
+    exprm2 = 2*y*x*sin(x)*cos(x)*log(x)*exp(x)
+    dex = exprm2.diff((x, n))
+    assert isinstance(dex, Sum)
+    for i in range(7):
+        assert dex.subs(n, i).doit().expand() == \
+        exprm2.diff((x, i)).expand()
+
+    assert (cos(x)*sin(y)).diff([[x, y, z]]) == NDimArray([
+        -sin(x)*sin(y), cos(x)*cos(y), 0])
+
+
+def test_issue_16160():
+    assert Derivative(x**3, (x, x)).subs(x, 2) == Subs(
+        Derivative(x**3, (x, 2)), x, 2)
+    assert Derivative(1 + x**3, (x, x)).subs(x, 0
+        ) == Derivative(1 + y**3, (y, 0)).subs(y, 0)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_equal.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_equal.py
new file mode 100644
index 0000000000000000000000000000000000000000..82213b757cda5fbd80310e387bdf00cc1c9c25fe
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_equal.py
@@ -0,0 +1,89 @@
+from sympy.core.numbers import Rational
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.exponential import exp
+
+
+def test_equal():
+    b = Symbol("b")
+    a = Symbol("a")
+    e1 = a + b
+    e2 = 2*a*b
+    e3 = a**3*b**2
+    e4 = a*b + b*a
+    assert not e1 == e2
+    assert not e1 == e2
+    assert e1 != e2
+    assert e2 == e4
+    assert e2 != e3
+    assert not e2 == e3
+
+    x = Symbol("x")
+    e1 = exp(x + 1/x)
+    y = Symbol("x")
+    e2 = exp(y + 1/y)
+    assert e1 == e2
+    assert not e1 != e2
+    y = Symbol("y")
+    e2 = exp(y + 1/y)
+    assert not e1 == e2
+    assert e1 != e2
+
+    e5 = Rational(3) + 2*x - x - x
+    assert e5 == 3
+    assert 3 == e5
+    assert e5 != 4
+    assert 4 != e5
+    assert e5 != 3 + x
+    assert 3 + x != e5
+
+
+def test_expevalbug():
+    x = Symbol("x")
+    e1 = exp(1*x)
+    e3 = exp(x)
+    assert e1 == e3
+
+
+def test_cmp_bug1():
+    class T:
+        pass
+
+    t = T()
+    x = Symbol("x")
+
+    assert not (x == t)
+    assert (x != t)
+
+
+def test_cmp_bug2():
+    class T:
+        pass
+
+    t = T()
+
+    assert not (Symbol == t)
+    assert (Symbol != t)
+
+
+def test_cmp_issue_4357():
+    """ Check that Basic subclasses can be compared with sympifiable objects.
+
+    https://github.com/sympy/sympy/issues/4357
+    """
+    assert not (Symbol == 1)
+    assert (Symbol != 1)
+    assert not (Symbol == 'x')
+    assert (Symbol != 'x')
+
+
+def test_dummy_eq():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    u = Dummy('u')
+
+    assert (u**2 + 1).dummy_eq(x**2 + 1) is True
+    assert ((u**2 + 1) == (x**2 + 1)) is False
+
+    assert (u**2 + y).dummy_eq(x**2 + y, x) is True
+    assert (u**2 + y).dummy_eq(x**2 + y, y) is False
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_eval.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_eval.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c1633f77b50483afee21c6d9fca232b1279d2b9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_eval.py
@@ -0,0 +1,95 @@
+from sympy.core.function import Function
+from sympy.core.numbers import (I, Rational)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, tan)
+from sympy.testing.pytest import XFAIL
+
+
+def test_add_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert a*b + c + p == a*b + 6
+    assert c + a + p == a + 6
+    assert c + a - p == a + (-4)
+    assert a + a == 2*a
+    assert a + p + a == 2*a + 5
+    assert c + p == Rational(6)
+    assert b + a - b == a
+
+
+def test_addmul_eval():
+    a = Symbol("a")
+    b = Symbol("b")
+    c = Rational(1)
+    p = Rational(5)
+    assert c + a + b*c + a - p == 2*a + b + (-4)
+    assert a*2 + p + a == a*2 + 5 + a
+    assert a*2 + p + a == 3*a + 5
+    assert a*2 + a == 3*a
+
+
+def test_pow_eval():
+    # XXX Pow does not fully support conversion of negative numbers
+    #     to their complex equivalent
+
+    assert sqrt(-1) == I
+
+    assert sqrt(-4) == 2*I
+    assert sqrt( 4) == 2
+    assert (8)**Rational(1, 3) == 2
+    assert (-8)**Rational(1, 3) == 2*((-1)**Rational(1, 3))
+
+    assert sqrt(-2) == I*sqrt(2)
+    assert (-1)**Rational(1, 3) != I
+    assert (-10)**Rational(1, 3) != I*((10)**Rational(1, 3))
+    assert (-2)**Rational(1, 4) != (2)**Rational(1, 4)
+
+    assert 64**Rational(1, 3) == 4
+    assert 64**Rational(2, 3) == 16
+    assert 24/sqrt(64) == 3
+    assert (-27)**Rational(1, 3) == 3*(-1)**Rational(1, 3)
+
+    assert (cos(2) / tan(2))**2 == (cos(2) / tan(2))**2
+
+
+@XFAIL
+def test_pow_eval_X1():
+    assert (-1)**Rational(1, 3) == S.Half + S.Half*I*sqrt(3)
+
+
+def test_mulpow_eval():
+    x = Symbol('x')
+    assert sqrt(50)/(sqrt(2)*x) == 5/x
+    assert sqrt(27)/sqrt(3) == 3
+
+
+def test_evalpow_bug():
+    x = Symbol("x")
+    assert 1/(1/x) == x
+    assert 1/(-1/x) == -x
+
+
+def test_symbol_expand():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    f = x**4*y**4
+    assert f == x**4*y**4
+    assert f == f.expand()
+
+    g = (x*y)**4
+    assert g == f
+    assert g.expand() == f
+    assert g.expand() == g.expand().expand()
+
+
+def test_function():
+    f, l = map(Function, 'fl')
+    x = Symbol('x')
+    assert exp(l(x))*l(x)/exp(l(x)) == l(x)
+    assert exp(f(x))*f(x)/exp(f(x)) == f(x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_evalf.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_evalf.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c3c26a2d265da9ea2daa73a9eea3091b2af1999
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_evalf.py
@@ -0,0 +1,738 @@
+import math
+
+from sympy.concrete.products import (Product, product)
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.evalf import N
+from sympy.core.function import (Function, nfloat)
+from sympy.core.mul import Mul
+from sympy.core import (GoldenRatio)
+from sympy.core.numbers import (AlgebraicNumber, E, Float, I, Rational,
+                                oo, zoo, nan, pi)
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.complexes import (Abs, re, im)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, cosh)
+from sympy.functions.elementary.integers import (ceiling, floor)
+from sympy.functions.elementary.miscellaneous import (Max, sqrt)
+from sympy.functions.elementary.trigonometric import (acos, atan, cos, sin, tan)
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import CRootOf
+from sympy.polys.specialpolys import cyclotomic_poly
+from sympy.printing import srepr
+from sympy.printing.str import sstr
+from sympy.simplify.simplify import simplify
+from sympy.core.numbers import comp
+from sympy.core.evalf import (complex_accuracy, PrecisionExhausted,
+                              scaled_zero, get_integer_part, as_mpmath, evalf, _evalf_with_bounded_error)
+from mpmath import inf, ninf, make_mpc
+from mpmath.libmp.libmpf import from_float, fzero
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises, XFAIL
+from sympy.abc import n, x, y
+
+
+def NS(e, n=15, **options):
+    return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+
+def test_evalf_helpers():
+    from mpmath.libmp import finf
+    assert complex_accuracy((from_float(2.0), None, 35, None)) == 35
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 35, 100)) == 37
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 35, 100)) == 43
+    assert complex_accuracy((from_float(2.0), from_float(10.0), 100, 35)) == 35
+    assert complex_accuracy(
+        (from_float(2.0), from_float(1000.0), 100, 35)) == 35
+    assert complex_accuracy(finf) == math.inf
+    assert complex_accuracy(zoo) == math.inf
+    raises(ValueError, lambda: get_integer_part(zoo, 1, {}))
+
+
+def test_evalf_basic():
+    assert NS('pi', 15) == '3.14159265358979'
+    assert NS('2/3', 10) == '0.6666666667'
+    assert NS('355/113-pi', 6) == '2.66764e-7'
+    assert NS('16*atan(1/5)-4*atan(1/239)', 15) == '3.14159265358979'
+
+
+def test_cancellation():
+    assert NS(Add(pi, Rational(1, 10**1000), -pi, evaluate=False), 15,
+              maxn=1200) == '1.00000000000000e-1000'
+
+
+def test_evalf_powers():
+    assert NS('pi**(10**20)', 10) == '1.339148777e+49714987269413385435'
+    assert NS(pi**(10**100), 10) == ('4.946362032e+4971498726941338543512682882'
+          '9089887365167832438044244613405349992494711208'
+          '95526746555473864642912223')
+    assert NS('2**(1/10**50)', 15) == '1.00000000000000'
+    assert NS('2**(1/10**50)-1', 15) == '6.93147180559945e-51'
+
+# Evaluation of Rump's ill-conditioned polynomial
+
+
+def test_evalf_rump():
+    a = 1335*y**6/4 + x**2*(11*x**2*y**2 - y**6 - 121*y**4 - 2) + 11*y**8/2 + x/(2*y)
+    assert NS(a, 15, subs={x: 77617, y: 33096}) == '-0.827396059946821'
+
+
+def test_evalf_complex():
+    assert NS('2*sqrt(pi)*I', 10) == '3.544907702*I'
+    assert NS('3+3*I', 15) == '3.00000000000000 + 3.00000000000000*I'
+    assert NS('E+pi*I', 15) == '2.71828182845905 + 3.14159265358979*I'
+    assert NS('pi * (3+4*I)', 15) == '9.42477796076938 + 12.5663706143592*I'
+    assert NS('I*(2+I)', 15) == '-1.00000000000000 + 2.00000000000000*I'
+
+
+@XFAIL
+def test_evalf_complex_bug():
+    assert NS('(pi+E*I)*(E+pi*I)', 15) in ('0.e-15 + 17.25866050002*I',
+              '0.e-17 + 17.25866050002*I', '-0.e-17 + 17.25866050002*I')
+
+
+def test_evalf_complex_powers():
+    assert NS('(E+pi*I)**100000000000000000') == \
+        '-3.58896782867793e+61850354284995199 + 4.58581754997159e+61850354284995199*I'
+    # XXX: rewrite if a+a*I simplification introduced in SymPy
+    #assert NS('(pi + pi*I)**2') in ('0.e-15 + 19.7392088021787*I', '0.e-16 + 19.7392088021787*I')
+    assert NS('(pi + pi*I)**2', chop=True) == '19.7392088021787*I'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**2') == '6.2831853e-8 + 19.7392088650106*I'
+    assert NS('(pi + 1/10**12 + pi*I)**2') == '6.283e-12 + 19.7392088021850*I'
+    assert NS('(pi + pi*I)**4', chop=True) == '-389.636364136010'
+    assert NS(
+        '(pi + 1/10**8 + pi*I)**4') == '-389.636366616512 + 2.4805021e-6*I'
+    assert NS('(pi + 1/10**12 + pi*I)**4') == '-389.636364136258 + 2.481e-10*I'
+    assert NS(
+        '(10000*pi + 10000*pi*I)**4', chop=True) == '-3.89636364136010e+18'
+
+
+@XFAIL
+def test_evalf_complex_powers_bug():
+    assert NS('(pi + pi*I)**4') == '-389.63636413601 + 0.e-14*I'
+
+
+def test_evalf_exponentiation():
+    assert NS(sqrt(-pi)) == '1.77245385090552*I'
+    assert NS(Pow(pi*I, Rational(
+        1, 2), evaluate=False)) == '1.25331413731550 + 1.25331413731550*I'
+    assert NS(pi**I) == '0.413292116101594 + 0.910598499212615*I'
+    assert NS(pi**(E + I/3)) == '20.8438653991931 + 8.36343473930031*I'
+    assert NS((pi + I/3)**(E + I/3)) == '17.2442906093590 + 13.6839376767037*I'
+    assert NS(exp(pi)) == '23.1406926327793'
+    assert NS(exp(pi + E*I)) == '-21.0981542849657 + 9.50576358282422*I'
+    assert NS(pi**pi) == '36.4621596072079'
+    assert NS((-pi)**pi) == '-32.9138577418939 - 15.6897116534332*I'
+    assert NS((-pi)**(-pi)) == '-0.0247567717232697 + 0.0118013091280262*I'
+
+# An example from Smith, "Multiple Precision Complex Arithmetic and Functions"
+
+
+def test_evalf_complex_cancellation():
+    A = Rational('63287/100000')
+    B = Rational('52498/100000')
+    C = Rational('69301/100000')
+    D = Rational('83542/100000')
+    F = Rational('2231321613/2500000000')
+    # XXX: the number of returned mantissa digits in the real part could
+    # change with the implementation. What matters is that the returned digits are
+    # correct; those that are showing now are correct.
+    # >>> ((A+B*I)*(C+D*I)).expand()
+    # 64471/10000000000 + 2231321613*I/2500000000
+    # >>> 2231321613*4
+    # 8925286452L
+    assert NS((A + B*I)*(C + D*I), 6) == '6.44710e-6 + 0.892529*I'
+    assert NS((A + B*I)*(C + D*I), 10) == '6.447100000e-6 + 0.8925286452*I'
+    assert NS((A + B*I)*(
+        C + D*I) - F*I, 5) in ('6.4471e-6 + 0.e-14*I', '6.4471e-6 - 0.e-14*I')
+
+
+def test_evalf_logs():
+    assert NS("log(3+pi*I)", 15) == '1.46877619736226 + 0.808448792630022*I'
+    assert NS("log(pi*I)", 15) == '1.14472988584940 + 1.57079632679490*I'
+    assert NS('log(-1 + 0.00001)', 2) == '-1.0e-5 + 3.1*I'
+    assert NS('log(100, 10, evaluate=False)', 15) == '2.00000000000000'
+    assert NS('-2*I*log(-(-1)**(S(1)/9))', 15) == '-5.58505360638185'
+
+
+def test_evalf_trig():
+    assert NS('sin(1)', 15) == '0.841470984807897'
+    assert NS('cos(1)', 15) == '0.540302305868140'
+    assert NS('tan(1)', 15) == '1.55740772465490'
+    assert NS('sin(10**-6)', 15) == '9.99999999999833e-7'
+    assert NS('cos(10**-6)', 15) == '0.999999999999500'
+    assert NS('tan(10**-6)', 15) == '1.00000000000033e-6'
+    assert NS('sin(E*10**100)', 15) == '0.409160531722613'
+    assert NS('tan(I)',15) =='0.761594155955765*I'
+    assert NS('tan(1000*I)',15)== '1.00000000000000*I'
+    # Some input near roots
+    assert NS(sin(exp(pi*sqrt(163))*pi), 15) == '-2.35596641936785e-12'
+    assert NS(sin(pi*10**100 + Rational(7, 10**5), evaluate=False), 15, maxn=120) == \
+        '6.99999999428333e-5'
+    assert NS(sin(Rational(7, 10**5), evaluate=False), 15) == \
+        '6.99999999428333e-5'
+
+# Check detection of various false identities
+
+
+def test_evalf_near_integers():
+    # Binet's formula
+    f = lambda n: ((1 + sqrt(5))**n)/(2**n * sqrt(5))
+    assert NS(f(5000) - fibonacci(5000), 10, maxn=1500) == '5.156009964e-1046'
+    # Some near-integer identities from
+    # http://mathworld.wolfram.com/AlmostInteger.html
+    assert NS('sin(2017*2**(1/5))', 15) == '-1.00000000000000'
+    assert NS('sin(2017*2**(1/5))', 20) == '-0.99999999999999997857'
+    assert NS('1+sin(2017*2**(1/5))', 15) == '2.14322287389390e-17'
+    assert NS('45 - 613*E/37 + 35/991', 15) == '6.03764498766326e-11'
+
+
+def test_evalf_ramanujan():
+    assert NS(exp(pi*sqrt(163)) - 640320**3 - 744, 10) == '-7.499274028e-13'
+    # A related identity
+    A = 262537412640768744*exp(-pi*sqrt(163))
+    B = 196884*exp(-2*pi*sqrt(163))
+    C = 103378831900730205293632*exp(-3*pi*sqrt(163))
+    assert NS(1 - A - B + C, 10) == '1.613679005e-59'
+
+# Input that for various reasons have failed at some point
+
+
+def test_evalf_bugs():
+    assert NS(sin(1) + exp(-10**10), 10) == NS(sin(1), 10)
+    assert NS(exp(10**10) + sin(1), 10) == NS(exp(10**10), 10)
+    assert NS('expand_log(log(1+1/10**50))', 20) == '1.0000000000000000000e-50'
+    assert NS('log(10**100,10)', 10) == '100.0000000'
+    assert NS('log(2)', 10) == '0.6931471806'
+    assert NS(
+        '(sin(x)-x)/x**3', 15, subs={x: '1/10**50'}) == '-0.166666666666667'
+    assert NS(sin(1) + Rational(
+        1, 10**100)*I, 15) == '0.841470984807897 + 1.00000000000000e-100*I'
+    assert x.evalf() == x
+    assert NS((1 + I)**2*I, 6) == '-2.00000'
+    d = {n: (
+        -1)**Rational(6, 7), y: (-1)**Rational(4, 7), x: (-1)**Rational(2, 7)}
+    assert NS((x*(1 + y*(1 + n))).subs(d).evalf(), 6) == '0.346011 + 0.433884*I'
+    assert NS(((-I - sqrt(2)*I)**2).evalf()) == '-5.82842712474619'
+    assert NS((1 + I)**2*I, 15) == '-2.00000000000000'
+    # issue 4758 (1/2):
+    assert NS(pi.evalf(69) - pi) == '-4.43863937855894e-71'
+    # issue 4758 (2/2): With the bug present, this still only fails if the
+    # terms are in the order given here. This is not generally the case,
+    # because the order depends on the hashes of the terms.
+    assert NS(20 - 5008329267844*n**25 - 477638700*n**37 - 19*n,
+              subs={n: .01}) == '19.8100000000000'
+    assert NS(((x - 1)*(1 - x)**1000).n()
+              ) == '(1.00000000000000 - x)**1000*(x - 1.00000000000000)'
+    assert NS((-x).n()) == '-x'
+    assert NS((-2*x).n()) == '-2.00000000000000*x'
+    assert NS((-2*x*y).n()) == '-2.00000000000000*x*y'
+    assert cos(x).n(subs={x: 1+I}) == cos(x).subs(x, 1+I).n()
+    # issue 6660. Also NaN != mpmath.nan
+    # In this order:
+    # 0*nan, 0/nan, 0*inf, 0/inf
+    # 0+nan, 0-nan, 0+inf, 0-inf
+    # >>> n = Some Number
+    # n*nan, n/nan, n*inf, n/inf
+    # n+nan, n-nan, n+inf, n-inf
+    assert (0*E**(oo)).n() is S.NaN
+    assert (0/E**(oo)).n() is S.Zero
+
+    assert (0+E**(oo)).n() is S.Infinity
+    assert (0-E**(oo)).n() is S.NegativeInfinity
+
+    assert (5*E**(oo)).n() is S.Infinity
+    assert (5/E**(oo)).n() is S.Zero
+
+    assert (5+E**(oo)).n() is S.Infinity
+    assert (5-E**(oo)).n() is S.NegativeInfinity
+
+    #issue 7416
+    assert as_mpmath(0.0, 10, {'chop': True}) == 0
+
+    #issue 5412
+    assert ((oo*I).n() == S.Infinity*I)
+    assert ((oo+oo*I).n() == S.Infinity + S.Infinity*I)
+
+    #issue 11518
+    assert NS(2*x**2.5, 5) == '2.0000*x**2.5000'
+
+    #issue 13076
+    assert NS(Mul(Max(0, y), x, evaluate=False).evalf()) == 'x*Max(0, y)'
+
+    #issue 18516
+    assert NS(log(S(3273390607896141870013189696827599152216642046043064789483291368096133796404674554883270092325904157150886684127560071009217256545885393053328527589376)/36360291795869936842385267079543319118023385026001623040346035832580600191583895484198508262979388783308179702534403855752855931517013066142992430916562025780021771247847643450125342836565813209972590371590152578728008385990139795377610001).evalf(15, chop=True)) == '-oo'
+
+
+def test_evalf_integer_parts():
+    a = floor(log(8)/log(2) - exp(-1000), evaluate=False)
+    b = floor(log(8)/log(2), evaluate=False)
+    assert a.evalf() == 3.0
+    assert b.evalf() == 3.0
+    # equals, as a fallback, can still fail but it might succeed as here
+    assert ceiling(10*(sin(1)**2 + cos(1)**2)) == 10
+
+    assert int(floor(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336800)
+    assert int(ceiling(factorial(50)/E, evaluate=False).evalf(70)) == \
+        int(11188719610782480504630258070757734324011354208865721592720336801)
+    assert int(floor(GoldenRatio**999 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(999)
+    assert int(floor(GoldenRatio**1000 / sqrt(5) + S.Half)
+               .evalf(1000)) == fibonacci(1000)
+
+    assert ceiling(x).evalf(subs={x: 3}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2 + 3*I}) == 2.0 + 3.0*I
+    assert ceiling(x).evalf(subs={x: 3.}) == 3.0
+    assert ceiling(x).evalf(subs={x: 3.*I}) == 3.0*I
+    assert ceiling(x).evalf(subs={x: 2. + 3*I}) == 2.0 + 3.0*I
+
+    assert float((floor(1.5, evaluate=False)+1/9).evalf()) == 1 + 1/9
+    assert float((floor(0.5, evaluate=False)+20).evalf()) == 20
+
+    # issue 19991
+    n = 1169809367327212570704813632106852886389036911
+    r = 744723773141314414542111064094745678855643068
+
+    assert floor(n / (pi / 2)) == r
+    assert floor(80782 * sqrt(2)) == 114242
+
+    # issue 20076
+    assert 260515 - floor(260515/pi + 1/2) * pi == atan(tan(260515))
+
+    assert floor(x).evalf(subs={x: sqrt(2)}) == 1.0
+
+
+def test_evalf_trig_zero_detection():
+    a = sin(160*pi, evaluate=False)
+    t = a.evalf(maxn=100)
+    assert abs(t) < 1e-100
+    assert t._prec < 2
+    assert a.evalf(chop=True) == 0
+    raises(PrecisionExhausted, lambda: a.evalf(strict=True))
+
+
+def test_evalf_sum():
+    assert Sum(n,(n,1,2)).evalf() == 3.
+    assert Sum(n,(n,1,2)).doit().evalf() == 3.
+    # the next test should return instantly
+    assert Sum(1/n,(n,1,2)).evalf() == 1.5
+
+    # issue 8219
+    assert Sum(E/factorial(n), (n, 0, oo)).evalf() == (E*E).evalf()
+    # issue 8254
+    assert Sum(2**n*n/factorial(n), (n, 0, oo)).evalf() == (2*E*E).evalf()
+    # issue 8411
+    s = Sum(1/x**2, (x, 100, oo))
+    assert s.n() == s.doit().n()
+
+
+def test_evalf_divergent_series():
+    raises(ValueError, lambda: Sum(1/n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n/(n**2 + 1), (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-1)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(n**2, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum(2**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((-2)**n, (n, 1, oo)).evalf())
+    raises(ValueError, lambda: Sum((2*n + 3)/(3*n**2 + 4), (n, 0, oo)).evalf())
+    raises(ValueError, lambda: Sum((0.5*n**3)/(n**4 + 1), (n, 0, oo)).evalf())
+
+
+def test_evalf_product():
+    assert Product(n, (n, 1, 10)).evalf() == 3628800.
+    assert comp(Product(1 - S.Half**2/n**2, (n, 1, oo)).n(5), 0.63662)
+    assert Product(n, (n, -1, 3)).evalf() == 0
+
+
+def test_evalf_py_methods():
+    assert abs(float(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(complex(pi + 1) - 4.1415926535897932) < 1e-10
+    assert abs(
+        complex(pi + E*I) - (3.1415926535897931 + 2.7182818284590451j)) < 1e-10
+    raises(TypeError, lambda: float(pi + x))
+
+
+def test_evalf_power_subs_bugs():
+    assert (x**2).evalf(subs={x: 0}) == 0
+    assert sqrt(x).evalf(subs={x: 0}) == 0
+    assert (x**Rational(2, 3)).evalf(subs={x: 0}) == 0
+    assert (x**x).evalf(subs={x: 0}) == 1.0
+    assert (3**x).evalf(subs={x: 0}) == 1.0
+    assert exp(x).evalf(subs={x: 0}) == 1.0
+    assert ((2 + I)**x).evalf(subs={x: 0}) == 1.0
+    assert (0**x).evalf(subs={x: 0}) == 1.0
+
+
+def test_evalf_arguments():
+    raises(TypeError, lambda: pi.evalf(method="garbage"))
+
+
+def test_implemented_function_evalf():
+    from sympy.utilities.lambdify import implemented_function
+    f = Function('f')
+    f = implemented_function(f, lambda x: x + 1)
+    assert str(f(x)) == "f(x)"
+    assert str(f(2)) == "f(2)"
+    assert f(2).evalf() == 3.0
+    assert f(x).evalf() == f(x)
+    f = implemented_function(Function('sin'), lambda x: x + 1)
+    assert f(2).evalf() != sin(2)
+    del f._imp_     # XXX: due to caching _imp_ would influence all other tests
+
+
+def test_evaluate_false():
+    for no in [0, False]:
+        assert Add(3, 2, evaluate=no).is_Add
+        assert Mul(3, 2, evaluate=no).is_Mul
+        assert Pow(3, 2, evaluate=no).is_Pow
+    assert Pow(y, 2, evaluate=True) - Pow(y, 2, evaluate=True) == 0
+
+
+def test_evalf_relational():
+    assert Eq(x/5, y/10).evalf() == Eq(0.2*x, 0.1*y)
+    # if this first assertion fails it should be replaced with
+    # one that doesn't
+    assert unchanged(Eq, (3 - I)**2/2 + I, 0)
+    assert Eq((3 - I)**2/2 + I, 0).n() is S.false
+    assert nfloat(Eq((3 - I)**2 + I, 0)) == S.false
+
+
+def test_issue_5486():
+    assert not cos(sqrt(0.5 + I)).n().is_Function
+
+
+def test_issue_5486_bug():
+    from sympy.core.expr import Expr
+    from sympy.core.numbers import I
+    assert abs(Expr._from_mpmath(I._to_mpmath(15), 15) - I) < 1.0e-15
+
+
+def test_bugs():
+    from sympy.functions.elementary.complexes import (polar_lift, re)
+
+    assert abs(re((1 + I)**2)) < 1e-15
+
+    # anything that evalf's to 0 will do in place of polar_lift
+    assert abs(polar_lift(0)).n() == 0
+
+
+def test_subs():
+    assert NS('besseli(-x, y) - besseli(x, y)', subs={x: 3.5, y: 20.0}) == \
+        '-4.92535585957223e-10'
+    assert NS('Piecewise((x, x>0)) + Piecewise((1-x, x>0))', subs={x: 0.1}) == \
+        '1.00000000000000'
+    raises(TypeError, lambda: x.evalf(subs=(x, 1)))
+
+
+def test_issue_4956_5204():
+    # issue 4956
+    v = S('''(-27*12**(1/3)*sqrt(31)*I +
+    27*2**(2/3)*3**(1/3)*sqrt(31)*I)/(-2511*2**(2/3)*3**(1/3) +
+    (29*18**(1/3) + 9*2**(1/3)*3**(2/3)*sqrt(31)*I +
+    87*2**(1/3)*3**(1/6)*I)**2)''')
+    assert NS(v, 1) == '0.e-118 - 0.e-118*I'
+
+    # issue 5204
+    v = S('''-(357587765856 + 18873261792*249**(1/2) + 56619785376*I*83**(1/2) +
+    108755765856*I*3**(1/2) + 41281887168*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) - 1239810624*6**(1/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) - 3110400000*I*6**(1/3)*83**(1/2)*(1422 +
+    54*249**(1/2))**(1/3) + 13478400000*I*3**(1/2)*6**(1/3)*(1422 +
+    54*249**(1/2))**(1/3) + 1274950152*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) + 32347944*6**(2/3)*249**(1/2)*(1422 +
+    54*249**(1/2))**(2/3) - 1758790152*I*3**(1/2)*6**(2/3)*(1422 +
+    54*249**(1/2))**(2/3) - 304403832*I*6**(2/3)*83**(1/2)*(1422 +
+    4*249**(1/2))**(2/3))/(175732658352 + (1106028 + 25596*249**(1/2) +
+    76788*I*83**(1/2))**2)''')
+    assert NS(v, 5) == '0.077284 + 1.1104*I'
+    assert NS(v, 1) == '0.08 + 1.*I'
+
+
+def test_old_docstring():
+    a = (E + pi*I)*(E - pi*I)
+    assert NS(a) == '17.2586605000200'
+    assert a.n() == 17.25866050002001
+
+
+def test_issue_4806():
+    assert integrate(atan(x)**2, (x, -1, 1)).evalf().round(1) == Float(0.5, 1)
+    assert atan(0, evaluate=False).n() == 0
+
+
+def test_evalf_mul():
+    # SymPy should not try to expand this; it should be handled term-wise
+    # in evalf through mpmath
+    assert NS(product(1 + sqrt(n)*I, (n, 1, 500)), 1) == '5.e+567 + 2.e+568*I'
+
+
+def test_scaled_zero():
+    a, b = (([0], 1, 100, 1), -1)
+    assert scaled_zero(100) == (a, b)
+    assert scaled_zero(a) == (0, 1, 100, 1)
+    a, b = (([1], 1, 100, 1), -1)
+    assert scaled_zero(100, -1) == (a, b)
+    assert scaled_zero(a) == (1, 1, 100, 1)
+    raises(ValueError, lambda: scaled_zero(scaled_zero(100)))
+    raises(ValueError, lambda: scaled_zero(100, 2))
+    raises(ValueError, lambda: scaled_zero(100, 0))
+    raises(ValueError, lambda: scaled_zero((1, 5, 1, 3)))
+
+
+def test_chop_value():
+    for i in range(-27, 28):
+        assert (Pow(10, i)*2).n(chop=10**i) and not (Pow(10, i)).n(chop=10**i)
+
+
+def test_infinities():
+    assert oo.evalf(chop=True) == inf
+    assert (-oo).evalf(chop=True) == ninf
+
+
+def test_to_mpmath():
+    assert sqrt(3)._to_mpmath(20)._mpf_ == (0, int(908093), -19, 20)
+    assert S(3.2)._to_mpmath(20)._mpf_ == (0, int(838861), -18, 20)
+
+
+def test_issue_6632_evalf():
+    add = (-100000*sqrt(2500000001) + 5000000001)
+    assert add.n() == 9.999999998e-11
+    assert (add*add).n() == 9.999999996e-21
+
+
+def test_issue_4945():
+    from sympy.abc import H
+    assert (H/0).evalf(subs={H:1}) == zoo
+
+
+def test_evalf_integral():
+    # test that workprec has to increase in order to get a result other than 0
+    eps = Rational(1, 1000000)
+    assert Integral(sin(x), (x, -pi, pi + eps)).n(2)._prec == 10
+
+
+def test_issue_8821_highprec_from_str():
+    s = str(pi.evalf(128))
+    p = N(s)
+    assert Abs(sin(p)) < 1e-15
+    p = N(s, 64)
+    assert Abs(sin(p)) < 1e-64
+
+
+def test_issue_8853():
+    p = Symbol('x', even=True, positive=True)
+    assert floor(-p - S.Half).is_even == False
+    assert floor(-p + S.Half).is_even == True
+    assert ceiling(p - S.Half).is_even == True
+    assert ceiling(p + S.Half).is_even == False
+
+    assert get_integer_part(S.Half, -1, {}, True) == (0, 0)
+    assert get_integer_part(S.Half, 1, {}, True) == (1, 0)
+    assert get_integer_part(Rational(-1, 2), -1, {}, True) == (-1, 0)
+    assert get_integer_part(Rational(-1, 2), 1, {}, True) == (0, 0)
+
+
+def test_issue_17681():
+    class identity_func(Function):
+
+        def _eval_evalf(self, *args, **kwargs):
+            return self.args[0].evalf(*args, **kwargs)
+
+    assert floor(identity_func(S(0))) == 0
+    assert get_integer_part(S(0), 1, {}, True) == (0, 0)
+
+
+def test_issue_9326():
+    from sympy.core.symbol import Dummy
+    d1 = Dummy('d')
+    d2 = Dummy('d')
+    e = d1 + d2
+    assert e.evalf(subs = {d1: 1, d2: 2}) == 3.0
+
+
+def test_issue_10323():
+    assert ceiling(sqrt(2**30 + 1)) == 2**15 + 1
+
+
+def test_AssocOp_Function():
+    # the first arg of Min is not comparable in the imaginary part
+    raises(ValueError, lambda: S('''
+    Min(-sqrt(3)*cos(pi/18)/6 + re(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 + sin(pi/18)/2 + 2 + I*(-cos(pi/18)/2 -
+    sqrt(3)*sin(pi/18)/6 + im(1/((-1/2 - sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3), re(1/((-1/2 + sqrt(3)*I/2)*(1/6 +
+    sqrt(3)*I/18)**(1/3)))/3 - sqrt(3)*cos(pi/18)/6 - sin(pi/18)/2 + 2 +
+    I*(im(1/((-1/2 + sqrt(3)*I/2)*(1/6 + sqrt(3)*I/18)**(1/3)))/3 -
+    sqrt(3)*sin(pi/18)/6 + cos(pi/18)/2))'''))
+    # if that is changed so a non-comparable number remains as
+    # an arg, then the Min/Max instantiation needs to be changed
+    # to watch out for non-comparable args when making simplifications
+    # and the following test should be added instead (with e being
+    # the sympified expression above):
+    # raises(ValueError, lambda: e._eval_evalf(2))
+
+
+def test_issue_10395():
+    eq = x*Max(0, y)
+    assert nfloat(eq) == eq
+    eq = x*Max(y, -1.1)
+    assert nfloat(eq) == eq
+    assert Max(y, 4).n() == Max(4.0, y)
+
+
+def test_issue_13098():
+    assert floor(log(S('9.'+'9'*20), 10)) == 0
+    assert ceiling(log(S('9.'+'9'*20), 10)) == 1
+    assert floor(log(20 - S('9.'+'9'*20), 10)) == 1
+    assert ceiling(log(20 - S('9.'+'9'*20), 10)) == 2
+
+
+def test_issue_14601():
+    e = 5*x*y/2 - y*(35*(x**3)/2 - 15*x/2)
+    subst = {x:0.0, y:0.0}
+    e2 = e.evalf(subs=subst)
+    assert float(e2) == 0.0
+    assert float((x + x*(x**2 + x)).evalf(subs={x: 0.0})) == 0.0
+
+
+def test_issue_11151():
+    z = S.Zero
+    e = Sum(z, (x, 1, 2))
+    assert e != z  # it shouldn't evaluate
+    # when it does evaluate, this is what it should give
+    assert evalf(e, 15, {}) == \
+        evalf(z, 15, {}) == (None, None, 15, None)
+    # so this shouldn't fail
+    assert (e/2).n() == 0
+    # this was where the issue appeared
+    expr0 = Sum(x**2 + x, (x, 1, 2))
+    expr1 = Sum(0, (x, 1, 2))
+    expr2 = expr1/expr0
+    assert simplify(factor(expr2) - expr2) == 0
+
+
+def test_issue_13425():
+    assert N('2**.5', 30) == N('sqrt(2)', 30)
+    assert N('x - x', 30) == 0
+    assert abs((N('pi*.1', 22)*10 - pi).n()) < 1e-22
+
+
+def test_issue_17421():
+    assert N(acos(-I + acosh(cosh(cosh(1) + I)))) == 1.0*I
+
+
+def test_issue_20291():
+    from sympy.sets import EmptySet, Reals
+    from sympy.sets.sets import (Complement, FiniteSet, Intersection)
+    a = Symbol('a')
+    b = Symbol('b')
+    A = FiniteSet(a, b)
+    assert A.evalf(subs={a: 1, b: 2}) == FiniteSet(1.0, 2.0)
+    B = FiniteSet(a-b, 1)
+    assert B.evalf(subs={a: 1, b: 2}) == FiniteSet(-1.0, 1.0)
+
+    sol = Complement(Intersection(FiniteSet(-b/2 - sqrt(b**2-4*pi)/2), Reals), FiniteSet(0))
+    assert sol.evalf(subs={b: 1}) == EmptySet
+
+
+def test_evalf_with_zoo():
+    assert (1/x).evalf(subs={x: 0}) == zoo  # issue 8242
+    assert (-1/x).evalf(subs={x: 0}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1}) == zoo  # PR 16150
+    assert (0 ** x).evalf(subs={x: -1 + I}) == nan
+    assert Mul(2, Pow(0, -1, evaluate=False), evaluate=False).evalf() == zoo  # issue 21147
+    assert Mul(x, 1/x, evaluate=False).evalf(subs={x: 0}) == Mul(x, 1/x, evaluate=False).subs(x, 0) == nan
+    assert Mul(1/x, 1/x, evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Mul(1/x, Abs(1/x), evaluate=False).evalf(subs={x: 0}) == zoo
+    assert Abs(zoo, evaluate=False).evalf() == oo
+    assert re(zoo, evaluate=False).evalf() == nan
+    assert im(zoo, evaluate=False).evalf() == nan
+    assert Add(zoo, zoo, evaluate=False).evalf() == nan
+    assert Add(oo, zoo, evaluate=False).evalf() == nan
+    assert Pow(zoo, -1, evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(-1, 3), evaluate=False).evalf() == 0
+    assert Pow(zoo, Rational(1, 3), evaluate=False).evalf() == zoo
+    assert Pow(zoo, S.Half, evaluate=False).evalf() == zoo
+    assert Pow(zoo, 2, evaluate=False).evalf() == zoo
+    assert Pow(0, zoo, evaluate=False).evalf() == nan
+    assert log(zoo, evaluate=False).evalf() == zoo
+    assert zoo.evalf(chop=True) == zoo
+    assert x.evalf(subs={x: zoo}) == zoo
+
+
+def test_evalf_with_bounded_error():
+    cases = [
+        # zero
+        (Rational(0), None, 1),
+        # zero im part
+        (pi, None, 10),
+        # zero real part
+        (pi*I, None, 10),
+        # re and im nonzero
+        (2-3*I, None, 5),
+        # similar tests again, but using eps instead of m
+        (Rational(0), Rational(1, 2), None),
+        (pi, Rational(1, 1000), None),
+        (pi * I, Rational(1, 1000), None),
+        (2 - 3 * I, Rational(1, 1000), None),
+        # very large eps
+        (2 - 3 * I, Rational(1000), None),
+        # case where x already small, hence some cancellation in p = m + n - 1
+        (Rational(1234, 10**8), Rational(1, 10**12), None),
+    ]
+    for x0, eps, m in cases:
+        a, b, _, _ = evalf(x0, 53, {})
+        c, d, _, _ = _evalf_with_bounded_error(x0, eps, m)
+        if eps is None:
+            eps = 2**(-m)
+        z = make_mpc((a or fzero, b or fzero))
+        w = make_mpc((c or fzero, d or fzero))
+        assert abs(w - z) < eps
+
+    # eps must be positive
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, Rational(0)))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, -pi))
+    raises(ValueError, lambda: _evalf_with_bounded_error(pi, I))
+
+
+def test_issue_22849():
+    a = -8 + 3 * sqrt(3)
+    x = AlgebraicNumber(a)
+    assert evalf(a, 1, {}) == evalf(x, 1, {})
+
+
+def test_evalf_real_alg_num():
+    # This test demonstrates why the entry for `AlgebraicNumber` in
+    # `sympy.core.evalf._create_evalf_table()` has to use `x.to_root()`,
+    # instead of `x.as_expr()`. If the latter is used, then `z` will be
+    # a complex number with `0.e-20` for imaginary part, even though `a5`
+    # is a real number.
+    zeta = Symbol('zeta')
+    a5 = AlgebraicNumber(CRootOf(cyclotomic_poly(5), -1), [-1, -1, 0, 0], alias=zeta)
+    z = a5.evalf()
+    assert isinstance(z, Float)
+    assert not hasattr(z, '_mpc_')
+    assert hasattr(z, '_mpf_')
+
+
+def test_issue_20733():
+    expr = 1/((x - 9)*(x - 8)*(x - 7)*(x - 4)**2*(x - 3)**3*(x - 2))
+    assert str(expr.evalf(1, subs={x:1})) == '-4.e-5'
+    assert str(expr.evalf(2, subs={x:1})) == '-4.1e-5'
+    assert str(expr.evalf(11, subs={x:1})) == '-4.1335978836e-5'
+    assert str(expr.evalf(20, subs={x:1})) == '-0.000041335978835978835979'
+
+    expr = Mul(*((x - i) for i in range(2, 1000)))
+    assert srepr(expr.evalf(2, subs={x: 1})) == "Float('4.0271e+2561', precision=10)"
+    assert srepr(expr.evalf(10, subs={x: 1})) == "Float('4.02790050126e+2561', precision=37)"
+    assert srepr(expr.evalf(53, subs={x: 1})) == "Float('4.0279005012722099453824067459760158730668154575647110393e+2561', precision=179)"
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expand.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expand.py
new file mode 100644
index 0000000000000000000000000000000000000000..e7abb5daacebbe81664b3de3a7ac35a490ab31bc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expand.py
@@ -0,0 +1,364 @@
+from sympy.core.expr import unchanged
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational as R, pi)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.order import O
+from sympy.simplify.radsimp import expand_numer
+from sympy.core.function import (expand, expand_multinomial,
+    expand_power_base, expand_log)
+
+from sympy.testing.pytest import raises
+from sympy.core.random import verify_numerically
+
+from sympy.abc import x, y, z
+
+
+def test_expand_no_log():
+    assert (
+        (1 + log(x**4))**2).expand(log=False) == 1 + 2*log(x**4) + log(x**4)**2
+    assert ((1 + log(x**4))*(1 + log(x**3))).expand(
+        log=False) == 1 + log(x**4) + log(x**3) + log(x**4)*log(x**3)
+
+
+def test_expand_no_multinomial():
+    assert ((1 + x)*(1 + (1 + x)**4)).expand(multinomial=False) == \
+        1 + x + (1 + x)**4 + x*(1 + x)**4
+
+
+def test_expand_negative_integer_powers():
+    expr = (x + y)**(-2)
+    assert expr.expand() == 1 / (2*x*y + x**2 + y**2)
+    assert expr.expand(multinomial=False) == (x + y)**(-2)
+    expr = (x + y)**(-3)
+    assert expr.expand() == 1 / (3*x*x*y + 3*x*y*y + x**3 + y**3)
+    assert expr.expand(multinomial=False) == (x + y)**(-3)
+    expr = (x + y)**(2) * (x + y)**(-4)
+    assert expr.expand() == 1 / (2*x*y + x**2 + y**2)
+    assert expr.expand(multinomial=False) == (x + y)**(-2)
+
+
+def test_expand_non_commutative():
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+    C = Symbol('C', commutative=False)
+    a = Symbol('a')
+    b = Symbol('b')
+    i = Symbol('i', integer=True)
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    p = Symbol('p', polar=True)
+    np = Symbol('p', polar=False)
+
+    assert (C*(A + B)).expand() == C*A + C*B
+    assert (C*(A + B)).expand() != A*C + B*C
+    assert ((A + B)**2).expand() == A**2 + A*B + B*A + B**2
+    assert ((A + B)**3).expand() == (A**2*B + B**2*A + A*B**2 + B*A**2 +
+                                     A**3 + B**3 + A*B*A + B*A*B)
+    # issue 6219
+    assert ((a*A*B*A**-1)**2).expand() == a**2*A*B**2/A
+    # Note that (a*A*B*A**-1)**2 is automatically converted to a**2*(A*B*A**-1)**2
+    assert ((a*A*B*A**-1)**2).expand(deep=False) == a**2*(A*B*A**-1)**2
+    assert ((a*A*B*A**-1)**2).expand() == a**2*(A*B**2*A**-1)
+    assert ((a*A*B*A**-1)**2).expand(force=True) == a**2*A*B**2*A**(-1)
+    assert ((a*A*B)**2).expand() == a**2*A*B*A*B
+    assert ((a*A)**2).expand() == a**2*A**2
+    assert ((a*A*B)**i).expand() == a**i*(A*B)**i
+    assert ((a*A*(B*(A*B/A)**2))**i).expand() == a**i*(A*B*A*B**2/A)**i
+    # issue 6558
+    assert (A*B*(A*B)**-1).expand() == 1
+    assert ((a*A)**i).expand() == a**i*A**i
+    assert ((a*A*B*A**-1)**3).expand() == a**3*A*B**3/A
+    assert ((a*A*B*A*B/A)**3).expand() == \
+        a**3*A*B*(A*B**2)*(A*B**2)*A*B*A**(-1)
+    assert ((a*A*B*A*B/A)**-2).expand() == \
+        A*B**-1*A**-1*B**-2*A**-1*B**-1*A**-1/a**2
+    assert ((a*b*A*B*A**-1)**i).expand() == a**i*b**i*(A*B/A)**i
+    assert ((a*(a*b)**i)**i).expand() == a**i*a**(i**2)*b**(i**2)
+    e = Pow(Mul(a, 1/a, A, B, evaluate=False), S(2), evaluate=False)
+    assert e.expand() == A*B*A*B
+    assert sqrt(a*(A*b)**i).expand() == sqrt(a*b**i*A**i)
+    assert (sqrt(-a)**a).expand() == sqrt(-a)**a
+    assert expand((-2*n)**(i/3)) == 2**(i/3)*(-n)**(i/3)
+    assert expand((-2*n*m)**(i/a)) == (-2)**(i/a)*(-n)**(i/a)*(-m)**(i/a)
+    assert expand((-2*a*p)**b) == 2**b*p**b*(-a)**b
+    assert expand((-2*a*np)**b) == 2**b*(-a*np)**b
+    assert expand(sqrt(A*B)) == sqrt(A*B)
+    assert expand(sqrt(-2*a*b)) == sqrt(2)*sqrt(-a*b)
+
+
+def test_expand_radicals():
+    a = (x + y)**R(1, 2)
+
+    assert (a**1).expand() == a
+    assert (a**3).expand() == x*a + y*a
+    assert (a**5).expand() == x**2*a + 2*x*y*a + y**2*a
+
+    assert (1/a**1).expand() == 1/a
+    assert (1/a**3).expand() == 1/(x*a + y*a)
+    assert (1/a**5).expand() == 1/(x**2*a + 2*x*y*a + y**2*a)
+
+    a = (x + y)**R(1, 3)
+
+    assert (a**1).expand() == a
+    assert (a**2).expand() == a**2
+    assert (a**4).expand() == x*a + y*a
+    assert (a**5).expand() == x*a**2 + y*a**2
+    assert (a**7).expand() == x**2*a + 2*x*y*a + y**2*a
+
+
+def test_expand_modulus():
+    assert ((x + y)**11).expand(modulus=11) == x**11 + y**11
+    assert ((x + sqrt(2)*y)**11).expand(modulus=11) == x**11 + 10*sqrt(2)*y**11
+    assert (x + y/2).expand(modulus=1) == y/2
+
+    raises(ValueError, lambda: ((x + y)**11).expand(modulus=0))
+    raises(ValueError, lambda: ((x + y)**11).expand(modulus=x))
+
+
+def test_issue_5743():
+    assert (x*sqrt(
+        x + y)*(1 + sqrt(x + y))).expand() == x**2 + x*y + x*sqrt(x + y)
+    assert (x*sqrt(
+        x + y)*(1 + x*sqrt(x + y))).expand() == x**3 + x**2*y + x*sqrt(x + y)
+
+
+def test_expand_frac():
+    assert expand((x + y)*y/x/(x + 1), frac=True) == \
+        (x*y + y**2)/(x**2 + x)
+    assert expand((x + y)*y/x/(x + 1), numer=True) == \
+        (x*y + y**2)/(x*(x + 1))
+    assert expand((x + y)*y/x/(x + 1), denom=True) == \
+        y*(x + y)/(x**2 + x)
+    eq = (x + 1)**2/y
+    assert expand_numer(eq, multinomial=False) == eq
+    # issue 26329
+    eq = (exp(x*z) - exp(y*z))/exp(z*(x + y))
+    ans = exp(-y*z) - exp(-x*z)
+    assert eq.expand(numer=True) != ans
+    assert eq.expand(numer=True, exact=True) == ans
+    assert expand_numer(eq) != ans
+    assert expand_numer(eq, exact=True) == ans
+
+
+def test_issue_6121():
+    eq = -I*exp(-3*I*pi/4)/(4*pi**(S(3)/2)*sqrt(x))
+    assert eq.expand(complex=True)  # does not give oo recursion
+    eq = -I*exp(-3*I*pi/4)/(4*pi**(R(3, 2))*sqrt(x))
+    assert eq.expand(complex=True)  # does not give oo recursion
+
+
+def test_expand_power_base():
+    assert expand_power_base((x*y*z)**4) == x**4*y**4*z**4
+    assert expand_power_base((x*y*z)**x).is_Pow
+    assert expand_power_base((x*y*z)**x, force=True) == x**x*y**x*z**x
+    assert expand_power_base((x*(y*z)**2)**3) == x**3*y**6*z**6
+
+    assert expand_power_base((sin((x*y)**2)*y)**z).is_Pow
+    assert expand_power_base(
+        (sin((x*y)**2)*y)**z, force=True) == sin((x*y)**2)**z*y**z
+    assert expand_power_base(
+        (sin((x*y)**2)*y)**z, deep=True) == (sin(x**2*y**2)*y)**z
+
+    assert expand_power_base(exp(x)**2) == exp(2*x)
+    assert expand_power_base((exp(x)*exp(y))**2) == exp(2*x)*exp(2*y)
+
+    assert expand_power_base(
+        (exp((x*y)**z)*exp(y))**2) == exp(2*(x*y)**z)*exp(2*y)
+    assert expand_power_base((exp((x*y)**z)*exp(
+        y))**2, deep=True, force=True) == exp(2*x**z*y**z)*exp(2*y)
+
+    assert expand_power_base((exp(x)*exp(y))**z).is_Pow
+    assert expand_power_base(
+        (exp(x)*exp(y))**z, force=True) == exp(x)**z*exp(y)**z
+
+
+def test_expand_arit():
+    a = Symbol("a")
+    b = Symbol("b", positive=True)
+    c = Symbol("c")
+
+    p = R(5)
+    e = (a + b)*c
+    assert e == c*(a + b)
+    assert (e.expand() - a*c - b*c) == R(0)
+    e = (a + b)*(a + b)
+    assert e == (a + b)**2
+    assert e.expand() == 2*a*b + a**2 + b**2
+    e = (a + b)*(a + b)**R(2)
+    assert e == (a + b)**3
+    assert e.expand() == 3*b*a**2 + 3*a*b**2 + a**3 + b**3
+    assert e.expand() == 3*b*a**2 + 3*a*b**2 + a**3 + b**3
+    e = (a + b)*(a + c)*(b + c)
+    assert e == (a + c)*(a + b)*(b + c)
+    assert e.expand() == 2*a*b*c + b*a**2 + c*a**2 + b*c**2 + a*c**2 + c*b**2 + a*b**2
+    e = (a + R(1))**p
+    assert e == (1 + a)**5
+    assert e.expand() == 1 + 5*a + 10*a**2 + 10*a**3 + 5*a**4 + a**5
+    e = (a + b + c)*(a + c + p)
+    assert e == (5 + a + c)*(a + b + c)
+    assert e.expand() == 5*a + 5*b + 5*c + 2*a*c + b*c + a*b + a**2 + c**2
+    x = Symbol("x")
+    s = exp(x*x) - 1
+    e = s.nseries(x, 0, 6)/x**2
+    assert e.expand() == 1 + x**2/2 + O(x**4)
+
+    e = (x*(y + z))**(x*(y + z))*(x + y)
+    assert e.expand(power_exp=False, power_base=False) == x*(x*y + x*
+                    z)**(x*y + x*z) + y*(x*y + x*z)**(x*y + x*z)
+    assert e.expand(power_exp=False, power_base=False, deep=False) == x* \
+        (x*(y + z))**(x*(y + z)) + y*(x*(y + z))**(x*(y + z))
+    e = x * (x + (y + 1)**2)
+    assert e.expand(deep=False) == x**2 + x*(y + 1)**2
+    e = (x*(y + z))**z
+    assert e.expand(power_base=True, mul=True, deep=True) in [x**z*(y +
+                    z)**z, (x*y + x*z)**z]
+    assert ((2*y)**z).expand() == 2**z*y**z
+    p = Symbol('p', positive=True)
+    assert sqrt(-x).expand().is_Pow
+    assert sqrt(-x).expand(force=True) == I*sqrt(x)
+    assert ((2*y*p)**z).expand() == 2**z*p**z*y**z
+    assert ((2*y*p*x)**z).expand() == 2**z*p**z*(x*y)**z
+    assert ((2*y*p*x)**z).expand(force=True) == 2**z*p**z*x**z*y**z
+    assert ((2*y*p*-pi)**z).expand() == 2**z*pi**z*p**z*(-y)**z
+    assert ((2*y*p*-pi*x)**z).expand() == 2**z*pi**z*p**z*(-x*y)**z
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    assert ((-2*x*y*n)**z).expand() == 2**z*(-n)**z*(x*y)**z
+    assert ((-2*x*y*n*m)**z).expand() == 2**z*(-m)**z*(-n)**z*(-x*y)**z
+    # issue 5482
+    assert sqrt(-2*x*n) == sqrt(2)*sqrt(-n)*sqrt(x)
+    # issue 5605 (2)
+    assert (cos(x + y)**2).expand(trig=True) in [
+        (-sin(x)*sin(y) + cos(x)*cos(y))**2,
+        sin(x)**2*sin(y)**2 - 2*sin(x)*sin(y)*cos(x)*cos(y) + cos(x)**2*cos(y)**2
+    ]
+
+    # Check that this isn't too slow
+    x = Symbol('x')
+    W = 1
+    for i in range(1, 21):
+        W = W * (x - i)
+    W = W.expand()
+    assert W.has(-1672280820*x**15)
+
+def test_expand_mul():
+    # part of issue 20597
+    e = Mul(2, 3, evaluate=False)
+    assert e.expand() == 6
+
+    e = Mul(2, 3, 1/x, evaluate=False)
+    assert e.expand() == 6/x
+    e = Mul(2, R(1, 3), evaluate=False)
+    assert e.expand() == R(2, 3)
+
+def test_power_expand():
+    """Test for Pow.expand()"""
+    a = Symbol('a')
+    b = Symbol('b')
+    p = (a + b)**2
+    assert p.expand() == a**2 + b**2 + 2*a*b
+
+    p = (1 + 2*(1 + a))**2
+    assert p.expand() == 9 + 4*(a**2) + 12*a
+
+    p = 2**(a + b)
+    assert p.expand() == 2**a*2**b
+
+    A = Symbol('A', commutative=False)
+    B = Symbol('B', commutative=False)
+    assert (2**(A + B)).expand() == 2**(A + B)
+    assert (A**(a + b)).expand() != A**(a + b)
+
+
+def test_issues_5919_6830():
+    # issue 5919
+    n = -1 + 1/x
+    z = n/x/(-n)**2 - 1/n/x
+    assert expand(z) == 1/(x**2 - 2*x + 1) - 1/(x - 2 + 1/x) - 1/(-x + 1)
+
+    # issue 6830
+    p = (1 + x)**2
+    assert expand_multinomial((1 + x*p)**2) == (
+        x**2*(x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 2*x*(x**2 + 2*x + 1) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**2) == (
+        2*((x + y)*(x**2 + 2*x + 1)) + (x**2 + 2*x*y + y**2)*
+        (x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 1)
+    A = Symbol('A', commutative=False)
+    p = (1 + A)**2
+    assert expand_multinomial((1 + x*p)**2) == (
+        x**2*(1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 2*x*(1 + 2*A + A**2) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**2) == (
+        (x + y)*(1 + 2*A + A**2)*2 + (x**2 + 2*x*y + y**2)*
+        (1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 1)
+    assert expand_multinomial((1 + (y + x)*p)**3) == (
+        (x + y)*(1 + 2*A + A**2)*3 + (x**2 + 2*x*y + y**2)*(1 + 4*A +
+        6*A**2 + 4*A**3 + A**4)*3 + (x**3 + 3*x**2*y + 3*x*y**2 + y**3)*(1 + 6*A
+        + 15*A**2 + 20*A**3 + 15*A**4 + 6*A**5 + A**6) + 1)
+    # unevaluate powers
+    eq = (Pow((x + 1)*((A + 1)**2), 2, evaluate=False))
+    # - in this case the base is not an Add so no further
+    #   expansion is done
+    assert expand_multinomial(eq) == \
+        (x**2 + 2*x + 1)*(1 + 4*A + 6*A**2 + 4*A**3 + A**4)
+    # - but here, the expanded base *is* an Add so it gets expanded
+    eq = (Pow(((A + 1)**2), 2, evaluate=False))
+    assert expand_multinomial(eq) == 1 + 4*A + 6*A**2 + 4*A**3 + A**4
+
+    # coverage
+    def ok(a, b, n):
+        e = (a + I*b)**n
+        return verify_numerically(e, expand_multinomial(e))
+
+    for a in [2, S.Half]:
+        for b in [3, R(1, 3)]:
+            for n in range(2, 6):
+                assert ok(a, b, n)
+
+    assert expand_multinomial((x + 1 + O(z))**2) == \
+        1 + 2*x + x**2 + O(z)
+    assert expand_multinomial((x + 1 + O(z))**3) == \
+        1 + 3*x + 3*x**2 + x**3 + O(z)
+
+    assert expand_multinomial(3**(x + y + 3)) == 27*3**(x + y)
+
+def test_expand_log():
+    t = Symbol('t', positive=True)
+    # after first expansion, -2*log(2) + log(4); then 0 after second
+    assert expand(log(t**2) - log(t**2/4) - 2*log(2)) == 0
+    assert expand_log(log(7*6)/log(6)) == 1 + log(7)/log(6)
+    b = factorial(10)
+    assert expand_log(log(7*b**4)/log(b)
+        ) == 4 + log(7)/log(b)
+
+
+def test_issue_23952():
+    assert (x**(y + z)).expand(force=True) == x**y*x**z
+    one = Symbol('1', integer=True, prime=True, odd=True, positive=True)
+    two = Symbol('2', integer=True, prime=True, even=True)
+    e = two - one
+    for b in (0, x):
+        # 0**e = 0, 0**-e = zoo; but if expanded then nan
+        assert unchanged(Pow, b, e)  # power_exp
+        assert unchanged(Pow, b, -e)  # power_exp
+        assert unchanged(Pow, b, y - x)  # power_exp
+        assert unchanged(Pow, b, 3 - x)  # multinomial
+        assert (b**e).expand().is_Pow  # power_exp
+        assert (b**-e).expand().is_Pow  # power_exp
+        assert (b**(y - x)).expand().is_Pow  # power_exp
+        assert (b**(3 - x)).expand().is_Pow  # multinomial
+    nn1 = Symbol('nn1', nonnegative=True)
+    nn2 = Symbol('nn2', nonnegative=True)
+    nn3 = Symbol('nn3', nonnegative=True)
+    assert (x**(nn1 + nn2)).expand() == x**nn1*x**nn2
+    assert (x**(-nn1 - nn2)).expand() == x**-nn1*x**-nn2
+    assert unchanged(Pow, x, nn1 + nn2 - nn3)
+    assert unchanged(Pow, x, 1 + nn2 - nn3)
+    assert unchanged(Pow, x, nn1 - nn2)
+    assert unchanged(Pow, x, 1 - nn2)
+    assert unchanged(Pow, x, -1 + nn2)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expr.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expr.py
new file mode 100644
index 0000000000000000000000000000000000000000..af63823345e2b0564ebb7e9015bfe1b423c9bafa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_expr.py
@@ -0,0 +1,2313 @@
+from sympy.assumptions.refine import refine
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import (ExprBuilder, unchanged, Expr,
+    UnevaluatedExpr)
+from sympy.core.function import (Function, expand, WildFunction,
+    AppliedUndef, Derivative, diff, Subs)
+from sympy.core.mul import Mul, _unevaluated_Mul
+from sympy.core.numbers import (NumberSymbol, E, zoo, oo, Float, I,
+    Rational, nan, Integer, Number, pi, _illegal)
+from sympy.core.power import Pow
+from sympy.core.relational import Ge, Lt, Gt, Le
+from sympy.core.singleton import S
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Symbol, symbols, Dummy, Wild
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.exponential import exp_polar, exp, log
+from sympy.functions.elementary.hyperbolic import sinh, tanh
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import tan, sin, cos
+from sympy.functions.special.delta_functions import (Heaviside,
+    DiracDelta)
+from sympy.functions.special.error_functions import Si
+from sympy.functions.special.gamma_functions import gamma
+from sympy.integrals.integrals import integrate, Integral
+from sympy.physics.secondquant import FockState
+from sympy.polys.partfrac import apart
+from sympy.polys.polytools import factor, cancel, Poly
+from sympy.polys.rationaltools import together
+from sympy.series.order import O
+from sympy.sets.sets import FiniteSet
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.powsimp import powsimp
+from sympy.simplify.radsimp import collect, radsimp
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import simplify, nsimplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.tensor.indexed import Indexed
+from sympy.physics.units import meter
+
+from sympy.testing.pytest import raises, XFAIL
+
+from sympy.abc import a, b, c, n, t, u, x, y, z
+
+
+f, g, h = symbols('f,g,h', cls=Function)
+
+
+class DummyNumber:
+    """
+    Minimal implementation of a number that works with SymPy.
+
+    If one has a Number class (e.g. Sage Integer, or some other custom class)
+    that one wants to work well with SymPy, one has to implement at least the
+    methods of this class DummyNumber, resp. its subclasses I5 and F1_1.
+
+    Basically, one just needs to implement either __int__() or __float__() and
+    then one needs to make sure that the class works with Python integers and
+    with itself.
+    """
+
+    def __radd__(self, a):
+        if isinstance(a, (int, float)):
+            return a + self.number
+        return NotImplemented
+
+    def __add__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number + a
+        return NotImplemented
+
+    def __rsub__(self, a):
+        if isinstance(a, (int, float)):
+            return a - self.number
+        return NotImplemented
+
+    def __sub__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number - a
+        return NotImplemented
+
+    def __rmul__(self, a):
+        if isinstance(a, (int, float)):
+            return a * self.number
+        return NotImplemented
+
+    def __mul__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number * a
+        return NotImplemented
+
+    def __rtruediv__(self, a):
+        if isinstance(a, (int, float)):
+            return a / self.number
+        return NotImplemented
+
+    def __truediv__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number / a
+        return NotImplemented
+
+    def __rpow__(self, a):
+        if isinstance(a, (int, float)):
+            return a ** self.number
+        return NotImplemented
+
+    def __pow__(self, a):
+        if isinstance(a, (int, float, DummyNumber)):
+            return self.number ** a
+        return NotImplemented
+
+    def __pos__(self):
+        return self.number
+
+    def __neg__(self):
+        return - self.number
+
+
+class I5(DummyNumber):
+    number = 5
+
+    def __int__(self):
+        return self.number
+
+
+class F1_1(DummyNumber):
+    number = 1.1
+
+    def __float__(self):
+        return self.number
+
+i5 = I5()
+f1_1 = F1_1()
+
+# basic SymPy objects
+basic_objs = [
+    Rational(2),
+    Float("1.3"),
+    x,
+    y,
+    pow(x, y)*y,
+]
+
+# all supported objects
+all_objs = basic_objs + [
+    5,
+    5.5,
+    i5,
+    f1_1
+]
+
+
+def dotest(s):
+    for xo in all_objs:
+        for yo in all_objs:
+            s(xo, yo)
+    return True
+
+
+def test_basic():
+    def j(a, b):
+        x = a
+        x = +a
+        x = -a
+        x = a + b
+        x = a - b
+        x = a*b
+        x = a/b
+        x = a**b
+        del x
+    assert dotest(j)
+
+
+def test_ibasic():
+    def s(a, b):
+        x = a
+        x += b
+        x = a
+        x -= b
+        x = a
+        x *= b
+        x = a
+        x /= b
+    assert dotest(s)
+
+
+class NonBasic:
+    '''This class represents an object that knows how to implement binary
+    operations like +, -, etc with Expr but is not a subclass of Basic itself.
+    The NonExpr subclass below does subclass Basic but not Expr.
+
+    For both NonBasic and NonExpr it should be possible for them to override
+    Expr.__add__ etc because Expr.__add__ should be returning NotImplemented
+    for non Expr classes. Otherwise Expr.__add__ would create meaningless
+    objects like Add(Integer(1), FiniteSet(2)) and it wouldn't be possible for
+    other classes to override these operations when interacting with Expr.
+    '''
+    def __add__(self, other):
+        return SpecialOp('+', self, other)
+
+    def __radd__(self, other):
+        return SpecialOp('+', other, self)
+
+    def __sub__(self, other):
+        return SpecialOp('-', self, other)
+
+    def __rsub__(self, other):
+        return SpecialOp('-', other, self)
+
+    def __mul__(self, other):
+        return SpecialOp('*', self, other)
+
+    def __rmul__(self, other):
+        return SpecialOp('*', other, self)
+
+    def __truediv__(self, other):
+        return SpecialOp('/', self, other)
+
+    def __rtruediv__(self, other):
+        return SpecialOp('/', other, self)
+
+    def __floordiv__(self, other):
+        return SpecialOp('//', self, other)
+
+    def __rfloordiv__(self, other):
+        return SpecialOp('//', other, self)
+
+    def __mod__(self, other):
+        return SpecialOp('%', self, other)
+
+    def __rmod__(self, other):
+        return SpecialOp('%', other, self)
+
+    def __divmod__(self, other):
+        return SpecialOp('divmod', self, other)
+
+    def __rdivmod__(self, other):
+        return SpecialOp('divmod', other, self)
+
+    def __pow__(self, other):
+        return SpecialOp('**', self, other)
+
+    def __rpow__(self, other):
+        return SpecialOp('**', other, self)
+
+    def __lt__(self, other):
+        return SpecialOp('<', self, other)
+
+    def __gt__(self, other):
+        return SpecialOp('>', self, other)
+
+    def __le__(self, other):
+        return SpecialOp('<=', self, other)
+
+    def __ge__(self, other):
+        return SpecialOp('>=', self, other)
+
+
+class NonExpr(Basic, NonBasic):
+    '''Like NonBasic above except this is a subclass of Basic but not Expr'''
+    pass
+
+
+class SpecialOp():
+    '''Represents the results of operations with NonBasic and NonExpr'''
+    def __new__(cls, op, arg1, arg2):
+        obj = object.__new__(cls)
+        obj.args = (op, arg1, arg2)
+        return obj
+
+
+class NonArithmetic(Basic):
+    '''Represents a Basic subclass that does not support arithmetic operations'''
+    pass
+
+
+def test_cooperative_operations():
+    '''Tests that Expr uses binary operations cooperatively.
+
+    In particular it should be possible for non-Expr classes to override
+    binary operators like +, - etc when used with Expr instances. This should
+    work for non-Expr classes whether they are Basic subclasses or not. Also
+    non-Expr classes that do not define binary operators with Expr should give
+    TypeError.
+    '''
+    # A bunch of instances of Expr subclasses
+    exprs = [
+        Expr(),
+        S.Zero,
+        S.One,
+        S.Infinity,
+        S.NegativeInfinity,
+        S.ComplexInfinity,
+        S.Half,
+        Float(0.5),
+        Integer(2),
+        Symbol('x'),
+        Mul(2, Symbol('x')),
+        Add(2, Symbol('x')),
+        Pow(2, Symbol('x')),
+    ]
+
+    for e in exprs:
+        # Test that these classes can override arithmetic operations in
+        # combination with various Expr types.
+        for ne in [NonBasic(), NonExpr()]:
+
+            results = [
+                (ne + e, ('+', ne, e)),
+                (e + ne, ('+', e, ne)),
+                (ne - e, ('-', ne, e)),
+                (e - ne, ('-', e, ne)),
+                (ne * e, ('*', ne, e)),
+                (e * ne, ('*', e, ne)),
+                (ne / e, ('/', ne, e)),
+                (e / ne, ('/', e, ne)),
+                (ne // e, ('//', ne, e)),
+                (e // ne, ('//', e, ne)),
+                (ne % e, ('%', ne, e)),
+                (e % ne, ('%', e, ne)),
+                (divmod(ne, e), ('divmod', ne, e)),
+                (divmod(e, ne), ('divmod', e, ne)),
+                (ne ** e, ('**', ne, e)),
+                (e ** ne, ('**', e, ne)),
+                (e < ne, ('>', ne, e)),
+                (ne < e, ('<', ne, e)),
+                (e > ne, ('<', ne, e)),
+                (ne > e, ('>', ne, e)),
+                (e <= ne, ('>=', ne, e)),
+                (ne <= e, ('<=', ne, e)),
+                (e >= ne, ('<=', ne, e)),
+                (ne >= e, ('>=', ne, e)),
+            ]
+
+            for res, args in results:
+                assert type(res) is SpecialOp and res.args == args
+
+        # These classes do not support binary operators with Expr. Every
+        # operation should raise in combination with any of the Expr types.
+        for na in [NonArithmetic(), object()]:
+
+            raises(TypeError, lambda : e + na)
+            raises(TypeError, lambda : na + e)
+            raises(TypeError, lambda : e - na)
+            raises(TypeError, lambda : na - e)
+            raises(TypeError, lambda : e * na)
+            raises(TypeError, lambda : na * e)
+            raises(TypeError, lambda : e / na)
+            raises(TypeError, lambda : na / e)
+            raises(TypeError, lambda : e // na)
+            raises(TypeError, lambda : na // e)
+            raises(TypeError, lambda : e % na)
+            raises(TypeError, lambda : na % e)
+            raises(TypeError, lambda : divmod(e, na))
+            raises(TypeError, lambda : divmod(na, e))
+            raises(TypeError, lambda : e ** na)
+            raises(TypeError, lambda : na ** e)
+            raises(TypeError, lambda : e > na)
+            raises(TypeError, lambda : na > e)
+            raises(TypeError, lambda : e < na)
+            raises(TypeError, lambda : na < e)
+            raises(TypeError, lambda : e >= na)
+            raises(TypeError, lambda : na >= e)
+            raises(TypeError, lambda : e <= na)
+            raises(TypeError, lambda : na <= e)
+
+
+def test_relational():
+    from sympy.core.relational import Lt
+    assert (pi < 3) is S.false
+    assert (pi <= 3) is S.false
+    assert (pi > 3) is S.true
+    assert (pi >= 3) is S.true
+    assert (-pi < 3) is S.true
+    assert (-pi <= 3) is S.true
+    assert (-pi > 3) is S.false
+    assert (-pi >= 3) is S.false
+    r = Symbol('r', real=True)
+    assert (r - 2 < r - 3) is S.false
+    assert Lt(x + I, x + I + 2).func == Lt  # issue 8288
+
+
+def test_relational_assumptions():
+    m1 = Symbol("m1", nonnegative=False)
+    m2 = Symbol("m2", positive=False)
+    m3 = Symbol("m3", nonpositive=False)
+    m4 = Symbol("m4", negative=False)
+    assert (m1 < 0) == Lt(m1, 0)
+    assert (m2 <= 0) == Le(m2, 0)
+    assert (m3 > 0) == Gt(m3, 0)
+    assert (m4 >= 0) == Ge(m4, 0)
+    m1 = Symbol("m1", nonnegative=False, real=True)
+    m2 = Symbol("m2", positive=False, real=True)
+    m3 = Symbol("m3", nonpositive=False, real=True)
+    m4 = Symbol("m4", negative=False, real=True)
+    assert (m1 < 0) is S.true
+    assert (m2 <= 0) is S.true
+    assert (m3 > 0) is S.true
+    assert (m4 >= 0) is S.true
+    m1 = Symbol("m1", negative=True)
+    m2 = Symbol("m2", nonpositive=True)
+    m3 = Symbol("m3", positive=True)
+    m4 = Symbol("m4", nonnegative=True)
+    assert (m1 < 0) is S.true
+    assert (m2 <= 0) is S.true
+    assert (m3 > 0) is S.true
+    assert (m4 >= 0) is S.true
+    m1 = Symbol("m1", negative=False, real=True)
+    m2 = Symbol("m2", nonpositive=False, real=True)
+    m3 = Symbol("m3", positive=False, real=True)
+    m4 = Symbol("m4", nonnegative=False, real=True)
+    assert (m1 < 0) is S.false
+    assert (m2 <= 0) is S.false
+    assert (m3 > 0) is S.false
+    assert (m4 >= 0) is S.false
+
+
+# See https://github.com/sympy/sympy/issues/17708
+#def test_relational_noncommutative():
+#    from sympy import Lt, Gt, Le, Ge
+#    A, B = symbols('A,B', commutative=False)
+#    assert (A < B) == Lt(A, B)
+#    assert (A <= B) == Le(A, B)
+#    assert (A > B) == Gt(A, B)
+#    assert (A >= B) == Ge(A, B)
+
+
+def test_basic_nostr():
+    for obj in basic_objs:
+        raises(TypeError, lambda: obj + '1')
+        raises(TypeError, lambda: obj - '1')
+        if obj == 2:
+            assert obj * '1' == '11'
+        else:
+            raises(TypeError, lambda: obj * '1')
+        raises(TypeError, lambda: obj / '1')
+        raises(TypeError, lambda: obj ** '1')
+
+
+def test_series_expansion_for_uniform_order():
+    assert (1/x + y + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + x).series(x, 0, 1) == 1/x + y + O(x)
+    assert (1/x + 1 + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + 1 + x).series(x, 0, 1) == 1/x + 1 + O(x)
+    assert (1/x + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + y*x + x).series(x, 0, 0) == 1/x + O(1, x)
+    assert (1/x + y + y*x + x).series(x, 0, 1) == 1/x + y + O(x)
+
+
+def test_leadterm():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).leadterm(x) == (3, 0)
+
+    assert (1/x**2 + 1 + x + x**2).leadterm(x)[1] == -2
+    assert (1/x + 1 + x + x**2).leadterm(x)[1] == -1
+    assert (x**2 + 1/x).leadterm(x)[1] == -1
+    assert (1 + x**2).leadterm(x)[1] == 0
+    assert (x + 1).leadterm(x)[1] == 0
+    assert (x + x**2).leadterm(x)[1] == 1
+    assert (x**2).leadterm(x)[1] == 2
+
+
+def test_as_leading_term():
+    assert (3 + 2*x**(log(3)/log(2) - 1)).as_leading_term(x) == 3
+    assert (1/x**2 + 1 + x + x**2).as_leading_term(x) == 1/x**2
+    assert (1/x + 1 + x + x**2).as_leading_term(x) == 1/x
+    assert (x**2 + 1/x).as_leading_term(x) == 1/x
+    assert (1 + x**2).as_leading_term(x) == 1
+    assert (x + 1).as_leading_term(x) == 1
+    assert (x + x**2).as_leading_term(x) == x
+    assert (x**2).as_leading_term(x) == x**2
+    assert (x + oo).as_leading_term(x) is oo
+
+    raises(ValueError, lambda: (x + 1).as_leading_term(1))
+
+    # https://github.com/sympy/sympy/issues/21177
+    e = -3*x + (x + Rational(3, 2) - sqrt(3)*S.ImaginaryUnit/2)**2\
+        - Rational(3, 2) + 3*sqrt(3)*S.ImaginaryUnit/2
+    assert e.as_leading_term(x) == -sqrt(3)*I*x
+
+    # https://github.com/sympy/sympy/issues/21245
+    e = 1 - x - x**2
+    d = (1 + sqrt(5))/2
+    assert e.subs(x, y + 1/d).as_leading_term(y) == \
+        (-40*y - 16*sqrt(5)*y)/(16 + 8*sqrt(5))
+
+    # https://github.com/sympy/sympy/issues/26991
+    assert sinh(tanh(3/(100*x))).as_leading_term(x, cdir = 1) == sinh(1)
+
+
+def test_leadterm2():
+    assert (x*cos(1)*cos(1 + sin(1)) + sin(1 + sin(1))).leadterm(x) == \
+           (sin(1 + sin(1)), 0)
+
+
+def test_leadterm3():
+    assert (y + z + x).leadterm(x) == (y + z, 0)
+
+
+def test_as_leading_term2():
+    assert (x*cos(1)*cos(1 + sin(1)) + sin(1 + sin(1))).as_leading_term(x) == \
+        sin(1 + sin(1))
+
+
+def test_as_leading_term3():
+    assert (2 + pi + x).as_leading_term(x) == 2 + pi
+    assert (2*x + pi*x + x**2).as_leading_term(x) == 2*x + pi*x
+
+
+def test_as_leading_term4():
+    # see issue 6843
+    n = Symbol('n', integer=True, positive=True)
+    r = -n**3/(2*n**2 + 4*n + 2) - n**2/(n**2 + 2*n + 1) + \
+        n**2/(n + 1) - n/(2*n**2 + 4*n + 2) + n/(n*x + x) + 2*n/(n + 1) - \
+        1 + 1/(n*x + x) + 1/(n + 1) - 1/x
+    assert r.as_leading_term(x).cancel() == n/2
+
+
+def test_as_leading_term_stub():
+    class foo(Function):
+        pass
+    assert foo(1/x).as_leading_term(x) == foo(1/x)
+    assert foo(1).as_leading_term(x) == foo(1)
+    raises(NotImplementedError, lambda: foo(x).as_leading_term(x))
+
+
+def test_as_leading_term_deriv_integral():
+    # related to issue 11313
+    assert Derivative(x ** 3, x).as_leading_term(x) == 3*x**2
+    assert Derivative(x ** 3, y).as_leading_term(x) == 0
+
+    assert Integral(x ** 3, x).as_leading_term(x) == x**4/4
+    assert Integral(x ** 3, y).as_leading_term(x) == y*x**3
+
+    assert Derivative(exp(x), x).as_leading_term(x) == 1
+    assert Derivative(log(x), x).as_leading_term(x) == (1/x).as_leading_term(x)
+
+
+def test_atoms():
+    assert x.atoms() == {x}
+    assert (1 + x).atoms() == {x, S.One}
+
+    assert (1 + 2*cos(x)).atoms(Symbol) == {x}
+    assert (1 + 2*cos(x)).atoms(Symbol, Number) == {S.One, S(2), x}
+
+    assert (2*(x**(y**x))).atoms() == {S(2), x, y}
+
+    assert S.Half.atoms() == {S.Half}
+    assert S.Half.atoms(Symbol) == set()
+
+    assert sin(oo).atoms(oo) == set()
+
+    assert Poly(0, x).atoms() == {S.Zero, x}
+    assert Poly(1, x).atoms() == {S.One, x}
+
+    assert Poly(x, x).atoms() == {x}
+    assert Poly(x, x, y).atoms() == {x, y}
+    assert Poly(x + y, x, y).atoms() == {x, y}
+    assert Poly(x + y, x, y, z).atoms() == {x, y, z}
+    assert Poly(x + y*t, x, y, z).atoms() == {t, x, y, z}
+
+    assert (I*pi).atoms(NumberSymbol) == {pi}
+    assert (I*pi).atoms(NumberSymbol, I) == \
+        (I*pi).atoms(I, NumberSymbol) == {pi, I}
+
+    assert exp(exp(x)).atoms(exp) == {exp(exp(x)), exp(x)}
+    assert (1 + x*(2 + y) + exp(3 + z)).atoms(Add) == \
+        {1 + x*(2 + y) + exp(3 + z), 2 + y, 3 + z}
+
+    # issue 6132
+    e = (f(x) + sin(x) + 2)
+    assert e.atoms(AppliedUndef) == \
+        {f(x)}
+    assert e.atoms(AppliedUndef, Function) == \
+        {f(x), sin(x)}
+    assert e.atoms(Function) == \
+        {f(x), sin(x)}
+    assert e.atoms(AppliedUndef, Number) == \
+        {f(x), S(2)}
+    assert e.atoms(Function, Number) == \
+        {S(2), sin(x), f(x)}
+
+
+def test_is_polynomial():
+    k = Symbol('k', nonnegative=True, integer=True)
+
+    assert Rational(2).is_polynomial(x, y, z) is True
+    assert (S.Pi).is_polynomial(x, y, z) is True
+
+    assert x.is_polynomial(x) is True
+    assert x.is_polynomial(y) is True
+
+    assert (x**2).is_polynomial(x) is True
+    assert (x**2).is_polynomial(y) is True
+
+    assert (x**(-2)).is_polynomial(x) is False
+    assert (x**(-2)).is_polynomial(y) is True
+
+    assert (2**x).is_polynomial(x) is False
+    assert (2**x).is_polynomial(y) is True
+
+    assert (x**k).is_polynomial(x) is False
+    assert (x**k).is_polynomial(k) is False
+    assert (x**x).is_polynomial(x) is False
+    assert (k**k).is_polynomial(k) is False
+    assert (k**x).is_polynomial(k) is False
+
+    assert (x**(-k)).is_polynomial(x) is False
+    assert ((2*x)**k).is_polynomial(x) is False
+
+    assert (x**2 + 3*x - 8).is_polynomial(x) is True
+    assert (x**2 + 3*x - 8).is_polynomial(y) is True
+
+    assert (x**2 + 3*x - 8).is_polynomial() is True
+
+    assert sqrt(x).is_polynomial(x) is False
+    assert (sqrt(x)**3).is_polynomial(x) is False
+
+    assert (x**2 + 3*x*sqrt(y) - 8).is_polynomial(x) is True
+    assert (x**2 + 3*x*sqrt(y) - 8).is_polynomial(y) is False
+
+    assert ((x**2)*(y**2) + x*(y**2) + y*x + exp(2)).is_polynomial() is True
+    assert ((x**2)*(y**2) + x*(y**2) + y*x + exp(x)).is_polynomial() is False
+
+    assert (
+        (x**2)*(y**2) + x*(y**2) + y*x + exp(2)).is_polynomial(x, y) is True
+    assert (
+        (x**2)*(y**2) + x*(y**2) + y*x + exp(x)).is_polynomial(x, y) is False
+
+    assert (1/f(x) + 1).is_polynomial(f(x)) is False
+
+
+def test_is_rational_function():
+    assert Integer(1).is_rational_function() is True
+    assert Integer(1).is_rational_function(x) is True
+
+    assert Rational(17, 54).is_rational_function() is True
+    assert Rational(17, 54).is_rational_function(x) is True
+
+    assert (12/x).is_rational_function() is True
+    assert (12/x).is_rational_function(x) is True
+
+    assert (x/y).is_rational_function() is True
+    assert (x/y).is_rational_function(x) is True
+    assert (x/y).is_rational_function(x, y) is True
+
+    assert (x**2 + 1/x/y).is_rational_function() is True
+    assert (x**2 + 1/x/y).is_rational_function(x) is True
+    assert (x**2 + 1/x/y).is_rational_function(x, y) is True
+
+    assert (sin(y)/x).is_rational_function() is False
+    assert (sin(y)/x).is_rational_function(y) is False
+    assert (sin(y)/x).is_rational_function(x) is True
+    assert (sin(y)/x).is_rational_function(x, y) is False
+
+    for i in _illegal:
+        assert not i.is_rational_function()
+        for d in (1, x):
+            assert not (i/d).is_rational_function()
+
+
+def test_is_meromorphic():
+    f = a/x**2 + b + x + c*x**2
+    assert f.is_meromorphic(x, 0) is True
+    assert f.is_meromorphic(x, 1) is True
+    assert f.is_meromorphic(x, zoo) is True
+
+    g = 3 + 2*x**(log(3)/log(2) - 1)
+    assert g.is_meromorphic(x, 0) is False
+    assert g.is_meromorphic(x, 1) is True
+    assert g.is_meromorphic(x, zoo) is False
+
+    n = Symbol('n', integer=True)
+    e = sin(1/x)**n*x
+    assert e.is_meromorphic(x, 0) is False
+    assert e.is_meromorphic(x, 1) is True
+    assert e.is_meromorphic(x, zoo) is False
+
+    e = log(x)**pi
+    assert e.is_meromorphic(x, 0) is False
+    assert e.is_meromorphic(x, 1) is False
+    assert e.is_meromorphic(x, 2) is True
+    assert e.is_meromorphic(x, zoo) is False
+
+    assert (log(x)**a).is_meromorphic(x, 0) is False
+    assert (log(x)**a).is_meromorphic(x, 1) is False
+    assert (a**log(x)).is_meromorphic(x, 0) is None
+    assert (3**log(x)).is_meromorphic(x, 0) is False
+    assert (3**log(x)).is_meromorphic(x, 1) is True
+
+def test_is_algebraic_expr():
+    assert sqrt(3).is_algebraic_expr(x) is True
+    assert sqrt(3).is_algebraic_expr() is True
+
+    eq = ((1 + x**2)/(1 - y**2))**(S.One/3)
+    assert eq.is_algebraic_expr(x) is True
+    assert eq.is_algebraic_expr(y) is True
+
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr(x) is True
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr(y) is True
+    assert (sqrt(x) + y**(S(2)/3)).is_algebraic_expr() is True
+
+    assert (cos(y)/sqrt(x)).is_algebraic_expr() is False
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(x) is True
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(y) is False
+    assert (cos(y)/sqrt(x)).is_algebraic_expr(x, y) is False
+
+
+def test_SAGE1():
+    #see https://github.com/sympy/sympy/issues/3346
+    class MyInt:
+        def _sympy_(self):
+            return Integer(5)
+    m = MyInt()
+    e = Rational(2)*m
+    assert e == 10
+
+    raises(TypeError, lambda: Rational(2)*MyInt)
+
+
+def test_SAGE2():
+    class MyInt:
+        def __int__(self):
+            return 5
+    assert sympify(MyInt()) == 5
+    e = Rational(2)*MyInt()
+    assert e == 10
+
+    raises(TypeError, lambda: Rational(2)*MyInt)
+
+
+def test_SAGE3():
+    class MySymbol:
+        def __rmul__(self, other):
+            return ('mys', other, self)
+
+    o = MySymbol()
+    e = x*o
+
+    assert e == ('mys', x, o)
+
+
+def test_len():
+    e = x*y
+    assert len(e.args) == 2
+    e = x + y + z
+    assert len(e.args) == 3
+
+
+def test_doit():
+    a = Integral(x**2, x)
+
+    assert isinstance(a.doit(), Integral) is False
+
+    assert isinstance(a.doit(integrals=True), Integral) is False
+    assert isinstance(a.doit(integrals=False), Integral) is True
+
+    assert (2*Integral(x, x)).doit() == x**2
+
+
+def test_attribute_error():
+    raises(AttributeError, lambda: x.cos())
+    raises(AttributeError, lambda: x.sin())
+    raises(AttributeError, lambda: x.exp())
+
+
+def test_args():
+    assert (x*y).args in ((x, y), (y, x))
+    assert (x + y).args in ((x, y), (y, x))
+    assert (x*y + 1).args in ((x*y, 1), (1, x*y))
+    assert sin(x*y).args == (x*y,)
+    assert sin(x*y).args[0] == x*y
+    assert (x**y).args == (x, y)
+    assert (x**y).args[0] == x
+    assert (x**y).args[1] == y
+
+
+def test_noncommutative_expand_issue_3757():
+    A, B, C = symbols('A,B,C', commutative=False)
+    assert A*B - B*A != 0
+    assert (A*(A + B)*B).expand() == A**2*B + A*B**2
+    assert (A*(A + B + C)*B).expand() == A**2*B + A*B**2 + A*C*B
+
+
+def test_as_numer_denom():
+    a, b, c = symbols('a, b, c')
+
+    assert nan.as_numer_denom() == (nan, 1)
+    assert oo.as_numer_denom() == (oo, 1)
+    assert (-oo).as_numer_denom() == (-oo, 1)
+    assert zoo.as_numer_denom() == (zoo, 1)
+    assert (-zoo).as_numer_denom() == (zoo, 1)
+
+    assert x.as_numer_denom() == (x, 1)
+    assert (1/x).as_numer_denom() == (1, x)
+    assert (x/y).as_numer_denom() == (x, y)
+    assert (x/2).as_numer_denom() == (x, 2)
+    assert (x*y/z).as_numer_denom() == (x*y, z)
+    assert (x/(y*z)).as_numer_denom() == (x, y*z)
+    assert S.Half.as_numer_denom() == (1, 2)
+    assert (1/y**2).as_numer_denom() == (1, y**2)
+    assert (x/y**2).as_numer_denom() == (x, y**2)
+    assert ((x**2 + 1)/y).as_numer_denom() == (x**2 + 1, y)
+    assert (x*(y + 1)/y**7).as_numer_denom() == (x*(y + 1), y**7)
+    assert (x**-2).as_numer_denom() == (1, x**2)
+    assert (a/x + b/2/x + c/3/x).as_numer_denom() == \
+        (6*a + 3*b + 2*c, 6*x)
+    assert (a/x + b/2/x + c/3/y).as_numer_denom() == \
+        (2*c*x + y*(6*a + 3*b), 6*x*y)
+    assert (a/x + b/2/x + c/.5/x).as_numer_denom() == \
+        (2*a + b + 4.0*c, 2*x)
+    # this should take no more than a few seconds
+    assert int(log(Add(*[Dummy()/i/x for i in range(1, 705)]
+                       ).as_numer_denom()[1]/x).n(4)) == 705
+    for i in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+        assert (i + x/3).as_numer_denom() == \
+            (x + i, 3)
+    assert (S.Infinity + x/3 + y/4).as_numer_denom() == \
+        (4*x + 3*y + S.Infinity, 12)
+    assert (oo*x + zoo*y).as_numer_denom() == \
+        (zoo*y + oo*x, 1)
+
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert (A*B*C**-1).as_numer_denom() == (A*B*C**-1, 1)
+    assert (A*B*C**-1/x).as_numer_denom() == (A*B*C**-1, x)
+    assert (C**-1*A*B).as_numer_denom() == (C**-1*A*B, 1)
+    assert (C**-1*A*B/x).as_numer_denom() == (C**-1*A*B, x)
+    assert ((A*B*C)**-1).as_numer_denom() == ((A*B*C)**-1, 1)
+    assert ((A*B*C)**-1/x).as_numer_denom() == ((A*B*C)**-1, x)
+
+    # the following morphs from Add to Mul during processing
+    assert Add(0, (x + y)/z/-2, evaluate=False).as_numer_denom(
+        ) == (-x - y, 2*z)
+
+
+def test_trunc():
+    import math
+    x, y = symbols('x y')
+    assert math.trunc(2) == 2
+    assert math.trunc(4.57) == 4
+    assert math.trunc(-5.79) == -5
+    assert math.trunc(pi) == 3
+    assert math.trunc(log(7)) == 1
+    assert math.trunc(exp(5)) == 148
+    assert math.trunc(cos(pi)) == -1
+    assert math.trunc(sin(5)) == 0
+
+    raises(TypeError, lambda: math.trunc(x))
+    raises(TypeError, lambda: math.trunc(x + y**2))
+    raises(TypeError, lambda: math.trunc(oo))
+
+
+def test_as_independent():
+    assert S.Zero.as_independent(x, as_Add=True) == (0, 0)
+    assert S.Zero.as_independent(x, as_Add=False) == (0, 0)
+    assert (2*x*sin(x) + y + x).as_independent(x) == (y, x + 2*x*sin(x))
+    assert (2*x*sin(x) + y + x).as_independent(y) == (x + 2*x*sin(x), y)
+
+    assert (2*x*sin(x) + y + x).as_independent(x, y) == (0, y + x + 2*x*sin(x))
+
+    assert (x*sin(x)*cos(y)).as_independent(x) == (cos(y), x*sin(x))
+    assert (x*sin(x)*cos(y)).as_independent(y) == (x*sin(x), cos(y))
+
+    assert (x*sin(x)*cos(y)).as_independent(x, y) == (1, x*sin(x)*cos(y))
+
+    assert (sin(x)).as_independent(x) == (1, sin(x))
+    assert (sin(x)).as_independent(y) == (sin(x), 1)
+
+    assert (2*sin(x)).as_independent(x) == (2, sin(x))
+    assert (2*sin(x)).as_independent(y) == (2*sin(x), 1)
+
+    # issue 4903 = 1766b
+    n1, n2, n3 = symbols('n1 n2 n3', commutative=False)
+    assert (n1 + n1*n2).as_independent(n2) == (n1, n1*n2)
+    assert (n2*n1 + n1*n2).as_independent(n2) == (0, n1*n2 + n2*n1)
+    assert (n1*n2*n1).as_independent(n2) == (n1, n2*n1)
+    assert (n1*n2*n1).as_independent(n1) == (1, n1*n2*n1)
+
+    assert (3*x).as_independent(x, as_Add=True) == (0, 3*x)
+    assert (3*x).as_independent(x, as_Add=False) == (3, x)
+    assert (3 + x).as_independent(x, as_Add=True) == (3, x)
+    assert (3 + x).as_independent(x, as_Add=False) == (1, 3 + x)
+
+    # issue 5479
+    assert (3*x).as_independent(Symbol) == (3, x)
+
+    # issue 5648
+    assert (n1*x*y).as_independent(x) == (n1*y, x)
+    assert ((x + n1)*(x - y)).as_independent(x) == (1, (x + n1)*(x - y))
+    assert ((x + n1)*(x - y)).as_independent(y) == (x + n1, x - y)
+    assert (DiracDelta(x - n1)*DiracDelta(x - y)).as_independent(x) \
+        == (1, DiracDelta(x - n1)*DiracDelta(x - y))
+    assert (x*y*n1*n2*n3).as_independent(n2) == (x*y*n1, n2*n3)
+    assert (x*y*n1*n2*n3).as_independent(n1) == (x*y, n1*n2*n3)
+    assert (x*y*n1*n2*n3).as_independent(n3) == (x*y*n1*n2, n3)
+    assert (DiracDelta(x - n1)*DiracDelta(y - n1)*DiracDelta(x - n2)).as_independent(y) == \
+           (DiracDelta(x - n1)*DiracDelta(x - n2), DiracDelta(y - n1))
+
+    # issue 5784
+    assert (x + Integral(x, (x, 1, 2))).as_independent(x, strict=True) == \
+           (Integral(x, (x, 1, 2)), x)
+
+    eq = Add(x, -x, 2, -3, evaluate=False)
+    assert eq.as_independent(x) == (-1, Add(x, -x, evaluate=False))
+    eq = Mul(x, 1/x, 2, -3, evaluate=False)
+    assert eq.as_independent(x) == (-6, Mul(x, 1/x, evaluate=False))
+
+    assert (x*y).as_independent(z, as_Add=True) == (x*y, 0)
+
+@XFAIL
+def test_call_2():
+    # TODO UndefinedFunction does not subclass Expr
+    assert (2*f)(x) == 2*f(x)
+
+
+def test_replace():
+    e = log(sin(x)) + tan(sin(x**2))
+
+    assert e.replace(sin, cos) == log(cos(x)) + tan(cos(x**2))
+    assert e.replace(
+        sin, lambda a: sin(2*a)) == log(sin(2*x)) + tan(sin(2*x**2))
+
+    a = Wild('a')
+    b = Wild('b')
+
+    assert e.replace(sin(a), cos(a)) == log(cos(x)) + tan(cos(x**2))
+    assert e.replace(
+        sin(a), lambda a: sin(2*a)) == log(sin(2*x)) + tan(sin(2*x**2))
+    # test exact
+    assert (2*x).replace(a*x + b, b - a, exact=True) == 2*x
+    assert (2*x).replace(a*x + b, b - a) == 2*x
+    assert (2*x).replace(a*x + b, b - a, exact=False) == 2/x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a, exact=True) == 2*x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a) == 2*x
+    assert (2*x).replace(a*x + b, lambda a, b: b - a, exact=False) == 2/x
+
+    g = 2*sin(x**3)
+
+    assert g.replace(
+        lambda expr: expr.is_Number, lambda expr: expr**2) == 4*sin(x**9)
+
+    assert cos(x).replace(cos, sin, map=True) == (sin(x), {cos(x): sin(x)})
+    assert sin(x).replace(cos, sin) == sin(x)
+
+    cond, func = lambda x: x.is_Mul, lambda x: 2*x
+    assert (x*y).replace(cond, func, map=True) == (2*x*y, {x*y: 2*x*y})
+    assert (x*(1 + x*y)).replace(cond, func, map=True) == \
+        (2*x*(2*x*y + 1), {x*(2*x*y + 1): 2*x*(2*x*y + 1), x*y: 2*x*y})
+    assert (y*sin(x)).replace(sin, lambda expr: sin(expr)/y, map=True) == \
+        (sin(x), {sin(x): sin(x)/y})
+    # if not simultaneous then y*sin(x) -> y*sin(x)/y = sin(x) -> sin(x)/y
+    assert (y*sin(x)).replace(sin, lambda expr: sin(expr)/y,
+        simultaneous=False) == sin(x)/y
+    assert (x**2 + O(x**3)).replace(Pow, lambda b, e: b**e/e
+        ) == x**2/2 + O(x**3)
+    assert (x**2 + O(x**3)).replace(Pow, lambda b, e: b**e/e,
+        simultaneous=False) == x**2/2 + O(x**3)
+    assert (x*(x*y + 3)).replace(lambda x: x.is_Mul, lambda x: 2 + x) == \
+        x*(x*y + 5) + 2
+    e = (x*y + 1)*(2*x*y + 1) + 1
+    assert e.replace(cond, func, map=True) == (
+        2*((2*x*y + 1)*(4*x*y + 1)) + 1,
+        {2*x*y: 4*x*y, x*y: 2*x*y, (2*x*y + 1)*(4*x*y + 1):
+        2*((2*x*y + 1)*(4*x*y + 1))})
+    assert x.replace(x, y) == y
+    assert (x + 1).replace(1, 2) == x + 2
+
+    # https://groups.google.com/forum/#!topic/sympy/8wCgeC95tz0
+    n1, n2, n3 = symbols('n1:4', commutative=False)
+    assert (n1*f(n2)).replace(f, lambda x: x) == n1*n2
+    assert (n3*f(n2)).replace(f, lambda x: x) == n3*n2
+
+    # issue 16725
+    assert S.Zero.replace(Wild('x'), 1) == 1
+    # let the user override the default decision of False
+    assert S.Zero.replace(Wild('x'), 1, exact=True) == 0
+
+
+def test_replace_integral():
+    # https://github.com/sympy/sympy/issues/27142
+    q, p, s, t = symbols('q p s t', cls=Wild)
+    a, b, c, d = symbols('a b c d')
+    i = Integral(a + b, (b, c, d))
+    pattern = Integral(q, (p, s, t))
+    assert i.replace(pattern, q) == a + b
+
+
+def test_find():
+    expr = (x + y + 2 + sin(3*x))
+
+    assert expr.find(lambda u: u.is_Integer) == {S(2), S(3)}
+    assert expr.find(lambda u: u.is_Symbol) == {x, y}
+
+    assert expr.find(lambda u: u.is_Integer, group=True) == {S(2): 1, S(3): 1}
+    assert expr.find(lambda u: u.is_Symbol, group=True) == {x: 2, y: 1}
+
+    assert expr.find(Integer) == {S(2), S(3)}
+    assert expr.find(Symbol) == {x, y}
+
+    assert expr.find(Integer, group=True) == {S(2): 1, S(3): 1}
+    assert expr.find(Symbol, group=True) == {x: 2, y: 1}
+
+    a = Wild('a')
+
+    expr = sin(sin(x)) + sin(x) + cos(x) + x
+
+    assert expr.find(lambda u: type(u) is sin) == {sin(x), sin(sin(x))}
+    assert expr.find(
+        lambda u: type(u) is sin, group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+    assert expr.find(sin(a)) == {sin(x), sin(sin(x))}
+    assert expr.find(sin(a), group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+    assert expr.find(sin) == {sin(x), sin(sin(x))}
+    assert expr.find(sin, group=True) == {sin(x): 2, sin(sin(x)): 1}
+
+
+def test_count():
+    expr = (x + y + 2 + sin(3*x))
+
+    assert expr.count(lambda u: u.is_Integer) == 2
+    assert expr.count(lambda u: u.is_Symbol) == 3
+
+    assert expr.count(Integer) == 2
+    assert expr.count(Symbol) == 3
+    assert expr.count(2) == 1
+
+    a = Wild('a')
+
+    assert expr.count(sin) == 1
+    assert expr.count(sin(a)) == 1
+    assert expr.count(lambda u: type(u) is sin) == 1
+
+    assert f(x).count(f(x)) == 1
+    assert f(x).diff(x).count(f(x)) == 1
+    assert f(x).diff(x).count(x) == 2
+
+
+def test_has_basics():
+    p = Wild('p')
+
+    assert sin(x).has(x)
+    assert sin(x).has(sin)
+    assert not sin(x).has(y)
+    assert not sin(x).has(cos)
+    assert f(x).has(x)
+    assert f(x).has(f)
+    assert not f(x).has(y)
+    assert not f(x).has(g)
+
+    assert f(x).diff(x).has(x)
+    assert f(x).diff(x).has(f)
+    assert f(x).diff(x).has(Derivative)
+    assert not f(x).diff(x).has(y)
+    assert not f(x).diff(x).has(g)
+    assert not f(x).diff(x).has(sin)
+
+    assert (x**2).has(Symbol)
+    assert not (x**2).has(Wild)
+    assert (2*p).has(Wild)
+
+    assert not x.has()
+
+    # see issue at https://github.com/sympy/sympy/issues/5190
+    assert not S(1).has(Wild)
+    assert not x.has(Wild)
+
+
+def test_has_multiple():
+    f = x**2*y + sin(2**t + log(z))
+
+    assert f.has(x)
+    assert f.has(y)
+    assert f.has(z)
+    assert f.has(t)
+
+    assert not f.has(u)
+
+    assert f.has(x, y, z, t)
+    assert f.has(x, y, z, t, u)
+
+    i = Integer(4400)
+
+    assert not i.has(x)
+
+    assert (i*x**i).has(x)
+    assert not (i*y**i).has(x)
+    assert (i*y**i).has(x, y)
+    assert not (i*y**i).has(x, z)
+
+
+def test_has_piecewise():
+    f = (x*y + 3/y)**(3 + 2)
+    p = Piecewise((g(x), x < -1), (1, x <= 1), (f, True))
+
+    assert p.has(x)
+    assert p.has(y)
+    assert not p.has(z)
+    assert p.has(1)
+    assert p.has(3)
+    assert not p.has(4)
+    assert p.has(f)
+    assert p.has(g)
+    assert not p.has(h)
+
+
+def test_has_iterative():
+    A, B, C = symbols('A,B,C', commutative=False)
+    f = x*gamma(x)*sin(x)*exp(x*y)*A*B*C*cos(x*A*B)
+
+    assert f.has(x)
+    assert f.has(x*y)
+    assert f.has(x*sin(x))
+    assert not f.has(x*sin(y))
+    assert f.has(x*A)
+    assert f.has(x*A*B)
+    assert not f.has(x*A*C)
+    assert f.has(x*A*B*C)
+    assert not f.has(x*A*C*B)
+    assert f.has(x*sin(x)*A*B*C)
+    assert not f.has(x*sin(x)*A*C*B)
+    assert not f.has(x*sin(y)*A*B*C)
+    assert f.has(x*gamma(x))
+    assert not f.has(x + sin(x))
+
+    assert (x & y & z).has(x & z)
+
+
+def test_has_integrals():
+    f = Integral(x**2 + sin(x*y*z), (x, 0, x + y + z))
+
+    assert f.has(x + y)
+    assert f.has(x + z)
+    assert f.has(y + z)
+
+    assert f.has(x*y)
+    assert f.has(x*z)
+    assert f.has(y*z)
+
+    assert not f.has(2*x + y)
+    assert not f.has(2*x*y)
+
+
+def test_has_tuple():
+    assert Tuple(x, y).has(x)
+    assert not Tuple(x, y).has(z)
+    assert Tuple(f(x), g(x)).has(x)
+    assert not Tuple(f(x), g(x)).has(y)
+    assert Tuple(f(x), g(x)).has(f)
+    assert Tuple(f(x), g(x)).has(f(x))
+    # XXX to be deprecated
+    #assert not Tuple(f, g).has(x)
+    #assert Tuple(f, g).has(f)
+    #assert not Tuple(f, g).has(h)
+    assert Tuple(True).has(True)
+    assert Tuple(True).has(S.true)
+    assert not Tuple(True).has(1)
+
+
+def test_has_units():
+    from sympy.physics.units import m, s
+
+    assert (x*m/s).has(x)
+    assert (x*m/s).has(y, z) is False
+
+
+def test_has_polys():
+    poly = Poly(x**2 + x*y*sin(z), x, y, t)
+
+    assert poly.has(x)
+    assert poly.has(x, y, z)
+    assert poly.has(x, y, z, t)
+
+
+def test_has_physics():
+    assert FockState((x, y)).has(x)
+
+
+def test_as_poly_as_expr():
+    f = x**2 + 2*x*y
+
+    assert f.as_poly().as_expr() == f
+    assert f.as_poly(x, y).as_expr() == f
+
+    assert (f + sin(x)).as_poly(x, y) is None
+
+    p = Poly(f, x, y)
+
+    assert p.as_poly() == p
+
+    # https://github.com/sympy/sympy/issues/20610
+    assert S(2).as_poly() is None
+    assert sqrt(2).as_poly(extension=True) is None
+
+    raises(AttributeError, lambda: Tuple(x, x).as_poly(x))
+    raises(AttributeError, lambda: Tuple(x ** 2, x, y).as_poly(x))
+
+
+def test_nonzero():
+    assert bool(S.Zero) is False
+    assert bool(S.One) is True
+    assert bool(x) is True
+    assert bool(x + y) is True
+    assert bool(x - x) is False
+    assert bool(x*y) is True
+    assert bool(x*1) is True
+    assert bool(x*0) is False
+
+
+def test_is_number():
+    assert Float(3.14).is_number is True
+    assert Integer(737).is_number is True
+    assert Rational(3, 2).is_number is True
+    assert Rational(8).is_number is True
+    assert x.is_number is False
+    assert (2*x).is_number is False
+    assert (x + y).is_number is False
+    assert log(2).is_number is True
+    assert log(x).is_number is False
+    assert (2 + log(2)).is_number is True
+    assert (8 + log(2)).is_number is True
+    assert (2 + log(x)).is_number is False
+    assert (8 + log(2) + x).is_number is False
+    assert (1 + x**2/x - x).is_number is True
+    assert Tuple(Integer(1)).is_number is False
+    assert Add(2, x).is_number is False
+    assert Mul(3, 4).is_number is True
+    assert Pow(log(2), 2).is_number is True
+    assert oo.is_number is True
+    g = WildFunction('g')
+    assert g.is_number is False
+    assert (2*g).is_number is False
+    assert (x**2).subs(x, 3).is_number is True
+
+    # test extensibility of .is_number
+    # on subinstances of Basic
+    class A(Basic):
+        pass
+    a = A()
+    assert a.is_number is False
+
+
+def test_as_coeff_add():
+    assert S(2).as_coeff_add() == (2, ())
+    assert S(3.0).as_coeff_add() == (0, (S(3.0),))
+    assert S(-3.0).as_coeff_add() == (0, (S(-3.0),))
+    assert x.as_coeff_add() == (0, (x,))
+    assert (x - 1).as_coeff_add() == (-1, (x,))
+    assert (x + 1).as_coeff_add() == (1, (x,))
+    assert (x + 2).as_coeff_add() == (2, (x,))
+    assert (x + y).as_coeff_add(y) == (x, (y,))
+    assert (3*x).as_coeff_add(y) == (3*x, ())
+    # don't do expansion
+    e = (x + y)**2
+    assert e.as_coeff_add(y) == (0, (e,))
+
+
+def test_as_coeff_mul():
+    assert S(2).as_coeff_mul() == (2, ())
+    assert S(3.0).as_coeff_mul() == (1, (S(3.0),))
+    assert S(-3.0).as_coeff_mul() == (-1, (S(3.0),))
+    assert S(-3.0).as_coeff_mul(rational=False) == (-S(3.0), ())
+    assert x.as_coeff_mul() == (1, (x,))
+    assert (-x).as_coeff_mul() == (-1, (x,))
+    assert (2*x).as_coeff_mul() == (2, (x,))
+    assert (x*y).as_coeff_mul(y) == (x, (y,))
+    assert (3 + x).as_coeff_mul() == (1, (3 + x,))
+    assert (3 + x).as_coeff_mul(y) == (3 + x, ())
+    # don't do expansion
+    e = exp(x + y)
+    assert e.as_coeff_mul(y) == (1, (e,))
+    e = 2**(x + y)
+    assert e.as_coeff_mul(y) == (1, (e,))
+    assert (1.1*x).as_coeff_mul(rational=False) == (1.1, (x,))
+    assert (1.1*x).as_coeff_mul() == (1, (1.1, x))
+    assert (-oo*x).as_coeff_mul(rational=True) == (-1, (oo, x))
+
+
+def test_as_coeff_exponent():
+    assert (3*x**4).as_coeff_exponent(x) == (3, 4)
+    assert (2*x**3).as_coeff_exponent(x) == (2, 3)
+    assert (4*x**2).as_coeff_exponent(x) == (4, 2)
+    assert (6*x**1).as_coeff_exponent(x) == (6, 1)
+    assert (3*x**0).as_coeff_exponent(x) == (3, 0)
+    assert (2*x**0).as_coeff_exponent(x) == (2, 0)
+    assert (1*x**0).as_coeff_exponent(x) == (1, 0)
+    assert (0*x**0).as_coeff_exponent(x) == (0, 0)
+    assert (-1*x**0).as_coeff_exponent(x) == (-1, 0)
+    assert (-2*x**0).as_coeff_exponent(x) == (-2, 0)
+    assert (2*x**3 + pi*x**3).as_coeff_exponent(x) == (2 + pi, 3)
+    assert (x*log(2)/(2*x + pi*x)).as_coeff_exponent(x) == \
+        (log(2)/(2 + pi), 0)
+    # issue 4784
+    D = Derivative
+    fx = D(f(x), x)
+    assert fx.as_coeff_exponent(f(x)) == (fx, 0)
+
+
+def test_extractions():
+    for base in (2, S.Exp1):
+        assert Pow(base**x, 3, evaluate=False
+            ).extract_multiplicatively(base**x) == base**(2*x)
+        assert (base**(5*x)).extract_multiplicatively(
+            base**(3*x)) == base**(2*x)
+    assert ((x*y)**3).extract_multiplicatively(x**2 * y) == x*y**2
+    assert ((x*y)**3).extract_multiplicatively(x**4 * y) is None
+    assert (2*x).extract_multiplicatively(2) == x
+    assert (2*x).extract_multiplicatively(3) is None
+    assert (2*x).extract_multiplicatively(-1) is None
+    assert (S.Half*x).extract_multiplicatively(3) == x/6
+    assert (sqrt(x)).extract_multiplicatively(x) is None
+    assert (sqrt(x)).extract_multiplicatively(1/x) is None
+    assert x.extract_multiplicatively(-x) is None
+    assert (-2 - 4*I).extract_multiplicatively(-2) == 1 + 2*I
+    assert (-2 - 4*I).extract_multiplicatively(3) is None
+    assert (-2*x - 4*y - 8).extract_multiplicatively(-2) == x + 2*y + 4
+    assert (-2*x*y - 4*x**2*y).extract_multiplicatively(-2*y) == 2*x**2 + x
+    assert (2*x*y + 4*x**2*y).extract_multiplicatively(2*y) == 2*x**2 + x
+    assert (-4*y**2*x).extract_multiplicatively(-3*y) is None
+    assert (2*x).extract_multiplicatively(1) == 2*x
+    assert (-oo).extract_multiplicatively(5) is -oo
+    assert (oo).extract_multiplicatively(5) is oo
+
+    assert ((x*y)**3).extract_additively(1) is None
+    assert (x + 1).extract_additively(x) == 1
+    assert (x + 1).extract_additively(2*x) is None
+    assert (x + 1).extract_additively(-x) is None
+    assert (-x + 1).extract_additively(2*x) is None
+    assert (2*x + 3).extract_additively(x) == x + 3
+    assert (2*x + 3).extract_additively(2) == 2*x + 1
+    assert (2*x + 3).extract_additively(3) == 2*x
+    assert (2*x + 3).extract_additively(-2) is None
+    assert (2*x + 3).extract_additively(3*x) is None
+    assert (2*x + 3).extract_additively(2*x) == 3
+    assert x.extract_additively(0) == x
+    assert S(2).extract_additively(x) is None
+    assert S(2.).extract_additively(2.) is S.Zero
+    assert S(2.).extract_additively(2) is S.Zero
+    assert S(2*x + 3).extract_additively(x + 1) == x + 2
+    assert S(2*x + 3).extract_additively(y + 1) is None
+    assert S(2*x - 3).extract_additively(x + 1) is None
+    assert S(2*x - 3).extract_additively(y + z) is None
+    assert ((a + 1)*x*4 + y).extract_additively(x).expand() == \
+        4*a*x + 3*x + y
+    assert ((a + 1)*x*4 + 3*y).extract_additively(x + 2*y).expand() == \
+        4*a*x + 3*x + y
+    assert (y*(x + 1)).extract_additively(x + 1) is None
+    assert ((y + 1)*(x + 1) + 3).extract_additively(x + 1) == \
+        y*(x + 1) + 3
+    assert ((x + y)*(x + 1) + x + y + 3).extract_additively(x + y) == \
+        x*(x + y) + 3
+    assert (x + y + 2*((x + y)*(x + 1)) + 3).extract_additively((x + y)*(x + 1)) == \
+        x + y + (x + 1)*(x + y) + 3
+    assert ((y + 1)*(x + 2*y + 1) + 3).extract_additively(y + 1) == \
+        (x + 2*y)*(y + 1) + 3
+    assert (-x - x*I).extract_additively(-x) == -I*x
+    # extraction does not leave artificats, now
+    assert (4*x*(y + 1) + y).extract_additively(x) == x*(4*y + 3) + y
+
+    n = Symbol("n", integer=True)
+    assert (Integer(-3)).could_extract_minus_sign() is True
+    assert (-n*x + x).could_extract_minus_sign() != \
+        (n*x - x).could_extract_minus_sign()
+    assert (x - y).could_extract_minus_sign() != \
+        (-x + y).could_extract_minus_sign()
+    assert (1 - x - y).could_extract_minus_sign() is True
+    assert (1 - x + y).could_extract_minus_sign() is False
+    assert ((-x - x*y)/y).could_extract_minus_sign() is False
+    assert ((x + x*y)/(-y)).could_extract_minus_sign() is True
+    assert ((x + x*y)/y).could_extract_minus_sign() is False
+    assert ((-x - y)/(x + y)).could_extract_minus_sign() is False
+
+    class sign_invariant(Function, Expr):
+        nargs = 1
+        def __neg__(self):
+            return self
+    foo = sign_invariant(x)
+    assert foo == -foo
+    assert foo.could_extract_minus_sign() is False
+    assert (x - y).could_extract_minus_sign() is False
+    assert (-x + y).could_extract_minus_sign() is True
+    assert (x - 1).could_extract_minus_sign() is False
+    assert (1 - x).could_extract_minus_sign() is True
+    assert (sqrt(2) - 1).could_extract_minus_sign() is True
+    assert (1 - sqrt(2)).could_extract_minus_sign() is False
+    # check that result is canonical
+    eq = (3*x + 15*y).extract_multiplicatively(3)
+    assert eq.args == eq.func(*eq.args).args
+
+
+def test_nan_extractions():
+    for r in (1, 0, I, nan):
+        assert nan.extract_additively(r) is None
+        assert nan.extract_multiplicatively(r) is None
+
+
+def test_coeff():
+    assert (x + 1).coeff(x + 1) == 1
+    assert (3*x).coeff(0) == 0
+    assert (z*(1 + x)*x**2).coeff(1 + x) == z*x**2
+    assert (1 + 2*x*x**(1 + x)).coeff(x*x**(1 + x)) == 2
+    assert (1 + 2*x**(y + z)).coeff(x**(y + z)) == 2
+    assert (3 + 2*x + 4*x**2).coeff(1) == 0
+    assert (3 + 2*x + 4*x**2).coeff(-1) == 0
+    assert (3 + 2*x + 4*x**2).coeff(x) == 2
+    assert (3 + 2*x + 4*x**2).coeff(x**2) == 4
+    assert (3 + 2*x + 4*x**2).coeff(x**3) == 0
+
+    assert (-x/8 + x*y).coeff(x) == Rational(-1, 8) + y
+    assert (-x/8 + x*y).coeff(-x) == S.One/8
+    assert (4*x).coeff(2*x) == 0
+    assert (2*x).coeff(2*x) == 1
+    assert (-oo*x).coeff(x*oo) == -1
+    assert (10*x).coeff(x, 0) == 0
+    assert (10*x).coeff(10*x, 0) == 0
+
+    n1, n2 = symbols('n1 n2', commutative=False)
+    assert (n1*n2).coeff(n1) == 1
+    assert (n1*n2).coeff(n2) == n1
+    assert (n1*n2 + x*n1).coeff(n1) == 1  # 1*n1*(n2+x)
+    assert (n2*n1 + x*n1).coeff(n1) == n2 + x
+    assert (n2*n1 + x*n1**2).coeff(n1) == n2
+    assert (n1**x).coeff(n1) == 0
+    assert (n1*n2 + n2*n1).coeff(n1) == 0
+    assert (2*(n1 + n2)*n2).coeff(n1 + n2, right=1) == n2
+    assert (2*(n1 + n2)*n2).coeff(n1 + n2, right=0) == 2
+
+    assert (2*f(x) + 3*f(x).diff(x)).coeff(f(x)) == 2
+
+    expr = z*(x + y)**2
+    expr2 = z*(x + y)**2 + z*(2*x + 2*y)**2
+    assert expr.coeff(z) == (x + y)**2
+    assert expr.coeff(x + y) == 0
+    assert expr2.coeff(z) == (x + y)**2 + (2*x + 2*y)**2
+
+    assert (x + y + 3*z).coeff(1) == x + y
+    assert (-x + 2*y).coeff(-1) == x
+    assert (x - 2*y).coeff(-1) == 2*y
+    assert (3 + 2*x + 4*x**2).coeff(1) == 0
+    assert (-x - 2*y).coeff(2) == -y
+    assert (x + sqrt(2)*x).coeff(sqrt(2)) == x
+    assert (3 + 2*x + 4*x**2).coeff(x) == 2
+    assert (3 + 2*x + 4*x**2).coeff(x**2) == 4
+    assert (3 + 2*x + 4*x**2).coeff(x**3) == 0
+    assert (z*(x + y)**2).coeff((x + y)**2) == z
+    assert (z*(x + y)**2).coeff(x + y) == 0
+    assert (2 + 2*x + (x + 1)*y).coeff(x + 1) == y
+
+    assert (x + 2*y + 3).coeff(1) == x
+    assert (x + 2*y + 3).coeff(x, 0) == 2*y + 3
+    assert (x**2 + 2*y + 3*x).coeff(x**2, 0) == 2*y + 3*x
+    assert x.coeff(0, 0) == 0
+    assert x.coeff(x, 0) == 0
+
+    n, m, o, l = symbols('n m o l', commutative=False)
+    assert n.coeff(n) == 1
+    assert y.coeff(n) == 0
+    assert (3*n).coeff(n) == 3
+    assert (2 + n).coeff(x*m) == 0
+    assert (2*x*n*m).coeff(x) == 2*n*m
+    assert (2 + n).coeff(x*m*n + y) == 0
+    assert (2*x*n*m).coeff(3*n) == 0
+    assert (n*m + m*n*m).coeff(n) == 1 + m
+    assert (n*m + m*n*m).coeff(n, right=True) == m  # = (1 + m)*n*m
+    assert (n*m + m*n).coeff(n) == 0
+    assert (n*m + o*m*n).coeff(m*n) == o
+    assert (n*m + o*m*n).coeff(m*n, right=True) == 1
+    assert (n*m + n*m*n).coeff(n*m, right=True) == 1 + n  # = n*m*(n + 1)
+
+    assert (x*y).coeff(z, 0) == x*y
+
+    assert (x*n + y*n + z*m).coeff(n) == x + y
+    assert (n*m + n*o + o*l).coeff(n, right=True) == m + o
+    assert (x*n*m*n + y*n*m*o + z*l).coeff(m, right=True) == x*n + y*o
+    assert (x*n*m*n + x*n*m*o + z*l).coeff(m, right=True) == n + o
+    assert (x*n*m*n + x*n*m*o + z*l).coeff(m) == x*n
+
+
+def test_coeff2():
+    r, kappa = symbols('r, kappa')
+    psi = Function("psi")
+    g = 1/r**2 * (2*r*psi(r).diff(r, 1) + r**2 * psi(r).diff(r, 2))
+    g = g.expand()
+    assert g.coeff(psi(r).diff(r)) == 2/r
+
+
+def test_coeff2_0():
+    r, kappa = symbols('r, kappa')
+    psi = Function("psi")
+    g = 1/r**2 * (2*r*psi(r).diff(r, 1) + r**2 * psi(r).diff(r, 2))
+    g = g.expand()
+
+    assert g.coeff(psi(r).diff(r, 2)) == 1
+
+
+def test_coeff_expand():
+    expr = z*(x + y)**2
+    expr2 = z*(x + y)**2 + z*(2*x + 2*y)**2
+    assert expr.coeff(z) == (x + y)**2
+    assert expr2.coeff(z) == (x + y)**2 + (2*x + 2*y)**2
+
+
+def test_integrate():
+    assert x.integrate(x) == x**2/2
+    assert x.integrate((x, 0, 1)) == S.Half
+
+
+def test_as_base_exp():
+    assert x.as_base_exp() == (x, S.One)
+    assert (x*y*z).as_base_exp() == (x*y*z, S.One)
+    assert (x + y + z).as_base_exp() == (x + y + z, S.One)
+    assert ((x + y)**z).as_base_exp() == (x + y, z)
+    assert (x**2*y**2).as_base_exp() == (x*y, 2)
+    assert (x**z*y**z).as_base_exp() == (x**z*y**z, S.One)
+
+
+def test_issue_4963():
+    assert hasattr(Mul(x, y), "is_commutative")
+    assert hasattr(Mul(x, y, evaluate=False), "is_commutative")
+    assert hasattr(Pow(x, y), "is_commutative")
+    assert hasattr(Pow(x, y, evaluate=False), "is_commutative")
+    expr = Mul(Pow(2, 2, evaluate=False), 3, evaluate=False) + 1
+    assert hasattr(expr, "is_commutative")
+
+
+def test_action_verbs():
+    assert nsimplify(1/(exp(3*pi*x/5) + 1)) == \
+        (1/(exp(3*pi*x/5) + 1)).nsimplify()
+    assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp()
+    assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep=True)
+    assert radsimp(1/(2 + sqrt(2))) == (1/(2 + sqrt(2))).radsimp()
+    assert radsimp(1/(a + b*sqrt(c)), symbolic=False) == \
+        (1/(a + b*sqrt(c))).radsimp(symbolic=False)
+    assert powsimp(x**y*x**z*y**z, combine='all') == \
+        (x**y*x**z*y**z).powsimp(combine='all')
+    assert (x**t*y**t).powsimp(force=True) == (x*y)**t
+    assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify()
+    assert together(1/x + 1/y) == (1/x + 1/y).together()
+    assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == \
+        (a*x**2 + b*x**2 + a*x - b*x + c).collect(x)
+    assert apart(y/(y + 2)/(y + 1), y) == (y/(y + 2)/(y + 1)).apart(y)
+    assert combsimp(y/(x + 2)/(x + 1)) == (y/(x + 2)/(x + 1)).combsimp()
+    assert gammasimp(gamma(x)/gamma(x-5)) == (gamma(x)/gamma(x-5)).gammasimp()
+    assert factor(x**2 + 5*x + 6) == (x**2 + 5*x + 6).factor()
+    assert refine(sqrt(x**2)) == sqrt(x**2).refine()
+    assert cancel((x**2 + 5*x + 6)/(x + 2)) == ((x**2 + 5*x + 6)/(x + 2)).cancel()
+
+
+def test_as_powers_dict():
+    assert x.as_powers_dict() == {x: 1}
+    assert (x**y*z).as_powers_dict() == {x: y, z: 1}
+    assert Mul(2, 2, evaluate=False).as_powers_dict() == {S(2): S(2)}
+    assert (x*y).as_powers_dict()[z] == 0
+    assert (x + y).as_powers_dict()[z] == 0
+
+
+def test_as_coefficients_dict():
+    check = [S.One, x, y, x*y, 1]
+    assert [Add(3*x, 2*x, y, 3).as_coefficients_dict()[i] for i in check] == \
+        [3, 5, 1, 0, 3]
+    assert [Add(3*x, 2*x, y, 3, evaluate=False).as_coefficients_dict()[i]
+            for i in check] == [3, 5, 1, 0, 3]
+    assert [(3*x*y).as_coefficients_dict()[i] for i in check] == \
+        [0, 0, 0, 3, 0]
+    assert [(3.0*x*y).as_coefficients_dict()[i] for i in check] == \
+        [0, 0, 0, 3.0, 0]
+    assert (3.0*x*y).as_coefficients_dict()[3.0*x*y] == 0
+    eq = x*(x + 1)*a + x*b + c/x
+    assert eq.as_coefficients_dict(x) == {x: b, 1/x: c,
+        x*(x + 1): a}
+    assert eq.expand().as_coefficients_dict(x) == {x**2: a, x: a + b, 1/x: c}
+    assert x.as_coefficients_dict() == {x: S.One}
+
+
+def test_args_cnc():
+    A = symbols('A', commutative=False)
+    assert (x + A).args_cnc() == \
+        [[], [x + A]]
+    assert (x + a).args_cnc() == \
+        [[a + x], []]
+    assert (x*a).args_cnc() == \
+        [[a, x], []]
+    assert (x*y*A*(A + 1)).args_cnc(cset=True) == \
+        [{x, y}, [A, 1 + A]]
+    assert Mul(x, x, evaluate=False).args_cnc(cset=True, warn=False) == \
+        [{x}, []]
+    assert Mul(x, x**2, evaluate=False).args_cnc(cset=True, warn=False) == \
+        [{x, x**2}, []]
+    raises(ValueError, lambda: Mul(x, x, evaluate=False).args_cnc(cset=True))
+    assert Mul(x, y, x, evaluate=False).args_cnc() == \
+        [[x, y, x], []]
+    # always split -1 from leading number
+    assert (-1.*x).args_cnc() == [[-1, 1.0, x], []]
+
+
+def test_new_rawargs():
+    n = Symbol('n', commutative=False)
+    a = x + n
+    assert a.is_commutative is False
+    assert a._new_rawargs(x).is_commutative
+    assert a._new_rawargs(x, y).is_commutative
+    assert a._new_rawargs(x, n).is_commutative is False
+    assert a._new_rawargs(x, y, n).is_commutative is False
+    m = x*n
+    assert m.is_commutative is False
+    assert m._new_rawargs(x).is_commutative
+    assert m._new_rawargs(n).is_commutative is False
+    assert m._new_rawargs(x, y).is_commutative
+    assert m._new_rawargs(x, n).is_commutative is False
+    assert m._new_rawargs(x, y, n).is_commutative is False
+
+    assert m._new_rawargs(x, n, reeval=False).is_commutative is False
+    assert m._new_rawargs(S.One) is S.One
+
+
+def test_issue_5226():
+    assert Add(evaluate=False) == 0
+    assert Mul(evaluate=False) == 1
+    assert Mul(x + y, evaluate=False).is_Add
+
+
+def test_free_symbols():
+    # free_symbols should return the free symbols of an object
+    assert S.One.free_symbols == set()
+    assert x.free_symbols == {x}
+    assert Integral(x, (x, 1, y)).free_symbols == {y}
+    assert (-Integral(x, (x, 1, y))).free_symbols == {y}
+    assert meter.free_symbols == set()
+    assert (meter**x).free_symbols == {x}
+
+
+def test_has_free():
+    assert x.has_free(x)
+    assert not x.has_free(y)
+    assert (x + y).has_free(x)
+    assert (x + y).has_free(*(x, z))
+    assert f(x).has_free(x)
+    assert f(x).has_free(f(x))
+    assert Integral(f(x), (f(x), 1, y)).has_free(y)
+    assert not Integral(f(x), (f(x), 1, y)).has_free(x)
+    assert not Integral(f(x), (f(x), 1, y)).has_free(f(x))
+    # simple extraction
+    assert (x + 1 + y).has_free(x + 1)
+    assert not (x + 2 + y).has_free(x + 1)
+    assert (2 + 3*x*y).has_free(3*x)
+    raises(TypeError, lambda: x.has_free({x, y}))
+    s = FiniteSet(1, 2)
+    assert Piecewise((s, x > 3), (4, True)).has_free(s)
+    assert not Piecewise((1, x > 3), (4, True)).has_free(s)
+    # can't make set of these, but fallback will handle
+    raises(TypeError, lambda: x.has_free(y, []))
+
+
+def test_has_xfree():
+    assert (x + 1).has_xfree({x})
+    assert ((x + 1)**2).has_xfree({x + 1})
+    assert not (x + y + 1).has_xfree({x + 1})
+    raises(TypeError, lambda: x.has_xfree(x))
+    raises(TypeError, lambda: x.has_xfree([x]))
+
+
+def test_issue_5300():
+    x = Symbol('x', commutative=False)
+    assert x*sqrt(2)/sqrt(6) == x*sqrt(3)/3
+
+
+def test_floordiv():
+    from sympy.functions.elementary.integers import floor
+    assert x // y == floor(x / y)
+
+
+def test_as_coeff_Mul():
+    assert Integer(3).as_coeff_Mul() == (Integer(3), Integer(1))
+    assert Rational(3, 4).as_coeff_Mul() == (Rational(3, 4), Integer(1))
+    assert Float(5.0).as_coeff_Mul() == (Float(5.0), Integer(1))
+    assert Float(0.0).as_coeff_Mul() == (Float(0.0), Integer(1))
+
+    assert (Integer(3)*x).as_coeff_Mul() == (Integer(3), x)
+    assert (Rational(3, 4)*x).as_coeff_Mul() == (Rational(3, 4), x)
+    assert (Float(5.0)*x).as_coeff_Mul() == (Float(5.0), x)
+
+    assert (Integer(3)*x*y).as_coeff_Mul() == (Integer(3), x*y)
+    assert (Rational(3, 4)*x*y).as_coeff_Mul() == (Rational(3, 4), x*y)
+    assert (Float(5.0)*x*y).as_coeff_Mul() == (Float(5.0), x*y)
+
+    assert (x).as_coeff_Mul() == (S.One, x)
+    assert (x*y).as_coeff_Mul() == (S.One, x*y)
+    assert (-oo*x).as_coeff_Mul(rational=True) == (-1, oo*x)
+
+
+def test_as_coeff_Add():
+    assert Integer(3).as_coeff_Add() == (Integer(3), Integer(0))
+    assert Rational(3, 4).as_coeff_Add() == (Rational(3, 4), Integer(0))
+    assert Float(5.0).as_coeff_Add() == (Float(5.0), Integer(0))
+
+    assert (Integer(3) + x).as_coeff_Add() == (Integer(3), x)
+    assert (Rational(3, 4) + x).as_coeff_Add() == (Rational(3, 4), x)
+    assert (Float(5.0) + x).as_coeff_Add() == (Float(5.0), x)
+    assert (Float(5.0) + x).as_coeff_Add(rational=True) == (0, Float(5.0) + x)
+
+    assert (Integer(3) + x + y).as_coeff_Add() == (Integer(3), x + y)
+    assert (Rational(3, 4) + x + y).as_coeff_Add() == (Rational(3, 4), x + y)
+    assert (Float(5.0) + x + y).as_coeff_Add() == (Float(5.0), x + y)
+
+    assert (x).as_coeff_Add() == (S.Zero, x)
+    assert (x*y).as_coeff_Add() == (S.Zero, x*y)
+
+
+def test_expr_sorting():
+
+    exprs = [1/x**2, 1/x, sqrt(sqrt(x)), sqrt(x), x, sqrt(x)**3, x**2]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [x, 2*x, 2*x**2, 2*x**3, x**n, 2*x**n, sin(x), sin(x)**n,
+             sin(x**2), cos(x), cos(x**2), tan(x)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [x + 1, x**2 + x + 1, x**3 + x**2 + x + 1]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [S(4), x - 3*I/2, x + 3*I/2, x - 4*I + 1, x + 4*I + 1]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [f(x), g(x), exp(x), sin(x), cos(x), factorial(x)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [Tuple(x, y), Tuple(x, z), Tuple(x, y, z)]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[3], [1, 2]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[1, 2], [2, 3]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [[1, 2], [1, 2, 3]]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [{x: -y}, {x: y}]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    exprs = [{1}, {1, 2}]
+    assert sorted(exprs, key=default_sort_key) == exprs
+
+    a, b = exprs = [Dummy('x'), Dummy('x')]
+    assert sorted([b, a], key=default_sort_key) == exprs
+
+
+def test_as_ordered_factors():
+
+    assert x.as_ordered_factors() == [x]
+    assert (2*x*x**n*sin(x)*cos(x)).as_ordered_factors() \
+        == [Integer(2), x, x**n, sin(x), cos(x)]
+
+    args = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    expr = Mul(*args)
+
+    assert expr.as_ordered_factors() == args
+
+    A, B = symbols('A,B', commutative=False)
+
+    assert (A*B).as_ordered_factors() == [A, B]
+    assert (B*A).as_ordered_factors() == [B, A]
+
+
+def test_as_ordered_terms():
+
+    assert x.as_ordered_terms() == [x]
+    assert (sin(x)**2*cos(x) + sin(x)*cos(x)**2 + 1).as_ordered_terms() \
+        == [sin(x)**2*cos(x), sin(x)*cos(x)**2, 1]
+
+    args = [f(1), f(2), f(3), f(1, 2, 3), g(1), g(2), g(3), g(1, 2, 3)]
+    expr = Add(*args)
+
+    assert expr.as_ordered_terms() == args
+
+    assert (1 + 4*sqrt(3)*pi*x).as_ordered_terms() == [4*pi*x*sqrt(3), 1]
+
+    assert ( 2 + 3*I).as_ordered_terms() == [2, 3*I]
+    assert (-2 + 3*I).as_ordered_terms() == [-2, 3*I]
+    assert ( 2 - 3*I).as_ordered_terms() == [2, -3*I]
+    assert (-2 - 3*I).as_ordered_terms() == [-2, -3*I]
+
+    assert ( 4 + 3*I).as_ordered_terms() == [4, 3*I]
+    assert (-4 + 3*I).as_ordered_terms() == [-4, 3*I]
+    assert ( 4 - 3*I).as_ordered_terms() == [4, -3*I]
+    assert (-4 - 3*I).as_ordered_terms() == [-4, -3*I]
+
+    e = x**2*y**2 + x*y**4 + y + 2
+
+    assert e.as_ordered_terms(order="lex") == [x**2*y**2, x*y**4, y, 2]
+    assert e.as_ordered_terms(order="grlex") == [x*y**4, x**2*y**2, y, 2]
+    assert e.as_ordered_terms(order="rev-lex") == [2, y, x*y**4, x**2*y**2]
+    assert e.as_ordered_terms(order="rev-grlex") == [2, y, x**2*y**2, x*y**4]
+
+    k = symbols('k')
+    assert k.as_ordered_terms(data=True) == ([(k, ((1.0, 0.0), (1,), ()))], [k])
+
+
+def test_sort_key_atomic_expr():
+    from sympy.physics.units import m, s
+    assert sorted([-m, s], key=lambda arg: arg.sort_key()) == [-m, s]
+
+
+def test_eval_interval():
+    assert exp(x)._eval_interval(*Tuple(x, 0, 1)) == exp(1) - exp(0)
+
+    # issue 4199
+    a = x/y
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.Zero, oo)._eval_interval(y, oo, S.Zero))
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.Zero, oo)._eval_interval(y, S.Zero, oo))
+    a = x - y
+    raises(NotImplementedError, lambda: a._eval_interval(x, S.One, oo)._eval_interval(y, oo, S.One))
+    raises(ValueError, lambda: x._eval_interval(x, None, None))
+    a = -y*Heaviside(x - y)
+    assert a._eval_interval(x, -oo, oo) == -y
+    assert a._eval_interval(x, oo, -oo) == y
+
+
+def test_eval_interval_zoo():
+    # Test that limit is used when zoo is returned
+    assert Si(1/x)._eval_interval(x, S.Zero, S.One) == -pi/2 + Si(1)
+
+
+def test_primitive():
+    assert (3*(x + 1)**2).primitive() == (3, (x + 1)**2)
+    assert (6*x + 2).primitive() == (2, 3*x + 1)
+    assert (x/2 + 3).primitive() == (S.Half, x + 6)
+    eq = (6*x + 2)*(x/2 + 3)
+    assert eq.primitive()[0] == 1
+    eq = (2 + 2*x)**2
+    assert eq.primitive()[0] == 1
+    assert (4.0*x).primitive() == (1, 4.0*x)
+    assert (4.0*x + y/2).primitive() == (S.Half, 8.0*x + y)
+    assert (-2*x).primitive() == (2, -x)
+    assert Add(5*z/7, 0.5*x, 3*y/2, evaluate=False).primitive() == \
+        (S.One/14, 7.0*x + 21*y + 10*z)
+    for i in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+        assert (i + x/3).primitive() == \
+            (S.One/3, i + x)
+    assert (S.Infinity + 2*x/3 + 4*y/7).primitive() == \
+        (S.One/21, 14*x + 12*y + oo)
+    assert S.Zero.primitive() == (S.One, S.Zero)
+
+
+def test_issue_5843():
+    a = 1 + x
+    assert (2*a).extract_multiplicatively(a) == 2
+    assert (4*a).extract_multiplicatively(2*a) == 2
+    assert ((3*a)*(2*a)).extract_multiplicatively(a) == 6*a
+
+
+def test_is_constant():
+    from sympy.solvers.solvers import checksol
+    assert Sum(x, (x, 1, 10)).is_constant() is True
+    assert Sum(x, (x, 1, n)).is_constant() is False
+    assert Sum(x, (x, 1, n)).is_constant(y) is True
+    assert Sum(x, (x, 1, n)).is_constant(n) is False
+    assert Sum(x, (x, 1, n)).is_constant(x) is True
+    eq = a*cos(x)**2 + a*sin(x)**2 - a
+    assert eq.is_constant() is True
+    assert eq.subs({x: pi, a: 2}) == eq.subs({x: pi, a: 3}) == 0
+    assert x.is_constant() is False
+    assert x.is_constant(y) is True
+    assert log(x/y).is_constant() is False
+
+    assert checksol(x, x, Sum(x, (x, 1, n))) is False
+    assert checksol(x, x, Sum(x, (x, 1, n))) is False
+    assert f(1).is_constant
+    assert checksol(x, x, f(x)) is False
+
+    assert Pow(x, S.Zero, evaluate=False).is_constant() is True  # == 1
+    assert Pow(S.Zero, x, evaluate=False).is_constant() is False  # == 0 or 1
+    assert (2**x).is_constant() is False
+    assert Pow(S(2), S(3), evaluate=False).is_constant() is True
+
+    z1, z2 = symbols('z1 z2', zero=True)
+    assert (z1 + 2*z2).is_constant() is True
+
+    assert meter.is_constant() is True
+    assert (3*meter).is_constant() is True
+    assert (x*meter).is_constant() is False
+
+
+def test_equals():
+    assert (-3 - sqrt(5) + (-sqrt(10)/2 - sqrt(2)/2)**2).equals(0)
+    assert (x**2 - 1).equals((x + 1)*(x - 1))
+    assert (cos(x)**2 + sin(x)**2).equals(1)
+    assert (a*cos(x)**2 + a*sin(x)**2).equals(a)
+    r = sqrt(2)
+    assert (-1/(r + r*x) + 1/r/(1 + x)).equals(0)
+    assert factorial(x + 1).equals((x + 1)*factorial(x))
+    assert sqrt(3).equals(2*sqrt(3)) is False
+    assert (sqrt(5)*sqrt(3)).equals(sqrt(3)) is False
+    assert (sqrt(5) + sqrt(3)).equals(0) is False
+    assert (sqrt(5) + pi).equals(0) is False
+    assert meter.equals(0) is False
+    assert (3*meter**2).equals(0) is False
+    eq = -(-1)**(S(3)/4)*6**(S.One/4) + (-6)**(S.One/4)*I
+    if eq != 0:  # if canonicalization makes this zero, skip the test
+        assert eq.equals(0)
+    assert sqrt(x).equals(0) is False
+
+    # from integrate(x*sqrt(1 + 2*x), x);
+    # diff is zero only when assumptions allow
+    i = 2*sqrt(2)*x**(S(5)/2)*(1 + 1/(2*x))**(S(5)/2)/5 + \
+        2*sqrt(2)*x**(S(3)/2)*(1 + 1/(2*x))**(S(5)/2)/(-6 - 3/x)
+    ans = sqrt(2*x + 1)*(6*x**2 + x - 1)/15
+    diff = i - ans
+    assert diff.equals(0) is None  # should be False, but previously this was False due to wrong intermediate result
+    assert diff.subs(x, Rational(-1, 2)/2) == 7*sqrt(2)/120
+    # there are regions for x for which the expression is True, for
+    # example, when x < -1/2 or x > 0 the expression is zero
+    p = Symbol('p', positive=True)
+    assert diff.subs(x, p).equals(0) is True
+    assert diff.subs(x, -1).equals(0) is True
+
+    # prove via minimal_polynomial or self-consistency
+    eq = sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) - sqrt(10 + 6*sqrt(3))
+    assert eq.equals(0)
+    q = 3**Rational(1, 3) + 3
+    p = expand(q**3)**Rational(1, 3)
+    assert (p - q).equals(0)
+
+    # issue 6829
+    # eq = q*x + q/4 + x**4 + x**3 + 2*x**2 - S.One/3
+    # z = eq.subs(x, solve(eq, x)[0])
+    q = symbols('q')
+    z = (q*(-sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12)/2 - sqrt((2*q - S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/6)/2 - S.One/4) + q/4 + (-sqrt(-2*(-(q
+    - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q
+    - S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**4 + (-sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q -
+    S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**3 + 2*(-sqrt(-2*(-(q - S(7)/8)**S(2)/8 -
+    S(2197)/13824)**(S.One/3) - S(13)/12)/2 - sqrt((2*q -
+    S(7)/4)/sqrt(-2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/12) + 2*(-(q - S(7)/8)**S(2)/8 - S(2197)/13824)**(S.One/3) -
+    S(13)/6)/2 - S.One/4)**2 - Rational(1, 3))
+    assert z.equals(0)
+
+
+def test_random():
+    from sympy.functions.combinatorial.numbers import lucas
+    from sympy.simplify.simplify import posify
+    assert posify(x)[0]._random() is not None
+    assert lucas(n)._random(2, -2, 0, -1, 1) is None
+
+    # issue 8662
+    assert Piecewise((Max(x, y), z))._random() is None
+
+
+def test_round():
+    assert str(Float('0.1249999').round(2)) == '0.12'
+    d20 = 12345678901234567890
+    ans = S(d20).round(2)
+    assert ans.is_Integer and ans == d20
+    ans = S(d20).round(-2)
+    assert ans.is_Integer and ans == 12345678901234567900
+    assert str(S('1/7').round(4)) == '0.1429'
+    assert str(S('.[12345]').round(4)) == '0.1235'
+    assert str(S('.1349').round(2)) == '0.13'
+    n = S(12345)
+    ans = n.round()
+    assert ans.is_Integer
+    assert ans == n
+    ans = n.round(1)
+    assert ans.is_Integer
+    assert ans == n
+    ans = n.round(4)
+    assert ans.is_Integer
+    assert ans == n
+    assert n.round(-1) == 12340
+
+    r = Float(str(n)).round(-4)
+    assert r == 10000.0
+
+    assert n.round(-5) == 0
+
+    assert str((pi + sqrt(2)).round(2)) == '4.56'
+    assert (10*(pi + sqrt(2))).round(-1) == 50.0
+    raises(TypeError, lambda: round(x + 2, 2))
+    assert str(S(2.3).round(1)) == '2.3'
+    # rounding in SymPy (as in Decimal) should be
+    # exact for the given precision; we check here
+    # that when a 5 follows the last digit that
+    # the rounded digit will be even.
+    for i in range(-99, 100):
+        # construct a decimal that ends in 5, e.g. 123 -> 0.1235
+        s = str(abs(i))
+        p = len(s)  # we are going to round to the last digit of i
+        n = '0.%s5' % s  # put a 5 after i's digits
+        j = p + 2  # 2 for '0.'
+        if i < 0:  # 1 for '-'
+            j += 1
+            n = '-' + n
+        v = str(Float(n).round(p))[:j]  # pertinent digits
+        if v.endswith('.'):
+            continue  # it ends with 0 which is even
+        L = int(v[-1])  # last digit
+        assert L % 2 == 0, (n, '->', v)
+
+    assert (Float(.3, 3) + 2*pi).round() == 7
+    assert (Float(.3, 3) + 2*pi*100).round() == 629
+    assert (pi + 2*E*I).round() == 3 + 5*I
+    # don't let request for extra precision give more than
+    # what is known (in this case, only 3 digits)
+    assert str((Float(.03, 3) + 2*pi/100).round(5)) == '0.0928'
+    assert str((Float(.03, 3) + 2*pi/100).round(4)) == '0.0928'
+
+    assert S.Zero.round() == 0
+
+    a = (Add(1, Float('1.' + '9'*27, ''), evaluate=False))
+    assert a.round(10) == Float('3.000000000000000000000000000', '')
+    assert a.round(25) == Float('3.000000000000000000000000000', '')
+    assert a.round(26) == Float('3.000000000000000000000000000', '')
+    assert a.round(27) == Float('2.999999999999999999999999999', '')
+    assert a.round(30) == Float('2.999999999999999999999999999', '')
+    #assert a.round(10) == Float('3.0000000000', '')
+    #assert a.round(25) == Float('3.0000000000000000000000000', '')
+    #assert a.round(26) == Float('3.00000000000000000000000000', '')
+    #assert a.round(27) == Float('2.999999999999999999999999999', '')
+    #assert a.round(30) == Float('2.999999999999999999999999999', '')
+
+    # XXX: Should round set the precision of the result?
+    #      The previous version of the tests above is this but they only pass
+    #      because Floats with unequal precision compare equal:
+    #
+    # assert a.round(10) == Float('3.0000000000', '')
+    # assert a.round(25) == Float('3.0000000000000000000000000', '')
+    # assert a.round(26) == Float('3.00000000000000000000000000', '')
+    # assert a.round(27) == Float('2.999999999999999999999999999', '')
+    # assert a.round(30) == Float('2.999999999999999999999999999', '')
+
+    raises(TypeError, lambda: x.round())
+    raises(TypeError, lambda: f(1).round())
+
+    # exact magnitude of 10
+    assert str(S.One.round()) == '1'
+    assert str(S(100).round()) == '100'
+
+    # applied to real and imaginary portions
+    assert (2*pi + E*I).round() == 6 + 3*I
+    assert (2*pi + I/10).round() == 6
+    assert (pi/10 + 2*I).round() == 2*I
+    # the lhs re and im parts are Float with dps of 2
+    # and those on the right have dps of 15 so they won't compare
+    # equal unless we use string or compare components (which will
+    # then coerce the floats to the same precision) or re-create
+    # the floats
+    assert str((pi/10 + E*I).round(2)) == '0.31 + 2.72*I'
+    assert str((pi/10 + E*I).round(2).as_real_imag()) == '(0.31, 2.72)'
+    assert str((pi/10 + E*I).round(2)) == '0.31 + 2.72*I'
+
+    # issue 6914
+    assert (I**(I + 3)).round(3) == Float('-0.208', '')*I
+
+    # issue 8720
+    assert S(-123.6).round() == -124
+    assert S(-1.5).round() == -2
+    assert S(-100.5).round() == -100
+    assert S(-1.5 - 10.5*I).round() == -2 - 10*I
+
+    # issue 7961
+    assert str(S(0.006).round(2)) == '0.01'
+    assert str(S(0.00106).round(4)) == '0.0011'
+
+    # issue 8147
+    assert S.NaN.round() is S.NaN
+    assert S.Infinity.round() is S.Infinity
+    assert S.NegativeInfinity.round() is S.NegativeInfinity
+    assert S.ComplexInfinity.round() is S.ComplexInfinity
+
+    # check that types match
+    for i in range(2):
+        fi = float(i)
+        # 2 args
+        assert all(type(round(i, p)) is int for p in (-1, 0, 1))
+        assert all(S(i).round(p).is_Integer for p in (-1, 0, 1))
+        assert all(type(round(fi, p)) is float for p in (-1, 0, 1))
+        assert all(S(fi).round(p).is_Float for p in (-1, 0, 1))
+        # 1 arg (p is None)
+        assert type(round(i)) is int
+        assert S(i).round().is_Integer
+        assert type(round(fi)) is int
+        assert S(fi).round().is_Integer
+
+        # issue 25698
+        n = 6000002
+        assert int(n*(log(n) + log(log(n)))) == 110130079
+        one = cos(2)**2 + sin(2)**2
+        eq = exp(one*I*pi)
+        qr, qi = eq.as_real_imag()
+        assert qi.round(2) == 0.0
+        assert eq.round(2) == -1.0
+        eq = one - 1/S(10**120)
+        assert S.true not in (eq > 1, eq < 1)
+        assert int(eq) == int(.9) == 0
+        assert int(-eq) == int(-.9) == 0
+
+
+def test_held_expression_UnevaluatedExpr():
+    x = symbols("x")
+    he = UnevaluatedExpr(1/x)
+    e1 = x*he
+
+    assert isinstance(e1, Mul)
+    assert e1.args == (x, he)
+    assert e1.doit() == 1
+    assert UnevaluatedExpr(Derivative(x, x)).doit(deep=False
+        ) == Derivative(x, x)
+    assert UnevaluatedExpr(Derivative(x, x)).doit() == 1
+
+    xx = Mul(x, x, evaluate=False)
+    assert xx != x**2
+
+    ue2 = UnevaluatedExpr(xx)
+    assert isinstance(ue2, UnevaluatedExpr)
+    assert ue2.args == (xx,)
+    assert ue2.doit() == x**2
+    assert ue2.doit(deep=False) == xx
+
+    x2 = UnevaluatedExpr(2)*2
+    assert type(x2) is Mul
+    assert x2.args == (2, UnevaluatedExpr(2))
+
+def test_round_exception_nostr():
+    # Don't use the string form of the expression in the round exception, as
+    # it's too slow
+    s = Symbol('bad')
+    try:
+        s.round()
+    except TypeError as e:
+        assert 'bad' not in str(e)
+    else:
+        # Did not raise
+        raise AssertionError("Did not raise")
+
+
+def test_extract_branch_factor():
+    assert exp_polar(2.0*I*pi).extract_branch_factor() == (1, 1)
+
+
+def test_identity_removal():
+    assert Add.make_args(x + 0) == (x,)
+    assert Mul.make_args(x*1) == (x,)
+
+
+def test_float_0():
+    assert Float(0.0) + 1 == Float(1.0)
+
+
+@XFAIL
+def test_float_0_fail():
+    assert Float(0.0)*x == Float(0.0)
+    assert (x + Float(0.0)).is_Add
+
+
+def test_issue_6325():
+    ans = (b**2 + z**2 - (b*(a + b*t) + z*(c + t*z))**2/(
+        (a + b*t)**2 + (c + t*z)**2))/sqrt((a + b*t)**2 + (c + t*z)**2)
+    e = sqrt((a + b*t)**2 + (c + z*t)**2)
+    assert diff(e, t, 2) == ans
+    assert e.diff(t, 2) == ans
+    assert diff(e, t, 2, simplify=False) != ans
+
+
+def test_issue_7426():
+    f1 = a % c
+    f2 = x % z
+    assert f1.equals(f2) is None
+
+
+def test_issue_11122():
+    x = Symbol('x', extended_positive=False)
+    assert unchanged(Gt, x, 0)  # (x > 0)
+    # (x > 0) should remain unevaluated after PR #16956
+
+    x = Symbol('x', positive=False, real=True)
+    assert (x > 0) is S.false
+
+
+def test_issue_10651():
+    x = Symbol('x', real=True)
+    e1 = (-1 + x)/(1 - x)
+    e3 = (4*x**2 - 4)/((1 - x)*(1 + x))
+    e4 = 1/(cos(x)**2) - (tan(x))**2
+    x = Symbol('x', positive=True)
+    e5 = (1 + x)/x
+    assert e1.is_constant() is None
+    assert e3.is_constant() is None
+    assert e4.is_constant() is None
+    assert e5.is_constant() is False
+
+
+def test_issue_10161():
+    x = symbols('x', real=True)
+    assert x*abs(x)*abs(x) == x**3
+
+
+def test_issue_10755():
+    x = symbols('x')
+    raises(TypeError, lambda: int(log(x)))
+    raises(TypeError, lambda: log(x).round(2))
+
+
+def test_issue_11877():
+    x = symbols('x')
+    assert integrate(log(S.Half - x), (x, 0, S.Half)) == Rational(-1, 2) -log(2)/2
+
+
+def test_normal():
+    x = symbols('x')
+    e = Mul(S.Half, 1 + x, evaluate=False)
+    assert e.normal() == e
+
+
+def test_expr():
+    x = symbols('x')
+    raises(TypeError, lambda: tan(x).series(x, 2, oo, "+"))
+
+
+def test_ExprBuilder():
+    eb = ExprBuilder(Mul)
+    eb.args.extend([x, x])
+    assert eb.build() == x**2
+
+
+def test_issue_22020():
+    from sympy.parsing.sympy_parser import parse_expr
+    x = parse_expr("log((2*V/3-V)/C)/-(R+r)*C")
+    y = parse_expr("log((2*V/3-V)/C)/-(R+r)*2")
+    assert x.equals(y) is False
+
+
+def test_non_string_equality():
+    # Expressions should not compare equal to strings
+    x = symbols('x')
+    one = sympify(1)
+    assert (x == 'x') is False
+    assert (x != 'x') is True
+    assert (one == '1') is False
+    assert (one != '1') is True
+    assert (x + 1 == 'x + 1') is False
+    assert (x + 1 != 'x + 1') is True
+
+    # Make sure == doesn't try to convert the resulting expression to a string
+    # (e.g., by calling sympify() instead of _sympify())
+
+    class BadRepr:
+        def __repr__(self):
+            raise RuntimeError
+
+    assert (x == BadRepr()) is False
+    assert (x != BadRepr()) is True
+
+
+def test_21494():
+    from sympy.testing.pytest import warns_deprecated_sympy
+
+    with warns_deprecated_sympy():
+        assert x.expr_free_symbols == {x}
+
+    with warns_deprecated_sympy():
+        assert Basic().expr_free_symbols == set()
+
+    with warns_deprecated_sympy():
+        assert S(2).expr_free_symbols == {S(2)}
+
+    with warns_deprecated_sympy():
+        assert Indexed("A", x).expr_free_symbols == {Indexed("A", x)}
+
+    with warns_deprecated_sympy():
+        assert Subs(x, x, 0).expr_free_symbols == set()
+
+
+def test_Expr__eq__iterable_handling():
+    assert x != range(3)
+
+
+def test_format():
+    assert '{:1.2f}'.format(S.Zero) == '0.00'
+    assert '{:+3.0f}'.format(S(3)) == ' +3'
+    assert '{:23.20f}'.format(pi) == ' 3.14159265358979323846'
+    assert '{:50.48f}'.format(exp(sin(1))) == '2.319776824715853173956590377503266813254904772376'
+
+
+def test_issue_24045():
+    assert powsimp(exp(a)/((c*a - c*b)*(Float(1.0)*c*a - Float(1.0)*c*b)))  # doesn't raise
+
+
+def test__unevaluated_Mul():
+    A, B = symbols('A B', commutative=False)
+    assert _unevaluated_Mul(x, A, B, S(2), A).args == (2, x, A, B, A)
+    assert _unevaluated_Mul(-x*A*B, S(2), A).args == (-2, x, A, B, A)
+
+
+def test_Float_zero_division_error():
+    # issue 27165
+    assert Float('1.7567e-1417').round(15) == Float(0)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_exprtools.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_exprtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..b550db1606866fb76442980ea2139aaf61219525
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_exprtools.py
@@ -0,0 +1,493 @@
+"""Tests for tools for manipulating of large commutative expressions. """
+
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (I, Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (root, sqrt)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O
+from sympy.sets.sets import Interval
+from sympy.simplify.radsimp import collect
+from sympy.simplify.simplify import simplify
+from sympy.core.exprtools import (decompose_power, Factors, Term, _gcd_terms,
+                                  gcd_terms, factor_terms, factor_nc, _mask_nc,
+                                  _monotonic_sign)
+from sympy.core.mul import _keep_coeff as _keep_coeff
+from sympy.simplify.cse_opts import sub_pre
+from sympy.testing.pytest import raises
+
+from sympy.abc import a, b, t, x, y, z
+
+
+def test_decompose_power():
+    assert decompose_power(x) == (x, 1)
+    assert decompose_power(x**2) == (x, 2)
+    assert decompose_power(x**(2*y)) == (x**y, 2)
+    assert decompose_power(x**(2*y/3)) == (x**(y/3), 2)
+    assert decompose_power(x**(y*Rational(2, 3))) == (x**(y/3), 2)
+
+
+def test_Factors():
+    assert Factors() == Factors({}) == Factors(S.One)
+    assert Factors().as_expr() is S.One
+    assert Factors({x: 2, y: 3, sin(x): 4}).as_expr() == x**2*y**3*sin(x)**4
+    assert Factors(S.Infinity) == Factors({oo: 1})
+    assert Factors(S.NegativeInfinity) == Factors({oo: 1, -1: 1})
+    # issue #18059:
+    assert Factors((x**2)**S.Half).as_expr() == (x**2)**S.Half
+
+    a = Factors({x: 5, y: 3, z: 7})
+    b = Factors({      y: 4, z: 3, t: 10})
+
+    assert a.mul(b) == a*b == Factors({x: 5, y: 7, z: 10, t: 10})
+
+    assert a.div(b) == divmod(a, b) == \
+        (Factors({x: 5, z: 4}), Factors({y: 1, t: 10}))
+    assert a.quo(b) == a/b == Factors({x: 5, z: 4})
+    assert a.rem(b) == a % b == Factors({y: 1, t: 10})
+
+    assert a.pow(3) == a**3 == Factors({x: 15, y: 9, z: 21})
+    assert b.pow(3) == b**3 == Factors({y: 12, z: 9, t: 30})
+
+    assert a.gcd(b) == Factors({y: 3, z: 3})
+    assert a.lcm(b) == Factors({x: 5, y: 4, z: 7, t: 10})
+
+    a = Factors({x: 4, y: 7, t: 7})
+    b = Factors({z: 1, t: 3})
+
+    assert a.normal(b) == (Factors({x: 4, y: 7, t: 4}), Factors({z: 1}))
+
+    assert Factors(sqrt(2)*x).as_expr() == sqrt(2)*x
+
+    assert Factors(-I)*I == Factors()
+    assert Factors({S.NegativeOne: S(3)})*Factors({S.NegativeOne: S.One, I: S(5)}) == \
+        Factors(I)
+    assert Factors(sqrt(I)*I) == Factors(I**(S(3)/2)) == Factors({I: S(3)/2})
+    assert Factors({I: S(3)/2}).as_expr() == I**(S(3)/2)
+
+    assert Factors(S(2)**x).div(S(3)**x) == \
+        (Factors({S(2): x}), Factors({S(3): x}))
+    assert Factors(2**(2*x + 2)).div(S(8)) == \
+        (Factors({S(2): 2*x + 2}), Factors({S(8): S.One}))
+
+    # coverage
+    # /!\ things break if this is not True
+    assert Factors({S.NegativeOne: Rational(3, 2)}) == Factors({I: S.One, S.NegativeOne: S.One})
+    assert Factors({I: S.One, S.NegativeOne: Rational(1, 3)}).as_expr() == I*(-1)**Rational(1, 3)
+
+    assert Factors(-1.) == Factors({S.NegativeOne: S.One, S(1.): 1})
+    assert Factors(-2.) == Factors({S.NegativeOne: S.One, S(2.): 1})
+    assert Factors((-2.)**x) == Factors({S(-2.): x})
+    assert Factors(S(-2)) == Factors({S.NegativeOne: S.One, S(2): 1})
+    assert Factors(S.Half) == Factors({S(2): -S.One})
+    assert Factors(Rational(3, 2)) == Factors({S(3): S.One, S(2): S.NegativeOne})
+    assert Factors({I: S.One}) == Factors(I)
+    assert Factors({-1.0: 2, I: 1}) == Factors({S(1.0): 1, I: 1})
+    assert Factors({S.NegativeOne: Rational(-3, 2)}).as_expr() == I
+    A = symbols('A', commutative=False)
+    assert Factors(2*A**2) == Factors({S(2): 1, A**2: 1})
+    assert Factors(I) == Factors({I: S.One})
+    assert Factors(x).normal(S(2)) == (Factors(x), Factors(S(2)))
+    assert Factors(x).normal(S.Zero) == (Factors(), Factors(S.Zero))
+    raises(ZeroDivisionError, lambda: Factors(x).div(S.Zero))
+    assert Factors(x).mul(S(2)) == Factors(2*x)
+    assert Factors(x).mul(S.Zero).is_zero
+    assert Factors(x).mul(1/x).is_one
+    assert Factors(x**sqrt(2)**3).as_expr() == x**(2*sqrt(2))
+    assert Factors(x)**Factors(S(2)) == Factors(x**2)
+    assert Factors(x).gcd(S.Zero) == Factors(x)
+    assert Factors(x).lcm(S.Zero).is_zero
+    assert Factors(S.Zero).div(x) == (Factors(S.Zero), Factors())
+    assert Factors(x).div(x) == (Factors(), Factors())
+    assert Factors({x: .2})/Factors({x: .2}) == Factors()
+    assert Factors(x) != Factors()
+    assert Factors(S.Zero).normal(x) == (Factors(S.Zero), Factors())
+    n, d = x**(2 + y), x**2
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors(x**y), Factors())
+    assert f.gcd(d) == Factors()
+    d = x**y
+    assert f.div(d) == f.normal(d) == (Factors(x**2), Factors())
+    assert f.gcd(d) == Factors(d)
+    n = d = 2**x
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors(), Factors())
+    assert f.gcd(d) == Factors(d)
+    n, d = 2**x, 2**y
+    f = Factors(n)
+    assert f.div(d) == f.normal(d) == (Factors({S(2): x}), Factors({S(2): y}))
+    assert f.gcd(d) == Factors()
+
+    # extraction of constant only
+    n = x**(x + 3)
+    assert Factors(n).normal(x**-3) == (Factors({x: x + 6}), Factors({}))
+    assert Factors(n).normal(x**3) == (Factors({x: x}), Factors({}))
+    assert Factors(n).normal(x**4) == (Factors({x: x}), Factors({x: 1}))
+    assert Factors(n).normal(x**(y - 3)) == \
+        (Factors({x: x + 6}), Factors({x: y}))
+    assert Factors(n).normal(x**(y + 3)) == (Factors({x: x}), Factors({x: y}))
+    assert Factors(n).normal(x**(y + 4)) == \
+        (Factors({x: x}), Factors({x: y + 1}))
+
+    assert Factors(n).div(x**-3) == (Factors({x: x + 6}), Factors({}))
+    assert Factors(n).div(x**3) == (Factors({x: x}), Factors({}))
+    assert Factors(n).div(x**4) == (Factors({x: x}), Factors({x: 1}))
+    assert Factors(n).div(x**(y - 3)) == \
+        (Factors({x: x + 6}), Factors({x: y}))
+    assert Factors(n).div(x**(y + 3)) == (Factors({x: x}), Factors({x: y}))
+    assert Factors(n).div(x**(y + 4)) == \
+        (Factors({x: x}), Factors({x: y + 1}))
+
+    assert Factors(3 * x / 2) == Factors({3: 1, 2: -1, x: 1})
+    assert Factors(x * x / y) == Factors({x: 2, y: -1})
+    assert Factors(27 * x / y**9) == Factors({27: 1, x: 1, y: -9})
+
+
+def test_Term():
+    a = Term(4*x*y**2/z/t**3)
+    b = Term(2*x**3*y**5/t**3)
+
+    assert a == Term(4, Factors({x: 1, y: 2}), Factors({z: 1, t: 3}))
+    assert b == Term(2, Factors({x: 3, y: 5}), Factors({t: 3}))
+
+    assert a.as_expr() == 4*x*y**2/z/t**3
+    assert b.as_expr() == 2*x**3*y**5/t**3
+
+    assert a.inv() == \
+        Term(S.One/4, Factors({z: 1, t: 3}), Factors({x: 1, y: 2}))
+    assert b.inv() == Term(S.Half, Factors({t: 3}), Factors({x: 3, y: 5}))
+
+    assert a.mul(b) == a*b == \
+        Term(8, Factors({x: 4, y: 7}), Factors({z: 1, t: 6}))
+    assert a.quo(b) == a/b == Term(2, Factors({}), Factors({x: 2, y: 3, z: 1}))
+
+    assert a.pow(3) == a**3 == \
+        Term(64, Factors({x: 3, y: 6}), Factors({z: 3, t: 9}))
+    assert b.pow(3) == b**3 == Term(8, Factors({x: 9, y: 15}), Factors({t: 9}))
+
+    assert a.pow(-3) == a**(-3) == \
+        Term(S.One/64, Factors({z: 3, t: 9}), Factors({x: 3, y: 6}))
+    assert b.pow(-3) == b**(-3) == \
+        Term(S.One/8, Factors({t: 9}), Factors({x: 9, y: 15}))
+
+    assert a.gcd(b) == Term(2, Factors({x: 1, y: 2}), Factors({t: 3}))
+    assert a.lcm(b) == Term(4, Factors({x: 3, y: 5}), Factors({z: 1, t: 3}))
+
+    a = Term(4*x*y**2/z/t**3)
+    b = Term(2*x**3*y**5*t**7)
+
+    assert a.mul(b) == Term(8, Factors({x: 4, y: 7, t: 4}), Factors({z: 1}))
+
+    assert Term((2*x + 2)**3) == Term(8, Factors({x + 1: 3}), Factors({}))
+    assert Term((2*x + 2)*(3*x + 6)**2) == \
+        Term(18, Factors({x + 1: 1, x + 2: 2}), Factors({}))
+
+
+def test_gcd_terms():
+    f = 2*(x + 1)*(x + 4)/(5*x**2 + 5) + (2*x + 2)*(x + 5)/(x**2 + 1)/5 + \
+        (2*x + 2)*(x + 6)/(5*x**2 + 5)
+
+    assert _gcd_terms(f) == ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1)
+    assert _gcd_terms(Add.make_args(f)) == \
+        ((Rational(6, 5))*((1 + x)/(1 + x**2)), 5 + x, 1)
+
+    newf = (Rational(6, 5))*((1 + x)*(5 + x)/(1 + x**2))
+    assert gcd_terms(f) == newf
+    args = Add.make_args(f)
+    # non-Basic sequences of terms treated as terms of Add
+    assert gcd_terms(list(args)) == newf
+    assert gcd_terms(tuple(args)) == newf
+    assert gcd_terms(set(args)) == newf
+    # but a Basic sequence is treated as a container
+    assert gcd_terms(Tuple(*args)) != newf
+    assert gcd_terms(Basic(Tuple(S(1), 3*y + 3*x*y), Tuple(S(1), S(3)))) == \
+        Basic(Tuple(S(1), 3*y*(x + 1)), Tuple(S(1), S(3)))
+    # but we shouldn't change keys of a dictionary or some may be lost
+    assert gcd_terms(Dict((x*(1 + y), S(2)), (x + x*y, y + x*y))) == \
+        Dict({x*(y + 1): S(2), x + x*y: y*(1 + x)})
+
+    assert gcd_terms((2*x + 2)**3 + (2*x + 2)**2) == 4*(x + 1)**2*(2*x + 3)
+
+    assert gcd_terms(0) == 0
+    assert gcd_terms(1) == 1
+    assert gcd_terms(x) == x
+    assert gcd_terms(2 + 2*x) == Mul(2, 1 + x, evaluate=False)
+    arg = x*(2*x + 4*y)
+    garg = 2*x*(x + 2*y)
+    assert gcd_terms(arg) == garg
+    assert gcd_terms(sin(arg)) == sin(garg)
+
+    # issue 6139-like
+    alpha, alpha1, alpha2, alpha3 = symbols('alpha:4')
+    a = alpha**2 - alpha*x**2 + alpha + x**3 - x*(alpha + 1)
+    rep = (alpha, (1 + sqrt(5))/2 + alpha1*x + alpha2*x**2 + alpha3*x**3)
+    s = (a/(x - alpha)).subs(*rep).series(x, 0, 1)
+    assert simplify(collect(s, x)) == -sqrt(5)/2 - Rational(3, 2) + O(x)
+
+    # issue 5917
+    assert _gcd_terms([S.Zero, S.Zero]) == (0, 0, 1)
+    assert _gcd_terms([2*x + 4]) == (2, x + 2, 1)
+
+    eq = x/(x + 1/x)
+    assert gcd_terms(eq, fraction=False) == eq
+    eq = x/2/y + 1/x/y
+    assert gcd_terms(eq, fraction=True, clear=True) == \
+        (x**2 + 2)/(2*x*y)
+    assert gcd_terms(eq, fraction=True, clear=False) == \
+        (x**2/2 + 1)/(x*y)
+    assert gcd_terms(eq, fraction=False, clear=True) == \
+        (x + 2/x)/(2*y)
+    assert gcd_terms(eq, fraction=False, clear=False) == \
+        (x/2 + 1/x)/y
+
+
+def test_factor_terms():
+    A = Symbol('A', commutative=False)
+    assert factor_terms(9*(x + x*y + 1) + (3*x + 3)**(2 + 2*x)) == \
+        9*x*y + 9*x + _keep_coeff(S(3), x + 1)**_keep_coeff(S(2), x + 1) + 9
+    assert factor_terms(9*(x + x*y + 1) + (3)**(2 + 2*x)) == \
+        _keep_coeff(S(9), 3**(2*x) + x*y + x + 1)
+    assert factor_terms(3**(2 + 2*x) + a*3**(2 + 2*x)) == \
+        9*3**(2*x)*(a + 1)
+    assert factor_terms(x + x*A) == \
+        x*(1 + A)
+    assert factor_terms(sin(x + x*A)) == \
+        sin(x*(1 + A))
+    assert factor_terms((3*x + 3)**((2 + 2*x)/3)) == \
+        _keep_coeff(S(3), x + 1)**_keep_coeff(Rational(2, 3), x + 1)
+    assert factor_terms(x + (x*y + x)**(3*x + 3)) == \
+        x + (x*(y + 1))**_keep_coeff(S(3), x + 1)
+    assert factor_terms(a*(x + x*y) + b*(x*2 + y*x*2)) == \
+        x*(a + 2*b)*(y + 1)
+    i = Integral(x, (x, 0, oo))
+    assert factor_terms(i) == i
+
+    assert factor_terms(x/2 + y) == x/2 + y
+    # fraction doesn't apply to integer denominators
+    assert factor_terms(x/2 + y, fraction=True) == x/2 + y
+    # clear *does* apply to the integer denominators
+    assert factor_terms(x/2 + y, clear=True) == Mul(S.Half, x + 2*y, evaluate=False)
+
+    # check radical extraction
+    eq = sqrt(2) + sqrt(10)
+    assert factor_terms(eq) == eq
+    assert factor_terms(eq, radical=True) == sqrt(2)*(1 + sqrt(5))
+    eq = root(-6, 3) + root(6, 3)
+    assert factor_terms(eq, radical=True) == 6**(S.One/3)*(1 + (-1)**(S.One/3))
+
+    eq = [x + x*y]
+    ans = [x*(y + 1)]
+    for c in [list, tuple, set]:
+        assert factor_terms(c(eq)) == c(ans)
+    assert factor_terms(Tuple(x + x*y)) == Tuple(x*(y + 1))
+    assert factor_terms(Interval(0, 1)) == Interval(0, 1)
+    e = 1/sqrt(a/2 + 1)
+    assert factor_terms(e, clear=False) == 1/sqrt(a/2 + 1)
+    assert factor_terms(e, clear=True) == sqrt(2)/sqrt(a + 2)
+
+    eq = x/(x + 1/x) + 1/(x**2 + 1)
+    assert factor_terms(eq, fraction=False) == eq
+    assert factor_terms(eq, fraction=True) == 1
+
+    assert factor_terms((1/(x**3 + x**2) + 2/x**2)*y) == \
+        y*(2 + 1/(x + 1))/x**2
+
+    # if not True, then processesing for this in factor_terms is not necessary
+    assert gcd_terms(-x - y) == -x - y
+    assert factor_terms(-x - y) == Mul(-1, x + y, evaluate=False)
+
+    # if not True, then "special" processesing in factor_terms is not necessary
+    assert gcd_terms(exp(Mul(-1, x + 1))) == exp(-x - 1)
+    e = exp(-x - 2) + x
+    assert factor_terms(e) == exp(Mul(-1, x + 2, evaluate=False)) + x
+    assert factor_terms(e, sign=False) == e
+    assert factor_terms(exp(-4*x - 2) - x) == -x + exp(Mul(-2, 2*x + 1, evaluate=False))
+
+    # sum/integral tests
+    for F in (Sum, Integral):
+        assert factor_terms(F(x, (y, 1, 10))) == x * F(1, (y, 1, 10))
+        assert factor_terms(F(x, (y, 1, 10)) + x) == x * (1 + F(1, (y, 1, 10)))
+        assert factor_terms(F(x*y + x*y**2, (y, 1, 10))) == x*F(y*(y + 1), (y, 1, 10))
+
+    # expressions involving Pow terms with base 0
+    assert factor_terms(0**(x - 2) - 1) == 0**(x - 2) - 1
+    assert factor_terms(0**(x + 2) - 1) == 0**(x + 2) - 1
+    assert factor_terms((0**(x + 2) - 1).subs(x,-2)) == 0
+
+
+def test_xreplace():
+    e = Mul(2, 1 + x, evaluate=False)
+    assert e.xreplace({}) == e
+    assert e.xreplace({y: x}) == e
+
+
+def test_factor_nc():
+    x, y = symbols('x,y')
+    k = symbols('k', integer=True)
+    n, m, o = symbols('n,m,o', commutative=False)
+
+    # mul and multinomial expansion is needed
+    from sympy.core.function import _mexpand
+    e = x*(1 + y)**2
+    assert _mexpand(e) == x + x*2*y + x*y**2
+
+    def factor_nc_test(e):
+        ex = _mexpand(e)
+        assert ex.is_Add
+        f = factor_nc(ex)
+        assert not f.is_Add and _mexpand(f) == ex
+
+    factor_nc_test(x*(1 + y))
+    factor_nc_test(n*(x + 1))
+    factor_nc_test(n*(x + m))
+    factor_nc_test((x + m)*n)
+    factor_nc_test(n*m*(x*o + n*o*m)*n)
+    s = Sum(x, (x, 1, 2))
+    factor_nc_test(x*(1 + s))
+    factor_nc_test(x*(1 + s)*s)
+    factor_nc_test(x*(1 + sin(s)))
+    factor_nc_test((1 + n)**2)
+
+    factor_nc_test((x + n)*(x + m)*(x + y))
+    factor_nc_test(x*(n*m + 1))
+    factor_nc_test(x*(n*m + x))
+    factor_nc_test(x*(x*n*m + 1))
+    factor_nc_test(n*(m/x + o))
+    factor_nc_test(m*(n + o/2))
+    factor_nc_test(x*n*(x*m + 1))
+    factor_nc_test(x*(m*n + x*n*m))
+    factor_nc_test(n*(1 - m)*n**2)
+
+    factor_nc_test((n + m)**2)
+    factor_nc_test((n - m)*(n + m)**2)
+    factor_nc_test((n + m)**2*(n - m))
+    factor_nc_test((m - n)*(n + m)**2*(n - m))
+
+    assert factor_nc(n*(n + n*m)) == n**2*(1 + m)
+    assert factor_nc(m*(m*n + n*m*n**2)) == m*(m + n*m*n)*n
+    eq = m*sin(n) - sin(n)*m
+    assert factor_nc(eq) == eq
+
+    # for coverage:
+    from sympy.physics.secondquant import Commutator
+    from sympy.polys.polytools import factor
+    eq = 1 + x*Commutator(m, n)
+    assert factor_nc(eq) == eq
+    eq = x*Commutator(m, n) + x*Commutator(m, o)*Commutator(m, n)
+    assert factor(eq) == x*(1 + Commutator(m, o))*Commutator(m, n)
+
+    # issue 6534
+    assert (2*n + 2*m).factor() == 2*(n + m)
+
+    # issue 6701
+    _n = symbols('nz', zero=False, commutative=False)
+    assert factor_nc(_n**k + _n**(k + 1)) == _n**k*(1 + _n)
+    assert factor_nc((m*n)**k + (m*n)**(k + 1)) == (1 + m*n)*(m*n)**k
+
+    # issue 6918
+    assert factor_nc(-n*(2*x**2 + 2*x)) == -2*n*x*(x + 1)
+
+
+def test_issue_6360():
+    a, b = symbols("a b")
+    apb = a + b
+    eq = apb + apb**2*(-2*a - 2*b)
+    assert factor_terms(sub_pre(eq)) == a + b - 2*(a + b)**3
+
+
+def test_issue_7903():
+    a = symbols(r'a', real=True)
+    t = exp(I*cos(a)) + exp(-I*sin(a))
+    assert t.simplify()
+
+def test_issue_8263():
+    F, G = symbols('F, G', commutative=False, cls=Function)
+    x, y = symbols('x, y')
+    expr, dummies, _ = _mask_nc(F(x)*G(y) - G(y)*F(x))
+    for v in dummies.values():
+        assert not v.is_commutative
+    assert not expr.is_zero
+
+def test_monotonic_sign():
+    F = _monotonic_sign
+    x = symbols('x')
+    assert F(x) is None
+    assert F(-x) is None
+    assert F(Dummy(prime=True)) == 2
+    assert F(Dummy(prime=True, odd=True)) == 3
+    assert F(Dummy(composite=True)) == 4
+    assert F(Dummy(composite=True, odd=True)) == 9
+    assert F(Dummy(positive=True, integer=True)) == 1
+    assert F(Dummy(positive=True, even=True)) == 2
+    assert F(Dummy(positive=True, even=True, prime=False)) == 4
+    assert F(Dummy(negative=True, integer=True)) == -1
+    assert F(Dummy(negative=True, even=True)) == -2
+    assert F(Dummy(zero=True)) == 0
+    assert F(Dummy(nonnegative=True)) == 0
+    assert F(Dummy(nonpositive=True)) == 0
+
+    assert F(Dummy(positive=True) + 1).is_positive
+    assert F(Dummy(positive=True, integer=True) - 1).is_nonnegative
+    assert F(Dummy(positive=True) - 1) is None
+    assert F(Dummy(negative=True) + 1) is None
+    assert F(Dummy(negative=True, integer=True) - 1).is_nonpositive
+    assert F(Dummy(negative=True) - 1).is_negative
+    assert F(-Dummy(positive=True) + 1) is None
+    assert F(-Dummy(positive=True, integer=True) - 1).is_negative
+    assert F(-Dummy(positive=True) - 1).is_negative
+    assert F(-Dummy(negative=True) + 1).is_positive
+    assert F(-Dummy(negative=True, integer=True) - 1).is_nonnegative
+    assert F(-Dummy(negative=True) - 1) is None
+    x = Dummy(negative=True)
+    assert F(x**3).is_nonpositive
+    assert F(x**3 + log(2)*x - 1).is_negative
+    x = Dummy(positive=True)
+    assert F(-x**3).is_nonpositive
+
+    p = Dummy(positive=True)
+    assert F(1/p).is_positive
+    assert F(p/(p + 1)).is_positive
+    p = Dummy(nonnegative=True)
+    assert F(p/(p + 1)).is_nonnegative
+    p = Dummy(positive=True)
+    assert F(-1/p).is_negative
+    p = Dummy(nonpositive=True)
+    assert F(p/(-p + 1)).is_nonpositive
+
+    p = Dummy(positive=True, integer=True)
+    q = Dummy(positive=True, integer=True)
+    assert F(-2/p/q).is_negative
+    assert F(-2/(p - 1)/q) is None
+
+    assert F((p - 1)*q + 1).is_positive
+    assert F(-(p - 1)*q - 1).is_negative
+
+def test_issue_17256():
+    from sympy.sets.fancysets import Range
+    x = Symbol('x')
+    s1 = Sum(x + 1, (x, 1, 9))
+    s2 = Sum(x + 1, (x, Range(1, 10)))
+    a = Symbol('a')
+    r1 = s1.xreplace({x:a})
+    r2 = s2.xreplace({x:a})
+
+    assert r1.doit() == r2.doit()
+    s1 = Sum(x + 1, (x, 0, 9))
+    s2 = Sum(x + 1, (x, Range(10)))
+    a = Symbol('a')
+    r1 = s1.xreplace({x:a})
+    r2 = s2.xreplace({x:a})
+    assert r1 == r2
+
+def test_issue_21623():
+    from sympy.matrices.expressions.matexpr import MatrixSymbol
+    M = MatrixSymbol('X', 2, 2)
+    assert gcd_terms(M[0,0], 1) == M[0,0]
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_facts.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_facts.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca04877d0bdaf8124258ea1d25a10bcfa0f5f3a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_facts.py
@@ -0,0 +1,312 @@
+from sympy.core.facts import (deduce_alpha_implications,
+        apply_beta_to_alpha_route, rules_2prereq, FactRules, FactKB)
+from sympy.core.logic import And, Not
+from sympy.testing.pytest import raises
+
+T = True
+F = False
+U = None
+
+
+def test_deduce_alpha_implications():
+    def D(i):
+        I = deduce_alpha_implications(i)
+        P = rules_2prereq({
+            (k, True): {(v, True) for v in S} for k, S in I.items()})
+        return I, P
+
+    # transitivity
+    I, P = D([('a', 'b'), ('b', 'c')])
+    assert I == {'a': {'b', 'c'}, 'b': {'c'}, Not('b'):
+        {Not('a')}, Not('c'): {Not('a'), Not('b')}}
+    assert P == {'a': {'b', 'c'}, 'b': {'a', 'c'}, 'c': {'a', 'b'}}
+
+    # Duplicate entry
+    I, P = D([('a', 'b'), ('b', 'c'), ('b', 'c')])
+    assert I == {'a': {'b', 'c'}, 'b': {'c'}, Not('b'): {Not('a')}, Not('c'): {Not('a'), Not('b')}}
+    assert P == {'a': {'b', 'c'}, 'b': {'a', 'c'}, 'c': {'a', 'b'}}
+
+    # see if it is tolerant to cycles
+    assert D([('a', 'a'), ('a', 'a')]) == ({}, {})
+    assert D([('a', 'b'), ('b', 'a')]) == (
+        {'a': {'b'}, 'b': {'a'}, Not('a'): {Not('b')}, Not('b'): {Not('a')}},
+        {'a': {'b'}, 'b': {'a'}})
+
+    # see if it catches inconsistency
+    raises(ValueError, lambda: D([('a', Not('a'))]))
+    raises(ValueError, lambda: D([('a', 'b'), ('b', Not('a'))]))
+    raises(ValueError, lambda: D([('a', 'b'), ('b', 'c'), ('b', 'na'),
+           ('na', Not('a'))]))
+
+    # see if it handles implications with negations
+    I, P = D([('a', Not('b')), ('c', 'b')])
+    assert I == {'a': {Not('b'), Not('c')}, 'b': {Not('a')}, 'c': {'b', Not('a')}, Not('b'): {Not('c')}}
+    assert P == {'a': {'b', 'c'}, 'b': {'a', 'c'}, 'c': {'a', 'b'}}
+    I, P = D([(Not('a'), 'b'), ('a', 'c')])
+    assert I == {'a': {'c'}, Not('a'): {'b'}, Not('b'): {'a',
+    'c'}, Not('c'): {Not('a'), 'b'},}
+    assert P == {'a': {'b', 'c'}, 'b': {'a', 'c'}, 'c': {'a', 'b'}}
+
+
+    # Long deductions
+    I, P = D([('a', 'b'), ('b', 'c'), ('c', 'd'), ('d', 'e')])
+    assert I == {'a': {'b', 'c', 'd', 'e'}, 'b': {'c', 'd', 'e'},
+        'c': {'d', 'e'}, 'd': {'e'}, Not('b'): {Not('a')},
+        Not('c'): {Not('a'), Not('b')}, Not('d'): {Not('a'), Not('b'),
+            Not('c')}, Not('e'): {Not('a'), Not('b'), Not('c'), Not('d')}}
+    assert P == {'a': {'b', 'c', 'd', 'e'}, 'b': {'a', 'c', 'd',
+        'e'}, 'c': {'a', 'b', 'd', 'e'}, 'd': {'a', 'b', 'c', 'e'},
+        'e': {'a', 'b', 'c', 'd'}}
+
+    # something related to real-world
+    I, P = D([('rat', 'real'), ('int', 'rat')])
+
+    assert I == {'int': {'rat', 'real'}, 'rat': {'real'},
+        Not('real'): {Not('rat'), Not('int')}, Not('rat'): {Not('int')}}
+    assert P == {'rat': {'int', 'real'}, 'real': {'int', 'rat'},
+        'int': {'rat', 'real'}}
+
+
+# TODO move me to appropriate place
+def test_apply_beta_to_alpha_route():
+    APPLY = apply_beta_to_alpha_route
+
+    # indicates empty alpha-chain with attached beta-rule #bidx
+    def Q(bidx):
+        return (set(), [bidx])
+
+    # x -> a        &(a,b) -> x     --  x -> a
+    A = {'x': {'a'}}
+    B = [(And('a', 'b'), 'x')]
+    assert APPLY(A, B) == {'x': ({'a'}, []), 'a': Q(0), 'b': Q(0)}
+
+    # x -> a        &(a,!x) -> b    --  x -> a
+    A = {'x': {'a'}}
+    B = [(And('a', Not('x')), 'b')]
+    assert APPLY(A, B) == {'x': ({'a'}, []), Not('x'): Q(0), 'a': Q(0)}
+
+    # x -> a b      &(a,b) -> c     --  x -> a b c
+    A = {'x': {'a', 'b'}}
+    B = [(And('a', 'b'), 'c')]
+    assert APPLY(A, B) == \
+        {'x': ({'a', 'b', 'c'}, []), 'a': Q(0), 'b': Q(0)}
+
+    # x -> a        &(a,b) -> y     --  x -> a [#0]
+    A = {'x': {'a'}}
+    B = [(And('a', 'b'), 'y')]
+    assert APPLY(A, B) == {'x': ({'a'}, [0]), 'a': Q(0), 'b': Q(0)}
+
+    # x -> a b c    &(a,b) -> c     --  x -> a b c
+    A = {'x': {'a', 'b', 'c'}}
+    B = [(And('a', 'b'), 'c')]
+    assert APPLY(A, B) == \
+        {'x': ({'a', 'b', 'c'}, []), 'a': Q(0), 'b': Q(0)}
+
+    # x -> a b      &(a,b,c) -> y   --  x -> a b [#0]
+    A = {'x': {'a', 'b'}}
+    B = [(And('a', 'b', 'c'), 'y')]
+    assert APPLY(A, B) == \
+        {'x': ({'a', 'b'}, [0]), 'a': Q(0), 'b': Q(0), 'c': Q(0)}
+
+    # x -> a b      &(a,b) -> c     --  x -> a b c d
+    # c -> d                            c -> d
+    A = {'x': {'a', 'b'}, 'c': {'d'}}
+    B = [(And('a', 'b'), 'c')]
+    assert APPLY(A, B) == {'x': ({'a', 'b', 'c', 'd'}, []),
+        'c': ({'d'}, []), 'a': Q(0), 'b': Q(0)}
+
+    # x -> a b      &(a,b) -> c     --  x -> a b c d e
+    # c -> d        &(c,d) -> e         c -> d e
+    A = {'x': {'a', 'b'}, 'c': {'d'}}
+    B = [(And('a', 'b'), 'c'), (And('c', 'd'), 'e')]
+    assert APPLY(A, B) == {'x': ({'a', 'b', 'c', 'd', 'e'}, []),
+        'c': ({'d', 'e'}, []), 'a': Q(0), 'b': Q(0), 'd': Q(1)}
+
+    # x -> a b      &(a,y) -> z     --  x -> a b y z
+    #               &(a,b) -> y
+    A = {'x': {'a', 'b'}}
+    B = [(And('a', 'y'), 'z'), (And('a', 'b'), 'y')]
+    assert APPLY(A, B) == {'x': ({'a', 'b', 'y', 'z'}, []),
+        'a': (set(), [0, 1]), 'y': Q(0), 'b': Q(1)}
+
+    # x -> a b      &(a,!b) -> c    --  x -> a b
+    A = {'x': {'a', 'b'}}
+    B = [(And('a', Not('b')), 'c')]
+    assert APPLY(A, B) == \
+        {'x': ({'a', 'b'}, []), 'a': Q(0), Not('b'): Q(0)}
+
+    # !x -> !a !b   &(!a,b) -> c    --  !x -> !a !b
+    A = {Not('x'): {Not('a'), Not('b')}}
+    B = [(And(Not('a'), 'b'), 'c')]
+    assert APPLY(A, B) == \
+        {Not('x'): ({Not('a'), Not('b')}, []), Not('a'): Q(0), 'b': Q(0)}
+
+    # x -> a b      &(b,c) -> !a    --  x -> a b
+    A = {'x': {'a', 'b'}}
+    B = [(And('b', 'c'), Not('a'))]
+    assert APPLY(A, B) == {'x': ({'a', 'b'}, []), 'b': Q(0), 'c': Q(0)}
+
+    # x -> a b      &(a, b) -> c    --  x -> a b c p
+    # c -> p a
+    A = {'x': {'a', 'b'}, 'c': {'p', 'a'}}
+    B = [(And('a', 'b'), 'c')]
+    assert APPLY(A, B) == {'x': ({'a', 'b', 'c', 'p'}, []),
+        'c': ({'p', 'a'}, []), 'a': Q(0), 'b': Q(0)}
+
+
+def test_FactRules_parse():
+    f = FactRules('a -> b')
+    assert f.prereq == {'b': {'a'}, 'a': {'b'}}
+
+    f = FactRules('a -> !b')
+    assert f.prereq == {'b': {'a'}, 'a': {'b'}}
+
+    f = FactRules('!a -> b')
+    assert f.prereq == {'b': {'a'}, 'a': {'b'}}
+
+    f = FactRules('!a -> !b')
+    assert f.prereq == {'b': {'a'}, 'a': {'b'}}
+
+    f = FactRules('!z == nz')
+    assert f.prereq == {'z': {'nz'}, 'nz': {'z'}}
+
+
+def test_FactRules_parse2():
+    raises(ValueError, lambda: FactRules('a -> !a'))
+
+
+def test_FactRules_deduce():
+    f = FactRules(['a -> b', 'b -> c', 'b -> d', 'c -> e'])
+
+    def D(facts):
+        kb = FactKB(f)
+        kb.deduce_all_facts(facts)
+        return kb
+
+    assert D({'a': T}) == {'a': T, 'b': T, 'c': T, 'd': T, 'e': T}
+    assert D({'b': T}) == {        'b': T, 'c': T, 'd': T, 'e': T}
+    assert D({'c': T}) == {                'c': T,         'e': T}
+    assert D({'d': T}) == {                        'd': T        }
+    assert D({'e': T}) == {                                'e': T}
+
+    assert D({'a': F}) == {'a': F                                }
+    assert D({'b': F}) == {'a': F, 'b': F                        }
+    assert D({'c': F}) == {'a': F, 'b': F, 'c': F                }
+    assert D({'d': F}) == {'a': F, 'b': F,         'd': F        }
+
+    assert D({'a': U}) == {'a': U}  # XXX ok?
+
+
+def test_FactRules_deduce2():
+    # pos/neg/zero, but the rules are not sufficient to derive all relations
+    f = FactRules(['pos -> !neg', 'pos -> !z'])
+
+    def D(facts):
+        kb = FactKB(f)
+        kb.deduce_all_facts(facts)
+        return kb
+
+    assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
+    assert D({'pos': F}) == {'pos': F                  }
+    assert D({'neg': T}) == {'pos': F, 'neg': T        }
+    assert D({'neg': F}) == {          'neg': F        }
+    assert D({'z': T}) == {'pos': F,           'z': T}
+    assert D({'z': F}) == {                    'z': F}
+
+    # pos/neg/zero. rules are sufficient to derive all relations
+    f = FactRules(['pos -> !neg', 'neg -> !pos', 'pos -> !z', 'neg -> !z'])
+
+    assert D({'pos': T}) == {'pos': T, 'neg': F, 'z': F}
+    assert D({'pos': F}) == {'pos': F                  }
+    assert D({'neg': T}) == {'pos': F, 'neg': T, 'z': F}
+    assert D({'neg': F}) == {          'neg': F        }
+    assert D({'z': T}) == {'pos': F, 'neg': F, 'z': T}
+    assert D({'z': F}) == {                    'z': F}
+
+
+def test_FactRules_deduce_multiple():
+    # deduction that involves _several_ starting points
+    f = FactRules(['real == pos | npos'])
+
+    def D(facts):
+        kb = FactKB(f)
+        kb.deduce_all_facts(facts)
+        return kb
+
+    assert D({'real': T}) == {'real': T}
+    assert D({'real': F}) == {'real': F, 'pos': F, 'npos': F}
+    assert D({'pos': T}) == {'real': T, 'pos': T}
+    assert D({'npos': T}) == {'real': T, 'npos': T}
+
+    # --- key tests below ---
+    assert D({'pos': F, 'npos': F}) == {'real': F, 'pos': F, 'npos': F}
+    assert D({'real': T, 'pos': F}) == {'real': T, 'pos': F, 'npos': T}
+    assert D({'real': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
+
+    assert D({'pos': T, 'npos': F}) == {'real': T, 'pos': T, 'npos': F}
+    assert D({'pos': F, 'npos': T}) == {'real': T, 'pos': F, 'npos': T}
+
+
+def test_FactRules_deduce_multiple2():
+    f = FactRules(['real == neg | zero | pos'])
+
+    def D(facts):
+        kb = FactKB(f)
+        kb.deduce_all_facts(facts)
+        return kb
+
+    assert D({'real': T}) == {'real': T}
+    assert D({'real': F}) == {'real': F, 'neg': F, 'zero': F, 'pos': F}
+    assert D({'neg': T}) == {'real': T, 'neg': T}
+    assert D({'zero': T}) == {'real': T, 'zero': T}
+    assert D({'pos': T}) == {'real': T, 'pos': T}
+
+    # --- key tests below ---
+    assert D({'neg': F, 'zero': F, 'pos': F}) == {'real': F, 'neg': F,
+             'zero': F, 'pos': F}
+    assert D({'real': T, 'neg': F}) == {'real': T, 'neg': F}
+    assert D({'real': T, 'zero': F}) == {'real': T, 'zero': F}
+    assert D({'real': T, 'pos': F}) == {'real': T, 'pos': F}
+
+    assert D({'real': T,           'zero': F, 'pos': F}) == {'real': T,
+             'neg': T, 'zero': F, 'pos': F}
+    assert D({'real': T, 'neg': F,            'pos': F}) == {'real': T,
+             'neg': F, 'zero': T, 'pos': F}
+    assert D({'real': T, 'neg': F, 'zero': F          }) == {'real': T,
+             'neg': F, 'zero': F, 'pos': T}
+
+    assert D({'neg': T, 'zero': F, 'pos': F}) == {'real': T, 'neg': T,
+             'zero': F, 'pos': F}
+    assert D({'neg': F, 'zero': T, 'pos': F}) == {'real': T, 'neg': F,
+             'zero': T, 'pos': F}
+    assert D({'neg': F, 'zero': F, 'pos': T}) == {'real': T, 'neg': F,
+             'zero': F, 'pos': T}
+
+
+def test_FactRules_deduce_base():
+    # deduction that starts from base
+
+    f = FactRules(['real  == neg | zero | pos',
+                   'neg   -> real & !zero & !pos',
+                   'pos   -> real & !zero & !neg'])
+    base = FactKB(f)
+
+    base.deduce_all_facts({'real': T, 'neg': F})
+    assert base == {'real': T, 'neg': F}
+
+    base.deduce_all_facts({'zero': F})
+    assert base == {'real': T, 'neg': F, 'zero': F, 'pos': T}
+
+
+def test_FactRules_deduce_staticext():
+    # verify that static beta-extensions deduction takes place
+    f = FactRules(['real  == neg | zero | pos',
+                   'neg   -> real & !zero & !pos',
+                   'pos   -> real & !zero & !neg',
+                   'nneg  == real & !neg',
+                   'npos  == real & !pos'])
+
+    assert ('npos', True) in f.full_implications[('neg', True)]
+    assert ('nneg', True) in f.full_implications[('pos', True)]
+    assert ('nneg', True) in f.full_implications[('zero', True)]
+    assert ('npos', True) in f.full_implications[('zero', True)]
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_function.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_function.py
new file mode 100644
index 0000000000000000000000000000000000000000..a69c6b81b786ab0f0592367eaf402c2165a615dc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_function.py
@@ -0,0 +1,1459 @@
+from sympy.concrete.summations import Sum
+from sympy.core.basic import Basic, _aresame
+from sympy.core.cache import clear_cache
+from sympy.core.containers import Dict, Tuple
+from sympy.core.expr import Expr, unchanged
+from sympy.core.function import (Subs, Function, diff, Lambda, expand,
+    nfloat, Derivative)
+from sympy.core.numbers import E, Float, zoo, Rational, pi, I, oo, nan
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols, Dummy, Symbol
+from sympy.functions.elementary.complexes import im, re
+from sympy.functions.elementary.exponential import log, exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import sin, cos, acos
+from sympy.functions.special.error_functions import expint
+from sympy.functions.special.gamma_functions import loggamma, polygamma
+from sympy.matrices.dense import Matrix
+from sympy.printing.str import sstr
+from sympy.series.order import O
+from sympy.tensor.indexed import Indexed
+from sympy.core.function import (PoleError, _mexpand, arity,
+        BadSignatureError, BadArgumentsError)
+from sympy.core.parameters import _exp_is_pow
+from sympy.core.sympify import sympify, SympifyError
+from sympy.matrices import MutableMatrix, ImmutableMatrix
+from sympy.sets.sets import FiniteSet
+from sympy.solvers.solveset import solveset
+from sympy.tensor.array import NDimArray
+from sympy.utilities.iterables import subsets, variations
+from sympy.testing.pytest import XFAIL, raises, warns_deprecated_sympy, _both_exp_pow
+
+from sympy.abc import t, w, x, y, z
+f, g, h = symbols('f g h', cls=Function)
+_xi_1, _xi_2, _xi_3 = [Dummy() for i in range(3)]
+
+def test_f_expand_complex():
+    x = Symbol('x', real=True)
+
+    assert f(x).expand(complex=True) == I*im(f(x)) + re(f(x))
+    assert exp(x).expand(complex=True) == exp(x)
+    assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
+    assert exp(z).expand(complex=True) == cos(im(z))*exp(re(z)) + \
+        I*sin(im(z))*exp(re(z))
+
+
+def test_bug1():
+    e = sqrt(-log(w))
+    assert e.subs(log(w), -x) == sqrt(x)
+
+    e = sqrt(-5*log(w))
+    assert e.subs(log(w), -x) == sqrt(5*x)
+
+
+def test_general_function():
+    nu = Function('nu')
+
+    e = nu(x)
+    edx = e.diff(x)
+    edy = e.diff(y)
+    edxdx = e.diff(x).diff(x)
+    edxdy = e.diff(x).diff(y)
+    assert e == nu(x)
+    assert edx != nu(x)
+    assert edx == diff(nu(x), x)
+    assert edy == 0
+    assert edxdx == diff(diff(nu(x), x), x)
+    assert edxdy == 0
+
+def test_general_function_nullary():
+    nu = Function('nu')
+
+    e = nu()
+    edx = e.diff(x)
+    edxdx = e.diff(x).diff(x)
+    assert e == nu()
+    assert edx != nu()
+    assert edx == 0
+    assert edxdx == 0
+
+
+def test_derivative_subs_bug():
+    e = diff(g(x), x)
+    assert e.subs(g(x), f(x)) != e
+    assert e.subs(g(x), f(x)) == Derivative(f(x), x)
+    assert e.subs(g(x), -f(x)) == Derivative(-f(x), x)
+
+    assert e.subs(x, y) == Derivative(g(y), y)
+
+
+def test_derivative_subs_self_bug():
+    d = diff(f(x), x)
+
+    assert d.subs(d, y) == y
+
+
+def test_derivative_linearity():
+    assert diff(-f(x), x) == -diff(f(x), x)
+    assert diff(8*f(x), x) == 8*diff(f(x), x)
+    assert diff(8*f(x), x) != 7*diff(f(x), x)
+    assert diff(8*f(x)*x, x) == 8*f(x) + 8*x*diff(f(x), x)
+    assert diff(8*f(x)*y*x, x).expand() == 8*y*f(x) + 8*y*x*diff(f(x), x)
+
+
+def test_derivative_evaluate():
+    assert Derivative(sin(x), x) != diff(sin(x), x)
+    assert Derivative(sin(x), x).doit() == diff(sin(x), x)
+
+    assert Derivative(Derivative(f(x), x), x) == diff(f(x), x, x)
+    assert Derivative(sin(x), x, 0) == sin(x)
+    assert Derivative(sin(x), (x, y), (x, -y)) == sin(x)
+
+
+def test_diff_symbols():
+    assert diff(f(x, y, z), x, y, z) == Derivative(f(x, y, z), x, y, z)
+    assert diff(f(x, y, z), x, x, x) == Derivative(f(x, y, z), x, x, x) == Derivative(f(x, y, z), (x, 3))
+    assert diff(f(x, y, z), x, 3) == Derivative(f(x, y, z), x, 3)
+
+    # issue 5028
+    assert [diff(-z + x/y, sym) for sym in (z, x, y)] == [-1, 1/y, -x/y**2]
+    assert diff(f(x, y, z), x, y, z, 2) == Derivative(f(x, y, z), x, y, z, z)
+    assert diff(f(x, y, z), x, y, z, 2, evaluate=False) == \
+        Derivative(f(x, y, z), x, y, z, z)
+    assert Derivative(f(x, y, z), x, y, z)._eval_derivative(z) == \
+        Derivative(f(x, y, z), x, y, z, z)
+    assert Derivative(Derivative(f(x, y, z), x), y)._eval_derivative(z) == \
+        Derivative(f(x, y, z), x, y, z)
+
+    raises(TypeError, lambda: cos(x).diff((x, y)).variables)
+    assert cos(x).diff((x, y))._wrt_variables == [x]
+
+    # issue 23222
+    assert sympify("a*x+b").diff("x") == sympify("a")
+
+def test_Function():
+    class myfunc(Function):
+        @classmethod
+        def eval(cls):  # zero args
+            return
+
+    assert myfunc.nargs == FiniteSet(0)
+    assert myfunc().nargs == FiniteSet(0)
+    raises(TypeError, lambda: myfunc(x).nargs)
+
+    class myfunc(Function):
+        @classmethod
+        def eval(cls, x):  # one arg
+            return
+
+    assert myfunc.nargs == FiniteSet(1)
+    assert myfunc(x).nargs == FiniteSet(1)
+    raises(TypeError, lambda: myfunc(x, y).nargs)
+
+    class myfunc(Function):
+        @classmethod
+        def eval(cls, *x):  # star args
+            return
+
+    assert myfunc.nargs == S.Naturals0
+    assert myfunc(x).nargs == S.Naturals0
+
+
+def test_nargs():
+    f = Function('f')
+    assert f.nargs == S.Naturals0
+    assert f(1).nargs == S.Naturals0
+    assert Function('f', nargs=2)(1, 2).nargs == FiniteSet(2)
+    assert sin.nargs == FiniteSet(1)
+    assert sin(2).nargs == FiniteSet(1)
+    assert log.nargs == FiniteSet(1, 2)
+    assert log(2).nargs == FiniteSet(1, 2)
+    assert Function('f', nargs=2).nargs == FiniteSet(2)
+    assert Function('f', nargs=0).nargs == FiniteSet(0)
+    assert Function('f', nargs=(0, 1)).nargs == FiniteSet(0, 1)
+    assert Function('f', nargs=None).nargs == S.Naturals0
+    raises(ValueError, lambda: Function('f', nargs=()))
+
+def test_nargs_inheritance():
+    class f1(Function):
+        nargs = 2
+    class f2(f1):
+        pass
+    class f3(f2):
+        pass
+    class f4(f3):
+        nargs = 1,2
+    class f5(f4):
+        pass
+    class f6(f5):
+        pass
+    class f7(f6):
+        nargs=None
+    class f8(f7):
+        pass
+    class f9(f8):
+        pass
+    class f10(f9):
+        nargs = 1
+    class f11(f10):
+        pass
+    assert f1.nargs == FiniteSet(2)
+    assert f2.nargs == FiniteSet(2)
+    assert f3.nargs == FiniteSet(2)
+    assert f4.nargs == FiniteSet(1, 2)
+    assert f5.nargs == FiniteSet(1, 2)
+    assert f6.nargs == FiniteSet(1, 2)
+    assert f7.nargs == S.Naturals0
+    assert f8.nargs == S.Naturals0
+    assert f9.nargs == S.Naturals0
+    assert f10.nargs == FiniteSet(1)
+    assert f11.nargs == FiniteSet(1)
+
+def test_arity():
+    f = lambda x, y: 1
+    assert arity(f) == 2
+    def f(x, y, z=None):
+        pass
+    assert arity(f) == (2, 3)
+    assert arity(lambda *x: x) is None
+    assert arity(log) == (1, 2)
+
+
+def test_Lambda():
+    e = Lambda(x, x**2)
+    assert e(4) == 16
+    assert e(x) == x**2
+    assert e(y) == y**2
+
+    assert Lambda((), 42)() == 42
+    assert unchanged(Lambda, (), 42)
+    assert Lambda((), 42) != Lambda((), 43)
+    assert Lambda((), f(x))() == f(x)
+    assert Lambda((), 42).nargs == FiniteSet(0)
+
+    assert unchanged(Lambda, (x,), x**2)
+    assert Lambda(x, x**2) == Lambda((x,), x**2)
+    assert Lambda(x, x**2) != Lambda(x, x**2 + 1)
+    assert Lambda((x, y), x**y) != Lambda((y, x), y**x)
+    assert Lambda((x, y), x**y) != Lambda((x, y), y**x)
+
+    assert Lambda((x, y), x**y)(x, y) == x**y
+    assert Lambda((x, y), x**y)(3, 3) == 3**3
+    assert Lambda((x, y), x**y)(x, 3) == x**3
+    assert Lambda((x, y), x**y)(3, y) == 3**y
+    assert Lambda(x, f(x))(x) == f(x)
+    assert Lambda(x, x**2)(e(x)) == x**4
+    assert e(e(x)) == x**4
+
+    x1, x2 = (Indexed('x', i) for i in (1, 2))
+    assert Lambda((x1, x2), x1 + x2)(x, y) == x + y
+
+    assert Lambda((x, y), x + y).nargs == FiniteSet(2)
+
+    p = x, y, z, t
+    assert Lambda(p, t*(x + y + z))(*p) == t * (x + y + z)
+
+    eq = Lambda(x, 2*x) + Lambda(y, 2*y)
+    assert eq != 2*Lambda(x, 2*x)
+    assert eq.as_dummy() == 2*Lambda(x, 2*x).as_dummy()
+    assert Lambda(x, 2*x) not in [ Lambda(x, x) ]
+    raises(BadSignatureError, lambda: Lambda(1, x))
+    assert Lambda(x, 1)(1) is S.One
+
+    raises(BadSignatureError, lambda: Lambda((x, x), x + 2))
+    raises(BadSignatureError, lambda: Lambda(((x, x), y), x))
+    raises(BadSignatureError, lambda: Lambda(((y, x), x), x))
+    raises(BadSignatureError, lambda: Lambda(((y, 1), 2), x))
+
+    with warns_deprecated_sympy():
+        assert Lambda([x, y], x+y) == Lambda((x, y), x+y)
+
+    flam = Lambda(((x, y),), x + y)
+    assert flam((2, 3)) == 5
+    flam = Lambda(((x, y), z), x + y + z)
+    assert flam((2, 3), 1) == 6
+    flam = Lambda((((x, y), z),), x + y + z)
+    assert flam(((2, 3), 1)) == 6
+    raises(BadArgumentsError, lambda: flam(1, 2, 3))
+    flam = Lambda( (x,), (x, x))
+    assert flam(1,) == (1, 1)
+    assert flam((1,)) == ((1,), (1,))
+    flam = Lambda( ((x,),), (x, x))
+    raises(BadArgumentsError, lambda: flam(1))
+    assert flam((1,)) == (1, 1)
+
+    # Previously TypeError was raised so this is potentially needed for
+    # backwards compatibility.
+    assert issubclass(BadSignatureError, TypeError)
+    assert issubclass(BadArgumentsError, TypeError)
+
+    # These are tested to see they don't raise:
+    hash(Lambda(x, 2*x))
+    hash(Lambda(x, x))  # IdentityFunction subclass
+
+
+def test_IdentityFunction():
+    assert Lambda(x, x) is Lambda(y, y) is S.IdentityFunction
+    assert Lambda(x, 2*x) is not S.IdentityFunction
+    assert Lambda((x, y), x) is not S.IdentityFunction
+
+
+def test_Lambda_symbols():
+    assert Lambda(x, 2*x).free_symbols == set()
+    assert Lambda(x, x*y).free_symbols == {y}
+    assert Lambda((), 42).free_symbols == set()
+    assert Lambda((), x*y).free_symbols == {x,y}
+
+
+def test_functionclas_symbols():
+    assert f.free_symbols == set()
+
+
+def test_Lambda_arguments():
+    raises(TypeError, lambda: Lambda(x, 2*x)(x, y))
+    raises(TypeError, lambda: Lambda((x, y), x + y)(x))
+    raises(TypeError, lambda: Lambda((), 42)(x))
+
+
+def test_Lambda_equality():
+    assert Lambda((x, y), 2*x) == Lambda((x, y), 2*x)
+    # these, of course, should never be equal
+    assert Lambda(x, 2*x) != Lambda((x, y), 2*x)
+    assert Lambda(x, 2*x) != 2*x
+    # But it is tempting to want expressions that differ only
+    # in bound symbols to compare the same.  But this is not what
+    # Python's `==` is intended to do; two objects that compare
+    # as equal means that they are indistibguishable and cache to the
+    # same value.  We wouldn't want to expression that are
+    # mathematically the same but written in different variables to be
+    # interchanged else what is the point of allowing for different
+    # variable names?
+    assert Lambda(x, 2*x) != Lambda(y, 2*y)
+
+
+def test_Subs():
+    assert Subs(1, (), ()) is S.One
+    # check null subs influence on hashing
+    assert Subs(x, y, z) != Subs(x, y, 1)
+    # neutral subs works
+    assert Subs(x, x, 1).subs(x, y).has(y)
+    # self mapping var/point
+    assert Subs(Derivative(f(x), (x, 2)), x, x).doit() == f(x).diff(x, x)
+    assert Subs(x, x, 0).has(x)  # it's a structural answer
+    assert not Subs(x, x, 0).free_symbols
+    assert Subs(Subs(x + y, x, 2), y, 1) == Subs(x + y, (x, y), (2, 1))
+    assert Subs(x, (x,), (0,)) == Subs(x, x, 0)
+    assert Subs(x, x, 0) == Subs(y, y, 0)
+    assert Subs(x, x, 0).subs(x, 1) == Subs(x, x, 0)
+    assert Subs(y, x, 0).subs(y, 1) == Subs(1, x, 0)
+    assert Subs(f(x), x, 0).doit() == f(0)
+    assert Subs(f(x**2), x**2, 0).doit() == f(0)
+    assert Subs(f(x, y, z), (x, y, z), (0, 1, 1)) != \
+        Subs(f(x, y, z), (x, y, z), (0, 0, 1))
+    assert Subs(x, y, 2).subs(x, y).doit() == 2
+    assert Subs(f(x, y), (x, y, z), (0, 1, 1)) != \
+        Subs(f(x, y) + z, (x, y, z), (0, 1, 0))
+    assert Subs(f(x, y), (x, y), (0, 1)).doit() == f(0, 1)
+    assert Subs(Subs(f(x, y), x, 0), y, 1).doit() == f(0, 1)
+    raises(ValueError, lambda: Subs(f(x, y), (x, y), (0, 0, 1)))
+    raises(ValueError, lambda: Subs(f(x, y), (x, x, y), (0, 0, 1)))
+
+    assert len(Subs(f(x, y), (x, y), (0, 1)).variables) == 2
+    assert Subs(f(x, y), (x, y), (0, 1)).point == Tuple(0, 1)
+
+    assert Subs(f(x), x, 0) == Subs(f(y), y, 0)
+    assert Subs(f(x, y), (x, y), (0, 1)) == Subs(f(x, y), (y, x), (1, 0))
+    assert Subs(f(x)*y, (x, y), (0, 1)) == Subs(f(y)*x, (y, x), (0, 1))
+    assert Subs(f(x)*y, (x, y), (1, 1)) == Subs(f(y)*x, (x, y), (1, 1))
+
+    assert Subs(f(x), x, 0).subs(x, 1).doit() == f(0)
+    assert Subs(f(x), x, y).subs(y, 0) == Subs(f(x), x, 0)
+    assert Subs(y*f(x), x, y).subs(y, 2) == Subs(2*f(x), x, 2)
+    assert (2 * Subs(f(x), x, 0)).subs(Subs(f(x), x, 0), y) == 2*y
+
+    assert Subs(f(x), x, 0).free_symbols == set()
+    assert Subs(f(x, y), x, z).free_symbols == {y, z}
+
+    assert Subs(f(x).diff(x), x, 0).doit(), Subs(f(x).diff(x), x, 0)
+    assert Subs(1 + f(x).diff(x), x, 0).doit(), 1 + Subs(f(x).diff(x), x, 0)
+    assert Subs(y*f(x, y).diff(x), (x, y), (0, 2)).doit() == \
+        2*Subs(Derivative(f(x, 2), x), x, 0)
+    assert Subs(y**2*f(x), x, 0).diff(y) == 2*y*f(0)
+
+    e = Subs(y**2*f(x), x, y)
+    assert e.diff(y) == e.doit().diff(y) == y**2*Derivative(f(y), y) + 2*y*f(y)
+
+    assert Subs(f(x), x, 0) + Subs(f(x), x, 0) == 2*Subs(f(x), x, 0)
+    e1 = Subs(z*f(x), x, 1)
+    e2 = Subs(z*f(y), y, 1)
+    assert e1 + e2 == 2*e1
+    assert e1.__hash__() == e2.__hash__()
+    assert Subs(z*f(x + 1), x, 1) not in [ e1, e2 ]
+    assert Derivative(f(x), x).subs(x, g(x)) == Derivative(f(g(x)), g(x))
+    assert Derivative(f(x), x).subs(x, x + y) == Subs(Derivative(f(x), x),
+        x, x + y)
+    assert Subs(f(x)*cos(y) + z, (x, y), (0, pi/3)).n(2) == \
+        Subs(f(x)*cos(y) + z, (x, y), (0, pi/3)).evalf(2) == \
+        z + Rational('1/2').n(2)*f(0)
+
+    assert f(x).diff(x).subs(x, 0).subs(x, y) == f(x).diff(x).subs(x, 0)
+    assert (x*f(x).diff(x).subs(x, 0)).subs(x, y) == y*f(x).diff(x).subs(x, 0)
+    assert Subs(Derivative(g(x)**2, g(x), x), g(x), exp(x)
+        ).doit() == 2*exp(x)
+    assert Subs(Derivative(g(x)**2, g(x), x), g(x), exp(x)
+        ).doit(deep=False) == 2*Derivative(exp(x), x)
+    assert Derivative(f(x, g(x)), x).doit() == Derivative(
+        f(x, g(x)), g(x))*Derivative(g(x), x) + Subs(Derivative(
+        f(y, g(x)), y), y, x)
+
+def test_doitdoit():
+    done = Derivative(f(x, g(x)), x, g(x)).doit()
+    assert done == done.doit()
+
+
+@XFAIL
+def test_Subs2():
+    # this reflects a limitation of subs(), probably won't fix
+    assert Subs(f(x), x**2, x).doit() == f(sqrt(x))
+
+
+def test_expand_function():
+    assert expand(x + y) == x + y
+    assert expand(x + y, complex=True) == I*im(x) + I*im(y) + re(x) + re(y)
+    assert expand((x + y)**11, modulus=11) == x**11 + y**11
+
+
+def test_function_comparable():
+    assert sin(x).is_comparable is False
+    assert cos(x).is_comparable is False
+
+    assert sin(Float('0.1')).is_comparable is True
+    assert cos(Float('0.1')).is_comparable is True
+
+    assert sin(E).is_comparable is True
+    assert cos(E).is_comparable is True
+
+    assert sin(Rational(1, 3)).is_comparable is True
+    assert cos(Rational(1, 3)).is_comparable is True
+
+
+def test_function_comparable_infinities():
+    assert sin(oo).is_comparable is False
+    assert sin(-oo).is_comparable is False
+    assert sin(zoo).is_comparable is False
+    assert sin(nan).is_comparable is False
+
+
+def test_deriv1():
+    # These all require derivatives evaluated at a point (issue 4719) to work.
+    # See issue 4624
+    assert f(2*x).diff(x) == 2*Subs(Derivative(f(x), x), x, 2*x)
+    assert (f(x)**3).diff(x) == 3*f(x)**2*f(x).diff(x)
+    assert (f(2*x)**3).diff(x) == 6*f(2*x)**2*Subs(
+        Derivative(f(x), x), x, 2*x)
+
+    assert f(2 + x).diff(x) == Subs(Derivative(f(x), x), x, x + 2)
+    assert f(2 + 3*x).diff(x) == 3*Subs(
+        Derivative(f(x), x), x, 3*x + 2)
+    assert f(3*sin(x)).diff(x) == 3*cos(x)*Subs(
+        Derivative(f(x), x), x, 3*sin(x))
+
+    # See issue 8510
+    assert f(x, x + z).diff(x) == (
+        Subs(Derivative(f(y, x + z), y), y, x) +
+        Subs(Derivative(f(x, y), y), y, x + z))
+    assert f(x, x**2).diff(x) == (
+        2*x*Subs(Derivative(f(x, y), y), y, x**2) +
+        Subs(Derivative(f(y, x**2), y), y, x))
+    # but Subs is not always necessary
+    assert f(x, g(y)).diff(g(y)) == Derivative(f(x, g(y)), g(y))
+
+
+def test_deriv2():
+    assert (x**3).diff(x) == 3*x**2
+    assert (x**3).diff(x, evaluate=False) != 3*x**2
+    assert (x**3).diff(x, evaluate=False) == Derivative(x**3, x)
+
+    assert diff(x**3, x) == 3*x**2
+    assert diff(x**3, x, evaluate=False) != 3*x**2
+    assert diff(x**3, x, evaluate=False) == Derivative(x**3, x)
+
+
+def test_func_deriv():
+    assert f(x).diff(x) == Derivative(f(x), x)
+    # issue 4534
+    assert f(x, y).diff(x, y) - f(x, y).diff(y, x) == 0
+    assert Derivative(f(x, y), x, y).args[1:] == ((x, 1), (y, 1))
+    assert Derivative(f(x, y), y, x).args[1:] == ((y, 1), (x, 1))
+    assert (Derivative(f(x, y), x, y) - Derivative(f(x, y), y, x)).doit() == 0
+
+
+def test_suppressed_evaluation():
+    a = sin(0, evaluate=False)
+    assert a != 0
+    assert a.func is sin
+    assert a.args == (0,)
+
+
+def test_function_evalf():
+    def eq(a, b, eps):
+        return abs(a - b) < eps
+    assert eq(sin(1).evalf(15), Float("0.841470984807897"), 1e-13)
+    assert eq(
+        sin(2).evalf(25), Float("0.9092974268256816953960199", 25), 1e-23)
+    assert eq(sin(1 + I).evalf(
+        15), Float("1.29845758141598") + Float("0.634963914784736")*I, 1e-13)
+    assert eq(exp(1 + I).evalf(15), Float(
+        "1.46869393991588") + Float("2.28735528717884239")*I, 1e-13)
+    assert eq(exp(-0.5 + 1.5*I).evalf(15), Float(
+        "0.0429042815937374") + Float("0.605011292285002")*I, 1e-13)
+    assert eq(log(pi + sqrt(2)*I).evalf(
+        15), Float("1.23699044022052") + Float("0.422985442737893")*I, 1e-13)
+    assert eq(cos(100).evalf(15), Float("0.86231887228768"), 1e-13)
+
+
+def test_extensibility_eval():
+    class MyFunc(Function):
+        @classmethod
+        def eval(cls, *args):
+            return (0, 0, 0)
+    assert MyFunc(0) == (0, 0, 0)
+
+
+@_both_exp_pow
+def test_function_non_commutative():
+    x = Symbol('x', commutative=False)
+    assert f(x).is_commutative is False
+    assert sin(x).is_commutative is False
+    assert exp(x).is_commutative is False
+    assert log(x).is_commutative is False
+    assert f(x).is_complex is False
+    assert sin(x).is_complex is False
+    assert exp(x).is_complex is False
+    assert log(x).is_complex is False
+
+
+def test_function_complex():
+    x = Symbol('x', complex=True)
+    xzf = Symbol('x', complex=True, zero=False)
+    assert f(x).is_commutative is True
+    assert sin(x).is_commutative is True
+    assert exp(x).is_commutative is True
+    assert log(x).is_commutative is True
+    assert f(x).is_complex is None
+    assert sin(x).is_complex is True
+    assert exp(x).is_complex is True
+    assert log(x).is_complex is None
+    assert log(xzf).is_complex is True
+
+
+def test_function__eval_nseries():
+    n = Symbol('n')
+
+    assert sin(x)._eval_nseries(x, 2, None) == x + O(x**2)
+    assert sin(x + 1)._eval_nseries(x, 2, None) == x*cos(1) + sin(1) + O(x**2)
+    assert sin(pi*(1 - x))._eval_nseries(x, 2, None) == pi*x + O(x**2)
+    assert acos(1 - x**2)._eval_nseries(x, 2, None) == sqrt(2)*sqrt(x**2) + O(x**2)
+    assert polygamma(n, x + 1)._eval_nseries(x, 2, None) == \
+        polygamma(n, 1) + polygamma(n + 1, 1)*x + O(x**2)
+    raises(PoleError, lambda: sin(1/x)._eval_nseries(x, 2, None))
+    assert acos(1 - x)._eval_nseries(x, 2, None) == sqrt(2)*sqrt(x) + sqrt(2)*x**(S(3)/2)/12 + O(x**2)
+    assert acos(1 + x)._eval_nseries(x, 2, None) == sqrt(2)*sqrt(-x) + sqrt(2)*(-x)**(S(3)/2)/12 + O(x**2)
+    assert loggamma(1/x)._eval_nseries(x, 0, None) == \
+        log(x)/2 - log(x)/x - 1/x + O(1, x)
+    assert loggamma(log(1/x)).nseries(x, n=1, logx=y) == loggamma(-y)
+
+    # issue 6725:
+    assert expint(Rational(3, 2), -x)._eval_nseries(x, 5, None) == \
+        2 - 2*x - x**2/3 - x**3/15 - x**4/84 - 2*I*sqrt(pi)*sqrt(x) + O(x**5)
+    assert sin(sqrt(x))._eval_nseries(x, 3, None) == \
+        sqrt(x) - x**Rational(3, 2)/6 + x**Rational(5, 2)/120 + O(x**3)
+
+    # issue 19065:
+    s1 = f(x,y).series(y, n=2)
+    assert {i.name for i in s1.atoms(Symbol)} == {'x', 'xi', 'y'}
+    xi = Symbol('xi')
+    s2 = f(xi, y).series(y, n=2)
+    assert {i.name for i in s2.atoms(Symbol)} == {'xi', 'xi0', 'y'}
+
+def test_doit():
+    n = Symbol('n', integer=True)
+    f = Sum(2 * n * x, (n, 1, 3))
+    d = Derivative(f, x)
+    assert d.doit() == 12
+    assert d.doit(deep=False) == Sum(2*n, (n, 1, 3))
+
+
+def test_evalf_default():
+    from sympy.functions.special.gamma_functions import polygamma
+    assert type(sin(4.0)) == Float
+    assert type(re(sin(I + 1.0))) == Float
+    assert type(im(sin(I + 1.0))) == Float
+    assert type(sin(4)) == sin
+    assert type(polygamma(2.0, 4.0)) == Float
+    assert type(sin(Rational(1, 4))) == sin
+
+
+def test_issue_5399():
+    args = [x, y, S(2), S.Half]
+
+    def ok(a):
+        """Return True if the input args for diff are ok"""
+        if not a:
+            return False
+        if a[0].is_Symbol is False:
+            return False
+        s_at = [i for i in range(len(a)) if a[i].is_Symbol]
+        n_at = [i for i in range(len(a)) if not a[i].is_Symbol]
+        # every symbol is followed by symbol or int
+        # every number is followed by a symbol
+        return (all(a[i + 1].is_Symbol or a[i + 1].is_Integer
+            for i in s_at if i + 1 < len(a)) and
+            all(a[i + 1].is_Symbol
+            for i in n_at if i + 1 < len(a)))
+    eq = x**10*y**8
+    for a in subsets(args):
+        for v in variations(a, len(a)):
+            if ok(v):
+                eq.diff(*v) # does not raise
+            else:
+                raises(ValueError, lambda: eq.diff(*v))
+
+
+def test_derivative_numerically():
+    z0 = x._random()
+    assert abs(Derivative(sin(x), x).doit_numerically(z0) - cos(z0)) < 1e-15
+
+
+def test_fdiff_argument_index_error():
+    from sympy.core.function import ArgumentIndexError
+
+    class myfunc(Function):
+        nargs = 1  # define since there is no eval routine
+
+        def fdiff(self, idx):
+            raise ArgumentIndexError
+    mf = myfunc(x)
+    assert mf.diff(x) == Derivative(mf, x)
+    raises(TypeError, lambda: myfunc(x, x))
+
+
+def test_deriv_wrt_function():
+    x = f(t)
+    xd = diff(x, t)
+    xdd = diff(xd, t)
+    y = g(t)
+    yd = diff(y, t)
+
+    assert diff(x, t) == xd
+    assert diff(2 * x + 4, t) == 2 * xd
+    assert diff(2 * x + 4 + y, t) == 2 * xd + yd
+    assert diff(2 * x + 4 + y * x, t) == 2 * xd + x * yd + xd * y
+    assert diff(2 * x + 4 + y * x, x) == 2 + y
+    assert (diff(4 * x**2 + 3 * x + x * y, t) == 3 * xd + x * yd + xd * y +
+            8 * x * xd)
+    assert (diff(4 * x**2 + 3 * xd + x * y, t) == 3 * xdd + x * yd + xd * y +
+            8 * x * xd)
+    assert diff(4 * x**2 + 3 * xd + x * y, xd) == 3
+    assert diff(4 * x**2 + 3 * xd + x * y, xdd) == 0
+    assert diff(sin(x), t) == xd * cos(x)
+    assert diff(exp(x), t) == xd * exp(x)
+    assert diff(sqrt(x), t) == xd / (2 * sqrt(x))
+
+
+def test_diff_wrt_value():
+    assert Expr()._diff_wrt is False
+    assert x._diff_wrt is True
+    assert f(x)._diff_wrt is True
+    assert Derivative(f(x), x)._diff_wrt is True
+    assert Derivative(x**2, x)._diff_wrt is False
+
+
+def test_diff_wrt():
+    fx = f(x)
+    dfx = diff(f(x), x)
+    ddfx = diff(f(x), x, x)
+
+    assert diff(sin(fx) + fx**2, fx) == cos(fx) + 2*fx
+    assert diff(sin(dfx) + dfx**2, dfx) == cos(dfx) + 2*dfx
+    assert diff(sin(ddfx) + ddfx**2, ddfx) == cos(ddfx) + 2*ddfx
+    assert diff(fx**2, dfx) == 0
+    assert diff(fx**2, ddfx) == 0
+    assert diff(dfx**2, fx) == 0
+    assert diff(dfx**2, ddfx) == 0
+    assert diff(ddfx**2, dfx) == 0
+
+    assert diff(fx*dfx*ddfx, fx) == dfx*ddfx
+    assert diff(fx*dfx*ddfx, dfx) == fx*ddfx
+    assert diff(fx*dfx*ddfx, ddfx) == fx*dfx
+
+    assert diff(f(x), x).diff(f(x)) == 0
+    assert (sin(f(x)) - cos(diff(f(x), x))).diff(f(x)) == cos(f(x))
+
+    assert diff(sin(fx), fx, x) == diff(sin(fx), x, fx)
+
+    # Chain rule cases
+    assert f(g(x)).diff(x) == \
+        Derivative(g(x), x)*Derivative(f(g(x)), g(x))
+    assert diff(f(g(x), h(y)), x) == \
+        Derivative(g(x), x)*Derivative(f(g(x), h(y)), g(x))
+    assert diff(f(g(x), h(x)), x) == (
+        Derivative(f(g(x), h(x)), g(x))*Derivative(g(x), x) +
+        Derivative(f(g(x), h(x)), h(x))*Derivative(h(x), x))
+    assert f(
+        sin(x)).diff(x) == cos(x)*Subs(Derivative(f(x), x), x, sin(x))
+
+    assert diff(f(g(x)), g(x)) == Derivative(f(g(x)), g(x))
+
+
+def test_diff_wrt_func_subs():
+    assert f(g(x)).diff(x).subs(g, Lambda(x, 2*x)).doit() == f(2*x).diff(x)
+
+
+def test_subs_in_derivative():
+    expr = sin(x*exp(y))
+    u = Function('u')
+    v = Function('v')
+    assert Derivative(expr, y).subs(expr, y) == Derivative(y, y)
+    assert Derivative(expr, y).subs(y, x).doit() == \
+        Derivative(expr, y).doit().subs(y, x)
+    assert Derivative(f(x, y), y).subs(y, x) == Subs(Derivative(f(x, y), y), y, x)
+    assert Derivative(f(x, y), y).subs(x, y) == Subs(Derivative(f(x, y), y), x, y)
+    assert Derivative(f(x, y), y).subs(y, g(x, y)) == Subs(Derivative(f(x, y), y), y, g(x, y)).doit()
+    assert Derivative(f(x, y), y).subs(x, g(x, y)) == Subs(Derivative(f(x, y), y), x, g(x, y))
+    assert Derivative(f(x, y), g(y)).subs(x, g(x, y)) == Derivative(f(g(x, y), y), g(y))
+    assert Derivative(f(u(x), h(y)), h(y)).subs(h(y), g(x, y)) == \
+        Subs(Derivative(f(u(x), h(y)), h(y)), h(y), g(x, y)).doit()
+    assert Derivative(f(x, y), y).subs(y, z) == Derivative(f(x, z), z)
+    assert Derivative(f(x, y), y).subs(y, g(y)) == Derivative(f(x, g(y)), g(y))
+    assert Derivative(f(g(x), h(y)), h(y)).subs(h(y), u(y)) == \
+        Derivative(f(g(x), u(y)), u(y))
+    assert Derivative(f(x, f(x, x)), f(x, x)).subs(
+        f, Lambda((x, y), x + y)) == Subs(
+        Derivative(z + x, z), z, 2*x)
+    assert Subs(Derivative(f(f(x)), x), f, cos).doit() == sin(x)*sin(cos(x))
+    assert Subs(Derivative(f(f(x)), f(x)), f, cos).doit() == -sin(cos(x))
+    # Issue 13791. No comparison (it's a long formula) but this used to raise an exception.
+    assert isinstance(v(x, y, u(x, y)).diff(y).diff(x).diff(y), Expr)
+    # This is also related to issues 13791 and 13795; issue 15190
+    F = Lambda((x, y), exp(2*x + 3*y))
+    abstract = f(x, f(x, x)).diff(x, 2)
+    concrete = F(x, F(x, x)).diff(x, 2)
+    assert (abstract.subs(f, F).doit() - concrete).simplify() == 0
+    # don't introduce a new symbol if not necessary
+    assert x in f(x).diff(x).subs(x, 0).atoms()
+    # case (4)
+    assert Derivative(f(x,f(x,y)), x, y).subs(x, g(y)
+        ) == Subs(Derivative(f(x, f(x, y)), x, y), x, g(y))
+
+    assert Derivative(f(x, x), x).subs(x, 0
+        ) == Subs(Derivative(f(x, x), x), x, 0)
+    # issue 15194
+    assert Derivative(f(y, g(x)), (x, z)).subs(z, x
+        ) == Derivative(f(y, g(x)), (x, x))
+
+    df = f(x).diff(x)
+    assert df.subs(df, 1) is S.One
+    assert df.diff(df) is S.One
+    dxy = Derivative(f(x, y), x, y)
+    dyx = Derivative(f(x, y), y, x)
+    assert dxy.subs(Derivative(f(x, y), y, x), 1) is S.One
+    assert dxy.diff(dyx) is S.One
+    assert Derivative(f(x, y), x, 2, y, 3).subs(
+        dyx, g(x, y)) == Derivative(g(x, y), x, 1, y, 2)
+    assert Derivative(f(x, x - y), y).subs(x, x + y) == Subs(
+        Derivative(f(x, x - y), y), x, x + y)
+
+
+def test_diff_wrt_not_allowed():
+    # issue 7027 included
+    for wrt in (
+            cos(x), re(x), x**2, x*y, 1 + x,
+            Derivative(cos(x), x), Derivative(f(f(x)), x)):
+        raises(ValueError, lambda: diff(f(x), wrt))
+    # if we don't differentiate wrt then don't raise error
+    assert diff(exp(x*y), x*y, 0) == exp(x*y)
+
+
+def test_diff_wrt_intlike():
+    class Two:
+        def __int__(self):
+            return 2
+
+    assert cos(x).diff(x, Two()) == -cos(x)
+
+
+def test_klein_gordon_lagrangian():
+    m = Symbol('m')
+    phi = f(x, t)
+
+    L = -(diff(phi, t)**2 - diff(phi, x)**2 - m**2*phi**2)/2
+    eqna = Eq(
+        diff(L, phi) - diff(L, diff(phi, x), x) - diff(L, diff(phi, t), t), 0)
+    eqnb = Eq(diff(phi, t, t) - diff(phi, x, x) + m**2*phi, 0)
+    assert eqna == eqnb
+
+
+def test_sho_lagrangian():
+    m = Symbol('m')
+    k = Symbol('k')
+    x = f(t)
+
+    L = m*diff(x, t)**2/2 - k*x**2/2
+    eqna = Eq(diff(L, x), diff(L, diff(x, t), t))
+    eqnb = Eq(-k*x, m*diff(x, t, t))
+    assert eqna == eqnb
+
+    assert diff(L, x, t) == diff(L, t, x)
+    assert diff(L, diff(x, t), t) == m*diff(x, t, 2)
+    assert diff(L, t, diff(x, t)) == -k*x + m*diff(x, t, 2)
+
+
+def test_straight_line():
+    F = f(x)
+    Fd = F.diff(x)
+    L = sqrt(1 + Fd**2)
+    assert diff(L, F) == 0
+    assert diff(L, Fd) == Fd/sqrt(1 + Fd**2)
+
+
+def test_sort_variable():
+    vsort = Derivative._sort_variable_count
+    def vsort0(*v, reverse=False):
+        return [i[0] for i in vsort([(i, 0) for i in (
+            reversed(v) if reverse else v)])]
+
+    for R in range(2):
+        assert vsort0(y, x, reverse=R) == [x, y]
+        assert vsort0(f(x), x, reverse=R) == [x, f(x)]
+        assert vsort0(f(y), f(x), reverse=R) == [f(x), f(y)]
+        assert vsort0(g(x), f(y), reverse=R) == [f(y), g(x)]
+        assert vsort0(f(x, y), f(x), reverse=R) == [f(x), f(x, y)]
+        fx = f(x).diff(x)
+        assert vsort0(fx, y, reverse=R) == [y, fx]
+        fy = f(y).diff(y)
+        assert vsort0(fy, fx, reverse=R) == [fx, fy]
+        fxx = fx.diff(x)
+        assert vsort0(fxx, fx, reverse=R) == [fx, fxx]
+        assert vsort0(Basic(x), f(x), reverse=R) == [f(x), Basic(x)]
+        assert vsort0(Basic(y), Basic(x), reverse=R) == [Basic(x), Basic(y)]
+        assert vsort0(Basic(y, z), Basic(x), reverse=R) == [
+            Basic(x), Basic(y, z)]
+        assert vsort0(fx, x, reverse=R) == [
+            x, fx] if R else [fx, x]
+        assert vsort0(Basic(x), x, reverse=R) == [
+            x, Basic(x)] if R else [Basic(x), x]
+        assert vsort0(Basic(f(x)), f(x), reverse=R) == [
+            f(x), Basic(f(x))] if R else [Basic(f(x)), f(x)]
+        assert vsort0(Basic(x, z), Basic(x), reverse=R) == [
+            Basic(x), Basic(x, z)] if R else [Basic(x, z), Basic(x)]
+    assert vsort([]) == []
+    assert _aresame(vsort([(x, 1)]), [Tuple(x, 1)])
+    assert vsort([(x, y), (x, z)]) == [(x, y + z)]
+    assert vsort([(y, 1), (x, 1 + y)]) == [(x, 1 + y), (y, 1)]
+    # coverage complete; legacy tests below
+    assert vsort([(x, 3), (y, 2), (z, 1)]) == [(x, 3), (y, 2), (z, 1)]
+    assert vsort([(h(x), 1), (g(x), 1), (f(x), 1)]) == [
+        (f(x), 1), (g(x), 1), (h(x), 1)]
+    assert vsort([(z, 1), (y, 2), (x, 3), (h(x), 1), (g(x), 1),
+        (f(x), 1)]) == [(x, 3), (y, 2), (z, 1), (f(x), 1), (g(x), 1),
+        (h(x), 1)]
+    assert vsort([(x, 1), (f(x), 1), (y, 1), (f(y), 1)]) == [(x, 1),
+        (y, 1), (f(x), 1), (f(y), 1)]
+    assert vsort([(y, 1), (x, 2), (g(x), 1), (f(x), 1), (z, 1),
+        (h(x), 1), (y, 2), (x, 1)]) == [(x, 3), (y, 3), (z, 1),
+        (f(x), 1), (g(x), 1), (h(x), 1)]
+    assert vsort([(z, 1), (y, 1), (f(x), 1), (x, 1), (f(x), 1),
+        (g(x), 1)]) == [(x, 1), (y, 1), (z, 1), (f(x), 2), (g(x), 1)]
+    assert vsort([(z, 1), (y, 2), (f(x), 1), (x, 2), (f(x), 2),
+        (g(x), 1), (z, 2), (z, 1), (y, 1), (x, 1)]) == [(x, 3), (y, 3),
+        (z, 4), (f(x), 3), (g(x), 1)]
+    assert vsort(((y, 2), (x, 1), (y, 1), (x, 1))) == [(x, 2), (y, 3)]
+    assert isinstance(vsort([(x, 3), (y, 2), (z, 1)])[0], Tuple)
+    assert vsort([(x, 1), (f(x), 1), (x, 1)]) == [(x, 2), (f(x), 1)]
+    assert vsort([(y, 2), (x, 3), (z, 1)]) == [(x, 3), (y, 2), (z, 1)]
+    assert vsort([(h(y), 1), (g(x), 1), (f(x), 1)]) == [
+        (f(x), 1), (g(x), 1), (h(y), 1)]
+    assert vsort([(x, 1), (y, 1), (x, 1)]) == [(x, 2), (y, 1)]
+    assert vsort([(f(x), 1), (f(y), 1), (f(x), 1)]) == [
+        (f(x), 2), (f(y), 1)]
+    dfx = f(x).diff(x)
+    self = [(dfx, 1), (x, 1)]
+    assert vsort(self) == self
+    assert vsort([
+        (dfx, 1), (y, 1), (f(x), 1), (x, 1), (f(y), 1), (x, 1)]) == [
+        (y, 1), (f(x), 1), (f(y), 1), (dfx, 1), (x, 2)]
+    dfy = f(y).diff(y)
+    assert vsort([(dfy, 1), (dfx, 1)]) == [(dfx, 1), (dfy, 1)]
+    d2fx = dfx.diff(x)
+    assert vsort([(d2fx, 1), (dfx, 1)]) == [(dfx, 1), (d2fx, 1)]
+
+
+def test_multiple_derivative():
+    # Issue #15007
+    assert f(x, y).diff(y, y, x, y, x
+        ) == Derivative(f(x, y), (x, 2), (y, 3))
+
+
+def test_unhandled():
+    class MyExpr(Expr):
+        def _eval_derivative(self, s):
+            if not s.name.startswith('xi'):
+                return self
+            else:
+                return None
+
+    eq = MyExpr(f(x), y, z)
+    assert diff(eq, x, y, f(x), z) == Derivative(eq, f(x))
+    assert diff(eq, f(x), x) == Derivative(eq, f(x))
+    assert f(x, y).diff(x,(y, z)) == Derivative(f(x, y), x, (y, z))
+    assert f(x, y).diff(x,(y, 0)) == Derivative(f(x, y), x)
+
+
+def test_nfloat():
+    from sympy.core.basic import _aresame
+    from sympy.polys.rootoftools import rootof
+
+    x = Symbol("x")
+    eq = x**Rational(4, 3) + 4*x**(S.One/3)/3
+    assert _aresame(nfloat(eq), x**Rational(4, 3) + (4.0/3)*x**(S.One/3))
+    assert _aresame(nfloat(eq, exponent=True), x**(4.0/3) + (4.0/3)*x**(1.0/3))
+    eq = x**Rational(4, 3) + 4*x**(x/3)/3
+    assert _aresame(nfloat(eq), x**Rational(4, 3) + (4.0/3)*x**(x/3))
+    big = 12345678901234567890
+    # specify precision to match value used in nfloat
+    Float_big = Float(big, 15)
+    assert _aresame(nfloat(big), Float_big)
+    assert _aresame(nfloat(big*x), Float_big*x)
+    assert _aresame(nfloat(x**big, exponent=True), x**Float_big)
+    assert nfloat(cos(x + sqrt(2))) == cos(x + nfloat(sqrt(2)))
+
+    # issue 6342
+    f = S('x*lamda + lamda**3*(x/2 + 1/2) + lamda**2 + 1/4')
+    assert not any(a.free_symbols for a in solveset(f.subs(x, -0.139)))
+
+    # issue 6632
+    assert nfloat(-100000*sqrt(2500000001) + 5000000001) == \
+        9.99999999800000e-11
+
+    # issue 7122
+    eq = cos(3*x**4 + y)*rootof(x**5 + 3*x**3 + 1, 0)
+    assert str(nfloat(eq, exponent=False, n=1)) == '-0.7*cos(3.0*x**4 + y)'
+
+    # issue 10933
+    for ti in (dict, Dict):
+        d = ti({S.Half: S.Half})
+        n = nfloat(d)
+        assert isinstance(n, ti)
+        assert _aresame(list(n.items()).pop(), (S.Half, Float(.5)))
+    for ti in (dict, Dict):
+        d = ti({S.Half: S.Half})
+        n = nfloat(d, dkeys=True)
+        assert isinstance(n, ti)
+        assert _aresame(list(n.items()).pop(), (Float(.5), Float(.5)))
+    d = [S.Half]
+    n = nfloat(d)
+    assert type(n) is list
+    assert _aresame(n[0], Float(.5))
+    assert _aresame(nfloat(Eq(x, S.Half)).rhs, Float(.5))
+    assert _aresame(nfloat(S(True)), S(True))
+    assert _aresame(nfloat(Tuple(S.Half))[0], Float(.5))
+    assert nfloat(Eq((3 - I)**2/2 + I, 0)) == S.false
+    # pass along kwargs
+    assert nfloat([{S.Half: x}], dkeys=True) == [{Float(0.5): x}]
+
+    # Issue 17706
+    A = MutableMatrix([[1, 2], [3, 4]])
+    B = MutableMatrix(
+        [[Float('1.0', precision=53), Float('2.0', precision=53)],
+        [Float('3.0', precision=53), Float('4.0', precision=53)]])
+    assert _aresame(nfloat(A), B)
+    A = ImmutableMatrix([[1, 2], [3, 4]])
+    B = ImmutableMatrix(
+        [[Float('1.0', precision=53), Float('2.0', precision=53)],
+        [Float('3.0', precision=53), Float('4.0', precision=53)]])
+    assert _aresame(nfloat(A), B)
+
+    # issue 22524
+    f = Function('f')
+    assert not nfloat(f(2)).atoms(Float)
+
+
+def test_issue_7068():
+    from sympy.abc import a, b
+    f = Function('f')
+    y1 = Dummy('y')
+    y2 = Dummy('y')
+    func1 = f(a + y1 * b)
+    func2 = f(a + y2 * b)
+    func1_y = func1.diff(y1)
+    func2_y = func2.diff(y2)
+    assert func1_y != func2_y
+    z1 = Subs(f(a), a, y1)
+    z2 = Subs(f(a), a, y2)
+    assert z1 != z2
+
+
+def test_issue_7231():
+    from sympy.abc import a
+    ans1 = f(x).series(x, a)
+    res = (f(a) + (-a + x)*Subs(Derivative(f(y), y), y, a) +
+           (-a + x)**2*Subs(Derivative(f(y), y, y), y, a)/2 +
+           (-a + x)**3*Subs(Derivative(f(y), y, y, y),
+                            y, a)/6 +
+           (-a + x)**4*Subs(Derivative(f(y), y, y, y, y),
+                            y, a)/24 +
+           (-a + x)**5*Subs(Derivative(f(y), y, y, y, y, y),
+                            y, a)/120 + O((-a + x)**6, (x, a)))
+    assert res == ans1
+    ans2 = f(x).series(x, a)
+    assert res == ans2
+
+
+def test_issue_7687():
+    from sympy.core.function import Function
+    from sympy.abc import x
+    f = Function('f')(x)
+    ff = Function('f')(x)
+    match_with_cache = ff.matches(f)
+    assert isinstance(f, type(ff))
+    clear_cache()
+    ff = Function('f')(x)
+    assert isinstance(f, type(ff))
+    assert match_with_cache == ff.matches(f)
+
+
+def test_issue_7688():
+    from sympy.core.function import Function, UndefinedFunction
+
+    f = Function('f')  # actually an UndefinedFunction
+    clear_cache()
+    class A(UndefinedFunction):
+        pass
+    a = A('f')
+    assert isinstance(a, type(f))
+
+
+def test_mexpand():
+    from sympy.abc import x
+    assert _mexpand(None) is None
+    assert _mexpand(1) is S.One
+    assert _mexpand(x*(x + 1)**2) == (x*(x + 1)**2).expand()
+
+
+def test_issue_8469():
+    # This should not take forever to run
+    N = 40
+    def g(w, theta):
+        return 1/(1+exp(w-theta))
+
+    ws = symbols(['w%i'%i for i in range(N)])
+    import functools
+    expr = functools.reduce(g, ws)
+    assert isinstance(expr, Pow)
+
+
+def test_issue_12996():
+    # foo=True imitates the sort of arguments that Derivative can get
+    # from Integral when it passes doit to the expression
+    assert Derivative(im(x), x).doit(foo=True) == Derivative(im(x), x)
+
+
+def test_should_evalf():
+    # This should not take forever to run (see #8506)
+    assert isinstance(sin((1.0 + 1.0*I)**10000 + 1), sin)
+
+
+def test_Derivative_as_finite_difference():
+    # Central 1st derivative at gridpoint
+    x, h = symbols('x h', real=True)
+    dfdx = f(x).diff(x)
+    assert (dfdx.as_finite_difference([x-2, x-1, x, x+1, x+2]) -
+            (S.One/12*(f(x-2)-f(x+2)) + Rational(2, 3)*(f(x+1)-f(x-1)))).simplify() == 0
+
+    # Central 1st derivative "half-way"
+    assert (dfdx.as_finite_difference() -
+            (f(x + S.Half)-f(x - S.Half))).simplify() == 0
+    assert (dfdx.as_finite_difference(h) -
+            (f(x + h/S(2))-f(x - h/S(2)))/h).simplify() == 0
+    assert (dfdx.as_finite_difference([x - 3*h, x-h, x+h, x + 3*h]) -
+            (S(9)/(8*2*h)*(f(x+h) - f(x-h)) +
+             S.One/(24*2*h)*(f(x - 3*h) - f(x + 3*h)))).simplify() == 0
+
+    # One sided 1st derivative at gridpoint
+    assert (dfdx.as_finite_difference([0, 1, 2], 0) -
+            (Rational(-3, 2)*f(0) + 2*f(1) - f(2)/2)).simplify() == 0
+    assert (dfdx.as_finite_difference([x, x+h], x) -
+            (f(x+h) - f(x))/h).simplify() == 0
+    assert (dfdx.as_finite_difference([x-h, x, x+h], x-h) -
+            (-S(3)/(2*h)*f(x-h) + 2/h*f(x) -
+             S.One/(2*h)*f(x+h))).simplify() == 0
+
+    # One sided 1st derivative "half-way"
+    assert (dfdx.as_finite_difference([x-h, x+h, x + 3*h, x + 5*h, x + 7*h])
+            - 1/(2*h)*(-S(11)/(12)*f(x-h) + S(17)/(24)*f(x+h)
+                       + Rational(3, 8)*f(x + 3*h) - Rational(5, 24)*f(x + 5*h)
+                       + S.One/24*f(x + 7*h))).simplify() == 0
+
+    d2fdx2 = f(x).diff(x, 2)
+    # Central 2nd derivative at gridpoint
+    assert (d2fdx2.as_finite_difference([x-h, x, x+h]) -
+            h**-2 * (f(x-h) + f(x+h) - 2*f(x))).simplify() == 0
+
+    assert (d2fdx2.as_finite_difference([x - 2*h, x-h, x, x+h, x + 2*h]) -
+            h**-2 * (Rational(-1, 12)*(f(x - 2*h) + f(x + 2*h)) +
+                     Rational(4, 3)*(f(x+h) + f(x-h)) - Rational(5, 2)*f(x))).simplify() == 0
+
+    # Central 2nd derivative "half-way"
+    assert (d2fdx2.as_finite_difference([x - 3*h, x-h, x+h, x + 3*h]) -
+            (2*h)**-2 * (S.Half*(f(x - 3*h) + f(x + 3*h)) -
+                         S.Half*(f(x+h) + f(x-h)))).simplify() == 0
+
+    # One sided 2nd derivative at gridpoint
+    assert (d2fdx2.as_finite_difference([x, x+h, x + 2*h, x + 3*h]) -
+            h**-2 * (2*f(x) - 5*f(x+h) +
+                     4*f(x+2*h) - f(x+3*h))).simplify() == 0
+
+    # One sided 2nd derivative at "half-way"
+    assert (d2fdx2.as_finite_difference([x-h, x+h, x + 3*h, x + 5*h]) -
+            (2*h)**-2 * (Rational(3, 2)*f(x-h) - Rational(7, 2)*f(x+h) + Rational(5, 2)*f(x + 3*h) -
+                         S.Half*f(x + 5*h))).simplify() == 0
+
+    d3fdx3 = f(x).diff(x, 3)
+    # Central 3rd derivative at gridpoint
+    assert (d3fdx3.as_finite_difference() -
+            (-f(x - Rational(3, 2)) + 3*f(x - S.Half) -
+             3*f(x + S.Half) + f(x + Rational(3, 2)))).simplify() == 0
+
+    assert (d3fdx3.as_finite_difference(
+        [x - 3*h, x - 2*h, x-h, x, x+h, x + 2*h, x + 3*h]) -
+        h**-3 * (S.One/8*(f(x - 3*h) - f(x + 3*h)) - f(x - 2*h) +
+                 f(x + 2*h) + Rational(13, 8)*(f(x-h) - f(x+h)))).simplify() == 0
+
+    # Central 3rd derivative at "half-way"
+    assert (d3fdx3.as_finite_difference([x - 3*h, x-h, x+h, x + 3*h]) -
+            (2*h)**-3 * (f(x + 3*h)-f(x - 3*h) +
+                         3*(f(x-h)-f(x+h)))).simplify() == 0
+
+    # One sided 3rd derivative at gridpoint
+    assert (d3fdx3.as_finite_difference([x, x+h, x + 2*h, x + 3*h]) -
+            h**-3 * (f(x + 3*h)-f(x) + 3*(f(x+h)-f(x + 2*h)))).simplify() == 0
+
+    # One sided 3rd derivative at "half-way"
+    assert (d3fdx3.as_finite_difference([x-h, x+h, x + 3*h, x + 5*h]) -
+            (2*h)**-3 * (f(x + 5*h)-f(x-h) +
+                         3*(f(x+h)-f(x + 3*h)))).simplify() == 0
+
+    # issue 11007
+    y = Symbol('y', real=True)
+    d2fdxdy = f(x, y).diff(x, y)
+
+    ref0 = Derivative(f(x + S.Half, y), y) - Derivative(f(x - S.Half, y), y)
+    assert (d2fdxdy.as_finite_difference(wrt=x) - ref0).simplify() == 0
+
+    half = S.Half
+    xm, xp, ym, yp = x-half, x+half, y-half, y+half
+    ref2 = f(xm, ym) + f(xp, yp) - f(xp, ym) - f(xm, yp)
+    assert (d2fdxdy.as_finite_difference() - ref2).simplify() == 0
+
+
+def test_issue_11159():
+    # Tests Application._eval_subs
+    with _exp_is_pow(False):
+        expr1 = E
+        expr0 = expr1 * expr1
+        expr1 = expr0.subs(expr1,expr0)
+        assert expr0 == expr1
+    with _exp_is_pow(True):
+        expr1 = E
+        expr0 = expr1 * expr1
+        expr2 = expr0.subs(expr1, expr0)
+        assert expr2 == E ** 4
+
+
+def test_issue_12005():
+    e1 = Subs(Derivative(f(x), x), x, x)
+    assert e1.diff(x) == Derivative(f(x), x, x)
+    e2 = Subs(Derivative(f(x), x), x, x**2 + 1)
+    assert e2.diff(x) == 2*x*Subs(Derivative(f(x), x, x), x, x**2 + 1)
+    e3 = Subs(Derivative(f(x) + y**2 - y, y), y, y**2)
+    assert e3.diff(y) == 4*y
+    e4 = Subs(Derivative(f(x + y), y), y, (x**2))
+    assert e4.diff(y) is S.Zero
+    e5 = Subs(Derivative(f(x), x), (y, z), (y, z))
+    assert e5.diff(x) == Derivative(f(x), x, x)
+    assert f(g(x)).diff(g(x), g(x)) == Derivative(f(g(x)), g(x), g(x))
+
+
+def test_issue_13843():
+    x = symbols('x')
+    f = Function('f')
+    m, n = symbols('m n', integer=True)
+    assert Derivative(Derivative(f(x), (x, m)), (x, n)) == Derivative(f(x), (x, m + n))
+    assert Derivative(Derivative(f(x), (x, m+5)), (x, n+3)) == Derivative(f(x), (x, m + n + 8))
+
+    assert Derivative(f(x), (x, n)).doit() == Derivative(f(x), (x, n))
+
+
+def test_order_could_be_zero():
+    x, y = symbols('x, y')
+    n = symbols('n', integer=True, nonnegative=True)
+    m = symbols('m', integer=True, positive=True)
+    assert diff(y, (x, n)) == Piecewise((y, Eq(n, 0)), (0, True))
+    assert diff(y, (x, n + 1)) is S.Zero
+    assert diff(y, (x, m)) is S.Zero
+
+
+def test_undefined_function_eq():
+    f = Function('f')
+    f2 = Function('f')
+    g = Function('g')
+    f_real = Function('f', is_real=True)
+
+    # This test may only be meaningful if the cache is turned off
+    assert f == f2
+    assert hash(f) == hash(f2)
+    assert f == f
+
+    assert f != g
+
+    assert f != f_real
+
+
+def test_function_assumptions():
+    x = Symbol('x')
+    f = Function('f')
+    f_real = Function('f', real=True)
+    f_real1 = Function('f', real=1)
+    f_real_inherit = Function(Symbol('f', real=True))
+
+    assert f_real == f_real1  # assumptions are sanitized
+    assert f != f_real
+    assert f(x) != f_real(x)
+
+    assert f(x).is_real is None
+    assert f_real(x).is_real is True
+    assert f_real_inherit(x).is_real is True and f_real_inherit.name == 'f'
+
+    # Can also do it this way, but it won't be equal to f_real because of the
+    # way UndefinedFunction.__new__ works. Any non-recognized assumptions
+    # are just added literally as something which is used in the hash
+    f_real2 = Function('f', is_real=True)
+    assert f_real2(x).is_real is True
+
+
+def test_undef_fcn_float_issue_6938():
+    f = Function('ceil')
+    assert not f(0.3).is_number
+    f = Function('sin')
+    assert not f(0.3).is_number
+    assert not f(pi).evalf().is_number
+    x = Symbol('x')
+    assert not f(x).evalf(subs={x:1.2}).is_number
+
+
+def test_undefined_function_eval():
+    # Issue 15170. Make sure UndefinedFunction with eval defined works
+    # properly.
+
+    fdiff = lambda self, argindex=1: cos(self.args[argindex - 1])
+    eval = classmethod(lambda cls, t: None)
+    _imp_ = classmethod(lambda cls, t: sin(t))
+
+    temp = Function('temp', fdiff=fdiff, eval=eval, _imp_=_imp_)
+
+    expr = temp(t)
+    assert sympify(expr) == expr
+    assert type(sympify(expr)).fdiff.__name__ == ""
+    assert expr.diff(t) == cos(t)
+
+
+def test_issue_15241():
+    F = f(x)
+    Fx = F.diff(x)
+    assert (F + x*Fx).diff(x, Fx) == 2
+    assert (F + x*Fx).diff(Fx, x) == 1
+    assert (x*F + x*Fx*F).diff(F, x) == x*Fx.diff(x) + Fx + 1
+    assert (x*F + x*Fx*F).diff(x, F) == x*Fx.diff(x) + Fx + 1
+    y = f(x)
+    G = f(y)
+    Gy = G.diff(y)
+    assert (G + y*Gy).diff(y, Gy) == 2
+    assert (G + y*Gy).diff(Gy, y) == 1
+    assert (y*G + y*Gy*G).diff(G, y) == y*Gy.diff(y) + Gy + 1
+    assert (y*G + y*Gy*G).diff(y, G) == y*Gy.diff(y) + Gy + 1
+
+
+def test_issue_15226():
+    assert Subs(Derivative(f(y), x, y), y, g(x)).doit() != 0
+
+
+def test_issue_7027():
+    for wrt in (cos(x), re(x), Derivative(cos(x), x)):
+        raises(ValueError, lambda: diff(f(x), wrt))
+
+
+def test_derivative_quick_exit():
+    assert f(x).diff(y) == 0
+    assert f(x).diff(y, f(x)) == 0
+    assert f(x).diff(x, f(y)) == 0
+    assert f(f(x)).diff(x, f(x), f(y)) == 0
+    assert f(f(x)).diff(x, f(x), y) == 0
+    assert f(x).diff(g(x)) == 0
+    assert f(x).diff(x, f(x).diff(x)) == 1
+    df = f(x).diff(x)
+    assert f(x).diff(df) == 0
+    dg = g(x).diff(x)
+    assert dg.diff(df).doit() == 0
+
+
+def test_issue_15084_13166():
+    eq = f(x, g(x))
+    assert eq.diff((g(x), y)) == Derivative(f(x, g(x)), (g(x), y))
+    # issue 13166
+    assert eq.diff(x, 2).doit() == (
+        (Derivative(f(x, g(x)), (g(x), 2))*Derivative(g(x), x) +
+        Subs(Derivative(f(x, _xi_2), _xi_2, x), _xi_2, g(x)))*Derivative(g(x),
+        x) + Derivative(f(x, g(x)), g(x))*Derivative(g(x), (x, 2)) +
+        Derivative(g(x), x)*Subs(Derivative(f(_xi_1, g(x)), _xi_1, g(x)),
+        _xi_1, x) + Subs(Derivative(f(_xi_1, g(x)), (_xi_1, 2)), _xi_1, x))
+    # issue 6681
+    assert diff(f(x, t, g(x, t)), x).doit() == (
+        Derivative(f(x, t, g(x, t)), g(x, t))*Derivative(g(x, t), x) +
+        Subs(Derivative(f(_xi_1, t, g(x, t)), _xi_1), _xi_1, x))
+    # make sure the order doesn't matter when using diff
+    assert eq.diff(x, g(x)) == eq.diff(g(x), x)
+
+
+def test_negative_counts():
+    # issue 13873
+    raises(ValueError, lambda: sin(x).diff(x, -1))
+
+
+def test_Derivative__new__():
+    raises(TypeError, lambda: f(x).diff((x, 2), 0))
+    assert f(x, y).diff([(x, y), 0]) == f(x, y)
+    assert f(x, y).diff([(x, y), 1]) == NDimArray([
+        Derivative(f(x, y), x), Derivative(f(x, y), y)])
+    assert f(x,y).diff(y, (x, z), y, x) == Derivative(
+        f(x, y), (x, z + 1), (y, 2))
+    assert Matrix([x]).diff(x, 2) == Matrix([0])  # is_zero exit
+
+
+def test_issue_14719_10150():
+    class V(Expr):
+        _diff_wrt = True
+        is_scalar = False
+    assert V().diff(V()) == Derivative(V(), V())
+    assert (2*V()).diff(V()) == 2*Derivative(V(), V())
+    class X(Expr):
+        _diff_wrt = True
+    assert X().diff(X()) == 1
+    assert (2*X()).diff(X()) == 2
+
+
+def test_noncommutative_issue_15131():
+    x = Symbol('x', commutative=False)
+    t = Symbol('t', commutative=False)
+    fx = Function('Fx', commutative=False)(x)
+    ft = Function('Ft', commutative=False)(t)
+    A = Symbol('A', commutative=False)
+    eq = fx * A * ft
+    eqdt = eq.diff(t)
+    assert eqdt.args[-1] == ft.diff(t)
+
+
+def test_Subs_Derivative():
+    a = Derivative(f(g(x), h(x)), g(x), h(x),x)
+    b = Derivative(Derivative(f(g(x), h(x)), g(x), h(x)),x)
+    c = f(g(x), h(x)).diff(g(x), h(x), x)
+    d = f(g(x), h(x)).diff(g(x), h(x)).diff(x)
+    e = Derivative(f(g(x), h(x)), x)
+    eqs = (a, b, c, d, e)
+    subs = lambda arg: arg.subs(f, Lambda((x, y), exp(x + y))
+        ).subs(g(x), 1/x).subs(h(x), x**3)
+    ans = 3*x**2*exp(1/x)*exp(x**3) - exp(1/x)*exp(x**3)/x**2
+    assert all(subs(i).doit().expand() == ans for i in eqs)
+    assert all(subs(i.doit()).doit().expand() == ans for i in eqs)
+
+def test_issue_15360():
+    f = Function('f')
+    assert f.name == 'f'
+
+
+def test_issue_15947():
+    assert f._diff_wrt is False
+    raises(TypeError, lambda: f(f))
+    raises(TypeError, lambda: f(x).diff(f))
+
+
+def test_Derivative_free_symbols():
+    f = Function('f')
+    n = Symbol('n', integer=True, positive=True)
+    assert diff(f(x), (x, n)).free_symbols == {n, x}
+
+
+def test_issue_20683():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+    y = Derivative(z, x).subs(x,0)
+    assert y.doit() == 0
+    y = Derivative(8, x).subs(x,0)
+    assert y.doit() == 0
+
+
+def test_issue_10503():
+    f = exp(x**3)*cos(x**6)
+    assert f.series(x, 0, 14) == 1 + x**3 + x**6/2 + x**9/6 - 11*x**12/24 + O(x**14)
+
+
+def test_issue_17382():
+    # copied from sympy/core/tests/test_evalf.py
+    def NS(e, n=15, **options):
+        return sstr(sympify(e).evalf(n, **options), full_prec=True)
+
+    x = Symbol('x')
+    expr = solveset(2 * cos(x) * cos(2 * x) - 1, x, S.Reals)
+    expected = "Union(" \
+               "ImageSet(Lambda(_n, 6.28318530717959*_n + 5.79812359592087), Integers), " \
+               "ImageSet(Lambda(_n, 6.28318530717959*_n + 0.485061711258717), Integers))"
+    assert NS(expr) == expected
+
+def test_eval_sympified():
+    # Check both arguments and return types from eval are sympified
+
+    class F(Function):
+        @classmethod
+        def eval(cls, x):
+            assert x is S.One
+            return 1
+
+    assert F(1) is S.One
+
+    # String arguments are not allowed
+    class F2(Function):
+        @classmethod
+        def eval(cls, x):
+            if x == 0:
+                return '1'
+
+    raises(SympifyError, lambda: F2(0))
+    F2(1) # Doesn't raise
+
+    # TODO: Disable string inputs (https://github.com/sympy/sympy/issues/11003)
+    # raises(SympifyError, lambda: F2('2'))
+
+def test_eval_classmethod_check():
+    with raises(TypeError):
+        class F(Function):
+            def eval(self, x):
+                pass
+
+
+def test_issue_27163():
+    # https://github.com/sympy/sympy/issues/27163
+    raises(TypeError, lambda: Derivative(f, t))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_kind.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_kind.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbfdffb9304b49488756752ca198fd4067087437
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_kind.py
@@ -0,0 +1,57 @@
+from sympy.core.add import Add
+from sympy.core.kind import NumberKind, UndefinedKind
+from sympy.core.mul import Mul
+from sympy.core.numbers import pi, zoo, I, AlgebraicNumber
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.integrals.integrals import Integral
+from sympy.core.function import Derivative
+from sympy.matrices import (Matrix, SparseMatrix, ImmutableMatrix,
+    ImmutableSparseMatrix, MatrixSymbol, MatrixKind, MatMul)
+
+comm_x = Symbol('x')
+noncomm_x = Symbol('x', commutative=False)
+
+def test_NumberKind():
+    assert S.One.kind is NumberKind
+    assert pi.kind is NumberKind
+    assert S.NaN.kind is NumberKind
+    assert zoo.kind is NumberKind
+    assert I.kind is NumberKind
+    assert AlgebraicNumber(1).kind is NumberKind
+
+def test_Add_kind():
+    assert Add(2, 3, evaluate=False).kind is NumberKind
+    assert Add(2,comm_x).kind is NumberKind
+    assert Add(2,noncomm_x).kind is UndefinedKind
+
+def test_mul_kind():
+    assert Mul(2,comm_x, evaluate=False).kind is NumberKind
+    assert Mul(2,3, evaluate=False).kind is NumberKind
+    assert Mul(noncomm_x,2, evaluate=False).kind is UndefinedKind
+    assert Mul(2,noncomm_x, evaluate=False).kind is UndefinedKind
+
+def test_Symbol_kind():
+    assert comm_x.kind is NumberKind
+    assert noncomm_x.kind is UndefinedKind
+
+def test_Integral_kind():
+    A = MatrixSymbol('A', 2,2)
+    assert Integral(comm_x, comm_x).kind is NumberKind
+    assert Integral(A, comm_x).kind is MatrixKind(NumberKind)
+
+def test_Derivative_kind():
+    A = MatrixSymbol('A', 2,2)
+    assert Derivative(comm_x, comm_x).kind is NumberKind
+    assert Derivative(A, comm_x).kind is MatrixKind(NumberKind)
+
+def test_Matrix_kind():
+    classes = (Matrix, SparseMatrix, ImmutableMatrix, ImmutableSparseMatrix)
+    for cls in classes:
+        m = cls.zeros(3, 2)
+        assert m.kind is MatrixKind(NumberKind)
+
+def test_MatMul_kind():
+    M = Matrix([[1,2],[3,4]])
+    assert MatMul(2, M).kind is MatrixKind(NumberKind)
+    assert MatMul(comm_x, M).kind is MatrixKind(NumberKind)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_logic.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_logic.py
new file mode 100644
index 0000000000000000000000000000000000000000..df5647f32ea7c4e326eb4e3aec6a7b2987f32aee
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_logic.py
@@ -0,0 +1,198 @@
+from sympy.core.logic import (fuzzy_not, Logic, And, Or, Not, fuzzy_and,
+    fuzzy_or, _fuzzy_group, _torf, fuzzy_nand, fuzzy_xor)
+from sympy.testing.pytest import raises
+
+from itertools import product
+
+T = True
+F = False
+U = None
+
+
+
+def test_torf():
+    v = [T, F, U]
+    for i in product(*[v]*3):
+        assert _torf(i) is (True if all(j for j in i) else
+                            (False if all(j is False for j in i) else None))
+
+
+def test_fuzzy_group():
+    v = [T, F, U]
+    for i in product(*[v]*3):
+        assert _fuzzy_group(i) is (None if None in i else
+                                   (True if all(j for j in i) else False))
+        assert _fuzzy_group(i, quick_exit=True) is \
+            (None if (i.count(False) > 1) else
+             (None if None in i else (True if all(j for j in i) else False)))
+    it = (True if (i == 0) else None for i in range(2))
+    assert _torf(it) is None
+    it = (True if (i == 1) else None for i in range(2))
+    assert _torf(it) is None
+
+
+def test_fuzzy_not():
+    assert fuzzy_not(T) == F
+    assert fuzzy_not(F) == T
+    assert fuzzy_not(U) == U
+
+
+def test_fuzzy_and():
+    assert fuzzy_and([T, T]) == T
+    assert fuzzy_and([T, F]) == F
+    assert fuzzy_and([T, U]) == U
+    assert fuzzy_and([F, F]) == F
+    assert fuzzy_and([F, U]) == F
+    assert fuzzy_and([U, U]) == U
+    assert [fuzzy_and([w]) for w in [U, T, F]] == [U, T, F]
+    assert fuzzy_and([T, F, U]) == F
+    assert fuzzy_and([]) == T
+    raises(TypeError, lambda: fuzzy_and())
+
+
+def test_fuzzy_or():
+    assert fuzzy_or([T, T]) == T
+    assert fuzzy_or([T, F]) == T
+    assert fuzzy_or([T, U]) == T
+    assert fuzzy_or([F, F]) == F
+    assert fuzzy_or([F, U]) == U
+    assert fuzzy_or([U, U]) == U
+    assert [fuzzy_or([w]) for w in [U, T, F]] == [U, T, F]
+    assert fuzzy_or([T, F, U]) == T
+    assert fuzzy_or([]) == F
+    raises(TypeError, lambda: fuzzy_or())
+
+
+def test_logic_cmp():
+    l1 = And('a', Not('b'))
+    l2 = And('a', Not('b'))
+
+    assert hash(l1) == hash(l2)
+    assert (l1 == l2) == T
+    assert (l1 != l2) == F
+
+    assert And('a', 'b', 'c') == And('b', 'a', 'c')
+    assert And('a', 'b', 'c') == And('c', 'b', 'a')
+    assert And('a', 'b', 'c') == And('c', 'a', 'b')
+
+    assert Not('a') < Not('b')
+    assert (Not('b') < Not('a')) is False
+    assert (Not('a') < 2) is False
+
+
+def test_logic_onearg():
+    assert And() is True
+    assert Or() is False
+
+    assert And(T) == T
+    assert And(F) == F
+    assert Or(T) == T
+    assert Or(F) == F
+
+    assert And('a') == 'a'
+    assert Or('a') == 'a'
+
+
+def test_logic_xnotx():
+    assert And('a', Not('a')) == F
+    assert Or('a', Not('a')) == T
+
+
+def test_logic_eval_TF():
+    assert And(F, F) == F
+    assert And(F, T) == F
+    assert And(T, F) == F
+    assert And(T, T) == T
+
+    assert Or(F, F) == F
+    assert Or(F, T) == T
+    assert Or(T, F) == T
+    assert Or(T, T) == T
+
+    assert And('a', T) == 'a'
+    assert And('a', F) == F
+    assert Or('a', T) == T
+    assert Or('a', F) == 'a'
+
+
+def test_logic_combine_args():
+    assert And('a', 'b', 'a') == And('a', 'b')
+    assert Or('a', 'b', 'a') == Or('a', 'b')
+
+    assert And(And('a', 'b'), And('c', 'd')) == And('a', 'b', 'c', 'd')
+    assert Or(Or('a', 'b'), Or('c', 'd')) == Or('a', 'b', 'c', 'd')
+
+    assert Or('t', And('n', 'p', 'r'), And('n', 'r'), And('n', 'p', 'r'), 't',
+              And('n', 'r')) == Or('t', And('n', 'p', 'r'), And('n', 'r'))
+
+
+def test_logic_expand():
+    t = And(Or('a', 'b'), 'c')
+    assert t.expand() == Or(And('a', 'c'), And('b', 'c'))
+
+    t = And(Or('a', Not('b')), 'b')
+    assert t.expand() == And('a', 'b')
+
+    t = And(Or('a', 'b'), Or('c', 'd'))
+    assert t.expand() == \
+        Or(And('a', 'c'), And('a', 'd'), And('b', 'c'), And('b', 'd'))
+
+
+def test_logic_fromstring():
+    S = Logic.fromstring
+
+    assert S('a') == 'a'
+    assert S('!a') == Not('a')
+    assert S('a & b') == And('a', 'b')
+    assert S('a | b') == Or('a', 'b')
+    assert S('a | b & c') == And(Or('a', 'b'), 'c')
+    assert S('a & b | c') == Or(And('a', 'b'), 'c')
+    assert S('a & b & c') == And('a', 'b', 'c')
+    assert S('a | b | c') == Or('a', 'b', 'c')
+
+    raises(ValueError, lambda: S('| a'))
+    raises(ValueError, lambda: S('& a'))
+    raises(ValueError, lambda: S('a | | b'))
+    raises(ValueError, lambda: S('a | & b'))
+    raises(ValueError, lambda: S('a & & b'))
+    raises(ValueError, lambda: S('a |'))
+    raises(ValueError, lambda: S('a|b'))
+    raises(ValueError, lambda: S('!'))
+    raises(ValueError, lambda: S('! a'))
+    raises(ValueError, lambda: S('!(a + 1)'))
+    raises(ValueError, lambda: S(''))
+
+
+def test_logic_not():
+    assert Not('a') != '!a'
+    assert Not('!a') != 'a'
+    assert Not(True) == False
+    assert Not(False) == True
+
+    # NOTE: we may want to change default Not behaviour and put this
+    # functionality into some method.
+    assert Not(And('a', 'b')) == Or(Not('a'), Not('b'))
+    assert Not(Or('a', 'b')) == And(Not('a'), Not('b'))
+
+    raises(ValueError, lambda: Not(1))
+
+
+def test_formatting():
+    S = Logic.fromstring
+    raises(ValueError, lambda: S('a&b'))
+    raises(ValueError, lambda: S('a|b'))
+    raises(ValueError, lambda: S('! a'))
+
+
+def test_fuzzy_xor():
+    assert fuzzy_xor((None,)) is None
+    assert fuzzy_xor((None, True)) is None
+    assert fuzzy_xor((None, False)) is None
+    assert fuzzy_xor((True, False)) is True
+    assert fuzzy_xor((True, True)) is False
+    assert fuzzy_xor((True, True, False)) is False
+    assert fuzzy_xor((True, True, False, True)) is True
+
+def test_fuzzy_nand():
+    for args in [(1, 0), (1, 1), (0, 0)]:
+        assert fuzzy_nand(args) == fuzzy_not(fuzzy_and(args))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_match.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_match.py
new file mode 100644
index 0000000000000000000000000000000000000000..b44012bebc4a5f3ec413c236dca1dec71da78cf5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_match.py
@@ -0,0 +1,766 @@
+from sympy import abc
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.hyper import meijerg
+from sympy.polys.polytools import Poly
+from sympy.simplify.radsimp import collect
+from sympy.simplify.simplify import signsimp
+
+from sympy.testing.pytest import XFAIL
+
+
+def test_symbol():
+    x = Symbol('x')
+    a, b, c, p, q = map(Wild, 'abcpq')
+
+    e = x
+    assert e.match(x) == {}
+    assert e.matches(x) == {}
+    assert e.match(a) == {a: x}
+
+    e = Rational(5)
+    assert e.match(c) == {c: 5}
+    assert e.match(e) == {}
+    assert e.match(e + 1) is None
+
+
+def test_add():
+    x, y, a, b, c = map(Symbol, 'xyabc')
+    p, q, r = map(Wild, 'pqr')
+
+    e = a + b
+    assert e.match(p + b) == {p: a}
+    assert e.match(p + a) == {p: b}
+
+    e = 1 + b
+    assert e.match(p + b) == {p: 1}
+
+    e = a + b + c
+    assert e.match(a + p + c) == {p: b}
+    assert e.match(b + p + c) == {p: a}
+
+    e = a + b + c + x
+    assert e.match(a + p + x + c) == {p: b}
+    assert e.match(b + p + c + x) == {p: a}
+    assert e.match(b) is None
+    assert e.match(b + p) == {p: a + c + x}
+    assert e.match(a + p + c) == {p: b + x}
+    assert e.match(b + p + c) == {p: a + x}
+
+    e = 4*x + 5
+    assert e.match(4*x + p) == {p: 5}
+    assert e.match(3*x + p) == {p: x + 5}
+    assert e.match(p*x + 5) == {p: 4}
+
+
+def test_power():
+    x, y, a, b, c = map(Symbol, 'xyabc')
+    p, q, r = map(Wild, 'pqr')
+
+    e = (x + y)**a
+    assert e.match(p**q) == {p: x + y, q: a}
+    assert e.match(p**p) is None
+
+    e = (x + y)**(x + y)
+    assert e.match(p**p) == {p: x + y}
+    assert e.match(p**q) == {p: x + y, q: x + y}
+
+    e = (2*x)**2
+    assert e.match(p*q**r) == {p: 4, q: x, r: 2}
+
+    e = Integer(1)
+    assert e.match(x**p) == {p: 0}
+
+
+def test_match_exclude():
+    x = Symbol('x')
+    y = Symbol('y')
+    p = Wild("p")
+    q = Wild("q")
+    r = Wild("r")
+
+    e = Rational(6)
+    assert e.match(2*p) == {p: 3}
+
+    e = 3/(4*x + 5)
+    assert e.match(3/(p*x + q)) == {p: 4, q: 5}
+
+    e = 3/(4*x + 5)
+    assert e.match(p/(q*x + r)) == {p: 3, q: 4, r: 5}
+
+    e = 2/(x + 1)
+    assert e.match(p/(q*x + r)) == {p: 2, q: 1, r: 1}
+
+    e = 1/(x + 1)
+    assert e.match(p/(q*x + r)) == {p: 1, q: 1, r: 1}
+
+    e = 4*x + 5
+    assert e.match(p*x + q) == {p: 4, q: 5}
+
+    e = 4*x + 5*y + 6
+    assert e.match(p*x + q*y + r) == {p: 4, q: 5, r: 6}
+
+    a = Wild('a', exclude=[x])
+
+    e = 3*x
+    assert e.match(p*x) == {p: 3}
+    assert e.match(a*x) == {a: 3}
+
+    e = 3*x**2
+    assert e.match(p*x) == {p: 3*x}
+    assert e.match(a*x) is None
+
+    e = 3*x + 3 + 6/x
+    assert e.match(p*x**2 + p*x + 2*p) == {p: 3/x}
+    assert e.match(a*x**2 + a*x + 2*a) is None
+
+
+def test_mul():
+    x, y, a, b, c = map(Symbol, 'xyabc')
+    p, q = map(Wild, 'pq')
+
+    e = 4*x
+    assert e.match(p*x) == {p: 4}
+    assert e.match(p*y) is None
+    assert e.match(e + p*y) == {p: 0}
+
+    e = a*x*b*c
+    assert e.match(p*x) == {p: a*b*c}
+    assert e.match(c*p*x) == {p: a*b}
+
+    e = (a + b)*(a + c)
+    assert e.match((p + b)*(p + c)) == {p: a}
+
+    e = x
+    assert e.match(p*x) == {p: 1}
+
+    e = exp(x)
+    assert e.match(x**p*exp(x*q)) == {p: 0, q: 1}
+
+    e = I*Poly(x, x)
+    assert e.match(I*p) == {p: x}
+
+
+def test_mul_noncommutative():
+    x, y = symbols('x y')
+    A, B, C = symbols('A B C', commutative=False)
+    u, v = symbols('u v', cls=Wild)
+    w, z = symbols('w z', cls=Wild, commutative=False)
+
+    assert (u*v).matches(x) in ({v: x, u: 1}, {u: x, v: 1})
+    assert (u*v).matches(x*y) in ({v: y, u: x}, {u: y, v: x})
+    assert (u*v).matches(A) is None
+    assert (u*v).matches(A*B) is None
+    assert (u*v).matches(x*A) is None
+    assert (u*v).matches(x*y*A) is None
+    assert (u*v).matches(x*A*B) is None
+    assert (u*v).matches(x*y*A*B) is None
+
+    assert (v*w).matches(x) is None
+    assert (v*w).matches(x*y) is None
+    assert (v*w).matches(A) == {w: A, v: 1}
+    assert (v*w).matches(A*B) == {w: A*B, v: 1}
+    assert (v*w).matches(x*A) == {w: A, v: x}
+    assert (v*w).matches(x*y*A) == {w: A, v: x*y}
+    assert (v*w).matches(x*A*B) == {w: A*B, v: x}
+    assert (v*w).matches(x*y*A*B) == {w: A*B, v: x*y}
+
+    assert (v*w).matches(-x) is None
+    assert (v*w).matches(-x*y) is None
+    assert (v*w).matches(-A) == {w: A, v: -1}
+    assert (v*w).matches(-A*B) == {w: A*B, v: -1}
+    assert (v*w).matches(-x*A) == {w: A, v: -x}
+    assert (v*w).matches(-x*y*A) == {w: A, v: -x*y}
+    assert (v*w).matches(-x*A*B) == {w: A*B, v: -x}
+    assert (v*w).matches(-x*y*A*B) == {w: A*B, v: -x*y}
+
+    assert (w*z).matches(x) is None
+    assert (w*z).matches(x*y) is None
+    assert (w*z).matches(A) is None
+    assert (w*z).matches(A*B) == {w: A, z: B}
+    assert (w*z).matches(B*A) == {w: B, z: A}
+    assert (w*z).matches(A*B*C) in [{w: A, z: B*C}, {w: A*B, z: C}]
+    assert (w*z).matches(x*A) is None
+    assert (w*z).matches(x*y*A) is None
+    assert (w*z).matches(x*A*B) is None
+    assert (w*z).matches(x*y*A*B) is None
+
+    assert (w*A).matches(A) is None
+    assert (A*w*B).matches(A*B) is None
+
+    assert (u*w*z).matches(x) is None
+    assert (u*w*z).matches(x*y) is None
+    assert (u*w*z).matches(A) is None
+    assert (u*w*z).matches(A*B) == {u: 1, w: A, z: B}
+    assert (u*w*z).matches(B*A) == {u: 1, w: B, z: A}
+    assert (u*w*z).matches(x*A) is None
+    assert (u*w*z).matches(x*y*A) is None
+    assert (u*w*z).matches(x*A*B) == {u: x, w: A, z: B}
+    assert (u*w*z).matches(x*B*A) == {u: x, w: B, z: A}
+    assert (u*w*z).matches(x*y*A*B) == {u: x*y, w: A, z: B}
+    assert (u*w*z).matches(x*y*B*A) == {u: x*y, w: B, z: A}
+
+    assert (u*A).matches(x*A) == {u: x}
+    assert (u*A).matches(x*A*B) is None
+    assert (u*B).matches(x*A) is None
+    assert (u*A*B).matches(x*A*B) == {u: x}
+    assert (u*A*B).matches(x*B*A) is None
+    assert (u*A*B).matches(x*A) is None
+
+    assert (u*w*A).matches(x*A*B) is None
+    assert (u*w*B).matches(x*A*B) == {u: x, w: A}
+
+    assert (u*v*A*B).matches(x*A*B) in [{u: x, v: 1}, {v: x, u: 1}]
+    assert (u*v*A*B).matches(x*B*A) is None
+    assert (u*v*A*B).matches(u*v*A*C) is None
+
+
+def test_mul_noncommutative_mismatch():
+    A, B, C = symbols('A B C', commutative=False)
+    w = symbols('w', cls=Wild, commutative=False)
+
+    assert (w*B*w).matches(A*B*A) == {w: A}
+    assert (w*B*w).matches(A*C*B*A*C) == {w: A*C}
+    assert (w*B*w).matches(A*C*B*A*B) is None
+    assert (w*B*w).matches(A*B*C) is None
+    assert (w*w*C).matches(A*B*C) is None
+
+
+def test_mul_noncommutative_pow():
+    A, B, C = symbols('A B C', commutative=False)
+    w = symbols('w', cls=Wild, commutative=False)
+
+    assert (A*B*w).matches(A*B**2) == {w: B}
+    assert (A*(B**2)*w*(B**3)).matches(A*B**8) == {w: B**3}
+    assert (A*B*w*C).matches(A*(B**4)*C) == {w: B**3}
+
+    assert (A*B*(w**(-1))).matches(A*B*(C**(-1))) == {w: C}
+    assert (A*(B*w)**(-1)*C).matches(A*(B*C)**(-1)*C) == {w: C}
+
+    assert ((w**2)*B*C).matches((A**2)*B*C) == {w: A}
+    assert ((w**2)*B*(w**3)).matches((A**2)*B*(A**3)) == {w: A}
+    assert ((w**2)*B*(w**4)).matches((A**2)*B*(A**2)) is None
+
+def test_complex():
+    a, b, c = map(Symbol, 'abc')
+    x, y = map(Wild, 'xy')
+
+    assert (1 + I).match(x + I) == {x: 1}
+    assert (a + I).match(x + I) == {x: a}
+    assert (2*I).match(x*I) == {x: 2}
+    assert (a*I).match(x*I) == {x: a}
+    assert (a*I).match(x*y) == {x: I, y: a}
+    assert (2*I).match(x*y) == {x: 2, y: I}
+    assert (a + b*I).match(x + y*I) == {x: a, y: b}
+
+
+def test_functions():
+    from sympy.core.function import WildFunction
+    x = Symbol('x')
+    g = WildFunction('g')
+    p = Wild('p')
+    q = Wild('q')
+
+    f = cos(5*x)
+    notf = x
+    assert f.match(p*cos(q*x)) == {p: 1, q: 5}
+    assert f.match(p*g) == {p: 1, g: cos(5*x)}
+    assert notf.match(g) is None
+
+
+@XFAIL
+def test_functions_X1():
+    from sympy.core.function import WildFunction
+    x = Symbol('x')
+    g = WildFunction('g')
+    p = Wild('p')
+    q = Wild('q')
+
+    f = cos(5*x)
+    assert f.match(p*g(q*x)) == {p: 1, g: cos, q: 5}
+
+
+def test_interface():
+    x, y = map(Symbol, 'xy')
+    p, q = map(Wild, 'pq')
+
+    assert (x + 1).match(p + 1) == {p: x}
+    assert (x*3).match(p*3) == {p: x}
+    assert (x**3).match(p**3) == {p: x}
+    assert (x*cos(y)).match(p*cos(q)) == {p: x, q: y}
+
+    assert (x*y).match(p*q) in [{p:x, q:y}, {p:y, q:x}]
+    assert (x + y).match(p + q) in [{p:x, q:y}, {p:y, q:x}]
+    assert (x*y + 1).match(p*q) in [{p:1, q:1 + x*y}, {p:1 + x*y, q:1}]
+
+
+def test_derivative1():
+    x, y = map(Symbol, 'xy')
+    p, q = map(Wild, 'pq')
+
+    f = Function('f', nargs=1)
+    fd = Derivative(f(x), x)
+
+    assert fd.match(p) == {p: fd}
+    assert (fd + 1).match(p + 1) == {p: fd}
+    assert (fd).match(fd) == {}
+    assert (3*fd).match(p*fd) is not None
+    assert (3*fd - 1).match(p*fd + q) == {p: 3, q: -1}
+
+
+def test_derivative_bug1():
+    f = Function("f")
+    x = Symbol("x")
+    a = Wild("a", exclude=[f, x])
+    b = Wild("b", exclude=[f])
+    pattern = a * Derivative(f(x), x, x) + b
+    expr = Derivative(f(x), x) + x**2
+    d1 = {b: x**2}
+    d2 = pattern.xreplace(d1).matches(expr, d1)
+    assert d2 is None
+
+
+def test_derivative2():
+    f = Function("f")
+    x = Symbol("x")
+    a = Wild("a", exclude=[f, x])
+    b = Wild("b", exclude=[f])
+    e = Derivative(f(x), x)
+    assert e.match(Derivative(f(x), x)) == {}
+    assert e.match(Derivative(f(x), x, x)) is None
+    e = Derivative(f(x), x, x)
+    assert e.match(Derivative(f(x), x)) is None
+    assert e.match(Derivative(f(x), x, x)) == {}
+    e = Derivative(f(x), x) + x**2
+    assert e.match(a*Derivative(f(x), x) + b) == {a: 1, b: x**2}
+    assert e.match(a*Derivative(f(x), x, x) + b) is None
+    e = Derivative(f(x), x, x) + x**2
+    assert e.match(a*Derivative(f(x), x) + b) is None
+    assert e.match(a*Derivative(f(x), x, x) + b) == {a: 1, b: x**2}
+
+
+def test_match_deriv_bug1():
+    n = Function('n')
+    l = Function('l')
+
+    x = Symbol('x')
+    p = Wild('p')
+
+    e = diff(l(x), x)/x - diff(diff(n(x), x), x)/2 - \
+        diff(n(x), x)**2/4 + diff(n(x), x)*diff(l(x), x)/4
+    e = e.subs(n(x), -l(x)).doit()
+    t = x*exp(-l(x))
+    t2 = t.diff(x, x)/t
+    assert e.match( (p*t2).expand() ) == {p: Rational(-1, 2)}
+
+
+def test_match_bug2():
+    x, y = map(Symbol, 'xy')
+    p, q, r = map(Wild, 'pqr')
+    res = (x + y).match(p + q + r)
+    assert (p + q + r).subs(res) == x + y
+
+
+def test_match_bug3():
+    x, a, b = map(Symbol, 'xab')
+    p = Wild('p')
+    assert (b*x*exp(a*x)).match(x*exp(p*x)) is None
+
+
+def test_match_bug4():
+    x = Symbol('x')
+    p = Wild('p')
+    e = x
+    assert e.match(-p*x) == {p: -1}
+
+
+def test_match_bug5():
+    x = Symbol('x')
+    p = Wild('p')
+    e = -x
+    assert e.match(-p*x) == {p: 1}
+
+
+def test_match_bug6():
+    x = Symbol('x')
+    p = Wild('p')
+    e = x
+    assert e.match(3*p*x) == {p: Rational(1)/3}
+
+
+def test_match_polynomial():
+    x = Symbol('x')
+    a = Wild('a', exclude=[x])
+    b = Wild('b', exclude=[x])
+    c = Wild('c', exclude=[x])
+    d = Wild('d', exclude=[x])
+
+    eq = 4*x**3 + 3*x**2 + 2*x + 1
+    pattern = a*x**3 + b*x**2 + c*x + d
+    assert eq.match(pattern) == {a: 4, b: 3, c: 2, d: 1}
+    assert (eq - 3*x**2).match(pattern) == {a: 4, b: 0, c: 2, d: 1}
+    assert (x + sqrt(2) + 3).match(a + b*x + c*x**2) == \
+        {b: 1, a: sqrt(2) + 3, c: 0}
+
+
+def test_exclude():
+    x, y, a = map(Symbol, 'xya')
+    p = Wild('p', exclude=[1, x])
+    q = Wild('q')
+    r = Wild('r', exclude=[sin, y])
+
+    assert sin(x).match(r) is None
+    assert cos(y).match(r) is None
+
+    e = 3*x**2 + y*x + a
+    assert e.match(p*x**2 + q*x + r) == {p: 3, q: y, r: a}
+
+    e = x + 1
+    assert e.match(x + p) is None
+    assert e.match(p + 1) is None
+    assert e.match(x + 1 + p) == {p: 0}
+
+    e = cos(x) + 5*sin(y)
+    assert e.match(r) is None
+    assert e.match(cos(y) + r) is None
+    assert e.match(r + p*sin(q)) == {r: cos(x), p: 5, q: y}
+
+
+def test_floats():
+    a, b = map(Wild, 'ab')
+
+    e = cos(0.12345, evaluate=False)**2
+    r = e.match(a*cos(b)**2)
+    assert r == {a: 1, b: Float(0.12345)}
+
+
+def test_Derivative_bug1():
+    f = Function("f")
+    x = abc.x
+    a = Wild("a", exclude=[f(x)])
+    b = Wild("b", exclude=[f(x)])
+    eq = f(x).diff(x)
+    assert eq.match(a*Derivative(f(x), x) + b) == {a: 1, b: 0}
+
+
+def test_match_wild_wild():
+    p = Wild('p')
+    q = Wild('q')
+    r = Wild('r')
+
+    assert p.match(q + r) in [ {q: p, r: 0}, {q: 0, r: p} ]
+    assert p.match(q*r) in [ {q: p, r: 1}, {q: 1, r: p} ]
+
+    p = Wild('p')
+    q = Wild('q', exclude=[p])
+    r = Wild('r')
+
+    assert p.match(q + r) == {q: 0, r: p}
+    assert p.match(q*r) == {q: 1, r: p}
+
+    p = Wild('p')
+    q = Wild('q', exclude=[p])
+    r = Wild('r', exclude=[p])
+
+    assert p.match(q + r) is None
+    assert p.match(q*r) is None
+
+
+def test__combine_inverse():
+    x, y = symbols("x y")
+    assert Mul._combine_inverse(x*I*y, x*I) == y
+    assert Mul._combine_inverse(x*x**(1 + y), x**(1 + y)) == x
+    assert Mul._combine_inverse(x*I*y, y*I) == x
+    assert Mul._combine_inverse(oo*I*y, y*I) is oo
+    assert Mul._combine_inverse(oo*I*y, oo*I) == y
+    assert Mul._combine_inverse(oo*I*y, oo*I) == y
+    assert Mul._combine_inverse(oo*y, -oo) == -y
+    assert Mul._combine_inverse(-oo*y, oo) == -y
+    assert Mul._combine_inverse((1-exp(x/y)),(exp(x/y)-1)) == -1
+    assert Add._combine_inverse(oo, oo) is S.Zero
+    assert Add._combine_inverse(oo*I, oo*I) is S.Zero
+    assert Add._combine_inverse(x*oo, x*oo) is S.Zero
+    assert Add._combine_inverse(-x*oo, -x*oo) is S.Zero
+    assert Add._combine_inverse((x - oo)*(x + oo), -oo)
+
+
+def test_issue_3773():
+    x = symbols('x')
+    z, phi, r = symbols('z phi r')
+    c, A, B, N = symbols('c A B N', cls=Wild)
+    l = Wild('l', exclude=(0,))
+
+    eq = z * sin(2*phi) * r**7
+    matcher = c * sin(phi*N)**l * r**A * log(r)**B
+
+    assert eq.match(matcher) == {c: z, l: 1, N: 2, A: 7, B: 0}
+    assert (-eq).match(matcher) == {c: -z, l: 1, N: 2, A: 7, B: 0}
+    assert (x*eq).match(matcher) == {c: x*z, l: 1, N: 2, A: 7, B: 0}
+    assert (-7*x*eq).match(matcher) == {c: -7*x*z, l: 1, N: 2, A: 7, B: 0}
+
+    matcher = c*sin(phi*N)**l * r**A
+
+    assert eq.match(matcher) == {c: z, l: 1, N: 2, A: 7}
+    assert (-eq).match(matcher) == {c: -z, l: 1, N: 2, A: 7}
+    assert (x*eq).match(matcher) == {c: x*z, l: 1, N: 2, A: 7}
+    assert (-7*x*eq).match(matcher) == {c: -7*x*z, l: 1, N: 2, A: 7}
+
+
+def test_issue_3883():
+    from sympy.abc import gamma, mu, x
+    f = (-gamma * (x - mu)**2 - log(gamma) + log(2*pi))/2
+    a, b, c = symbols('a b c', cls=Wild, exclude=(gamma,))
+
+    assert f.match(a * log(gamma) + b * gamma + c) == \
+        {a: Rational(-1, 2), b: -(-mu + x)**2/2, c: log(2*pi)/2}
+    assert f.expand().collect(gamma).match(a * log(gamma) + b * gamma + c) == \
+        {a: Rational(-1, 2), b: (-(x - mu)**2/2).expand(), c: (log(2*pi)/2).expand()}
+    g1 = Wild('g1', exclude=[gamma])
+    g2 = Wild('g2', exclude=[gamma])
+    g3 = Wild('g3', exclude=[gamma])
+    assert f.expand().match(g1 * log(gamma) + g2 * gamma + g3) == \
+    {g3: log(2)/2 + log(pi)/2, g1: Rational(-1, 2), g2: -mu**2/2 + mu*x - x**2/2}
+
+
+def test_issue_4418():
+    x = Symbol('x')
+    a, b, c = symbols('a b c', cls=Wild, exclude=(x,))
+    f, g = symbols('f g', cls=Function)
+
+    eq = diff(g(x)*f(x).diff(x), x)
+
+    assert eq.match(
+        g(x).diff(x)*f(x).diff(x) + g(x)*f(x).diff(x, x) + c) == {c: 0}
+    assert eq.match(a*g(x).diff(
+        x)*f(x).diff(x) + b*g(x)*f(x).diff(x, x) + c) == {a: 1, b: 1, c: 0}
+
+
+def test_issue_4700():
+    f = Function('f')
+    x = Symbol('x')
+    a, b = symbols('a b', cls=Wild, exclude=(f(x),))
+
+    p = a*f(x) + b
+    eq1 = sin(x)
+    eq2 = f(x) + sin(x)
+    eq3 = f(x) + x + sin(x)
+    eq4 = x + sin(x)
+
+    assert eq1.match(p) == {a: 0, b: sin(x)}
+    assert eq2.match(p) == {a: 1, b: sin(x)}
+    assert eq3.match(p) == {a: 1, b: x + sin(x)}
+    assert eq4.match(p) == {a: 0, b: x + sin(x)}
+
+
+def test_issue_5168():
+    a, b, c = symbols('a b c', cls=Wild)
+    x = Symbol('x')
+    f = Function('f')
+
+    assert x.match(a) == {a: x}
+    assert x.match(a*f(x)**c) == {a: x, c: 0}
+    assert x.match(a*b) == {a: 1, b: x}
+    assert x.match(a*b*f(x)**c) == {a: 1, b: x, c: 0}
+
+    assert (-x).match(a) == {a: -x}
+    assert (-x).match(a*f(x)**c) == {a: -x, c: 0}
+    assert (-x).match(a*b) == {a: -1, b: x}
+    assert (-x).match(a*b*f(x)**c) == {a: -1, b: x, c: 0}
+
+    assert (2*x).match(a) == {a: 2*x}
+    assert (2*x).match(a*f(x)**c) == {a: 2*x, c: 0}
+    assert (2*x).match(a*b) == {a: 2, b: x}
+    assert (2*x).match(a*b*f(x)**c) == {a: 2, b: x, c: 0}
+
+    assert (-2*x).match(a) == {a: -2*x}
+    assert (-2*x).match(a*f(x)**c) == {a: -2*x, c: 0}
+    assert (-2*x).match(a*b) == {a: -2, b: x}
+    assert (-2*x).match(a*b*f(x)**c) == {a: -2, b: x, c: 0}
+
+
+def test_issue_4559():
+    x = Symbol('x')
+    e = Symbol('e')
+    w = Wild('w', exclude=[x])
+    y = Wild('y')
+
+    # this is as it should be
+
+    assert (3/x).match(w/y) == {w: 3, y: x}
+    assert (3*x).match(w*y) == {w: 3, y: x}
+    assert (x/3).match(y/w) == {w: 3, y: x}
+    assert (3*x).match(y/w) == {w: S.One/3, y: x}
+    assert (3*x).match(y/w) == {w: Rational(1, 3), y: x}
+
+    # these could be allowed to fail
+
+    assert (x/3).match(w/y) == {w: S.One/3, y: 1/x}
+    assert (3*x).match(w/y) == {w: 3, y: 1/x}
+    assert (3/x).match(w*y) == {w: 3, y: 1/x}
+
+    # Note that solve will give
+    # multiple roots but match only gives one:
+    #
+    # >>> solve(x**r-y**2,y)
+    # [-x**(r/2), x**(r/2)]
+
+    r = Symbol('r', rational=True)
+    assert (x**r).match(y**2) == {y: x**(r/2)}
+    assert (x**e).match(y**2) == {y: sqrt(x**e)}
+
+    # since (x**i = y) -> x = y**(1/i) where i is an integer
+    # the following should also be valid as long as y is not
+    # zero when i is negative.
+
+    a = Wild('a')
+
+    e = S.Zero
+    assert e.match(a) == {a: e}
+    assert e.match(1/a) is None
+    assert e.match(a**.3) is None
+
+    e = S(3)
+    assert e.match(1/a) == {a: 1/e}
+    assert e.match(1/a**2) == {a: 1/sqrt(e)}
+    e = pi
+    assert e.match(1/a) == {a: 1/e}
+    assert e.match(1/a**2) == {a: 1/sqrt(e)}
+    assert (-e).match(sqrt(a)) is None
+    assert (-e).match(a**2) == {a: I*sqrt(pi)}
+
+# The pattern matcher doesn't know how to handle (x - a)**2 == (a - x)**2. To
+# avoid ambiguity in actual applications, don't put a coefficient (including a
+# minus sign) in front of a wild.
+@XFAIL
+def test_issue_4883():
+    a = Wild('a')
+    x = Symbol('x')
+
+    e = [i**2 for i in (x - 2, 2 - x)]
+    p = [i**2 for i in (x - a, a- x)]
+    for eq in e:
+        for pat in p:
+            assert eq.match(pat) == {a: 2}
+
+
+def test_issue_4319():
+    x, y = symbols('x y')
+
+    p = -x*(S.One/8 - y)
+    ans = {S.Zero, y - S.One/8}
+
+    def ok(pat):
+        assert set(p.match(pat).values()) == ans
+
+    ok(Wild("coeff", exclude=[x])*x + Wild("rest"))
+    ok(Wild("w", exclude=[x])*x + Wild("rest"))
+    ok(Wild("coeff", exclude=[x])*x + Wild("rest"))
+    ok(Wild("w", exclude=[x])*x + Wild("rest"))
+    ok(Wild("e", exclude=[x])*x + Wild("rest"))
+    ok(Wild("ress", exclude=[x])*x + Wild("rest"))
+    ok(Wild("resu", exclude=[x])*x + Wild("rest"))
+
+
+def test_issue_3778():
+    p, c, q = symbols('p c q', cls=Wild)
+    x = Symbol('x')
+
+    assert (sin(x)**2).match(sin(p)*sin(q)*c) == {q: x, c: 1, p: x}
+    assert (2*sin(x)).match(sin(p) + sin(q) + c) == {q: x, c: 0, p: x}
+
+
+def test_issue_6103():
+    x = Symbol('x')
+    a = Wild('a')
+    assert (-I*x*oo).match(I*a*oo) == {a: -x}
+
+
+def test_issue_3539():
+    a = Wild('a')
+    x = Symbol('x')
+    assert (x - 2).match(a - x) is None
+    assert (6/x).match(a*x) is None
+    assert (6/x**2).match(a/x) == {a: 6/x}
+
+def test_gh_issue_2711():
+    x = Symbol('x')
+    f = meijerg(((), ()), ((0,), ()), x)
+    a = Wild('a')
+    b = Wild('b')
+
+    assert f.find(a) == {(S.Zero,), ((), ()), ((S.Zero,), ()), x, S.Zero,
+                             (), meijerg(((), ()), ((S.Zero,), ()), x)}
+    assert f.find(a + b) == \
+        {meijerg(((), ()), ((S.Zero,), ()), x), x, S.Zero}
+    assert f.find(a**2) == {meijerg(((), ()), ((S.Zero,), ()), x), x}
+
+
+def test_issue_17354():
+    from sympy.core.symbol import (Wild, symbols)
+    x, y = symbols("x y", real=True)
+    a, b = symbols("a b", cls=Wild)
+    assert ((0 <= x).reversed | (y <= x)).match((1/a <= b) | (a <= b)) is None
+
+
+def test_match_issue_17397():
+    f = Function("f")
+    x = Symbol("x")
+    a3 = Wild('a3', exclude=[f(x), f(x).diff(x), f(x).diff(x, 2)])
+    b3 = Wild('b3', exclude=[f(x), f(x).diff(x), f(x).diff(x, 2)])
+    c3 = Wild('c3', exclude=[f(x), f(x).diff(x), f(x).diff(x, 2)])
+    deq = a3*(f(x).diff(x, 2)) + b3*f(x).diff(x) + c3*f(x)
+
+    eq = (x-2)**2*(f(x).diff(x, 2)) + (x-2)*(f(x).diff(x)) + ((x-2)**2 - 4)*f(x)
+    r = collect(eq, [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+    assert r == {a3: (x - 2)**2, c3: (x - 2)**2 - 4, b3: x - 2}
+
+    eq =x*f(x) + x*Derivative(f(x), (x, 2)) - 4*f(x) + Derivative(f(x), x) \
+        - 4*Derivative(f(x), (x, 2)) - 2*Derivative(f(x), x)/x + 4*Derivative(f(x), (x, 2))/x
+    r = collect(eq, [f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
+    assert r == {a3: x - 4 + 4/x, b3: 1 - 2/x, c3: x - 4}
+
+
+def test_match_issue_21942():
+    a, r, w = symbols('a, r, w', nonnegative=True)
+    p = symbols('p', positive=True)
+    g_ = Wild('g')
+    pattern = g_ ** (1 / (1 - p))
+    eq = (a * r ** (1 - p) + w ** (1 - p) * (1 - a)) ** (1 / (1 - p))
+    m = {g_: a * r ** (1 - p) + w ** (1 - p) * (1 - a)}
+    assert pattern.matches(eq) == m
+    assert (-pattern).matches(-eq) == m
+    assert pattern.matches(signsimp(eq)) is None
+
+
+def test_match_terms():
+    X, Y = map(Wild, "XY")
+    x, y, z = symbols('x y z')
+    assert (5*y - x).match(5*X - Y) == {X: y, Y: x}
+    # 15907
+    assert (x + (y - 1)*z).match(x + X*z) == {X: y - 1}
+    # 20747
+    assert (x - log(x/y)*(1-exp(x/y))).match(x - log(X/y)*(1-exp(x/y))) == {X: x}
+
+
+def test_match_bound():
+    V, W = map(Wild, "VW")
+    x, y = symbols('x y')
+    assert Sum(x, (x, 1, 2)).match(Sum(y, (y, 1, W))) is None
+    assert Sum(x, (x, 1, 2)).match(Sum(V, (V, 1, W))) == {W: 2, V:x}
+    assert Sum(x, (x, 1, 2)).match(Sum(V, (V, 1, 2))) == {V:x}
+
+
+def test_issue_22462():
+    x, f = symbols('x'), Function('f')
+    n, Q = symbols('n Q', cls=Wild)
+    pattern = -Q*f(x)**n
+    eq = 5*f(x)**2
+    assert pattern.matches(eq) == {n: 2, Q: -5}
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_multidimensional.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_multidimensional.py
new file mode 100644
index 0000000000000000000000000000000000000000..765c78adf8dbed2ead43721ca4ab9510dbeeb282
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_multidimensional.py
@@ -0,0 +1,24 @@
+from sympy.core.function import (Derivative, Function, diff)
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.trigonometric import sin
+from sympy.core.multidimensional import vectorize
+x, y, z = symbols('x y z')
+f, g, h = list(map(Function, 'fgh'))
+
+
+def test_vectorize():
+    @vectorize(0)
+    def vsin(x):
+        return sin(x)
+
+    assert vsin([1, x, y]) == [sin(1), sin(x), sin(y)]
+
+    @vectorize(0, 1)
+    def vdiff(f, y):
+        return diff(f, y)
+
+    assert vdiff([f(x, y, z), g(x, y, z), h(x, y, z)], [x, y, z]) == \
+         [[Derivative(f(x, y, z), x), Derivative(f(x, y, z), y),
+           Derivative(f(x, y, z), z)], [Derivative(g(x, y, z), x),
+                     Derivative(g(x, y, z), y), Derivative(g(x, y, z), z)],
+         [Derivative(h(x, y, z), x), Derivative(h(x, y, z), y), Derivative(h(x, y, z), z)]]
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_noncommutative.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_noncommutative.py
new file mode 100644
index 0000000000000000000000000000000000000000..b3d3a3cec2ef64aa500aad08b438c90cc8987581
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_noncommutative.py
@@ -0,0 +1,140 @@
+"""Tests for noncommutative symbols and expressions."""
+
+from sympy.core.function import expand
+from sympy.core.numbers import I
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import (adjoint, conjugate, transpose)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.polys.polytools import (cancel, factor)
+from sympy.simplify.combsimp import combsimp
+from sympy.simplify.gammasimp import gammasimp
+from sympy.simplify.radsimp import (collect, radsimp, rcollect)
+from sympy.simplify.ratsimp import ratsimp
+from sympy.simplify.simplify import (posify, simplify)
+from sympy.simplify.trigsimp import trigsimp
+from sympy.abc import x, y, z
+from sympy.testing.pytest import XFAIL
+
+A, B, C = symbols("A B C", commutative=False)
+X = symbols("X", commutative=False, hermitian=True)
+Y = symbols("Y", commutative=False, antihermitian=True)
+
+
+def test_adjoint():
+    assert adjoint(A).is_commutative is False
+    assert adjoint(A*A) == adjoint(A)**2
+    assert adjoint(A*B) == adjoint(B)*adjoint(A)
+    assert adjoint(A*B**2) == adjoint(B)**2*adjoint(A)
+    assert adjoint(A*B - B*A) == adjoint(B)*adjoint(A) - adjoint(A)*adjoint(B)
+    assert adjoint(A + I*B) == adjoint(A) - I*adjoint(B)
+
+    assert adjoint(X) == X
+    assert adjoint(-I*X) == I*X
+    assert adjoint(Y) == -Y
+    assert adjoint(-I*Y) == -I*Y
+
+    assert adjoint(X) == conjugate(transpose(X))
+    assert adjoint(Y) == conjugate(transpose(Y))
+    assert adjoint(X) == transpose(conjugate(X))
+    assert adjoint(Y) == transpose(conjugate(Y))
+
+
+def test_cancel():
+    assert cancel(A*B - B*A) == A*B - B*A
+    assert cancel(A*B*(x - 1)) == A*B*(x - 1)
+    assert cancel(A*B*(x**2 - 1)/(x + 1)) == A*B*(x - 1)
+    assert cancel(A*B*(x**2 - 1)/(x + 1) - B*A*(x - 1)) == A*B*(x - 1) + (1 - x)*B*A
+
+
+@XFAIL
+def test_collect():
+    assert collect(A*B - B*A, A) == A*B - B*A
+    assert collect(A*B - B*A, B) == A*B - B*A
+    assert collect(A*B - B*A, x) == A*B - B*A
+
+
+def test_combsimp():
+    assert combsimp(A*B - B*A) == A*B - B*A
+
+
+def test_gammasimp():
+    assert gammasimp(A*B - B*A) == A*B - B*A
+
+
+def test_conjugate():
+    assert conjugate(A).is_commutative is False
+    assert (A*A).conjugate() == conjugate(A)**2
+    assert (A*B).conjugate() == conjugate(A)*conjugate(B)
+    assert (A*B**2).conjugate() == conjugate(A)*conjugate(B)**2
+    assert (A*B - B*A).conjugate() == \
+        conjugate(A)*conjugate(B) - conjugate(B)*conjugate(A)
+    assert (A*B).conjugate() - (B*A).conjugate() == \
+        conjugate(A)*conjugate(B) - conjugate(B)*conjugate(A)
+    assert (A + I*B).conjugate() == conjugate(A) - I*conjugate(B)
+
+
+def test_expand():
+    assert expand((A*B)**2) == A*B*A*B
+    assert expand(A*B - B*A) == A*B - B*A
+    assert expand((A*B/A)**2) == A*B*B/A
+    assert expand(B*A*(A + B)*B) == B*A**2*B + B*A*B**2
+    assert expand(B*A*(A + C)*B) == B*A**2*B + B*A*C*B
+
+
+def test_factor():
+    assert factor(A*B - B*A) == A*B - B*A
+
+
+def test_posify():
+    assert posify(A)[0].is_commutative is False
+    for q in (A*B/A, (A*B/A)**2, (A*B)**2, A*B - B*A):
+        p = posify(q)
+        assert p[0].subs(p[1]) == q
+
+
+def test_radsimp():
+    assert radsimp(A*B - B*A) == A*B - B*A
+
+
+@XFAIL
+def test_ratsimp():
+    assert ratsimp(A*B - B*A) == A*B - B*A
+
+
+@XFAIL
+def test_rcollect():
+    assert rcollect(A*B - B*A, A) == A*B - B*A
+    assert rcollect(A*B - B*A, B) == A*B - B*A
+    assert rcollect(A*B - B*A, x) == A*B - B*A
+
+
+def test_simplify():
+    assert simplify(A*B - B*A) == A*B - B*A
+
+
+def test_subs():
+    assert (x*y*A).subs(x*y, z) == A*z
+    assert (x*A*B).subs(x*A, C) == C*B
+    assert (x*A*x*x).subs(x**2*A, C) == x*C
+    assert (x*A*x*B).subs(x**2*A, C) == C*B
+    assert (A**2*B**2).subs(A*B**2, C) == A*C
+    assert (A*A*A + A*B*A).subs(A*A*A, C) == C + A*B*A
+
+
+def test_transpose():
+    assert transpose(A).is_commutative is False
+    assert transpose(A*A) == transpose(A)**2
+    assert transpose(A*B) == transpose(B)*transpose(A)
+    assert transpose(A*B**2) == transpose(B)**2*transpose(A)
+    assert transpose(A*B - B*A) == \
+        transpose(B)*transpose(A) - transpose(A)*transpose(B)
+    assert transpose(A + I*B) == transpose(A) + I*transpose(B)
+
+    assert transpose(X) == conjugate(X)
+    assert transpose(-I*X) == -I*conjugate(X)
+    assert transpose(Y) == -conjugate(Y)
+    assert transpose(-I*Y) == I*conjugate(Y)
+
+
+def test_trigsimp():
+    assert trigsimp(A*sin(x)**2 + A*cos(x)**2) == A
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_numbers.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..10d14b6ac09fb0ab102c37cb99405440bd0bbffb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_numbers.py
@@ -0,0 +1,2335 @@
+import numbers as nums
+import decimal
+from sympy.concrete.summations import Sum
+from sympy.core import (EulerGamma, Catalan, TribonacciConstant,
+    GoldenRatio)
+from sympy.core.containers import Tuple
+from sympy.core.expr import unchanged
+from sympy.core.logic import fuzzy_not
+from sympy.core.mul import Mul
+from sympy.core.numbers import (mpf_norm, seterr,
+    Integer, I, pi, comp, Rational, E, nan,
+    oo, AlgebraicNumber, Number, Float, zoo, equal_valued,
+    int_valued, all_close)
+from sympy.core.intfunc import (igcd, igcdex, igcd2, igcd_lehmer,
+    ilcm, integer_nthroot, isqrt, integer_log, mod_inverse)
+from sympy.core.power import Pow
+from sympy.core.relational import Ge, Gt, Le, Lt
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.integers import floor
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import sqrt, cbrt
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.polys.domains.realfield import RealField
+from sympy.printing.latex import latex
+from sympy.printing.repr import srepr
+from sympy.simplify import simplify
+from sympy.polys.domains.groundtypes import PythonRational
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.iterables import permutations
+from sympy.testing.pytest import (XFAIL, raises, _both_exp_pow,
+                                  warns_deprecated_sympy)
+from sympy import Add
+
+from mpmath import mpf
+import mpmath
+from sympy.core import numbers
+t = Symbol('t', real=False)
+
+_ninf = float(-oo)
+_inf = float(oo)
+
+
+def same_and_same_prec(a, b):
+    # stricter matching for Floats
+    return a == b and a._prec == b._prec
+
+
+def test_seterr():
+    seterr(divide=True)
+    raises(ValueError, lambda: S.Zero/S.Zero)
+    seterr(divide=False)
+    assert S.Zero / S.Zero is S.NaN
+
+
+def test_mod():
+    x = S.Half
+    y = Rational(3, 4)
+    z = Rational(5, 18043)
+
+    assert x % x == 0
+    assert x % y == S.Half
+    assert x % z == Rational(3, 36086)
+    assert y % x == Rational(1, 4)
+    assert y % y == 0
+    assert y % z == Rational(9, 72172)
+    assert z % x == Rational(5, 18043)
+    assert z % y == Rational(5, 18043)
+    assert z % z == 0
+
+    a = Float(2.6)
+
+    assert (a % .2) == 0.0
+    assert (a % 2).round(15) == 0.6
+    assert (a % 0.5).round(15) == 0.1
+
+    p = Symbol('p', infinite=True)
+
+    assert oo % oo is nan
+    assert zoo % oo is nan
+    assert 5 % oo is nan
+    assert p % 5 is nan
+
+    # In these two tests, if the precision of m does
+    # not match the precision of the ans, then it is
+    # likely that the change made now gives an answer
+    # with degraded accuracy.
+    r = Rational(500, 41)
+    f = Float('.36', 3)
+    m = r % f
+    ans = Float(r % Rational(f), 3)
+    assert m == ans and m._prec == ans._prec
+    f = Float('8.36', 3)
+    m = f % r
+    ans = Float(Rational(f) % r, 3)
+    assert m == ans and m._prec == ans._prec
+
+    s = S.Zero
+
+    assert s % float(1) == 0.0
+
+    # No rounding required since these numbers can be represented
+    # exactly.
+    assert Rational(3, 4) % Float(1.1) == 0.75
+    assert Float(1.5) % Rational(5, 4) == 0.25
+    assert Rational(5, 4).__rmod__(Float('1.5')) == 0.25
+    assert Float('1.5').__rmod__(Float('2.75')) == Float('1.25')
+    assert 2.75 % Float('1.5') == Float('1.25')
+
+    a = Integer(7)
+    b = Integer(4)
+
+    assert type(a % b) == Integer
+    assert a % b == Integer(3)
+    assert Integer(1) % Rational(2, 3) == Rational(1, 3)
+    assert Rational(7, 5) % Integer(1) == Rational(2, 5)
+    assert Integer(2) % 1.5 == 0.5
+
+    assert Integer(3).__rmod__(Integer(10)) == Integer(1)
+    assert Integer(10) % 4 == Integer(2)
+    assert 15 % Integer(4) == Integer(3)
+
+
+def test_divmod():
+    x = Symbol("x")
+    assert divmod(S(12), S(8)) == Tuple(1, 4)
+    assert divmod(-S(12), S(8)) == Tuple(-2, 4)
+    assert divmod(S.Zero, S.One) == Tuple(0, 0)
+    raises(ZeroDivisionError, lambda: divmod(S.Zero, S.Zero))
+    raises(ZeroDivisionError, lambda: divmod(S.One, S.Zero))
+    assert divmod(S(12), 8) == Tuple(1, 4)
+    assert divmod(12, S(8)) == Tuple(1, 4)
+    assert S(1024)//x == 1024//x == floor(1024/x)
+
+    assert divmod(S("2"), S("3/2")) == Tuple(S("1"), S("1/2"))
+    assert divmod(S("3/2"), S("2")) == Tuple(S("0"), S("3/2"))
+    assert divmod(S("2"), S("3.5")) == Tuple(S("0"), S("2."))
+    assert divmod(S("3.5"), S("2")) == Tuple(S("1"), S("1.5"))
+    assert divmod(S("2"), S("1/3")) == Tuple(S("6"), S("0"))
+    assert divmod(S("1/3"), S("2")) == Tuple(S("0"), S("1/3"))
+    assert divmod(S("2"), S("1/10")) == Tuple(S("20"), S("0"))
+    assert divmod(S("2"), S(".1"))[0] == 19
+    assert divmod(S("0.1"), S("2")) == Tuple(S("0"), S("0.1"))
+    assert divmod(S("2"), 2) == Tuple(S("1"), S("0"))
+    assert divmod(2, S("2")) == Tuple(S("1"), S("0"))
+    assert divmod(S("2"), 1.5) == Tuple(S("1"), S("0.5"))
+    assert divmod(1.5, S("2")) == Tuple(S("0"), S("1.5"))
+    assert divmod(0.3, S("2")) == Tuple(S("0"), S("0.3"))
+    assert divmod(S("3/2"), S("3.5")) == Tuple(S("0"), S(3/2))
+    assert divmod(S("3.5"), S("3/2")) == Tuple(S("2"), S("0.5"))
+    assert divmod(S("3/2"), S("1/3")) == Tuple(S("4"), S("1/6"))
+    assert divmod(S("1/3"), S("3/2")) == Tuple(S("0"), S("1/3"))
+    assert divmod(S("3/2"), S("0.1"))[0] == 14
+    assert divmod(S("0.1"), S("3/2")) == Tuple(S("0"), S("0.1"))
+    assert divmod(S("3/2"), 2) == Tuple(S("0"), S("3/2"))
+    assert divmod(2, S("3/2")) == Tuple(S("1"), S("1/2"))
+    assert divmod(S("3/2"), 1.5) == Tuple(S("1"), S("0."))
+    assert divmod(1.5, S("3/2")) == Tuple(S("1"), S("0."))
+    assert divmod(S("3/2"), 0.3) == Tuple(S("5"), S("0."))
+    assert divmod(0.3, S("3/2")) == Tuple(S("0"), S("0.3"))
+    assert divmod(S("1/3"), S("3.5")) == (0, 1/3)
+    assert divmod(S("3.5"), S("0.1")) == Tuple(S("35"), S("0."))
+    assert divmod(S("0.1"), S("3.5")) == Tuple(S("0"), S("0.1"))
+    assert divmod(S("3.5"), 2) == Tuple(S("1"), S("1.5"))
+    assert divmod(2, S("3.5")) == Tuple(S("0"), S("2."))
+    assert divmod(S("3.5"), 1.5) == Tuple(S("2"), S("0.5"))
+    assert divmod(1.5, S("3.5")) == Tuple(S("0"), S("1.5"))
+    assert divmod(0.3, S("3.5")) == Tuple(S("0"), S("0.3"))
+    assert divmod(S("0.1"), S("1/3")) == Tuple(S("0"), S("0.1"))
+    assert divmod(S("1/3"), 2) == Tuple(S("0"), S("1/3"))
+    assert divmod(2, S("1/3")) == Tuple(S("6"), S("0"))
+    assert divmod(S("1/3"), 1.5) == (0, 1/3)
+    assert divmod(0.3, S("1/3")) == (0, 0.3)
+    assert divmod(S("0.1"), 2) == (0, 0.1)
+    assert divmod(2, S("0.1"))[0] == 19
+    assert divmod(S("0.1"), 1.5) == (0, 0.1)
+    assert divmod(1.5, S("0.1")) == Tuple(S("15"), S("0."))
+    assert divmod(S("0.1"), 0.3) == Tuple(S("0"), S("0.1"))
+
+    assert str(divmod(S("2"), 0.3)) == '(6, 0.2)'
+    assert str(divmod(S("3.5"), S("1/3"))) == '(10, 0.166666666666667)'
+    assert str(divmod(S("3.5"), 0.3)) == '(11, 0.2)'
+    assert str(divmod(S("1/3"), S("0.1"))) == '(3, 0.0333333333333333)'
+    assert str(divmod(1.5, S("1/3"))) == '(4, 0.166666666666667)'
+    assert str(divmod(S("1/3"), 0.3)) == '(1, 0.0333333333333333)'
+    assert str(divmod(0.3, S("0.1"))) == '(2, 0.1)'
+
+    assert divmod(-3, S(2)) == (-2, 1)
+    assert divmod(S(-3), S(2)) == (-2, 1)
+    assert divmod(S(-3), 2) == (-2, 1)
+
+    assert divmod(oo, 1) == (S.NaN, S.NaN)
+    assert divmod(S.NaN, 1) == (S.NaN, S.NaN)
+    assert divmod(1, S.NaN) == (S.NaN, S.NaN)
+    ans = [(-1, oo), (-1, oo), (0, 0), (0, 1), (0, 2)]
+    OO = float('inf')
+    ANS = [tuple(map(float, i)) for i in ans]
+    assert [divmod(i, oo) for i in range(-2, 3)] == ans
+    ans = [(0, -2), (0, -1), (0, 0), (-1, -oo), (-1, -oo)]
+    ANS = [tuple(map(float, i)) for i in ans]
+    assert [divmod(i, -oo) for i in range(-2, 3)] == ans
+    assert [divmod(i, -OO) for i in range(-2, 3)] == ANS
+
+    # sympy's divmod gives an Integer for the quotient rather than a float
+    dmod = lambda a, b: tuple([j if i else int(j) for i, j in enumerate(divmod(a, b))])
+    for a in (4, 4., 4.25, 0, 0., -4, -4. -4.25):
+        for b in (2, 2., 2.5, -2, -2., -2.5):
+            assert divmod(S(a), S(b)) == dmod(a, b)
+
+
+def test_igcd():
+    assert igcd(0, 0) == 0
+    assert igcd(0, 1) == 1
+    assert igcd(1, 0) == 1
+    assert igcd(0, 7) == 7
+    assert igcd(7, 0) == 7
+    assert igcd(7, 1) == 1
+    assert igcd(1, 7) == 1
+    assert igcd(-1, 0) == 1
+    assert igcd(0, -1) == 1
+    assert igcd(-1, -1) == 1
+    assert igcd(-1, 7) == 1
+    assert igcd(7, -1) == 1
+    assert igcd(8, 2) == 2
+    assert igcd(4, 8) == 4
+    assert igcd(8, 16) == 8
+    assert igcd(7, -3) == 1
+    assert igcd(-7, 3) == 1
+    assert igcd(-7, -3) == 1
+    assert igcd(*[10, 20, 30]) == 10
+    raises(TypeError, lambda: igcd())
+    raises(TypeError, lambda: igcd(2))
+    raises(ValueError, lambda: igcd(0, None))
+    raises(ValueError, lambda: igcd(1, 2.2))
+    for args in permutations((45.1, 1, 30)):
+        raises(ValueError, lambda: igcd(*args))
+    for args in permutations((1, 2, None)):
+        raises(ValueError, lambda: igcd(*args))
+
+
+def test_igcd_lehmer():
+    a, b = fibonacci(10001), fibonacci(10000)
+    # len(str(a)) == 2090
+    # small divisors, long Euclidean sequence
+    assert igcd_lehmer(a, b) == 1
+    c = fibonacci(100)
+    assert igcd_lehmer(a*c, b*c) == c
+    # big divisor
+    assert igcd_lehmer(a, 10**1000) == 1
+    # swapping argument
+    assert igcd_lehmer(1, 2) == igcd_lehmer(2, 1)
+
+
+def test_igcd2():
+    # short loop
+    assert igcd2(2**100 - 1, 2**99 - 1) == 1
+    # Lehmer's algorithm
+    a, b = int(fibonacci(10001)), int(fibonacci(10000))
+    assert igcd2(a, b) == 1
+
+
+def test_ilcm():
+    assert ilcm(0, 0) == 0
+    assert ilcm(1, 0) == 0
+    assert ilcm(0, 1) == 0
+    assert ilcm(1, 1) == 1
+    assert ilcm(2, 1) == 2
+    assert ilcm(8, 2) == 8
+    assert ilcm(8, 6) == 24
+    assert ilcm(8, 7) == 56
+    assert ilcm(*[10, 20, 30]) == 60
+    raises(ValueError, lambda: ilcm(8.1, 7))
+    raises(ValueError, lambda: ilcm(8, 7.1))
+    raises(TypeError, lambda: ilcm(8))
+
+
+def test_igcdex():
+    assert igcdex(2, 3) == (-1, 1, 1)
+    assert igcdex(10, 12) == (-1, 1, 2)
+    assert igcdex(100, 2004) == (-20, 1, 4)
+    assert igcdex(0, 0) == (0, 0, 0)
+    assert igcdex(1, 0) == (1, 0, 1)
+
+
+def _strictly_equal(a, b):
+    return (a.p, a.q, type(a.p), type(a.q)) == \
+           (b.p, b.q, type(b.p), type(b.q))
+
+
+def _test_rational_new(cls):
+    """
+    Tests that are common between Integer and Rational.
+    """
+    assert cls(0) is S.Zero
+    assert cls(1) is S.One
+    assert cls(-1) is S.NegativeOne
+    # These look odd, but are similar to int():
+    assert cls('1') is S.One
+    assert cls('-1') is S.NegativeOne
+
+    i = Integer(10)
+    assert _strictly_equal(i, cls('10'))
+    assert _strictly_equal(i, cls('10'))
+    assert _strictly_equal(i, cls(int(10)))
+    assert _strictly_equal(i, cls(i))
+
+    raises(TypeError, lambda: cls(Symbol('x')))
+
+
+def test_Integer_new():
+    """
+    Test for Integer constructor
+    """
+    _test_rational_new(Integer)
+
+    assert _strictly_equal(Integer(0.9), S.Zero)
+    assert _strictly_equal(Integer(10.5), Integer(10))
+    raises(ValueError, lambda: Integer("10.5"))
+    assert Integer(Rational('1.' + '9'*20)) == 1
+
+
+def test_Rational_new():
+    """"
+    Test for Rational constructor
+    """
+    _test_rational_new(Rational)
+
+    n1 = S.Half
+    assert n1 == Rational(Integer(1), 2)
+    assert n1 == Rational(Integer(1), Integer(2))
+    assert n1 == Rational(1, Integer(2))
+    assert n1 == Rational(S.Half)
+    assert 1 == Rational(n1, n1)
+    assert Rational(3, 2) == Rational(S.Half, Rational(1, 3))
+    assert Rational(3, 1) == Rational(1, Rational(1, 3))
+    n3_4 = Rational(3, 4)
+    assert Rational('3/4') == n3_4
+    assert -Rational('-3/4') == n3_4
+    assert Rational('.76').limit_denominator(4) == n3_4
+    assert Rational(19, 25).limit_denominator(4) == n3_4
+    assert Rational('19/25').limit_denominator(4) == n3_4
+    assert Rational(1.0, 3) == Rational(1, 3)
+    assert Rational(1, 3.0) == Rational(1, 3)
+    assert Rational(Float(0.5)) == S.Half
+    assert Rational('1e2/1e-2') == Rational(10000)
+    assert Rational('1 234') == Rational(1234)
+    assert Rational('1/1 234') == Rational(1, 1234)
+    assert Rational(-1, 0) is S.ComplexInfinity
+    assert Rational(1, 0) is S.ComplexInfinity
+    # Make sure Rational doesn't lose precision on Floats
+    assert Rational(pi.evalf(100)).evalf(100) == pi.evalf(100)
+    raises(TypeError, lambda: Rational('3**3'))
+    raises(TypeError, lambda: Rational('1/2 + 2/3'))
+
+    # handle fractions.Fraction instances
+    try:
+        import fractions
+        assert Rational(fractions.Fraction(1, 2)) == S.Half
+    except ImportError:
+        pass
+
+    assert Rational(PythonRational(2, 6)) == Rational(1, 3)
+
+    with warns_deprecated_sympy():
+        assert Rational(2, 4, gcd=1).q == 4
+    with warns_deprecated_sympy():
+        n = Rational(2, -4, gcd=1)
+    assert n.q == 4
+    assert n.p == -2
+
+    assert Rational.from_coprime_ints(3, 5) == Rational(3, 5)
+
+
+def test_issue_24543():
+    for p in ('1.5', 1.5, 2):
+        for q in ('1.5', 1.5, 2):
+            assert Rational(p, q).as_numer_denom() == Rational('%s/%s'%(p,q)).as_numer_denom()
+
+    assert Rational('0.5', '100') == Rational(1, 200)
+
+
+def test_Number_new():
+    """"
+    Test for Number constructor
+    """
+    # Expected behavior on numbers and strings
+    assert Number(1) is S.One
+    assert Number(2).__class__ is Integer
+    assert Number(-622).__class__ is Integer
+    assert Number(5, 3).__class__ is Rational
+    assert Number(5.3).__class__ is Float
+    assert Number('1') is S.One
+    assert Number('2').__class__ is Integer
+    assert Number('-622').__class__ is Integer
+    assert Number('5/3').__class__ is Rational
+    assert Number('5.3').__class__ is Float
+    raises(ValueError, lambda: Number('cos'))
+    raises(TypeError, lambda: Number(cos))
+    a = Rational(3, 5)
+    assert Number(a) is a  # Check idempotence on Numbers
+    u = ['inf', '-inf', 'nan', 'iNF', '+inf']
+    v = [oo, -oo, nan, oo, oo]
+    for i, a in zip(u, v):
+        assert Number(i) is a, (i, Number(i), a)
+
+
+def test_Number_cmp():
+    n1 = Number(1)
+    n2 = Number(2)
+    n3 = Number(-3)
+
+    assert n1 < n2
+    assert n1 <= n2
+    assert n3 < n1
+    assert n2 > n3
+    assert n2 >= n3
+
+    raises(TypeError, lambda: n1 < S.NaN)
+    raises(TypeError, lambda: n1 <= S.NaN)
+    raises(TypeError, lambda: n1 > S.NaN)
+    raises(TypeError, lambda: n1 >= S.NaN)
+
+
+def test_Rational_cmp():
+    n1 = Rational(1, 4)
+    n2 = Rational(1, 3)
+    n3 = Rational(2, 4)
+    n4 = Rational(2, -4)
+    n5 = Rational(0)
+    n6 = Rational(1)
+    n7 = Rational(3)
+    n8 = Rational(-3)
+
+    assert n8 < n5
+    assert n5 < n6
+    assert n6 < n7
+    assert n8 < n7
+    assert n7 > n8
+    assert (n1 + 1)**n2 < 2
+    assert ((n1 + n6)/n7) < 1
+
+    assert n4 < n3
+    assert n2 < n3
+    assert n1 < n2
+    assert n3 > n1
+    assert not n3 < n1
+    assert not (Rational(-1) > 0)
+    assert Rational(-1) < 0
+
+    raises(TypeError, lambda: n1 < S.NaN)
+    raises(TypeError, lambda: n1 <= S.NaN)
+    raises(TypeError, lambda: n1 > S.NaN)
+    raises(TypeError, lambda: n1 >= S.NaN)
+
+
+def test_Float():
+    def eq(a, b):
+        t = Float("1.0E-15")
+        return (-t < a - b < t)
+
+    equal_pairs = [
+        (0, 0.0), # This is just how Python works...
+        (0, S.Zero),
+        (0.0, Float(0)),
+    ]
+    unequal_pairs = [
+        (0.0, S.Zero),
+        (0, Float(0)),
+        (S.Zero, Float(0)),
+    ]
+    for p1, p2 in equal_pairs:
+        assert (p1 == p2) is True
+        assert (p1 != p2) is False
+        assert (p2 == p1) is True
+        assert (p2 != p1) is False
+    for p1, p2 in unequal_pairs:
+        assert (p1 == p2) is False
+        assert (p1 != p2) is True
+        assert (p2 == p1) is False
+        assert (p2 != p1) is True
+
+    assert S.Zero.is_zero
+
+    a = Float(2) ** Float(3)
+    assert eq(a.evalf(), Float(8))
+    assert eq((pi ** -1).evalf(), Float("0.31830988618379067"))
+    a = Float(2) ** Float(4)
+    assert eq(a.evalf(), Float(16))
+    assert (S(.3) == S(.5)) is False
+
+    mpf = (0, 5404319552844595, -52, 53)
+    x_str = Float((0, '13333333333333', -52, 53))
+    x_0xstr = Float((0, '0x13333333333333', -52, 53))
+    x2_str = Float((0, '26666666666666', -53, 54))
+    x_hex = Float((0, int(0x13333333333333), -52, 53))
+    x_dec = Float(mpf)
+    assert x_str == x_0xstr == x_hex == x_dec == Float(1.2)
+    # x2_str was entered slightly malformed in that the mantissa
+    # was even -- it should be odd and the even part should be
+    # included with the exponent, but this is resolved by normalization
+    # ONLY IF REQUIREMENTS of mpf_norm are met: the bitcount must
+    # be exact: double the mantissa ==> increase bc by 1
+    assert Float(1.2)._mpf_ == mpf
+    assert x2_str._mpf_ == mpf
+
+    assert Float((0, int(0), -123, -1)) is S.NaN
+    assert Float((0, int(0), -456, -2)) is S.Infinity
+    assert Float((1, int(0), -789, -3)) is S.NegativeInfinity
+    # if you don't give the full signature, it's not special
+    assert Float((0, int(0), -123)) == Float(0)
+    assert Float((0, int(0), -456)) == Float(0)
+    assert Float((1, int(0), -789)) == Float(0)
+
+    raises(ValueError, lambda: Float((0, 7, 1, 3), ''))
+
+    assert Float('0.0').is_finite is True
+    assert Float('0.0').is_negative is False
+    assert Float('0.0').is_positive is False
+    assert Float('0.0').is_infinite is False
+    assert Float('0.0').is_zero is True
+
+    # rationality properties
+    # if the integer test fails then the use of intlike
+    # should be removed from gamma_functions.py
+    assert Float(1).is_integer is None
+    assert Float(1).is_rational is None
+    assert Float(1).is_irrational is None
+    assert sqrt(2).n(15).is_rational is None
+    assert sqrt(2).n(15).is_irrational is None
+
+    # do not automatically evalf
+    def teq(a):
+        assert (a.evalf() == a) is False
+        assert (a.evalf() != a) is True
+        assert (a == a.evalf()) is False
+        assert (a != a.evalf()) is True
+
+    teq(pi)
+    teq(2*pi)
+    teq(cos(0.1, evaluate=False))
+
+    # long integer
+    i = 12345678901234567890
+    assert same_and_same_prec(Float(12, ''), Float('12', ''))
+    assert same_and_same_prec(Float(Integer(i), ''), Float(i, ''))
+    assert same_and_same_prec(Float(i, ''), Float(str(i), 20))
+    assert same_and_same_prec(Float(str(i)), Float(i, ''))
+    assert same_and_same_prec(Float(i), Float(i, ''))
+
+    # inexact floats (repeating binary = denom not multiple of 2)
+    # cannot have precision greater than 15
+    assert Float(.125, 22)._prec == 76
+    assert Float(2.0, 22)._prec == 76
+    # only default prec is equal, even for exactly representable float
+    assert Float(.125, 22) != .125
+    #assert Float(2.0, 22) == 2
+    assert float(Float('.12500000000000001', '')) == .125
+    raises(ValueError, lambda: Float(.12500000000000001, ''))
+
+    # allow spaces
+    assert Float('123 456.123 456') == Float('123456.123456')
+    assert Integer('123 456') == Integer('123456')
+    assert Rational('123 456.123 456') == Rational('123456.123456')
+    assert Float(' .3e2') == Float('0.3e2')
+    # but treat them as strictly ass underscore between digits: only 1
+    raises(ValueError, lambda: Float('1  2'))
+
+    # allow underscore between digits
+    assert Float('1_23.4_56') == Float('123.456')
+    # assert Float('1_23.4_5_6', 12) == Float('123.456', 12)
+    # ...but not in all cases (per Py 3.6)
+    raises(ValueError, lambda: Float('1_'))
+    raises(ValueError, lambda: Float('1__2'))
+    raises(ValueError, lambda: Float('_1'))
+    raises(ValueError, lambda: Float('_inf'))
+
+    # allow auto precision detection
+    assert Float('.1', '') == Float(.1, 1)
+    assert Float('.125', '') == Float(.125, 3)
+    assert Float('.100', '') == Float(.1, 3)
+    assert Float('2.0', '') == Float('2', 2)
+
+    raises(ValueError, lambda: Float("12.3d-4", ""))
+    raises(ValueError, lambda: Float(12.3, ""))
+    raises(ValueError, lambda: Float('.'))
+    raises(ValueError, lambda: Float('-.'))
+
+    zero = Float('0.0')
+    assert Float('-0') == zero
+    assert Float('.0') == zero
+    assert Float('-.0') == zero
+    assert Float('-0.0') == zero
+    assert Float(0.0) == zero
+    assert Float(0) == zero
+    assert Float(0, '') == Float('0', '')
+    assert Float(1) == Float(1.0)
+    assert Float(S.Zero) == zero
+    assert Float(S.One) == Float(1.0)
+
+    assert Float(decimal.Decimal('0.1'), 3) == Float('.1', 3)
+    assert Float(decimal.Decimal('nan')) is S.NaN
+    assert Float(decimal.Decimal('Infinity')) is S.Infinity
+    assert Float(decimal.Decimal('-Infinity')) is S.NegativeInfinity
+
+    assert '{:.3f}'.format(Float(4.236622)) == '4.237'
+    assert '{:.35f}'.format(Float(pi.n(40), 40)) == \
+        '3.14159265358979323846264338327950288'
+
+    # unicode
+    assert Float('0.73908513321516064100000000') == \
+        Float('0.73908513321516064100000000')
+    assert Float('0.73908513321516064100000000', 28) == \
+        Float('0.73908513321516064100000000', 28)
+
+    # binary precision
+    # Decimal value 0.1 cannot be expressed precisely as a base 2 fraction
+    a = Float(S.One/10, dps=15)
+    b = Float(S.One/10, dps=16)
+    p = Float(S.One/10, precision=53)
+    q = Float(S.One/10, precision=54)
+    assert a._mpf_ == p._mpf_
+    assert not a._mpf_ == q._mpf_
+    assert not b._mpf_ == q._mpf_
+
+    # Precision specifying errors
+    raises(ValueError, lambda: Float("1.23", dps=3, precision=10))
+    raises(ValueError, lambda: Float("1.23", dps="", precision=10))
+    raises(ValueError, lambda: Float("1.23", dps=3, precision=""))
+    raises(ValueError, lambda: Float("1.23", dps="", precision=""))
+
+    # from NumberSymbol
+    assert same_and_same_prec(Float(pi, 32), pi.evalf(32))
+    assert same_and_same_prec(Float(Catalan), Catalan.evalf())
+
+    # oo and nan
+    u = ['inf', '-inf', 'nan', 'iNF', '+inf']
+    v = [oo, -oo, nan, oo, oo]
+    for i, a in zip(u, v):
+        assert Float(i) is a
+
+
+def test_zero_not_false():
+    # https://github.com/sympy/sympy/issues/20796
+    assert (S(0.0) == S.false) is False
+    assert (S.false == S(0.0)) is False
+    assert (S(0) == S.false) is False
+    assert (S.false == S(0)) is False
+
+
+@conserve_mpmath_dps
+def test_float_mpf():
+    import mpmath
+    mpmath.mp.dps = 100
+    mp_pi = mpmath.pi()
+
+    assert Float(mp_pi, 100) == Float(mp_pi._mpf_, 100) == pi.evalf(100)
+
+    mpmath.mp.dps = 15
+
+    assert Float(mp_pi, 100) == Float(mp_pi._mpf_, 100) == pi.evalf(100)
+
+
+def test_Float_RealElement():
+    repi = RealField(dps=100)(pi.evalf(100))
+    # We still have to pass the precision because Float doesn't know what
+    # RealElement is, but make sure it keeps full precision from the result.
+    assert Float(repi, 100) == pi.evalf(100)
+
+
+def test_Float_default_to_highprec_from_str():
+    s = str(pi.evalf(128))
+    assert same_and_same_prec(Float(s), Float(s, ''))
+
+
+def test_Float_eval():
+    a = Float(3.2)
+    assert (a**2).is_Float
+
+
+def test_Float_issue_2107():
+    a = Float(0.1, 10)
+    b = Float("0.1", 10)
+
+    assert a - a == 0
+    assert a + (-a) == 0
+    assert S.Zero + a - a == 0
+    assert S.Zero + a + (-a) == 0
+
+    assert b - b == 0
+    assert b + (-b) == 0
+    assert S.Zero + b - b == 0
+    assert S.Zero + b + (-b) == 0
+
+
+def test_issue_14289():
+    from sympy.polys.numberfields import to_number_field
+
+    a = 1 - sqrt(2)
+    b = to_number_field(a)
+    assert b.as_expr() == a
+    assert b.minpoly(a).expand() == 0
+
+
+def test_Float_from_tuple():
+    a = Float((0, '1L', 0, 1))
+    b = Float((0, '1', 0, 1))
+    assert a == b
+
+
+def test_Infinity():
+    assert oo != 1
+    assert 1*oo is oo
+    assert 1 != oo
+    assert oo != -oo
+    assert oo != Symbol("x")**3
+    assert oo + 1 is oo
+    assert 2 + oo is oo
+    assert 3*oo + 2 is oo
+    assert S.Half**oo == 0
+    assert S.Half**(-oo) is oo
+    assert -oo*3 is -oo
+    assert oo + oo is oo
+    assert -oo + oo*(-5) is -oo
+    assert 1/oo == 0
+    assert 1/(-oo) == 0
+    assert 8/oo == 0
+    assert oo % 2 is nan
+    assert 2 % oo is nan
+    assert oo/oo is nan
+    assert oo/-oo is nan
+    assert -oo/oo is nan
+    assert -oo/-oo is nan
+    assert oo - oo is nan
+    assert oo - -oo is oo
+    assert -oo - oo is -oo
+    assert -oo - -oo is nan
+    assert oo + -oo is nan
+    assert -oo + oo is nan
+    assert oo + oo is oo
+    assert -oo + oo is nan
+    assert oo + -oo is nan
+    assert -oo + -oo is -oo
+    assert oo*oo is oo
+    assert -oo*oo is -oo
+    assert oo*-oo is -oo
+    assert -oo*-oo is oo
+    assert oo/0 is oo
+    assert -oo/0 is -oo
+    assert 0/oo == 0
+    assert 0/-oo == 0
+    assert oo*0 is nan
+    assert -oo*0 is nan
+    assert 0*oo is nan
+    assert 0*-oo is nan
+    assert oo + 0 is oo
+    assert -oo + 0 is -oo
+    assert 0 + oo is oo
+    assert 0 + -oo is -oo
+    assert oo - 0 is oo
+    assert -oo - 0 is -oo
+    assert 0 - oo is -oo
+    assert 0 - -oo is oo
+    assert oo/2 is oo
+    assert -oo/2 is -oo
+    assert oo/-2 is -oo
+    assert -oo/-2 is oo
+    assert oo*2 is oo
+    assert -oo*2 is -oo
+    assert oo*-2 is -oo
+    assert 2/oo == 0
+    assert 2/-oo == 0
+    assert -2/oo == 0
+    assert -2/-oo == 0
+    assert 2*oo is oo
+    assert 2*-oo is -oo
+    assert -2*oo is -oo
+    assert -2*-oo is oo
+    assert 2 + oo is oo
+    assert 2 - oo is -oo
+    assert -2 + oo is oo
+    assert -2 - oo is -oo
+    assert 2 + -oo is -oo
+    assert 2 - -oo is oo
+    assert -2 + -oo is -oo
+    assert -2 - -oo is oo
+    assert S(2) + oo is oo
+    assert S(2) - oo is -oo
+    assert oo/I == -oo*I
+    assert -oo/I == oo*I
+    assert oo*float(1) == _inf and (oo*float(1)) is oo
+    assert -oo*float(1) == _ninf and (-oo*float(1)) is -oo
+    assert oo/float(1) == _inf and (oo/float(1)) is oo
+    assert -oo/float(1) == _ninf and (-oo/float(1)) is -oo
+    assert oo*float(-1) == _ninf and (oo*float(-1)) is -oo
+    assert -oo*float(-1) == _inf and (-oo*float(-1)) is oo
+    assert oo/float(-1) == _ninf and (oo/float(-1)) is -oo
+    assert -oo/float(-1) == _inf and (-oo/float(-1)) is oo
+    assert oo + float(1) == _inf and (oo + float(1)) is oo
+    assert -oo + float(1) == _ninf and (-oo + float(1)) is -oo
+    assert oo - float(1) == _inf and (oo - float(1)) is oo
+    assert -oo - float(1) == _ninf and (-oo - float(1)) is -oo
+    assert float(1)*oo == _inf and (float(1)*oo) is oo
+    assert float(1)*-oo == _ninf and (float(1)*-oo) is -oo
+    assert float(1)/oo == 0
+    assert float(1)/-oo == 0
+    assert float(-1)*oo == _ninf and (float(-1)*oo) is -oo
+    assert float(-1)*-oo == _inf and (float(-1)*-oo) is oo
+    assert float(-1)/oo == 0
+    assert float(-1)/-oo == 0
+    assert float(1) + oo is oo
+    assert float(1) + -oo is -oo
+    assert float(1) - oo is -oo
+    assert float(1) - -oo is oo
+    assert oo == float(oo)
+    assert (oo != float(oo)) is False
+    assert type(float(oo)) is float
+    assert -oo == float(-oo)
+    assert (-oo != float(-oo)) is False
+    assert type(float(-oo)) is float
+
+    assert Float('nan') is nan
+    assert nan*1.0 is nan
+    assert -1.0*nan is nan
+    assert nan*oo is nan
+    assert nan*-oo is nan
+    assert nan/oo is nan
+    assert nan/-oo is nan
+    assert nan + oo is nan
+    assert nan + -oo is nan
+    assert nan - oo is nan
+    assert nan - -oo is nan
+    assert -oo * S.Zero is nan
+
+    assert oo*nan is nan
+    assert -oo*nan is nan
+    assert oo/nan is nan
+    assert -oo/nan is nan
+    assert oo + nan is nan
+    assert -oo + nan is nan
+    assert oo - nan is nan
+    assert -oo - nan is nan
+    assert S.Zero * oo is nan
+    assert oo.is_Rational is False
+    assert isinstance(oo, Rational) is False
+
+    assert S.One/oo == 0
+    assert -S.One/oo == 0
+    assert S.One/-oo == 0
+    assert -S.One/-oo == 0
+    assert S.One*oo is oo
+    assert -S.One*oo is -oo
+    assert S.One*-oo is -oo
+    assert -S.One*-oo is oo
+    assert S.One/nan is nan
+    assert S.One - -oo is oo
+    assert S.One + nan is nan
+    assert S.One - nan is nan
+    assert nan - S.One is nan
+    assert nan/S.One is nan
+    assert -oo - S.One is -oo
+
+
+def test_Infinity_2():
+    x = Symbol('x')
+    assert oo*x != oo
+    assert oo*(pi - 1) is oo
+    assert oo*(1 - pi) is -oo
+
+    assert (-oo)*x != -oo
+    assert (-oo)*(pi - 1) is -oo
+    assert (-oo)*(1 - pi) is oo
+
+    assert (-1)**S.NaN is S.NaN
+    assert oo - _inf is S.NaN
+    assert oo + _ninf is S.NaN
+    assert oo*0 is S.NaN
+    assert oo/_inf is S.NaN
+    assert oo/_ninf is S.NaN
+    assert oo**S.NaN is S.NaN
+    assert -oo + _inf is S.NaN
+    assert -oo - _ninf is S.NaN
+    assert -oo*S.NaN is S.NaN
+    assert -oo*0 is S.NaN
+    assert -oo/_inf is S.NaN
+    assert -oo/_ninf is S.NaN
+    assert -oo/S.NaN is S.NaN
+    assert abs(-oo) is oo
+    assert all((-oo)**i is S.NaN for i in (oo, -oo, S.NaN))
+    assert (-oo)**3 is -oo
+    assert (-oo)**2 is oo
+    assert abs(S.ComplexInfinity) is oo
+
+
+def test_Mul_Infinity_Zero():
+    assert Float(0)*_inf is nan
+    assert Float(0)*_ninf is nan
+    assert Float(0)*_inf is nan
+    assert Float(0)*_ninf is nan
+    assert _inf*Float(0) is nan
+    assert _ninf*Float(0) is nan
+    assert _inf*Float(0) is nan
+    assert _ninf*Float(0) is nan
+
+
+def test_Div_By_Zero():
+    assert 1/S.Zero is zoo
+    assert 1/Float(0) is zoo
+    assert 0/S.Zero is nan
+    assert 0/Float(0) is nan
+    assert S.Zero/0 is nan
+    assert Float(0)/0 is nan
+    assert -1/S.Zero is zoo
+    assert -1/Float(0) is zoo
+
+
+@_both_exp_pow
+def test_Infinity_inequations():
+    assert oo > pi
+    assert not (oo < pi)
+    assert exp(-3) < oo
+
+    assert _inf > pi
+    assert not (_inf < pi)
+    assert exp(-3) < _inf
+
+    raises(TypeError, lambda: oo < I)
+    raises(TypeError, lambda: oo <= I)
+    raises(TypeError, lambda: oo > I)
+    raises(TypeError, lambda: oo >= I)
+    raises(TypeError, lambda: -oo < I)
+    raises(TypeError, lambda: -oo <= I)
+    raises(TypeError, lambda: -oo > I)
+    raises(TypeError, lambda: -oo >= I)
+
+    raises(TypeError, lambda: I < oo)
+    raises(TypeError, lambda: I <= oo)
+    raises(TypeError, lambda: I > oo)
+    raises(TypeError, lambda: I >= oo)
+    raises(TypeError, lambda: I < -oo)
+    raises(TypeError, lambda: I <= -oo)
+    raises(TypeError, lambda: I > -oo)
+    raises(TypeError, lambda: I >= -oo)
+
+    assert oo > -oo and oo >= -oo
+    assert (oo < -oo) == False and (oo <= -oo) == False
+    assert -oo < oo and -oo <= oo
+    assert (-oo > oo) == False and (-oo >= oo) == False
+
+    assert (oo < oo) == False  # issue 7775
+    assert (oo > oo) == False
+    assert (-oo > -oo) == False and (-oo < -oo) == False
+    assert oo >= oo and oo <= oo and -oo >= -oo and -oo <= -oo
+    assert (-oo < -_inf) ==  False
+    assert (oo > _inf) == False
+    assert -oo >= -_inf
+    assert oo <= _inf
+
+    x = Symbol('x')
+    b = Symbol('b', finite=True, real=True)
+    assert (x < oo) == Lt(x, oo)  # issue 7775
+    assert b < oo and b > -oo and b <= oo and b >= -oo
+    assert oo > b and oo >= b and (oo < b) == False and (oo <= b) == False
+    assert (-oo > b) == False and (-oo >= b) == False and -oo < b and -oo <= b
+    assert (oo < x) == Lt(oo, x) and (oo > x) == Gt(oo, x)
+    assert (oo <= x) == Le(oo, x) and (oo >= x) == Ge(oo, x)
+    assert (-oo < x) == Lt(-oo, x) and (-oo > x) == Gt(-oo, x)
+    assert (-oo <= x) == Le(-oo, x) and (-oo >= x) == Ge(-oo, x)
+
+
+def test_NaN():
+    assert nan is nan
+    assert nan != 1
+    assert 1*nan is nan
+    assert 1 != nan
+    assert -nan is nan
+    assert oo != Symbol("x")**3
+    assert 2 + nan is nan
+    assert 3*nan + 2 is nan
+    assert -nan*3 is nan
+    assert nan + nan is nan
+    assert -nan + nan*(-5) is nan
+    assert 8/nan is nan
+    raises(TypeError, lambda: nan > 0)
+    raises(TypeError, lambda: nan < 0)
+    raises(TypeError, lambda: nan >= 0)
+    raises(TypeError, lambda: nan <= 0)
+    raises(TypeError, lambda: 0 < nan)
+    raises(TypeError, lambda: 0 > nan)
+    raises(TypeError, lambda: 0 <= nan)
+    raises(TypeError, lambda: 0 >= nan)
+    assert nan**0 == 1  # as per IEEE 754
+    assert 1**nan is nan # IEEE 754 is not the best choice for symbolic work
+    # test Pow._eval_power's handling of NaN
+    assert Pow(nan, 0, evaluate=False)**2 == 1
+    for n in (1, 1., S.One, S.NegativeOne, Float(1)):
+        assert n + nan is nan
+        assert n - nan is nan
+        assert nan + n is nan
+        assert nan - n is nan
+        assert n/nan is nan
+        assert nan/n is nan
+
+
+def test_special_numbers():
+    assert isinstance(S.NaN, Number) is True
+    assert isinstance(S.Infinity, Number) is True
+    assert isinstance(S.NegativeInfinity, Number) is True
+
+    assert S.NaN.is_number is True
+    assert S.Infinity.is_number is True
+    assert S.NegativeInfinity.is_number is True
+    assert S.ComplexInfinity.is_number is True
+
+    assert isinstance(S.NaN, Rational) is False
+    assert isinstance(S.Infinity, Rational) is False
+    assert isinstance(S.NegativeInfinity, Rational) is False
+
+    assert S.NaN.is_rational is not True
+    assert S.Infinity.is_rational is not True
+    assert S.NegativeInfinity.is_rational is not True
+
+
+def test_powers():
+    assert integer_nthroot(1, 2) == (1, True)
+    assert integer_nthroot(1, 5) == (1, True)
+    assert integer_nthroot(2, 1) == (2, True)
+    assert integer_nthroot(2, 2) == (1, False)
+    assert integer_nthroot(2, 5) == (1, False)
+    assert integer_nthroot(4, 2) == (2, True)
+    assert integer_nthroot(123**25, 25) == (123, True)
+    assert integer_nthroot(123**25 + 1, 25) == (123, False)
+    assert integer_nthroot(123**25 - 1, 25) == (122, False)
+    assert integer_nthroot(1, 1) == (1, True)
+    assert integer_nthroot(0, 1) == (0, True)
+    assert integer_nthroot(0, 3) == (0, True)
+    assert integer_nthroot(10000, 1) == (10000, True)
+    assert integer_nthroot(4, 2) == (2, True)
+    assert integer_nthroot(16, 2) == (4, True)
+    assert integer_nthroot(26, 2) == (5, False)
+    assert integer_nthroot(1234567**7, 7) == (1234567, True)
+    assert integer_nthroot(1234567**7 + 1, 7) == (1234567, False)
+    assert integer_nthroot(1234567**7 - 1, 7) == (1234566, False)
+    b = 25**1000
+    assert integer_nthroot(b, 1000) == (25, True)
+    assert integer_nthroot(b + 1, 1000) == (25, False)
+    assert integer_nthroot(b - 1, 1000) == (24, False)
+    c = 10**400
+    c2 = c**2
+    assert integer_nthroot(c2, 2) == (c, True)
+    assert integer_nthroot(c2 + 1, 2) == (c, False)
+    assert integer_nthroot(c2 - 1, 2) == (c - 1, False)
+    assert integer_nthroot(2, 10**10) == (1, False)
+
+    p, r = integer_nthroot(int(factorial(10000)), 100)
+    assert p % (10**10) == 5322420655
+    assert not r
+
+    # Test that this is fast
+    assert integer_nthroot(2, 10**10) == (1, False)
+
+    # output should be int if possible
+    assert type(integer_nthroot(2**61, 2)[0]) is int
+
+
+def test_integer_nthroot_overflow():
+    assert integer_nthroot(10**(50*50), 50) == (10**50, True)
+    assert integer_nthroot(10**100000, 10000) == (10**10, True)
+
+
+def test_integer_log():
+    raises(ValueError, lambda: integer_log(2, 1))
+    raises(ValueError, lambda: integer_log(0, 2))
+    raises(ValueError, lambda: integer_log(1.1, 2))
+    raises(ValueError, lambda: integer_log(1, 2.2))
+
+    assert integer_log(1, 2) == (0, True)
+    assert integer_log(1, 3) == (0, True)
+    assert integer_log(2, 3) == (0, False)
+    assert integer_log(3, 3) == (1, True)
+    assert integer_log(3*2, 3) == (1, False)
+    assert integer_log(3**2, 3) == (2, True)
+    assert integer_log(3*4, 3) == (2, False)
+    assert integer_log(3**3, 3) == (3, True)
+    assert integer_log(27, 5) == (2, False)
+    assert integer_log(2, 3) == (0, False)
+    assert integer_log(-4, 2) == (2, False)
+    assert integer_log(-16, 4) == (0, False)
+    assert integer_log(-4, -2) == (2, False)
+    assert integer_log(4, -2) == (2, True)
+    assert integer_log(-8, -2) == (3, True)
+    assert integer_log(8, -2) == (3, False)
+    assert integer_log(-9, 3) == (0, False)
+    assert integer_log(-9, -3) == (2, False)
+    assert integer_log(9, -3) == (2, True)
+    assert integer_log(-27, -3) == (3, True)
+    assert integer_log(27, -3) == (3, False)
+
+
+def test_isqrt():
+    from math import sqrt as _sqrt
+    limit = 4503599761588223
+    assert int(_sqrt(limit)) == integer_nthroot(limit, 2)[0]
+    assert int(_sqrt(limit + 1)) != integer_nthroot(limit + 1, 2)[0]
+    assert isqrt(limit + 1) == integer_nthroot(limit + 1, 2)[0]
+    assert isqrt(limit + S.Half) == integer_nthroot(limit, 2)[0]
+    assert isqrt(limit + 1 + S.Half) == integer_nthroot(limit + 1, 2)[0]
+    assert isqrt(limit + 2 + S.Half) == integer_nthroot(limit + 2, 2)[0]
+
+    # Regression tests for https://github.com/sympy/sympy/issues/17034
+    assert isqrt(4503599761588224) == 67108864
+    assert isqrt(9999999999999999) == 99999999
+
+    # Other corner cases, especially involving non-integers.
+    raises(ValueError, lambda: isqrt(-1))
+    raises(ValueError, lambda: isqrt(-10**1000))
+    raises(ValueError, lambda: isqrt(Rational(-1, 2)))
+
+    tiny = Rational(1, 10**1000)
+    raises(ValueError, lambda: isqrt(-tiny))
+    assert isqrt(1-tiny) == 0
+    assert isqrt(4503599761588224-tiny) == 67108864
+    assert isqrt(10**100 - tiny) == 10**50 - 1
+
+
+def test_powers_Integer():
+    """Test Integer._eval_power"""
+    # check infinity
+    assert S.One ** S.Infinity is S.NaN
+    assert S.NegativeOne** S.Infinity is S.NaN
+    assert S(2) ** S.Infinity is S.Infinity
+    assert S(-2)** S.Infinity == zoo
+    assert S(0) ** S.Infinity is S.Zero
+
+    # check Nan
+    assert S.One ** S.NaN is S.NaN
+    assert S.NegativeOne ** S.NaN is S.NaN
+
+    # check for exact roots
+    assert S.NegativeOne ** Rational(6, 5) == - (-1)**(S.One/5)
+    assert sqrt(S(4)) == 2
+    assert sqrt(S(-4)) == I * 2
+    assert S(16) ** Rational(1, 4) == 2
+    assert S(-16) ** Rational(1, 4) == 2 * (-1)**Rational(1, 4)
+    assert S(9) ** Rational(3, 2) == 27
+    assert S(-9) ** Rational(3, 2) == -27*I
+    assert S(27) ** Rational(2, 3) == 9
+    assert S(-27) ** Rational(2, 3) == 9 * (S.NegativeOne ** Rational(2, 3))
+    assert (-2) ** Rational(-2, 1) == Rational(1, 4)
+
+    # not exact roots
+    assert sqrt(-3) == I*sqrt(3)
+    assert (3) ** (Rational(3, 2)) == 3 * sqrt(3)
+    assert (-3) ** (Rational(3, 2)) == - 3 * sqrt(-3)
+    assert (-3) ** (Rational(5, 2)) == 9 * I * sqrt(3)
+    assert (-3) ** (Rational(7, 2)) == - I * 27 * sqrt(3)
+    assert (2) ** (Rational(3, 2)) == 2 * sqrt(2)
+    assert (2) ** (Rational(-3, 2)) == sqrt(2) / 4
+    assert (81) ** (Rational(2, 3)) == 9 * (S(3) ** (Rational(2, 3)))
+    assert (-81) ** (Rational(2, 3)) == 9 * (S(-3) ** (Rational(2, 3)))
+    assert (-3) ** Rational(-7, 3) == \
+        -(-1)**Rational(2, 3)*3**Rational(2, 3)/27
+    assert (-3) ** Rational(-2, 3) == \
+        -(-1)**Rational(1, 3)*3**Rational(1, 3)/3
+
+    # join roots
+    assert sqrt(6) + sqrt(24) == 3*sqrt(6)
+    assert sqrt(2) * sqrt(3) == sqrt(6)
+
+    # separate symbols & constansts
+    x = Symbol("x")
+    assert sqrt(49 * x) == 7 * sqrt(x)
+    assert sqrt((3 - sqrt(pi)) ** 2) == 3 - sqrt(pi)
+
+    # check that it is fast for big numbers
+    assert (2**64 + 1) ** Rational(4, 3)
+    assert (2**64 + 1) ** Rational(17, 25)
+
+    # negative rational power and negative base
+    assert (-3) ** Rational(-7, 3) == \
+        -(-1)**Rational(2, 3)*3**Rational(2, 3)/27
+    assert (-3) ** Rational(-2, 3) == \
+        -(-1)**Rational(1, 3)*3**Rational(1, 3)/3
+    assert (-2) ** Rational(-10, 3) == \
+        (-1)**Rational(2, 3)*2**Rational(2, 3)/16
+    assert abs(Pow(-2, Rational(-10, 3)).n() -
+        Pow(-2, Rational(-10, 3), evaluate=False).n()) < 1e-16
+
+    # negative base and rational power with some simplification
+    assert (-8) ** Rational(2, 5) == \
+        2*(-1)**Rational(2, 5)*2**Rational(1, 5)
+    assert (-4) ** Rational(9, 5) == \
+        -8*(-1)**Rational(4, 5)*2**Rational(3, 5)
+
+    assert S(1234).factors() == {617: 1, 2: 1}
+    assert Rational(2*3, 3*5*7).factors() == {2: 1, 5: -1, 7: -1}
+
+    # test that eval_power factors numbers bigger than
+    # the current limit in factor_trial_division (2**15)
+    from sympy.ntheory.generate import nextprime
+    n = nextprime(2**15)
+    assert sqrt(n**2) == n
+    assert sqrt(n**3) == n*sqrt(n)
+    assert sqrt(4*n) == 2*sqrt(n)
+
+    # check that factors of base with powers sharing gcd with power are removed
+    assert (2**4*3)**Rational(1, 6) == 2**Rational(2, 3)*3**Rational(1, 6)
+    assert (2**4*3)**Rational(5, 6) == 8*2**Rational(1, 3)*3**Rational(5, 6)
+
+    # check that bases sharing a gcd are exptracted
+    assert 2**Rational(1, 3)*3**Rational(1, 4)*6**Rational(1, 5) == \
+        2**Rational(8, 15)*3**Rational(9, 20)
+    assert sqrt(8)*24**Rational(1, 3)*6**Rational(1, 5) == \
+        4*2**Rational(7, 10)*3**Rational(8, 15)
+    assert sqrt(8)*(-24)**Rational(1, 3)*(-6)**Rational(1, 5) == \
+        4*(-3)**Rational(8, 15)*2**Rational(7, 10)
+    assert 2**Rational(1, 3)*2**Rational(8, 9) == 2*2**Rational(2, 9)
+    assert 2**Rational(2, 3)*6**Rational(1, 3) == 2*3**Rational(1, 3)
+    assert 2**Rational(2, 3)*6**Rational(8, 9) == \
+        2*2**Rational(5, 9)*3**Rational(8, 9)
+    assert (-2)**Rational(2, S(3))*(-4)**Rational(1, S(3)) == -2*2**Rational(1, 3)
+    assert 3*Pow(3, 2, evaluate=False) == 3**3
+    assert 3*Pow(3, Rational(-1, 3), evaluate=False) == 3**Rational(2, 3)
+    assert (-2)**Rational(1, 3)*(-3)**Rational(1, 4)*(-5)**Rational(5, 6) == \
+        -(-1)**Rational(5, 12)*2**Rational(1, 3)*3**Rational(1, 4) * \
+        5**Rational(5, 6)
+
+    assert Integer(-2)**Symbol('', even=True) == \
+        Integer(2)**Symbol('', even=True)
+    assert (-1)**Float(.5) == 1.0*I
+
+
+def test_powers_Rational():
+    """Test Rational._eval_power"""
+    # check infinity
+    assert S.Half ** S.Infinity == 0
+    assert Rational(3, 2) ** S.Infinity is S.Infinity
+    assert Rational(-1, 2) ** S.Infinity == 0
+    assert Rational(-3, 2) ** S.Infinity == zoo
+
+    # check Nan
+    assert Rational(3, 4) ** S.NaN is S.NaN
+    assert Rational(-2, 3) ** S.NaN is S.NaN
+
+    # exact roots on numerator
+    assert sqrt(Rational(4, 3)) == 2 * sqrt(3) / 3
+    assert Rational(4, 3) ** Rational(3, 2) == 8 * sqrt(3) / 9
+    assert sqrt(Rational(-4, 3)) == I * 2 * sqrt(3) / 3
+    assert Rational(-4, 3) ** Rational(3, 2) == - I * 8 * sqrt(3) / 9
+    assert Rational(27, 2) ** Rational(1, 3) == 3 * (2 ** Rational(2, 3)) / 2
+    assert Rational(5**3, 8**3) ** Rational(4, 3) == Rational(5**4, 8**4)
+
+    # exact root on denominator
+    assert sqrt(Rational(1, 4)) == S.Half
+    assert sqrt(Rational(1, -4)) == I * S.Half
+    assert sqrt(Rational(3, 4)) == sqrt(3) / 2
+    assert sqrt(Rational(3, -4)) == I * sqrt(3) / 2
+    assert Rational(5, 27) ** Rational(1, 3) == (5 ** Rational(1, 3)) / 3
+
+    # not exact roots
+    assert sqrt(S.Half) == sqrt(2) / 2
+    assert sqrt(Rational(-4, 7)) == I * sqrt(Rational(4, 7))
+    assert Rational(-3, 2)**Rational(-7, 3) == \
+        -4*(-1)**Rational(2, 3)*2**Rational(1, 3)*3**Rational(2, 3)/27
+    assert Rational(-3, 2)**Rational(-2, 3) == \
+        -(-1)**Rational(1, 3)*2**Rational(2, 3)*3**Rational(1, 3)/3
+    assert Rational(-3, 2)**Rational(-10, 3) == \
+        8*(-1)**Rational(2, 3)*2**Rational(1, 3)*3**Rational(2, 3)/81
+    assert abs(Pow(Rational(-2, 3), Rational(-7, 4)).n() -
+        Pow(Rational(-2, 3), Rational(-7, 4), evaluate=False).n()) < 1e-16
+
+    # negative integer power and negative rational base
+    assert Rational(-2, 3) ** Rational(-2, 1) == Rational(9, 4)
+
+    a = Rational(1, 10)
+    assert a**Float(a, 2) == Float(a, 2)**Float(a, 2)
+    assert Rational(-2, 3)**Symbol('', even=True) == \
+        Rational(2, 3)**Symbol('', even=True)
+
+
+def test_powers_Float():
+    assert str((S('-1/10')**S('3/10')).n()) == str(Float(-.1)**(.3))
+
+
+def test_lshift_Integer():
+    assert Integer(0) << Integer(2) == Integer(0)
+    assert Integer(0) << 2 == Integer(0)
+    assert 0 << Integer(2) == Integer(0)
+
+    assert Integer(0b11) << Integer(0) == Integer(0b11)
+    assert Integer(0b11) << 0 == Integer(0b11)
+    assert 0b11 << Integer(0) == Integer(0b11)
+
+    assert Integer(0b11) << Integer(2) == Integer(0b11 << 2)
+    assert Integer(0b11) << 2 == Integer(0b11 << 2)
+    assert 0b11 << Integer(2) == Integer(0b11 << 2)
+
+    assert Integer(-0b11) << Integer(2) == Integer(-0b11 << 2)
+    assert Integer(-0b11) << 2 == Integer(-0b11 << 2)
+    assert -0b11 << Integer(2) == Integer(-0b11 << 2)
+
+    raises(TypeError, lambda: Integer(2) << 0.0)
+    raises(TypeError, lambda: 0.0 << Integer(2))
+    raises(ValueError, lambda: Integer(1) << Integer(-1))
+
+
+def test_rshift_Integer():
+    assert Integer(0) >> Integer(2) == Integer(0)
+    assert Integer(0) >> 2 == Integer(0)
+    assert 0 >> Integer(2) == Integer(0)
+
+    assert Integer(0b11) >> Integer(0) == Integer(0b11)
+    assert Integer(0b11) >> 0 == Integer(0b11)
+    assert 0b11 >> Integer(0) == Integer(0b11)
+
+    assert Integer(0b11) >> Integer(2) == Integer(0)
+    assert Integer(0b11) >> 2 == Integer(0)
+    assert 0b11 >> Integer(2) == Integer(0)
+
+    assert Integer(-0b11) >> Integer(2) == Integer(-1)
+    assert Integer(-0b11) >> 2 == Integer(-1)
+    assert -0b11 >> Integer(2) == Integer(-1)
+
+    assert Integer(0b1100) >> Integer(2) == Integer(0b1100 >> 2)
+    assert Integer(0b1100) >> 2 == Integer(0b1100 >> 2)
+    assert 0b1100 >> Integer(2) == Integer(0b1100 >> 2)
+
+    assert Integer(-0b1100) >> Integer(2) == Integer(-0b1100 >> 2)
+    assert Integer(-0b1100) >> 2 == Integer(-0b1100 >> 2)
+    assert -0b1100 >> Integer(2) == Integer(-0b1100 >> 2)
+
+    raises(TypeError, lambda: Integer(0b10) >> 0.0)
+    raises(TypeError, lambda: 0.0 >> Integer(2))
+    raises(ValueError, lambda: Integer(1) >> Integer(-1))
+
+
+def test_and_Integer():
+    assert Integer(0b01010101) & Integer(0b10101010) == Integer(0)
+    assert Integer(0b01010101) & 0b10101010 == Integer(0)
+    assert 0b01010101 & Integer(0b10101010) == Integer(0)
+
+    assert Integer(0b01010101) & Integer(0b11011011) == Integer(0b01010001)
+    assert Integer(0b01010101) & 0b11011011 == Integer(0b01010001)
+    assert 0b01010101 & Integer(0b11011011) == Integer(0b01010001)
+
+    assert -Integer(0b01010101) & Integer(0b11011011) == Integer(-0b01010101 & 0b11011011)
+    assert Integer(-0b01010101) & 0b11011011 == Integer(-0b01010101 & 0b11011011)
+    assert -0b01010101 & Integer(0b11011011) == Integer(-0b01010101 & 0b11011011)
+
+    assert Integer(0b01010101) & -Integer(0b11011011) == Integer(0b01010101 & -0b11011011)
+    assert Integer(0b01010101) & -0b11011011 == Integer(0b01010101 & -0b11011011)
+    assert 0b01010101 & Integer(-0b11011011) == Integer(0b01010101 & -0b11011011)
+
+    raises(TypeError, lambda: Integer(2) & 0.0)
+    raises(TypeError, lambda: 0.0 & Integer(2))
+
+
+def test_xor_Integer():
+    assert Integer(0b01010101) ^ Integer(0b11111111) == Integer(0b10101010)
+    assert Integer(0b01010101) ^ 0b11111111 == Integer(0b10101010)
+    assert 0b01010101 ^ Integer(0b11111111) == Integer(0b10101010)
+
+    assert Integer(0b01010101) ^ Integer(0b11011011) == Integer(0b10001110)
+    assert Integer(0b01010101) ^ 0b11011011 == Integer(0b10001110)
+    assert 0b01010101 ^ Integer(0b11011011) == Integer(0b10001110)
+
+    assert -Integer(0b01010101) ^ Integer(0b11011011) == Integer(-0b01010101 ^ 0b11011011)
+    assert Integer(-0b01010101) ^ 0b11011011 == Integer(-0b01010101 ^ 0b11011011)
+    assert -0b01010101 ^ Integer(0b11011011) == Integer(-0b01010101 ^ 0b11011011)
+
+    assert Integer(0b01010101) ^ -Integer(0b11011011) == Integer(0b01010101 ^ -0b11011011)
+    assert Integer(0b01010101) ^ -0b11011011 == Integer(0b01010101 ^ -0b11011011)
+    assert 0b01010101 ^ Integer(-0b11011011) == Integer(0b01010101 ^ -0b11011011)
+
+    raises(TypeError, lambda: Integer(2) ^ 0.0)
+    raises(TypeError, lambda: 0.0 ^ Integer(2))
+
+
+def test_or_Integer():
+    assert Integer(0b01010101) | Integer(0b10101010) == Integer(0b11111111)
+    assert Integer(0b01010101) | 0b10101010 == Integer(0b11111111)
+    assert 0b01010101 | Integer(0b10101010) == Integer(0b11111111)
+
+    assert Integer(0b01010101) | Integer(0b11011011) == Integer(0b11011111)
+    assert Integer(0b01010101) | 0b11011011 == Integer(0b11011111)
+    assert 0b01010101 | Integer(0b11011011) == Integer(0b11011111)
+
+    assert -Integer(0b01010101) | Integer(0b11011011) == Integer(-0b01010101 | 0b11011011)
+    assert Integer(-0b01010101) | 0b11011011 == Integer(-0b01010101 | 0b11011011)
+    assert -0b01010101 | Integer(0b11011011) == Integer(-0b01010101 | 0b11011011)
+
+    assert Integer(0b01010101) | -Integer(0b11011011) == Integer(0b01010101 | -0b11011011)
+    assert Integer(0b01010101) | -0b11011011 == Integer(0b01010101 | -0b11011011)
+    assert 0b01010101 | Integer(-0b11011011) == Integer(0b01010101 | -0b11011011)
+
+    raises(TypeError, lambda: Integer(2) | 0.0)
+    raises(TypeError, lambda: 0.0 | Integer(2))
+
+
+def test_invert_Integer():
+    assert ~Integer(0b01010101) == Integer(-0b01010110)
+    assert ~Integer(0b01010101) == Integer(~0b01010101)
+    assert ~(~Integer(0b01010101)) == Integer(0b01010101)
+
+
+def test_abs1():
+    assert Rational(1, 6) != Rational(-1, 6)
+    assert abs(Rational(1, 6)) == abs(Rational(-1, 6))
+
+
+def test_accept_int():
+    assert not Float(4) == 4
+    assert Float(4) != 4
+    assert Float(4) == 4.0
+
+
+def test_dont_accept_str():
+    assert Float("0.2") != "0.2"
+    assert not (Float("0.2") == "0.2")
+
+
+def test_int():
+    a = Rational(5)
+    assert int(a) == 5
+    a = Rational(9, 10)
+    assert int(a) == int(-a) == 0
+    assert 1/(-1)**Rational(2, 3) == -(-1)**Rational(1, 3)
+    # issue 10368
+    a = Rational(32442016954, 78058255275)
+    assert type(int(a)) is type(int(-a)) is int
+
+
+def test_int_NumberSymbols():
+    assert int(Catalan) == 0
+    assert int(EulerGamma) == 0
+    assert int(pi) == 3
+    assert int(E) == 2
+    assert int(GoldenRatio) == 1
+    assert int(TribonacciConstant) == 1
+    for i in [Catalan, E, EulerGamma, GoldenRatio, TribonacciConstant, pi]:
+        a, b = i.approximation_interval(Integer)
+        ia = int(i)
+        assert ia == a
+        assert isinstance(ia, int)
+        assert b == a + 1
+        assert a.is_Integer and b.is_Integer
+
+
+def test_real_bug():
+    x = Symbol("x")
+    assert str(2.0*x*x) in ["(2.0*x)*x", "2.0*x**2", "2.00000000000000*x**2"]
+    assert str(2.1*x*x) != "(2.0*x)*x"
+
+
+def test_bug_sqrt():
+    assert ((sqrt(Rational(2)) + 1)*(sqrt(Rational(2)) - 1)).expand() == 1
+
+
+def test_pi_Pi():
+    "Test that pi (instance) is imported, but Pi (class) is not"
+    from sympy import pi  # noqa
+    with raises(ImportError):
+        from sympy import Pi  # noqa
+
+
+def test_no_len():
+    # there should be no len for numbers
+    raises(TypeError, lambda: len(Rational(2)))
+    raises(TypeError, lambda: len(Rational(2, 3)))
+    raises(TypeError, lambda: len(Integer(2)))
+
+
+def test_issue_3321():
+    assert sqrt(Rational(1, 5)) == Rational(1, 5)**S.Half
+    assert 5 * sqrt(Rational(1, 5)) == sqrt(5)
+
+
+def test_issue_3692():
+    assert ((-1)**Rational(1, 6)).expand(complex=True) == I/2 + sqrt(3)/2
+    assert ((-5)**Rational(1, 6)).expand(complex=True) == \
+        5**Rational(1, 6)*I/2 + 5**Rational(1, 6)*sqrt(3)/2
+    assert ((-64)**Rational(1, 6)).expand(complex=True) == I + sqrt(3)
+
+
+def test_issue_3423():
+    x = Symbol("x")
+    assert sqrt(x - 1).as_base_exp() == (x - 1, S.Half)
+    assert sqrt(x - 1) != I*sqrt(1 - x)
+
+
+def test_issue_3449():
+    x = Symbol("x")
+    assert sqrt(x - 1).subs(x, 5) == 2
+
+
+def test_issue_13890():
+    x = Symbol("x")
+    e = (-x/4 - S.One/12)**x - 1
+    f = simplify(e)
+    a = Rational(9, 5)
+    assert abs(e.subs(x,a).evalf() - f.subs(x,a).evalf()) < 1e-15
+
+
+def test_Integer_factors():
+    def F(i):
+        return Integer(i).factors()
+
+    assert F(1) == {}
+    assert F(2) == {2: 1}
+    assert F(3) == {3: 1}
+    assert F(4) == {2: 2}
+    assert F(5) == {5: 1}
+    assert F(6) == {2: 1, 3: 1}
+    assert F(7) == {7: 1}
+    assert F(8) == {2: 3}
+    assert F(9) == {3: 2}
+    assert F(10) == {2: 1, 5: 1}
+    assert F(11) == {11: 1}
+    assert F(12) == {2: 2, 3: 1}
+    assert F(13) == {13: 1}
+    assert F(14) == {2: 1, 7: 1}
+    assert F(15) == {3: 1, 5: 1}
+    assert F(16) == {2: 4}
+    assert F(17) == {17: 1}
+    assert F(18) == {2: 1, 3: 2}
+    assert F(19) == {19: 1}
+    assert F(20) == {2: 2, 5: 1}
+    assert F(21) == {3: 1, 7: 1}
+    assert F(22) == {2: 1, 11: 1}
+    assert F(23) == {23: 1}
+    assert F(24) == {2: 3, 3: 1}
+    assert F(25) == {5: 2}
+    assert F(26) == {2: 1, 13: 1}
+    assert F(27) == {3: 3}
+    assert F(28) == {2: 2, 7: 1}
+    assert F(29) == {29: 1}
+    assert F(30) == {2: 1, 3: 1, 5: 1}
+    assert F(31) == {31: 1}
+    assert F(32) == {2: 5}
+    assert F(33) == {3: 1, 11: 1}
+    assert F(34) == {2: 1, 17: 1}
+    assert F(35) == {5: 1, 7: 1}
+    assert F(36) == {2: 2, 3: 2}
+    assert F(37) == {37: 1}
+    assert F(38) == {2: 1, 19: 1}
+    assert F(39) == {3: 1, 13: 1}
+    assert F(40) == {2: 3, 5: 1}
+    assert F(41) == {41: 1}
+    assert F(42) == {2: 1, 3: 1, 7: 1}
+    assert F(43) == {43: 1}
+    assert F(44) == {2: 2, 11: 1}
+    assert F(45) == {3: 2, 5: 1}
+    assert F(46) == {2: 1, 23: 1}
+    assert F(47) == {47: 1}
+    assert F(48) == {2: 4, 3: 1}
+    assert F(49) == {7: 2}
+    assert F(50) == {2: 1, 5: 2}
+    assert F(51) == {3: 1, 17: 1}
+
+
+def test_Rational_factors():
+    def F(p, q, visual=None):
+        return Rational(p, q).factors(visual=visual)
+
+    assert F(2, 3) == {2: 1, 3: -1}
+    assert F(2, 9) == {2: 1, 3: -2}
+    assert F(2, 15) == {2: 1, 3: -1, 5: -1}
+    assert F(6, 10) == {3: 1, 5: -1}
+
+
+def test_issue_4107():
+    assert pi*(E + 10) + pi*(-E - 10) != 0
+    assert pi*(E + 10**10) + pi*(-E - 10**10) != 0
+    assert pi*(E + 10**20) + pi*(-E - 10**20) != 0
+    assert pi*(E + 10**80) + pi*(-E - 10**80) != 0
+
+    assert (pi*(E + 10) + pi*(-E - 10)).expand() == 0
+    assert (pi*(E + 10**10) + pi*(-E - 10**10)).expand() == 0
+    assert (pi*(E + 10**20) + pi*(-E - 10**20)).expand() == 0
+    assert (pi*(E + 10**80) + pi*(-E - 10**80)).expand() == 0
+
+
+def test_IntegerInteger():
+    a = Integer(4)
+    b = Integer(a)
+
+    assert a == b
+
+
+def test_Rational_gcd_lcm_cofactors():
+    assert Integer(4).gcd(2) == Integer(2)
+    assert Integer(4).lcm(2) == Integer(4)
+    assert Integer(4).gcd(Integer(2)) == Integer(2)
+    assert Integer(4).lcm(Integer(2)) == Integer(4)
+    a, b = 720**99911, 480**12342
+    assert Integer(a).lcm(b) == a*b/Integer(a).gcd(b)
+
+    assert Integer(4).gcd(3) == Integer(1)
+    assert Integer(4).lcm(3) == Integer(12)
+    assert Integer(4).gcd(Integer(3)) == Integer(1)
+    assert Integer(4).lcm(Integer(3)) == Integer(12)
+
+    assert Rational(4, 3).gcd(2) == Rational(2, 3)
+    assert Rational(4, 3).lcm(2) == Integer(4)
+    assert Rational(4, 3).gcd(Integer(2)) == Rational(2, 3)
+    assert Rational(4, 3).lcm(Integer(2)) == Integer(4)
+
+    assert Integer(4).gcd(Rational(2, 9)) == Rational(2, 9)
+    assert Integer(4).lcm(Rational(2, 9)) == Integer(4)
+
+    assert Rational(4, 3).gcd(Rational(2, 9)) == Rational(2, 9)
+    assert Rational(4, 3).lcm(Rational(2, 9)) == Rational(4, 3)
+    assert Rational(4, 5).gcd(Rational(2, 9)) == Rational(2, 45)
+    assert Rational(4, 5).lcm(Rational(2, 9)) == Integer(4)
+    assert Rational(5, 9).lcm(Rational(3, 7)) == Rational(Integer(5).lcm(3),Integer(9).gcd(7))
+
+    assert Integer(4).cofactors(2) == (Integer(2), Integer(2), Integer(1))
+    assert Integer(4).cofactors(Integer(2)) == \
+        (Integer(2), Integer(2), Integer(1))
+
+    assert Integer(4).gcd(Float(2.0)) == Float(1.0)
+    assert Integer(4).lcm(Float(2.0)) == Float(8.0)
+    assert Integer(4).cofactors(Float(2.0)) == (Float(1.0), Float(4.0), Float(2.0))
+
+    assert S.Half.gcd(Float(2.0)) == Float(1.0)
+    assert S.Half.lcm(Float(2.0)) == Float(1.0)
+    assert S.Half.cofactors(Float(2.0)) == \
+        (Float(1.0), Float(0.5), Float(2.0))
+
+
+def test_Float_gcd_lcm_cofactors():
+    assert Float(2.0).gcd(Integer(4)) == Float(1.0)
+    assert Float(2.0).lcm(Integer(4)) == Float(8.0)
+    assert Float(2.0).cofactors(Integer(4)) == (Float(1.0), Float(2.0), Float(4.0))
+
+    assert Float(2.0).gcd(S.Half) == Float(1.0)
+    assert Float(2.0).lcm(S.Half) == Float(1.0)
+    assert Float(2.0).cofactors(S.Half) == \
+        (Float(1.0), Float(2.0), Float(0.5))
+
+
+def test_issue_4611():
+    assert abs(pi._evalf(50) - 3.14159265358979) < 1e-10
+    assert abs(E._evalf(50) - 2.71828182845905) < 1e-10
+    assert abs(Catalan._evalf(50) - 0.915965594177219) < 1e-10
+    assert abs(EulerGamma._evalf(50) - 0.577215664901533) < 1e-10
+    assert abs(GoldenRatio._evalf(50) - 1.61803398874989) < 1e-10
+    assert abs(TribonacciConstant._evalf(50) - 1.83928675521416) < 1e-10
+
+    x = Symbol("x")
+    assert (pi + x).evalf() == pi.evalf() + x
+    assert (E + x).evalf() == E.evalf() + x
+    assert (Catalan + x).evalf() == Catalan.evalf() + x
+    assert (EulerGamma + x).evalf() == EulerGamma.evalf() + x
+    assert (GoldenRatio + x).evalf() == GoldenRatio.evalf() + x
+    assert (TribonacciConstant + x).evalf() == TribonacciConstant.evalf() + x
+
+
+@conserve_mpmath_dps
+def test_conversion_to_mpmath():
+    assert mpmath.mpmathify(Integer(1)) == mpmath.mpf(1)
+    assert mpmath.mpmathify(S.Half) == mpmath.mpf(0.5)
+    assert mpmath.mpmathify(Float('1.23', 15)) == mpmath.mpf('1.23')
+
+    assert mpmath.mpmathify(I) == mpmath.mpc(1j)
+
+    assert mpmath.mpmathify(1 + 2*I) == mpmath.mpc(1 + 2j)
+    assert mpmath.mpmathify(1.0 + 2*I) == mpmath.mpc(1 + 2j)
+    assert mpmath.mpmathify(1 + 2.0*I) == mpmath.mpc(1 + 2j)
+    assert mpmath.mpmathify(1.0 + 2.0*I) == mpmath.mpc(1 + 2j)
+    assert mpmath.mpmathify(S.Half + S.Half*I) == mpmath.mpc(0.5 + 0.5j)
+
+    assert mpmath.mpmathify(2*I) == mpmath.mpc(2j)
+    assert mpmath.mpmathify(2.0*I) == mpmath.mpc(2j)
+    assert mpmath.mpmathify(S.Half*I) == mpmath.mpc(0.5j)
+
+    mpmath.mp.dps = 100
+    assert mpmath.mpmathify(pi.evalf(100) + pi.evalf(100)*I) == mpmath.pi + mpmath.pi*mpmath.j
+    assert mpmath.mpmathify(pi.evalf(100)*I) == mpmath.pi*mpmath.j
+
+
+def test_relational():
+    # real
+    x = S(.1)
+    assert (x != cos) is True
+    assert (x == cos) is False
+
+    # rational
+    x = Rational(1, 3)
+    assert (x != cos) is True
+    assert (x == cos) is False
+
+    # integer defers to rational so these tests are omitted
+
+    # number symbol
+    x = pi
+    assert (x != cos) is True
+    assert (x == cos) is False
+
+
+def test_Integer_as_index():
+    assert 'hello'[Integer(2):] == 'llo'
+
+
+def test_Rational_int():
+    assert int( Rational(7, 5)) == 1
+    assert int( S.Half) == 0
+    assert int(Rational(-1, 2)) == 0
+    assert int(-Rational(7, 5)) == -1
+
+
+def test_zoo():
+    b = Symbol('b', finite=True)
+    nz = Symbol('nz', nonzero=True)
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    im = Symbol('i', imaginary=True)
+    c = Symbol('c', complex=True)
+    pb = Symbol('pb', positive=True)
+    nb = Symbol('nb', negative=True)
+    imb = Symbol('ib', imaginary=True, finite=True)
+    for i in [I, S.Infinity, S.NegativeInfinity, S.Zero, S.One, S.Pi, S.Half, S(3), log(3),
+              b, nz, p, n, im, pb, nb, imb, c]:
+        if i.is_finite and (i.is_real or i.is_imaginary):
+            assert i + zoo is zoo
+            assert i - zoo is zoo
+            assert zoo + i is zoo
+            assert zoo - i is zoo
+        elif i.is_finite is not False:
+            assert (i + zoo).is_Add
+            assert (i - zoo).is_Add
+            assert (zoo + i).is_Add
+            assert (zoo - i).is_Add
+        else:
+            assert (i + zoo) is S.NaN
+            assert (i - zoo) is S.NaN
+            assert (zoo + i) is S.NaN
+            assert (zoo - i) is S.NaN
+
+        if fuzzy_not(i.is_zero) and (i.is_extended_real or i.is_imaginary):
+            assert i*zoo is zoo
+            assert zoo*i is zoo
+        elif i.is_zero:
+            assert i*zoo is S.NaN
+            assert zoo*i is S.NaN
+        else:
+            assert (i*zoo).is_Mul
+            assert (zoo*i).is_Mul
+
+        if fuzzy_not((1/i).is_zero) and (i.is_real or i.is_imaginary):
+            assert zoo/i is zoo
+        elif (1/i).is_zero:
+            assert zoo/i is S.NaN
+        elif i.is_zero:
+            assert zoo/i is zoo
+        else:
+            assert (zoo/i).is_Mul
+
+    assert (I*oo).is_Mul  # allow directed infinity
+    assert zoo + zoo is S.NaN
+    assert zoo * zoo is zoo
+    assert zoo - zoo is S.NaN
+    assert zoo/zoo is S.NaN
+    assert zoo**zoo is S.NaN
+    assert zoo**0 is S.One
+    assert zoo**2 is zoo
+    assert 1/zoo is S.Zero
+
+    assert Mul.flatten([S.NegativeOne, oo, S(0)]) == ([S.NaN], [], None)
+
+
+def test_issue_4122():
+    x = Symbol('x', nonpositive=True)
+    assert oo + x is oo
+    x = Symbol('x', extended_nonpositive=True)
+    assert (oo + x).is_Add
+    x = Symbol('x', finite=True)
+    assert (oo + x).is_Add  # x could be imaginary
+    x = Symbol('x', nonnegative=True)
+    assert oo + x is oo
+    x = Symbol('x', extended_nonnegative=True)
+    assert oo + x is oo
+    x = Symbol('x', finite=True, real=True)
+    assert oo + x is oo
+
+    # similarly for negative infinity
+    x = Symbol('x', nonnegative=True)
+    assert -oo + x is -oo
+    x = Symbol('x', extended_nonnegative=True)
+    assert (-oo + x).is_Add
+    x = Symbol('x', finite=True)
+    assert (-oo + x).is_Add
+    x = Symbol('x', nonpositive=True)
+    assert -oo + x is -oo
+    x = Symbol('x', extended_nonpositive=True)
+    assert -oo + x is -oo
+    x = Symbol('x', finite=True, real=True)
+    assert -oo + x is -oo
+
+
+def test_GoldenRatio_expand():
+    assert GoldenRatio.expand(func=True) == S.Half + sqrt(5)/2
+
+
+def test_TribonacciConstant_expand():
+        assert TribonacciConstant.expand(func=True) == \
+          (1 + cbrt(19 - 3*sqrt(33)) + cbrt(19 + 3*sqrt(33))) / 3
+
+
+def test_as_content_primitive():
+    assert S.Zero.as_content_primitive() == (1, 0)
+    assert S.Half.as_content_primitive() == (S.Half, 1)
+    assert (Rational(-1, 2)).as_content_primitive() == (S.Half, -1)
+    assert S(3).as_content_primitive() == (3, 1)
+    assert S(3.1).as_content_primitive() == (1, 3.1)
+
+
+def test_hashing_sympy_integers():
+    # Test for issue 5072
+    assert {Integer(3)} == {int(3)}
+    assert hash(Integer(4)) == hash(int(4))
+
+
+def test_rounding_issue_4172():
+    assert int((E**100).round()) == \
+        26881171418161354484126255515800135873611119
+    assert int((pi**100).round()) == \
+        51878483143196131920862615246303013562686760680406
+    assert int((Rational(1)/EulerGamma**100).round()) == \
+        734833795660954410469466
+
+
+@XFAIL
+def test_mpmath_issues():
+    from mpmath.libmp.libmpf import _normalize
+    import mpmath.libmp as mlib
+    rnd = mlib.round_nearest
+    mpf = (0, int(0), -123, -1, 53, rnd)  # nan
+    assert _normalize(mpf, 53) != (0, int(0), 0, 0)
+    mpf = (0, int(0), -456, -2, 53, rnd)  # +inf
+    assert _normalize(mpf, 53) != (0, int(0), 0, 0)
+    mpf = (1, int(0), -789, -3, 53, rnd)  # -inf
+    assert _normalize(mpf, 53) != (0, int(0), 0, 0)
+
+    from mpmath.libmp.libmpf import fnan
+    assert mlib.mpf_eq(fnan, fnan)
+
+
+def test_Catalan_EulerGamma_prec():
+    n = GoldenRatio
+    f = Float(n.n(), 5)
+    assert f._mpf_ == (0, int(212079), -17, 18)
+    assert f._prec == 20
+    assert n._as_mpf_val(20) == f._mpf_
+
+    n = EulerGamma
+    f = Float(n.n(), 5)
+    assert f._mpf_ == (0, int(302627), -19, 19)
+    assert f._prec == 20
+    assert n._as_mpf_val(20) == f._mpf_
+
+
+def test_Catalan_rewrite():
+    k = Dummy('k', integer=True, nonnegative=True)
+    assert Catalan.rewrite(Sum).dummy_eq(
+            Sum((-1)**k/(2*k + 1)**2, (k, 0, oo)))
+    assert Catalan.rewrite() == Catalan
+
+
+def test_bool_eq():
+    assert 0 == False
+    assert S(0) == False
+    assert S(0) != S.false
+    assert 1 == True
+    assert S.One == True
+    assert S.One != S.true
+
+
+def test_Float_eq():
+    # Floats with different precision should not compare equal
+    assert Float(.5, 10) != Float(.5, 11) != Float(.5, 1)
+    # but floats that aren't exact in base-2 still
+    # don't compare the same because they have different
+    # underlying mpf values
+    assert Float(.12, 3) != Float(.12, 4)
+    assert Float(.12, 3) != .12
+    assert 0.12 != Float(.12, 3)
+    assert Float('.12', 22) != .12
+    # issue 11707
+    # but Float/Rational -- except for 0 --
+    # are exact so Rational(x) = Float(y) only if
+    # Rational(x) == Rational(Float(y))
+    assert Float('1.1') != Rational(11, 10)
+    assert Rational(11, 10) != Float('1.1')
+    # coverage
+    assert not Float(3) == 2
+    assert not Float(3) == Float(2)
+    assert not Float(3) == 3
+    assert not Float(2**2) == S.Half
+    assert Float(2**2) == 4.0
+    assert not Float(2**-2) == 1
+    assert Float(2**-1) == 0.5
+    assert not Float(2*3) == 3
+    assert not Float(2*3) == 0.5
+    assert Float(2*3) == 6.0
+    assert not Float(2*3) == 6
+    assert not Float(2*3) == 8
+    assert not Float(.75) == Rational(3, 4)
+    assert Float(.75) == 0.75
+    assert Float(5/18) == 5/18
+    # 4473
+    assert Float(2.) != 3
+    assert not Float((0,1,-3)) == S.One/8
+    assert Float((0,1,-3)) == 1/8
+    assert Float((0,1,-3)) != S.One/9
+    # 16196
+    assert not 2 == Float(2)  # unlike Python
+    assert t**2 != t**2.0
+
+
+def test_issue_6640():
+    from mpmath.libmp.libmpf import finf, fninf
+    # fnan is not included because Float no longer returns fnan,
+    # but otherwise, the same sort of test could apply
+    assert Float(finf).is_zero is False
+    assert Float(fninf).is_zero is False
+    assert bool(Float(0)) is False
+
+
+def test_issue_6349():
+    assert Float('23.e3', '')._prec == 10
+    assert Float('23e3', '')._prec == 20
+    assert Float('23000', '')._prec == 20
+    assert Float('-23000', '')._prec == 20
+
+
+def test_mpf_norm():
+    assert mpf_norm((1, 0, 1, 0), 10) == mpf('0')._mpf_
+    assert Float._new((1, 0, 1, 0), 10)._mpf_ == mpf('0')._mpf_
+
+
+def test_latex():
+    assert latex(pi) == r"\pi"
+    assert latex(E) == r"e"
+    assert latex(GoldenRatio) == r"\phi"
+    assert latex(TribonacciConstant) == r"\text{TribonacciConstant}"
+    assert latex(EulerGamma) == r"\gamma"
+    assert latex(oo) == r"\infty"
+    assert latex(-oo) == r"-\infty"
+    assert latex(zoo) == r"\tilde{\infty}"
+    assert latex(nan) == r"\text{NaN}"
+    assert latex(I) == r"i"
+
+
+def test_issue_7742():
+    assert -oo % 1 is nan
+
+
+def test_simplify_AlgebraicNumber():
+    A = AlgebraicNumber
+    e = 3**(S.One/6)*(3 + (135 + 78*sqrt(3))**Rational(2, 3))/(45 + 26*sqrt(3))**(S.One/3)
+    assert simplify(A(e)) == A(12)  # wester test_C20
+
+    e = (41 + 29*sqrt(2))**(S.One/5)
+    assert simplify(A(e)) == A(1 + sqrt(2))  # wester test_C21
+
+    e = (3 + 4*I)**Rational(3, 2)
+    assert simplify(A(e)) == A(2 + 11*I)  # issue 4401
+
+
+def test_Float_idempotence():
+    x = Float('1.23', '')
+    y = Float(x)
+    z = Float(x, 15)
+    assert same_and_same_prec(y, x)
+    assert not same_and_same_prec(z, x)
+    x = Float(10**20)
+    y = Float(x)
+    z = Float(x, 15)
+    assert same_and_same_prec(y, x)
+    assert not same_and_same_prec(z, x)
+
+
+def test_comp1():
+    # sqrt(2) = 1.414213 5623730950...
+    a = sqrt(2).n(7)
+    assert comp(a, 1.4142129) is False
+    assert comp(a, 1.4142130)
+    #                  ...
+    assert comp(a, 1.4142141)
+    assert comp(a, 1.4142142) is False
+    assert comp(sqrt(2).n(2), '1.4')
+    assert comp(sqrt(2).n(2), Float(1.4, 2), '')
+    assert comp(sqrt(2).n(2), 1.4, '')
+    assert comp(sqrt(2).n(2), Float(1.4, 3), '') is False
+    assert comp(sqrt(2) + sqrt(3)*I, 1.4 + 1.7*I, .1)
+    assert not comp(sqrt(2) + sqrt(3)*I, (1.5 + 1.7*I)*0.89, .1)
+    assert comp(sqrt(2) + sqrt(3)*I, (1.5 + 1.7*I)*0.90, .1)
+    assert comp(sqrt(2) + sqrt(3)*I, (1.5 + 1.7*I)*1.07, .1)
+    assert not comp(sqrt(2) + sqrt(3)*I, (1.5 + 1.7*I)*1.08, .1)
+    assert [(i, j)
+            for i in range(130, 150)
+            for j in range(170, 180)
+            if comp((sqrt(2)+ I*sqrt(3)).n(3), i/100. + I*j/100.)] == [
+        (141, 173), (142, 173)]
+    raises(ValueError, lambda: comp(t, '1'))
+    raises(ValueError, lambda: comp(t, 1))
+    assert comp(0, 0.0)
+    assert comp(.5, S.Half)
+    assert comp(2 + sqrt(2), 2.0 + sqrt(2))
+    assert not comp(0, 1)
+    assert not comp(2, sqrt(2))
+    assert not comp(2 + I, 2.0 + sqrt(2))
+    assert not comp(2.0 + sqrt(2), 2 + I)
+    assert not comp(2.0 + sqrt(2), sqrt(3))
+    assert comp(1/pi.n(4), 0.3183, 1e-5)
+    assert not comp(1/pi.n(4), 0.3183, 8e-6)
+
+
+def test_issue_9491():
+    assert oo**zoo is nan
+
+
+def test_issue_10063():
+    assert 2**Float(3) == Float(8)
+
+
+def test_issue_10020():
+    assert oo**I is S.NaN
+    assert oo**(1 + I) is S.ComplexInfinity
+    assert oo**(-1 + I) is S.Zero
+    assert (-oo)**I is S.NaN
+    assert (-oo)**(-1 + I) is S.Zero
+    assert oo**t == Pow(oo, t, evaluate=False)
+    assert (-oo)**t == Pow(-oo, t, evaluate=False)
+
+
+def test_invert_numbers():
+    assert S(2).invert(5) == 3
+    assert S(2).invert(Rational(5, 2)) == S.Half
+    assert S(2).invert(5.) == S.Half
+    assert S(2).invert(S(5)) == 3
+    assert S(2.).invert(5) == 0.5
+    assert S(sqrt(2)).invert(5) == 1/sqrt(2)
+    assert S(sqrt(2)).invert(sqrt(3)) == 1/sqrt(2)
+
+
+def test_mod_inverse():
+    assert mod_inverse(3, 11) == 4
+    assert mod_inverse(5, 11) == 9
+    assert mod_inverse(21124921, 521512) == 7713
+    assert mod_inverse(124215421, 5125) == 2981
+    assert mod_inverse(214, 12515) == 1579
+    assert mod_inverse(5823991, 3299) == 1442
+    assert mod_inverse(123, 44) == 39
+    assert mod_inverse(2, 5) == 3
+    assert mod_inverse(-2, 5) == 2
+    assert mod_inverse(2, -5) == -2
+    assert mod_inverse(-2, -5) == -3
+    assert mod_inverse(-3, -7) == -5
+    x = Symbol('x')
+    assert S(2).invert(x) == S.Half
+    raises(TypeError, lambda: mod_inverse(2, x))
+    raises(ValueError, lambda: mod_inverse(2, S.Half))
+    raises(ValueError, lambda: mod_inverse(2, cos(1)**2 + sin(1)**2))
+
+
+def test_golden_ratio_rewrite_as_sqrt():
+    assert GoldenRatio.rewrite(sqrt) == S.Half + sqrt(5)*S.Half
+
+
+def test_tribonacci_constant_rewrite_as_sqrt():
+    assert TribonacciConstant.rewrite(sqrt) == \
+      (1 + cbrt(19 - 3*sqrt(33)) + cbrt(19 + 3*sqrt(33))) / 3
+
+
+def test_comparisons_with_unknown_type():
+    class Foo:
+        """
+        Class that is unaware of Basic, and relies on both classes returning
+        the NotImplemented singleton for equivalence to evaluate to False.
+
+        """
+
+    ni, nf, nr = Integer(3), Float(1.0), Rational(1, 3)
+    foo = Foo()
+
+    for n in ni, nf, nr, oo, -oo, zoo, nan:
+        assert n != foo
+        assert foo != n
+        assert not n == foo
+        assert not foo == n
+        raises(TypeError, lambda: n < foo)
+        raises(TypeError, lambda: foo > n)
+        raises(TypeError, lambda: n > foo)
+        raises(TypeError, lambda: foo < n)
+        raises(TypeError, lambda: n <= foo)
+        raises(TypeError, lambda: foo >= n)
+        raises(TypeError, lambda: n >= foo)
+        raises(TypeError, lambda: foo <= n)
+
+    class Bar:
+        """
+        Class that considers itself equal to any instance of Number except
+        infinities and nans, and relies on SymPy types returning the
+        NotImplemented singleton for symmetric equality relations.
+
+        """
+        def __eq__(self, other):
+            if other in (oo, -oo, zoo, nan):
+                return False
+            if isinstance(other, Number):
+                return True
+            return NotImplemented
+
+        def __ne__(self, other):
+            return not self == other
+
+    bar = Bar()
+
+    for n in ni, nf, nr:
+        assert n == bar
+        assert bar == n
+        assert not n != bar
+        assert not bar != n
+
+    for n in oo, -oo, zoo, nan:
+        assert n != bar
+        assert bar != n
+        assert not n == bar
+        assert not bar == n
+
+    for n in ni, nf, nr, oo, -oo, zoo, nan:
+        raises(TypeError, lambda: n < bar)
+        raises(TypeError, lambda: bar > n)
+        raises(TypeError, lambda: n > bar)
+        raises(TypeError, lambda: bar < n)
+        raises(TypeError, lambda: n <= bar)
+        raises(TypeError, lambda: bar >= n)
+        raises(TypeError, lambda: n >= bar)
+        raises(TypeError, lambda: bar <= n)
+
+
+def test_NumberSymbol_comparison():
+    from sympy.core.tests.test_relational import rel_check
+    rpi = Rational('905502432259640373/288230376151711744')
+    fpi = Float(float(pi))
+    assert rel_check(rpi, fpi)
+
+
+def test_Integer_precision():
+    # Make sure Integer inputs for keyword args work
+    assert Float('1.0', dps=Integer(15))._prec == 53
+    assert Float('1.0', precision=Integer(15))._prec == 15
+    assert type(Float('1.0', precision=Integer(15))._prec) == int
+    assert sympify(srepr(Float('1.0', precision=15))) == Float('1.0', precision=15)
+
+
+def test_numpy_to_float():
+    from sympy.testing.pytest import skip
+    from sympy.external import import_module
+    np = import_module('numpy')
+    if not np:
+        skip('numpy not installed. Abort numpy tests.')
+
+    def check_prec_and_relerr(npval, ratval):
+        prec = np.finfo(npval).nmant + 1
+        x = Float(npval)
+        assert x._prec == prec
+        y = Float(ratval, precision=prec)
+        assert abs((x - y)/y) < 2**(-(prec + 1))
+
+    check_prec_and_relerr(np.float16(2.0/3), Rational(2, 3))
+    check_prec_and_relerr(np.float32(2.0/3), Rational(2, 3))
+    check_prec_and_relerr(np.float64(2.0/3), Rational(2, 3))
+    # extended precision, on some arch/compilers:
+    x = np.longdouble(2)/3
+    check_prec_and_relerr(x, Rational(2, 3))
+    y = Float(x, precision=10)
+    assert same_and_same_prec(y, Float(Rational(2, 3), precision=10))
+
+    raises(TypeError, lambda: Float(np.complex64(1+2j)))
+    raises(TypeError, lambda: Float(np.complex128(1+2j)))
+
+
+def test_Integer_ceiling_floor():
+    a = Integer(4)
+
+    assert a.floor() == a
+    assert a.ceiling() == a
+
+
+def test_ComplexInfinity():
+    assert zoo.floor() is zoo
+    assert zoo.ceiling() is zoo
+    assert zoo**zoo is S.NaN
+
+
+def test_Infinity_floor_ceiling_power():
+    assert oo.floor() is oo
+    assert oo.ceiling() is oo
+    assert oo**S.NaN is S.NaN
+    assert oo**zoo is S.NaN
+
+
+def test_One_power():
+    assert S.One**12 is S.One
+    assert S.NegativeOne**S.NaN is S.NaN
+
+
+def test_NegativeInfinity():
+    assert (-oo).floor() is -oo
+    assert (-oo).ceiling() is -oo
+    assert (-oo)**11 is -oo
+    assert (-oo)**12 is oo
+
+
+def test_issue_6133():
+    raises(TypeError, lambda: (-oo < None))
+    raises(TypeError, lambda: (S(-2) < None))
+    raises(TypeError, lambda: (oo < None))
+    raises(TypeError, lambda: (oo > None))
+    raises(TypeError, lambda: (S(2) < None))
+
+
+def test_abc():
+    x = numbers.Float(5)
+    assert(isinstance(x, nums.Number))
+    assert(isinstance(x, numbers.Number))
+    assert(isinstance(x, nums.Real))
+    y = numbers.Rational(1, 3)
+    assert(isinstance(y, nums.Number))
+    assert(y.numerator == 1)
+    assert(y.denominator == 3)
+    assert(isinstance(y, nums.Rational))
+    z = numbers.Integer(3)
+    assert(isinstance(z, nums.Number))
+    assert(isinstance(z, numbers.Number))
+    assert(isinstance(z, nums.Rational))
+    assert(isinstance(z, numbers.Rational))
+    assert(isinstance(z, nums.Integral))
+
+
+def test_floordiv():
+    assert S(2)//S.Half == 4
+
+
+def test_negation():
+    assert -S.Zero is S.Zero
+    assert -Float(0) is not S.Zero and -Float(0) == 0.0
+
+
+def test_exponentiation_of_0():
+    x = Symbol('x')
+    assert 0**-x == zoo**x
+    assert unchanged(Pow, 0, x)
+    x = Symbol('x', zero=True)
+    assert 0**-x == S.One
+    assert 0**x == S.One
+
+
+def test_int_valued():
+    x = Symbol('x')
+    assert int_valued(x) == False
+    assert int_valued(S.Half) == False
+    assert int_valued(S.One) == True
+    assert int_valued(Float(1)) == True
+    assert int_valued(Float(1.1)) == False
+    assert int_valued(pi) == False
+
+
+def test_equal_valued():
+    x = Symbol('x')
+
+    equal_values = [
+        [1, 1.0, S(1), S(1.0), S(1).n(5)],
+        [2, 2.0, S(2), S(2.0), S(2).n(5)],
+        [-1, -1.0, -S(1), -S(1.0), -S(1).n(5)],
+        [0.5, S(0.5), S(1)/2],
+        [-0.5, -S(0.5), -S(1)/2],
+        [0, 0.0, S(0), S(0.0), S(0).n()],
+        [pi], [pi.n()],           # <-- not equal
+        [S(1)/10], [0.1, S(0.1)], # <-- not equal
+        [S(0.1).n(5)],
+        [oo],
+        [cos(x/2)], [cos(0.5*x)], # <-- no recursion
+    ]
+
+    for m, values_m in enumerate(equal_values):
+        for value_i in values_m:
+
+            # All values in same list equal
+            for value_j in values_m:
+                assert equal_valued(value_i, value_j) is True
+
+            # Not equal to anything in any other list:
+            for n, values_n in enumerate(equal_values):
+                if n == m:
+                    continue
+                for value_j in values_n:
+                    assert equal_valued(value_i, value_j) is False
+
+
+def test_all_close():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+    assert all_close(2, 2) is True
+    assert all_close(2, 2.0000) is True
+    assert all_close(2, 2.0001) is False
+    assert all_close(1/3, 1/3.0001) is False
+    assert all_close(1/3, 1/3.0001, 1e-3, 1e-3) is True
+    assert all_close(1/3, Rational(1, 3)) is True
+    assert all_close(0.1*exp(0.2*x), exp(x/5)/10) is True
+    # The expressions should be structurally the same modulo identity:
+    assert all_close(1.4142135623730951, sqrt(2)) is False
+    assert all_close(1.4142135623730951, sqrt(2).evalf()) is True
+    assert all_close(x + 1e-20, x) is True
+    # We should be able to match terms of an Add/Mul in any order
+    assert all_close(Add(1, 2, evaluate=False), Add(2, 1, evaluate=False))
+    # coverage
+    assert not all_close(2*x, 3*x)
+    assert all_close(2*x, 3*x, 1)
+    assert not all_close(2*x, 3*x, 0, 0.5)
+    assert all_close(2*x, 3*x, 0, 1)
+    assert not all_close(y*x, z*x)
+    assert all_close(2*x*exp(1.0*x), 2.0*x*exp(x))
+    assert not all_close(2*x*exp(1.0*x), 2.0*x*exp(2.*x))
+    assert all_close(x + 2.*y, 1.*x + 2*y)
+    assert all_close(x + exp(2.*x)*y, 1.*x + exp(2*x)*y)
+    assert not all_close(x + exp(2.*x)*y, 1.*x + 2*exp(2*x)*y)
+    assert not all_close(x + exp(2.*x)*y, 1.*x + exp(3*x)*y)
+    assert not all_close(x + 2.*y, 1.*x + 3*y)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_operations.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_operations.py
new file mode 100644
index 0000000000000000000000000000000000000000..c60d691ef00ee9601ada04ef68e2db37794a81ad
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_operations.py
@@ -0,0 +1,110 @@
+from sympy.core.expr import Expr
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.core.operations import AssocOp, LatticeOp
+from sympy.testing.pytest import raises
+from sympy.core.sympify import SympifyError
+from sympy.core.add import Add, add
+from sympy.core.mul import Mul, mul
+
+# create the simplest possible Lattice class
+
+
+class join(LatticeOp):
+    zero = Integer(0)
+    identity = Integer(1)
+
+
+def test_lattice_simple():
+    assert join(join(2, 3), 4) == join(2, join(3, 4))
+    assert join(2, 3) == join(3, 2)
+    assert join(0, 2) == 0
+    assert join(1, 2) == 2
+    assert join(2, 2) == 2
+
+    assert join(join(2, 3), 4) == join(2, 3, 4)
+    assert join() == 1
+    assert join(4) == 4
+    assert join(1, 4, 2, 3, 1, 3, 2) == join(2, 3, 4)
+
+
+def test_lattice_shortcircuit():
+    raises(SympifyError, lambda: join(object))
+    assert join(0, object) == 0
+
+
+def test_lattice_print():
+    assert str(join(5, 4, 3, 2)) == 'join(2, 3, 4, 5)'
+
+
+def test_lattice_make_args():
+    assert join.make_args(join(2, 3, 4)) == {S(2), S(3), S(4)}
+    assert join.make_args(0) == {0}
+    assert list(join.make_args(0))[0] is S.Zero
+    assert Add.make_args(0)[0] is S.Zero
+
+
+def test_issue_14025():
+    a, b, c, d = symbols('a,b,c,d', commutative=False)
+    assert Mul(a, b, c).has(c*b) == False
+    assert Mul(a, b, c).has(b*c) == True
+    assert Mul(a, b, c, d).has(b*c*d) == True
+
+
+def test_AssocOp_flatten():
+    a, b, c, d = symbols('a,b,c,d')
+
+    class MyAssoc(AssocOp):
+        identity = S.One
+
+    assert MyAssoc(a, MyAssoc(b, c)).args == \
+        MyAssoc(MyAssoc(a, b), c).args == \
+        MyAssoc(MyAssoc(a, b, c)).args == \
+        MyAssoc(a, b, c).args == \
+            (a, b, c)
+    u = MyAssoc(b, c)
+    v = MyAssoc(u, d, evaluate=False)
+    assert v.args == (u, d)
+    # like Add, any unevaluated outer call will flatten inner args
+    assert MyAssoc(a, v).args == (a, b, c, d)
+
+
+def test_add_dispatcher():
+
+    class NewBase(Expr):
+        @property
+        def _add_handler(self):
+            return NewAdd
+    class NewAdd(NewBase, Add):
+        pass
+    add.register_handlerclass((Add, NewAdd), NewAdd)
+
+    a, b = Symbol('a'), NewBase()
+
+    # Add called as fallback
+    assert add(1, 2) == Add(1, 2)
+    assert add(a, a) == Add(a, a)
+
+    # selection by registered priority
+    assert add(a,b,a) == NewAdd(2*a, b)
+
+
+def test_mul_dispatcher():
+
+    class NewBase(Expr):
+        @property
+        def _mul_handler(self):
+            return NewMul
+    class NewMul(NewBase, Mul):
+        pass
+    mul.register_handlerclass((Mul, NewMul), NewMul)
+
+    a, b = Symbol('a'), NewBase()
+
+    # Mul called as fallback
+    assert mul(1, 2) == Mul(1, 2)
+    assert mul(a, a) == Mul(a, a)
+
+    # selection by registered priority
+    assert mul(a,b,a) == NewMul(a**2, b)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_parameters.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_parameters.py
new file mode 100644
index 0000000000000000000000000000000000000000..21e03d717872a9a8165ceeebf7ef58e9842702c0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_parameters.py
@@ -0,0 +1,126 @@
+from sympy.abc import x, y
+from sympy.core.parameters import evaluate
+from sympy.core import Mul, Add, Pow, S
+from sympy.core.numbers import oo
+from sympy.functions.elementary.miscellaneous import sqrt
+
+def test_add():
+    with evaluate(False):
+        p = oo - oo
+        assert isinstance(p, Add) and p.args == (oo, -oo)
+        p = 5 - oo
+        assert isinstance(p, Add) and p.args == (-oo, 5)
+        p = oo - 5
+        assert isinstance(p, Add) and p.args == (oo, -5)
+        p = oo + 5
+        assert isinstance(p, Add) and p.args == (oo, 5)
+        p = 5 + oo
+        assert isinstance(p, Add) and p.args == (oo, 5)
+        p = -oo + 5
+        assert isinstance(p, Add) and p.args == (-oo, 5)
+        p = -5 - oo
+        assert isinstance(p, Add) and p.args == (-oo, -5)
+
+    with evaluate(False):
+        expr = x + x
+        assert isinstance(expr, Add)
+        assert expr.args == (x, x)
+
+        with evaluate(True):
+            assert (x + x).args == (2, x)
+
+        assert (x + x).args == (x, x)
+
+    assert isinstance(x + x, Mul)
+
+    with evaluate(False):
+        assert S.One + 1 == Add(1, 1)
+        assert 1 + S.One == Add(1, 1)
+
+        assert S(4) - 3 == Add(4, -3)
+        assert -3 + S(4) == Add(4, -3)
+
+        assert S(2) * 4 == Mul(2, 4)
+        assert 4 * S(2) == Mul(2, 4)
+
+        assert S(6) / 3 == Mul(6, Pow(3, -1))
+        assert S.One / 3 * 6 == Mul(S.One / 3, 6)
+
+        assert 9 ** S(2) == Pow(9, 2)
+        assert S(2) ** 9 == Pow(2, 9)
+
+        assert S(2) / 2 == Mul(2, Pow(2, -1))
+        assert S.One / 2 * 2 == Mul(S.One / 2, 2)
+
+        assert S(2) / 3 + 1 == Add(S(2) / 3, 1)
+        assert 1 + S(2) / 3 == Add(1, S(2) / 3)
+
+        assert S(4) / 7 - 3 == Add(S(4) / 7, -3)
+        assert -3 + S(4) / 7 == Add(-3, S(4) / 7)
+
+        assert S(2) / 4 * 4 == Mul(S(2) / 4, 4)
+        assert 4 * (S(2) / 4) == Mul(4, S(2) / 4)
+
+        assert S(6) / 3 == Mul(6, Pow(3, -1))
+        assert S.One / 3 * 6 == Mul(S.One / 3, 6)
+
+        assert S.One / 3 + sqrt(3) == Add(S.One / 3, sqrt(3))
+        assert sqrt(3) + S.One / 3 == Add(sqrt(3), S.One / 3)
+
+        assert S.One / 2 * 10.333 == Mul(S.One / 2, 10.333)
+        assert 10.333 * (S.One / 2) == Mul(10.333, S.One / 2)
+
+        assert sqrt(2) * sqrt(2) == Mul(sqrt(2), sqrt(2))
+
+        assert S.One / 2 + x == Add(S.One / 2, x)
+        assert x + S.One / 2 == Add(x, S.One / 2)
+
+        assert S.One / x * x == Mul(S.One / x, x)
+        assert x * (S.One / x) == Mul(x, Pow(x, -1))
+
+        assert S.One / 3 == Pow(3, -1)
+        assert S.One / x == Pow(x, -1)
+        assert 1 / S(3) == Pow(3, -1)
+        assert 1 / x == Pow(x, -1)
+
+def test_nested():
+    with evaluate(False):
+        expr = (x + x) + (y + y)
+        assert expr.args == ((x + x), (y + y))
+        assert expr.args[0].args == (x, x)
+
+def test_reentrantcy():
+    with evaluate(False):
+        expr = x + x
+        assert expr.args == (x, x)
+        with evaluate(True):
+            expr = x + x
+            assert expr.args == (2, x)
+        expr = x + x
+        assert expr.args == (x, x)
+
+def test_reusability():
+    f = evaluate(False)
+
+    with f:
+        expr = x + x
+        assert expr.args == (x, x)
+
+    expr = x + x
+    assert expr.args == (2, x)
+
+    with f:
+        expr = x + x
+        assert expr.args == (x, x)
+
+    # Assure reentrancy with reusability
+    ctx = evaluate(False)
+    with ctx:
+        expr = x + x
+        assert expr.args == (x, x)
+        with ctx:
+            expr = x + x
+            assert expr.args == (x, x)
+
+    expr = x + x
+    assert expr.args == (2, x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_power.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_power.py
new file mode 100644
index 0000000000000000000000000000000000000000..80ae48c525c20da6153deffbc9feadef81acf527
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_power.py
@@ -0,0 +1,670 @@
+from sympy.core import (
+    Basic, Rational, Symbol, S, Float, Integer, Mul, Number, Pow,
+    Expr, I, nan, pi, symbols, oo, zoo, N)
+from sympy.core.parameters import global_parameters
+from sympy.core.tests.test_evalf import NS
+from sympy.core.function import expand_multinomial
+from sympy.functions.elementary.miscellaneous import sqrt, cbrt
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.special.error_functions import erf
+from sympy.functions.elementary.trigonometric import (
+    sin, cos, tan, sec, csc, atan)
+from sympy.functions.elementary.hyperbolic import cosh, sinh, tanh
+from sympy.polys import Poly
+from sympy.series.order import O
+from sympy.sets import FiniteSet
+from sympy.core.power import power
+from sympy.core.intfunc import integer_nthroot
+from sympy.testing.pytest import warns, _both_exp_pow
+from sympy.utilities.exceptions import SymPyDeprecationWarning
+from sympy.abc import a, b, c, x, y
+from sympy.core.numbers import all_close
+
+def test_rational():
+    a = Rational(1, 5)
+
+    r = sqrt(5)/5
+    assert sqrt(a) == r
+    assert 2*sqrt(a) == 2*r
+
+    r = a*a**S.Half
+    assert a**Rational(3, 2) == r
+    assert 2*a**Rational(3, 2) == 2*r
+
+    r = a**5*a**Rational(2, 3)
+    assert a**Rational(17, 3) == r
+    assert 2 * a**Rational(17, 3) == 2*r
+
+
+def test_large_rational():
+    e = (Rational(123712**12 - 1, 7) + Rational(1, 7))**Rational(1, 3)
+    assert e == 234232585392159195136 * (Rational(1, 7)**Rational(1, 3))
+
+
+def test_negative_real():
+    def feq(a, b):
+        return abs(a - b) < 1E-10
+
+    assert feq(S.One / Float(-0.5), -Integer(2))
+
+
+def test_expand():
+    assert (2**(-1 - x)).expand() == S.Half*2**(-x)
+
+
+def test_issue_3449():
+    #test if powers are simplified correctly
+    #see also issue 3995
+    assert ((x**Rational(1, 3))**Rational(2)) == x**Rational(2, 3)
+    assert (
+        (x**Rational(3))**Rational(2, 5)) == (x**Rational(3))**Rational(2, 5)
+
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    assert (a**2)**b == (abs(a)**b)**2
+    assert sqrt(1/a) != 1/sqrt(a)  # e.g. for a = -1
+    assert (a**3)**Rational(1, 3) != a
+    assert (x**a)**b != x**(a*b)  # e.g. x = -1, a=2, b=1/2
+    assert (x**.5)**b == x**(.5*b)
+    assert (x**.5)**.5 == x**.25
+    assert (x**2.5)**.5 != x**1.25  # e.g. for x = 5*I
+
+    k = Symbol('k', integer=True)
+    m = Symbol('m', integer=True)
+    assert (x**k)**m == x**(k*m)
+    assert Number(5)**Rational(2, 3) == Number(25)**Rational(1, 3)
+
+    assert (x**.5)**2 == x**1.0
+    assert (x**2)**k == (x**k)**2 == x**(2*k)
+
+    a = Symbol('a', positive=True)
+    assert (a**3)**Rational(2, 5) == a**Rational(6, 5)
+    assert (a**2)**b == (a**b)**2
+    assert (a**Rational(2, 3))**x == a**(x*Rational(2, 3)) != (a**x)**Rational(2, 3)
+
+
+def test_issue_3866():
+    assert --sqrt(sqrt(5) - 1) == sqrt(sqrt(5) - 1)
+
+
+def test_negative_one():
+    x = Symbol('x', complex=True)
+    y = Symbol('y', complex=True)
+    assert 1/x**y == x**(-y)
+
+
+def test_issue_4362():
+    neg = Symbol('neg', negative=True)
+    nonneg = Symbol('nonneg', nonnegative=True)
+    any = Symbol('any')
+    num, den = sqrt(1/neg).as_numer_denom()
+    assert num == sqrt(-1)
+    assert den == sqrt(-neg)
+    num, den = sqrt(1/nonneg).as_numer_denom()
+    assert num == 1
+    assert den == sqrt(nonneg)
+    num, den = sqrt(1/any).as_numer_denom()
+    assert num == sqrt(1/any)
+    assert den == 1
+
+    def eqn(num, den, pow):
+        return (num/den)**pow
+    npos = 1
+    nneg = -1
+    dpos = 2 - sqrt(3)
+    dneg = 1 - sqrt(3)
+    assert dpos > 0 and dneg < 0 and npos > 0 and nneg < 0
+    # pos or neg integer
+    eq = eqn(npos, dpos, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
+    eq = eqn(npos, dneg, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
+    eq = eqn(nneg, dpos, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dpos**2)
+    eq = eqn(nneg, dneg, 2)
+    assert eq.is_Pow and eq.as_numer_denom() == (1, dneg**2)
+    eq = eqn(npos, dpos, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
+    eq = eqn(npos, dneg, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
+    eq = eqn(nneg, dpos, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**2, 1)
+    eq = eqn(nneg, dneg, -2)
+    assert eq.is_Pow and eq.as_numer_denom() == (dneg**2, 1)
+    # pos or neg rational
+    pow = S.Half
+    eq = eqn(npos, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
+    eq = eqn(npos, dneg, pow)
+    assert eq.is_Pow is False and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
+    eq = eqn(nneg, dpos, pow)
+    assert not eq.is_Pow or eq.as_numer_denom() == (nneg**pow, dpos**pow)
+    eq = eqn(nneg, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
+    eq = eqn(npos, dpos, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, npos**pow)
+    eq = eqn(npos, dneg, -pow)
+    assert eq.is_Pow is False and eq.as_numer_denom() == (-(-npos)**pow*(-dneg)**pow, npos)
+    eq = eqn(nneg, dpos, -pow)
+    assert not eq.is_Pow or eq.as_numer_denom() == (dpos**pow, nneg**pow)
+    eq = eqn(nneg, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
+    # unknown exponent
+    pow = 2*any
+    eq = eqn(npos, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (npos**pow, dpos**pow)
+    eq = eqn(npos, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-npos)**pow, (-dneg)**pow)
+    eq = eqn(nneg, dpos, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (nneg**pow, dpos**pow)
+    eq = eqn(nneg, dneg, pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-nneg)**pow, (-dneg)**pow)
+    eq = eqn(npos, dpos, -pow)
+    assert eq.as_numer_denom() == (dpos**pow, npos**pow)
+    eq = eqn(npos, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-npos)**pow)
+    eq = eqn(nneg, dpos, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == (dpos**pow, nneg**pow)
+    eq = eqn(nneg, dneg, -pow)
+    assert eq.is_Pow and eq.as_numer_denom() == ((-dneg)**pow, (-nneg)**pow)
+
+    assert ((1/(1 + x/3))**(-S.One)).as_numer_denom() == (3 + x, 3)
+    notp = Symbol('notp', positive=False)  # not positive does not imply real
+    b = ((1 + x/notp)**-2)
+    assert (b**(-y)).as_numer_denom() == (1, b**y)
+    assert (b**(-S.One)).as_numer_denom() == ((notp + x)**2, notp**2)
+    nonp = Symbol('nonp', nonpositive=True)
+    assert (((1 + x/nonp)**-2)**(-S.One)).as_numer_denom() == ((-nonp -
+            x)**2, nonp**2)
+
+    n = Symbol('n', negative=True)
+    assert (x**n).as_numer_denom() == (1, x**-n)
+    assert sqrt(1/n).as_numer_denom() == (S.ImaginaryUnit, sqrt(-n))
+    n = Symbol('0 or neg', nonpositive=True)
+    # if x and n are split up without negating each term and n is negative
+    # then the answer might be wrong; if n is 0 it won't matter since
+    # 1/oo and 1/zoo are both zero as is sqrt(0)/sqrt(-x) unless x is also
+    # zero (in which case the negative sign doesn't matter):
+    # 1/sqrt(1/-1) = -I but sqrt(-1)/sqrt(1) = I
+    assert (1/sqrt(x/n)).as_numer_denom() == (sqrt(-n), sqrt(-x))
+    c = Symbol('c', complex=True)
+    e = sqrt(1/c)
+    assert e.as_numer_denom() == (e, 1)
+    i = Symbol('i', integer=True)
+    assert ((1 + x/y)**i).as_numer_denom() == ((x + y)**i, y**i)
+
+
+def test_Pow_Expr_args():
+    bases = [Basic(), Poly(x, x), FiniteSet(x)]
+    for base in bases:
+        # The cache can mess with the stacklevel test
+        with warns(SymPyDeprecationWarning, test_stacklevel=False):
+            Pow(base, S.One)
+
+
+def test_Pow_signs():
+    """Cf. issues 4595 and 5250"""
+    n = Symbol('n', even=True)
+    assert (3 - y)**2 != (y - 3)**2
+    assert (3 - y)**n != (y - 3)**n
+    assert (-3 + y - x)**2 != (3 - y + x)**2
+    assert (y - 3)**3 != -(3 - y)**3
+
+
+def test_power_with_noncommutative_mul_as_base():
+    x = Symbol('x', commutative=False)
+    y = Symbol('y', commutative=False)
+    assert not (x*y)**3 == x**3*y**3
+    assert (2*x*y)**3 == 8*(x*y)**3
+
+
+@_both_exp_pow
+def test_power_rewrite_exp():
+    assert (I**I).rewrite(exp) == exp(-pi/2)
+
+    expr = (2 + 3*I)**(4 + 5*I)
+    assert expr.rewrite(exp) == exp((4 + 5*I)*(log(sqrt(13)) + I*atan(Rational(3, 2))))
+    assert expr.rewrite(exp).expand() == \
+        169*exp(5*I*log(13)/2)*exp(4*I*atan(Rational(3, 2)))*exp(-5*atan(Rational(3, 2)))
+
+    assert ((6 + 7*I)**5).rewrite(exp) == 7225*sqrt(85)*exp(5*I*atan(Rational(7, 6)))
+
+    expr = 5**(6 + 7*I)
+    assert expr.rewrite(exp) == exp((6 + 7*I)*log(5))
+    assert expr.rewrite(exp).expand() == 15625*exp(7*I*log(5))
+
+    assert Pow(123, 789, evaluate=False).rewrite(exp) == 123**789
+    assert (1**I).rewrite(exp) == 1**I
+    assert (0**I).rewrite(exp) == 0**I
+
+    expr = (-2)**(2 + 5*I)
+    assert expr.rewrite(exp) == exp((2 + 5*I)*(log(2) + I*pi))
+    assert expr.rewrite(exp).expand() == 4*exp(-5*pi)*exp(5*I*log(2))
+
+    assert ((-2)**S(-5)).rewrite(exp) == (-2)**S(-5)
+
+    x, y = symbols('x y')
+    assert (x**y).rewrite(exp) == exp(y*log(x))
+    if global_parameters.exp_is_pow:
+        assert (7**x).rewrite(exp) == Pow(S.Exp1, x*log(7), evaluate=False)
+    else:
+        assert (7**x).rewrite(exp) == exp(x*log(7), evaluate=False)
+    assert ((2 + 3*I)**x).rewrite(exp) == exp(x*(log(sqrt(13)) + I*atan(Rational(3, 2))))
+    assert (y**(5 + 6*I)).rewrite(exp) == exp(log(y)*(5 + 6*I))
+
+    assert all((1/func(x)).rewrite(exp) == 1/(func(x).rewrite(exp)) for func in
+                    (sin, cos, tan, sec, csc, sinh, cosh, tanh))
+
+
+def test_zero():
+    assert 0**x != 0
+    assert 0**(2*x) == 0**x
+    assert 0**(1.0*x) == 0**x
+    assert 0**(2.0*x) == 0**x
+    assert (0**(2 - x)).as_base_exp() == (0, 2 - x)
+    assert 0**(x - 2) != S.Infinity**(2 - x)
+    assert 0**(2*x*y) == 0**(x*y)
+    assert 0**(-2*x*y) == S.ComplexInfinity**(x*y)
+    assert Float(0)**2 is not S.Zero
+    assert Float(0)**2 == 0.0
+    assert Float(0)**-2 is zoo
+    assert Float(0)**oo is S.Zero
+
+    #Test issue 19572
+    assert 0 ** -oo is zoo
+    assert power(0, -oo) is zoo
+    assert Float(0)**-oo is zoo
+
+def test_pow_as_base_exp():
+    assert (S.Infinity**(2 - x)).as_base_exp() == (S.Infinity, 2 - x)
+    assert (S.Infinity**(x - 2)).as_base_exp() == (S.Infinity, x - 2)
+    p = S.Half**x
+    assert p.base, p.exp == p.as_base_exp() == (S(2), -x)
+    p = (S(3)/2)**x
+    assert p.base, p.exp == p.as_base_exp() == (3*S.Half, x)
+    p = (S(2)/3)**x
+    assert p.as_base_exp() == (S(2)/3, x)
+    assert p.base, p.exp == (S(2)/3, x)
+    # issue 8344:
+    assert Pow(1, 2, evaluate=False).as_base_exp() == (S.One, S(2))
+
+
+def test_nseries():
+    assert sqrt(I*x - 1)._eval_nseries(x, 4, None, 1) == I + x/2 + I*x**2/8 - x**3/16 + O(x**4)
+    assert sqrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -I - x/2 - I*x**2/8 + x**3/16 + O(x**4)
+    assert cbrt(I*x - 1)._eval_nseries(x, 4, None, 1) == (-1)**(S(1)/3) - (-1)**(S(5)/6)*x/3 + \
+    (-1)**(S(1)/3)*x**2/9 + 5*(-1)**(S(5)/6)*x**3/81 + O(x**4)
+    assert cbrt(I*x - 1)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3) - (-1)**(S(1)/6)*x/3 - \
+    (-1)**(S(2)/3)*x**2/9 + 5*(-1)**(S(1)/6)*x**3/81 + O(x**4)
+    assert (1 / (exp(-1/x) + 1/x))._eval_nseries(x, 2, None) == x + O(x**2)
+    # test issue 23752
+    assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \
+    sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4)
+    assert sqrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -sqrt(3)*I + sqrt(3)*I*x/6 - \
+    sqrt(3)*I*x**2*(-S(1)/72 + I/6) - sqrt(3)*I*x**3*(-S(1)/432 + I/36) + O(x**4)
+    assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, 1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4)
+    assert cbrt(-I*x**2 + x - 3)._eval_nseries(x, 4, None, -1) == -(-1)**(S(2)/3)*3**(S(1)/3) + \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x/9 - (-1)**(S(2)/3)*3**(S(1)/3)*x**2*(-S(1)/81 + I/9) - \
+    (-1)**(S(2)/3)*3**(S(1)/3)*x**3*(-S(5)/2187 + 2*I/81) + O(x**4)
+
+
+def test_issue_6100_12942_4473():
+    assert x**1.0 != x
+    assert x != x**1.0
+    assert True != x**1.0
+    assert x**1.0 is not True
+    assert x is not True
+    assert x*y != (x*y)**1.0
+    # Pow != Symbol
+    assert (x**1.0)**1.0 != x
+    assert (x**1.0)**2.0 != x**2
+    b = Expr()
+    assert Pow(b, 1.0, evaluate=False) != b
+    # if the following gets distributed as a Mul (x**1.0*y**1.0 then
+    # __eq__ methods could be added to Symbol and Pow to detect the
+    # power-of-1.0 case.
+    assert ((x*y)**1.0).func is Pow
+
+
+def test_issue_6208():
+    from sympy.functions.elementary.miscellaneous import root
+    assert sqrt(33**(I*9/10)) == -33**(I*9/20)
+    assert root((6*I)**(2*I), 3).as_base_exp()[1] == Rational(1, 3)  # != 2*I/3
+    assert root((6*I)**(I/3), 3).as_base_exp()[1] == I/9
+    assert sqrt(exp(3*I)) == exp(3*I/2)
+    assert sqrt(-sqrt(3)*(1 + 2*I)) == sqrt(sqrt(3))*sqrt(-1 - 2*I)
+    assert sqrt(exp(5*I)) == -exp(5*I/2)
+    assert root(exp(5*I), 3).exp == Rational(1, 3)
+
+
+def test_issue_6990():
+    assert (sqrt(a + b*x + x**2)).series(x, 0, 3).removeO() == \
+        sqrt(a)*x**2*(1/(2*a) - b**2/(8*a**2)) + sqrt(a) + b*x/(2*sqrt(a))
+
+
+def test_issue_6068():
+    assert sqrt(sin(x)).series(x, 0, 7) == \
+        sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
+        x**Rational(13, 2)/24192 + O(x**7)
+    assert sqrt(sin(x)).series(x, 0, 9) == \
+        sqrt(x) - x**Rational(5, 2)/12 + x**Rational(9, 2)/1440 - \
+        x**Rational(13, 2)/24192 - 67*x**Rational(17, 2)/29030400 + O(x**9)
+    assert sqrt(sin(x**3)).series(x, 0, 19) == \
+        x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 + O(x**19)
+    assert sqrt(sin(x**3)).series(x, 0, 20) == \
+        x**Rational(3, 2) - x**Rational(15, 2)/12 + x**Rational(27, 2)/1440 - \
+        x**Rational(39, 2)/24192 + O(x**20)
+
+
+def test_issue_6782():
+    assert sqrt(sin(x**3)).series(x, 0, 7) == x**Rational(3, 2) + O(x**7)
+    assert sqrt(sin(x**4)).series(x, 0, 3) == x**2 + O(x**3)
+
+
+def test_issue_6653():
+    assert (1 / sqrt(1 + sin(x**2))).series(x, 0, 3) == 1 - x**2/2 + O(x**3)
+
+
+def test_issue_6429():
+    f = (c**2 + x)**(0.5)
+    assert f.series(x, x0=0, n=1) == (c**2)**0.5 + O(x)
+    assert f.taylor_term(0, x) == (c**2)**0.5
+    assert f.taylor_term(1, x) == 0.5*x*(c**2)**(-0.5)
+    assert f.taylor_term(2, x) == -0.125*x**2*(c**2)**(-1.5)
+
+
+def test_issue_7638():
+    f = pi/log(sqrt(2))
+    assert ((1 + I)**(I*f/2))**0.3 == (1 + I)**(0.15*I*f)
+    # if 1/3 -> 1.0/3 this should fail since it cannot be shown that the
+    # sign will be +/-1; for the previous "small arg" case, it didn't matter
+    # that this could not be proved
+    assert (1 + I)**(4*I*f) == ((1 + I)**(12*I*f))**Rational(1, 3)
+
+    assert (((1 + I)**(I*(1 + 7*f)))**Rational(1, 3)).exp == Rational(1, 3)
+    r = symbols('r', real=True)
+    assert sqrt(r**2) == abs(r)
+    assert cbrt(r**3) != r
+    assert sqrt(Pow(2*I, 5*S.Half)) != (2*I)**Rational(5, 4)
+    p = symbols('p', positive=True)
+    assert cbrt(p**2) == p**Rational(2, 3)
+    assert NS(((0.2 + 0.7*I)**(0.7 + 1.0*I))**(0.5 - 0.1*I), 1) == '0.4 + 0.2*I'
+    assert sqrt(1/(1 + I)) == sqrt(1 - I)/sqrt(2)  # or 1/sqrt(1 + I)
+    e = 1/(1 - sqrt(2))
+    assert sqrt(e) == I/sqrt(-1 + sqrt(2))
+    assert e**Rational(-1, 2) == -I*sqrt(-1 + sqrt(2))
+    assert sqrt((cos(1)**2 + sin(1)**2 - 1)**(3 + I)).exp in [S.Half,
+                                                              Rational(3, 2) + I/2]
+    assert sqrt(r**Rational(4, 3)) != r**Rational(2, 3)
+    assert sqrt((p + I)**Rational(4, 3)) == (p + I)**Rational(2, 3)
+
+    for q in 1+I, 1-I:
+        assert sqrt(q**2) == q
+    for q in -1+I, -1-I:
+        assert sqrt(q**2) == -q
+
+    assert sqrt((p + r*I)**2) != p + r*I
+    e = (1 + I/5)
+    assert sqrt(e**5) == e**(5*S.Half)
+    assert sqrt(e**6) == e**3
+    assert sqrt((1 + I*r)**6) != (1 + I*r)**3
+
+
+def test_issue_8582():
+    assert 1**oo is nan
+    assert 1**(-oo) is nan
+    assert 1**zoo is nan
+    assert 1**(oo + I) is nan
+    assert 1**(1 + I*oo) is nan
+    assert 1**(oo + I*oo) is nan
+
+
+def test_issue_8650():
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert (n**n).is_positive is True
+    x = 5*n + 5
+    assert (x**(5*(n + 1))).is_positive is True
+
+
+def test_issue_13914():
+    b = Symbol('b')
+    assert (-1)**zoo is nan
+    assert 2**zoo is nan
+    assert (S.Half)**(1 + zoo) is nan
+    assert I**(zoo + I) is nan
+    assert b**(I + zoo) is nan
+
+
+def test_better_sqrt():
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert sqrt(3 + 4*I) == 2 + I
+    assert sqrt(3 - 4*I) == 2 - I
+    assert sqrt(-3 - 4*I) == 1 - 2*I
+    assert sqrt(-3 + 4*I) == 1 + 2*I
+    assert sqrt(32 + 24*I) == 6 + 2*I
+    assert sqrt(32 - 24*I) == 6 - 2*I
+    assert sqrt(-32 - 24*I) == 2 - 6*I
+    assert sqrt(-32 + 24*I) == 2 + 6*I
+
+    # triple (3, 4, 5):
+    # parity of 3 matches parity of 5 and
+    # den, 4, is a square
+    assert sqrt((3 + 4*I)/4) == 1 + I/2
+    # triple (8, 15, 17)
+    # parity of 8 doesn't match parity of 17 but
+    # den/2, 8/2, is a square
+    assert sqrt((8 + 15*I)/8) == (5 + 3*I)/4
+    # handle the denominator
+    assert sqrt((3 - 4*I)/25) == (2 - I)/5
+    assert sqrt((3 - 4*I)/26) == (2 - I)/sqrt(26)
+    # mul
+    #  issue #12739
+    assert sqrt((3 + 4*I)/(3 - 4*I)) == (3 + 4*I)/5
+    assert sqrt(2/(3 + 4*I)) == sqrt(2)/5*(2 - I)
+    assert sqrt(n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(2 - I)
+    assert sqrt(-2/(3 + 4*I)) == sqrt(2)/5*(1 + 2*I)
+    assert sqrt(-n/(3 + 4*I)).subs(n, 2) == sqrt(2)/5*(1 + 2*I)
+    # power
+    assert sqrt(1/(3 + I*4)) == (2 - I)/5
+    assert sqrt(1/(3 - I)) == sqrt(10)*sqrt(3 + I)/10
+    # symbolic
+    i = symbols('i', imaginary=True)
+    assert sqrt(3/i) == Mul(sqrt(3), 1/sqrt(i), evaluate=False)
+    # multiples of 1/2; don't make this too automatic
+    assert sqrt(3 + 4*I)**3 == (2 + I)**3
+    assert Pow(3 + 4*I, Rational(3, 2)) == 2 + 11*I
+    assert Pow(6 + 8*I, Rational(3, 2)) == 2*sqrt(2)*(2 + 11*I)
+    n, d = (3 + 4*I), (3 - 4*I)**3
+    a = n/d
+    assert a.args == (1/d, n)
+    eq = sqrt(a)
+    assert eq.args == (a, S.Half)
+    assert expand_multinomial(eq) == sqrt((-117 + 44*I)*(3 + 4*I))/125
+    assert eq.expand() == (7 - 24*I)/125
+
+    # issue 12775
+    # pos im part
+    assert sqrt(2*I) == (1 + I)
+    assert sqrt(2*9*I) == Mul(3, 1 + I, evaluate=False)
+    assert Pow(2*I, 3*S.Half) == (1 + I)**3
+    # neg im part
+    assert sqrt(-I/2) == Mul(S.Half, 1 - I, evaluate=False)
+    # fractional im part
+    assert Pow(Rational(-9, 2)*I, Rational(3, 2)) == 27*(1 - I)**3/8
+
+
+def test_issue_2993():
+    assert str((2.3*x - 4)**0.3) == '(2.3*x - 4)**0.3'
+    assert str((2.3*x + 4)**0.3) == '(2.3*x + 4)**0.3'
+    assert str((-2.3*x + 4)**0.3) == '(4 - 2.3*x)**0.3'
+    assert str((-2.3*x - 4)**0.3) == '(-2.3*x - 4)**0.3'
+    assert str((2.3*x - 2)**0.3) == '(2.3*x - 2)**0.3'
+    assert str((-2.3*x - 2)**0.3) == '(-2.3*x - 2)**0.3'
+    assert str((-2.3*x + 2)**0.3) == '(2 - 2.3*x)**0.3'
+    assert str((2.3*x + 2)**0.3) == '(2.3*x + 2)**0.3'
+    assert str((2.3*x - 4)**Rational(1, 3)) == '(2.3*x - 4)**(1/3)'
+    eq = (2.3*x + 4)
+    assert str(eq**2) == '(2.3*x + 4)**2'
+    assert (1/eq).args == (eq, -1)  # don't change trivial power
+    # issue 17735
+    q=.5*exp(x) - .5*exp(-x) + 0.1
+    assert int((q**2).subs(x, 1)) == 1
+    # issue 17756
+    y = Symbol('y')
+    assert len(sqrt(x/(x + y)**2 + Float('0.008', 30)).subs(y, pi.n(25)).atoms(Float)) == 2
+    # issue 17756
+    a, b, c, d, e, f, g = symbols('a:g')
+    expr = sqrt(1 + a*(c**4 + g*d - 2*g*e - f*(-g + d))**2/
+        (c**3*b**2*(d - 3*e + 2*f)**2))/2
+    r = [
+    (a, N('0.0170992456333788667034850458615', 30)),
+    (b, N('0.0966594956075474769169134801223', 30)),
+    (c, N('0.390911862903463913632151616184', 30)),
+    (d, N('0.152812084558656566271750185933', 30)),
+    (e, N('0.137562344465103337106561623432', 30)),
+    (f, N('0.174259178881496659302933610355', 30)),
+    (g, N('0.220745448491223779615401870086', 30))]
+    tru = expr.n(30, subs=dict(r))
+    seq = expr.subs(r)
+    # although `tru` is the right way to evaluate
+    # expr with numerical values, `seq` will have
+    # significant loss of precision if extraction of
+    # the largest coefficient of a power's base's terms
+    # is done improperly
+    assert seq == tru
+
+def test_issue_17450():
+    assert (erf(cosh(1)**7)**I).is_real is None
+    assert (erf(cosh(1)**7)**I).is_imaginary is False
+    assert (Pow(exp(1+sqrt(2)), ((1-sqrt(2))*I*pi), evaluate=False)).is_real is None
+    assert ((-10)**(10*I*pi/3)).is_real is False
+    assert ((-5)**(4*I*pi)).is_real is False
+
+
+def test_issue_18190():
+    assert sqrt(1 / tan(1 + I)) == 1 / sqrt(tan(1 + I))
+
+
+def test_issue_14815():
+    x = Symbol('x', real=True)
+    assert sqrt(x).is_extended_negative is False
+    x = Symbol('x', real=False)
+    assert sqrt(x).is_extended_negative is None
+    x = Symbol('x', complex=True)
+    assert sqrt(x).is_extended_negative is False
+    x = Symbol('x', extended_real=True)
+    assert sqrt(x).is_extended_negative is False
+    assert sqrt(zoo, evaluate=False).is_extended_negative is False
+    assert sqrt(nan, evaluate=False).is_extended_negative is None
+
+
+def test_issue_18509():
+    x = Symbol('x', prime=True)
+    assert x**oo is oo
+    assert (1/x)**oo is S.Zero
+    assert (-1/x)**oo is S.Zero
+    assert (-x)**oo is zoo
+    assert (-oo)**(-1 + I) is S.Zero
+    assert (-oo)**(1 + I) is zoo
+    assert (oo)**(-1 + I) is S.Zero
+    assert (oo)**(1 + I) is zoo
+
+
+def test_issue_18762():
+    e, p = symbols('e p')
+    g0 = sqrt(1 + e**2 - 2*e*cos(p))
+    assert len(g0.series(e, 1, 3).args) == 4
+
+
+def test_issue_21860():
+    e = 3*2**Rational(66666666667,200000000000)*3**Rational(16666666667,50000000000)*x**Rational(66666666667, 200000000000)
+    ans = Mul(Rational(3, 2),
+              Pow(Integer(2), Rational(33333333333, 100000000000)),
+              Pow(Integer(3), Rational(26666666667, 40000000000)))
+    assert e.xreplace({x: Rational(3,8)}) == ans
+
+
+def test_issue_21647():
+    e = log((Integer(567)/500)**(811*(Integer(567)/500)**x/100))
+    ans = log(Mul(Rational(64701150190720499096094005280169087619821081527,
+                           76293945312500000000000000000000000000000000000),
+                  Pow(Integer(2), Rational(396204892125479941, 781250000000000000)),
+                  Pow(Integer(3), Rational(385045107874520059, 390625000000000000)),
+                  Pow(Integer(5), Rational(407364676376439823, 1562500000000000000)),
+                  Pow(Integer(7), Rational(385045107874520059, 1562500000000000000))))
+    assert e.xreplace({x: 6}) == ans
+
+
+def test_issue_21762():
+    e = (x**2 + 6)**(Integer(33333333333333333)/50000000000000000)
+    ans = Mul(Rational(5, 4),
+              Pow(Integer(2), Rational(16666666666666667, 25000000000000000)),
+              Pow(Integer(5), Rational(8333333333333333, 25000000000000000)))
+    assert e.xreplace({x: S.Half}) == ans
+
+
+def test_issue_14704():
+    a = 144**144
+    x, xexact = integer_nthroot(a,a)
+    assert x == 1 and xexact is False
+
+
+def test_rational_powers_larger_than_one():
+    assert Rational(2, 3)**Rational(3, 2) == 2*sqrt(6)/9
+    assert Rational(1, 6)**Rational(9, 4) == 6**Rational(3, 4)/216
+    assert Rational(3, 7)**Rational(7, 3) == 9*3**Rational(1, 3)*7**Rational(2, 3)/343
+
+
+def test_power_dispatcher():
+
+    class NewBase(Expr):
+        pass
+    class NewPow(NewBase, Pow):
+        pass
+    a, b = Symbol('a'), NewBase()
+
+    @power.register(Expr, NewBase)
+    @power.register(NewBase, Expr)
+    @power.register(NewBase, NewBase)
+    def _(a, b):
+        return NewPow(a, b)
+
+    # Pow called as fallback
+    assert power(2, 3) == 8*S.One
+    assert power(a, 2) == Pow(a, 2)
+    assert power(a, a) == Pow(a, a)
+
+    # NewPow called by dispatch
+    assert power(a, b) == NewPow(a, b)
+    assert power(b, a) == NewPow(b, a)
+    assert power(b, b) == NewPow(b, b)
+
+
+def test_powers_of_I():
+    assert [sqrt(I)**i for i in range(13)] == [
+        1, sqrt(I), I, sqrt(I)**3, -1, -sqrt(I), -I, -sqrt(I)**3,
+        1, sqrt(I), I, sqrt(I)**3, -1]
+    assert sqrt(I)**(S(9)/2) == -I**(S(1)/4)
+
+
+def test_issue_23918():
+    b = S(2)/3
+    assert (b**x).as_base_exp() == (b, x)
+
+
+def test_issue_26546():
+    x = Symbol('x', real=True)
+    assert x.is_extended_real is True
+    assert sqrt(x+I).is_extended_real is False
+    assert Pow(x+I, S.Half).is_extended_real is False
+    assert Pow(x+I, Rational(1,2)).is_extended_real is False
+    assert Pow(x+I, Rational(1,13)).is_extended_real is False
+    assert Pow(x+I, Rational(2,3)).is_extended_real is None
+
+
+def test_issue_25165():
+    e1 = (1/sqrt(( - x + 1)**2 + (x - 0.23)**4)).series(x, 0, 2)
+    e2 = 0.998603724830355 + 1.02004923189934*x + O(x**2)
+    assert all_close(e1, e2)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_priority.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_priority.py
new file mode 100644
index 0000000000000000000000000000000000000000..276e653100f886243e07b866b699b8da53cdaf88
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_priority.py
@@ -0,0 +1,145 @@
+from sympy.core.decorators import call_highest_priority
+from sympy.core.expr import Expr
+from sympy.core.mod import Mod
+from sympy.core.numbers import Integer
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.integers import floor
+
+
+class Higher(Integer):
+    '''
+    Integer of value 1 and _op_priority 20
+
+    Operations handled by this class return 1 and reverse operations return 2
+    '''
+
+    _op_priority = 20.0
+    result: Expr = S.One
+
+    def __new__(cls):
+        obj = Expr.__new__(cls)
+        obj.p = 1
+        return obj
+
+    @call_highest_priority('__rmul__')
+    def __mul__(self, other):
+        return self.result
+
+    @call_highest_priority('__mul__')
+    def __rmul__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__radd__')
+    def __add__(self, other):
+        return self.result
+
+    @call_highest_priority('__add__')
+    def __radd__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__rsub__')
+    def __sub__(self, other):
+        return self.result
+
+    @call_highest_priority('__sub__')
+    def __rsub__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__rpow__')
+    def __pow__(self, other):
+        return self.result
+
+    @call_highest_priority('__pow__')
+    def __rpow__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__rtruediv__')
+    def __truediv__(self, other):
+        return self.result
+
+    @call_highest_priority('__truediv__')
+    def __rtruediv__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__rmod__')
+    def __mod__(self, other):
+        return self.result
+
+    @call_highest_priority('__mod__')
+    def __rmod__(self, other):
+        return 2*self.result
+
+    @call_highest_priority('__rfloordiv__')
+    def __floordiv__(self, other):
+        return self.result
+
+    @call_highest_priority('__floordiv__')
+    def __rfloordiv__(self, other):
+        return 2*self.result
+
+
+class Lower(Higher):
+    '''
+    Integer of value -1 and _op_priority 5
+
+    Operations handled by this class return -1 and reverse operations return -2
+    '''
+
+    _op_priority = 5.0
+    result: Expr = S.NegativeOne
+
+    def __new__(cls):
+        obj = Expr.__new__(cls)
+        obj.p = -1
+        return obj
+
+
+x = Symbol('x')
+h = Higher()
+l = Lower()
+
+
+def test_mul():
+    assert h*l == h*x == 1
+    assert l*h == x*h == 2
+    assert x*l == l*x == -x
+
+
+def test_add():
+    assert h + l == h + x == 1
+    assert l + h == x + h == 2
+    assert x + l == l + x == x - 1
+
+
+def test_sub():
+    assert h - l == h - x == 1
+    assert l - h == x - h == 2
+    assert x - l == -(l - x) == x + 1
+
+
+def test_pow():
+    assert h**l == h**x == 1
+    assert l**h == x**h == 2
+    assert (x**l).args == (1/x).args and (x**l).is_Pow
+    assert (l**x).args == ((-1)**x).args and (l**x).is_Pow
+
+
+def test_div():
+    assert h/l == h/x == 1
+    assert l/h == x/h == 2
+    assert x/l == 1/(l/x) == -x
+
+
+def test_mod():
+    assert h%l == h%x == 1
+    assert l%h == x%h == 2
+    assert x%l == Mod(x, -1)
+    assert l%x == Mod(-1, x)
+
+
+def test_floordiv():
+    assert h//l == h//x == 1
+    assert l//h == x//h == 2
+    assert x//l == floor(-x)
+    assert l//x == floor(-1/x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_random.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_random.py
new file mode 100644
index 0000000000000000000000000000000000000000..01c677126285eb66349253368b94b3270fb97793
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_random.py
@@ -0,0 +1,61 @@
+import random
+from sympy.core.random import random as rand, seed, shuffle, _assumptions_shuffle
+from sympy.core.symbol import Symbol, symbols
+from sympy.functions.elementary.trigonometric import sin, acos
+from sympy.abc import x
+
+
+def test_random():
+    random.seed(42)
+    a = random.random()
+    random.seed(42)
+    Symbol('z').is_finite
+    b = random.random()
+    assert a == b
+
+    got = set()
+    for i in range(2):
+        random.seed(28)
+        m0, m1 = symbols('m_0 m_1', real=True)
+        _ = acos(-m0/m1)
+        got.add(random.uniform(0,1))
+    assert len(got) == 1
+
+    random.seed(10)
+    y = 0
+    for i in range(4):
+        y += sin(random.uniform(-10,10) * x)
+    random.seed(10)
+    z = 0
+    for i in range(4):
+        z += sin(random.uniform(-10,10) * x)
+    assert y == z
+
+
+def test_seed():
+    assert rand() < 1
+    seed(1)
+    a = rand()
+    b = rand()
+    seed(1)
+    c = rand()
+    d = rand()
+    assert a == c
+    if not c == d:
+        assert a != b
+    else:
+        assert a == b
+
+    abc = 'abc'
+    first = list(abc)
+    second = list(abc)
+    third = list(abc)
+
+    seed(123)
+    shuffle(first)
+
+    seed(123)
+    shuffle(second)
+    _assumptions_shuffle(third)
+
+    assert first == second == third
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_relational.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_relational.py
new file mode 100644
index 0000000000000000000000000000000000000000..60c026fd5f5b8cee2e90e00582047cc7763bb8a4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_relational.py
@@ -0,0 +1,1271 @@
+from sympy.core.logic import fuzzy_and
+from sympy.core.sympify import _sympify
+from sympy.multipledispatch import dispatch
+from sympy.testing.pytest import XFAIL, raises
+from sympy.assumptions.ask import Q
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr, unchanged
+from sympy.core.function import Function
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import sign, Abs
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.integers import (ceiling, floor)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.logic.boolalg import (And, Implies, Not, Or, Xor)
+from sympy.sets import Reals
+from sympy.simplify.simplify import simplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.core.relational import (Relational, Equality, Unequality,
+                                   GreaterThan, LessThan, StrictGreaterThan,
+                                   StrictLessThan, Rel, Eq, Lt, Le,
+                                   Gt, Ge, Ne, is_le, is_gt, is_ge, is_lt, is_eq, is_neq)
+from sympy.sets.sets import Interval, FiniteSet
+
+from itertools import combinations
+
+x, y, z, t = symbols('x,y,z,t')
+
+
+def rel_check(a, b):
+    from sympy.testing.pytest import raises
+    assert a.is_number and b.is_number
+    for do in range(len({type(a), type(b)})):
+        if S.NaN in (a, b):
+            v = [(a == b), (a != b)]
+            assert len(set(v)) == 1 and v[0] == False
+            assert not (a != b) and not (a == b)
+            assert raises(TypeError, lambda: a < b)
+            assert raises(TypeError, lambda: a <= b)
+            assert raises(TypeError, lambda: a > b)
+            assert raises(TypeError, lambda: a >= b)
+        else:
+            E = [(a == b), (a != b)]
+            assert len(set(E)) == 2
+            v = [
+            (a < b), (a <= b), (a > b), (a >= b)]
+            i = [
+            [True,    True,     False,   False],
+            [False,   True,     False,   True], # <-- i == 1
+            [False,   False,    True,    True]].index(v)
+            if i == 1:
+                assert E[0] or (a.is_Float != b.is_Float) # ugh
+            else:
+                assert E[1]
+        a, b = b, a
+    return True
+
+
+def test_rel_ne():
+    assert Relational(x, y, '!=') == Ne(x, y)
+
+    # issue 6116
+    p = Symbol('p', positive=True)
+    assert Ne(p, 0) is S.true
+
+
+def test_rel_subs():
+    e = Relational(x, y, '==')
+    e = e.subs(x, z)
+
+    assert isinstance(e, Equality)
+    assert e.lhs == z
+    assert e.rhs == y
+
+    e = Relational(x, y, '>=')
+    e = e.subs(x, z)
+
+    assert isinstance(e, GreaterThan)
+    assert e.lhs == z
+    assert e.rhs == y
+
+    e = Relational(x, y, '<=')
+    e = e.subs(x, z)
+
+    assert isinstance(e, LessThan)
+    assert e.lhs == z
+    assert e.rhs == y
+
+    e = Relational(x, y, '>')
+    e = e.subs(x, z)
+
+    assert isinstance(e, StrictGreaterThan)
+    assert e.lhs == z
+    assert e.rhs == y
+
+    e = Relational(x, y, '<')
+    e = e.subs(x, z)
+
+    assert isinstance(e, StrictLessThan)
+    assert e.lhs == z
+    assert e.rhs == y
+
+    e = Eq(x, 0)
+    assert e.subs(x, 0) is S.true
+    assert e.subs(x, 1) is S.false
+
+
+def test_wrappers():
+    e = x + x**2
+
+    res = Relational(y, e, '==')
+    assert Rel(y, x + x**2, '==') == res
+    assert Eq(y, x + x**2) == res
+
+    res = Relational(y, e, '<')
+    assert Lt(y, x + x**2) == res
+
+    res = Relational(y, e, '<=')
+    assert Le(y, x + x**2) == res
+
+    res = Relational(y, e, '>')
+    assert Gt(y, x + x**2) == res
+
+    res = Relational(y, e, '>=')
+    assert Ge(y, x + x**2) == res
+
+    res = Relational(y, e, '!=')
+    assert Ne(y, x + x**2) == res
+
+
+def test_Eq_Ne():
+
+    assert Eq(x, x)  # issue 5719
+
+    # issue 6116
+    p = Symbol('p', positive=True)
+    assert Eq(p, 0) is S.false
+
+    # issue 13348; 19048
+    # SymPy is strict about 0 and 1 not being
+    # interpreted as Booleans
+    assert Eq(True, 1) is S.false
+    assert Eq(False, 0) is S.false
+    assert Eq(~x, 0) is S.false
+    assert Eq(~x, 1) is S.false
+    assert Ne(True, 1) is S.true
+    assert Ne(False, 0) is S.true
+    assert Ne(~x, 0) is S.true
+    assert Ne(~x, 1) is S.true
+
+    assert Eq((), 1) is S.false
+    assert Ne((), 1) is S.true
+
+
+def test_as_poly():
+    from sympy.polys.polytools import Poly
+    # Only Eq should have an as_poly method:
+    assert Eq(x, 1).as_poly() == Poly(x - 1, x, domain='ZZ')
+    raises(AttributeError, lambda: Ne(x, 1).as_poly())
+    raises(AttributeError, lambda: Ge(x, 1).as_poly())
+    raises(AttributeError, lambda: Gt(x, 1).as_poly())
+    raises(AttributeError, lambda: Le(x, 1).as_poly())
+    raises(AttributeError, lambda: Lt(x, 1).as_poly())
+
+
+def test_rel_Infinity():
+    # NOTE: All of these are actually handled by sympy.core.Number, and do
+    # not create Relational objects.
+    assert (oo > oo) is S.false
+    assert (oo > -oo) is S.true
+    assert (oo > 1) is S.true
+    assert (oo < oo) is S.false
+    assert (oo < -oo) is S.false
+    assert (oo < 1) is S.false
+    assert (oo >= oo) is S.true
+    assert (oo >= -oo) is S.true
+    assert (oo >= 1) is S.true
+    assert (oo <= oo) is S.true
+    assert (oo <= -oo) is S.false
+    assert (oo <= 1) is S.false
+    assert (-oo > oo) is S.false
+    assert (-oo > -oo) is S.false
+    assert (-oo > 1) is S.false
+    assert (-oo < oo) is S.true
+    assert (-oo < -oo) is S.false
+    assert (-oo < 1) is S.true
+    assert (-oo >= oo) is S.false
+    assert (-oo >= -oo) is S.true
+    assert (-oo >= 1) is S.false
+    assert (-oo <= oo) is S.true
+    assert (-oo <= -oo) is S.true
+    assert (-oo <= 1) is S.true
+
+
+def test_infinite_symbol_inequalities():
+    x = Symbol('x', extended_positive=True, infinite=True)
+    y = Symbol('y', extended_positive=True, infinite=True)
+    z = Symbol('z', extended_negative=True, infinite=True)
+    w = Symbol('w', extended_negative=True, infinite=True)
+
+    inf_set = (x, y, oo)
+    ninf_set = (z, w, -oo)
+
+    for inf1 in inf_set:
+        assert (inf1 < 1) is S.false
+        assert (inf1 > 1) is S.true
+        assert (inf1 <= 1) is S.false
+        assert (inf1 >= 1) is S.true
+
+        for inf2 in inf_set:
+            assert (inf1 < inf2) is S.false
+            assert (inf1 > inf2) is S.false
+            assert (inf1 <= inf2) is S.true
+            assert (inf1 >= inf2) is S.true
+
+        for ninf1 in ninf_set:
+            assert (inf1 < ninf1) is S.false
+            assert (inf1 > ninf1) is S.true
+            assert (inf1 <= ninf1) is S.false
+            assert (inf1 >= ninf1) is S.true
+            assert (ninf1 < inf1) is S.true
+            assert (ninf1 > inf1) is S.false
+            assert (ninf1 <= inf1) is S.true
+            assert (ninf1 >= inf1) is S.false
+
+    for ninf1 in ninf_set:
+        assert (ninf1 < 1) is S.true
+        assert (ninf1 > 1) is S.false
+        assert (ninf1 <= 1) is S.true
+        assert (ninf1 >= 1) is S.false
+
+        for ninf2 in ninf_set:
+            assert (ninf1 < ninf2) is S.false
+            assert (ninf1 > ninf2) is S.false
+            assert (ninf1 <= ninf2) is S.true
+            assert (ninf1 >= ninf2) is S.true
+
+
+def test_bool():
+    assert Eq(0, 0) is S.true
+    assert Eq(1, 0) is S.false
+    assert Ne(0, 0) is S.false
+    assert Ne(1, 0) is S.true
+    assert Lt(0, 1) is S.true
+    assert Lt(1, 0) is S.false
+    assert Le(0, 1) is S.true
+    assert Le(1, 0) is S.false
+    assert Le(0, 0) is S.true
+    assert Gt(1, 0) is S.true
+    assert Gt(0, 1) is S.false
+    assert Ge(1, 0) is S.true
+    assert Ge(0, 1) is S.false
+    assert Ge(1, 1) is S.true
+    assert Eq(I, 2) is S.false
+    assert Ne(I, 2) is S.true
+    raises(TypeError, lambda: Gt(I, 2))
+    raises(TypeError, lambda: Ge(I, 2))
+    raises(TypeError, lambda: Lt(I, 2))
+    raises(TypeError, lambda: Le(I, 2))
+    a = Float('.000000000000000000001', '')
+    b = Float('.0000000000000000000001', '')
+    assert Eq(pi + a, pi + b) is S.false
+
+
+def test_rich_cmp():
+    assert (x < y) == Lt(x, y)
+    assert (x <= y) == Le(x, y)
+    assert (x > y) == Gt(x, y)
+    assert (x >= y) == Ge(x, y)
+
+
+def test_doit():
+    from sympy.core.symbol import Symbol
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    np = Symbol('np', nonpositive=True)
+    nn = Symbol('nn', nonnegative=True)
+
+    assert Gt(p, 0).doit() is S.true
+    assert Gt(p, 1).doit() == Gt(p, 1)
+    assert Ge(p, 0).doit() is S.true
+    assert Le(p, 0).doit() is S.false
+    assert Lt(n, 0).doit() is S.true
+    assert Le(np, 0).doit() is S.true
+    assert Gt(nn, 0).doit() == Gt(nn, 0)
+    assert Lt(nn, 0).doit() is S.false
+
+    assert Eq(x, 0).doit() == Eq(x, 0)
+
+
+def test_new_relational():
+    x = Symbol('x')
+
+    assert Eq(x, 0) == Relational(x, 0)       # None ==> Equality
+    assert Eq(x, 0) == Relational(x, 0, '==')
+    assert Eq(x, 0) == Relational(x, 0, 'eq')
+    assert Eq(x, 0) == Equality(x, 0)
+
+    assert Eq(x, 0) != Relational(x, 1)       # None ==> Equality
+    assert Eq(x, 0) != Relational(x, 1, '==')
+    assert Eq(x, 0) != Relational(x, 1, 'eq')
+    assert Eq(x, 0) != Equality(x, 1)
+
+    assert Eq(x, -1) == Relational(x, -1)       # None ==> Equality
+    assert Eq(x, -1) == Relational(x, -1, '==')
+    assert Eq(x, -1) == Relational(x, -1, 'eq')
+    assert Eq(x, -1) == Equality(x, -1)
+    assert Eq(x, -1) != Relational(x, 1)       # None ==> Equality
+    assert Eq(x, -1) != Relational(x, 1, '==')
+    assert Eq(x, -1) != Relational(x, 1, 'eq')
+    assert Eq(x, -1) != Equality(x, 1)
+
+    assert Ne(x, 0) == Relational(x, 0, '!=')
+    assert Ne(x, 0) == Relational(x, 0, '<>')
+    assert Ne(x, 0) == Relational(x, 0, 'ne')
+    assert Ne(x, 0) == Unequality(x, 0)
+    assert Ne(x, 0) != Relational(x, 1, '!=')
+    assert Ne(x, 0) != Relational(x, 1, '<>')
+    assert Ne(x, 0) != Relational(x, 1, 'ne')
+    assert Ne(x, 0) != Unequality(x, 1)
+
+    assert Ge(x, 0) == Relational(x, 0, '>=')
+    assert Ge(x, 0) == Relational(x, 0, 'ge')
+    assert Ge(x, 0) == GreaterThan(x, 0)
+    assert Ge(x, 1) != Relational(x, 0, '>=')
+    assert Ge(x, 1) != Relational(x, 0, 'ge')
+    assert Ge(x, 1) != GreaterThan(x, 0)
+    assert (x >= 1) == Relational(x, 1, '>=')
+    assert (x >= 1) == Relational(x, 1, 'ge')
+    assert (x >= 1) == GreaterThan(x, 1)
+    assert (x >= 0) != Relational(x, 1, '>=')
+    assert (x >= 0) != Relational(x, 1, 'ge')
+    assert (x >= 0) != GreaterThan(x, 1)
+
+    assert Le(x, 0) == Relational(x, 0, '<=')
+    assert Le(x, 0) == Relational(x, 0, 'le')
+    assert Le(x, 0) == LessThan(x, 0)
+    assert Le(x, 1) != Relational(x, 0, '<=')
+    assert Le(x, 1) != Relational(x, 0, 'le')
+    assert Le(x, 1) != LessThan(x, 0)
+    assert (x <= 1) == Relational(x, 1, '<=')
+    assert (x <= 1) == Relational(x, 1, 'le')
+    assert (x <= 1) == LessThan(x, 1)
+    assert (x <= 0) != Relational(x, 1, '<=')
+    assert (x <= 0) != Relational(x, 1, 'le')
+    assert (x <= 0) != LessThan(x, 1)
+
+    assert Gt(x, 0) == Relational(x, 0, '>')
+    assert Gt(x, 0) == Relational(x, 0, 'gt')
+    assert Gt(x, 0) == StrictGreaterThan(x, 0)
+    assert Gt(x, 1) != Relational(x, 0, '>')
+    assert Gt(x, 1) != Relational(x, 0, 'gt')
+    assert Gt(x, 1) != StrictGreaterThan(x, 0)
+    assert (x > 1) == Relational(x, 1, '>')
+    assert (x > 1) == Relational(x, 1, 'gt')
+    assert (x > 1) == StrictGreaterThan(x, 1)
+    assert (x > 0) != Relational(x, 1, '>')
+    assert (x > 0) != Relational(x, 1, 'gt')
+    assert (x > 0) != StrictGreaterThan(x, 1)
+
+    assert Lt(x, 0) == Relational(x, 0, '<')
+    assert Lt(x, 0) == Relational(x, 0, 'lt')
+    assert Lt(x, 0) == StrictLessThan(x, 0)
+    assert Lt(x, 1) != Relational(x, 0, '<')
+    assert Lt(x, 1) != Relational(x, 0, 'lt')
+    assert Lt(x, 1) != StrictLessThan(x, 0)
+    assert (x < 1) == Relational(x, 1, '<')
+    assert (x < 1) == Relational(x, 1, 'lt')
+    assert (x < 1) == StrictLessThan(x, 1)
+    assert (x < 0) != Relational(x, 1, '<')
+    assert (x < 0) != Relational(x, 1, 'lt')
+    assert (x < 0) != StrictLessThan(x, 1)
+
+    # finally, some fuzz testing
+    from sympy.core.random import randint
+    for i in range(100):
+        while 1:
+            strtype, length = (chr, 65535) if randint(0, 1) else (chr, 255)
+            relation_type = strtype(randint(0, length))
+            if randint(0, 1):
+                relation_type += strtype(randint(0, length))
+            if relation_type not in ('==', 'eq', '!=', '<>', 'ne', '>=', 'ge',
+                                     '<=', 'le', '>', 'gt', '<', 'lt', ':=',
+                                     '+=', '-=', '*=', '/=', '%='):
+                break
+
+        raises(ValueError, lambda: Relational(x, 1, relation_type))
+    assert all(Relational(x, 0, op).rel_op == '==' for op in ('eq', '=='))
+    assert all(Relational(x, 0, op).rel_op == '!='
+               for op in ('ne', '<>', '!='))
+    assert all(Relational(x, 0, op).rel_op == '>' for op in ('gt', '>'))
+    assert all(Relational(x, 0, op).rel_op == '<' for op in ('lt', '<'))
+    assert all(Relational(x, 0, op).rel_op == '>=' for op in ('ge', '>='))
+    assert all(Relational(x, 0, op).rel_op == '<=' for op in ('le', '<='))
+
+
+def test_relational_arithmetic():
+    for cls in [Eq, Ne, Le, Lt, Ge, Gt]:
+        rel = cls(x, y)
+        raises(TypeError, lambda: 0+rel)
+        raises(TypeError, lambda: 1*rel)
+        raises(TypeError, lambda: 1**rel)
+        raises(TypeError, lambda: rel**1)
+        raises(TypeError, lambda: Add(0, rel))
+        raises(TypeError, lambda: Mul(1, rel))
+        raises(TypeError, lambda: Pow(1, rel))
+        raises(TypeError, lambda: Pow(rel, 1))
+
+
+def test_relational_bool_output():
+    # https://github.com/sympy/sympy/issues/5931
+    raises(TypeError, lambda: bool(x > 3))
+    raises(TypeError, lambda: bool(x >= 3))
+    raises(TypeError, lambda: bool(x < 3))
+    raises(TypeError, lambda: bool(x <= 3))
+    raises(TypeError, lambda: bool(Eq(x, 3)))
+    raises(TypeError, lambda: bool(Ne(x, 3)))
+
+
+def test_relational_logic_symbols():
+    # See issue 6204
+    assert (x < y) & (z < t) == And(x < y, z < t)
+    assert (x < y) | (z < t) == Or(x < y, z < t)
+    assert ~(x < y) == Not(x < y)
+    assert (x < y) >> (z < t) == Implies(x < y, z < t)
+    assert (x < y) << (z < t) == Implies(z < t, x < y)
+    assert (x < y) ^ (z < t) == Xor(x < y, z < t)
+
+    assert isinstance((x < y) & (z < t), And)
+    assert isinstance((x < y) | (z < t), Or)
+    assert isinstance(~(x < y), GreaterThan)
+    assert isinstance((x < y) >> (z < t), Implies)
+    assert isinstance((x < y) << (z < t), Implies)
+    assert isinstance((x < y) ^ (z < t), (Or, Xor))
+
+
+def test_univariate_relational_as_set():
+    assert (x > 0).as_set() == Interval(0, oo, True, True)
+    assert (x >= 0).as_set() == Interval(0, oo)
+    assert (x < 0).as_set() == Interval(-oo, 0, True, True)
+    assert (x <= 0).as_set() == Interval(-oo, 0)
+    assert Eq(x, 0).as_set() == FiniteSet(0)
+    assert Ne(x, 0).as_set() == Interval(-oo, 0, True, True) + \
+        Interval(0, oo, True, True)
+
+    assert (x**2 >= 4).as_set() == Interval(-oo, -2) + Interval(2, oo)
+
+
+@XFAIL
+def test_multivariate_relational_as_set():
+    assert (x*y >= 0).as_set() == Interval(0, oo)*Interval(0, oo) + \
+        Interval(-oo, 0)*Interval(-oo, 0)
+
+
+def test_Not():
+    assert Not(Equality(x, y)) == Unequality(x, y)
+    assert Not(Unequality(x, y)) == Equality(x, y)
+    assert Not(StrictGreaterThan(x, y)) == LessThan(x, y)
+    assert Not(StrictLessThan(x, y)) == GreaterThan(x, y)
+    assert Not(GreaterThan(x, y)) == StrictLessThan(x, y)
+    assert Not(LessThan(x, y)) == StrictGreaterThan(x, y)
+
+
+def test_evaluate():
+    assert str(Eq(x, x, evaluate=False)) == 'Eq(x, x)'
+    assert Eq(x, x, evaluate=False).doit() == S.true
+    assert str(Ne(x, x, evaluate=False)) == 'Ne(x, x)'
+    assert Ne(x, x, evaluate=False).doit() == S.false
+
+    assert str(Ge(x, x, evaluate=False)) == 'x >= x'
+    assert str(Le(x, x, evaluate=False)) == 'x <= x'
+    assert str(Gt(x, x, evaluate=False)) == 'x > x'
+    assert str(Lt(x, x, evaluate=False)) == 'x < x'
+
+
+def assert_all_ineq_raise_TypeError(a, b):
+    raises(TypeError, lambda: a > b)
+    raises(TypeError, lambda: a >= b)
+    raises(TypeError, lambda: a < b)
+    raises(TypeError, lambda: a <= b)
+    raises(TypeError, lambda: b > a)
+    raises(TypeError, lambda: b >= a)
+    raises(TypeError, lambda: b < a)
+    raises(TypeError, lambda: b <= a)
+
+
+def assert_all_ineq_give_class_Inequality(a, b):
+    """All inequality operations on `a` and `b` result in class Inequality."""
+    from sympy.core.relational import _Inequality as Inequality
+    assert isinstance(a > b,  Inequality)
+    assert isinstance(a >= b, Inequality)
+    assert isinstance(a < b,  Inequality)
+    assert isinstance(a <= b, Inequality)
+    assert isinstance(b > a,  Inequality)
+    assert isinstance(b >= a, Inequality)
+    assert isinstance(b < a,  Inequality)
+    assert isinstance(b <= a, Inequality)
+
+
+def test_imaginary_compare_raises_TypeError():
+    # See issue #5724
+    assert_all_ineq_raise_TypeError(I, x)
+
+
+def test_complex_compare_not_real():
+    # two cases which are not real
+    y = Symbol('y', imaginary=True)
+    z = Symbol('z', complex=True, extended_real=False)
+    for w in (y, z):
+        assert_all_ineq_raise_TypeError(2, w)
+    # some cases which should remain un-evaluated
+    t = Symbol('t')
+    x = Symbol('x', real=True)
+    z = Symbol('z', complex=True)
+    for w in (x, z, t):
+        assert_all_ineq_give_class_Inequality(2, w)
+
+
+def test_imaginary_and_inf_compare_raises_TypeError():
+    # See pull request #7835
+    y = Symbol('y', imaginary=True)
+    assert_all_ineq_raise_TypeError(oo, y)
+    assert_all_ineq_raise_TypeError(-oo, y)
+
+
+def test_complex_pure_imag_not_ordered():
+    raises(TypeError, lambda: 2*I < 3*I)
+
+    # more generally
+    x = Symbol('x', real=True, nonzero=True)
+    y = Symbol('y', imaginary=True)
+    z = Symbol('z', complex=True)
+    assert_all_ineq_raise_TypeError(I, y)
+
+    t = I*x   # an imaginary number, should raise errors
+    assert_all_ineq_raise_TypeError(2, t)
+
+    t = -I*y   # a real number, so no errors
+    assert_all_ineq_give_class_Inequality(2, t)
+
+    t = I*z   # unknown, should be unevaluated
+    assert_all_ineq_give_class_Inequality(2, t)
+
+
+def test_x_minus_y_not_same_as_x_lt_y():
+    """
+    A consequence of pull request #7792 is that `x - y < 0` and `x < y`
+    are not synonymous.
+    """
+    x = I + 2
+    y = I + 3
+    raises(TypeError, lambda: x < y)
+    assert x - y < 0
+
+    ineq = Lt(x, y, evaluate=False)
+    raises(TypeError, lambda: ineq.doit())
+    assert ineq.lhs - ineq.rhs < 0
+
+    t = Symbol('t', imaginary=True)
+    x = 2 + t
+    y = 3 + t
+    ineq = Lt(x, y, evaluate=False)
+    raises(TypeError, lambda: ineq.doit())
+    assert ineq.lhs - ineq.rhs < 0
+
+    # this one should give error either way
+    x = I + 2
+    y = 2*I + 3
+    raises(TypeError, lambda: x < y)
+    raises(TypeError, lambda: x - y < 0)
+
+
+def test_nan_equality_exceptions():
+    # See issue #7774
+    import random
+    assert Equality(nan, nan) is S.false
+    assert Unequality(nan, nan) is S.true
+
+    # See issue #7773
+    A = (x, S.Zero, S.One/3, pi, oo, -oo)
+    assert Equality(nan, random.choice(A)) is S.false
+    assert Equality(random.choice(A), nan) is S.false
+    assert Unequality(nan, random.choice(A)) is S.true
+    assert Unequality(random.choice(A), nan) is S.true
+
+
+def test_nan_inequality_raise_errors():
+    # See discussion in pull request #7776.  We test inequalities with
+    # a set including examples of various classes.
+    for q in (x, S.Zero, S(10), S.One/3, pi, S(1.3), oo, -oo, nan):
+        assert_all_ineq_raise_TypeError(q, nan)
+
+
+def test_nan_complex_inequalities():
+    # Comparisons of NaN with non-real raise errors, we're not too
+    # fussy whether its the NaN error or complex error.
+    for r in (I, zoo, Symbol('z', imaginary=True)):
+        assert_all_ineq_raise_TypeError(r, nan)
+
+
+def test_complex_infinity_inequalities():
+    raises(TypeError, lambda: zoo > 0)
+    raises(TypeError, lambda: zoo >= 0)
+    raises(TypeError, lambda: zoo < 0)
+    raises(TypeError, lambda: zoo <= 0)
+
+
+def test_inequalities_symbol_name_same():
+    """Using the operator and functional forms should give same results."""
+    # We test all combinations from a set
+    # FIXME: could replace with random selection after test passes
+    A = (x, y, S.Zero, S.One/3, pi, oo, -oo)
+    for a in A:
+        for b in A:
+            assert Gt(a, b) == (a > b)
+            assert Lt(a, b) == (a < b)
+            assert Ge(a, b) == (a >= b)
+            assert Le(a, b) == (a <= b)
+
+    for b in (y, S.Zero, S.One/3, pi, oo, -oo):
+        assert Gt(x, b, evaluate=False) == (x > b)
+        assert Lt(x, b, evaluate=False) == (x < b)
+        assert Ge(x, b, evaluate=False) == (x >= b)
+        assert Le(x, b, evaluate=False) == (x <= b)
+
+    for b in (y, S.Zero, S.One/3, pi, oo, -oo):
+        assert Gt(b, x, evaluate=False) == (b > x)
+        assert Lt(b, x, evaluate=False) == (b < x)
+        assert Ge(b, x, evaluate=False) == (b >= x)
+        assert Le(b, x, evaluate=False) == (b <= x)
+
+
+def test_inequalities_symbol_name_same_complex():
+    """Using the operator and functional forms should give same results.
+    With complex non-real numbers, both should raise errors.
+    """
+    # FIXME: could replace with random selection after test passes
+    for a in (x, S.Zero, S.One/3, pi, oo, Rational(1, 3)):
+        raises(TypeError, lambda: Gt(a, I))
+        raises(TypeError, lambda: a > I)
+        raises(TypeError, lambda: Lt(a, I))
+        raises(TypeError, lambda: a < I)
+        raises(TypeError, lambda: Ge(a, I))
+        raises(TypeError, lambda: a >= I)
+        raises(TypeError, lambda: Le(a, I))
+        raises(TypeError, lambda: a <= I)
+
+
+def test_inequalities_cant_sympify_other():
+    # see issue 7833
+    from operator import gt, lt, ge, le
+
+    bar = "foo"
+
+    for a in (x, S.Zero, S.One/3, pi, I, zoo, oo, -oo, nan, Rational(1, 3)):
+        for op in (lt, gt, le, ge):
+            raises(TypeError, lambda: op(a, bar))
+
+
+def test_ineq_avoid_wild_symbol_flip():
+    # see issue #7951, we try to avoid this internally, e.g., by using
+    # __lt__ instead of "<".
+    from sympy.core.symbol import Wild
+    p = symbols('p', cls=Wild)
+    # x > p might flip, but Gt should not:
+    assert Gt(x, p) == Gt(x, p, evaluate=False)
+    # Previously failed as 'p > x':
+    e = Lt(x, y).subs({y: p})
+    assert e == Lt(x, p, evaluate=False)
+    # Previously failed as 'p <= x':
+    e = Ge(x, p).doit()
+    assert e == Ge(x, p, evaluate=False)
+
+
+def test_issue_8245():
+    a = S("6506833320952669167898688709329/5070602400912917605986812821504")
+    assert rel_check(a, a.n(10))
+    assert rel_check(a, a.n(20))
+    assert rel_check(a, a.n())
+    # prec of 31 is enough to fully capture a as mpf
+    assert Float(a, 31) == Float(str(a.p), '')/Float(str(a.q), '')
+    for i in range(31):
+        r = Rational(Float(a, i))
+        f = Float(r)
+        assert (f < a) == (Rational(f) < a)
+    # test sign handling
+    assert (-f < -a) == (Rational(-f) < -a)
+    # test equivalence handling
+    isa = Float(a.p,'')/Float(a.q,'')
+    assert isa <= a
+    assert not isa < a
+    assert isa >= a
+    assert not isa > a
+    assert isa > 0
+
+    a = sqrt(2)
+    r = Rational(str(a.n(30)))
+    assert rel_check(a, r)
+
+    a = sqrt(2)
+    r = Rational(str(a.n(29)))
+    assert rel_check(a, r)
+
+    assert Eq(log(cos(2)**2 + sin(2)**2), 0) is S.true
+
+
+def test_issue_8449():
+    p = Symbol('p', nonnegative=True)
+    assert Lt(-oo, p)
+    assert Ge(-oo, p) is S.false
+    assert Gt(oo, -p)
+    assert Le(oo, -p) is S.false
+
+
+def test_simplify_relational():
+    assert simplify(x*(y + 1) - x*y - x + 1 < x) == (x > 1)
+    assert simplify(x*(y + 1) - x*y - x - 1 < x) == (x > -1)
+    assert simplify(x < x*(y + 1) - x*y - x + 1) == (x < 1)
+    q, r = symbols("q r")
+    assert (((-q + r) - (q - r)) <= 0).simplify() == (q >= r)
+    root2 = sqrt(2)
+    equation = ((root2 * (-q + r) - root2 * (q - r)) <= 0).simplify()
+    assert equation == (q >= r)
+    r = S.One < x
+    # canonical operations are not the same as simplification,
+    # so if there is no simplification, canonicalization will
+    # be done unless the measure forbids it
+    assert simplify(r) == r.canonical
+    assert simplify(r, ratio=0) != r.canonical
+    # this is not a random test; in _eval_simplify
+    # this will simplify to S.false and that is the
+    # reason for the 'if r.is_Relational' in Relational's
+    # _eval_simplify routine
+    assert simplify(-(2**(pi*Rational(3, 2)) + 6**pi)**(1/pi) +
+                    2*(2**(pi/2) + 3**pi)**(1/pi) < 0) is S.false
+    # canonical at least
+    assert Eq(y, x).simplify() == Eq(x, y)
+    assert Eq(x - 1, 0).simplify() == Eq(x, 1)
+    assert Eq(x - 1, x).simplify() == S.false
+    assert Eq(2*x - 1, x).simplify() == Eq(x, 1)
+    assert Eq(2*x, 4).simplify() == Eq(x, 2)
+    z = cos(1)**2 + sin(1)**2 - 1  # z.is_zero is None
+    assert Eq(z*x, 0).simplify() == S.true
+
+    assert Ne(y, x).simplify() == Ne(x, y)
+    assert Ne(x - 1, 0).simplify() == Ne(x, 1)
+    assert Ne(x - 1, x).simplify() == S.true
+    assert Ne(2*x - 1, x).simplify() == Ne(x, 1)
+    assert Ne(2*x, 4).simplify() == Ne(x, 2)
+    assert Ne(z*x, 0).simplify() == S.false
+
+    # No real-valued assumptions
+    assert Ge(y, x).simplify() == Le(x, y)
+    assert Ge(x - 1, 0).simplify() == Ge(x, 1)
+    assert Ge(x - 1, x).simplify() == S.false
+    assert Ge(2*x - 1, x).simplify() == Ge(x, 1)
+    assert Ge(2*x, 4).simplify() == Ge(x, 2)
+    assert Ge(z*x, 0).simplify() == S.true
+    assert Ge(x, -2).simplify() == Ge(x, -2)
+    assert Ge(-x, -2).simplify() == Le(x, 2)
+    assert Ge(x, 2).simplify() == Ge(x, 2)
+    assert Ge(-x, 2).simplify() == Le(x, -2)
+
+    assert Le(y, x).simplify() == Ge(x, y)
+    assert Le(x - 1, 0).simplify() == Le(x, 1)
+    assert Le(x - 1, x).simplify() == S.true
+    assert Le(2*x - 1, x).simplify() == Le(x, 1)
+    assert Le(2*x, 4).simplify() == Le(x, 2)
+    assert Le(z*x, 0).simplify() == S.true
+    assert Le(x, -2).simplify() == Le(x, -2)
+    assert Le(-x, -2).simplify() == Ge(x, 2)
+    assert Le(x, 2).simplify() == Le(x, 2)
+    assert Le(-x, 2).simplify() == Ge(x, -2)
+
+    assert Gt(y, x).simplify() == Lt(x, y)
+    assert Gt(x - 1, 0).simplify() == Gt(x, 1)
+    assert Gt(x - 1, x).simplify() == S.false
+    assert Gt(2*x - 1, x).simplify() == Gt(x, 1)
+    assert Gt(2*x, 4).simplify() == Gt(x, 2)
+    assert Gt(z*x, 0).simplify() == S.false
+    assert Gt(x, -2).simplify() == Gt(x, -2)
+    assert Gt(-x, -2).simplify() == Lt(x, 2)
+    assert Gt(x, 2).simplify() == Gt(x, 2)
+    assert Gt(-x, 2).simplify() == Lt(x, -2)
+
+    assert Lt(y, x).simplify() == Gt(x, y)
+    assert Lt(x - 1, 0).simplify() == Lt(x, 1)
+    assert Lt(x - 1, x).simplify() == S.true
+    assert Lt(2*x - 1, x).simplify() == Lt(x, 1)
+    assert Lt(2*x, 4).simplify() == Lt(x, 2)
+    assert Lt(z*x, 0).simplify() == S.false
+    assert Lt(x, -2).simplify() == Lt(x, -2)
+    assert Lt(-x, -2).simplify() == Gt(x, 2)
+    assert Lt(x, 2).simplify() == Lt(x, 2)
+    assert Lt(-x, 2).simplify() == Gt(x, -2)
+
+    # Test particular branches of _eval_simplify
+    m = exp(1) - exp_polar(1)
+    assert simplify(m*x > 1) is S.false
+    # These two test the same branch
+    assert simplify(m*x + 2*m*y > 1) is S.false
+    assert simplify(m*x + y > 1 + y) is S.false
+
+
+def test_equals():
+    w, x, y, z = symbols('w:z')
+    f = Function('f')
+    assert Eq(x, 1).equals(Eq(x*(y + 1) - x*y - x + 1, x))
+    assert Eq(x, y).equals(x < y, True) == False
+    assert Eq(x, f(1)).equals(Eq(x, f(2)), True) == f(1) - f(2)
+    assert Eq(f(1), y).equals(Eq(f(2), y), True) == f(1) - f(2)
+    assert Eq(x, f(1)).equals(Eq(f(2), x), True) == f(1) - f(2)
+    assert Eq(f(1), x).equals(Eq(x, f(2)), True) == f(1) - f(2)
+    assert Eq(w, x).equals(Eq(y, z), True) == False
+    assert Eq(f(1), f(2)).equals(Eq(f(3), f(4)), True) == f(1) - f(3)
+    assert (x < y).equals(y > x, True) == True
+    assert (x < y).equals(y >= x, True) == False
+    assert (x < y).equals(z < y, True) == False
+    assert (x < y).equals(x < z, True) == False
+    assert (x < f(1)).equals(x < f(2), True) == f(1) - f(2)
+    assert (f(1) < x).equals(f(2) < x, True) == f(1) - f(2)
+
+
+def test_reversed():
+    assert (x < y).reversed == (y > x)
+    assert (x <= y).reversed == (y >= x)
+    assert Eq(x, y, evaluate=False).reversed == Eq(y, x, evaluate=False)
+    assert Ne(x, y, evaluate=False).reversed == Ne(y, x, evaluate=False)
+    assert (x >= y).reversed == (y <= x)
+    assert (x > y).reversed == (y < x)
+
+
+def test_canonical():
+    c = [i.canonical for i in (
+        x + y < z,
+        x + 2 > 3,
+        x < 2,
+        S(2) > x,
+        x**2 > -x/y,
+        Gt(3, 2, evaluate=False)
+        )]
+    assert [i.canonical for i in c] == c
+    assert [i.reversed.canonical for i in c] == c
+    assert not any(i.lhs.is_Number and not i.rhs.is_Number for i in c)
+
+    c = [i.reversed.func(i.rhs, i.lhs, evaluate=False).canonical for i in c]
+    assert [i.canonical for i in c] == c
+    assert [i.reversed.canonical for i in c] == c
+    assert not any(i.lhs.is_Number and not i.rhs.is_Number for i in c)
+    assert Eq(y < x, x > y).canonical is S.true
+
+
+@XFAIL
+def test_issue_8444_nonworkingtests():
+    x = symbols('x', real=True)
+    assert (x <= oo) == (x >= -oo) == True
+
+    x = symbols('x')
+    assert x >= floor(x)
+    assert (x < floor(x)) == False
+    assert x <= ceiling(x)
+    assert (x > ceiling(x)) == False
+
+
+def test_issue_8444_workingtests():
+    x = symbols('x')
+    assert Gt(x, floor(x)) == Gt(x, floor(x), evaluate=False)
+    assert Ge(x, floor(x)) == Ge(x, floor(x), evaluate=False)
+    assert Lt(x, ceiling(x)) == Lt(x, ceiling(x), evaluate=False)
+    assert Le(x, ceiling(x)) == Le(x, ceiling(x), evaluate=False)
+    i = symbols('i', integer=True)
+    assert (i > floor(i)) == False
+    assert (i < ceiling(i)) == False
+
+
+def test_issue_10304():
+    d = cos(1)**2 + sin(1)**2 - 1
+    assert d.is_comparable is False  # if this fails, find a new d
+    e = 1 + d*I
+    assert simplify(Eq(e, 0)) is S.false
+
+
+def test_issue_18412():
+    d = (Rational(1, 6) + z / 4 / y)
+    assert Eq(x, pi * y**3 * d).replace(y**3, z) == Eq(x, pi * z * d)
+
+
+def test_issue_10401():
+    x = symbols('x')
+    fin = symbols('inf', finite=True)
+    inf = symbols('inf', infinite=True)
+    inf2 = symbols('inf2', infinite=True)
+    infx = symbols('infx', infinite=True, extended_real=True)
+    # Used in the commented tests below:
+    #infx2 = symbols('infx2', infinite=True, extended_real=True)
+    infnx = symbols('inf~x', infinite=True, extended_real=False)
+    infnx2 = symbols('inf~x2', infinite=True, extended_real=False)
+    infp = symbols('infp', infinite=True, extended_positive=True)
+    infp1 = symbols('infp1', infinite=True, extended_positive=True)
+    infn = symbols('infn', infinite=True, extended_negative=True)
+    zero = symbols('z', zero=True)
+    nonzero = symbols('nz', zero=False, finite=True)
+
+    assert Eq(1/(1/x + 1), 1).func is Eq
+    assert Eq(1/(1/x + 1), 1).subs(x, S.ComplexInfinity) is S.true
+    assert Eq(1/(1/fin + 1), 1) is S.false
+
+    T, F = S.true, S.false
+    assert Eq(fin, inf) is F
+    assert Eq(inf, inf2) not in (T, F) and inf != inf2
+    assert Eq(1 + inf, 2 + inf2) not in (T, F) and inf != inf2
+    assert Eq(infp, infp1) is T
+    assert Eq(infp, infn) is F
+    assert Eq(1 + I*oo, I*oo) is F
+    assert Eq(I*oo, 1 + I*oo) is F
+    assert Eq(1 + I*oo, 2 + I*oo) is F
+    assert Eq(1 + I*oo, 2 + I*infx) is F
+    assert Eq(1 + I*oo, 2 + infx) is F
+    # FIXME: The test below fails because (-infx).is_extended_positive is True
+    # (should be None)
+    #assert Eq(1 + I*infx, 1 + I*infx2) not in (T, F) and infx != infx2
+    #
+    assert Eq(zoo, sqrt(2) + I*oo) is F
+    assert Eq(zoo, oo) is F
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    assert Eq(i*I, r) not in (T, F)
+    assert Eq(infx, infnx) is F
+    assert Eq(infnx, infnx2) not in (T, F) and infnx != infnx2
+    assert Eq(zoo, oo) is F
+    assert Eq(inf/inf2, 0) is F
+    assert Eq(inf/fin, 0) is F
+    assert Eq(fin/inf, 0) is T
+    assert Eq(zero/nonzero, 0) is T and ((zero/nonzero) != 0)
+    # The commented out test below is incorrect because:
+    assert zoo == -zoo
+    assert Eq(zoo, -zoo) is T
+    assert Eq(oo, -oo) is F
+    assert Eq(inf, -inf) not in (T, F)
+
+    assert Eq(fin/(fin + 1), 1) is S.false
+
+    o = symbols('o', odd=True)
+    assert Eq(o, 2*o) is S.false
+
+    p = symbols('p', positive=True)
+    assert Eq(p/(p - 1), 1) is F
+
+
+def test_issue_10633():
+    assert Eq(True, False) == False
+    assert Eq(False, True) == False
+    assert Eq(True, True) == True
+    assert Eq(False, False) == True
+
+
+def test_issue_10927():
+    x = symbols('x')
+    assert str(Eq(x, oo)) == 'Eq(x, oo)'
+    assert str(Eq(x, -oo)) == 'Eq(x, -oo)'
+
+
+def test_issues_13081_12583_12534():
+    # 13081
+    r = Rational('905502432259640373/288230376151711744')
+    assert (r < pi) is S.false
+    assert (r > pi) is S.true
+    # 12583
+    v = sqrt(2)
+    u = sqrt(v) + 2/sqrt(10 - 8/sqrt(2 - v) + 4*v*(1/sqrt(2 - v) - 1))
+    assert (u >= 0) is S.true
+    # 12534; Rational vs NumberSymbol
+    # here are some precisions for which Rational forms
+    # at a lower and higher precision bracket the value of pi
+    # e.g. for p = 20:
+    # Rational(pi.n(p + 1)).n(25) = 3.14159265358979323846 2834
+    #                    pi.n(25) = 3.14159265358979323846 2643
+    # Rational(pi.n(p    )).n(25) = 3.14159265358979323846 1987
+    assert [p for p in range(20, 50) if
+            (Rational(pi.n(p)) < pi) and
+            (pi < Rational(pi.n(p + 1)))] == [20, 24, 27, 33, 37, 43, 48]
+    # pick one such precision and affirm that the reversed operation
+    # gives the opposite result, i.e. if x < y is true then x > y
+    # must be false
+    for i in (20, 21):
+        v = pi.n(i)
+        assert rel_check(Rational(v), pi)
+        assert rel_check(v, pi)
+    assert rel_check(pi.n(20), pi.n(21))
+    # Float vs Rational
+    # the rational form is less than the floating representation
+    # at the same precision
+    assert [i for i in range(15, 50) if Rational(pi.n(i)) > pi.n(i)] == []
+    # this should be the same if we reverse the relational
+    assert [i for i in range(15, 50) if pi.n(i) < Rational(pi.n(i))] == []
+
+def test_issue_18188():
+    from sympy.sets.conditionset import ConditionSet
+    result1 = Eq(x*cos(x) - 3*sin(x), 0)
+    assert result1.as_set() == ConditionSet(x, Eq(x*cos(x) - 3*sin(x), 0), Reals)
+
+    result2 = Eq(x**2 + sqrt(x*2) + sin(x), 0)
+    assert result2.as_set() == ConditionSet(x, Eq(sqrt(2)*sqrt(x) + x**2 + sin(x), 0), Reals)
+
+def test_binary_symbols():
+    ans = {x}
+    for f in Eq, Ne:
+        for t in S.true, S.false:
+            eq = f(x, S.true)
+            assert eq.binary_symbols == ans
+            assert eq.reversed.binary_symbols == ans
+        assert f(x, 1).binary_symbols == set()
+
+
+def test_rel_args():
+    # can't have Boolean args; this is automatic for True/False
+    # with Python 3 and we confirm that SymPy does the same
+    # for true/false
+    for op in ['<', '<=', '>', '>=']:
+        for b in (S.true, x < 1, And(x, y)):
+            for v in (0.1, 1, 2**32, t, S.One):
+                raises(TypeError, lambda: Relational(b, v, op))
+
+
+def test_nothing_happens_to_Eq_condition_during_simplify():
+    # issue 25701
+    r = symbols('r', real=True)
+    assert Eq(2*sign(r + 3)/(5*Abs(r + 3)**Rational(3, 5)), 0
+        ).simplify() == Eq(Piecewise(
+        (0, Eq(r, -3)), ((r + 3)/(5*Abs((r + 3)**Rational(8, 5)))*2, True)), 0)
+
+
+def test_issue_15847():
+    a = Ne(x*(x + y), x**2 + x*y)
+    assert simplify(a) == False
+
+
+def test_negated_property():
+    eq = Eq(x, y)
+    assert eq.negated == Ne(x, y)
+
+    eq = Ne(x, y)
+    assert eq.negated == Eq(x, y)
+
+    eq = Ge(x + y, y - x)
+    assert eq.negated == Lt(x + y, y - x)
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(x, y).negated.negated == f(x, y)
+
+
+def test_reversedsign_property():
+    eq = Eq(x, y)
+    assert eq.reversedsign == Eq(-x, -y)
+
+    eq = Ne(x, y)
+    assert eq.reversedsign == Ne(-x, -y)
+
+    eq = Ge(x + y, y - x)
+    assert eq.reversedsign == Le(-x - y, x - y)
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(x, y).reversedsign.reversedsign == f(x, y)
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(-x, y).reversedsign.reversedsign == f(-x, y)
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(x, -y).reversedsign.reversedsign == f(x, -y)
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(-x, -y).reversedsign.reversedsign == f(-x, -y)
+
+
+def test_reversed_reversedsign_property():
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(x, y).reversed.reversedsign == f(x, y).reversedsign.reversed
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(-x, y).reversed.reversedsign == f(-x, y).reversedsign.reversed
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(x, -y).reversed.reversedsign == f(x, -y).reversedsign.reversed
+
+    for f in (Eq, Ne, Ge, Gt, Le, Lt):
+        assert f(-x, -y).reversed.reversedsign == \
+            f(-x, -y).reversedsign.reversed
+
+
+def test_improved_canonical():
+    def test_different_forms(listofforms):
+        for form1, form2 in combinations(listofforms, 2):
+            assert form1.canonical == form2.canonical
+
+    def generate_forms(expr):
+        return [expr, expr.reversed, expr.reversedsign,
+                expr.reversed.reversedsign]
+
+    test_different_forms(generate_forms(x > -y))
+    test_different_forms(generate_forms(x >= -y))
+    test_different_forms(generate_forms(Eq(x, -y)))
+    test_different_forms(generate_forms(Ne(x, -y)))
+    test_different_forms(generate_forms(pi < x))
+    test_different_forms(generate_forms(pi - 5*y < -x + 2*y**2 - 7))
+
+    assert (pi >= x).canonical == (x <= pi)
+
+
+def test_set_equality_canonical():
+    a, b, c = symbols('a b c')
+
+    A = Eq(FiniteSet(a, b, c), FiniteSet(1, 2, 3))
+    B = Ne(FiniteSet(a, b, c), FiniteSet(4, 5, 6))
+
+    assert A.canonical == A.reversed
+    assert B.canonical == B.reversed
+
+
+def test_trigsimp():
+    # issue 16736
+    s, c = sin(2*x), cos(2*x)
+    eq = Eq(s, c)
+    assert trigsimp(eq) == eq  # no rearrangement of sides
+    # simplification of sides might result in
+    # an unevaluated Eq
+    changed = trigsimp(Eq(s + c, sqrt(2)))
+    assert isinstance(changed, Eq)
+    assert changed.subs(x, pi/8) is S.true
+    # or an evaluated one
+    assert trigsimp(Eq(cos(x)**2 + sin(x)**2, 1)) is S.true
+
+
+def test_polynomial_relation_simplification():
+    assert Ge(3*x*(x + 1) + 4, 3*x).simplify() in [Ge(x**2, -Rational(4,3)), Le(-x**2, Rational(4, 3))]
+    assert Le(-(3*x*(x + 1) + 4), -3*x).simplify() in [Ge(x**2, -Rational(4,3)), Le(-x**2, Rational(4, 3))]
+    assert ((x**2+3)*(x**2-1)+3*x >= 2*x**2).simplify() in [(x**4 + 3*x >= 3), (-x**4 - 3*x <= -3)]
+
+
+def test_multivariate_linear_function_simplification():
+    assert Ge(x + y, x - y).simplify() == Ge(y, 0)
+    assert Le(-x + y, -x - y).simplify() == Le(y, 0)
+    assert Eq(2*x + y, 2*x + y - 3).simplify() == False
+    assert (2*x + y > 2*x + y - 3).simplify() == True
+    assert (2*x + y < 2*x + y - 3).simplify() == False
+    assert (2*x + y < 2*x + y + 3).simplify() == True
+    a, b, c, d, e, f, g = symbols('a b c d e f g')
+    assert Lt(a + b + c + 2*d, 3*d - f + g). simplify() == Lt(a, -b - c + d - f + g)
+
+
+def test_nonpolymonial_relations():
+    assert Eq(cos(x), 0).simplify() == Eq(cos(x), 0)
+
+def test_18778():
+    raises(TypeError, lambda: is_le(Basic(), Basic()))
+    raises(TypeError, lambda: is_gt(Basic(), Basic()))
+    raises(TypeError, lambda: is_ge(Basic(), Basic()))
+    raises(TypeError, lambda: is_lt(Basic(), Basic()))
+
+def test_EvalEq():
+    """
+
+    This test exists to ensure backwards compatibility.
+    The method to use is _eval_is_eq
+    """
+    from sympy.core.expr import Expr
+
+    class PowTest(Expr):
+        def __new__(cls, base, exp):
+            return Basic.__new__(PowTest, _sympify(base), _sympify(exp))
+
+        def _eval_Eq(lhs, rhs):
+            if type(lhs) == PowTest and type(rhs) == PowTest:
+                return lhs.args[0] == rhs.args[0] and lhs.args[1] == rhs.args[1]
+
+    assert is_eq(PowTest(3, 4), PowTest(3,4))
+    assert is_eq(PowTest(3, 4), _sympify(4)) is None
+    assert is_neq(PowTest(3, 4), PowTest(3,7))
+
+
+def test_is_eq():
+    # test assumptions
+    assert is_eq(x, y, Q.infinite(x) & Q.finite(y)) is False
+    assert is_eq(x, y, Q.infinite(x) & Q.infinite(y) & Q.extended_real(x) & ~Q.extended_real(y)) is False
+    assert is_eq(x, y, Q.infinite(x) & Q.infinite(y) & Q.extended_positive(x) & Q.extended_negative(y)) is False
+
+    assert is_eq(x+I, y+I, Q.infinite(x) & Q.finite(y)) is False
+    assert is_eq(1+x*I, 1+y*I, Q.infinite(x) & Q.finite(y)) is False
+
+    assert is_eq(x, S(0), assumptions=Q.zero(x))
+    assert is_eq(x, S(0), assumptions=~Q.zero(x)) is False
+    assert is_eq(x, S(0), assumptions=Q.nonzero(x)) is False
+    assert is_neq(x, S(0), assumptions=Q.zero(x)) is False
+    assert is_neq(x, S(0), assumptions=~Q.zero(x))
+    assert is_neq(x, S(0), assumptions=Q.nonzero(x))
+
+    # test registration
+    class PowTest(Expr):
+        def __new__(cls, base, exp):
+            return Basic.__new__(cls, _sympify(base), _sympify(exp))
+
+    @dispatch(PowTest, PowTest)
+    def _eval_is_eq(lhs, rhs):
+        if type(lhs) == PowTest and type(rhs) == PowTest:
+            return fuzzy_and([is_eq(lhs.args[0], rhs.args[0]), is_eq(lhs.args[1], rhs.args[1])])
+
+    assert is_eq(PowTest(3, 4), PowTest(3,4))
+    assert is_eq(PowTest(3, 4), _sympify(4)) is None
+    assert is_neq(PowTest(3, 4), PowTest(3,7))
+
+
+def test_is_ge_le():
+    # test assumptions
+    assert is_ge(x, S(0), Q.nonnegative(x)) is True
+    assert is_ge(x, S(0), Q.negative(x)) is False
+
+    # test registration
+    class PowTest(Expr):
+        def __new__(cls, base, exp):
+            return Basic.__new__(cls, _sympify(base), _sympify(exp))
+
+    @dispatch(PowTest, PowTest)
+    def _eval_is_ge(lhs, rhs):
+        if type(lhs) == PowTest and type(rhs) == PowTest:
+            return fuzzy_and([is_ge(lhs.args[0], rhs.args[0]), is_ge(lhs.args[1], rhs.args[1])])
+
+    assert is_ge(PowTest(3, 9), PowTest(3,2))
+    assert is_gt(PowTest(3, 9), PowTest(3,2))
+    assert is_le(PowTest(3, 2), PowTest(3,9))
+    assert is_lt(PowTest(3, 2), PowTest(3,9))
+
+
+def test_weak_strict():
+    for func in (Eq, Ne):
+        eq = func(x, 1)
+        assert eq.strict == eq.weak == eq
+    eq = Gt(x, 1)
+    assert eq.weak == Ge(x, 1)
+    assert eq.strict == eq
+    eq = Lt(x, 1)
+    assert eq.weak == Le(x, 1)
+    assert eq.strict == eq
+    eq = Ge(x, 1)
+    assert eq.strict == Gt(x, 1)
+    assert eq.weak == eq
+    eq = Le(x, 1)
+    assert eq.strict == Lt(x, 1)
+    assert eq.weak == eq
+
+
+def test_issue_23731():
+    i = symbols('i', integer=True)
+    assert unchanged(Eq, i, 1.0)
+    assert unchanged(Eq, i/2, 0.5)
+    ni = symbols('ni', integer=False)
+    assert Eq(ni, 1) == False
+    assert unchanged(Eq, ni, .1)
+    assert Eq(ni, 1.0) == False
+    nr = symbols('nr', rational=False)
+    assert Eq(nr, .1) == False
+
+
+def test_rewrite_Add():
+    from sympy.testing.pytest import warns_deprecated_sympy
+    with warns_deprecated_sympy():
+        assert Eq(x, y).rewrite(Add) == x - y
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_rules.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_rules.py
new file mode 100644
index 0000000000000000000000000000000000000000..31cb88b52db21f39653033b4567526e992be99f0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_rules.py
@@ -0,0 +1,14 @@
+from sympy.core.rules import Transform
+
+from sympy.testing.pytest import raises
+
+
+def test_Transform():
+    add1 = Transform(lambda x: x + 1, lambda x: x % 2 == 1)
+    assert add1[1] == 2
+    assert (1 in add1) is True
+    assert add1.get(1) == 2
+
+    raises(KeyError, lambda: add1[2])
+    assert (2 in add1) is False
+    assert add1.get(2) is None
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_singleton.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_singleton.py
new file mode 100644
index 0000000000000000000000000000000000000000..893713f27d74b884391ad800d186eafe5337ab1c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_singleton.py
@@ -0,0 +1,76 @@
+from sympy.core.basic import Basic
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S, Singleton
+
+def test_Singleton():
+
+    class MySingleton(Basic, metaclass=Singleton):
+        pass
+
+    MySingleton() # force instantiation
+    assert MySingleton() is not Basic()
+    assert MySingleton() is MySingleton()
+    assert S.MySingleton is MySingleton()
+
+    class MySingleton_sub(MySingleton):
+        pass
+
+    MySingleton_sub()
+    assert MySingleton_sub() is not MySingleton()
+    assert MySingleton_sub() is MySingleton_sub()
+
+def test_singleton_redefinition():
+    class TestSingleton(Basic, metaclass=Singleton):
+        pass
+
+    assert TestSingleton() is S.TestSingleton
+
+    class TestSingleton(Basic, metaclass=Singleton):
+        pass
+
+    assert TestSingleton() is S.TestSingleton
+
+def test_names_in_namespace():
+    # Every singleton name should be accessible from the 'from sympy import *'
+    # namespace in addition to the S object. However, it does not need to be
+    # by the same name (e.g., oo instead of S.Infinity).
+
+    # As a general rule, things should only be added to the singleton registry
+    # if they are used often enough that code can benefit either from the
+    # performance benefit of being able to use 'is' (this only matters in very
+    # tight loops), or from the memory savings of having exactly one instance
+    # (this matters for the numbers singletons, but very little else). The
+    # singleton registry is already a bit overpopulated, and things cannot be
+    # removed from it without breaking backwards compatibility. So if you got
+    # here by adding something new to the singletons, ask yourself if it
+    # really needs to be singletonized. Note that SymPy classes compare to one
+    # another just fine, so Class() == Class() will give True even if each
+    # Class() returns a new instance. Having unique instances is only
+    # necessary for the above noted performance gains. It should not be needed
+    # for any behavioral purposes.
+
+    # If you determine that something really should be a singleton, it must be
+    # accessible to sympify() without using 'S' (hence this test). Also, its
+    # str printer should print a form that does not use S. This is because
+    # sympify() disables attribute lookups by default for safety purposes.
+    d = {}
+    exec('from sympy import *', d)
+
+    for name in dir(S) + list(S._classes_to_install):
+        if name.startswith('_'):
+            continue
+        if name == 'register':
+            continue
+        if isinstance(getattr(S, name), Rational):
+            continue
+        if getattr(S, name).__module__.startswith('sympy.physics'):
+            continue
+        if name in ['MySingleton', 'MySingleton_sub', 'TestSingleton']:
+            # From the tests above
+            continue
+        if name == 'NegativeInfinity':
+            # Accessible by -oo
+            continue
+
+        # Use is here to ensure it is the exact same object
+        assert any(getattr(S, name) is i for i in d.values()), name
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sorting.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sorting.py
new file mode 100644
index 0000000000000000000000000000000000000000..a18dbfb624552cf2fa11bb7f3c3a9e865caeb0c4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sorting.py
@@ -0,0 +1,28 @@
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.testing.pytest import raises
+
+from sympy.abc import x
+
+
+def test_default_sort_key():
+    func = lambda x: x
+    assert sorted([func, x, func], key=default_sort_key) == [func, func, x]
+
+    class C:
+        def __repr__(self):
+            return 'x.y'
+    func = C()
+    assert sorted([x, func], key=default_sort_key) == [func, x]
+
+
+def test_ordered():
+    # Issue 7210 - this had been failing with python2/3 problems
+    assert (list(ordered([{1:3, 2:4, 9:10}, {1:3}])) == \
+               [{1: 3}, {1: 3, 2: 4, 9: 10}])
+    # warnings should not be raised for identical items
+    l = [1, 1]
+    assert list(ordered(l, warn=True)) == l
+    l = [[1], [2], [1]]
+    assert list(ordered(l, warn=True)) == [[1], [1], [2]]
+    raises(ValueError, lambda: list(ordered(['a', 'ab'], keys=[lambda x: x[0]],
+        default=False, warn=True)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_subs.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_subs.py
new file mode 100644
index 0000000000000000000000000000000000000000..0803a4b1b5e93b8a35f43516ccef3ab9a16f08ec
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_subs.py
@@ -0,0 +1,895 @@
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import (Dict, Tuple)
+from sympy.core.function import (Derivative, Function, Lambda, Subs)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, Wild, symbols)
+from sympy.core.sympify import SympifyError
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (atan2, cos, cot, sin, tan)
+from sympy.matrices.dense import (Matrix, zeros)
+from sympy.matrices.expressions.special import ZeroMatrix
+from sympy.polys.polytools import factor
+from sympy.polys.rootoftools import RootOf
+from sympy.simplify.cse_main import cse
+from sympy.simplify.simplify import nsimplify
+from sympy.core.basic import _aresame
+from sympy.testing.pytest import XFAIL, raises
+from sympy.abc import a, x, y, z, t
+
+
+def test_subs():
+    n3 = Rational(3)
+    e = x
+    e = e.subs(x, n3)
+    assert e == Rational(3)
+
+    e = 2*x
+    assert e == 2*x
+    e = e.subs(x, n3)
+    assert e == Rational(6)
+
+
+def test_subs_Matrix():
+    z = zeros(2)
+    z1 = ZeroMatrix(2, 2)
+    assert (x*y).subs({x:z, y:0}) in [z, z1]
+    assert (x*y).subs({y:z, x:0}) == 0
+    assert (x*y).subs({y:z, x:0}, simultaneous=True) in [z, z1]
+    assert (x + y).subs({x: z, y: z}, simultaneous=True) in [z, z1]
+    assert (x + y).subs({x: z, y: z}) in [z, z1]
+
+    # Issue #15528
+    assert Mul(Matrix([[3]]), x).subs(x, 2.0) == Matrix([[6.0]])
+    # Does not raise a TypeError, see comment on the MatAdd postprocessor
+    assert Add(Matrix([[3]]), x).subs(x, 2.0) == Add(Matrix([[3]]), 2.0)
+
+
+def test_subs_AccumBounds():
+    e = x
+    e = e.subs(x, AccumBounds(1, 3))
+    assert e == AccumBounds(1, 3)
+
+    e = 2*x
+    e = e.subs(x, AccumBounds(1, 3))
+    assert e == AccumBounds(2, 6)
+
+    e = x + x**2
+    e = e.subs(x, AccumBounds(-1, 1))
+    assert e == AccumBounds(-1, 2)
+
+
+def test_trigonometric():
+    n3 = Rational(3)
+    e = (sin(x)**2).diff(x)
+    assert e == 2*sin(x)*cos(x)
+    e = e.subs(x, n3)
+    assert e == 2*cos(n3)*sin(n3)
+
+    e = (sin(x)**2).diff(x)
+    assert e == 2*sin(x)*cos(x)
+    e = e.subs(sin(x), cos(x))
+    assert e == 2*cos(x)**2
+
+    assert exp(pi).subs(exp, sin) == 0
+    assert cos(exp(pi)).subs(exp, sin) == 1
+
+    i = Symbol('i', integer=True)
+    zoo = S.ComplexInfinity
+    assert tan(x).subs(x, pi/2) is zoo
+    assert cot(x).subs(x, pi) is zoo
+    assert cot(i*x).subs(x, pi) is zoo
+    assert tan(i*x).subs(x, pi/2) == tan(i*pi/2)
+    assert tan(i*x).subs(x, pi/2).subs(i, 1) is zoo
+    o = Symbol('o', odd=True)
+    assert tan(o*x).subs(x, pi/2) == tan(o*pi/2)
+
+
+def test_powers():
+    assert sqrt(1 - sqrt(x)).subs(x, 4) == I
+    assert (sqrt(1 - x**2)**3).subs(x, 2) == - 3*I*sqrt(3)
+    assert (x**Rational(1, 3)).subs(x, 27) == 3
+    assert (x**Rational(1, 3)).subs(x, -27) == 3*(-1)**Rational(1, 3)
+    assert ((-x)**Rational(1, 3)).subs(x, 27) == 3*(-1)**Rational(1, 3)
+    n = Symbol('n', negative=True)
+    assert (x**n).subs(x, 0) is S.ComplexInfinity
+    assert exp(-1).subs(S.Exp1, 0) is S.ComplexInfinity
+    assert (x**(4.0*y)).subs(x**(2.0*y), n) == n**2.0
+    assert (2**(x + 2)).subs(2, 3) == 3**(x + 3)
+
+
+def test_logexppow():   # no eval()
+    x = Symbol('x', real=True)
+    w = Symbol('w')
+    e = (3**(1 + x) + 2**(1 + x))/(3**x + 2**x)
+    assert e.subs(2**x, w) != e
+    assert e.subs(exp(x*log(Rational(2))), w) != e
+
+
+def test_bug():
+    x1 = Symbol('x1')
+    x2 = Symbol('x2')
+    y = x1*x2
+    assert y.subs(x1, Float(3.0)) == Float(3.0)*x2
+
+
+def test_subbug1():
+    # see that they don't fail
+    (x**x).subs(x, 1)
+    (x**x).subs(x, 1.0)
+
+
+def test_subbug2():
+    # Ensure this does not cause infinite recursion
+    assert Float(7.7).epsilon_eq(abs(x).subs(x, -7.7))
+
+
+def test_dict_set():
+    a, b, c = map(Wild, 'abc')
+
+    f = 3*cos(4*x)
+    r = f.match(a*cos(b*x))
+    assert r == {a: 3, b: 4}
+    e = a/b*sin(b*x)
+    assert e.subs(r) == r[a]/r[b]*sin(r[b]*x)
+    assert e.subs(r) == 3*sin(4*x) / 4
+    s = set(r.items())
+    assert e.subs(s) == r[a]/r[b]*sin(r[b]*x)
+    assert e.subs(s) == 3*sin(4*x) / 4
+
+    assert e.subs(r) == r[a]/r[b]*sin(r[b]*x)
+    assert e.subs(r) == 3*sin(4*x) / 4
+    assert x.subs(Dict((x, 1))) == 1
+
+
+def test_dict_ambigous():   # see issue 3566
+    f = x*exp(x)
+    g = z*exp(z)
+
+    df = {x: y, exp(x): y}
+    dg = {z: y, exp(z): y}
+
+    assert f.subs(df) == y**2
+    assert g.subs(dg) == y**2
+
+    # and this is how order can affect the result
+    assert f.subs(x, y).subs(exp(x), y) == y*exp(y)
+    assert f.subs(exp(x), y).subs(x, y) == y**2
+
+    # length of args and count_ops are the same so
+    # default_sort_key resolves ordering...if one
+    # doesn't want this result then an unordered
+    # sequence should not be used.
+    e = 1 + x*y
+    assert e.subs({x: y, y: 2}) == 5
+    # here, there are no obviously clashing keys or values
+    # but the results depend on the order
+    assert exp(x/2 + y).subs({exp(y + 1): 2, x: 2}) == exp(y + 1)
+
+
+def test_deriv_sub_bug3():
+    f = Function('f')
+    pat = Derivative(f(x), x, x)
+    assert pat.subs(y, y**2) == Derivative(f(x), x, x)
+    assert pat.subs(y, y**2) != Derivative(f(x), x)
+
+
+def test_equality_subs1():
+    f = Function('f')
+    eq = Eq(f(x)**2, x)
+    res = Eq(Integer(16), x)
+    assert eq.subs(f(x), 4) == res
+
+
+def test_equality_subs2():
+    f = Function('f')
+    eq = Eq(f(x)**2, 16)
+    assert bool(eq.subs(f(x), 3)) is False
+    assert bool(eq.subs(f(x), 4)) is True
+
+
+def test_issue_3742():
+    e = sqrt(x)*exp(y)
+    assert e.subs(sqrt(x), 1) == exp(y)
+
+
+def test_subs_dict1():
+    assert (1 + x*y).subs(x, pi) == 1 + pi*y
+    assert (1 + x*y).subs({x: pi, y: 2}) == 1 + 2*pi
+
+    c2, c3, q1p, q2p, c1, s1, s2, s3 = symbols('c2 c3 q1p q2p c1 s1 s2 s3')
+    test = (c2**2*q2p*c3 + c1**2*s2**2*q2p*c3 + s1**2*s2**2*q2p*c3
+            - c1**2*q1p*c2*s3 - s1**2*q1p*c2*s3)
+    assert (test.subs({c1**2: 1 - s1**2, c2**2: 1 - s2**2, c3**3: 1 - s3**2})
+        == c3*q2p*(1 - s2**2) + c3*q2p*s2**2*(1 - s1**2)
+            - c2*q1p*s3*(1 - s1**2) + c3*q2p*s1**2*s2**2 - c2*q1p*s3*s1**2)
+
+
+def test_mul():
+    x, y, z, a, b, c = symbols('x y z a b c')
+    A, B, C = symbols('A B C', commutative=0)
+    assert (x*y*z).subs(z*x, y) == y**2
+    assert (z*x).subs(1/x, z) == 1
+    assert (x*y/z).subs(1/z, a) == a*x*y
+    assert (x*y/z).subs(x/z, a) == a*y
+    assert (x*y/z).subs(y/z, a) == a*x
+    assert (x*y/z).subs(x/z, 1/a) == y/a
+    assert (x*y/z).subs(x, 1/a) == y/(z*a)
+    assert (2*x*y).subs(5*x*y, z) != z*Rational(2, 5)
+    assert (x*y*A).subs(x*y, a) == a*A
+    assert (x**2*y**(x*Rational(3, 2))).subs(x*y**(x/2), 2) == 4*y**(x/2)
+    assert (x*exp(x*2)).subs(x*exp(x), 2) == 2*exp(x)
+    assert ((x**(2*y))**3).subs(x**y, 2) == 64
+    assert (x*A*B).subs(x*A, y) == y*B
+    assert (x*y*(1 + x)*(1 + x*y)).subs(x*y, 2) == 6*(1 + x)
+    assert ((1 + A*B)*A*B).subs(A*B, x*A*B)
+    assert (x*a/z).subs(x/z, A) == a*A
+    assert (x**3*A).subs(x**2*A, a) == a*x
+    assert (x**2*A*B).subs(x**2*B, a) == a*A
+    assert (x**2*A*B).subs(x**2*A, a) == a*B
+    assert (b*A**3/(a**3*c**3)).subs(a**4*c**3*A**3/b**4, z) == \
+        b*A**3/(a**3*c**3)
+    assert (6*x).subs(2*x, y) == 3*y
+    assert (y*exp(x*Rational(3, 2))).subs(y*exp(x), 2) == 2*exp(x/2)
+    assert (y*exp(x*Rational(3, 2))).subs(y*exp(x), 2) == 2*exp(x/2)
+    assert (A**2*B*A**2*B*A**2).subs(A*B*A, C) == A*C**2*A
+    assert (x*A**3).subs(x*A, y) == y*A**2
+    assert (x**2*A**3).subs(x*A, y) == y**2*A
+    assert (x*A**3).subs(x*A, B) == B*A**2
+    assert (x*A*B*A*exp(x*A*B)).subs(x*A, B) == B**2*A*exp(B*B)
+    assert (x**2*A*B*A*exp(x*A*B)).subs(x*A, B) == B**3*exp(B**2)
+    assert (x**3*A*exp(x*A*B)*A*exp(x*A*B)).subs(x*A, B) == \
+        x*B*exp(B**2)*B*exp(B**2)
+    assert (x*A*B*C*A*B).subs(x*A*B, C) == C**2*A*B
+    assert (-I*a*b).subs(a*b, 2) == -2*I
+
+    # issue 6361
+    assert (-8*I*a).subs(-2*a, 1) == 4*I
+    assert (-I*a).subs(-a, 1) == I
+
+    # issue 6441
+    assert (4*x**2).subs(2*x, y) == y**2
+    assert (2*4*x**2).subs(2*x, y) == 2*y**2
+    assert (-x**3/9).subs(-x/3, z) == -z**2*x
+    assert (-x**3/9).subs(x/3, z) == -z**2*x
+    assert (-2*x**3/9).subs(x/3, z) == -2*x*z**2
+    assert (-2*x**3/9).subs(-x/3, z) == -2*x*z**2
+    assert (-2*x**3/9).subs(-2*x, z) == z*x**2/9
+    assert (-2*x**3/9).subs(2*x, z) == -z*x**2/9
+    assert (2*(3*x/5/7)**2).subs(3*x/5, z) == 2*(Rational(1, 7))**2*z**2
+    assert (4*x).subs(-2*x, z) == 4*x  # try keep subs literal
+
+
+def test_subs_simple():
+    a = symbols('a', commutative=True)
+    x = symbols('x', commutative=False)
+
+    assert (2*a).subs(1, 3) == 2*a
+    assert (2*a).subs(2, 3) == 3*a
+    assert (2*a).subs(a, 3) == 6
+    assert sin(2).subs(1, 3) == sin(2)
+    assert sin(2).subs(2, 3) == sin(3)
+    assert sin(a).subs(a, 3) == sin(3)
+
+    assert (2*x).subs(1, 3) == 2*x
+    assert (2*x).subs(2, 3) == 3*x
+    assert (2*x).subs(x, 3) == 6
+    assert sin(x).subs(x, 3) == sin(3)
+
+
+def test_subs_constants():
+    a, b = symbols('a b', commutative=True)
+    x, y = symbols('x y', commutative=False)
+
+    assert (a*b).subs(2*a, 1) == a*b
+    assert (1.5*a*b).subs(a, 1) == 1.5*b
+    assert (2*a*b).subs(2*a, 1) == b
+    assert (2*a*b).subs(4*a, 1) == 2*a*b
+
+    assert (x*y).subs(2*x, 1) == x*y
+    assert (1.5*x*y).subs(x, 1) == 1.5*y
+    assert (2*x*y).subs(2*x, 1) == y
+    assert (2*x*y).subs(4*x, 1) == 2*x*y
+
+
+def test_subs_commutative():
+    a, b, c, d, K = symbols('a b c d K', commutative=True)
+
+    assert (a*b).subs(a*b, K) == K
+    assert (a*b*a*b).subs(a*b, K) == K**2
+    assert (a*a*b*b).subs(a*b, K) == K**2
+    assert (a*b*c*d).subs(a*b*c, K) == d*K
+    assert (a*b**c).subs(a, K) == K*b**c
+    assert (a*b**c).subs(b, K) == a*K**c
+    assert (a*b**c).subs(c, K) == a*b**K
+    assert (a*b*c*b*a).subs(a*b, K) == c*K**2
+    assert (a**3*b**2*a).subs(a*b, K) == a**2*K**2
+
+
+def test_subs_noncommutative():
+    w, x, y, z, L = symbols('w x y z L', commutative=False)
+    alpha = symbols('alpha', commutative=True)
+    someint = symbols('someint', commutative=True, integer=True)
+
+    assert (x*y).subs(x*y, L) == L
+    assert (w*y*x).subs(x*y, L) == w*y*x
+    assert (w*x*y*z).subs(x*y, L) == w*L*z
+    assert (x*y*x*y).subs(x*y, L) == L**2
+    assert (x*x*y).subs(x*y, L) == x*L
+    assert (x*x*y*y).subs(x*y, L) == x*L*y
+    assert (w*x*y).subs(x*y*z, L) == w*x*y
+    assert (x*y**z).subs(x, L) == L*y**z
+    assert (x*y**z).subs(y, L) == x*L**z
+    assert (x*y**z).subs(z, L) == x*y**L
+    assert (w*x*y*z*x*y).subs(x*y*z, L) == w*L*x*y
+    assert (w*x*y*y*w*x*x*y*x*y*y*x*y).subs(x*y, L) == w*L*y*w*x*L**2*y*L
+
+    # Check fractional power substitutions. It should not do
+    # substitutions that choose a value for noncommutative log,
+    # or inverses that don't already appear in the expressions.
+    assert (x*x*x).subs(x*x, L) == L*x
+    assert (x*x*x*y*x*x*x*x).subs(x*x, L) == L*x*y*L**2
+    for p in range(1, 5):
+        for k in range(10):
+            assert (y * x**k).subs(x**p, L) == y * L**(k//p) * x**(k % p)
+    assert (x**Rational(3, 2)).subs(x**S.Half, L) == x**Rational(3, 2)
+    assert (x**S.Half).subs(x**S.Half, L) == L
+    assert (x**Rational(-1, 2)).subs(x**S.Half, L) == x**Rational(-1, 2)
+    assert (x**Rational(-1, 2)).subs(x**Rational(-1, 2), L) == L
+
+    assert (x**(2*someint)).subs(x**someint, L) == L**2
+    assert (x**(2*someint + 3)).subs(x**someint, L) == L**2*x**3
+    assert (x**(3*someint + 3)).subs(x**someint, L) == L**3*x**3
+    assert (x**(3*someint)).subs(x**(2*someint), L) == L * x**someint
+    assert (x**(4*someint)).subs(x**(2*someint), L) == L**2
+    assert (x**(4*someint + 1)).subs(x**(2*someint), L) == L**2 * x
+    assert (x**(4*someint)).subs(x**(3*someint), L) == L * x**someint
+    assert (x**(4*someint + 1)).subs(x**(3*someint), L) == L * x**(someint + 1)
+
+    assert (x**(2*alpha)).subs(x**alpha, L) == x**(2*alpha)
+    assert (x**(2*alpha + 2)).subs(x**2, L) == x**(2*alpha + 2)
+    assert ((2*z)**alpha).subs(z**alpha, y) == (2*z)**alpha
+    assert (x**(2*someint*alpha)).subs(x**someint, L) == x**(2*someint*alpha)
+    assert (x**(2*someint + alpha)).subs(x**someint, L) == x**(2*someint + alpha)
+
+    # This could in principle be substituted, but is not currently
+    # because it requires recognizing that someint**2 is divisible by
+    # someint.
+    assert (x**(someint**2 + 3)).subs(x**someint, L) == x**(someint**2 + 3)
+
+    # alpha**z := exp(log(alpha) z) is usually well-defined
+    assert (4**z).subs(2**z, y) == y**2
+
+    # Negative powers
+    assert (x**(-1)).subs(x**3, L) == x**(-1)
+    assert (x**(-2)).subs(x**3, L) == x**(-2)
+    assert (x**(-3)).subs(x**3, L) == L**(-1)
+    assert (x**(-4)).subs(x**3, L) == L**(-1) * x**(-1)
+    assert (x**(-5)).subs(x**3, L) == L**(-1) * x**(-2)
+
+    assert (x**(-1)).subs(x**(-3), L) == x**(-1)
+    assert (x**(-2)).subs(x**(-3), L) == x**(-2)
+    assert (x**(-3)).subs(x**(-3), L) == L
+    assert (x**(-4)).subs(x**(-3), L) == L * x**(-1)
+    assert (x**(-5)).subs(x**(-3), L) == L * x**(-2)
+
+    assert (x**1).subs(x**(-3), L) == x
+    assert (x**2).subs(x**(-3), L) == x**2
+    assert (x**3).subs(x**(-3), L) == L**(-1)
+    assert (x**4).subs(x**(-3), L) == L**(-1) * x
+    assert (x**5).subs(x**(-3), L) == L**(-1) * x**2
+
+
+def test_subs_basic_funcs():
+    a, b, c, d, K = symbols('a b c d K', commutative=True)
+    w, x, y, z, L = symbols('w x y z L', commutative=False)
+
+    assert (x + y).subs(x + y, L) == L
+    assert (x - y).subs(x - y, L) == L
+    assert (x/y).subs(x, L) == L/y
+    assert (x**y).subs(x, L) == L**y
+    assert (x**y).subs(y, L) == x**L
+    assert ((a - c)/b).subs(b, K) == (a - c)/K
+    assert (exp(x*y - z)).subs(x*y, L) == exp(L - z)
+    assert (a*exp(x*y - w*z) + b*exp(x*y + w*z)).subs(z, 0) == \
+        a*exp(x*y) + b*exp(x*y)
+    assert ((a - b)/(c*d - a*b)).subs(c*d - a*b, K) == (a - b)/K
+    assert (w*exp(a*b - c)*x*y/4).subs(x*y, L) == w*exp(a*b - c)*L/4
+
+
+def test_subs_wild():
+    R, S, T, U = symbols('R S T U', cls=Wild)
+
+    assert (R*S).subs(R*S, T) == T
+    assert (S*R).subs(R*S, T) == T
+    assert (R + S).subs(R + S, T) == T
+    assert (R**S).subs(R, T) == T**S
+    assert (R**S).subs(S, T) == R**T
+    assert (R*S**T).subs(R, U) == U*S**T
+    assert (R*S**T).subs(S, U) == R*U**T
+    assert (R*S**T).subs(T, U) == R*S**U
+
+
+def test_subs_mixed():
+    a, b, c, d, K = symbols('a b c d K', commutative=True)
+    w, x, y, z, L = symbols('w x y z L', commutative=False)
+    R, S, T, U = symbols('R S T U', cls=Wild)
+
+    assert (a*x*y).subs(x*y, L) == a*L
+    assert (a*b*x*y*x).subs(x*y, L) == a*b*L*x
+    assert (R*x*y*exp(x*y)).subs(x*y, L) == R*L*exp(L)
+    assert (a*x*y*y*x - x*y*z*exp(a*b)).subs(x*y, L) == a*L*y*x - L*z*exp(a*b)
+    e = c*y*x*y*x**(R*S - a*b) - T*(a*R*b*S)
+    assert e.subs(x*y, L).subs(a*b, K).subs(R*S, U) == \
+        c*y*L*x**(U - K) - T*(U*K)
+
+
+def test_division():
+    a, b, c = symbols('a b c', commutative=True)
+    x, y, z = symbols('x y z', commutative=True)
+
+    assert (1/a).subs(a, c) == 1/c
+    assert (1/a**2).subs(a, c) == 1/c**2
+    assert (1/a**2).subs(a, -2) == Rational(1, 4)
+    assert (-(1/a**2)).subs(a, -2) == Rational(-1, 4)
+
+    assert (1/x).subs(x, z) == 1/z
+    assert (1/x**2).subs(x, z) == 1/z**2
+    assert (1/x**2).subs(x, -2) == Rational(1, 4)
+    assert (-(1/x**2)).subs(x, -2) == Rational(-1, 4)
+
+    #issue 5360
+    assert (1/x).subs(x, 0) == 1/S.Zero
+
+
+def test_add():
+    a, b, c, d, x, y, t = symbols('a b c d x y t')
+
+    assert (a**2 - b - c).subs(a**2 - b, d) in [d - c, a**2 - b - c]
+    assert (a**2 - c).subs(a**2 - c, d) == d
+    assert (a**2 - b - c).subs(a**2 - c, d) in [d - b, a**2 - b - c]
+    assert (a**2 - x - c).subs(a**2 - c, d) in [d - x, a**2 - x - c]
+    assert (a**2 - b - sqrt(a)).subs(a**2 - sqrt(a), c) == c - b
+    assert (a + b + exp(a + b)).subs(a + b, c) == c + exp(c)
+    assert (c + b + exp(c + b)).subs(c + b, a) == a + exp(a)
+    assert (a + b + c + d).subs(b + c, x) == a + d + x
+    assert (a + b + c + d).subs(-b - c, x) == a + d - x
+    assert ((x + 1)*y).subs(x + 1, t) == t*y
+    assert ((-x - 1)*y).subs(x + 1, t) == -t*y
+    assert ((x - 1)*y).subs(x + 1, t) == y*(t - 2)
+    assert ((-x + 1)*y).subs(x + 1, t) == y*(-t + 2)
+
+    # this should work every time:
+    e = a**2 - b - c
+    assert e.subs(Add(*e.args[:2]), d) == d + e.args[2]
+    assert e.subs(a**2 - c, d) == d - b
+
+    # the fallback should recognize when a change has
+    # been made; while .1 == Rational(1, 10) they are not the same
+    # and the change should be made
+    assert (0.1 + a).subs(0.1, Rational(1, 10)) == Rational(1, 10) + a
+
+    e = (-x*(-y + 1) - y*(y - 1))
+    ans = (-x*(x) - y*(-x)).expand()
+    assert e.subs(-y + 1, x) == ans
+
+    #Test issue 18747
+    assert (exp(x) + cos(x)).subs(x, oo) == oo
+    assert Add(*[AccumBounds(-1, 1), oo]) == oo
+    assert Add(*[oo, AccumBounds(-1, 1)]) == oo
+
+
+def test_subs_issue_4009():
+    assert (I*Symbol('a')).subs(1, 2) == I*Symbol('a')
+
+
+def test_functions_subs():
+    f, g = symbols('f g', cls=Function)
+    l = Lambda((x, y), sin(x) + y)
+    assert (g(y, x) + cos(x)).subs(g, l) == sin(y) + x + cos(x)
+    assert (f(x)**2).subs(f, sin) == sin(x)**2
+    assert (f(x, y)).subs(f, log) == log(x, y)
+    assert (f(x, y)).subs(f, sin) == f(x, y)
+    assert (sin(x) + atan2(x, y)).subs([[atan2, f], [sin, g]]) == \
+        f(x, y) + g(x)
+    assert (g(f(x + y, x))).subs([[f, l], [g, exp]]) == exp(x + sin(x + y))
+
+
+def test_derivative_subs():
+    f = Function('f')
+    g = Function('g')
+    assert Derivative(f(x), x).subs(f(x), y) != 0
+    # need xreplace to put the function back, see #13803
+    assert Derivative(f(x), x).subs(f(x), y).xreplace({y: f(x)}) == \
+        Derivative(f(x), x)
+    # issues 5085, 5037
+    assert cse(Derivative(f(x), x) + f(x))[1][0].has(Derivative)
+    assert cse(Derivative(f(x, y), x) +
+               Derivative(f(x, y), y))[1][0].has(Derivative)
+    eq = Derivative(g(x), g(x))
+    assert eq.subs(g, f) == Derivative(f(x), f(x))
+    assert eq.subs(g(x), f(x)) == Derivative(f(x), f(x))
+    assert eq.subs(g, cos) == Subs(Derivative(y, y), y, cos(x))
+
+
+def test_derivative_subs2():
+    f_func, g_func = symbols('f g', cls=Function)
+    f, g = f_func(x, y, z), g_func(x, y, z)
+    assert Derivative(f, x, y).subs(Derivative(f, x, y), g) == g
+    assert Derivative(f, y, x).subs(Derivative(f, x, y), g) == g
+    assert Derivative(f, x, y).subs(Derivative(f, x), g) == Derivative(g, y)
+    assert Derivative(f, x, y).subs(Derivative(f, y), g) == Derivative(g, x)
+    assert (Derivative(f, x, y, z).subs(
+                Derivative(f, x, z), g) == Derivative(g, y))
+    assert (Derivative(f, x, y, z).subs(
+                Derivative(f, z, y), g) == Derivative(g, x))
+    assert (Derivative(f, x, y, z).subs(
+                Derivative(f, z, y, x), g) == g)
+
+    # Issue 9135
+    assert (Derivative(f, x, x, y).subs(
+                Derivative(f, y, y), g) == Derivative(f, x, x, y))
+    assert (Derivative(f, x, y, y, z).subs(
+                Derivative(f, x, y, y, y), g) == Derivative(f, x, y, y, z))
+
+    assert Derivative(f, x, y).subs(Derivative(f_func(x), x, y), g) == Derivative(f, x, y)
+
+
+def test_derivative_subs3():
+    dex = Derivative(exp(x), x)
+    assert Derivative(dex, x).subs(dex, exp(x)) == dex
+    assert dex.subs(exp(x), dex) == Derivative(exp(x), x, x)
+
+
+def test_issue_5284():
+    A, B = symbols('A B', commutative=False)
+    assert (x*A).subs(x**2*A, B) == x*A
+    assert (A**2).subs(A**3, B) == A**2
+    assert (A**6).subs(A**3, B) == B**2
+
+
+def test_subs_iter():
+    assert x.subs(reversed([[x, y]])) == y
+    it = iter([[x, y]])
+    assert x.subs(it) == y
+    assert x.subs(Tuple((x, y))) == y
+
+
+def test_subs_dict():
+    a, b, c, d, e = symbols('a b c d e')
+
+    assert (2*x + y + z).subs({"x": 1, "y": 2}) == 4 + z
+
+    l = [(sin(x), 2), (x, 1)]
+    assert (sin(x)).subs(l) == \
+           (sin(x)).subs(dict(l)) == 2
+    assert sin(x).subs(reversed(l)) == sin(1)
+
+    expr = sin(2*x) + sqrt(sin(2*x))*cos(2*x)*sin(exp(x)*x)
+    reps = {sin(2*x): c,
+               sqrt(sin(2*x)): a,
+               cos(2*x): b,
+               exp(x): e,
+               x: d,}
+    assert expr.subs(reps) == c + a*b*sin(d*e)
+
+    l = [(x, 3), (y, x**2)]
+    assert (x + y).subs(l) == 3 + x**2
+    assert (x + y).subs(reversed(l)) == 12
+
+    # If changes are made to convert lists into dictionaries and do
+    # a dictionary-lookup replacement, these tests will help to catch
+    # some logical errors that might occur
+    l = [(y, z + 2), (1 + z, 5), (z, 2)]
+    assert (y - 1 + 3*x).subs(l) == 5 + 3*x
+    l = [(y, z + 2), (z, 3)]
+    assert (y - 2).subs(l) == 3
+
+
+def test_no_arith_subs_on_floats():
+    assert (x + 3).subs(x + 3, a) == a
+    assert (x + 3).subs(x + 2, a) == a + 1
+
+    assert (x + y + 3).subs(x + 3, a) == a + y
+    assert (x + y + 3).subs(x + 2, a) == a + y + 1
+
+    assert (x + 3.0).subs(x + 3.0, a) == a
+    assert (x + 3.0).subs(x + 2.0, a) == x + 3.0
+
+    assert (x + y + 3.0).subs(x + 3.0, a) == a + y
+    assert (x + y + 3.0).subs(x + 2.0, a) == x + y + 3.0
+
+
+def test_issue_5651():
+    a, b, c, K = symbols('a b c K', commutative=True)
+    assert (a/(b*c)).subs(b*c, K) == a/K
+    assert (a/(b**2*c**3)).subs(b*c, K) == a/(c*K**2)
+    assert (1/(x*y)).subs(x*y, 2) == S.Half
+    assert ((1 + x*y)/(x*y)).subs(x*y, 1) == 2
+    assert (x*y*z).subs(x*y, 2) == 2*z
+    assert ((1 + x*y)/(x*y)/z).subs(x*y, 1) == 2/z
+
+
+def test_issue_6075():
+    assert Tuple(1, True).subs(1, 2) == Tuple(2, True)
+
+
+def test_issue_6079():
+    # since x + 2.0 == x + 2 we can't do a simple equality test
+    assert _aresame((x + 2.0).subs(2, 3), x + 2.0)
+    assert _aresame((x + 2.0).subs(2.0, 3), x + 3)
+    assert not _aresame(x + 2, x + 2.0)
+    assert not _aresame(Basic(cos(x), S(1)), Basic(cos(x), S(1.)))
+    assert _aresame(cos, cos)
+    assert not _aresame(1, S.One)
+    assert not _aresame(x, symbols('x', positive=True))
+
+
+def test_issue_4680():
+    N = Symbol('N')
+    assert N.subs({"N": 3}) == 3
+
+
+def test_issue_6158():
+    assert (x - 1).subs(1, y) == x - y
+    assert (x - 1).subs(-1, y) == x + y
+    assert (x - oo).subs(oo, y) == x - y
+    assert (x - oo).subs(-oo, y) == x + y
+
+
+def test_Function_subs():
+    f, g, h, i = symbols('f g h i', cls=Function)
+    p = Piecewise((g(f(x, y)), x < -1), (g(x), x <= 1))
+    assert p.subs(g, h) == Piecewise((h(f(x, y)), x < -1), (h(x), x <= 1))
+    assert (f(y) + g(x)).subs({f: h, g: i}) == i(x) + h(y)
+
+
+def test_simultaneous_subs():
+    reps = {x: 0, y: 0}
+    assert (x/y).subs(reps) != (y/x).subs(reps)
+    assert (x/y).subs(reps, simultaneous=True) == \
+        (y/x).subs(reps, simultaneous=True)
+    reps = reps.items()
+    assert (x/y).subs(reps) != (y/x).subs(reps)
+    assert (x/y).subs(reps, simultaneous=True) == \
+        (y/x).subs(reps, simultaneous=True)
+    assert Derivative(x, y, z).subs(reps, simultaneous=True) == \
+        Subs(Derivative(0, y, z), y, 0)
+
+
+def test_issue_6419_6421():
+    assert (1/(1 + x/y)).subs(x/y, x) == 1/(1 + x)
+    assert (-2*I).subs(2*I, x) == -x
+    assert (-I*x).subs(I*x, x) == -x
+    assert (-3*I*y**4).subs(3*I*y**2, x) == -x*y**2
+
+
+def test_issue_6559():
+    assert (-12*x + y).subs(-x, 1) == 12 + y
+    # though this involves cse it generated a failure in Mul._eval_subs
+    x0, x1 = symbols('x0 x1')
+    e = -log(-12*sqrt(2) + 17)/24 - log(-2*sqrt(2) + 3)/12 + sqrt(2)/3
+    # XXX modify cse so x1 is eliminated and x0 = -sqrt(2)?
+    assert cse(e) == (
+        [(x0, sqrt(2))], [x0/3 - log(-12*x0 + 17)/24 - log(-2*x0 + 3)/12])
+
+
+def test_issue_5261():
+    x = symbols('x', real=True)
+    e = I*x
+    assert exp(e).subs(exp(x), y) == y**I
+    assert (2**e).subs(2**x, y) == y**I
+    eq = (-2)**e
+    assert eq.subs((-2)**x, y) == eq
+
+
+def test_issue_6923():
+    assert (-2*x*sqrt(2)).subs(2*x, y) == -sqrt(2)*y
+
+
+def test_2arg_hack():
+    N = Symbol('N', commutative=False)
+    ans = Mul(2, y + 1, evaluate=False)
+    assert (2*x*(y + 1)).subs(x, 1, hack2=True) == ans
+    assert (2*(y + 1 + N)).subs(N, 0, hack2=True) == ans
+
+
+@XFAIL
+def test_mul2():
+    """When this fails, remove things labelled "2-arg hack"
+    1) remove special handling in the fallback of subs that
+    was added in the same commit as this test
+    2) remove the special handling in Mul.flatten
+    """
+    assert (2*(x + 1)).is_Mul
+
+
+def test_noncommutative_subs():
+    x,y = symbols('x,y', commutative=False)
+    assert (x*y*x).subs([(x, x*y), (y, x)], simultaneous=True) == (x*y*x**2*y)
+
+
+def test_issue_2877():
+    f = Float(2.0)
+    assert (x + f).subs({f: 2}) == x + 2
+
+    def r(a, b, c):
+        return factor(a*x**2 + b*x + c)
+    e = r(5.0/6, 10, 5)
+    assert nsimplify(e) == 5*x**2/6 + 10*x + 5
+
+
+def test_issue_5910():
+    t = Symbol('t')
+    assert (1/(1 - t)).subs(t, 1) is zoo
+    n = t
+    d = t - 1
+    assert (n/d).subs(t, 1) is zoo
+    assert (-n/-d).subs(t, 1) is zoo
+
+
+def test_issue_5217():
+    s = Symbol('s')
+    z = (1 - 2*x*x)
+    w = (1 + 2*x*x)
+    q = 2*x*x*2*y*y
+    sub = {2*x*x: s}
+    assert w.subs(sub) == 1 + s
+    assert z.subs(sub) == 1 - s
+    assert q == 4*x**2*y**2
+    assert q.subs(sub) == 2*y**2*s
+
+
+def test_issue_10829():
+    assert (4**x).subs(2**x, y) == y**2
+    assert (9**x).subs(3**x, y) == y**2
+
+
+def test_pow_eval_subs_no_cache():
+    # Tests pull request 9376 is working
+    from sympy.core.cache import clear_cache
+
+    s = 1/sqrt(x**2)
+    # This bug only appeared when the cache was turned off.
+    # We need to approximate running this test without the cache.
+    # This creates approximately the same situation.
+    clear_cache()
+
+    # This used to fail with a wrong result.
+    # It incorrectly returned 1/sqrt(x**2) before this pull request.
+    result = s.subs(sqrt(x**2), y)
+    assert result == 1/y
+
+
+def test_RootOf_issue_10092():
+    x = Symbol('x', real=True)
+    eq = x**3 - 17*x**2 + 81*x - 118
+    r = RootOf(eq, 0)
+    assert (x < r).subs(x, r) is S.false
+
+
+def test_issue_8886():
+    from sympy.physics.mechanics import ReferenceFrame as R
+    # if something can't be sympified we assume that it
+    # doesn't play well with SymPy and disallow the
+    # substitution
+    v = R('A').x
+    raises(SympifyError, lambda: x.subs(x, v))
+    raises(SympifyError, lambda: v.subs(v, x))
+    assert v.__eq__(x) is False
+
+
+def test_issue_12657():
+    # treat -oo like the atom that it is
+    reps = [(-oo, 1), (oo, 2)]
+    assert (x < -oo).subs(reps) == (x < 1)
+    assert (x < -oo).subs(list(reversed(reps))) == (x < 1)
+    reps = [(-oo, 2), (oo, 1)]
+    assert (x < oo).subs(reps) == (x < 1)
+    assert (x < oo).subs(list(reversed(reps))) == (x < 1)
+
+
+def test_recurse_Application_args():
+    F = Lambda((x, y), exp(2*x + 3*y))
+    f = Function('f')
+    A = f(x, f(x, x))
+    C = F(x, F(x, x))
+    assert A.subs(f, F) == A.replace(f, F) == C
+
+
+def test_Subs_subs():
+    assert Subs(x*y, x, x).subs(x, y) == Subs(x*y, x, y)
+    assert Subs(x*y, x, x + 1).subs(x, y) == \
+        Subs(x*y, x, y + 1)
+    assert Subs(x*y, y, x + 1).subs(x, y) == \
+        Subs(y**2, y, y + 1)
+    a = Subs(x*y*z, (y, x, z), (x + 1, x + z, x))
+    b = Subs(x*y*z, (y, x, z), (x + 1, y + z, y))
+    assert a.subs(x, y) == b and \
+        a.doit().subs(x, y) == a.subs(x, y).doit()
+    f = Function('f')
+    g = Function('g')
+    assert Subs(2*f(x, y) + g(x), f(x, y), 1).subs(y, 2) == Subs(
+        2*f(x, y) + g(x), (f(x, y), y), (1, 2))
+
+
+def test_issue_13333():
+    eq = 1/x
+    assert eq.subs({"x": '1/2'}) == 2
+    assert eq.subs({"x": '(1/2)'}) == 2
+
+
+def test_issue_15234():
+    x, y = symbols('x y', real=True)
+    p = 6*x**5 + x**4 - 4*x**3 + 4*x**2 - 2*x + 3
+    p_subbed = 6*x**5 - 4*x**3 - 2*x + y**4 + 4*y**2 + 3
+    assert p.subs([(x**i, y**i) for i in [2, 4]]) == p_subbed
+    x, y = symbols('x y', complex=True)
+    p = 6*x**5 + x**4 - 4*x**3 + 4*x**2 - 2*x + 3
+    p_subbed = 6*x**5 - 4*x**3 - 2*x + y**4 + 4*y**2 + 3
+    assert p.subs([(x**i, y**i) for i in [2, 4]]) == p_subbed
+
+
+def test_issue_6976():
+    x, y = symbols('x y')
+    assert (sqrt(x)**3 + sqrt(x) + x + x**2).subs(sqrt(x), y) == \
+        y**4 + y**3 + y**2 + y
+    assert (x**4 + x**3 + x**2 + x + sqrt(x)).subs(x**2, y) == \
+        sqrt(x) + x**3 + x + y**2 + y
+    assert x.subs(x**3, y) == x
+    assert x.subs(x**Rational(1, 3), y) == y**3
+
+    # More substitutions are possible with nonnegative symbols
+    x, y = symbols('x y', nonnegative=True)
+    assert (x**4 + x**3 + x**2 + x + sqrt(x)).subs(x**2, y) == \
+        y**Rational(1, 4) + y**Rational(3, 2) + sqrt(y) + y**2 + y
+    assert x.subs(x**3, y) == y**Rational(1, 3)
+
+
+def test_issue_11746():
+    assert (1/x).subs(x**2, 1) == 1/x
+    assert (1/(x**3)).subs(x**2, 1) == x**(-3)
+    assert (1/(x**4)).subs(x**2, 1) == 1
+    assert (1/(x**3)).subs(x**4, 1) == x**(-3)
+    assert (1/(y**5)).subs(x**5, 1) == y**(-5)
+
+
+def test_issue_17823():
+    from sympy.physics.mechanics import dynamicsymbols
+    q1, q2 = dynamicsymbols('q1, q2')
+    expr = q1.diff().diff()**2*q1 + q1.diff()*q2.diff()
+    reps={q1: a, q1.diff(): a*x*y, q1.diff().diff(): z}
+    assert expr.subs(reps) == a*x*y*Derivative(q2, t) + a*z**2
+
+
+def test_issue_19326():
+    x, y = [i(t) for i in map(Function, 'xy')]
+    assert (x*y).subs({x: 1 + x, y: x}) == (1 + x)*x
+
+
+def test_issue_19558():
+    e = (7*x*cos(x) - 12*log(x)**3)*(-log(x)**4 + 2*sin(x) + 1)**2/ \
+    (2*(x*cos(x) - 2*log(x)**3)*(3*log(x)**4 - 7*sin(x) + 3)**2)
+
+    assert e.subs(x, oo) == AccumBounds(-oo, oo)
+    assert (sin(x) + cos(x)).subs(x, oo) == AccumBounds(-2, 2)
+
+
+def test_issue_22033():
+    xr = Symbol('xr', real=True)
+    e = (1/xr)
+    assert e.subs(xr**2, y) == e
+
+
+def test_guard_against_indeterminate_evaluation():
+    eq = x**y
+    assert eq.subs([(x, 1), (y, oo)]) == 1  # because 1**y == 1
+    assert eq.subs([(y, oo), (x, 1)]) is S.NaN
+    assert eq.subs({x: 1, y: oo}) is S.NaN
+    assert eq.subs([(x, 1), (y, oo)], simultaneous=True) is S.NaN
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_symbol.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_symbol.py
new file mode 100644
index 0000000000000000000000000000000000000000..acf27700825c4822456207afe95108480505ce2c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_symbol.py
@@ -0,0 +1,421 @@
+import threading
+
+from sympy.core.function import Function, UndefinedFunction
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.relational import (GreaterThan, LessThan, StrictGreaterThan, StrictLessThan)
+from sympy.core.symbol import (Dummy, Symbol, Wild, symbols)
+from sympy.core.sympify import sympify  # can't import as S yet
+from sympy.core.symbol import uniquely_named_symbol, _symbol, Str
+
+from sympy.testing.pytest import raises, skip_under_pyodide
+from sympy.core.symbol import disambiguate
+
+
+def test_Str():
+    a1 = Str('a')
+    a2 = Str('a')
+    b = Str('b')
+    assert a1 == a2 != b
+    raises(TypeError, lambda: Str())
+
+
+def test_Symbol():
+    a = Symbol("a")
+    x1 = Symbol("x")
+    x2 = Symbol("x")
+    xdummy1 = Dummy("x")
+    xdummy2 = Dummy("x")
+
+    assert a != x1
+    assert a != x2
+    assert x1 == x2
+    assert x1 != xdummy1
+    assert xdummy1 != xdummy2
+
+    assert Symbol("x") == Symbol("x")
+    assert Dummy("x") != Dummy("x")
+    d = symbols('d', cls=Dummy)
+    assert isinstance(d, Dummy)
+    c, d = symbols('c,d', cls=Dummy)
+    assert isinstance(c, Dummy)
+    assert isinstance(d, Dummy)
+    raises(TypeError, lambda: Symbol())
+
+
+def test_Dummy():
+    assert Dummy() != Dummy()
+
+
+def test_Dummy_force_dummy_index():
+    raises(AssertionError, lambda: Dummy(dummy_index=1))
+    assert Dummy('d', dummy_index=2) == Dummy('d', dummy_index=2)
+    assert Dummy('d1', dummy_index=2) != Dummy('d2', dummy_index=2)
+    d1 = Dummy('d', dummy_index=3)
+    d2 = Dummy('d')
+    # might fail if d1 were created with dummy_index >= 10**6
+    assert d1 != d2
+    d3 = Dummy('d', dummy_index=3)
+    assert d1 == d3
+    assert Dummy()._count == Dummy('d', dummy_index=3)._count
+
+
+def test_lt_gt():
+    S = sympify
+    x, y = Symbol('x'), Symbol('y')
+
+    assert (x >= y) == GreaterThan(x, y)
+    assert (x >= 0) == GreaterThan(x, 0)
+    assert (x <= y) == LessThan(x, y)
+    assert (x <= 0) == LessThan(x, 0)
+
+    assert (0 <= x) == GreaterThan(x, 0)
+    assert (0 >= x) == LessThan(x, 0)
+    assert (S(0) >= x) == GreaterThan(0, x)
+    assert (S(0) <= x) == LessThan(0, x)
+
+    assert (x > y) == StrictGreaterThan(x, y)
+    assert (x > 0) == StrictGreaterThan(x, 0)
+    assert (x < y) == StrictLessThan(x, y)
+    assert (x < 0) == StrictLessThan(x, 0)
+
+    assert (0 < x) == StrictGreaterThan(x, 0)
+    assert (0 > x) == StrictLessThan(x, 0)
+    assert (S(0) > x) == StrictGreaterThan(0, x)
+    assert (S(0) < x) == StrictLessThan(0, x)
+
+    e = x**2 + 4*x + 1
+    assert (e >= 0) == GreaterThan(e, 0)
+    assert (0 <= e) == GreaterThan(e, 0)
+    assert (e > 0) == StrictGreaterThan(e, 0)
+    assert (0 < e) == StrictGreaterThan(e, 0)
+
+    assert (e <= 0) == LessThan(e, 0)
+    assert (0 >= e) == LessThan(e, 0)
+    assert (e < 0) == StrictLessThan(e, 0)
+    assert (0 > e) == StrictLessThan(e, 0)
+
+    assert (S(0) >= e) == GreaterThan(0, e)
+    assert (S(0) <= e) == LessThan(0, e)
+    assert (S(0) < e) == StrictLessThan(0, e)
+    assert (S(0) > e) == StrictGreaterThan(0, e)
+
+
+def test_no_len():
+    # there should be no len for numbers
+    x = Symbol('x')
+    raises(TypeError, lambda: len(x))
+
+
+def test_ineq_unequal():
+    S = sympify
+    x, y, z = symbols('x,y,z')
+
+    e = (
+        S(-1) >= x, S(-1) >= y, S(-1) >= z,
+        S(-1) > x, S(-1) > y, S(-1) > z,
+        S(-1) <= x, S(-1) <= y, S(-1) <= z,
+        S(-1) < x, S(-1) < y, S(-1) < z,
+        S(0) >= x, S(0) >= y, S(0) >= z,
+        S(0) > x, S(0) > y, S(0) > z,
+        S(0) <= x, S(0) <= y, S(0) <= z,
+        S(0) < x, S(0) < y, S(0) < z,
+        S('3/7') >= x, S('3/7') >= y, S('3/7') >= z,
+        S('3/7') > x, S('3/7') > y, S('3/7') > z,
+        S('3/7') <= x, S('3/7') <= y, S('3/7') <= z,
+        S('3/7') < x, S('3/7') < y, S('3/7') < z,
+        S(1.5) >= x, S(1.5) >= y, S(1.5) >= z,
+        S(1.5) > x, S(1.5) > y, S(1.5) > z,
+        S(1.5) <= x, S(1.5) <= y, S(1.5) <= z,
+        S(1.5) < x, S(1.5) < y, S(1.5) < z,
+        S(2) >= x, S(2) >= y, S(2) >= z,
+        S(2) > x, S(2) > y, S(2) > z,
+        S(2) <= x, S(2) <= y, S(2) <= z,
+        S(2) < x, S(2) < y, S(2) < z,
+        x >= -1, y >= -1, z >= -1,
+        x > -1, y > -1, z > -1,
+        x <= -1, y <= -1, z <= -1,
+        x < -1, y < -1, z < -1,
+        x >= 0, y >= 0, z >= 0,
+        x > 0, y > 0, z > 0,
+        x <= 0, y <= 0, z <= 0,
+        x < 0, y < 0, z < 0,
+        x >= 1.5, y >= 1.5, z >= 1.5,
+        x > 1.5, y > 1.5, z > 1.5,
+        x <= 1.5, y <= 1.5, z <= 1.5,
+        x < 1.5, y < 1.5, z < 1.5,
+        x >= 2, y >= 2, z >= 2,
+        x > 2, y > 2, z > 2,
+        x <= 2, y <= 2, z <= 2,
+        x < 2, y < 2, z < 2,
+
+        x >= y, x >= z, y >= x, y >= z, z >= x, z >= y,
+        x > y, x > z, y > x, y > z, z > x, z > y,
+        x <= y, x <= z, y <= x, y <= z, z <= x, z <= y,
+        x < y, x < z, y < x, y < z, z < x, z < y,
+
+        x - pi >= y + z, y - pi >= x + z, z - pi >= x + y,
+        x - pi > y + z, y - pi > x + z, z - pi > x + y,
+        x - pi <= y + z, y - pi <= x + z, z - pi <= x + y,
+        x - pi < y + z, y - pi < x + z, z - pi < x + y,
+        True, False
+    )
+
+    left_e = e[:-1]
+    for i, e1 in enumerate( left_e ):
+        for e2 in e[i + 1:]:
+            assert e1 != e2
+
+
+def test_Wild_properties():
+    S = sympify
+    # these tests only include Atoms
+    x = Symbol("x")
+    y = Symbol("y")
+    p = Symbol("p", positive=True)
+    k = Symbol("k", integer=True)
+    n = Symbol("n", integer=True, positive=True)
+
+    given_patterns = [ x, y, p, k, -k, n, -n, S(-3), S(3),
+                       pi, Rational(3, 2), I ]
+
+    integerp = lambda k: k.is_integer
+    positivep = lambda k: k.is_positive
+    symbolp = lambda k: k.is_Symbol
+    realp = lambda k: k.is_extended_real
+
+    S = Wild("S", properties=[symbolp])
+    R = Wild("R", properties=[realp])
+    Y = Wild("Y", exclude=[x, p, k, n])
+    P = Wild("P", properties=[positivep])
+    K = Wild("K", properties=[integerp])
+    N = Wild("N", properties=[positivep, integerp])
+
+    given_wildcards = [ S, R, Y, P, K, N ]
+
+    goodmatch = {
+        S: (x, y, p, k, n),
+        R: (p, k, -k, n, -n, -3, 3, pi, Rational(3, 2)),
+        Y: (y, -3, 3, pi, Rational(3, 2), I ),
+        P: (p, n, 3, pi, Rational(3, 2)),
+        K: (k, -k, n, -n, -3, 3),
+        N: (n, 3)}
+
+    for A in given_wildcards:
+        for pat in given_patterns:
+            d = pat.match(A)
+            if pat in goodmatch[A]:
+                assert d[A] in goodmatch[A]
+            else:
+                assert d is None
+
+
+def test_symbols():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    assert symbols('x') == x
+    assert symbols('x ') == x
+    assert symbols(' x ') == x
+    assert symbols('x,') == (x,)
+    assert symbols('x, ') == (x,)
+    assert symbols('x ,') == (x,)
+
+    assert symbols('x , y') == (x, y)
+
+    assert symbols('x,y,z') == (x, y, z)
+    assert symbols('x y z') == (x, y, z)
+
+    assert symbols('x,y,z,') == (x, y, z)
+    assert symbols('x y z ') == (x, y, z)
+
+    xyz = Symbol('xyz')
+    abc = Symbol('abc')
+
+    assert symbols('xyz') == xyz
+    assert symbols('xyz,') == (xyz,)
+    assert symbols('xyz,abc') == (xyz, abc)
+
+    assert symbols(('xyz',)) == (xyz,)
+    assert symbols(('xyz,',)) == ((xyz,),)
+    assert symbols(('x,y,z,',)) == ((x, y, z),)
+    assert symbols(('xyz', 'abc')) == (xyz, abc)
+    assert symbols(('xyz,abc',)) == ((xyz, abc),)
+    assert symbols(('xyz,abc', 'x,y,z')) == ((xyz, abc), (x, y, z))
+
+    assert symbols(('x', 'y', 'z')) == (x, y, z)
+    assert symbols(['x', 'y', 'z']) == [x, y, z]
+    assert symbols({'x', 'y', 'z'}) == {x, y, z}
+
+    raises(ValueError, lambda: symbols(''))
+    raises(ValueError, lambda: symbols(','))
+    raises(ValueError, lambda: symbols('x,,y,,z'))
+    raises(ValueError, lambda: symbols(('x', '', 'y', '', 'z')))
+
+    a, b = symbols('x,y', real=True)
+    assert a.is_real and b.is_real
+
+    x0 = Symbol('x0')
+    x1 = Symbol('x1')
+    x2 = Symbol('x2')
+
+    y0 = Symbol('y0')
+    y1 = Symbol('y1')
+
+    assert symbols('x0:0') == ()
+    assert symbols('x0:1') == (x0,)
+    assert symbols('x0:2') == (x0, x1)
+    assert symbols('x0:3') == (x0, x1, x2)
+
+    assert symbols('x:0') == ()
+    assert symbols('x:1') == (x0,)
+    assert symbols('x:2') == (x0, x1)
+    assert symbols('x:3') == (x0, x1, x2)
+
+    assert symbols('x1:1') == ()
+    assert symbols('x1:2') == (x1,)
+    assert symbols('x1:3') == (x1, x2)
+
+    assert symbols('x1:3,x,y,z') == (x1, x2, x, y, z)
+
+    assert symbols('x:3,y:2') == (x0, x1, x2, y0, y1)
+    assert symbols(('x:3', 'y:2')) == ((x0, x1, x2), (y0, y1))
+
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+    d = Symbol('d')
+
+    assert symbols('x:z') == (x, y, z)
+    assert symbols('a:d,x:z') == (a, b, c, d, x, y, z)
+    assert symbols(('a:d', 'x:z')) == ((a, b, c, d), (x, y, z))
+
+    aa = Symbol('aa')
+    ab = Symbol('ab')
+    ac = Symbol('ac')
+    ad = Symbol('ad')
+
+    assert symbols('aa:d') == (aa, ab, ac, ad)
+    assert symbols('aa:d,x:z') == (aa, ab, ac, ad, x, y, z)
+    assert symbols(('aa:d','x:z')) == ((aa, ab, ac, ad), (x, y, z))
+
+    assert type(symbols(('q:2', 'u:2'), cls=Function)[0][0]) == UndefinedFunction  # issue 23532
+
+    # issue 6675
+    def sym(s):
+        return str(symbols(s))
+    assert sym('a0:4') == '(a0, a1, a2, a3)'
+    assert sym('a2:4,b1:3') == '(a2, a3, b1, b2)'
+    assert sym('a1(2:4)') == '(a12, a13)'
+    assert sym('a0:2.0:2') == '(a0.0, a0.1, a1.0, a1.1)'
+    assert sym('aa:cz') == '(aaz, abz, acz)'
+    assert sym('aa:c0:2') == '(aa0, aa1, ab0, ab1, ac0, ac1)'
+    assert sym('aa:ba:b') == '(aaa, aab, aba, abb)'
+    assert sym('a:3b') == '(a0b, a1b, a2b)'
+    assert sym('a-1:3b') == '(a-1b, a-2b)'
+    assert sym(r'a:2\,:2' + chr(0)) == '(a0,0%s, a0,1%s, a1,0%s, a1,1%s)' % (
+        (chr(0),)*4)
+    assert sym('x(:a:3)') == '(x(a0), x(a1), x(a2))'
+    assert sym('x(:c):1') == '(xa0, xb0, xc0)'
+    assert sym('x((:a)):3') == '(x(a)0, x(a)1, x(a)2)'
+    assert sym('x(:a:3') == '(x(a0, x(a1, x(a2)'
+    assert sym(':2') == '(0, 1)'
+    assert sym(':b') == '(a, b)'
+    assert sym(':b:2') == '(a0, a1, b0, b1)'
+    assert sym(':2:2') == '(00, 01, 10, 11)'
+    assert sym(':b:b') == '(aa, ab, ba, bb)'
+
+    raises(ValueError, lambda: symbols(':'))
+    raises(ValueError, lambda: symbols('a:'))
+    raises(ValueError, lambda: symbols('::'))
+    raises(ValueError, lambda: symbols('a::'))
+    raises(ValueError, lambda: symbols(':a:'))
+    raises(ValueError, lambda: symbols('::a'))
+
+
+def test_symbols_become_functions_issue_3539():
+    from sympy.abc import alpha, phi, beta, t
+    raises(TypeError, lambda: beta(2))
+    raises(TypeError, lambda: beta(2.5))
+    raises(TypeError, lambda: phi(2.5))
+    raises(TypeError, lambda: alpha(2.5))
+    raises(TypeError, lambda: phi(t))
+
+
+def test_unicode():
+    xu = Symbol('x')
+    x = Symbol('x')
+    assert x == xu
+
+    raises(TypeError, lambda: Symbol(1))
+
+
+def test_uniquely_named_symbol_and_Symbol():
+    F = uniquely_named_symbol
+    x = Symbol('x')
+    assert F(x) == x
+    assert F('x') == x
+    assert str(F('x', x)) == 'x0'
+    assert str(F('x', (x + 1, 1/x))) == 'x0'
+    _x = Symbol('x', real=True)
+    assert F(('x', _x)) == _x
+    assert F((x, _x)) == _x
+    assert F('x', real=True).is_real
+    y = Symbol('y')
+    assert F(('x', y), real=True).is_real
+    r = Symbol('x', real=True)
+    assert F(('x', r)).is_real
+    assert F(('x', r), real=False).is_real
+    assert F('x1', Symbol('x1'),
+        compare=lambda i: str(i).rstrip('1')).name == 'x0'
+    assert F('x1', Symbol('x1'),
+        modify=lambda i: i + '_').name == 'x1_'
+    assert _symbol(x, _x) == x
+
+
+def test_disambiguate():
+    x, y, y_1, _x, x_1, x_2 = symbols('x y y_1 _x x_1 x_2')
+    t1 = Dummy('y'), _x, Dummy('x'), Dummy('x')
+    t2 = Dummy('x'), Dummy('x')
+    t3 = Dummy('x'), Dummy('y')
+    t4 = x, Dummy('x')
+    t5 = Symbol('x', integer=True), x, Symbol('x_1')
+
+    assert disambiguate(*t1) == (y, x_2, x, x_1)
+    assert disambiguate(*t2) == (x, x_1)
+    assert disambiguate(*t3) == (x, y)
+    assert disambiguate(*t4) == (x_1, x)
+    assert disambiguate(*t5) == (t5[0], x_2, x_1)
+    assert disambiguate(*t5)[0] != x  # assumptions are retained
+
+    t6 = _x, Dummy('x')/y
+    t7 = y*Dummy('y'), y
+
+    assert disambiguate(*t6) == (x_1, x/y)
+    assert disambiguate(*t7) == (y*y_1, y_1)
+    assert disambiguate(Dummy('x_1'), Dummy('x_1')
+        ) == (x_1, Symbol('x_1_1'))
+
+
+@skip_under_pyodide("Cannot create threads under pyodide.")
+def test_issue_gh_16734():
+    # https://github.com/sympy/sympy/issues/16734
+
+    syms = list(symbols('x, y'))
+
+    def thread1():
+        for n in range(1000):
+            syms[0], syms[1] = symbols(f'x{n}, y{n}')
+            syms[0].is_positive # Check an assumption in this thread.
+        syms[0] = None
+
+    def thread2():
+        while syms[0] is not None:
+            # Compare the symbol in this thread.
+            result = (syms[0] == syms[1])  # noqa
+
+    # Previously this would be very likely to raise an exception:
+    thread = threading.Thread(target=thread1)
+    thread.start()
+    thread2()
+    thread.join()
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sympify.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sympify.py
new file mode 100644
index 0000000000000000000000000000000000000000..40be30c25d5826ceadde6d176c160a0090967659
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_sympify.py
@@ -0,0 +1,892 @@
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.function import (Function, Lambda)
+from sympy.core.mul import Mul
+from sympy.core.numbers import (Float, I, Integer, Rational, pi, oo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.logic.boolalg import (false, Or, true, Xor)
+from sympy.matrices.dense import Matrix
+from sympy.parsing.sympy_parser import null
+from sympy.polys.polytools import Poly
+from sympy.printing.repr import srepr
+from sympy.sets.fancysets import Range
+from sympy.sets.sets import Interval
+from sympy.abc import x, y
+from sympy.core.sympify import (sympify, _sympify, SympifyError, kernS,
+    CantSympify, converter)
+from sympy.core.decorators import _sympifyit
+from sympy.external import import_module
+from sympy.testing.pytest import raises, XFAIL, skip
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.geometry import Point, Line
+from sympy.functions.combinatorial.factorials import factorial, factorial2
+from sympy.abc import _clash, _clash1, _clash2
+from sympy.external.gmpy import gmpy as _gmpy, flint as _flint
+from sympy.sets import FiniteSet, EmptySet
+from sympy.tensor.array.dense_ndim_array import ImmutableDenseNDimArray
+
+import mpmath
+from collections import defaultdict, OrderedDict
+
+
+numpy = import_module('numpy')
+
+
+def test_issue_3538():
+    v = sympify("exp(x)")
+    assert v == exp(x)
+    assert type(v) == type(exp(x))
+    assert str(type(v)) == str(type(exp(x)))
+
+
+def test_sympify1():
+    assert sympify("x") == Symbol("x")
+    assert sympify("   x") == Symbol("x")
+    assert sympify("   x   ") == Symbol("x")
+    # issue 4877
+    assert sympify('--.5') == 0.5
+    assert sympify('-1/2') == -S.Half
+    assert sympify('-+--.5') == -0.5
+    assert sympify('-.[3]') == Rational(-1, 3)
+    assert sympify('.[3]') == Rational(1, 3)
+    assert sympify('+.[3]') == Rational(1, 3)
+    assert sympify('+0.[3]*10**-2') == Rational(1, 300)
+    assert sympify('.[052631578947368421]') == Rational(1, 19)
+    assert sympify('.0[526315789473684210]') == Rational(1, 19)
+    assert sympify('.034[56]') == Rational(1711, 49500)
+    # options to make reals into rationals
+    assert sympify('1.22[345]', rational=True) == \
+        1 + Rational(22, 100) + Rational(345, 99900)
+    assert sympify('2/2.6', rational=True) == Rational(10, 13)
+    assert sympify('2.6/2', rational=True) == Rational(13, 10)
+    assert sympify('2.6e2/17', rational=True) == Rational(260, 17)
+    assert sympify('2.6e+2/17', rational=True) == Rational(260, 17)
+    assert sympify('2.6e-2/17', rational=True) == Rational(26, 17000)
+    assert sympify('2.1+3/4', rational=True) == \
+        Rational(21, 10) + Rational(3, 4)
+    assert sympify('2.234456', rational=True) == Rational(279307, 125000)
+    assert sympify('2.234456e23', rational=True) == 223445600000000000000000
+    assert sympify('2.234456e-23', rational=True) == \
+        Rational(279307, 12500000000000000000000000000)
+    assert sympify('-2.234456e-23', rational=True) == \
+        Rational(-279307, 12500000000000000000000000000)
+    assert sympify('12345678901/17', rational=True) == \
+        Rational(12345678901, 17)
+    assert sympify('1/.3 + x', rational=True) == Rational(10, 3) + x
+    # make sure longs in fractions work
+    assert sympify('222222222222/11111111111') == \
+        Rational(222222222222, 11111111111)
+    # ... even if they come from repetend notation
+    assert sympify('1/.2[123456789012]') == Rational(333333333333, 70781892967)
+    # ... or from high precision reals
+    assert sympify('.1234567890123456', rational=True) == \
+        Rational(19290123283179, 156250000000000)
+
+
+def test_sympify_Fraction():
+    try:
+        import fractions
+    except ImportError:
+        pass
+    else:
+        value = sympify(fractions.Fraction(101, 127))
+        assert value == Rational(101, 127) and type(value) is Rational
+
+
+def test_sympify_gmpy():
+    if _gmpy is not None:
+        import gmpy2
+
+        value = sympify(gmpy2.mpz(1000001))
+        assert value == Integer(1000001) and type(value) is Integer
+
+        value = sympify(gmpy2.mpq(101, 127))
+        assert value == Rational(101, 127) and type(value) is Rational
+
+
+def test_sympify_flint():
+    if _flint is not None:
+        import flint
+
+        value = sympify(flint.fmpz(1000001))
+        assert value == Integer(1000001) and type(value) is Integer
+
+        value = sympify(flint.fmpq(101, 127))
+        assert value == Rational(101, 127) and type(value) is Rational
+
+
+@conserve_mpmath_dps
+def test_sympify_mpmath():
+    value = sympify(mpmath.mpf(1.0))
+    assert value == Float(1.0) and type(value) is Float
+
+    mpmath.mp.dps = 12
+    assert sympify(
+        mpmath.pi).epsilon_eq(Float("3.14159265359"), Float("1e-12")) == True
+    assert sympify(
+        mpmath.pi).epsilon_eq(Float("3.14159265359"), Float("1e-13")) == False
+
+    mpmath.mp.dps = 6
+    assert sympify(
+        mpmath.pi).epsilon_eq(Float("3.14159"), Float("1e-5")) == True
+    assert sympify(
+        mpmath.pi).epsilon_eq(Float("3.14159"), Float("1e-6")) == False
+
+    mpmath.mp.dps = 15
+    assert sympify(mpmath.mpc(1.0 + 2.0j)) == Float(1.0) + Float(2.0)*I
+
+
+def test_sympify2():
+    class A:
+        def _sympy_(self):
+            return Symbol("x")**3
+
+    a = A()
+
+    assert _sympify(a) == x**3
+    assert sympify(a) == x**3
+    assert a == x**3
+
+
+def test_sympify3():
+    assert sympify("x**3") == x**3
+    assert sympify("x^3") == x**3
+    assert sympify("1/2") == Integer(1)/2
+
+    raises(SympifyError, lambda: _sympify('x**3'))
+    raises(SympifyError, lambda: _sympify('1/2'))
+
+
+def test_sympify_keywords():
+    raises(SympifyError, lambda: sympify('if'))
+    raises(SympifyError, lambda: sympify('for'))
+    raises(SympifyError, lambda: sympify('while'))
+    raises(SympifyError, lambda: sympify('lambda'))
+
+
+def test_sympify_float():
+    assert sympify("1e-64") != 0
+    assert sympify("1e-20000") != 0
+
+
+def test_sympify_bool():
+    assert sympify(True) is true
+    assert sympify(False) is false
+
+
+def test_sympify_iterables():
+    ans = [Rational(3, 10), Rational(1, 5)]
+    assert sympify(['.3', '.2'], rational=True) == ans
+    assert sympify({"x": 0, "y": 1}) == {x: 0, y: 1}
+    assert sympify(['1', '2', ['3', '4']]) == [S(1), S(2), [S(3), S(4)]]
+
+
+@XFAIL
+def test_issue_16772():
+    # because there is a converter for tuple, the
+    # args are only sympified without the flags being passed
+    # along; list, on the other hand, is not converted
+    # with a converter so its args are traversed later
+    ans = [Rational(3, 10), Rational(1, 5)]
+    assert sympify(('.3', '.2'), rational=True) == Tuple(*ans)
+
+
+def test_issue_16859():
+    class no(float, CantSympify):
+        pass
+    raises(SympifyError, lambda: sympify(no(1.2)))
+
+
+def test_sympify4():
+    class A:
+        def _sympy_(self):
+            return Symbol("x")
+
+    a = A()
+
+    assert _sympify(a)**3 == x**3
+    assert sympify(a)**3 == x**3
+    assert a == x
+
+
+def test_sympify_text():
+    assert sympify('some') == Symbol('some')
+    assert sympify('core') == Symbol('core')
+
+    assert sympify('True') is True
+    assert sympify('False') is False
+
+    assert sympify('Poly') == Poly
+    assert sympify('sin') == sin
+
+
+def test_sympify_function():
+    assert sympify('factor(x**2-1, x)') == -(1 - x)*(x + 1)
+    assert sympify('sin(pi/2)*cos(pi)') == -Integer(1)
+
+
+def test_sympify_poly():
+    p = Poly(x**2 + x + 1, x)
+
+    assert _sympify(p) is p
+    assert sympify(p) is p
+
+
+def test_sympify_factorial():
+    assert sympify('x!') == factorial(x)
+    assert sympify('(x+1)!') == factorial(x + 1)
+    assert sympify('(1 + y*(x + 1))!') == factorial(1 + y*(x + 1))
+    assert sympify('(1 + y*(x + 1)!)^2') == (1 + y*factorial(x + 1))**2
+    assert sympify('y*x!') == y*factorial(x)
+    assert sympify('x!!') == factorial2(x)
+    assert sympify('(x+1)!!') == factorial2(x + 1)
+    assert sympify('(1 + y*(x + 1))!!') == factorial2(1 + y*(x + 1))
+    assert sympify('(1 + y*(x + 1)!!)^2') == (1 + y*factorial2(x + 1))**2
+    assert sympify('y*x!!') == y*factorial2(x)
+    assert sympify('factorial2(x)!') == factorial(factorial2(x))
+
+    raises(SympifyError, lambda: sympify("+!!"))
+    raises(SympifyError, lambda: sympify(")!!"))
+    raises(SympifyError, lambda: sympify("!"))
+    raises(SympifyError, lambda: sympify("(!)"))
+    raises(SympifyError, lambda: sympify("x!!!"))
+
+
+def test_issue_3595():
+    assert sympify("a_") == Symbol("a_")
+    assert sympify("_a") == Symbol("_a")
+
+
+def test_lambda():
+    x = Symbol('x')
+    assert sympify('lambda: 1') == Lambda((), 1)
+    assert sympify('lambda x: x') == Lambda(x, x)
+    assert sympify('lambda x: 2*x') == Lambda(x, 2*x)
+    assert sympify('lambda x, y: 2*x+y') == Lambda((x, y), 2*x + y)
+
+
+def test_lambda_raises():
+    raises(SympifyError, lambda: sympify("lambda *args: args")) # args argument error
+    raises(SympifyError, lambda: sympify("lambda **kwargs: kwargs[0]")) # kwargs argument error
+    raises(SympifyError, lambda: sympify("lambda x = 1: x"))    # Keyword argument error
+    with raises(SympifyError):
+        _sympify('lambda: 1')
+
+
+def test_sympify_raises():
+    raises(SympifyError, lambda: sympify("fx)"))
+
+    class A:
+        def __str__(self):
+            return 'x'
+
+    raises(SympifyError, lambda: sympify(A()))
+
+
+def test__sympify():
+    x = Symbol('x')
+    f = Function('f')
+
+    # positive _sympify
+    assert _sympify(x) is x
+    assert _sympify(1) == Integer(1)
+    assert _sympify(0.5) == Float("0.5")
+    assert _sympify(1 + 1j) == 1.0 + I*1.0
+
+    # Function f is not Basic and can't sympify to Basic. We allow it to pass
+    # with sympify but not with _sympify.
+    # https://github.com/sympy/sympy/issues/20124
+    assert sympify(f) is f
+    raises(SympifyError, lambda: _sympify(f))
+
+    class A:
+        def _sympy_(self):
+            return Integer(5)
+
+    a = A()
+    assert _sympify(a) == Integer(5)
+
+    # negative _sympify
+    raises(SympifyError, lambda: _sympify('1'))
+    raises(SympifyError, lambda: _sympify([1, 2, 3]))
+
+
+def test_sympifyit():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    @_sympifyit('b', NotImplemented)
+    def add(a, b):
+        return a + b
+
+    assert add(x, 1) == x + 1
+    assert add(x, 0.5) == x + Float('0.5')
+    assert add(x, y) == x + y
+
+    assert add(x, '1') == NotImplemented
+
+    @_sympifyit('b')
+    def add_raises(a, b):
+        return a + b
+
+    assert add_raises(x, 1) == x + 1
+    assert add_raises(x, 0.5) == x + Float('0.5')
+    assert add_raises(x, y) == x + y
+
+    raises(SympifyError, lambda: add_raises(x, '1'))
+
+
+def test_int_float():
+    class F1_1:
+        def __float__(self):
+            return 1.1
+
+    class F1_1b:
+        """
+        This class is still a float, even though it also implements __int__().
+        """
+        def __float__(self):
+            return 1.1
+
+        def __int__(self):
+            return 1
+
+    class F1_1c:
+        """
+        This class is still a float, because it implements _sympy_()
+        """
+        def __float__(self):
+            return 1.1
+
+        def __int__(self):
+            return 1
+
+        def _sympy_(self):
+            return Float(1.1)
+
+    class I5:
+        def __int__(self):
+            return 5
+
+    class I5b:
+        """
+        This class implements both __int__() and __float__(), so it will be
+        treated as Float in SymPy. One could change this behavior, by using
+        float(a) == int(a), but deciding that integer-valued floats represent
+        exact numbers is arbitrary and often not correct, so we do not do it.
+        If, in the future, we decide to do it anyway, the tests for I5b need to
+        be changed.
+        """
+        def __float__(self):
+            return 5.0
+
+        def __int__(self):
+            return 5
+
+    class I5c:
+        """
+        This class implements both __int__() and __float__(), but also
+        a _sympy_() method, so it will be Integer.
+        """
+        def __float__(self):
+            return 5.0
+
+        def __int__(self):
+            return 5
+
+        def _sympy_(self):
+            return Integer(5)
+
+    i5 = I5()
+    i5b = I5b()
+    i5c = I5c()
+    f1_1 = F1_1()
+    f1_1b = F1_1b()
+    f1_1c = F1_1c()
+    assert sympify(i5) == 5
+    assert isinstance(sympify(i5), Integer)
+    assert sympify(i5b) == 5.0
+    assert isinstance(sympify(i5b), Float)
+    assert sympify(i5c) == 5
+    assert isinstance(sympify(i5c), Integer)
+    assert abs(sympify(f1_1) - 1.1) < 1e-5
+    assert abs(sympify(f1_1b) - 1.1) < 1e-5
+    assert abs(sympify(f1_1c) - 1.1) < 1e-5
+
+    assert _sympify(i5) == 5
+    assert isinstance(_sympify(i5), Integer)
+    assert _sympify(i5b) == 5.0
+    assert isinstance(_sympify(i5b), Float)
+    assert _sympify(i5c) == 5
+    assert isinstance(_sympify(i5c), Integer)
+    assert abs(_sympify(f1_1) - 1.1) < 1e-5
+    assert abs(_sympify(f1_1b) - 1.1) < 1e-5
+    assert abs(_sympify(f1_1c) - 1.1) < 1e-5
+
+
+def test_evaluate_false():
+    cases = {
+        '2 + 3': Add(2, 3, evaluate=False),
+        '2**2 / 3': Mul(Pow(2, 2, evaluate=False), Pow(3, -1, evaluate=False), evaluate=False),
+        '2 + 3 * 5': Add(2, Mul(3, 5, evaluate=False), evaluate=False),
+        '2 - 3 * 5': Add(2, Mul(-1, Mul(3, 5,evaluate=False), evaluate=False), evaluate=False),
+        '1 / 3': Mul(1, Pow(3, -1, evaluate=False), evaluate=False),
+        'True | False': Or(True, False, evaluate=False),
+        '1 + 2 + 3 + 5*3 + integrate(x)': Add(1, 2, 3, Mul(5, 3, evaluate=False), x**2/2, evaluate=False),
+        '2 * 4 * 6 + 8': Add(Mul(2, 4, 6, evaluate=False), 8, evaluate=False),
+        '2 - 8 / 4': Add(2, Mul(-1, Mul(8, Pow(4, -1, evaluate=False), evaluate=False), evaluate=False), evaluate=False),
+        '2 - 2**2': Add(2, Mul(-1, Pow(2, 2, evaluate=False), evaluate=False), evaluate=False),
+    }
+    for case, result in cases.items():
+        assert sympify(case, evaluate=False) == result
+
+
+def test_issue_4133():
+    a = sympify('Integer(4)')
+
+    assert a == Integer(4)
+    assert a.is_Integer
+
+
+def test_issue_3982():
+    a = [3, 2.0]
+    assert sympify(a) == [Integer(3), Float(2.0)]
+    assert sympify(tuple(a)) == Tuple(Integer(3), Float(2.0))
+    assert sympify(set(a)) == FiniteSet(Integer(3), Float(2.0))
+
+
+def test_S_sympify():
+    assert S(1)/2 == sympify(1)/2 == S.Half
+    assert (-2)**(S(1)/2) == sqrt(2)*I
+
+
+def test_issue_4788():
+    assert srepr(S(1.0 + 0J)) == srepr(S(1.0)) == srepr(Float(1.0))
+
+
+def test_issue_4798_None():
+    assert S(None) is None
+
+
+def test_issue_3218():
+    assert sympify("x+\ny") == x + y
+
+def test_issue_19399():
+    if not numpy:
+        skip("numpy not installed.")
+
+    a = numpy.array(Rational(1, 2))
+    b = Rational(1, 3)
+    assert (a * b, type(a * b)) == (b * a, type(b * a))
+
+
+def test_issue_4988_builtins():
+    C = Symbol('C')
+    vars = {'C': C}
+    exp1 = sympify('C')
+    assert exp1 == C  # Make sure it did not get mixed up with sympy.C
+
+    exp2 = sympify('C', vars)
+    assert exp2 == C  # Make sure it did not get mixed up with sympy.C
+
+
+def test_geometry():
+    p = sympify(Point(0, 1))
+    assert p == Point(0, 1) and isinstance(p, Point)
+    L = sympify(Line(p, (1, 0)))
+    assert L == Line((0, 1), (1, 0)) and isinstance(L, Line)
+
+
+def test_kernS():
+    s =   '-1 - 2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x)))'
+    # when 1497 is fixed, this no longer should pass: the expression
+    # should be unchanged
+    assert -1 - 2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x))) == -1
+    # sympification should not allow the constant to enter a Mul
+    # or else the structure can change dramatically
+    ss = kernS(s)
+    assert ss != -1 and ss.simplify() == -1
+    s = '-1 - 2*(-(-x + 1/x)/(x*(x - 1/x)**2) - 1/(x*(x - 1/x)))'.replace(
+        'x', '_kern')
+    ss = kernS(s)
+    assert ss != -1 and ss.simplify() == -1
+    # issue 6687
+    assert (kernS('Interval(-1,-2 - 4*(-3))')
+        == Interval(-1, Add(-2, Mul(12, 1, evaluate=False), evaluate=False)))
+    assert kernS('_kern') == Symbol('_kern')
+    assert kernS('E**-(x)') == exp(-x)
+    e = 2*(x + y)*y
+    assert kernS(['2*(x + y)*y', ('2*(x + y)*y',)]) == [e, (e,)]
+    assert kernS('-(2*sin(x)**2 + 2*sin(x)*cos(x))*y/2') == \
+        -y*(2*sin(x)**2 + 2*sin(x)*cos(x))/2
+    # issue 15132
+    assert kernS('(1 - x)/(1 - x*(1-y))') == kernS('(1-x)/(1-(1-y)*x)')
+    assert kernS('(1-2**-(4+1)*(1-y)*x)') == (1 - x*(1 - y)/32)
+    assert kernS('(1-2**(4+1)*(1-y)*x)') == (1 - 32*x*(1 - y))
+    assert kernS('(1-2.*(1-y)*x)') == 1 - 2.*x*(1 - y)
+    one = kernS('x - (x - 1)')
+    assert one != 1 and one.expand() == 1
+    assert kernS("(2*x)/(x-1)") == 2*x/(x-1)
+
+
+def test_issue_6540_6552():
+    assert S('[[1/3,2], (2/5,)]') == [[Rational(1, 3), 2], (Rational(2, 5),)]
+    assert S('[[2/6,2], (2/4,)]') == [[Rational(1, 3), 2], (S.Half,)]
+    assert S('[[[2*(1)]]]') == [[[2]]]
+    assert S('Matrix([2*(1)])') == Matrix([2])
+
+
+def test_issue_6046():
+    assert str(S("Q & C", locals=_clash1)) == 'C & Q'
+    assert str(S('pi(x)', locals=_clash2)) == 'pi(x)'
+    locals = {}
+    exec("from sympy.abc import Q, C", locals)
+    assert str(S('C&Q', locals)) == 'C & Q'
+    # clash can act as Symbol or Function
+    assert str(S('pi(C, Q)', locals=_clash)) == 'pi(C, Q)'
+    assert len(S('pi + x', locals=_clash2).free_symbols) == 2
+    # but not both
+    raises(TypeError, lambda: S('pi + pi(x)', locals=_clash2))
+    assert all(set(i.values()) == {null} for i in (
+        _clash, _clash1, _clash2))
+
+
+def test_issue_8821_highprec_from_str():
+    s = str(pi.evalf(128))
+    p = sympify(s)
+    assert Abs(sin(p)) < 1e-127
+
+
+def test_issue_10295():
+    if not numpy:
+        skip("numpy not installed.")
+
+    A = numpy.array([[1, 3, -1],
+                     [0, 1, 7]])
+    sA = S(A)
+    assert sA.shape == (2, 3)
+    for (ri, ci), val in numpy.ndenumerate(A):
+        assert sA[ri, ci] == val
+
+    B = numpy.array([-7, x, 3*y**2])
+    sB = S(B)
+    assert sB.shape == (3,)
+    assert B[0] == sB[0] == -7
+    assert B[1] == sB[1] == x
+    assert B[2] == sB[2] == 3*y**2
+
+    C = numpy.arange(0, 24)
+    C.resize(2,3,4)
+    sC = S(C)
+    assert sC[0, 0, 0].is_integer
+    assert sC[0, 0, 0] == 0
+
+    a1 = numpy.array([1, 2, 3])
+    a2 = numpy.array(list(range(24)))
+    a2.resize(2, 4, 3)
+    assert sympify(a1) == ImmutableDenseNDimArray([1, 2, 3])
+    assert sympify(a2) == ImmutableDenseNDimArray(list(range(24)), (2, 4, 3))
+
+
+def test_Range():
+    # Only works in Python 3 where range returns a range type
+    assert sympify(range(10)) == Range(10)
+    assert _sympify(range(10)) == Range(10)
+
+
+def test_sympify_set():
+    n = Symbol('n')
+    assert sympify({n}) == FiniteSet(n)
+    assert sympify(set()) == EmptySet
+
+
+def test_sympify_numpy():
+    if not numpy:
+        skip('numpy not installed. Abort numpy tests.')
+    np = numpy
+
+    def equal(x, y):
+        return x == y and type(x) == type(y)
+
+    assert sympify(np.bool_(1)) is S(True)
+    try:
+        assert equal(
+            sympify(np.int_(1234567891234567891)), S(1234567891234567891))
+        assert equal(
+            sympify(np.intp(1234567891234567891)), S(1234567891234567891))
+    except OverflowError:
+        # May fail on 32-bit systems: Python int too large to convert to C long
+        pass
+    assert equal(sympify(np.intc(1234567891)), S(1234567891))
+    assert equal(sympify(np.int8(-123)), S(-123))
+    assert equal(sympify(np.int16(-12345)), S(-12345))
+    assert equal(sympify(np.int32(-1234567891)), S(-1234567891))
+    assert equal(
+        sympify(np.int64(-1234567891234567891)), S(-1234567891234567891))
+    assert equal(sympify(np.uint8(123)), S(123))
+    assert equal(sympify(np.uint16(12345)), S(12345))
+    assert equal(sympify(np.uint32(1234567891)), S(1234567891))
+    assert equal(
+        sympify(np.uint64(1234567891234567891)), S(1234567891234567891))
+    assert equal(sympify(np.float32(1.123456)), Float(1.123456, precision=24))
+    assert equal(sympify(np.float64(1.1234567891234)),
+                Float(1.1234567891234, precision=53))
+
+    # The exact precision of np.longdouble, npfloat128 and other extended
+    # precision dtypes is platform dependent.
+    ldprec = np.finfo(np.longdouble(1)).nmant + 1
+    assert equal(sympify(np.longdouble(1.123456789)),
+                 Float(1.123456789, precision=ldprec))
+
+    assert equal(sympify(np.complex64(1 + 2j)), S(1.0 + 2.0*I))
+    assert equal(sympify(np.complex128(1 + 2j)), S(1.0 + 2.0*I))
+
+    lcprec = np.finfo(np.clongdouble(1)).nmant + 1
+    assert equal(sympify(np.clongdouble(1 + 2j)),
+                Float(1.0, precision=lcprec) + Float(2.0, precision=lcprec)*I)
+
+    #float96 does not exist on all platforms
+    if hasattr(np, 'float96'):
+        f96prec = np.finfo(np.float96(1)).nmant + 1
+        assert equal(sympify(np.float96(1.123456789)),
+                    Float(1.123456789, precision=f96prec))
+
+    #float128 does not exist on all platforms
+    if hasattr(np, 'float128'):
+        f128prec = np.finfo(np.float128(1)).nmant + 1
+        assert equal(sympify(np.float128(1.123456789123)),
+                    Float(1.123456789123, precision=f128prec))
+
+
+@XFAIL
+def test_sympify_rational_numbers_set():
+    ans = [Rational(3, 10), Rational(1, 5)]
+    assert sympify({'.3', '.2'}, rational=True) == FiniteSet(*ans)
+
+
+def test_sympify_mro():
+    """Tests the resolution order for classes that implement _sympy_"""
+    class a:
+        def _sympy_(self):
+            return Integer(1)
+    class b(a):
+        def _sympy_(self):
+            return Integer(2)
+    class c(a):
+        pass
+
+    assert sympify(a()) == Integer(1)
+    assert sympify(b()) == Integer(2)
+    assert sympify(c()) == Integer(1)
+
+
+def test_sympify_converter():
+    """Tests the resolution order for classes in converter"""
+    class a:
+        pass
+    class b(a):
+        pass
+    class c(a):
+        pass
+
+    converter[a] = lambda x: Integer(1)
+    converter[b] = lambda x: Integer(2)
+
+    assert sympify(a()) == Integer(1)
+    assert sympify(b()) == Integer(2)
+    assert sympify(c()) == Integer(1)
+
+    class MyInteger(Integer):
+        pass
+
+    if int in converter:
+        int_converter = converter[int]
+    else:
+        int_converter = None
+
+    try:
+        converter[int] = MyInteger
+        assert sympify(1) == MyInteger(1)
+    finally:
+        if int_converter is None:
+            del converter[int]
+        else:
+            converter[int] = int_converter
+
+
+def test_issue_13924():
+    if not numpy:
+        skip("numpy not installed.")
+
+    a = sympify(numpy.array([1]))
+    assert isinstance(a, ImmutableDenseNDimArray)
+    assert a[0] == 1
+
+
+def test_numpy_sympify_args():
+    # Issue 15098. Make sure sympify args work with numpy types (like numpy.str_)
+    if not numpy:
+        skip("numpy not installed.")
+
+    a = sympify(numpy.str_('a'))
+    assert type(a) is Symbol
+    assert a == Symbol('a')
+
+    class CustomSymbol(Symbol):
+        pass
+
+    a = sympify(numpy.str_('a'), {"Symbol": CustomSymbol})
+    assert isinstance(a, CustomSymbol)
+
+    a = sympify(numpy.str_('x^y'))
+    assert a == x**y
+    a = sympify(numpy.str_('x^y'), convert_xor=False)
+    assert a == Xor(x, y)
+
+    raises(SympifyError, lambda: sympify(numpy.str_('x'), strict=True))
+
+    a = sympify(numpy.str_('1.1'))
+    assert isinstance(a, Float)
+    assert a == 1.1
+
+    a = sympify(numpy.str_('1.1'), rational=True)
+    assert isinstance(a, Rational)
+    assert a == Rational(11, 10)
+
+    a = sympify(numpy.str_('x + x'))
+    assert isinstance(a, Mul)
+    assert a == 2*x
+
+    a = sympify(numpy.str_('x + x'), evaluate=False)
+    assert isinstance(a, Add)
+    assert a == Add(x, x, evaluate=False)
+
+
+def test_issue_5939():
+    a = Symbol('a')
+    b = Symbol('b')
+    assert sympify('''a+\nb''') == a + b
+
+
+def test_issue_16759():
+    d = sympify({.5: 1})
+    assert S.Half not in d
+    assert Float(.5) in d
+    assert d[.5] is S.One
+    d = sympify(OrderedDict({.5: 1}))
+    assert S.Half not in d
+    assert Float(.5) in d
+    assert d[.5] is S.One
+    d = sympify(defaultdict(int, {.5: 1}))
+    assert S.Half not in d
+    assert Float(.5) in d
+    assert d[.5] is S.One
+
+
+def test_issue_17811():
+    a = Function('a')
+    assert sympify('a(x)*5', evaluate=False) == Mul(a(x), 5, evaluate=False)
+
+
+def test_issue_8439():
+    assert sympify(float('inf')) == oo
+    assert x + float('inf') == x + oo
+    assert S(float('inf')) == oo
+
+
+def test_issue_14706():
+    if not numpy:
+        skip("numpy not installed.")
+
+    z1 = numpy.zeros((1, 1), dtype=numpy.float64)
+    z2 = numpy.zeros((2, 2), dtype=numpy.float64)
+    z3 = numpy.zeros((), dtype=numpy.float64)
+
+    y1 = numpy.ones((1, 1), dtype=numpy.float64)
+    y2 = numpy.ones((2, 2), dtype=numpy.float64)
+    y3 = numpy.ones((), dtype=numpy.float64)
+
+    assert numpy.all(x + z1 == numpy.full((1, 1), x))
+    assert numpy.all(x + z2 == numpy.full((2, 2), x))
+    assert numpy.all(z1 + x == numpy.full((1, 1), x))
+    assert numpy.all(z2 + x == numpy.full((2, 2), x))
+    for z in [z3,
+              numpy.int64(0),
+              numpy.float64(0),
+              numpy.complex64(0)]:
+        assert x + z == x
+        assert z + x == x
+        assert isinstance(x + z, Symbol)
+        assert isinstance(z + x, Symbol)
+
+    # If these tests fail, then it means that numpy has finally
+    # fixed the issue of scalar conversion for rank>0 arrays
+    # which is mentioned in numpy/numpy#10404. In that case,
+    # some changes have to be made in sympify.py.
+    # Note: For future reference, for anyone who takes up this
+    # issue when numpy has finally fixed their side of the problem,
+    # the changes for this temporary fix were introduced in PR 18651
+    assert numpy.all(x + y1 == numpy.full((1, 1), x + 1.0))
+    assert numpy.all(x + y2 == numpy.full((2, 2), x + 1.0))
+    assert numpy.all(y1 + x == numpy.full((1, 1), x + 1.0))
+    assert numpy.all(y2 + x == numpy.full((2, 2), x + 1.0))
+    for y_ in [y3,
+              numpy.int64(1),
+              numpy.float64(1),
+              numpy.complex64(1)]:
+        assert x + y_ == y_ + x
+        assert isinstance(x + y_, Add)
+        assert isinstance(y_ + x, Add)
+
+    assert x + numpy.array(x) == 2 * x
+    assert x + numpy.array([x]) == numpy.array([2*x], dtype=object)
+
+    assert sympify(numpy.array([1])) == ImmutableDenseNDimArray([1], 1)
+    assert sympify(numpy.array([[[1]]])) == ImmutableDenseNDimArray([1], (1, 1, 1))
+    assert sympify(z1) == ImmutableDenseNDimArray([0.0], (1, 1))
+    assert sympify(z2) == ImmutableDenseNDimArray([0.0, 0.0, 0.0, 0.0], (2, 2))
+    assert sympify(z3) == ImmutableDenseNDimArray([0.0], ())
+    assert sympify(z3, strict=True) == 0.0
+
+    raises(SympifyError, lambda: sympify(numpy.array([1]), strict=True))
+    raises(SympifyError, lambda: sympify(z1, strict=True))
+    raises(SympifyError, lambda: sympify(z2, strict=True))
+
+
+def test_issue_21536():
+    #test to check evaluate=False in case of iterable input
+    u = sympify("x+3*x+2", evaluate=False)
+    v = sympify("2*x+4*x+2+4", evaluate=False)
+
+    assert u.is_Add and set(u.args) == {x, 3*x, 2}
+    assert v.is_Add and set(v.args) == {2*x, 4*x, 2, 4}
+    assert sympify(["x+3*x+2", "2*x+4*x+2+4"], evaluate=False) == [u, v]
+
+    #test to check evaluate=True in case of iterable input
+    u = sympify("x+3*x+2", evaluate=True)
+    v = sympify("2*x+4*x+2+4", evaluate=True)
+
+    assert u.is_Add and set(u.args) == {4*x, 2}
+    assert v.is_Add and set(v.args) == {6*x, 6}
+    assert sympify(["x+3*x+2", "2*x+4*x+2+4"], evaluate=True) == [u, v]
+
+    #test to check evaluate with no input in case of iterable input
+    u = sympify("x+3*x+2")
+    v = sympify("2*x+4*x+2+4")
+
+    assert u.is_Add and set(u.args) == {4*x, 2}
+    assert v.is_Add and set(v.args) == {6*x, 6}
+    assert sympify(["x+3*x+2", "2*x+4*x+2+4"]) == [u, v]
+
+def test_issue_27284():
+    if not numpy:
+        skip("numpy not installed.")
+
+    assert Float(numpy.float32(float('inf'))) == S.Infinity
+    assert Float(numpy.float32(float('-inf'))) == S.NegativeInfinity
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_traversal.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..8bf067283eaba5d4a073a73feb07aac199055a7f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_traversal.py
@@ -0,0 +1,119 @@
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import symbols
+from sympy.core.singleton import S
+from sympy.core.function import expand, Function
+from sympy.core.numbers import I
+from sympy.integrals.integrals import Integral
+from sympy.polys.polytools import factor
+from sympy.core.traversal import preorder_traversal, use, postorder_traversal, iterargs, iterfreeargs
+from sympy.functions.elementary.piecewise import ExprCondPair, Piecewise
+from sympy.testing.pytest import warns_deprecated_sympy
+from sympy.utilities.iterables import capture
+
+b1 = Basic()
+b2 = Basic(b1)
+b3 = Basic(b2)
+b21 = Basic(b2, b1)
+
+
+def test_preorder_traversal():
+    expr = Basic(b21, b3)
+    assert list(
+        preorder_traversal(expr)) == [expr, b21, b2, b1, b1, b3, b2, b1]
+    assert list(preorder_traversal(('abc', ('d', 'ef')))) == [
+        ('abc', ('d', 'ef')), 'abc', ('d', 'ef'), 'd', 'ef']
+
+    result = []
+    pt = preorder_traversal(expr)
+    for i in pt:
+        result.append(i)
+        if i == b2:
+            pt.skip()
+    assert result == [expr, b21, b2, b1, b3, b2]
+
+    w, x, y, z = symbols('w:z')
+    expr = z + w*(x + y)
+    assert list(preorder_traversal([expr], keys=default_sort_key)) == \
+        [[w*(x + y) + z], w*(x + y) + z, z, w*(x + y), w, x + y, x, y]
+    assert list(preorder_traversal((x + y)*z, keys=True)) == \
+        [z*(x + y), z, x + y, x, y]
+
+
+def test_use():
+    x, y = symbols('x y')
+
+    assert use(0, expand) == 0
+
+    f = (x + y)**2*x + 1
+
+    assert use(f, expand, level=0) == x**3 + 2*x**2*y + x*y**2 + + 1
+    assert use(f, expand, level=1) == x**3 + 2*x**2*y + x*y**2 + + 1
+    assert use(f, expand, level=2) == 1 + x*(2*x*y + x**2 + y**2)
+    assert use(f, expand, level=3) == (x + y)**2*x + 1
+
+    f = (x**2 + 1)**2 - 1
+    kwargs = {'gaussian': True}
+
+    assert use(f, factor, level=0, kwargs=kwargs) == x**2*(x**2 + 2)
+    assert use(f, factor, level=1, kwargs=kwargs) == (x + I)**2*(x - I)**2 - 1
+    assert use(f, factor, level=2, kwargs=kwargs) == (x + I)**2*(x - I)**2 - 1
+    assert use(f, factor, level=3, kwargs=kwargs) == (x**2 + 1)**2 - 1
+
+
+def test_postorder_traversal():
+    x, y, z, w = symbols('x y z w')
+    expr = z + w*(x + y)
+    expected = [z, w, x, y, x + y, w*(x + y), w*(x + y) + z]
+    assert list(postorder_traversal(expr, keys=default_sort_key)) == expected
+    assert list(postorder_traversal(expr, keys=True)) == expected
+
+    expr = Piecewise((x, x < 1), (x**2, True))
+    expected = [
+        x, 1, x, x < 1, ExprCondPair(x, x < 1),
+        2, x, x**2, S.true,
+        ExprCondPair(x**2, True), Piecewise((x, x < 1), (x**2, True))
+    ]
+    assert list(postorder_traversal(expr, keys=default_sort_key)) == expected
+    assert list(postorder_traversal(
+        [expr], keys=default_sort_key)) == expected + [[expr]]
+
+    assert list(postorder_traversal(Integral(x**2, (x, 0, 1)),
+        keys=default_sort_key)) == [
+            2, x, x**2, 0, 1, x, Tuple(x, 0, 1),
+            Integral(x**2, Tuple(x, 0, 1))
+        ]
+    assert list(postorder_traversal(('abc', ('d', 'ef')))) == [
+        'abc', 'd', 'ef', ('d', 'ef'), ('abc', ('d', 'ef'))]
+
+
+def test_iterargs():
+    f = Function('f')
+    x = symbols('x')
+    assert list(iterfreeargs(Integral(f(x), (f(x), 1)))) == [
+        Integral(f(x), (f(x), 1)), 1]
+    assert list(iterargs(Integral(f(x), (f(x), 1)))) == [
+        Integral(f(x), (f(x), 1)), f(x), (f(x), 1), x, f(x), 1, x]
+
+def test_deprecated_imports():
+    x = symbols('x')
+
+    with warns_deprecated_sympy():
+        from sympy.core.basic import preorder_traversal
+        preorder_traversal(x)
+    with warns_deprecated_sympy():
+        from sympy.simplify.simplify import bottom_up
+        bottom_up(x, lambda x: x)
+    with warns_deprecated_sympy():
+        from sympy.simplify.simplify import walk
+        walk(x, lambda x: x)
+    with warns_deprecated_sympy():
+        from sympy.simplify.traversaltools import use
+        use(x, lambda x: x)
+    with warns_deprecated_sympy():
+        from sympy.utilities.iterables import postorder_traversal
+        postorder_traversal(x)
+    with warns_deprecated_sympy():
+        from sympy.utilities.iterables import interactive_traversal
+        capture(lambda: interactive_traversal(x))
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_truediv.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_truediv.py
new file mode 100644
index 0000000000000000000000000000000000000000..1fcf9e1ab754d05a3b47e7ec0c2be5ea9929da02
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_truediv.py
@@ -0,0 +1,54 @@
+#this module tests that SymPy works with true division turned on
+
+from sympy.core.numbers import (Float, Rational)
+from sympy.core.symbol import Symbol
+
+
+def test_truediv():
+    assert 1/2 != 0
+    assert Rational(1)/2 != 0
+
+
+def dotest(s):
+    x = Symbol("x")
+    y = Symbol("y")
+    l = [
+        Rational(2),
+        Float("1.3"),
+        x,
+        y,
+        pow(x, y)*y,
+        5,
+        5.5
+    ]
+    for x in l:
+        for y in l:
+            s(x, y)
+    return True
+
+
+def test_basic():
+    def s(a, b):
+        x = a
+        x = +a
+        x = -a
+        x = a + b
+        x = a - b
+        x = a*b
+        x = a/b
+        x = a**b
+        del x
+    assert dotest(s)
+
+
+def test_ibasic():
+    def s(a, b):
+        x = a
+        x += b
+        x = a
+        x -= b
+        x = a
+        x *= b
+        x = a
+        x /= b
+    assert dotest(s)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/tests/test_var.py b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_var.py
new file mode 100644
index 0000000000000000000000000000000000000000..a02709464c9878082fecaf70fa47067ac8838ac6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/tests/test_var.py
@@ -0,0 +1,62 @@
+from sympy.core.function import (Function, FunctionClass)
+from sympy.core.symbol import (Symbol, var)
+from sympy.testing.pytest import raises
+
+def test_var():
+    ns = {"var": var, "raises": raises}
+    eval("var('a')", ns)
+    assert ns["a"] == Symbol("a")
+
+    eval("var('b bb cc zz _x')", ns)
+    assert ns["b"] == Symbol("b")
+    assert ns["bb"] == Symbol("bb")
+    assert ns["cc"] == Symbol("cc")
+    assert ns["zz"] == Symbol("zz")
+    assert ns["_x"] == Symbol("_x")
+
+    v = eval("var(['d', 'e', 'fg'])", ns)
+    assert ns['d'] == Symbol('d')
+    assert ns['e'] == Symbol('e')
+    assert ns['fg'] == Symbol('fg')
+
+# check return value
+    assert v != ['d', 'e', 'fg']
+    assert v == [Symbol('d'), Symbol('e'), Symbol('fg')]
+
+
+def test_var_return():
+    ns = {"var": var, "raises": raises}
+    "raises(ValueError, lambda: var(''))"
+    v2 = eval("var('q')", ns)
+    v3 = eval("var('q p')", ns)
+
+    assert v2 == Symbol('q')
+    assert v3 == (Symbol('q'), Symbol('p'))
+
+
+def test_var_accepts_comma():
+    ns = {"var": var}
+    v1 = eval("var('x y z')", ns)
+    v2 = eval("var('x,y,z')", ns)
+    v3 = eval("var('x,y z')", ns)
+
+    assert v1 == v2
+    assert v1 == v3
+
+
+def test_var_keywords():
+    ns = {"var": var}
+    eval("var('x y', real=True)", ns)
+    assert ns['x'].is_real and ns['y'].is_real
+
+
+def test_var_cls():
+    ns = {"var": var, "Function": Function}
+    eval("var('f', cls=Function)", ns)
+
+    assert isinstance(ns['f'], FunctionClass)
+
+    eval("var('g,h', cls=Function)", ns)
+
+    assert isinstance(ns['g'], FunctionClass)
+    assert isinstance(ns['h'], FunctionClass)
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/trace.py b/.venv/lib/python3.12/site-packages/sympy/core/trace.py
new file mode 100644
index 0000000000000000000000000000000000000000..58326ce1fdd5038f0b5805afe7c453314a22cb6a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/trace.py
@@ -0,0 +1,12 @@
+from sympy.utilities.exceptions import sympy_deprecation_warning
+
+sympy_deprecation_warning(
+    """
+    sympy.core.trace is deprecated. Use sympy.physics.quantum.trace
+    instead.
+    """,
+    deprecated_since_version="1.10",
+    active_deprecations_target="sympy-core-trace-deprecated",
+)
+
+from sympy.physics.quantum.trace import Tr # noqa:F401
diff --git a/.venv/lib/python3.12/site-packages/sympy/core/traversal.py b/.venv/lib/python3.12/site-packages/sympy/core/traversal.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4e000ef44bf636b9adc700964a7ee4c2372a019
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/core/traversal.py
@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+from typing import Iterator
+
+from .basic import Basic
+from .sorting import ordered
+from .sympify import sympify
+from sympy.utilities.iterables import iterable
+
+
+
+def iterargs(expr):
+    """Yield the args of a Basic object in a breadth-first traversal.
+    Depth-traversal stops if `arg.args` is either empty or is not
+    an iterable.
+
+    Examples
+    ========
+
+    >>> from sympy import Integral, Function
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> from sympy.core.traversal import iterargs
+    >>> list(iterargs(Integral(f(x), (f(x), 1))))
+    [Integral(f(x), (f(x), 1)), f(x), (f(x), 1), x, f(x), 1, x]
+
+    See Also
+    ========
+    iterfreeargs, preorder_traversal
+    """
+    args = [expr]
+    for i in args:
+        yield i
+        args.extend(i.args)
+
+
+def iterfreeargs(expr, _first=True):
+    """Yield the args of a Basic object in a breadth-first traversal.
+    Depth-traversal stops if `arg.args` is either empty or is not
+    an iterable. The bound objects of an expression will be returned
+    as canonical variables.
+
+    Examples
+    ========
+
+    >>> from sympy import Integral, Function
+    >>> from sympy.abc import x
+    >>> f = Function('f')
+    >>> from sympy.core.traversal import iterfreeargs
+    >>> list(iterfreeargs(Integral(f(x), (f(x), 1))))
+    [Integral(f(x), (f(x), 1)), 1]
+
+    See Also
+    ========
+    iterargs, preorder_traversal
+    """
+    args = [expr]
+    for i in args:
+        yield i
+        if _first and hasattr(i, 'bound_symbols'):
+            void = i.canonical_variables.values()
+            for i in iterfreeargs(i.as_dummy(), _first=False):
+                if not i.has(*void):
+                    yield i
+        args.extend(i.args)
+
+
+class preorder_traversal:
+    """
+    Do a pre-order traversal of a tree.
+
+    This iterator recursively yields nodes that it has visited in a pre-order
+    fashion. That is, it yields the current node then descends through the
+    tree breadth-first to yield all of a node's children's pre-order
+    traversal.
+
+
+    For an expression, the order of the traversal depends on the order of
+    .args, which in many cases can be arbitrary.
+
+    Parameters
+    ==========
+    node : SymPy expression
+        The expression to traverse.
+    keys : (default None) sort key(s)
+        The key(s) used to sort args of Basic objects. When None, args of Basic
+        objects are processed in arbitrary order. If key is defined, it will
+        be passed along to ordered() as the only key(s) to use to sort the
+        arguments; if ``key`` is simply True then the default keys of ordered
+        will be used.
+
+    Yields
+    ======
+    subtree : SymPy expression
+        All of the subtrees in the tree.
+
+    Examples
+    ========
+
+    >>> from sympy import preorder_traversal, symbols
+    >>> x, y, z = symbols('x y z')
+
+    The nodes are returned in the order that they are encountered unless key
+    is given; simply passing key=True will guarantee that the traversal is
+    unique.
+
+    >>> list(preorder_traversal((x + y)*z, keys=None)) # doctest: +SKIP
+    [z*(x + y), z, x + y, y, x]
+    >>> list(preorder_traversal((x + y)*z, keys=True))
+    [z*(x + y), z, x + y, x, y]
+
+    """
+    def __init__(self, node, keys=None):
+        self._skip_flag = False
+        self._pt = self._preorder_traversal(node, keys)
+
+    def _preorder_traversal(self, node, keys):
+        yield node
+        if self._skip_flag:
+            self._skip_flag = False
+            return
+        if isinstance(node, Basic):
+            if not keys and hasattr(node, '_argset'):
+                # LatticeOp keeps args as a set. We should use this if we
+                # don't care about the order, to prevent unnecessary sorting.
+                args = node._argset
+            else:
+                args = node.args
+            if keys:
+                if keys != True:
+                    args = ordered(args, keys, default=False)
+                else:
+                    args = ordered(args)
+            for arg in args:
+                yield from self._preorder_traversal(arg, keys)
+        elif iterable(node):
+            for item in node:
+                yield from self._preorder_traversal(item, keys)
+
+    def skip(self):
+        """
+        Skip yielding current node's (last yielded node's) subtrees.
+
+        Examples
+        ========
+
+        >>> from sympy import preorder_traversal, symbols
+        >>> x, y, z = symbols('x y z')
+        >>> pt = preorder_traversal((x + y*z)*z)
+        >>> for i in pt:
+        ...     print(i)
+        ...     if i == x + y*z:
+        ...             pt.skip()
+        z*(x + y*z)
+        z
+        x + y*z
+        """
+        self._skip_flag = True
+
+    def __next__(self):
+        return next(self._pt)
+
+    def __iter__(self) -> Iterator[Basic]:
+        return self
+
+
+def use(expr, func, level=0, args=(), kwargs={}):
+    """
+    Use ``func`` to transform ``expr`` at the given level.
+
+    Examples
+    ========
+
+    >>> from sympy import use, expand
+    >>> from sympy.abc import x, y
+
+    >>> f = (x + y)**2*x + 1
+
+    >>> use(f, expand, level=2)
+    x*(x**2 + 2*x*y + y**2) + 1
+    >>> expand(f)
+    x**3 + 2*x**2*y + x*y**2 + 1
+
+    """
+    def _use(expr, level):
+        if not level:
+            return func(expr, *args, **kwargs)
+        else:
+            if expr.is_Atom:
+                return expr
+            else:
+                level -= 1
+                _args = [_use(arg, level) for arg in expr.args]
+                return expr.__class__(*_args)
+
+    return _use(sympify(expr), level)
+
+
+def walk(e, *target):
+    """Iterate through the args that are the given types (target) and
+    return a list of the args that were traversed; arguments
+    that are not of the specified types are not traversed.
+
+    Examples
+    ========
+
+    >>> from sympy.core.traversal import walk
+    >>> from sympy import Min, Max
+    >>> from sympy.abc import x, y, z
+    >>> list(walk(Min(x, Max(y, Min(1, z))), Min))
+    [Min(x, Max(y, Min(1, z)))]
+    >>> list(walk(Min(x, Max(y, Min(1, z))), Min, Max))
+    [Min(x, Max(y, Min(1, z))), Max(y, Min(1, z)), Min(1, z)]
+
+    See Also
+    ========
+
+    bottom_up
+    """
+    if isinstance(e, target):
+        yield e
+        for i in e.args:
+            yield from walk(i, *target)
+
+
+def bottom_up(rv, F, atoms=False, nonbasic=False):
+    """Apply ``F`` to all expressions in an expression tree from the
+    bottom up. If ``atoms`` is True, apply ``F`` even if there are no args;
+    if ``nonbasic`` is True, try to apply ``F`` to non-Basic objects.
+    """
+    args = getattr(rv, 'args', None)
+    if args is not None:
+        if args:
+            args = tuple([bottom_up(a, F, atoms, nonbasic) for a in args])
+            if args != rv.args:
+                rv = rv.func(*args)
+            rv = F(rv)
+        elif atoms:
+            rv = F(rv)
+    else:
+        if nonbasic:
+            try:
+                rv = F(rv)
+            except TypeError:
+                pass
+
+    return rv
+
+
+def postorder_traversal(node, keys=None):
+    """
+    Do a postorder traversal of a tree.
+
+    This generator recursively yields nodes that it has visited in a postorder
+    fashion. That is, it descends through the tree depth-first to yield all of
+    a node's children's postorder traversal before yielding the node itself.
+
+    Parameters
+    ==========
+
+    node : SymPy expression
+        The expression to traverse.
+    keys : (default None) sort key(s)
+        The key(s) used to sort args of Basic objects. When None, args of Basic
+        objects are processed in arbitrary order. If key is defined, it will
+        be passed along to ordered() as the only key(s) to use to sort the
+        arguments; if ``key`` is simply True then the default keys of
+        ``ordered`` will be used (node count and default_sort_key).
+
+    Yields
+    ======
+    subtree : SymPy expression
+        All of the subtrees in the tree.
+
+    Examples
+    ========
+
+    >>> from sympy import postorder_traversal
+    >>> from sympy.abc import w, x, y, z
+
+    The nodes are returned in the order that they are encountered unless key
+    is given; simply passing key=True will guarantee that the traversal is
+    unique.
+
+    >>> list(postorder_traversal(w + (x + y)*z)) # doctest: +SKIP
+    [z, y, x, x + y, z*(x + y), w, w + z*(x + y)]
+    >>> list(postorder_traversal(w + (x + y)*z, keys=True))
+    [w, z, x, y, x + y, z*(x + y), w + z*(x + y)]
+
+
+    """
+    if isinstance(node, Basic):
+        args = node.args
+        if keys:
+            if keys != True:
+                args = ordered(args, keys, default=False)
+            else:
+                args = ordered(args)
+        for arg in args:
+            yield from postorder_traversal(arg, keys)
+    elif iterable(node):
+        for item in node:
+            yield from postorder_traversal(item, keys)
+    yield node
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/__init__.py b/.venv/lib/python3.12/site-packages/sympy/crypto/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b27b4b036e5f2ed93a1ea88cd7d7144eb5615d4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/crypto/__init__.py
@@ -0,0 +1,35 @@
+from sympy.crypto.crypto import (cycle_list,
+        encipher_shift, encipher_affine, encipher_substitution,
+        check_and_join, encipher_vigenere, decipher_vigenere, bifid5_square,
+        bifid6_square, encipher_hill, decipher_hill,
+        encipher_bifid5, encipher_bifid6, decipher_bifid5,
+        decipher_bifid6, encipher_kid_rsa, decipher_kid_rsa,
+        kid_rsa_private_key, kid_rsa_public_key, decipher_rsa, rsa_private_key,
+        rsa_public_key, encipher_rsa, lfsr_connection_polynomial,
+        lfsr_autocorrelation, lfsr_sequence, encode_morse, decode_morse,
+        elgamal_private_key, elgamal_public_key, decipher_elgamal,
+        encipher_elgamal, dh_private_key, dh_public_key, dh_shared_key,
+        padded_key, encipher_bifid, decipher_bifid, bifid_square, bifid5,
+        bifid6, bifid10, decipher_gm, encipher_gm, gm_public_key,
+        gm_private_key, bg_private_key, bg_public_key, encipher_bg, decipher_bg,
+        encipher_rot13, decipher_rot13, encipher_atbash, decipher_atbash,
+        encipher_railfence, decipher_railfence)
+
+__all__ = [
+    'cycle_list', 'encipher_shift', 'encipher_affine',
+    'encipher_substitution', 'check_and_join', 'encipher_vigenere',
+    'decipher_vigenere', 'bifid5_square', 'bifid6_square', 'encipher_hill',
+    'decipher_hill', 'encipher_bifid5', 'encipher_bifid6', 'decipher_bifid5',
+    'decipher_bifid6', 'encipher_kid_rsa', 'decipher_kid_rsa',
+    'kid_rsa_private_key', 'kid_rsa_public_key', 'decipher_rsa',
+    'rsa_private_key', 'rsa_public_key', 'encipher_rsa',
+    'lfsr_connection_polynomial', 'lfsr_autocorrelation', 'lfsr_sequence',
+    'encode_morse', 'decode_morse', 'elgamal_private_key',
+    'elgamal_public_key', 'decipher_elgamal', 'encipher_elgamal',
+    'dh_private_key', 'dh_public_key', 'dh_shared_key', 'padded_key',
+    'encipher_bifid', 'decipher_bifid', 'bifid_square', 'bifid5', 'bifid6',
+    'bifid10', 'decipher_gm', 'encipher_gm', 'gm_public_key',
+    'gm_private_key', 'bg_private_key', 'bg_public_key', 'encipher_bg',
+    'decipher_bg', 'encipher_rot13', 'decipher_rot13', 'encipher_atbash',
+    'decipher_atbash', 'encipher_railfence', 'decipher_railfence',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e7ec603194d44555b94b4936bdcc98a1bc342da
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/crypto.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/crypto.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..158389453a85ba23a43fb59411ba328333673b6a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/crypto/__pycache__/crypto.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:494d52f4d6f05dc67b47711beec8b5ed2a7b1f3395eb3761833a56422cac0a4a
+size 107137
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/crypto.py b/.venv/lib/python3.12/site-packages/sympy/crypto/crypto.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c298e4ac08616dbe7d607a9d56d33b7fe9d5e2d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/crypto/crypto.py
@@ -0,0 +1,3368 @@
+"""
+This file contains some classical ciphers and routines
+implementing a linear-feedback shift register (LFSR)
+and the Diffie-Hellman key exchange.
+
+.. warning::
+
+   This module is intended for educational purposes only. Do not use the
+   functions in this module for real cryptographic applications. If you wish
+   to encrypt real data, we recommend using something like the `cryptography
+   `_ module.
+
+"""
+
+from string import whitespace, ascii_uppercase as uppercase, printable
+from functools import reduce
+import string
+import warnings
+
+from itertools import cycle
+
+from sympy.external.gmpy import GROUND_TYPES
+from sympy.core import Symbol
+from sympy.core.numbers import Rational
+from sympy.core.random import _randrange, _randint
+from sympy.external.gmpy import gcd, invert
+from sympy.functions.combinatorial.numbers import (totient as _euler,
+                                                   reduced_totient as _carmichael)
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, primitive_root, factorint
+from sympy.ntheory.generate import nextprime
+from sympy.ntheory.modular import crt
+from sympy.polys.domains import FF
+from sympy.polys.polytools import Poly
+from sympy.utilities.misc import as_int, filldedent, translate
+from sympy.utilities.iterables import uniq, multiset
+from sympy.utilities.decorator import doctest_depends_on
+
+
+if GROUND_TYPES == 'flint':
+    __doctest_skip__ = ['lfsr_sequence']
+
+
+class NonInvertibleCipherWarning(RuntimeWarning):
+    """A warning raised if the cipher is not invertible."""
+    def __init__(self, msg):
+        self.fullMessage = msg
+
+    def __str__(self):
+        return '\n\t' + self.fullMessage
+
+    def warn(self, stacklevel=3):
+        warnings.warn(self, stacklevel=stacklevel)
+
+
+def AZ(s=None):
+    """Return the letters of ``s`` in uppercase. In case more than
+    one string is passed, each of them will be processed and a list
+    of upper case strings will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import AZ
+    >>> AZ('Hello, world!')
+    'HELLOWORLD'
+    >>> AZ('Hello, world!'.split())
+    ['HELLO', 'WORLD']
+
+    See Also
+    ========
+
+    check_and_join
+
+    """
+    if not s:
+        return uppercase
+    t = isinstance(s, str)
+    if t:
+        s = [s]
+    rv = [check_and_join(i.upper().split(), uppercase, filter=True)
+        for i in s]
+    if t:
+        return rv[0]
+    return rv
+
+bifid5 = AZ().replace('J', '')
+bifid6 = AZ() + string.digits
+bifid10 = printable
+
+
+def padded_key(key, symbols):
+    """Return a string of the distinct characters of ``symbols`` with
+    those of ``key`` appearing first. A ValueError is raised if
+    a) there are duplicate characters in ``symbols`` or
+    b) there are characters in ``key`` that are  not in ``symbols``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import padded_key
+    >>> padded_key('PUPPY', 'OPQRSTUVWXY')
+    'PUYOQRSTVWX'
+    >>> padded_key('RSA', 'ARTIST')
+    Traceback (most recent call last):
+    ...
+    ValueError: duplicate characters in symbols: T
+
+    """
+    syms = list(uniq(symbols))
+    if len(syms) != len(symbols):
+        extra = ''.join(sorted({
+            i for i in symbols if symbols.count(i) > 1}))
+        raise ValueError('duplicate characters in symbols: %s' % extra)
+    extra = set(key) - set(syms)
+    if extra:
+        raise ValueError(
+            'characters in key but not symbols: %s' % ''.join(
+            sorted(extra)))
+    key0 = ''.join(list(uniq(key)))
+    # remove from syms characters in key0
+    return key0 + translate(''.join(syms), None, key0)
+
+
+def check_and_join(phrase, symbols=None, filter=None):
+    """
+    Joins characters of ``phrase`` and if ``symbols`` is given, raises
+    an error if any character in ``phrase`` is not in ``symbols``.
+
+    Parameters
+    ==========
+
+    phrase
+        String or list of strings to be returned as a string.
+
+    symbols
+        Iterable of characters allowed in ``phrase``.
+
+        If ``symbols`` is ``None``, no checking is performed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import check_and_join
+    >>> check_and_join('a phrase')
+    'a phrase'
+    >>> check_and_join('a phrase'.upper().split())
+    'APHRASE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE', filter=True)
+    'ARAE'
+    >>> check_and_join('a phrase!'.upper().split(), 'ARE')
+    Traceback (most recent call last):
+    ...
+    ValueError: characters in phrase but not symbols: "!HPS"
+
+    """
+    rv = ''.join(''.join(phrase))
+    if symbols is not None:
+        symbols = check_and_join(symbols)
+        missing = ''.join(sorted(set(rv) - set(symbols)))
+        if missing:
+            if not filter:
+                raise ValueError(
+                    'characters in phrase but not symbols: "%s"' % missing)
+            rv = translate(rv, None, missing)
+    return rv
+
+
+def _prep(msg, key, alp, default=None):
+    if not alp:
+        if not default:
+            alp = AZ()
+            msg = AZ(msg)
+            key = AZ(key)
+        else:
+            alp = default
+    else:
+        alp = ''.join(alp)
+    key = check_and_join(key, alp, filter=True)
+    msg = check_and_join(msg, alp, filter=True)
+    return msg, key, alp
+
+
+def cycle_list(k, n):
+    """
+    Returns the elements of the list ``range(n)`` shifted to the
+    left by ``k`` (so the list starts with ``k`` (mod ``n``)).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import cycle_list
+    >>> cycle_list(3, 10)
+    [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]
+
+    """
+    k = k % n
+    return list(range(k, n)) + list(range(k))
+
+
+######## shift cipher examples ############
+
+
+def encipher_shift(msg, key, symbols=None):
+    """
+    Performs shift cipher encryption on plaintext msg, and returns the
+    ciphertext.
+
+    Parameters
+    ==========
+
+    key : int
+        The secret key.
+
+    msg : str
+        Plaintext of upper-case letters.
+
+    Returns
+    =======
+
+    str
+        Ciphertext of upper-case letters.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    There is also a convenience function that does this with the
+    original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               adding ``(k mod 26)`` to each element in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    The shift cipher is also called the Caesar cipher, after
+    Julius Caesar, who, according to Suetonius, used it with a
+    shift of three to protect messages of military significance.
+    Caesar's nephew Augustus reportedly used a similar cipher, but
+    with a right shift of 1.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Caesar_cipher
+    .. [2] https://mathworld.wolfram.com/CaesarsMethod.html
+
+    See Also
+    ========
+
+    decipher_shift
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    shift = len(A) - key % len(A)
+    key = A[shift:] + A[:shift]
+    return translate(msg, key, A)
+
+
+def decipher_shift(msg, key, symbols=None):
+    """
+    Return the text by shifting the characters of ``msg`` to the
+    left by the amount given by ``key``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_shift, decipher_shift
+    >>> msg = "GONAVYBEATARMY"
+    >>> ct = encipher_shift(msg, 1); ct
+    'HPOBWZCFBUBSNZ'
+
+    To decipher the shifted text, change the sign of the key:
+
+    >>> encipher_shift(ct, -1)
+    'GONAVYBEATARMY'
+
+    Or use this function with the original key:
+
+    >>> decipher_shift(ct, 1)
+    'GONAVYBEATARMY'
+
+    """
+    return encipher_shift(msg, -key, symbols)
+
+def encipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 encryption on a given plaintext ``msg``.
+
+    Explanation
+    ===========
+
+    ROT13 is a substitution cipher which substitutes each letter
+    in the plaintext message for the letter furthest away from it
+    in the English alphabet.
+
+    Equivalently, it is just a Caeser (shift) cipher with a shift
+    key of 13 (midway point of the alphabet).
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/ROT13
+
+    See Also
+    ========
+
+    decipher_rot13
+    encipher_shift
+
+    """
+    return encipher_shift(msg, 13, symbols)
+
+def decipher_rot13(msg, symbols=None):
+    """
+    Performs the ROT13 decryption on a given plaintext ``msg``.
+
+    Explanation
+    ============
+
+    ``decipher_rot13`` is equivalent to ``encipher_rot13`` as both
+    ``decipher_shift`` with a key of 13 and ``encipher_shift`` key with a
+    key of 13 will return the same results. Nonetheless,
+    ``decipher_rot13`` has nonetheless been explicitly defined here for
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rot13, decipher_rot13
+    >>> msg = 'GONAVYBEATARMY'
+    >>> ciphertext = encipher_rot13(msg);ciphertext
+    'TBANILORNGNEZL'
+    >>> decipher_rot13(ciphertext)
+    'GONAVYBEATARMY'
+    >>> encipher_rot13(msg) == decipher_rot13(msg)
+    True
+    >>> msg == decipher_rot13(ciphertext)
+    True
+
+    """
+    return decipher_shift(msg, 13, symbols)
+
+######## affine cipher examples ############
+
+
+def encipher_affine(msg, key, symbols=None, _inverse=False):
+    r"""
+    Performs the affine cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    Encryption is based on the map `x \rightarrow ax+b` (mod `N`)
+    where ``N`` is the number of characters in the alphabet.
+    Decryption is based on the map `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+    In particular, for the map to be invertible, we need
+    `\mathrm{gcd}(a, N) = 1` and an error will be raised if this is
+    not true.
+
+    Parameters
+    ==========
+
+    msg : str
+        Characters that appear in ``symbols``.
+
+    a, b : int, int
+        A pair integers, with ``gcd(a, N) = 1`` (the secret key).
+
+    symbols
+        String of characters (default = uppercase letters).
+
+        When no symbols are given, ``msg`` is converted to upper case
+        letters and all other characters are ignored.
+
+    Returns
+    =======
+
+    ct
+        String of characters (the ciphertext message)
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L1`` of
+               corresponding integers.
+            2. Compute from the list ``L1`` a new list ``L2``, given by
+               replacing ``x`` by ``a*x + b (mod N)``, for each element
+               ``x`` in ``L1``.
+            3. Compute from the list ``L2`` a string ``ct`` of
+               corresponding letters.
+
+    This is a straightforward generalization of the shift cipher with
+    the added complexity of requiring 2 characters to be deciphered in
+    order to recover the key.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Affine_cipher
+
+    See Also
+    ========
+
+    decipher_affine
+
+    """
+    msg, _, A = _prep(msg, '', symbols)
+    N = len(A)
+    a, b = key
+    assert gcd(a, N) == 1
+    if _inverse:
+        c = invert(a, N)
+        d = -b*c
+        a, b = c, d
+    B = ''.join([A[(a*i + b) % N] for i in range(N)])
+    return translate(msg, A, B)
+
+
+def decipher_affine(msg, key, symbols=None):
+    r"""
+    Return the deciphered text that was made from the mapping,
+    `x \rightarrow ax+b` (mod `N`), where ``N`` is the
+    number of characters in the alphabet. Deciphering is done by
+    reciphering with a new key: `x \rightarrow cx+d` (mod `N`),
+    where `c = a^{-1}` (mod `N`) and `d = -a^{-1}b` (mod `N`).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_affine, decipher_affine
+    >>> msg = "GO NAVY BEAT ARMY"
+    >>> key = (3, 1)
+    >>> encipher_affine(msg, key)
+    'TROBMVENBGBALV'
+    >>> decipher_affine(_, key)
+    'GONAVYBEATARMY'
+
+    See Also
+    ========
+
+    encipher_affine
+
+    """
+    return encipher_affine(msg, key, symbols, _inverse=True)
+
+
+def encipher_atbash(msg, symbols=None):
+    r"""
+    Enciphers a given ``msg`` into its Atbash ciphertext and returns it.
+
+    Explanation
+    ===========
+
+    Atbash is a substitution cipher originally used to encrypt the Hebrew
+    alphabet. Atbash works on the principle of mapping each alphabet to its
+    reverse / counterpart (i.e. a would map to z, b to y etc.)
+
+    Atbash is functionally equivalent to the affine cipher with ``a = 25``
+    and ``b = 25``
+
+    See Also
+    ========
+
+    decipher_atbash
+
+    """
+    return encipher_affine(msg, (25, 25), symbols)
+
+
+def decipher_atbash(msg, symbols=None):
+    r"""
+    Deciphers a given ``msg`` using Atbash cipher and returns it.
+
+    Explanation
+    ===========
+
+    ``decipher_atbash`` is functionally equivalent to ``encipher_atbash``.
+    However, it has still been added as a separate function to maintain
+    consistency.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_atbash, decipher_atbash
+    >>> msg = 'GONAVYBEATARMY'
+    >>> encipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> decipher_atbash(msg)
+    'TLMZEBYVZGZINB'
+    >>> encipher_atbash(msg) == decipher_atbash(msg)
+    True
+    >>> msg == encipher_atbash(encipher_atbash(msg))
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Atbash
+
+    See Also
+    ========
+
+    encipher_atbash
+
+    """
+    return decipher_affine(msg, (25, 25), symbols)
+
+#################### substitution cipher ###########################
+
+
+def encipher_substitution(msg, old, new=None):
+    r"""
+    Returns the ciphertext obtained by replacing each character that
+    appears in ``old`` with the corresponding character in ``new``.
+    If ``old`` is a mapping, then new is ignored and the replacements
+    defined by ``old`` are used.
+
+    Explanation
+    ===========
+
+    This is a more general than the affine cipher in that the key can
+    only be recovered by determining the mapping for each symbol.
+    Though in practice, once a few symbols are recognized the mappings
+    for other characters can be quickly guessed.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_substitution, AZ
+    >>> old = 'OEYAG'
+    >>> new = '034^6'
+    >>> msg = AZ("go navy! beat army!")
+    >>> ct = encipher_substitution(msg, old, new); ct
+    '60N^V4B3^T^RM4'
+
+    To decrypt a substitution, reverse the last two arguments:
+
+    >>> encipher_substitution(ct, new, old)
+    'GONAVYBEATARMY'
+
+    In the special case where ``old`` and ``new`` are a permutation of
+    order 2 (representing a transposition of characters) their order
+    is immaterial:
+
+    >>> old = 'NAVY'
+    >>> new = 'ANYV'
+    >>> encipher = lambda x: encipher_substitution(x, old, new)
+    >>> encipher('NAVY')
+    'ANYV'
+    >>> encipher(_)
+    'NAVY'
+
+    The substitution cipher, in general, is a method
+    whereby "units" (not necessarily single characters) of plaintext
+    are replaced with ciphertext according to a regular system.
+
+    >>> ords = dict(zip('abc', ['\\%i' % ord(i) for i in 'abc']))
+    >>> print(encipher_substitution('abc', ords))
+    \97\98\99
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Substitution_cipher
+
+    """
+    return translate(msg, old, new)
+
+
+######################################################################
+#################### Vigenere cipher examples ########################
+######################################################################
+
+def encipher_vigenere(msg, key, symbols=None):
+    """
+    Performs the Vigenere cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_vigenere, AZ
+    >>> key = "encrypt"
+    >>> msg = "meet me on monday"
+    >>> encipher_vigenere(msg, key)
+    'QRGKKTHRZQEBPR'
+
+    Section 1 of the Kryptos sculpture at the CIA headquarters
+    uses this cipher and also changes the order of the
+    alphabet [2]_. Here is the first line of that section of
+    the sculpture:
+
+    >>> from sympy.crypto.crypto import decipher_vigenere, padded_key
+    >>> alp = padded_key('KRYPTOS', AZ())
+    >>> key = 'PALIMPSEST'
+    >>> msg = 'EMUFPHZLRFAXYUSDJKZLDKRNSHGNFIVJ'
+    >>> decipher_vigenere(msg, key, alp)
+    'BETWEENSUBTLESHADINGANDTHEABSENC'
+
+    Explanation
+    ===========
+
+    The Vigenere cipher is named after Blaise de Vigenere, a sixteenth
+    century diplomat and cryptographer, by a historical accident.
+    Vigenere actually invented a different and more complicated cipher.
+    The so-called *Vigenere cipher* was actually invented
+    by Giovan Batista Belaso in 1553.
+
+    This cipher was used in the 1800's, for example, during the American
+    Civil War. The Confederacy used a brass cipher disk to implement the
+    Vigenere cipher (now on display in the NSA Museum in Fort
+    Meade) [1]_.
+
+    The Vigenere cipher is a generalization of the shift cipher.
+    Whereas the shift cipher shifts each letter by the same amount
+    (that amount being the key of the shift cipher) the Vigenere
+    cipher shifts a letter by an amount determined by the key (which is
+    a word or phrase known only to the sender and receiver).
+
+    For example, if the key was a single letter, such as "C", then the
+    so-called Vigenere cipher is actually a shift cipher with a
+    shift of `2` (since "C" is the 2nd letter of the alphabet, if
+    you start counting at `0`). If the key was a word with two
+    letters, such as "CA", then the so-called Vigenere cipher will
+    shift letters in even positions by `2` and letters in odd positions
+    are left alone (shifted by `0`, since "A" is the 0th letter, if
+    you start counting at `0`).
+
+
+    ALGORITHM:
+
+        INPUT:
+
+            ``msg``: string of characters that appear in ``symbols``
+            (the plaintext)
+
+            ``key``: a string of characters that appear in ``symbols``
+            (the secret key)
+
+            ``symbols``: a string of letters defining the alphabet
+
+
+        OUTPUT:
+
+            ``ct``: string of characters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``key`` a list ``L1`` of
+               corresponding integers. Let ``n1 = len(L1)``.
+            2. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            3. Break ``L2`` up sequentially into sublists of size
+               ``n1``; the last sublist may be smaller than ``n1``
+            4. For each of these sublists ``L`` of ``L2``, compute a
+               new list ``C`` given by ``C[i] = L[i] + L1[i] (mod N)``
+               to the ``i``-th element in the sublist, for each ``i``.
+            5. Assemble these lists ``C`` by concatenation into a new
+               list of length ``n2``.
+            6. Compute from the new list a string ``ct`` of
+               corresponding letters.
+
+    Once it is known that the key is, say, `n` characters long,
+    frequency analysis can be applied to every `n`-th letter of
+    the ciphertext to determine the plaintext. This method is
+    called *Kasiski examination* (although it was first discovered
+    by Babbage). If they key is as long as the message and is
+    comprised of randomly selected characters -- a one-time pad -- the
+    message is theoretically unbreakable.
+
+    The cipher Vigenere actually discovered is an "auto-key" cipher
+    described as follows.
+
+    ALGORITHM:
+
+        INPUT:
+
+          ``key``: a string of letters (the secret key)
+
+          ``msg``: string of letters (the plaintext message)
+
+        OUTPUT:
+
+          ``ct``: string of upper-case letters (the ciphertext message)
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L2`` of
+               corresponding integers. Let ``n2 = len(L2)``.
+            2. Let ``n1`` be the length of the key. Append to the
+               string ``key`` the first ``n2 - n1`` characters of
+               the plaintext message. Compute from this string (also of
+               length ``n2``) a list ``L1`` of integers corresponding
+               to the letter numbers in the first step.
+            3. Compute a new list ``C`` given by
+               ``C[i] = L1[i] + L2[i] (mod N)``.
+            4. Compute from the new list a string ``ct`` of letters
+               corresponding to the new integers.
+
+    To decipher the auto-key ciphertext, the key is used to decipher
+    the first ``n1`` characters and then those characters become the
+    key to  decipher the next ``n1`` characters, etc...:
+
+    >>> m = AZ('go navy, beat army! yes you can'); m
+    'GONAVYBEATARMYYESYOUCAN'
+    >>> key = AZ('gold bug'); n1 = len(key); n2 = len(m)
+    >>> auto_key = key + m[:n2 - n1]; auto_key
+    'GOLDBUGGONAVYBEATARMYYE'
+    >>> ct = encipher_vigenere(m, auto_key); ct
+    'MCYDWSHKOGAMKZCELYFGAYR'
+    >>> n1 = len(key)
+    >>> pt = []
+    >>> while ct:
+    ...     part, ct = ct[:n1], ct[n1:]
+    ...     pt.append(decipher_vigenere(part, key))
+    ...     key = pt[-1]
+    ...
+    >>> ''.join(pt) == m
+    True
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Vigenere_cipher
+    .. [2] https://web.archive.org/web/20071116100808/https://filebox.vt.edu/users/batman/kryptos.html
+       (short URL: https://goo.gl/ijr22d)
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    key = [map[c] for c in key]
+    N = len(map)
+    k = len(key)
+    rv = []
+    for i, m in enumerate(msg):
+        rv.append(A[(map[m] + key[i % k]) % N])
+    rv = ''.join(rv)
+    return rv
+
+
+def decipher_vigenere(msg, key, symbols=None):
+    """
+    Decode using the Vigenere cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_vigenere
+    >>> key = "encrypt"
+    >>> ct = "QRGK kt HRZQE BPR"
+    >>> decipher_vigenere(ct, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, A = _prep(msg, key, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    N = len(A)   # normally, 26
+    K = [map[c] for c in key]
+    n = len(K)
+    C = [map[c] for c in msg]
+    rv = ''.join([A[(-K[i % n] + c) % N] for i, c in enumerate(C)])
+    return rv
+
+
+#################### Hill cipher  ########################
+
+
+def encipher_hill(msg, key, symbols=None, pad="Q"):
+    r"""
+    Return the Hill cipher encryption of ``msg``.
+
+    Explanation
+    ===========
+
+    The Hill cipher [1]_, invented by Lester S. Hill in the 1920's [2]_,
+    was the first polygraphic cipher in which it was practical
+    (though barely) to operate on more than three symbols at once.
+    The following discussion assumes an elementary knowledge of
+    matrices.
+
+    First, each letter is first encoded as a number starting with 0.
+    Suppose your message `msg` consists of `n` capital letters, with no
+    spaces. This may be regarded an `n`-tuple M of elements of
+    `Z_{26}` (if the letters are those of the English alphabet). A key
+    in the Hill cipher is a `k x k` matrix `K`, all of whose entries
+    are in `Z_{26}`, such that the matrix `K` is invertible (i.e., the
+    linear transformation `K: Z_{N}^k \rightarrow Z_{N}^k`
+    is one-to-one).
+
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext message of `n` upper-case letters.
+
+    key
+        A `k \times k` invertible matrix `K`, all of whose entries are
+        in `Z_{26}` (or whatever number of symbols are being used).
+
+    pad
+        Character (default "Q") to use to make length of text be a
+        multiple of ``k``.
+
+    Returns
+    =======
+
+    ct
+        Ciphertext of upper-case letters.
+
+    Notes
+    =====
+
+    ALGORITHM:
+
+        STEPS:
+            0. Number the letters of the alphabet from 0, ..., N
+            1. Compute from the string ``msg`` a list ``L`` of
+               corresponding integers. Let ``n = len(L)``.
+            2. Break the list ``L`` up into ``t = ceiling(n/k)``
+               sublists ``L_1``, ..., ``L_t`` of size ``k`` (with
+               the last list "padded" to ensure its size is
+               ``k``).
+            3. Compute new list ``C_1``, ..., ``C_t`` given by
+               ``C[i] = K*L_i`` (arithmetic is done mod N), for each
+               ``i``.
+            4. Concatenate these into a list ``C = C_1 + ... + C_t``.
+            5. Compute from ``C`` a string ``ct`` of corresponding
+               letters. This has length ``k*t``.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hill_cipher
+    .. [2] Lester S. Hill, Cryptography in an Algebraic Alphabet,
+       The American Mathematical Monthly Vol.36, June-July 1929,
+       pp.306-312.
+
+    See Also
+    ========
+
+    decipher_hill
+
+    """
+    assert key.is_square
+    assert len(pad) == 1
+    msg, pad, A = _prep(msg, pad, symbols)
+    map = {c: i for i, c in enumerate(A)}
+    P = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(P)
+    m, r = divmod(n, k)
+    if r:
+        P = P + [map[pad]]*(k - r)
+        m += 1
+    rv = ''.join([A[c % N] for j in range(m) for c in
+        list(key*Matrix(k, 1, [P[i]
+        for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+def decipher_hill(msg, key, symbols=None):
+    """
+    Deciphering is the same as enciphering but using the inverse of the
+    key matrix.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_hill, decipher_hill
+    >>> from sympy import Matrix
+
+    >>> key = Matrix([[1, 2], [3, 5]])
+    >>> encipher_hill("meet me on monday", key)
+    'UEQDUEODOCTCWQ'
+    >>> decipher_hill(_, key)
+    'MEETMEONMONDAY'
+
+    When the length of the plaintext (stripped of invalid characters)
+    is not a multiple of the key dimension, extra characters will
+    appear at the end of the enciphered and deciphered text. In order to
+    decipher the text, those characters must be included in the text to
+    be deciphered. In the following, the key has a dimension of 4 but
+    the text is 2 short of being a multiple of 4 so two characters will
+    be added.
+
+    >>> key = Matrix([[1, 1, 1, 2], [0, 1, 1, 0],
+    ...               [2, 2, 3, 4], [1, 1, 0, 1]])
+    >>> msg = "ST"
+    >>> encipher_hill(msg, key)
+    'HJEB'
+    >>> decipher_hill(_, key)
+    'STQQ'
+    >>> encipher_hill(msg, key, pad="Z")
+    'ISPK'
+    >>> decipher_hill(_, key)
+    'STZZ'
+
+    If the last two characters of the ciphertext were ignored in
+    either case, the wrong plaintext would be recovered:
+
+    >>> decipher_hill("HD", key)
+    'ORMV'
+    >>> decipher_hill("IS", key)
+    'UIKY'
+
+    See Also
+    ========
+
+    encipher_hill
+
+    """
+    assert key.is_square
+    msg, _, A = _prep(msg, '', symbols)
+    map = {c: i for i, c in enumerate(A)}
+    C = [map[c] for c in msg]
+    N = len(A)
+    k = key.cols
+    n = len(C)
+    m, r = divmod(n, k)
+    if r:
+        C = C + [0]*(k - r)
+        m += 1
+    key_inv = key.inv_mod(N)
+    rv = ''.join([A[p % N] for j in range(m) for p in
+        list(key_inv*Matrix(
+        k, 1, [C[i] for i in range(k*j, k*(j + 1))]))])
+    return rv
+
+
+#################### Bifid cipher  ########################
+
+
+def encipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses an `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in ``symbols`` that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default is string.printable)
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext using Bifid5 cipher without spaces.
+
+    See Also
+    ========
+
+    decipher_bifid, encipher_bifid5, encipher_bifid6
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bifid_cipher
+
+    """
+    msg, key, A = _prep(msg, key, symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+        long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the fractionalization
+    row_col = {ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    r, c = zip(*[row_col[x] for x in msg])
+    rc = r + c
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in zip(rc[::2], rc[1::2]))
+    return rv
+
+
+def decipher_bifid(msg, key, symbols=None):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `n \times n`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key.
+
+        Duplicate characters are ignored and then it is padded with the
+        characters in symbols that were not in the short key.
+
+    symbols
+        `n \times n` characters defining the alphabet.
+
+        (default=string.printable, a `10 \times 10` matrix)
+
+    Returns
+    =======
+
+    deciphered
+        Deciphered text.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid, decipher_bifid, AZ)
+
+    Do an encryption using the bifid5 alphabet:
+
+    >>> alp = AZ().replace('J', '')
+    >>> ct = AZ("meet me on monday!")
+    >>> key = AZ("gold bug")
+    >>> encipher_bifid(ct, key, alp)
+    'IEILHHFSTSFQYE'
+
+    When entering the text or ciphertext, spaces are ignored so it
+    can be formatted as desired. Re-entering the ciphertext from the
+    preceding, putting 4 characters per line and padding with an extra
+    J, does not cause problems for the deciphering:
+
+    >>> decipher_bifid('''
+    ... IEILH
+    ... HFSTS
+    ... FQYEJ''', key, alp)
+    'MEETMEONMONDAY'
+
+    When no alphabet is given, all 100 printable characters will be
+    used:
+
+    >>> key = ''
+    >>> encipher_bifid('hello world!', key)
+    'bmtwmg-bIo*w'
+    >>> decipher_bifid(_, key)
+    'hello world!'
+
+    If the key is changed, a different encryption is obtained:
+
+    >>> key = 'gold bug'
+    >>> encipher_bifid('hello world!', 'gold_bug')
+    'hg2sfuei7t}w'
+
+    And if the key used to decrypt the message is not exact, the
+    original text will not be perfectly obtained:
+
+    >>> decipher_bifid(_, 'gold pug')
+    'heldo~wor6d!'
+
+    """
+    msg, _, A = _prep(msg, '', symbols, bifid10)
+    long_key = ''.join(uniq(key)) or A
+
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    N = int(n)
+    if len(long_key) < N**2:
+        long_key = list(long_key) + [x for x in A if x not in long_key]
+
+    # the reverse fractionalization
+    row_col = {
+        ch: divmod(i, N) for i, ch in enumerate(long_key)}
+    rc = [i for c in msg for i in row_col[c]]
+    n = len(msg)
+    rc = zip(*(rc[:n], rc[n:]))
+    ch = {i: ch for ch, i in row_col.items()}
+    rv = ''.join(ch[i] for i in rc)
+    return rv
+
+
+def bifid_square(key):
+    """Return characters of ``key`` arranged in a square.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...    bifid_square, AZ, padded_key, bifid5)
+    >>> bifid_square(AZ().replace('J', ''))
+    Matrix([
+    [A, B, C, D, E],
+    [F, G, H, I, K],
+    [L, M, N, O, P],
+    [Q, R, S, T, U],
+    [V, W, X, Y, Z]])
+
+    >>> bifid_square(padded_key(AZ('gold bug!'), bifid5))
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    See Also
+    ========
+
+    padded_key
+
+    """
+    A = ''.join(uniq(''.join(key)))
+    n = len(A)**.5
+    if n != int(n):
+        raise ValueError(
+            'Length of alphabet (%s) is not a square number.' % len(A))
+    n = int(n)
+    f = lambda i, j: Symbol(A[n*i + j])
+    rv = Matrix(n, n, f)
+    return rv
+
+
+def encipher_bifid5(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square. The letter "J" is ignored so it must be replaced
+    with something else (traditionally an "I") before encryption.
+
+    ALGORITHM: (5x5 case)
+
+        STEPS:
+            0. Create the `5 \times 5` Polybius square ``S`` associated
+               to ``key`` as follows:
+
+                a) moving from left-to-right, top-to-bottom,
+                   place the letters of the key into a `5 \times 5`
+                   matrix,
+                b) if the key has less than 25 letters, add the
+                   letters of the alphabet not in the key until the
+                   `5 \times 5` square is filled.
+
+            1. Create a list ``P`` of pairs of numbers which are the
+               coordinates in the Polybius square of the letters in
+               ``msg``.
+            2. Let ``L1`` be the list of all first coordinates of ``P``
+               (length of ``L1 = n``), let ``L2`` be the list of all
+               second coordinates of ``P`` (so the length of ``L2``
+               is also ``n``).
+            3. Let ``L`` be the concatenation of ``L1`` and ``L2``
+               (length ``L = 2*n``), except that consecutive numbers
+               are paired ``(L[2*i], L[2*i + 1])``. You can regard
+               ``L`` as a list of pairs of length ``n``.
+            4. Let ``C`` be the list of all letters which are of the
+               form ``S[i, j]``, for all ``(i, j)`` in ``L``. As a
+               string, this is the ciphertext of ``msg``.
+
+    Parameters
+    ==========
+
+    msg : str
+        Plaintext string.
+
+        Converted to upper case and filtered of anything but all letters
+        except J.
+
+    key
+        Short string for key; non-alphabetic letters, J and duplicated
+        characters are ignored and then, if the length is less than 25
+        characters, it is padded with other letters of the alphabet
+        (in alphabetical order).
+
+    Returns
+    =======
+
+    ct
+        Ciphertext (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_bifid5, decipher_bifid5)
+
+    "J" will be omitted unless it is replaced with something else:
+
+    >>> round_trip = lambda m, k: \
+    ...     decipher_bifid5(encipher_bifid5(m, k), k)
+    >>> key = 'a'
+    >>> msg = "JOSIE"
+    >>> round_trip(msg, key)
+    'OSIE'
+    >>> round_trip(msg.replace("J", "I"), key)
+    'IOSIE'
+    >>> j = "QIQ"
+    >>> round_trip(msg.replace("J", j), key).replace(j, "J")
+    'JOSIE'
+
+
+    Notes
+    =====
+
+    The Bifid cipher was invented around 1901 by Felix Delastelle.
+    It is a *fractional substitution* cipher, where letters are
+    replaced by pairs of symbols from a smaller alphabet. The
+    cipher uses a `5 \times 5` square filled with some ordering of the
+    alphabet, except that "J" is replaced with "I" (this is a so-called
+    Polybius square; there is a `6 \times 6` analog if you add back in
+    "J" and also append onto the usual 26 letter alphabet, the digits
+    0, 1, ..., 9).
+    According to Helen Gaines' book *Cryptanalysis*, this type of cipher
+    was used in the field by the German Army during World War I.
+
+    See Also
+    ========
+
+    decipher_bifid5, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid5(msg, key):
+    r"""
+    Return the Bifid cipher decryption of ``msg``.
+
+    Explanation
+    ===========
+
+    This is the version of the Bifid cipher that uses the `5 \times 5`
+    Polybius square; the letter "J" is ignored unless a ``key`` of
+    length 25 is used.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string.
+
+    key
+        Short string for key; duplicated characters are ignored and if
+        the length is less then 25 characters, it will be padded with
+        other letters from the alphabet omitting "J".
+        Non-alphabetic characters are ignored.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid5 cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid5, decipher_bifid5
+    >>> key = "gold bug"
+    >>> encipher_bifid5('meet me on friday', key)
+    'IEILEHFSTSFXEE'
+    >>> encipher_bifid5('meet me on monday', key)
+    'IEILHHFSTSFQYE'
+    >>> decipher_bifid5(_, key)
+    'MEETMEONMONDAY'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid5)
+    key = padded_key(key, bifid5)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid5_square(key=None):
+    r"""
+    5x5 Polybius square.
+
+    Produce the Polybius square for the `5 \times 5` Bifid cipher.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid5_square
+    >>> bifid5_square("gold bug")
+    Matrix([
+    [G, O, L, D, B],
+    [U, A, C, E, F],
+    [H, I, K, M, N],
+    [P, Q, R, S, T],
+    [V, W, X, Y, Z]])
+
+    """
+    if not key:
+        key = bifid5
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid5)
+        key = padded_key(key, bifid5)
+    return bifid_square(key)
+
+
+def encipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher encryption on plaintext ``msg``, and
+    returns the ciphertext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Plaintext string (digits okay).
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+
+    Returns
+    =======
+
+    ciphertext
+        Ciphertext from Bifid cipher (all caps, no spaces).
+
+    See Also
+    ========
+
+    decipher_bifid6, encipher_bifid
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return encipher_bifid(msg, '', key)
+
+
+def decipher_bifid6(msg, key):
+    r"""
+    Performs the Bifid cipher decryption on ciphertext ``msg``, and
+    returns the plaintext.
+
+    This is the version of the Bifid cipher that uses the `6 \times 6`
+    Polybius square.
+
+    Parameters
+    ==========
+
+    msg
+        Ciphertext string (digits okay); converted to upper case
+
+    key
+        Short string for key (digits okay).
+
+        If ``key`` is less than 36 characters long, the square will be
+        filled with letters A through Z and digits 0 through 9.
+        All letters are converted to uppercase.
+
+    Returns
+    =======
+
+    plaintext
+        Plaintext from Bifid cipher (all caps, no spaces).
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_bifid6, decipher_bifid6
+    >>> key = "gold bug"
+    >>> encipher_bifid6('meet me on monday at 8am', key)
+    'KFKLJJHF5MMMKTFRGPL'
+    >>> decipher_bifid6(_, key)
+    'MEETMEONMONDAYAT8AM'
+
+    """
+    msg, key, _ = _prep(msg.upper(), key.upper(), None, bifid6)
+    key = padded_key(key, bifid6)
+    return decipher_bifid(msg, '', key)
+
+
+def bifid6_square(key=None):
+    r"""
+    6x6 Polybius square.
+
+    Produces the Polybius square for the `6 \times 6` Bifid cipher.
+    Assumes alphabet of symbols is "A", ..., "Z", "0", ..., "9".
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import bifid6_square
+    >>> key = "gold bug"
+    >>> bifid6_square(key)
+    Matrix([
+    [G, O, L, D, B, U],
+    [A, C, E, F, H, I],
+    [J, K, M, N, P, Q],
+    [R, S, T, V, W, X],
+    [Y, Z, 0, 1, 2, 3],
+    [4, 5, 6, 7, 8, 9]])
+
+    """
+    if not key:
+        key = bifid6
+    else:
+        _, key, _ = _prep('', key.upper(), None, bifid6)
+        key = padded_key(key, bifid6)
+    return bifid_square(key)
+
+
+#################### RSA  #############################
+
+def _decipher_rsa_crt(i, d, factors):
+    """Decipher RSA using chinese remainder theorem from the information
+    of the relatively-prime factors of the modulus.
+
+    Parameters
+    ==========
+
+    i : integer
+        Ciphertext
+
+    d : integer
+        The exponent component.
+
+    factors : list of relatively-prime integers
+        The integers given must be coprime and the product must equal
+        the modulus component of the original RSA key.
+
+    Examples
+    ========
+
+    How to decrypt RSA with CRT:
+
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+    >>> primes = [61, 53]
+    >>> e = 17
+    >>> args = primes + [e]
+    >>> puk = rsa_public_key(*args)
+    >>> prk = rsa_private_key(*args)
+
+    >>> from sympy.crypto.crypto import encipher_rsa, _decipher_rsa_crt
+    >>> msg = 65
+    >>> crt_primes = primes
+    >>> encrypted = encipher_rsa(msg, puk)
+    >>> decrypted = _decipher_rsa_crt(encrypted, prk[1], primes)
+    >>> decrypted
+    65
+    """
+    moduluses = [pow(i, d, p) for p in factors]
+
+    result = crt(factors, moduluses)
+    if not result:
+        raise ValueError("CRT failed")
+    return result[0]
+
+
+def _rsa_key(*args, public=True, private=True, totient='Euler', index=None, multipower=None):
+    r"""A private subroutine to generate RSA key
+
+    Parameters
+    ==========
+
+    public, private : bool, optional
+        Flag to generate either a public key, a private key.
+
+    totient : 'Euler' or 'Carmichael'
+        Different notation used for totient.
+
+    multipower : bool, optional
+        Flag to bypass warning for multipower RSA.
+    """
+
+    if len(args) < 2:
+        return False
+
+    if totient not in ('Euler', 'Carmichael'):
+        raise ValueError(
+            "The argument totient={} should either be " \
+            "'Euler', 'Carmichalel'." \
+            .format(totient))
+
+    if totient == 'Euler':
+        _totient = _euler
+    else:
+        _totient = _carmichael
+
+    if index is not None:
+        index = as_int(index)
+        if totient != 'Carmichael':
+            raise ValueError(
+                "Setting the 'index' keyword argument requires totient"
+                "notation to be specified as 'Carmichael'.")
+
+    primes, e = args[:-1], args[-1]
+
+    if not all(isprime(p) for p in primes):
+        new_primes = []
+        for i in primes:
+            new_primes.extend(factorint(i, multiple=True))
+        primes = new_primes
+
+    n = reduce(lambda i, j: i*j, primes)
+
+    tally = multiset(primes)
+    if all(v == 1 for v in tally.values()):
+        phi = int(_totient(tally))
+
+    else:
+        if not multipower:
+            NonInvertibleCipherWarning(
+                'Non-distinctive primes found in the factors {}. '
+                'The cipher may not be decryptable for some numbers '
+                'in the complete residue system Z[{}], but the cipher '
+                'can still be valid if you restrict the domain to be '
+                'the reduced residue system Z*[{}]. You can pass '
+                'the flag multipower=True if you want to suppress this '
+                'warning.'
+                .format(primes, n, n)
+                # stacklevel=4 because most users will call a function that
+                # calls this function
+                ).warn(stacklevel=4)
+        phi = int(_totient(tally))
+
+    if gcd(e, phi) == 1:
+        if public and not private:
+            if isinstance(index, int):
+                e = e % phi
+                e += index * phi
+            return n, e
+
+        if private and not public:
+            d = invert(e, phi)
+            if isinstance(index, int):
+                d += index * phi
+            return n, d
+
+    return False
+
+
+def rsa_public_key(*args, **kwargs):
+    r"""Return the RSA *public key* pair, `(n, e)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        If specified as `p, q, e` where `p` and `q` are distinct primes
+        and `e` is a desired public exponent of the RSA, `n = p q` and
+        `e` will be verified against the totient
+        `\phi(n)` (Euler totient) or `\lambda(n)` (Carmichael totient)
+        to be `\gcd(e, \phi(n)) = 1` or `\gcd(e, \lambda(n)) = 1`.
+
+        If specified as `p_1, p_2, \dots, p_n, e` where
+        `p_1, p_2, \dots, p_n` are specified as primes,
+        and `e` is specified as a desired public exponent of the RSA,
+        it will be able to form a multi-prime RSA, which is a more
+        generalized form of the popular 2-prime RSA.
+
+        It can also be possible to form a single-prime RSA by specifying
+        the argument as `p, e`, which can be considered a trivial case
+        of a multiprime RSA.
+
+        Furthermore, it can be possible to form a multi-power RSA by
+        specifying two or more pairs of the primes to be same.
+        However, unlike the two-distinct prime RSA or multi-prime
+        RSA, not every numbers in the complete residue system
+        (`\mathbb{Z}_n`) will be decryptable since the mapping
+        `\mathbb{Z}_{n} \rightarrow \mathbb{Z}_{n}`
+        will not be bijective.
+        (Only except for the trivial case when
+        `e = 1`
+        or more generally,
+
+        .. math::
+            e \in \left \{ 1 + k \lambda(n)
+            \mid k \in \mathbb{Z} \land k \geq 0 \right \}
+
+        when RSA reduces to the identity.)
+        However, the RSA can still be decryptable for the numbers in the
+        reduced residue system (`\mathbb{Z}_n^{\times}`), since the
+        mapping
+        `\mathbb{Z}_{n}^{\times} \rightarrow \mathbb{Z}_{n}^{\times}`
+        can still be bijective.
+
+        If you pass a non-prime integer to the arguments
+        `p_1, p_2, \dots, p_n`, the particular number will be
+        prime-factored and it will become either a multi-prime RSA or a
+        multi-power RSA in its canonical form, depending on whether the
+        product equals its radical or not.
+        `p_1 p_2 \dots p_n = \text{rad}(p_1 p_2 \dots p_n)`
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient `\phi(n)` which is
+        :meth:`sympy.functions.combinatorial.numbers.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient `\lambda(n)`
+        which is :meth:`sympy.functions.combinatorial.numbers.reduced_totient` in SymPy.
+
+        Unlike private key generation, this is a trivial keyword for
+        public key generation because
+        `\gcd(e, \phi(n)) = 1 \iff \gcd(e, \lambda(n)) = 1`.
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA public key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        Similarly to the non-uniquenss of a RSA private key as described
+        in the ``index`` parameter documentation in
+        :meth:`rsa_private_key`, RSA public key is also not unique and
+        there is an infinite number of RSA public exponents which
+        can behave in the same manner.
+
+        From any given RSA public exponent `e`, there are can be an
+        another RSA public exponent `e + k \lambda(n)` where `k` is an
+        integer, `\lambda` is a Carmichael's totient function.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA public exponent `e_0` in
+        `0 < e_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `e_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA public key can have.
+
+        An example of computing any arbitrary RSA public key:
+
+        >>> from sympy.crypto.crypto import rsa_public_key
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 17)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 797)
+        >>> rsa_public_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1577)
+
+    multipower : bool, optional
+        Any pair of non-distinct primes found in the RSA specification
+        will restrict the domain of the cryptosystem, as noted in the
+        explanation of the parameter ``args``.
+
+        SymPy RSA key generator may give a warning before dispatching it
+        as a multi-power RSA, however, you can disable the warning if
+        you pass ``True`` to this keyword.
+
+    Returns
+    =======
+
+    (n, e) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `e` is relatively prime (coprime) to the Euler totient
+        `\phi(n)`.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_public_key
+
+    A public key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_public_key(p, q, e)
+    (15, 7)
+    >>> rsa_public_key(p, q, 30)
+    False
+
+    A public key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_public_key(*args)
+    (30030, 7)
+
+    Notes
+    =====
+
+    Although the RSA can be generalized over any modulus `n`, using
+    two large primes had became the most popular specification because a
+    product of two large primes is usually the hardest to factor
+    relatively to the digits of `n` can have.
+
+    However, it may need further understanding of the time complexities
+    of each prime-factoring algorithms to verify the claim.
+
+    See Also
+    ========
+
+    rsa_private_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=True, private=False, **kwargs)
+
+
+def rsa_private_key(*args, **kwargs):
+    r"""Return the RSA *private key* pair, `(n, d)`
+
+    Parameters
+    ==========
+
+    args : naturals
+        The keyword is identical to the ``args`` in
+        :meth:`rsa_public_key`.
+
+    totient : bool, optional
+        If ``'Euler'``, it uses Euler's totient convention `\phi(n)`
+        which is :meth:`sympy.functions.combinatorial.numbers.totient` in SymPy.
+
+        If ``'Carmichael'``, it uses Carmichael's totient convention
+        `\lambda(n)` which is
+        :meth:`sympy.functions.combinatorial.numbers.reduced_totient` in SymPy.
+
+        There can be some output differences for private key generation
+        as examples below.
+
+        Example using Euler's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Euler')
+        (3233, 2753)
+
+        Example using Carmichael's totient:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael')
+        (3233, 413)
+
+    index : nonnegative integer, optional
+        Returns an arbitrary solution of a RSA private key at the index
+        specified at `0, 1, 2, \dots`. This parameter needs to be
+        specified along with ``totient='Carmichael'``.
+
+        RSA private exponent is a non-unique solution of
+        `e d \mod \lambda(n) = 1` and it is possible in any form of
+        `d + k \lambda(n)`, where `d` is an another
+        already-computed private exponent, and `\lambda` is a
+        Carmichael's totient function, and `k` is any integer.
+
+        However, considering only the positive cases, there can be
+        a principal solution of a RSA private exponent `d_0` in
+        `0 < d_0 < \lambda(n)`, and all the other solutions
+        can be canonicalzed in a form of `d_0 + k \lambda(n)`.
+
+        ``index`` specifies the `k` notation to yield any possible value
+        an RSA private key can have.
+
+        An example of computing any arbitrary RSA private key:
+
+        >>> from sympy.crypto.crypto import rsa_private_key
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=0)
+        (3233, 413)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=1)
+        (3233, 1193)
+        >>> rsa_private_key(61, 53, 17, totient='Carmichael', index=2)
+        (3233, 1973)
+
+    multipower : bool, optional
+        The keyword is identical to the ``multipower`` in
+        :meth:`rsa_public_key`.
+
+    Returns
+    =======
+
+    (n, d) : int, int
+        `n` is a product of any arbitrary number of primes given as
+        the argument.
+
+        `d` is the inverse of `e` (mod `\phi(n)`) where `e` is the
+        exponent given, and `\phi` is a Euler totient.
+
+    False
+        Returned if less than two arguments are given, or `e` is
+        not relatively prime to the totient of the modulus.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import rsa_private_key
+
+    A private key of a two-prime RSA:
+
+    >>> p, q, e = 3, 5, 7
+    >>> rsa_private_key(p, q, e)
+    (15, 7)
+    >>> rsa_private_key(p, q, 30)
+    False
+
+    A private key of a multiprime RSA:
+
+    >>> primes = [2, 3, 5, 7, 11, 13]
+    >>> e = 7
+    >>> args = primes + [e]
+    >>> rsa_private_key(*args)
+    (30030, 823)
+
+    See Also
+    ========
+
+    rsa_public_key
+    encipher_rsa
+    decipher_rsa
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/RSA_%28cryptosystem%29
+
+    .. [2] https://cacr.uwaterloo.ca/techreports/2006/cacr2006-16.pdf
+
+    .. [3] https://link.springer.com/content/pdf/10.1007/BFb0055738.pdf
+
+    .. [4] https://www.itiis.org/digital-library/manuscript/1381
+    """
+    return _rsa_key(*args, public=False, private=True, **kwargs)
+
+
+def _encipher_decipher_rsa(i, key, factors=None):
+    n, d = key
+    if not factors:
+        return pow(i, d, n)
+
+    def _is_coprime_set(l):
+        is_coprime_set = True
+        for i in range(len(l)):
+            for j in range(i+1, len(l)):
+                if gcd(l[i], l[j]) != 1:
+                    is_coprime_set = False
+                    break
+        return is_coprime_set
+
+    prod = reduce(lambda i, j: i*j, factors)
+    if prod == n and _is_coprime_set(factors):
+        return _decipher_rsa_crt(i, d, factors)
+    return _encipher_decipher_rsa(i, key, factors=None)
+
+
+def encipher_rsa(i, key, factors=None):
+    r"""Encrypt the plaintext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The plaintext to be encrypted for.
+
+    key : (n, e) where n, e are integers
+        `n` is the modulus of the key and `e` is the exponent of the
+        key. The encryption is computed by `i^e \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        This is identical to the keyword ``factors`` in
+        :meth:`decipher_rsa`.
+
+    Notes
+    =====
+
+    Some specifications may make the RSA not cryptographically
+    meaningful.
+
+    For example, `0`, `1` will remain always same after taking any
+    number of exponentiation, thus, should be avoided.
+
+    Furthermore, if `i^e < n`, `i` may easily be figured out by taking
+    `e` th root.
+
+    And also, specifying the exponent as `1` or in more generalized form
+    as `1 + k \lambda(n)` where `k` is an nonnegative integer,
+    `\lambda` is a carmichael totient, the RSA becomes an identity
+    mapping.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, puk)
+    3
+
+    Private Key Encryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> msg = 12
+    >>> encipher_rsa(msg, prk)
+    3
+
+    Encryption using chinese remainder theorem:
+
+    >>> encipher_rsa(msg, prk, factors=[p, q])
+    3
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+def decipher_rsa(i, key, factors=None):
+    r"""Decrypt the ciphertext with RSA.
+
+    Parameters
+    ==========
+
+    i : integer
+        The ciphertext to be decrypted for.
+
+    key : (n, d) where n, d are integers
+        `n` is the modulus of the key and `d` is the exponent of the
+        key. The decryption is computed by `i^d \bmod n`.
+
+        The key can either be a public key or a private key, however,
+        the message encrypted by a public key can only be decrypted by
+        a private key, and vice versa, as RSA is an asymmetric
+        cryptography system.
+
+    factors : list of coprime integers
+        As the modulus `n` created from RSA key generation is composed
+        of arbitrary prime factors
+        `n = {p_1}^{k_1}{p_2}^{k_2}\dots{p_n}^{k_n}` where
+        `p_1, p_2, \dots, p_n` are distinct primes and
+        `k_1, k_2, \dots, k_n` are positive integers, chinese remainder
+        theorem can be used to compute `i^d \bmod n` from the
+        fragmented modulo operations like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}, i^d \bmod {p_2}^{k_2}, \dots,
+            i^d \bmod {p_n}^{k_n}
+
+        or like
+
+        .. math::
+            i^d \bmod {p_1}^{k_1}{p_2}^{k_2},
+            i^d \bmod {p_3}^{k_3}, \dots ,
+            i^d \bmod {p_n}^{k_n}
+
+        as long as every moduli does not share any common divisor each
+        other.
+
+        The raw primes used in generating the RSA key pair can be a good
+        option.
+
+        Note that the speed advantage of using this is only viable for
+        very large cases (Like 2048-bit RSA keys) since the
+        overhead of using pure Python implementation of
+        :meth:`sympy.ntheory.modular.crt` may overcompensate the
+        theoretical speed advantage.
+
+    Notes
+    =====
+
+    See the ``Notes`` section in the documentation of
+    :meth:`encipher_rsa`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_rsa, encipher_rsa
+    >>> from sympy.crypto.crypto import rsa_public_key, rsa_private_key
+
+    Public Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, prk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, puk)
+    12
+
+    Private Key Encryption and Decryption:
+
+    >>> p, q, e = 3, 5, 7
+    >>> prk = rsa_private_key(p, q, e)
+    >>> puk = rsa_public_key(p, q, e)
+    >>> msg = 12
+    >>> new_msg = encipher_rsa(msg, puk)
+    >>> new_msg
+    3
+    >>> decipher_rsa(new_msg, prk)
+    12
+
+    Decryption using chinese remainder theorem:
+
+    >>> decipher_rsa(new_msg, prk, factors=[p, q])
+    12
+
+    See Also
+    ========
+
+    encipher_rsa
+    """
+    return _encipher_decipher_rsa(i, key, factors=factors)
+
+
+#################### kid krypto (kid RSA) #############################
+
+
+def kid_rsa_public_key(a, b, A, B):
+    r"""
+    Kid RSA is a version of RSA useful to teach grade school children
+    since it does not involve exponentiation.
+
+    Explanation
+    ===========
+
+    Alice wants to talk to Bob. Bob generates keys as follows.
+    Key generation:
+
+    * Select positive integers `a, b, A, B` at random.
+    * Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+      `n = (e d - 1)//M`.
+    * The *public key* is `(n, e)`. Bob sends these to Alice.
+    * The *private key* is `(n, d)`, which Bob keeps secret.
+
+    Encryption: If `p` is the plaintext message then the
+    ciphertext is `c = p e \pmod n`.
+
+    Decryption: If `c` is the ciphertext message then the
+    plaintext is `p = c d \pmod n`.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_public_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_public_key(a, b, A, B)
+    (369, 58)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, e
+
+
+def kid_rsa_private_key(a, b, A, B):
+    """
+    Compute `M = a b - 1`, `e = A M + a`, `d = B M + b`,
+    `n = (e d - 1) / M`. The *private key* is `d`, which Bob
+    keeps secret.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import kid_rsa_private_key
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> kid_rsa_private_key(a, b, A, B)
+    (369, 70)
+
+    """
+    M = a*b - 1
+    e = A*M + a
+    d = B*M + b
+    n = (e*d - 1)//M
+    return n, d
+
+
+def encipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the public key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     encipher_kid_rsa, kid_rsa_public_key)
+    >>> msg = 200
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> key = kid_rsa_public_key(a, b, A, B)
+    >>> encipher_kid_rsa(msg, key)
+    161
+
+    """
+    n, e = key
+    return (msg*e) % n
+
+
+def decipher_kid_rsa(msg, key):
+    """
+    Here ``msg`` is the plaintext and ``key`` is the private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     kid_rsa_public_key, kid_rsa_private_key,
+    ...     decipher_kid_rsa, encipher_kid_rsa)
+    >>> a, b, A, B = 3, 4, 5, 6
+    >>> d = kid_rsa_private_key(a, b, A, B)
+    >>> msg = 200
+    >>> pub = kid_rsa_public_key(a, b, A, B)
+    >>> pri = kid_rsa_private_key(a, b, A, B)
+    >>> ct = encipher_kid_rsa(msg, pub)
+    >>> decipher_kid_rsa(ct, pri)
+    200
+
+    """
+    n, d = key
+    return (msg*d) % n
+
+
+#################### Morse Code ######################################
+
+morse_char = {
+    ".-": "A", "-...": "B",
+    "-.-.": "C", "-..": "D",
+    ".": "E", "..-.": "F",
+    "--.": "G", "....": "H",
+    "..": "I", ".---": "J",
+    "-.-": "K", ".-..": "L",
+    "--": "M", "-.": "N",
+    "---": "O", ".--.": "P",
+    "--.-": "Q", ".-.": "R",
+    "...": "S", "-": "T",
+    "..-": "U", "...-": "V",
+    ".--": "W", "-..-": "X",
+    "-.--": "Y", "--..": "Z",
+    "-----": "0", ".----": "1",
+    "..---": "2", "...--": "3",
+    "....-": "4", ".....": "5",
+    "-....": "6", "--...": "7",
+    "---..": "8", "----.": "9",
+    ".-.-.-": ".", "--..--": ",",
+    "---...": ":", "-.-.-.": ";",
+    "..--..": "?", "-....-": "-",
+    "..--.-": "_", "-.--.": "(",
+    "-.--.-": ")", ".----.": "'",
+    "-...-": "=", ".-.-.": "+",
+    "-..-.": "/", ".--.-.": "@",
+    "...-..-": "$", "-.-.--": "!"}
+char_morse = {v: k for k, v in morse_char.items()}
+
+
+def encode_morse(msg, sep='|', mapping=None):
+    """
+    Encodes a plaintext into popular Morse Code with letters
+    separated by ``sep`` and words by a double ``sep``.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encode_morse
+    >>> msg = 'ATTACK RIGHT FLANK'
+    >>> encode_morse(msg)
+    '.-|-|-|.-|-.-.|-.-||.-.|..|--.|....|-||..-.|.-..|.-|-.|-.-'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or char_morse
+    assert sep not in mapping
+    word_sep = 2*sep
+    mapping[" "] = word_sep
+    suffix = msg and msg[-1] in whitespace
+
+    # normalize whitespace
+    msg = (' ' if word_sep else '').join(msg.split())
+    # omit unmapped chars
+    chars = set(''.join(msg.split()))
+    ok = set(mapping.keys())
+    msg = translate(msg, None, ''.join(chars - ok))
+
+    morsestring = []
+    words = msg.split()
+    for word in words:
+        morseword = []
+        for letter in word:
+            morseletter = mapping[letter]
+            morseword.append(morseletter)
+
+        word = sep.join(morseword)
+        morsestring.append(word)
+
+    return word_sep.join(morsestring) + (word_sep if suffix else '')
+
+
+def decode_morse(msg, sep='|', mapping=None):
+    """
+    Decodes a Morse Code with letters separated by ``sep``
+    (default is '|') and words by `word_sep` (default is '||)
+    into plaintext.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decode_morse
+    >>> mc = '--|---|...-|.||.|.-|...|-'
+    >>> decode_morse(mc)
+    'MOVE EAST'
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Morse_code
+
+    """
+
+    mapping = mapping or morse_char
+    word_sep = 2*sep
+    characterstring = []
+    words = msg.strip(word_sep).split(word_sep)
+    for word in words:
+        letters = word.split(sep)
+        chars = [mapping[c] for c in letters]
+        word = ''.join(chars)
+        characterstring.append(word)
+    rv = " ".join(characterstring)
+    return rv
+
+
+#################### LFSRs  ##########################################
+
+
+@doctest_depends_on(ground_types=['python', 'gmpy'])
+def lfsr_sequence(key, fill, n):
+    r"""
+    This function creates an LFSR sequence.
+
+    Parameters
+    ==========
+
+    key : list
+        A list of finite field elements, `[c_0, c_1, \ldots, c_k].`
+
+    fill : list
+        The list of the initial terms of the LFSR sequence,
+        `[x_0, x_1, \ldots, x_k].`
+
+    n
+        Number of terms of the sequence that the function returns.
+
+    Returns
+    =======
+
+    L
+        The LFSR sequence defined by
+        `x_{n+1} = c_k x_n + \ldots + c_0 x_{n-k}`, for
+        `n \leq k`.
+
+    Notes
+    =====
+
+    S. Golomb [G]_ gives a list of three statistical properties a
+    sequence of numbers `a = \{a_n\}_{n=1}^\infty`,
+    `a_n \in \{0,1\}`, should display to be considered
+    "random". Define the autocorrelation of `a` to be
+
+    .. math::
+
+        C(k) = C(k,a) = \lim_{N\rightarrow \infty} {1\over N}\sum_{n=1}^N (-1)^{a_n + a_{n+k}}.
+
+    In the case where `a` is periodic with period
+    `P` then this reduces to
+
+    .. math::
+
+        C(k) = {1\over P}\sum_{n=1}^P (-1)^{a_n + a_{n+k}}.
+
+    Assume `a` is periodic with period `P`.
+
+    - balance:
+
+      .. math::
+
+        \left|\sum_{n=1}^P(-1)^{a_n}\right| \leq 1.
+
+    - low autocorrelation:
+
+       .. math::
+
+         C(k) = \left\{ \begin{array}{cc} 1,& k = 0,\\ \epsilon, & k \ne 0. \end{array} \right.
+
+      (For sequences satisfying these first two properties, it is known
+      that `\epsilon = -1/P` must hold.)
+
+    - proportional runs property: In each period, half the runs have
+      length `1`, one-fourth have length `2`, etc.
+      Moreover, there are as many runs of `1`'s as there are of
+      `0`'s.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import lfsr_sequence
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> lfsr_sequence(key, fill, 10)
+    [1 mod 2, 1 mod 2, 0 mod 2, 1 mod 2, 0 mod 2,
+    1 mod 2, 1 mod 2, 0 mod 2, 0 mod 2, 1 mod 2]
+
+    References
+    ==========
+
+    .. [G] Solomon Golomb, Shift register sequences, Aegean Park Press,
+       Laguna Hills, Ca, 1967
+
+    """
+    if not isinstance(key, list):
+        raise TypeError("key must be a list")
+    if not isinstance(fill, list):
+        raise TypeError("fill must be a list")
+    p = key[0].modulus()
+    F = FF(p)
+    s = fill
+    k = len(fill)
+    L = []
+    for i in range(n):
+        s0 = s[:]
+        L.append(s[0])
+        s = s[1:k]
+        x = sum(int(key[i]*s0[i]) for i in range(k))
+        s.append(F(x))
+    return L       # use [int(x) for x in L] for int version
+
+
+def lfsr_autocorrelation(L, P, k):
+    """
+    This function computes the LFSR autocorrelation function.
+
+    Parameters
+    ==========
+
+    L
+        A periodic sequence of elements of `GF(2)`.
+        L must have length larger than P.
+
+    P
+        The period of L.
+
+    k : int
+        An integer `k` (`0 < k < P`).
+
+    Returns
+    =======
+
+    autocorrelation
+        The k-th value of the autocorrelation of the LFSR L.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_autocorrelation)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_autocorrelation(s, 15, 7)
+    -1/15
+    >>> lfsr_autocorrelation(s, 15, 0)
+    1
+
+    """
+    if not isinstance(L, list):
+        raise TypeError("L (=%s) must be a list" % L)
+    P = int(P)
+    k = int(k)
+    L0 = L[:P]     # slices makes a copy
+    L1 = L0 + L0[:k]
+    L2 = [(-1)**(int(L1[i]) + int(L1[i + k])) for i in range(P)]
+    tot = sum(L2)
+    return Rational(tot, P)
+
+
+def lfsr_connection_polynomial(s):
+    """
+    This function computes the LFSR connection polynomial.
+
+    Parameters
+    ==========
+
+    s
+        A sequence of elements of even length, with entries in a finite
+        field.
+
+    Returns
+    =======
+
+    C(x)
+        The connection polynomial of a minimal LFSR yielding s.
+
+        This implements the algorithm in section 3 of J. L. Massey's
+        article [M]_.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     lfsr_sequence, lfsr_connection_polynomial)
+    >>> from sympy.polys.domains import FF
+    >>> F = FF(2)
+    >>> fill = [F(1), F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**4 + x + 1
+    >>> fill = [F(1), F(0), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(1), F(0)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x**2 + 1
+    >>> fill = [F(1), F(0), F(1)]
+    >>> key = [F(1), F(0), F(1)]
+    >>> s = lfsr_sequence(key, fill, 20)
+    >>> lfsr_connection_polynomial(s)
+    x**3 + x + 1
+
+    References
+    ==========
+
+    .. [M] James L. Massey, "Shift-Register Synthesis and BCH Decoding."
+        IEEE Trans. on Information Theory, vol. 15(1), pp. 122-127,
+        Jan 1969.
+
+    """
+    # Initialization:
+    p = s[0].modulus()
+    x = Symbol("x")
+    C = 1*x**0
+    B = 1*x**0
+    m = 1
+    b = 1*x**0
+    L = 0
+    N = 0
+    while N < len(s):
+        if L > 0:
+            dC = Poly(C).degree()
+            r = min(L + 1, dC + 1)
+            coeffsC = [C.subs(x, 0)] + [C.coeff(x**i)
+                for i in range(1, dC + 1)]
+            d = (int(s[N]) + sum(coeffsC[i]*int(s[N - i])
+                for i in range(1, r))) % p
+        if L == 0:
+            d = int(s[N])*x**0
+        if d == 0:
+            m += 1
+            N += 1
+        if d > 0:
+            if 2*L > N:
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                m += 1
+                N += 1
+            else:
+                T = C
+                C = (C - d*((b**(p - 2)) % p)*x**m*B).expand()
+                L = N + 1 - L
+                m = 1
+                b = d
+                B = T
+                N += 1
+    dC = Poly(C).degree()
+    coeffsC = [C.subs(x, 0)] + [C.coeff(x**i) for i in range(1, dC + 1)]
+    return sum(coeffsC[i] % p*x**i for i in range(dC + 1)
+        if coeffsC[i] is not None)
+
+
+#################### ElGamal  #############################
+
+
+def elgamal_private_key(digit=10, seed=None):
+    r"""
+    Return three number tuple as private key.
+
+    Explanation
+    ===========
+
+    Elgamal encryption is based on the mathematical problem
+    called the Discrete Logarithm Problem (DLP). For example,
+
+    `a^{b} \equiv c \pmod p`
+
+    In general, if ``a`` and ``b`` are known, ``ct`` is easily
+    calculated. If ``b`` is unknown, it is hard to use
+    ``a`` and ``ct`` to get ``b``.
+
+    Parameters
+    ==========
+
+    digit : int
+        Minimum number of binary digits for key.
+
+    Returns
+    =======
+
+    tuple : (p, r, d)
+        p = prime number.
+
+        r = primitive root.
+
+        d = random number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.ntheory import is_primitive_root, isprime
+    >>> a, b, _ = elgamal_private_key()
+    >>> isprime(a)
+    True
+    >>> is_primitive_root(b, a)
+    True
+
+    """
+    randrange = _randrange(seed)
+    p = nextprime(2**digit)
+    return p, primitive_root(p), randrange(2, p)
+
+
+def elgamal_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    Parameters
+    ==========
+
+    key : (p, r, e)
+        Tuple generated by ``elgamal_private_key``.
+
+    Returns
+    =======
+
+    tuple : (p, r, e)
+        `e = r**d \bmod p`
+
+        `d` is a random number in private key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import elgamal_public_key
+    >>> elgamal_public_key((1031, 14, 636))
+    (1031, 14, 212)
+
+    """
+    p, r, e = key
+    return p, r, pow(r, e, p)
+
+
+def encipher_elgamal(i, key, seed=None):
+    r"""
+    Encrypt message with public key.
+
+    Explanation
+    ===========
+
+    ``i`` is a plaintext message expressed as an integer.
+    ``key`` is public key (p, r, e). In order to encrypt
+    a message, a random number ``a`` in ``range(2, p)``
+    is generated and the encrypted message is returned as
+    `c_{1}` and `c_{2}` where:
+
+    `c_{1} \equiv r^{a} \pmod p`
+
+    `c_{2} \equiv m e^{a} \pmod p`
+
+    Parameters
+    ==========
+
+    msg
+        int of encoded message.
+
+    key
+        Public key.
+
+    Returns
+    =======
+
+    tuple : (c1, c2)
+        Encipher into two number.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_elgamal, elgamal_private_key, elgamal_public_key
+    >>> pri = elgamal_private_key(5, seed=[3]); pri
+    (37, 2, 3)
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 36
+    >>> encipher_elgamal(msg, pub, seed=[3])
+    (8, 6)
+
+    """
+    p, r, e = key
+    if i < 0 or i >= p:
+        raise ValueError(
+            'Message (%s) should be in range(%s)' % (i, p))
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return pow(r, a, p), i*pow(e, a, p) % p
+
+
+def decipher_elgamal(msg, key):
+    r"""
+    Decrypt message with private key.
+
+    `msg = (c_{1}, c_{2})`
+
+    `key = (p, r, d)`
+
+    According to extended Eucliden theorem,
+    `u c_{1}^{d} + p n = 1`
+
+    `u \equiv 1/{{c_{1}}^d} \pmod p`
+
+    `u c_{2} \equiv \frac{1}{c_{1}^d} c_{2} \equiv \frac{1}{r^{ad}} c_{2} \pmod p`
+
+    `\frac{1}{r^{ad}} m e^a \equiv \frac{1}{r^{ad}} m {r^{d a}} \equiv m \pmod p`
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_elgamal
+    >>> from sympy.crypto.crypto import encipher_elgamal
+    >>> from sympy.crypto.crypto import elgamal_private_key
+    >>> from sympy.crypto.crypto import elgamal_public_key
+
+    >>> pri = elgamal_private_key(5, seed=[3])
+    >>> pub = elgamal_public_key(pri); pub
+    (37, 2, 8)
+    >>> msg = 17
+    >>> decipher_elgamal(encipher_elgamal(msg, pub), pri) == msg
+    True
+
+    """
+    p, _, d = key
+    c1, c2 = msg
+    u = pow(c1, -d, p)
+    return u * c2 % p
+
+
+################ Diffie-Hellman Key Exchange  #########################
+
+def dh_private_key(digit=10, seed=None):
+    r"""
+    Return three integer tuple as private key.
+
+    Explanation
+    ===========
+
+    Diffie-Hellman key exchange is based on the mathematical problem
+    called the Discrete Logarithm Problem (see ElGamal).
+
+    Diffie-Hellman key exchange is divided into the following steps:
+
+    *   Alice and Bob agree on a base that consist of a prime ``p``
+        and a primitive root of ``p`` called ``g``
+    *   Alice choses a number ``a`` and Bob choses a number ``b`` where
+        ``a`` and ``b`` are random numbers in range `[2, p)`. These are
+        their private keys.
+    *   Alice then publicly sends Bob `g^{a} \pmod p` while Bob sends
+        Alice `g^{b} \pmod p`
+    *   They both raise the received value to their secretly chosen
+        number (``a`` or ``b``) and now have both as their shared key
+        `g^{ab} \pmod p`
+
+    Parameters
+    ==========
+
+    digit
+        Minimum number of binary digits required in key.
+
+    Returns
+    =======
+
+    tuple : (p, g, a)
+        p = prime number.
+
+        g = primitive root of p.
+
+        a = random number from 2 through p - 1.
+
+    Notes
+    =====
+
+    For testing purposes, the ``seed`` parameter may be set to control
+    the output of this routine. See sympy.core.random._randrange.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key
+    >>> from sympy.ntheory import isprime, is_primitive_root
+    >>> p, g, _ = dh_private_key()
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+    >>> p, g, _ = dh_private_key(5)
+    >>> isprime(p)
+    True
+    >>> is_primitive_root(g, p)
+    True
+
+    """
+    p = nextprime(2**digit)
+    g = primitive_root(p)
+    randrange = _randrange(seed)
+    a = randrange(2, p)
+    return p, g, a
+
+
+def dh_public_key(key):
+    r"""
+    Return three number tuple as public key.
+
+    This is the tuple that Alice sends to Bob.
+
+    Parameters
+    ==========
+
+    key : (p, g, a)
+        A tuple generated by ``dh_private_key``.
+
+    Returns
+    =======
+
+    tuple : int, int, int
+        A tuple of `(p, g, g^a \mod p)` with `p`, `g` and `a` given as
+        parameters.s
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import dh_private_key, dh_public_key
+    >>> p, g, a = dh_private_key();
+    >>> _p, _g, x = dh_public_key((p, g, a))
+    >>> p == _p and g == _g
+    True
+    >>> x == pow(g, a, p)
+    True
+
+    """
+    p, g, a = key
+    return p, g, pow(g, a, p)
+
+
+def dh_shared_key(key, b):
+    """
+    Return an integer that is the shared key.
+
+    This is what Bob and Alice can both calculate using the public
+    keys they received from each other and their private keys.
+
+    Parameters
+    ==========
+
+    key : (p, g, x)
+        Tuple `(p, g, x)` generated by ``dh_public_key``.
+
+    b
+        Random number in the range of `2` to `p - 1`
+        (Chosen by second key exchange member (Bob)).
+
+    Returns
+    =======
+
+    int
+        A shared key.
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import (
+    ...     dh_private_key, dh_public_key, dh_shared_key)
+    >>> prk = dh_private_key();
+    >>> p, g, x = dh_public_key(prk);
+    >>> sk = dh_shared_key((p, g, x), 1000)
+    >>> sk == pow(x, 1000, p)
+    True
+
+    """
+    p, _, x = key
+    if 1 >= b or b >= p:
+        raise ValueError(filldedent('''
+            Value of b should be greater 1 and less
+            than prime %s.''' % p))
+
+    return pow(x, b, p)
+
+
+################ Goldwasser-Micali Encryption  #########################
+
+
+def _legendre(a, p):
+    """
+    Returns the legendre symbol of a and p
+    assuming that p is a prime.
+
+    i.e. 1 if a is a quadratic residue mod p
+        -1 if a is not a quadratic residue mod p
+         0 if a is divisible by p
+
+    Parameters
+    ==========
+
+    a : int
+        The number to test.
+
+    p : prime
+        The prime to test ``a`` against.
+
+    Returns
+    =======
+
+    int
+        Legendre symbol (a / p).
+
+    """
+    sig = pow(a, (p - 1)//2, p)
+    if sig == 1:
+        return 1
+    elif sig == 0:
+        return 0
+    else:
+        return -1
+
+
+def _random_coprime_stream(n, seed=None):
+    randrange = _randrange(seed)
+    while True:
+        y = randrange(n)
+        if gcd(y, n) == 1:
+            yield y
+
+
+def gm_private_key(p, q, a=None):
+    r"""
+    Check if ``p`` and ``q`` can be used as private keys for
+    the Goldwasser-Micali encryption. The method works
+    roughly as follows.
+
+    Explanation
+    ===========
+
+    #. Pick two large primes $p$ and $q$.
+    #. Call their product $N$.
+    #. Given a message as an integer $i$, write $i$ in its bit representation $b_0, \dots, b_n$.
+    #. For each $k$,
+
+     if $b_k = 0$:
+        let $a_k$ be a random square
+        (quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+     if $b_k = 1$:
+        let $a_k$ be a random non-square
+        (non-quadratic residue) modulo $p q$
+        such that ``jacobi_symbol(a, p*q) = 1``
+
+    returns $\left[a_1, a_2, \dots\right]$
+
+    $b_k$ can be recovered by checking whether or not
+    $a_k$ is a residue. And from the $b_k$'s, the message
+    can be reconstructed.
+
+    The idea is that, while ``jacobi_symbol(a, p*q)``
+    can be easily computed (and when it is equal to $-1$ will
+    tell you that $a$ is not a square mod $p q$), quadratic
+    residuosity modulo a composite number is hard to compute
+    without knowing its factorization.
+
+    Moreover, approximately half the numbers coprime to $p q$ have
+    :func:`~.jacobi_symbol` equal to $1$ . And among those, approximately half
+    are residues and approximately half are not. This maximizes the
+    entropy of the code.
+
+    Parameters
+    ==========
+
+    p, q, a
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (p, q)
+        The input value ``p`` and ``q``.
+
+    Raises
+    ======
+
+    ValueError
+        If ``p`` and ``q`` are not distinct odd primes.
+
+    """
+    if p == q:
+        raise ValueError("expected distinct primes, "
+                         "got two copies of %i" % p)
+    elif not isprime(p) or not isprime(q):
+        raise ValueError("first two arguments must be prime, "
+                         "got %i of %i" % (p, q))
+    elif p == 2 or q == 2:
+        raise ValueError("first two arguments must not be even, "
+                         "got %i of %i" % (p, q))
+    return p, q
+
+
+def gm_public_key(p, q, a=None, seed=None):
+    """
+    Compute public keys for ``p`` and ``q``.
+    Note that in Goldwasser-Micali Encryption,
+    public keys are randomly selected.
+
+    Parameters
+    ==========
+
+    p, q, a : int, int, int
+        Initialization variables.
+
+    Returns
+    =======
+
+    tuple : (a, N)
+        ``a`` is the input ``a`` if it is not ``None`` otherwise
+        some random integer coprime to ``p`` and ``q``.
+
+        ``N`` is the product of ``p`` and ``q``.
+
+    """
+
+    p, q = gm_private_key(p, q)
+    N = p * q
+
+    if a is None:
+        randrange = _randrange(seed)
+        while True:
+            a = randrange(N)
+            if _legendre(a, p) == _legendre(a, q) == -1:
+                break
+    else:
+        if _legendre(a, p) != -1 or _legendre(a, q) != -1:
+            return False
+    return (a, N)
+
+
+def encipher_gm(i, key, seed=None):
+    """
+    Encrypt integer 'i' using public_key 'key'
+    Note that gm uses random encryption.
+
+    Parameters
+    ==========
+
+    i : int
+        The message to encrypt.
+
+    key : (a, N)
+        The public key.
+
+    Returns
+    =======
+
+    list : list of int
+        The randomized encrypted message.
+
+    """
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+    a, N = key
+    bits = []
+    while i > 0:
+        bits.append(i % 2)
+        i //= 2
+
+    gen = _random_coprime_stream(N, seed)
+    rev = reversed(bits)
+    encode = lambda b: next(gen)**2*pow(a, b) % N
+    return [ encode(b) for b in rev ]
+
+
+
+def decipher_gm(message, key):
+    """
+    Decrypt message 'message' using public_key 'key'.
+
+    Parameters
+    ==========
+
+    message : list of int
+        The randomized encrypted message.
+
+    key : (p, q)
+        The private key.
+
+    Returns
+    =======
+
+    int
+        The encrypted message.
+
+    """
+    p, q = key
+    res = lambda m, p: _legendre(m, p) > 0
+    bits = [res(m, p) * res(m, q) for m in message]
+    m = 0
+    for b in bits:
+        m <<= 1
+        m += not b
+    return m
+
+
+
+########### RailFence Cipher #############
+
+def encipher_railfence(message,rails):
+    """
+    Performs Railfence Encryption on plaintext and returns ciphertext
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import encipher_railfence
+    >>> message = "hello world"
+    >>> encipher_railfence(message,3)
+    'horel ollwd'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Encrypted string message.
+
+    References
+    ==========
+    .. [1] https://en.wikipedia.org/wiki/Rail_fence_cipher
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+    return ''.join(sorted(message, key=lambda i: next(p)))
+
+
+def decipher_railfence(ciphertext,rails):
+    """
+    Decrypt the message using the given rails
+
+    Examples
+    ========
+
+    >>> from sympy.crypto.crypto import decipher_railfence
+    >>> decipher_railfence("horel ollwd",3)
+    'hello world'
+
+    Parameters
+    ==========
+
+    message : string, the message to encrypt.
+    rails : int, the number of rails.
+
+    Returns
+    =======
+
+    The Decrypted string message.
+
+    """
+    r = list(range(rails))
+    p = cycle(r + r[-2:0:-1])
+
+    idx = sorted(range(len(ciphertext)), key=lambda i: next(p))
+    res = [''] * len(ciphertext)
+    for i, c in zip(idx, ciphertext):
+        res[i] = c
+    return ''.join(res)
+
+
+################ Blum-Goldwasser cryptosystem  #########################
+
+def bg_private_key(p, q):
+    """
+    Check if p and q can be used as private keys for
+    the Blum-Goldwasser cryptosystem.
+
+    Explanation
+    ===========
+
+    The three necessary checks for p and q to pass
+    so that they can be used as private keys:
+
+        1. p and q must both be prime
+        2. p and q must be distinct
+        3. p and q must be congruent to 3 mod 4
+
+    Parameters
+    ==========
+
+    p, q
+        The keys to be checked.
+
+    Returns
+    =======
+
+    p, q
+        Input values.
+
+    Raises
+    ======
+
+    ValueError
+        If p and q do not pass the above conditions.
+
+    """
+
+    if not isprime(p) or not isprime(q):
+        raise ValueError("the two arguments must be prime, "
+                         "got %i and %i" %(p, q))
+    elif p == q:
+        raise ValueError("the two arguments must be distinct, "
+                         "got two copies of %i. " %p)
+    elif (p - 3) % 4 != 0 or (q - 3) % 4 != 0:
+        raise ValueError("the two arguments must be congruent to 3 mod 4, "
+                         "got %i and %i" %(p, q))
+    return p, q
+
+def bg_public_key(p, q):
+    """
+    Calculates public keys from private keys.
+
+    Explanation
+    ===========
+
+    The function first checks the validity of
+    private keys passed as arguments and
+    then returns their product.
+
+    Parameters
+    ==========
+
+    p, q
+        The private keys.
+
+    Returns
+    =======
+
+    N
+        The public key.
+
+    """
+    p, q = bg_private_key(p, q)
+    N = p * q
+    return N
+
+def encipher_bg(i, key, seed=None):
+    """
+    Encrypts the message using public key and seed.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Encodes i as a string of L bits, m.
+        2. Select a random element r, where 1 < r < key, and computes
+           x = r^2 mod key.
+        3. Use BBS pseudo-random number generator to generate L random bits, b,
+        using the initial seed as x.
+        4. Encrypted message, c_i = m_i XOR b_i, 1 <= i <= L.
+        5. x_L = x^(2^L) mod key.
+        6. Return (c, x_L)
+
+    Parameters
+    ==========
+
+    i
+        Message, a non-negative integer
+
+    key
+        The public key
+
+    Returns
+    =======
+
+    Tuple
+        (encrypted_message, x_L)
+
+    Raises
+    ======
+
+    ValueError
+        If i is negative.
+
+    """
+
+    if i < 0:
+        raise ValueError(
+            "message must be a non-negative "
+            "integer: got %d instead" % i)
+
+    enc_msg = []
+    while i > 0:
+        enc_msg.append(i % 2)
+        i //= 2
+    enc_msg.reverse()
+    L = len(enc_msg)
+
+    r = _randint(seed)(2, key - 1)
+    x = r**2 % key
+    x_L = pow(int(x), int(2**L), int(key))
+
+    rand_bits = []
+    for _ in range(L):
+        rand_bits.append(x % 2)
+        x = x**2 % key
+
+    encrypt_msg = [m ^ b for (m, b) in zip(enc_msg, rand_bits)]
+
+    return (encrypt_msg, x_L)
+
+def decipher_bg(message, key):
+    """
+    Decrypts the message using private keys.
+
+    Explanation
+    ===========
+
+    ALGORITHM:
+        1. Let, c be the encrypted message, y the second number received,
+        and p and q be the private keys.
+        2. Compute, r_p = y^((p+1)/4 ^ L) mod p and
+        r_q = y^((q+1)/4 ^ L) mod q.
+        3. Compute x_0 = (q(q^-1 mod p)r_p + p(p^-1 mod q)r_q) mod N.
+        4. From, recompute the bits using the BBS generator, as in the
+        encryption algorithm.
+        5. Compute original message by XORing c and b.
+
+    Parameters
+    ==========
+
+    message
+        Tuple of encrypted message and a non-negative integer.
+
+    key
+        Tuple of private keys.
+
+    Returns
+    =======
+
+    orig_msg
+        The original message
+
+    """
+
+    p, q = key
+    encrypt_msg, y = message
+    public_key = p * q
+    L = len(encrypt_msg)
+    p_t = ((p + 1)/4)**L
+    q_t = ((q + 1)/4)**L
+    r_p = pow(int(y), int(p_t), int(p))
+    r_q = pow(int(y), int(q_t), int(q))
+
+    x = (q * invert(q, p) * r_p + p * invert(p, q) * r_q) % public_key
+
+    orig_bits = []
+    for _ in range(L):
+        orig_bits.append(x % 2)
+        x = x**2 % public_key
+
+    orig_msg = 0
+    for (m, b) in zip(encrypt_msg, orig_bits):
+        orig_msg = orig_msg * 2
+        orig_msg += (m ^ b)
+
+    return orig_msg
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..086ee5824747ca91e16cc15484dfc8d1be0d624d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/test_crypto.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/test_crypto.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..243bbf7a76f3c2e442ff01155fccf07a69f06eb3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/__pycache__/test_crypto.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/crypto/tests/test_crypto.py b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/test_crypto.py
new file mode 100644
index 0000000000000000000000000000000000000000..c671138f9a61325f6e65cc7cafddc7cd46f19229
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/crypto/tests/test_crypto.py
@@ -0,0 +1,562 @@
+from sympy.core import symbols
+from sympy.crypto.crypto import (cycle_list,
+      encipher_shift, encipher_affine, encipher_substitution,
+      check_and_join, encipher_vigenere, decipher_vigenere,
+      encipher_hill, decipher_hill, encipher_bifid5, encipher_bifid6,
+      bifid5_square, bifid6_square, bifid5, bifid6,
+      decipher_bifid5, decipher_bifid6, encipher_kid_rsa,
+      decipher_kid_rsa, kid_rsa_private_key, kid_rsa_public_key,
+      decipher_rsa, rsa_private_key, rsa_public_key, encipher_rsa,
+      lfsr_connection_polynomial, lfsr_autocorrelation, lfsr_sequence,
+      encode_morse, decode_morse, elgamal_private_key, elgamal_public_key,
+      encipher_elgamal, decipher_elgamal, dh_private_key, dh_public_key,
+      dh_shared_key, decipher_shift, decipher_affine, encipher_bifid,
+      decipher_bifid, bifid_square, padded_key, uniq, decipher_gm,
+      encipher_gm, gm_public_key, gm_private_key, encipher_bg, decipher_bg,
+      bg_private_key, bg_public_key, encipher_rot13, decipher_rot13,
+      encipher_atbash, decipher_atbash, NonInvertibleCipherWarning,
+      encipher_railfence, decipher_railfence)
+from sympy.external.gmpy import gcd
+from sympy.matrices import Matrix
+from sympy.ntheory import isprime, is_primitive_root
+from sympy.polys.domains import FF
+
+from sympy.testing.pytest import raises, warns
+
+from sympy.core.random import randrange
+
+def test_encipher_railfence():
+    assert encipher_railfence("hello world",2) == "hlowrdel ol"
+    assert encipher_railfence("hello world",3) == "horel ollwd"
+    assert encipher_railfence("hello world",4) == "hwe olordll"
+
+def test_decipher_railfence():
+    assert decipher_railfence("hlowrdel ol",2) == "hello world"
+    assert decipher_railfence("horel ollwd",3) == "hello world"
+    assert decipher_railfence("hwe olordll",4) == "hello world"
+
+
+def test_cycle_list():
+    assert cycle_list(3, 4) == [3, 0, 1, 2]
+    assert cycle_list(-1, 4) == [3, 0, 1, 2]
+    assert cycle_list(1, 4) == [1, 2, 3, 0]
+
+
+def test_encipher_shift():
+    assert encipher_shift("ABC", 0) == "ABC"
+    assert encipher_shift("ABC", 1) == "BCD"
+    assert encipher_shift("ABC", -1) == "ZAB"
+    assert decipher_shift("ZAB", -1) == "ABC"
+
+def test_encipher_rot13():
+    assert encipher_rot13("ABC") == "NOP"
+    assert encipher_rot13("NOP") == "ABC"
+    assert decipher_rot13("ABC") == "NOP"
+    assert decipher_rot13("NOP") == "ABC"
+
+
+def test_encipher_affine():
+    assert encipher_affine("ABC", (1, 0)) == "ABC"
+    assert encipher_affine("ABC", (1, 1)) == "BCD"
+    assert encipher_affine("ABC", (-1, 0)) == "AZY"
+    assert encipher_affine("ABC", (-1, 1), symbols="ABCD") == "BAD"
+    assert encipher_affine("123", (-1, 1), symbols="1234") == "214"
+    assert encipher_affine("ABC", (3, 16)) == "QTW"
+    assert decipher_affine("QTW", (3, 16)) == "ABC"
+
+def test_encipher_atbash():
+    assert encipher_atbash("ABC") == "ZYX"
+    assert encipher_atbash("ZYX") == "ABC"
+    assert decipher_atbash("ABC") == "ZYX"
+    assert decipher_atbash("ZYX") == "ABC"
+
+def test_encipher_substitution():
+    assert encipher_substitution("ABC", "BAC", "ABC") == "BAC"
+    assert encipher_substitution("123", "1243", "1234") == "124"
+
+
+def test_check_and_join():
+    assert check_and_join("abc") == "abc"
+    assert check_and_join(uniq("aaabc")) == "abc"
+    assert check_and_join("ab c".split()) == "abc"
+    assert check_and_join("abc", "a", filter=True) == "a"
+    raises(ValueError, lambda: check_and_join('ab', 'a'))
+
+
+def test_encipher_vigenere():
+    assert encipher_vigenere("ABC", "ABC") == "ACE"
+    assert encipher_vigenere("ABC", "ABC", symbols="ABCD") == "ACA"
+    assert encipher_vigenere("ABC", "AB", symbols="ABCD") == "ACC"
+    assert encipher_vigenere("AB", "ABC", symbols="ABCD") == "AC"
+    assert encipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_decipher_vigenere():
+    assert decipher_vigenere("ABC", "ABC") == "AAA"
+    assert decipher_vigenere("ABC", "ABC", symbols="ABCD") == "AAA"
+    assert decipher_vigenere("ABC", "AB", symbols="ABCD") == "AAC"
+    assert decipher_vigenere("AB", "ABC", symbols="ABCD") == "AA"
+    assert decipher_vigenere("A", "ABC", symbols="ABCD") == "A"
+
+
+def test_encipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A) == "CFIV"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert encipher_hill("ABCD", A) == "ABCD"
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert encipher_hill("ABCD", A, symbols="ABCD") == "CBAB"
+    assert encipher_hill("AB", A, symbols="ABCD") == "CB"
+    # message length, n, does not need to be a multiple of k;
+    # it is padded
+    assert encipher_hill("ABA", A) == "CFGC"
+    assert encipher_hill("ABA", A, pad="Z") == "CFYV"
+
+
+def test_decipher_hill():
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CFIV", A) == "ABCD"
+    A = Matrix(2, 2, [1, 0, 0, 1])
+    assert decipher_hill("ABCD", A) == "ABCD"
+    assert decipher_hill("ABCD", A, symbols="ABCD") == "ABCD"
+    A = Matrix(2, 2, [1, 2, 3, 5])
+    assert decipher_hill("CBAB", A, symbols="ABCD") == "ABCD"
+    assert decipher_hill("CB", A, symbols="ABCD") == "AB"
+    # n does not need to be a multiple of k
+    assert decipher_hill("CFA", A) == "ABAA"
+
+
+def test_encipher_bifid5():
+    assert encipher_bifid5("AB", "AB") == "AB"
+    assert encipher_bifid5("AB", "CD") == "CO"
+    assert encipher_bifid5("ab", "c") == "CH"
+    assert encipher_bifid5("a bc", "b") == "BAC"
+
+
+def test_bifid5_square():
+    A = bifid5
+    f = lambda i, j: symbols(A[5*i + j])
+    M = Matrix(5, 5, f)
+    assert bifid5_square("") == M
+
+
+def test_decipher_bifid5():
+    assert decipher_bifid5("AB", "AB") == "AB"
+    assert decipher_bifid5("CO", "CD") == "AB"
+    assert decipher_bifid5("ch", "c") == "AB"
+    assert decipher_bifid5("b ac", "b") == "ABC"
+
+
+def test_encipher_bifid6():
+    assert encipher_bifid6("AB", "AB") == "AB"
+    assert encipher_bifid6("AB", "CD") == "CP"
+    assert encipher_bifid6("ab", "c") == "CI"
+    assert encipher_bifid6("a bc", "b") == "BAC"
+
+
+def test_decipher_bifid6():
+    assert decipher_bifid6("AB", "AB") == "AB"
+    assert decipher_bifid6("CP", "CD") == "AB"
+    assert decipher_bifid6("ci", "c") == "AB"
+    assert decipher_bifid6("b ac", "b") == "ABC"
+
+
+def test_bifid6_square():
+    A = bifid6
+    f = lambda i, j: symbols(A[6*i + j])
+    M = Matrix(6, 6, f)
+    assert bifid6_square("") == M
+
+
+def test_rsa_public_key():
+    assert rsa_public_key(2, 3, 1) == (6, 1)
+    assert rsa_public_key(5, 3, 3) == (15, 3)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_public_key(2, 2, 1) == (4, 1)
+        assert rsa_public_key(8, 8, 8) is False
+
+
+def test_rsa_private_key():
+    assert rsa_private_key(2, 3, 1) == (6, 1)
+    assert rsa_private_key(5, 3, 3) == (15, 3)
+    assert rsa_private_key(23,29,5) == (667,493)
+
+    with warns(NonInvertibleCipherWarning):
+        assert rsa_private_key(2, 2, 1) == (4, 1)
+        assert rsa_private_key(8, 8, 8) is False
+
+
+def test_rsa_large_key():
+    # Sample from
+    # http://www.herongyang.com/Cryptography/JCE-Public-Key-RSA-Private-Public-Key-Pair-Sample.html
+    p = int('101565610013301240713207239558950144682174355406589305284428666'\
+        '903702505233009')
+    q = int('894687191887545488935455605955948413812376003053143521429242133'\
+        '12069293984003')
+    e = int('65537')
+    d = int('893650581832704239530398858744759129594796235440844479456143566'\
+        '6999402846577625762582824202269399672579058991442587406384754958587'\
+        '400493169361356902030209')
+    assert rsa_public_key(p, q, e) == (p*q, e)
+    assert rsa_private_key(p, q, e) == (p*q, d)
+
+
+def test_encipher_rsa():
+    puk = rsa_public_key(2, 3, 1)
+    assert encipher_rsa(2, puk) == 2
+    puk = rsa_public_key(5, 3, 3)
+    assert encipher_rsa(2, puk) == 8
+
+    with warns(NonInvertibleCipherWarning):
+        puk = rsa_public_key(2, 2, 1)
+        assert encipher_rsa(2, puk) == 2
+
+
+def test_decipher_rsa():
+    prk = rsa_private_key(2, 3, 1)
+    assert decipher_rsa(2, prk) == 2
+    prk = rsa_private_key(5, 3, 3)
+    assert decipher_rsa(8, prk) == 2
+
+    with warns(NonInvertibleCipherWarning):
+        prk = rsa_private_key(2, 2, 1)
+        assert decipher_rsa(2, prk) == 2
+
+
+def test_mutltiprime_rsa_full_example():
+    # Test example from
+    # https://iopscience.iop.org/article/10.1088/1742-6596/995/1/012030
+    puk = rsa_public_key(2, 3, 5, 7, 11, 13, 7)
+    prk = rsa_private_key(2, 3, 5, 7, 11, 13, 7)
+    assert puk == (30030, 7)
+    assert prk == (30030, 823)
+
+    msg = 10
+    encrypted = encipher_rsa(2 * msg - 15, puk)
+    assert encrypted == 18065
+    decrypted = (decipher_rsa(encrypted, prk) + 15) / 2
+    assert decrypted == msg
+
+    # Test example from
+    # https://www.scirp.org/pdf/JCC_2018032215502008.pdf
+    puk1 = rsa_public_key(53, 41, 43, 47, 41)
+    prk1 = rsa_private_key(53, 41, 43, 47, 41)
+    puk2 = rsa_public_key(53, 41, 43, 47, 97)
+    prk2 = rsa_private_key(53, 41, 43, 47, 97)
+
+    assert puk1 == (4391633, 41)
+    assert prk1 == (4391633, 294041)
+    assert puk2 == (4391633, 97)
+    assert prk2 == (4391633, 455713)
+
+    msg = 12321
+    encrypted = encipher_rsa(encipher_rsa(msg, puk1), puk2)
+    assert encrypted == 1081588
+    decrypted = decipher_rsa(decipher_rsa(encrypted, prk2), prk1)
+    assert decrypted == msg
+
+
+def test_rsa_crt_extreme():
+    p = int(
+        '10177157607154245068023861503693082120906487143725062283406501' \
+        '54082258226204046999838297167140821364638180697194879500245557' \
+        '65445186962893346463841419427008800341257468600224049986260471' \
+        '92257248163014468841725476918639415726709736077813632961290911' \
+        '0256421232977833028677441206049309220354796014376698325101693')
+
+    q = int(
+        '28752342353095132872290181526607275886182793241660805077850801' \
+        '75689512797754286972952273553128181861830576836289738668745250' \
+        '34028199691128870676414118458442900035778874482624765513861643' \
+        '27966696316822188398336199002306588703902894100476186823849595' \
+        '103239410527279605442148285816149368667083114802852804976893')
+
+    r = int(
+        '17698229259868825776879500736350186838850961935956310134378261' \
+        '89771862186717463067541369694816245225291921138038800171125596' \
+        '07315449521981157084370187887650624061033066022458512942411841' \
+        '18747893789972315277160085086164119879536041875335384844820566' \
+        '0287479617671726408053319619892052000850883994343378882717849')
+
+    s = int(
+        '68925428438585431029269182233502611027091755064643742383515623' \
+        '64321310582896893395529367074942808353187138794422745718419645' \
+        '28291231865157212604266903677599180789896916456120289112752835' \
+        '98502265889669730331688206825220074713977607415178738015831030' \
+        '364290585369150502819743827343552098197095520550865360159439'
+    )
+
+    t = int(
+        '69035483433453632820551311892368908779778144568711455301541094' \
+        '31487047642322695357696860925747923189635033183069823820910521' \
+        '71172909106797748883261493224162414050106920442445896819806600' \
+        '15448444826108008217972129130625571421904893252804729877353352' \
+        '739420480574842850202181462656251626522910618936534699566291'
+    )
+
+    e = 65537
+    puk = rsa_public_key(p, q, r, s, t, e)
+    prk = rsa_private_key(p, q, r, s, t, e)
+
+    plaintext = 1000
+    ciphertext_1 = encipher_rsa(plaintext, puk)
+    ciphertext_2 = encipher_rsa(plaintext, puk, [p, q, r, s, t])
+    assert ciphertext_1 == ciphertext_2
+    assert decipher_rsa(ciphertext_1, prk) == \
+        decipher_rsa(ciphertext_1, prk, [p, q, r, s, t])
+
+
+def test_rsa_exhaustive():
+    p, q = 61, 53
+    e = 17
+    puk = rsa_public_key(p, q, e, totient='Carmichael')
+    prk = rsa_private_key(p, q, e, totient='Carmichael')
+
+    for msg in range(puk[0]):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multiprime_exhanstive():
+    primes = [3, 5, 7, 11]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, totient='Carmichael')
+    prk = rsa_private_key(*args, totient='Carmichael')
+    n = puk[0]
+
+    for msg in range(n):
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_rsa_multipower_exhanstive():
+    primes = [5, 5, 7]
+    e = 7
+    args = primes + [e]
+    puk = rsa_public_key(*args, multipower=True)
+    prk = rsa_private_key(*args, multipower=True)
+    n = puk[0]
+
+    for msg in range(n):
+        if gcd(msg, n) != 1:
+            continue
+
+        encrypted = encipher_rsa(msg, puk)
+        decrypted = decipher_rsa(encrypted, prk)
+        try:
+            assert decrypted == msg
+        except AssertionError:
+            raise AssertionError(
+                "The RSA is not correctly decrypted " \
+                "(Original : {}, Encrypted : {}, Decrypted : {})" \
+                .format(msg, encrypted, decrypted)
+                )
+
+
+def test_kid_rsa_public_key():
+    assert kid_rsa_public_key(1, 2, 1, 1) == (5, 2)
+    assert kid_rsa_public_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_public_key(1, 2, 1, 2) == (7, 2)
+
+
+def test_kid_rsa_private_key():
+    assert kid_rsa_private_key(1, 2, 1, 1) == (5, 3)
+    assert kid_rsa_private_key(1, 2, 2, 1) == (8, 3)
+    assert kid_rsa_private_key(1, 2, 1, 2) == (7, 4)
+
+
+def test_encipher_kid_rsa():
+    assert encipher_kid_rsa(1, (5, 2)) == 2
+    assert encipher_kid_rsa(1, (8, 3)) == 3
+    assert encipher_kid_rsa(1, (7, 2)) == 2
+
+
+def test_decipher_kid_rsa():
+    assert decipher_kid_rsa(2, (5, 3)) == 1
+    assert decipher_kid_rsa(3, (8, 3)) == 1
+    assert decipher_kid_rsa(2, (7, 4)) == 1
+
+
+def test_encode_morse():
+    assert encode_morse('ABC') == '.-|-...|-.-.'
+    assert encode_morse('SMS ') == '...|--|...||'
+    assert encode_morse('SMS\n') == '...|--|...||'
+    assert encode_morse('') == ''
+    assert encode_morse(' ') == '||'
+    assert encode_morse(' ', sep='`') == '``'
+    assert encode_morse(' ', sep='``') == '````'
+    assert encode_morse('!@#$%^&*()_+') == '-.-.--|.--.-.|...-..-|-.--.|-.--.-|..--.-|.-.-.'
+    assert encode_morse('12345') == '.----|..---|...--|....-|.....'
+    assert encode_morse('67890') == '-....|--...|---..|----.|-----'
+
+
+def test_decode_morse():
+    assert decode_morse('-.-|.|-.--') == 'KEY'
+    assert decode_morse('.-.|..-|-.||') == 'RUN'
+    raises(KeyError, lambda: decode_morse('.....----'))
+
+
+def test_lfsr_sequence():
+    raises(TypeError, lambda: lfsr_sequence(1, [1], 1))
+    raises(TypeError, lambda: lfsr_sequence([1], 1, 1))
+    F = FF(2)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(1)], 2) == [F(1), F(0)]
+    F = FF(3)
+    assert lfsr_sequence([F(1)], [F(1)], 2) == [F(1), F(1)]
+    assert lfsr_sequence([F(0)], [F(2)], 2) == [F(2), F(0)]
+    assert lfsr_sequence([F(1)], [F(2)], 2) == [F(2), F(2)]
+
+
+def test_lfsr_autocorrelation():
+    raises(TypeError, lambda: lfsr_autocorrelation(1, 2, 3))
+    F = FF(2)
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_autocorrelation(s, 2, 0) == 1
+    assert lfsr_autocorrelation(s, 2, 1) == -1
+
+
+def test_lfsr_connection_polynomial():
+    F = FF(2)
+    x = symbols("x")
+    s = lfsr_sequence([F(1), F(0)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + 1
+    s = lfsr_sequence([F(1), F(1)], [F(0), F(1)], 5)
+    assert lfsr_connection_polynomial(s) == x**2 + x + 1
+
+
+def test_elgamal_private_key():
+    a, b, _ = elgamal_private_key(digit=100)
+    assert isprime(a)
+    assert is_primitive_root(b, a)
+    assert len(bin(a)) >= 102
+
+
+def test_elgamal():
+    dk = elgamal_private_key(5)
+    ek = elgamal_public_key(dk)
+    P = ek[0]
+    assert P - 1 == decipher_elgamal(encipher_elgamal(P - 1, ek), dk)
+    raises(ValueError, lambda: encipher_elgamal(P, dk))
+    raises(ValueError, lambda: encipher_elgamal(-1, dk))
+
+
+def test_dh_private_key():
+    p, g, _ = dh_private_key(digit = 100)
+    assert isprime(p)
+    assert is_primitive_root(g, p)
+    assert len(bin(p)) >= 102
+
+
+def test_dh_public_key():
+    p1, g1, a = dh_private_key(digit = 100)
+    p2, g2, ga = dh_public_key((p1, g1, a))
+    assert p1 == p2
+    assert g1 == g2
+    assert ga == pow(g1, a, p1)
+
+
+def test_dh_shared_key():
+    prk = dh_private_key(digit = 100)
+    p, _, ga = dh_public_key(prk)
+    b = randrange(2, p)
+    sk = dh_shared_key((p, _, ga), b)
+    assert sk == pow(ga, b, p)
+    raises(ValueError, lambda: dh_shared_key((1031, 14, 565), 2000))
+
+
+def test_padded_key():
+    assert padded_key('b', 'ab') == 'ba'
+    raises(ValueError, lambda: padded_key('ab', 'ace'))
+    raises(ValueError, lambda: padded_key('ab', 'abba'))
+
+
+def test_bifid():
+    raises(ValueError, lambda: encipher_bifid('abc', 'b', 'abcde'))
+    assert encipher_bifid('abc', 'b', 'abcd') == 'bdb'
+    raises(ValueError, lambda: decipher_bifid('bdb', 'b', 'abcde'))
+    assert encipher_bifid('bdb', 'b', 'abcd') == 'abc'
+    raises(ValueError, lambda: bifid_square('abcde'))
+    assert bifid5_square("B") == \
+        bifid5_square('BACDEFGHIKLMNOPQRSTUVWXYZ')
+    assert bifid6_square('B0') == \
+        bifid6_square('B0ACDEFGHIJKLMNOPQRSTUVWXYZ123456789')
+
+
+def test_encipher_decipher_gm():
+    ps = [131, 137, 139, 149, 151, 157, 163, 167,
+          173, 179, 181, 191, 193, 197, 199]
+    qs = [89, 97, 101, 103, 107, 109, 113, 127,
+          131, 137, 139, 149, 151, 157, 47]
+    messages = [
+        0, 32855, 34303, 14805, 1280, 75859, 38368,
+        724, 60356, 51675, 76697, 61854, 18661,
+    ]
+    for p, q in zip(ps, qs):
+        pri = gm_private_key(p, q)
+        for msg in messages:
+            pub = gm_public_key(p, q)
+            enc = encipher_gm(msg, pub)
+            dec = decipher_gm(enc, pri)
+            assert dec == msg
+
+
+def test_gm_private_key():
+    raises(ValueError, lambda: gm_public_key(13, 15))
+    raises(ValueError, lambda: gm_public_key(0, 0))
+    raises(ValueError, lambda: gm_public_key(0, 5))
+    assert 17, 19 == gm_public_key(17, 19)
+
+
+def test_gm_public_key():
+    assert 323 == gm_public_key(17, 19)[1]
+    assert 15  == gm_public_key(3, 5)[1]
+    raises(ValueError, lambda: gm_public_key(15, 19))
+
+def test_encipher_decipher_bg():
+    ps = [67, 7, 71, 103, 11, 43, 107, 47,
+          79, 19, 83, 23, 59, 127, 31]
+    qs = qs = [7, 71, 103, 11, 43, 107, 47,
+               79, 19, 83, 23, 59, 127, 31, 67]
+    messages = [
+        0, 328, 343, 148, 1280, 758, 383,
+        724, 603, 516, 766, 618, 186,
+    ]
+
+    for p, q in zip(ps, qs):
+        pri = bg_private_key(p, q)
+        for msg in messages:
+            pub = bg_public_key(p, q)
+            enc = encipher_bg(msg, pub)
+            dec = decipher_bg(enc, pri)
+            assert dec == msg
+
+def test_bg_private_key():
+    raises(ValueError, lambda: bg_private_key(8, 16))
+    raises(ValueError, lambda: bg_private_key(8, 8))
+    raises(ValueError, lambda: bg_private_key(13, 17))
+    assert 23, 31 == bg_private_key(23, 31)
+
+def test_bg_public_key():
+    assert 5293 == bg_public_key(67, 79)
+    assert 713 == bg_public_key(23, 31)
+    raises(ValueError, lambda: bg_private_key(13, 17))
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/__init__.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8846a99510601c9675103e21ef5a0a1e839fdd11
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__init__.py
@@ -0,0 +1,19 @@
+from .diffgeom import (
+    BaseCovarDerivativeOp, BaseScalarField, BaseVectorField, Commutator,
+    contravariant_order, CoordSystem, CoordinateSymbol,
+    CovarDerivativeOp, covariant_order, Differential, intcurve_diffequ,
+    intcurve_series, LieDerivative, Manifold, metric_to_Christoffel_1st,
+    metric_to_Christoffel_2nd, metric_to_Ricci_components,
+    metric_to_Riemann_components, Patch, Point, TensorProduct, twoform_to_matrix,
+    vectors_in_basis, WedgeProduct,
+)
+
+__all__ = [
+    'BaseCovarDerivativeOp', 'BaseScalarField', 'BaseVectorField', 'Commutator',
+    'contravariant_order', 'CoordSystem', 'CoordinateSymbol',
+    'CovarDerivativeOp', 'covariant_order', 'Differential', 'intcurve_diffequ',
+    'intcurve_series', 'LieDerivative', 'Manifold', 'metric_to_Christoffel_1st',
+    'metric_to_Christoffel_2nd', 'metric_to_Ricci_components',
+    'metric_to_Riemann_components', 'Patch', 'Point', 'TensorProduct',
+    'twoform_to_matrix', 'vectors_in_basis', 'WedgeProduct',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6d0d3654b893d24c2b7bd0687e21fb19f4d91ea7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/diffgeom.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/diffgeom.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10e6d88aa373fa5914e78774f21c5a840a30c4e5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/diffgeom.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/rn.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/rn.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a82037c92308b4380aa21720cb73dade50fcfad3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/__pycache__/rn.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/diffgeom.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/diffgeom.py
new file mode 100644
index 0000000000000000000000000000000000000000..a95f83122d6de0b7015b9a3ad0573cbfd97a7ef3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/diffgeom.py
@@ -0,0 +1,2270 @@
+from __future__ import annotations
+from typing import Any
+
+from functools import reduce
+from itertools import permutations
+
+from sympy.combinatorics import Permutation
+from sympy.core import (
+    Basic, Expr, Function, diff,
+    Pow, Mul, Add, Lambda, S, Tuple, Dict
+)
+from sympy.core.cache import cacheit
+
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.symbol import Str
+from sympy.core.sympify import _sympify
+from sympy.functions import factorial
+from sympy.matrices import ImmutableDenseMatrix as Matrix
+from sympy.solvers import solve
+
+from sympy.utilities.exceptions import (sympy_deprecation_warning,
+                                        SymPyDeprecationWarning,
+                                        ignore_warnings)
+
+
+# TODO you are a bit excessive in the use of Dummies
+# TODO dummy point, literal field
+# TODO too often one needs to call doit or simplify on the output, check the
+# tests and find out why
+from sympy.tensor.array import ImmutableDenseNDimArray
+
+
+class Manifold(Basic):
+    """
+    A mathematical manifold.
+
+    Explanation
+    ===========
+
+    A manifold is a topological space that locally resembles
+    Euclidean space near each point [1].
+    This class does not provide any means to study the topological
+    characteristics of the manifold that it represents, though.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the manifold.
+
+    dim : int
+        The dimension of the manifold.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import Manifold
+    >>> m = Manifold('M', 2)
+    >>> m
+    M
+    >>> m.dim
+    2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Manifold
+    """
+
+    def __new__(cls, name, dim, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+        dim = _sympify(dim)
+        obj = super().__new__(cls, name, dim)
+
+        obj.patches = _deprecated_list(
+            """
+            Manifold.patches is deprecated. The Manifold object is now
+            immutable. Instead use a separate list to keep track of the
+            patches.
+            """, [])
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def dim(self):
+        return self.args[1]
+
+
+class Patch(Basic):
+    """
+    A patch on a manifold.
+
+    Explanation
+    ===========
+
+    Coordinate patch, or patch in short, is a simply-connected open set around
+    a point in the manifold [1]. On a manifold one can have many patches that
+    do not always include the whole manifold. On these patches coordinate
+    charts can be defined that permit the parameterization of any point on the
+    patch in terms of a tuple of real numbers (the coordinates).
+
+    This class does not provide any means to study the topological
+    characteristics of the patch that it represents.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the patch.
+
+    manifold : Manifold
+        The manifold on which the patch is defined.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import Manifold, Patch
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> p
+    P
+    >>> p.dim
+    2
+
+    References
+    ==========
+
+    .. [1] G. Sussman, J. Wisdom, W. Farr, Functional Differential Geometry
+           (2013)
+
+    """
+    def __new__(cls, name, manifold, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+        obj = super().__new__(cls, name, manifold)
+
+        obj.manifold.patches.append(obj) # deprecated
+        obj.coord_systems = _deprecated_list(
+            """
+            Patch.coord_systms is deprecated. The Patch class is now
+            immutable. Instead use a separate list to keep track of coordinate
+            systems.
+            """, [])
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def manifold(self):
+        return self.args[1]
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+
+class CoordSystem(Basic):
+    """
+    A coordinate system defined on the patch.
+
+    Explanation
+    ===========
+
+    Coordinate system is a system that uses one or more coordinates to uniquely
+    determine the position of the points or other geometric elements on a
+    manifold [1].
+
+    By passing ``Symbols`` to *symbols* parameter, user can define the name and
+    assumptions of coordinate symbols of the coordinate system. If not passed,
+    these symbols are generated automatically and are assumed to be real valued.
+
+    By passing *relations* parameter, user can define the transform relations of
+    coordinate systems. Inverse transformation and indirect transformation can
+    be found automatically. If this parameter is not passed, coordinate
+    transformation cannot be done.
+
+    Parameters
+    ==========
+
+    name : str
+        The name of the coordinate system.
+
+    patch : Patch
+        The patch where the coordinate system is defined.
+
+    symbols : list of Symbols, optional
+        Defines the names and assumptions of coordinate symbols.
+
+    relations : dict, optional
+        Key is a tuple of two strings, who are the names of the systems where
+        the coordinates transform from and transform to.
+        Value is a tuple of the symbols before transformation and a tuple of
+        the expressions after transformation.
+
+    Examples
+    ========
+
+    We define two-dimensional Cartesian coordinate system and polar coordinate
+    system.
+
+    >>> from sympy import symbols, pi, sqrt, atan2, cos, sin
+    >>> from sympy.diffgeom import Manifold, Patch, CoordSystem
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> x, y = symbols('x y', real=True)
+    >>> r, theta = symbols('r theta', nonnegative=True)
+    >>> relation_dict = {
+    ... ('Car2D', 'Pol'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
+    ... ('Pol', 'Car2D'): [(r, theta), (r*cos(theta), r*sin(theta))]
+    ... }
+    >>> Car2D = CoordSystem('Car2D', p, (x, y), relation_dict)
+    >>> Pol = CoordSystem('Pol', p, (r, theta), relation_dict)
+
+    ``symbols`` property returns ``CoordinateSymbol`` instances. These symbols
+    are not same with the symbols used to construct the coordinate system.
+
+    >>> Car2D
+    Car2D
+    >>> Car2D.dim
+    2
+    >>> Car2D.symbols
+    (x, y)
+    >>> _[0].func
+    
+
+    ``transformation()`` method returns the transformation function from
+    one coordinate system to another. ``transform()`` method returns the
+    transformed coordinates.
+
+    >>> Car2D.transformation(Pol)
+    Lambda((x, y), Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]]))
+    >>> Car2D.transform(Pol)
+    Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]])
+    >>> Car2D.transform(Pol, [1, 2])
+    Matrix([
+    [sqrt(5)],
+    [atan(2)]])
+
+    ``jacobian()`` method returns the Jacobian matrix of coordinate
+    transformation between two systems. ``jacobian_determinant()`` method
+    returns the Jacobian determinant of coordinate transformation between two
+    systems.
+
+    >>> Pol.jacobian(Car2D)
+    Matrix([
+    [cos(theta), -r*sin(theta)],
+    [sin(theta),  r*cos(theta)]])
+    >>> Pol.jacobian(Car2D, [1, pi/2])
+    Matrix([
+    [0, -1],
+    [1,  0]])
+    >>> Car2D.jacobian_determinant(Pol)
+    1/sqrt(x**2 + y**2)
+    >>> Car2D.jacobian_determinant(Pol, [1,0])
+    1
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Coordinate_system
+
+    """
+    def __new__(cls, name, patch, symbols=None, relations={}, **kwargs):
+        if not isinstance(name, Str):
+            name = Str(name)
+
+        # canonicallize the symbols
+        if symbols is None:
+            names = kwargs.get('names', None)
+            if names is None:
+                symbols = Tuple(
+                    *[Symbol('%s_%s' % (name.name, i), real=True)
+                      for i in range(patch.dim)]
+                )
+            else:
+                sympy_deprecation_warning(
+                    f"""
+The 'names' argument to CoordSystem is deprecated. Use 'symbols' instead. That
+is, replace
+
+    CoordSystem(..., names={names})
+
+with
+
+    CoordSystem(..., symbols=[{', '.join(["Symbol(" + repr(n) + ", real=True)" for n in names])}])
+                    """,
+                    deprecated_since_version="1.7",
+                    active_deprecations_target="deprecated-diffgeom-mutable",
+                )
+                symbols = Tuple(
+                    *[Symbol(n, real=True) for n in names]
+                )
+        else:
+            syms = []
+            for s in symbols:
+                if isinstance(s, Symbol):
+                    syms.append(Symbol(s.name, **s._assumptions.generator))
+                elif isinstance(s, str):
+                    sympy_deprecation_warning(
+                        f"""
+
+Passing a string as the coordinate symbol name to CoordSystem is deprecated.
+Pass a Symbol with the appropriate name and assumptions instead.
+
+That is, replace {s} with Symbol({s!r}, real=True).
+                        """,
+
+                        deprecated_since_version="1.7",
+                        active_deprecations_target="deprecated-diffgeom-mutable",
+                    )
+                    syms.append(Symbol(s, real=True))
+            symbols = Tuple(*syms)
+
+        # canonicallize the relations
+        rel_temp = {}
+        for k,v in relations.items():
+            s1, s2 = k
+            if not isinstance(s1, Str):
+                s1 = Str(s1)
+            if not isinstance(s2, Str):
+                s2 = Str(s2)
+            key = Tuple(s1, s2)
+
+            # Old version used Lambda as a value.
+            if isinstance(v, Lambda):
+                v = (tuple(v.signature), tuple(v.expr))
+            else:
+                v = (tuple(v[0]), tuple(v[1]))
+            rel_temp[key] = v
+        relations = Dict(rel_temp)
+
+        # construct the object
+        obj = super().__new__(cls, name, patch, symbols, relations)
+
+        # Add deprecated attributes
+        obj.transforms = _deprecated_dict(
+            """
+            CoordSystem.transforms is deprecated. The CoordSystem class is now
+            immutable. Use the 'relations' keyword argument to the
+            CoordSystems() constructor to specify relations.
+            """, {})
+        obj._names = [str(n) for n in symbols]
+        obj.patch.coord_systems.append(obj) # deprecated
+        obj._dummies = [Dummy(str(n)) for n in symbols] # deprecated
+        obj._dummy = Dummy()
+
+        return obj
+
+    @property
+    def name(self):
+        return self.args[0]
+
+    @property
+    def patch(self):
+        return self.args[1]
+
+    @property
+    def manifold(self):
+        return self.patch.manifold
+
+    @property
+    def symbols(self):
+        return tuple(CoordinateSymbol(self, i, **s._assumptions.generator)
+            for i,s in enumerate(self.args[2]))
+
+    @property
+    def relations(self):
+        return self.args[3]
+
+    @property
+    def dim(self):
+        return self.patch.dim
+
+    ##########################################################################
+    # Finding transformation relation
+    ##########################################################################
+
+    def transformation(self, sys):
+        """
+        Return coordinate transformation function from *self* to *sys*.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        Returns
+        =======
+
+        sympy.Lambda
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.transformation(R2_p)
+        Lambda((x, y), Matrix([
+        [sqrt(x**2 + y**2)],
+        [      atan2(y, x)]]))
+
+        """
+        signature = self.args[2]
+
+        key = Tuple(self.name, sys.name)
+        if self == sys:
+            expr = Matrix(self.symbols)
+        elif key in self.relations:
+            expr = Matrix(self.relations[key][1])
+        elif key[::-1] in self.relations:
+            expr = Matrix(self._inverse_transformation(sys, self))
+        else:
+            expr = Matrix(self._indirect_transformation(self, sys))
+        return Lambda(signature, expr)
+
+    @staticmethod
+    def _solve_inverse(sym1, sym2, exprs, sys1_name, sys2_name):
+        ret = solve(
+            [t[0] - t[1] for t in zip(sym2, exprs)],
+            list(sym1), dict=True)
+
+        if len(ret) == 0:
+            temp = "Cannot solve inverse relation from {} to {}."
+            raise NotImplementedError(temp.format(sys1_name, sys2_name))
+        elif len(ret) > 1:
+            temp = "Obtained multiple inverse relation from {} to {}."
+            raise ValueError(temp.format(sys1_name, sys2_name))
+
+        return ret[0]
+
+    @classmethod
+    def _inverse_transformation(cls, sys1, sys2):
+        # Find the transformation relation from sys2 to sys1
+        forward = sys1.transform(sys2)
+        inv_results = cls._solve_inverse(sys1.symbols, sys2.symbols, forward,
+                                         sys1.name, sys2.name)
+        signature = tuple(sys1.symbols)
+        return [inv_results[s] for s in signature]
+
+    @classmethod
+    @cacheit
+    def _indirect_transformation(cls, sys1, sys2):
+        # Find the transformation relation between two indirectly connected
+        # coordinate systems
+        rel = sys1.relations
+        path = cls._dijkstra(sys1, sys2)
+
+        transforms = []
+        for s1, s2 in zip(path, path[1:]):
+            if (s1, s2) in rel:
+                transforms.append(rel[(s1, s2)])
+            else:
+                sym2, inv_exprs = rel[(s2, s1)]
+                sym1 = tuple(Dummy() for i in sym2)
+                ret = cls._solve_inverse(sym2, sym1, inv_exprs, s2, s1)
+                ret = tuple(ret[s] for s in sym2)
+                transforms.append((sym1, ret))
+        syms = sys1.args[2]
+        exprs = syms
+        for newsyms, newexprs in transforms:
+            exprs = tuple(e.subs(zip(newsyms, exprs)) for e in newexprs)
+        return exprs
+
+    @staticmethod
+    def _dijkstra(sys1, sys2):
+        # Use Dijkstra algorithm to find the shortest path between two indirectly-connected
+        # coordinate systems
+        # return value is the list of the names of the systems.
+        relations = sys1.relations
+        graph = {}
+        for s1, s2 in relations.keys():
+            if s1 not in graph:
+                graph[s1] = {s2}
+            else:
+                graph[s1].add(s2)
+            if s2 not in graph:
+                graph[s2] = {s1}
+            else:
+                graph[s2].add(s1)
+
+        path_dict = {sys:[0, [], 0] for sys in graph} # minimum distance, path, times of visited
+
+        def visit(sys):
+            path_dict[sys][2] = 1
+            for newsys in graph[sys]:
+                distance = path_dict[sys][0] + 1
+                if path_dict[newsys][0] >= distance or not path_dict[newsys][1]:
+                    path_dict[newsys][0] = distance
+                    path_dict[newsys][1] = list(path_dict[sys][1])
+                    path_dict[newsys][1].append(sys)
+
+        visit(sys1.name)
+
+        while True:
+            min_distance = max(path_dict.values(), key=lambda x:x[0])[0]
+            newsys = None
+            for sys, lst in path_dict.items():
+                if 0 < lst[0] <= min_distance and not lst[2]:
+                    min_distance = lst[0]
+                    newsys = sys
+            if newsys is None:
+                break
+            visit(newsys)
+
+        result = path_dict[sys2.name][1]
+        result.append(sys2.name)
+
+        if result == [sys2.name]:
+            raise KeyError("Two coordinate systems are not connected.")
+        return result
+
+    def connect_to(self, to_sys, from_coords, to_exprs, inverse=True, fill_in_gaps=False):
+        sympy_deprecation_warning(
+            """
+            The CoordSystem.connect_to() method is deprecated. Instead,
+            generate a new instance of CoordSystem with the 'relations'
+            keyword argument (CoordSystem classes are now immutable).
+            """,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+        )
+
+        from_coords, to_exprs = dummyfy(from_coords, to_exprs)
+        self.transforms[to_sys] = Matrix(from_coords), Matrix(to_exprs)
+
+        if inverse:
+            to_sys.transforms[self] = self._inv_transf(from_coords, to_exprs)
+
+        if fill_in_gaps:
+            self._fill_gaps_in_transformations()
+
+    @staticmethod
+    def _inv_transf(from_coords, to_exprs):
+        # Will be removed when connect_to is removed
+        inv_from = [i.as_dummy() for i in from_coords]
+        inv_to = solve(
+            [t[0] - t[1] for t in zip(inv_from, to_exprs)],
+            list(from_coords), dict=True)[0]
+        inv_to = [inv_to[fc] for fc in from_coords]
+        return Matrix(inv_from), Matrix(inv_to)
+
+    @staticmethod
+    def _fill_gaps_in_transformations():
+        # Will be removed when connect_to is removed
+        raise NotImplementedError
+
+    ##########################################################################
+    # Coordinate transformations
+    ##########################################################################
+
+    def transform(self, sys, coordinates=None):
+        """
+        Return the result of coordinate transformation from *self* to *sys*.
+        If coordinates are not given, coordinate symbols of *self* are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.ImmutableDenseMatrix containing CoordinateSymbol
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.transform(R2_p)
+        Matrix([
+        [sqrt(x**2 + y**2)],
+        [      atan2(y, x)]])
+        >>> R2_r.transform(R2_p, [0, 1])
+        Matrix([
+        [   1],
+        [pi/2]])
+
+        """
+        if coordinates is None:
+            coordinates = self.symbols
+        if self != sys:
+            transf = self.transformation(sys)
+            coordinates = transf(*coordinates)
+        else:
+            coordinates = Matrix(coordinates)
+        return coordinates
+
+    def coord_tuple_transform_to(self, to_sys, coords):
+        """Transform ``coords`` to coord system ``to_sys``."""
+        sympy_deprecation_warning(
+            """
+            The CoordSystem.coord_tuple_transform_to() method is deprecated.
+            Use the CoordSystem.transform() method instead.
+            """,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+        )
+
+        coords = Matrix(coords)
+        if self != to_sys:
+            with ignore_warnings(SymPyDeprecationWarning):
+                transf = self.transforms[to_sys]
+            coords = transf[1].subs(list(zip(transf[0], coords)))
+        return coords
+
+    def jacobian(self, sys, coordinates=None):
+        """
+        Return the jacobian matrix of a transformation on given coordinates.
+        If coordinates are not given, coordinate symbols of *self* are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.ImmutableDenseMatrix
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_p.jacobian(R2_r)
+        Matrix([
+        [cos(theta), -rho*sin(theta)],
+        [sin(theta),  rho*cos(theta)]])
+        >>> R2_p.jacobian(R2_r, [1, 0])
+        Matrix([
+        [1, 0],
+        [0, 1]])
+
+        """
+        result = self.transform(sys).jacobian(self.symbols)
+        if coordinates is not None:
+            result = result.subs(list(zip(self.symbols, coordinates)))
+        return result
+    jacobian_matrix = jacobian
+
+    def jacobian_determinant(self, sys, coordinates=None):
+        """
+        Return the jacobian determinant of a transformation on given
+        coordinates. If coordinates are not given, coordinate symbols of *self*
+        are used.
+
+        Parameters
+        ==========
+
+        sys : CoordSystem
+
+        coordinates : Any iterable, optional.
+
+        Returns
+        =======
+
+        sympy.Expr
+
+        Examples
+        ========
+
+        >>> from sympy.diffgeom.rn import R2_r, R2_p
+        >>> R2_r.jacobian_determinant(R2_p)
+        1/sqrt(x**2 + y**2)
+        >>> R2_r.jacobian_determinant(R2_p, [1, 0])
+        1
+
+        """
+        return self.jacobian(sys, coordinates).det()
+
+
+    ##########################################################################
+    # Points
+    ##########################################################################
+
+    def point(self, coords):
+        """Create a ``Point`` with coordinates given in this coord system."""
+        return Point(self, coords)
+
+    def point_to_coords(self, point):
+        """Calculate the coordinates of a point in this coord system."""
+        return point.coords(self)
+
+    ##########################################################################
+    # Base fields.
+    ##########################################################################
+
+    def base_scalar(self, coord_index):
+        """Return ``BaseScalarField`` that takes a point and returns one of the coordinates."""
+        return BaseScalarField(self, coord_index)
+    coord_function = base_scalar
+
+    def base_scalars(self):
+        """Returns a list of all coordinate functions.
+        For more details see the ``base_scalar`` method of this class."""
+        return [self.base_scalar(i) for i in range(self.dim)]
+    coord_functions = base_scalars
+
+    def base_vector(self, coord_index):
+        """Return a basis vector field.
+        The basis vector field for this coordinate system. It is also an
+        operator on scalar fields."""
+        return BaseVectorField(self, coord_index)
+
+    def base_vectors(self):
+        """Returns a list of all base vectors.
+        For more details see the ``base_vector`` method of this class."""
+        return [self.base_vector(i) for i in range(self.dim)]
+
+    def base_oneform(self, coord_index):
+        """Return a basis 1-form field.
+        The basis one-form field for this coordinate system. It is also an
+        operator on vector fields."""
+        return Differential(self.coord_function(coord_index))
+
+    def base_oneforms(self):
+        """Returns a list of all base oneforms.
+        For more details see the ``base_oneform`` method of this class."""
+        return [self.base_oneform(i) for i in range(self.dim)]
+
+
+class CoordinateSymbol(Symbol):
+    """A symbol which denotes an abstract value of i-th coordinate of
+    the coordinate system with given context.
+
+    Explanation
+    ===========
+
+    Each coordinates in coordinate system are represented by unique symbol,
+    such as x, y, z in Cartesian coordinate system.
+
+    You may not construct this class directly. Instead, use `symbols` method
+    of CoordSystem.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, Lambda, Matrix, sqrt, atan2, cos, sin
+    >>> from sympy.diffgeom import Manifold, Patch, CoordSystem
+    >>> m = Manifold('M', 2)
+    >>> p = Patch('P', m)
+    >>> x, y = symbols('x y', real=True)
+    >>> r, theta = symbols('r theta', nonnegative=True)
+    >>> relation_dict = {
+    ... ('Car2D', 'Pol'): Lambda((x, y), Matrix([sqrt(x**2 + y**2), atan2(y, x)])),
+    ... ('Pol', 'Car2D'): Lambda((r, theta), Matrix([r*cos(theta), r*sin(theta)]))
+    ... }
+    >>> Car2D = CoordSystem('Car2D', p, [x, y], relation_dict)
+    >>> Pol = CoordSystem('Pol', p, [r, theta], relation_dict)
+    >>> x, y = Car2D.symbols
+
+    ``CoordinateSymbol`` contains its coordinate symbol and index.
+
+    >>> x.name
+    'x'
+    >>> x.coord_sys == Car2D
+    True
+    >>> x.index
+    0
+    >>> x.is_real
+    True
+
+    You can transform ``CoordinateSymbol`` into other coordinate system using
+    ``rewrite()`` method.
+
+    >>> x.rewrite(Pol)
+    r*cos(theta)
+    >>> sqrt(x**2 + y**2).rewrite(Pol).simplify()
+    r
+
+    """
+    def __new__(cls, coord_sys, index, **assumptions):
+        name = coord_sys.args[2][index].name
+        obj = super().__new__(cls, name, **assumptions)
+        obj.coord_sys = coord_sys
+        obj.index = index
+        return obj
+
+    def __getnewargs__(self):
+        return (self.coord_sys, self.index)
+
+    def _hashable_content(self):
+        return (
+            self.coord_sys, self.index
+        ) + tuple(sorted(self.assumptions0.items()))
+
+    def _eval_rewrite(self, rule, args, **hints):
+        if isinstance(rule, CoordSystem):
+            return rule.transform(self.coord_sys)[self.index]
+        return super()._eval_rewrite(rule, args, **hints)
+
+
+class Point(Basic):
+    """Point defined in a coordinate system.
+
+    Explanation
+    ===========
+
+    Mathematically, point is defined in the manifold and does not have any coordinates
+    by itself. Coordinate system is what imbues the coordinates to the point by coordinate
+    chart. However, due to the difficulty of realizing such logic, you must supply
+    a coordinate system and coordinates to define a Point here.
+
+    The usage of this object after its definition is independent of the
+    coordinate system that was used in order to define it, however due to
+    limitations in the simplification routines you can arrive at complicated
+    expressions if you use inappropriate coordinate systems.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    coords : list
+        The coordinates of the point.
+
+    Examples
+    ========
+
+    >>> from sympy import pi
+    >>> from sympy.diffgeom import Point
+    >>> from sympy.diffgeom.rn import R2, R2_r, R2_p
+    >>> rho, theta = R2_p.symbols
+
+    >>> p = Point(R2_p, [rho, 3*pi/4])
+
+    >>> p.manifold == R2
+    True
+
+    >>> p.coords()
+    Matrix([
+    [   rho],
+    [3*pi/4]])
+    >>> p.coords(R2_r)
+    Matrix([
+    [-sqrt(2)*rho/2],
+    [ sqrt(2)*rho/2]])
+
+    """
+
+    def __new__(cls, coord_sys, coords, **kwargs):
+        coords = Matrix(coords)
+        obj = super().__new__(cls, coord_sys, coords)
+        obj._coord_sys = coord_sys
+        obj._coords = coords
+        return obj
+
+    @property
+    def patch(self):
+        return self._coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self._coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def coords(self, sys=None):
+        """
+        Coordinates of the point in given coordinate system. If coordinate system
+        is not passed, it returns the coordinates in the coordinate system in which
+        the point was defined.
+        """
+        if sys is None:
+            return self._coords
+        else:
+            return self._coord_sys.transform(sys, self._coords)
+
+    @property
+    def free_symbols(self):
+        return self._coords.free_symbols
+
+
+class BaseScalarField(Expr):
+    """Base scalar field over a manifold for a given coordinate system.
+
+    Explanation
+    ===========
+
+    A scalar field takes a point as an argument and returns a scalar.
+    A base scalar field of a coordinate system takes a point and returns one of
+    the coordinates of that point in the coordinate system in question.
+
+    To define a scalar field you need to choose the coordinate system and the
+    index of the coordinate.
+
+    The use of the scalar field after its definition is independent of the
+    coordinate system in which it was defined, however due to limitations in
+    the simplification routines you may arrive at more complicated
+    expression if you use unappropriate coordinate systems.
+    You can build complicated scalar fields by just building up SymPy
+    expressions containing ``BaseScalarField`` instances.
+
+    Parameters
+    ==========
+
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import Function, pi
+    >>> from sympy.diffgeom import BaseScalarField
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+    >>> rho, _ = R2_p.symbols
+    >>> point = R2_p.point([rho, 0])
+    >>> fx, fy = R2_r.base_scalars()
+    >>> ftheta = BaseScalarField(R2_r, 1)
+
+    >>> fx(point)
+    rho
+    >>> fy(point)
+    0
+
+    >>> (fx**2+fy**2).rcall(point)
+    rho**2
+
+    >>> g = Function('g')
+    >>> fg = g(ftheta-pi)
+    >>> fg.rcall(point)
+    g(-pi)
+
+    """
+
+    is_commutative = True
+
+    def __new__(cls, coord_sys, index, **kwargs):
+        index = _sympify(index)
+        obj = super().__new__(cls, coord_sys, index)
+        obj._coord_sys = coord_sys
+        obj._index = index
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def patch(self):
+        return self.coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self.coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def __call__(self, *args):
+        """Evaluating the field at a point or doing nothing.
+        If the argument is a ``Point`` instance, the field is evaluated at that
+        point. The field is returned itself if the argument is any other
+        object. It is so in order to have working recursive calling mechanics
+        for all fields (check the ``__call__`` method of ``Expr``).
+        """
+        point = args[0]
+        if len(args) != 1 or not isinstance(point, Point):
+            return self
+        coords = point.coords(self._coord_sys)
+        # XXX Calling doit  is necessary with all the Subs expressions
+        # XXX Calling simplify is necessary with all the trig expressions
+        return simplify(coords[self._index]).doit()
+
+    # XXX Workaround for limitations on the content of args
+    free_symbols: set[Any] = set()
+
+
+class BaseVectorField(Expr):
+    r"""Base vector field over a manifold for a given coordinate system.
+
+    Explanation
+    ===========
+
+    A vector field is an operator taking a scalar field and returning a
+    directional derivative (which is also a scalar field).
+    A base vector field is the same type of operator, however the derivation is
+    specifically done with respect to a chosen coordinate.
+
+    To define a base vector field you need to choose the coordinate system and
+    the index of the coordinate.
+
+    The use of the vector field after its definition is independent of the
+    coordinate system in which it was defined, however due to limitations in the
+    simplification routines you may arrive at more complicated expression if you
+    use unappropriate coordinate systems.
+
+    Parameters
+    ==========
+    coord_sys : CoordSystem
+
+    index : integer
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import BaseVectorField
+    >>> from sympy import pprint
+
+    >>> x, y = R2_r.symbols
+    >>> rho, theta = R2_p.symbols
+    >>> fx, fy = R2_r.base_scalars()
+    >>> point_p = R2_p.point([rho, theta])
+    >>> point_r = R2_r.point([x, y])
+
+    >>> g = Function('g')
+    >>> s_field = g(fx, fy)
+
+    >>> v = BaseVectorField(R2_r, 1)
+    >>> pprint(v(s_field))
+    / d           \|
+    |---(g(x, xi))||
+    \dxi          /|xi=y
+    >>> pprint(v(s_field).rcall(point_r).doit())
+    d
+    --(g(x, y))
+    dy
+    >>> pprint(v(s_field).rcall(point_p))
+    / d                        \|
+    |---(g(rho*cos(theta), xi))||
+    \dxi                       /|xi=rho*sin(theta)
+
+    """
+
+    is_commutative = False
+
+    def __new__(cls, coord_sys, index, **kwargs):
+        index = _sympify(index)
+        obj = super().__new__(cls, coord_sys, index)
+        obj._coord_sys = coord_sys
+        obj._index = index
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def patch(self):
+        return self.coord_sys.patch
+
+    @property
+    def manifold(self):
+        return self.coord_sys.manifold
+
+    @property
+    def dim(self):
+        return self.manifold.dim
+
+    def __call__(self, scalar_field):
+        """Apply on a scalar field.
+        The action of a vector field on a scalar field is a directional
+        differentiation.
+        If the argument is not a scalar field an error is raised.
+        """
+        if covariant_order(scalar_field) or contravariant_order(scalar_field):
+            raise ValueError('Only scalar fields can be supplied as arguments to vector fields.')
+
+        if scalar_field is None:
+            return self
+
+        base_scalars = list(scalar_field.atoms(BaseScalarField))
+
+        # First step: e_x(x+r**2) -> e_x(x) + 2*r*e_x(r)
+        d_var = self._coord_sys._dummy
+        # TODO: you need a real dummy function for the next line
+        d_funcs = [Function('_#_%s' % i)(d_var) for i,
+                   b in enumerate(base_scalars)]
+        d_result = scalar_field.subs(list(zip(base_scalars, d_funcs)))
+        d_result = d_result.diff(d_var)
+
+        # Second step: e_x(x) -> 1 and e_x(r) -> cos(atan2(x, y))
+        coords = self._coord_sys.symbols
+        d_funcs_deriv = [f.diff(d_var) for f in d_funcs]
+        d_funcs_deriv_sub = []
+        for b in base_scalars:
+            jac = self._coord_sys.jacobian(b._coord_sys, coords)
+            d_funcs_deriv_sub.append(jac[b._index, self._index])
+        d_result = d_result.subs(list(zip(d_funcs_deriv, d_funcs_deriv_sub)))
+
+        # Remove the dummies
+        result = d_result.subs(list(zip(d_funcs, base_scalars)))
+        result = result.subs(list(zip(coords, self._coord_sys.coord_functions())))
+        return result.doit()
+
+
+def _find_coords(expr):
+    # Finds CoordinateSystems existing in expr
+    fields = expr.atoms(BaseScalarField, BaseVectorField)
+    return {f._coord_sys for f in fields}
+
+
+class Commutator(Expr):
+    r"""Commutator of two vector fields.
+
+    Explanation
+    ===========
+
+    The commutator of two vector fields `v_1` and `v_2` is defined as the
+    vector field `[v_1, v_2]` that evaluated on each scalar field `f` is equal
+    to `v_1(v_2(f)) - v_2(v_1(f))`.
+
+    Examples
+    ========
+
+
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import Commutator
+    >>> from sympy import simplify
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> e_r = R2_p.base_vector(0)
+
+    >>> c_xy = Commutator(e_x, e_y)
+    >>> c_xr = Commutator(e_x, e_r)
+    >>> c_xy
+    0
+
+    Unfortunately, the current code is not able to compute everything:
+
+    >>> c_xr
+    Commutator(e_x, e_rho)
+    >>> simplify(c_xr(fy**2))
+    -2*cos(theta)*y**2/(x**2 + y**2)
+
+    """
+    def __new__(cls, v1, v2):
+        if (covariant_order(v1) or contravariant_order(v1) != 1
+                or covariant_order(v2) or contravariant_order(v2) != 1):
+            raise ValueError(
+                'Only commutators of vector fields are supported.')
+        if v1 == v2:
+            return S.Zero
+        coord_sys = set().union(*[_find_coords(v) for v in (v1, v2)])
+        if len(coord_sys) == 1:
+            # Only one coordinate systems is used, hence it is easy enough to
+            # actually evaluate the commutator.
+            if all(isinstance(v, BaseVectorField) for v in (v1, v2)):
+                return S.Zero
+            bases_1, bases_2 = [list(v.atoms(BaseVectorField))
+                                for v in (v1, v2)]
+            coeffs_1 = [v1.expand().coeff(b) for b in bases_1]
+            coeffs_2 = [v2.expand().coeff(b) for b in bases_2]
+            res = 0
+            for c1, b1 in zip(coeffs_1, bases_1):
+                for c2, b2 in zip(coeffs_2, bases_2):
+                    res += c1*b1(c2)*b2 - c2*b2(c1)*b1
+            return res
+        else:
+            obj = super().__new__(cls, v1, v2)
+            obj._v1 = v1 # deprecated assignment
+            obj._v2 = v2 # deprecated assignment
+            return obj
+
+    @property
+    def v1(self):
+        return self.args[0]
+
+    @property
+    def v2(self):
+        return self.args[1]
+
+    def __call__(self, scalar_field):
+        """Apply on a scalar field.
+        If the argument is not a scalar field an error is raised.
+        """
+        return self.v1(self.v2(scalar_field)) - self.v2(self.v1(scalar_field))
+
+
+class Differential(Expr):
+    r"""Return the differential (exterior derivative) of a form field.
+
+    Explanation
+    ===========
+
+    The differential of a form (i.e. the exterior derivative) has a complicated
+    definition in the general case.
+    The differential `df` of the 0-form `f` is defined for any vector field `v`
+    as `df(v) = v(f)`.
+
+    Examples
+    ========
+
+    >>> from sympy import Function
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import Differential
+    >>> from sympy import pprint
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> g = Function('g')
+    >>> s_field = g(fx, fy)
+    >>> dg = Differential(s_field)
+
+    >>> dg
+    d(g(x, y))
+    >>> pprint(dg(e_x))
+    / d           \|
+    |---(g(xi, y))||
+    \dxi          /|xi=x
+    >>> pprint(dg(e_y))
+    / d           \|
+    |---(g(x, xi))||
+    \dxi          /|xi=y
+
+    Applying the exterior derivative operator twice always results in:
+
+    >>> Differential(dg)
+    0
+    """
+
+    is_commutative = False
+
+    def __new__(cls, form_field):
+        if contravariant_order(form_field):
+            raise ValueError(
+                'A vector field was supplied as an argument to Differential.')
+        if isinstance(form_field, Differential):
+            return S.Zero
+        else:
+            obj = super().__new__(cls, form_field)
+            obj._form_field = form_field # deprecated assignment
+            return obj
+
+    @property
+    def form_field(self):
+        return self.args[0]
+
+    def __call__(self, *vector_fields):
+        """Apply on a list of vector_fields.
+
+        Explanation
+        ===========
+
+        If the number of vector fields supplied is not equal to 1 + the order of
+        the form field inside the differential the result is undefined.
+
+        For 1-forms (i.e. differentials of scalar fields) the evaluation is
+        done as `df(v)=v(f)`. However if `v` is ``None`` instead of a vector
+        field, the differential is returned unchanged. This is done in order to
+        permit partial contractions for higher forms.
+
+        In the general case the evaluation is done by applying the form field
+        inside the differential on a list with one less elements than the number
+        of elements in the original list. Lowering the number of vector fields
+        is achieved through replacing each pair of fields by their
+        commutator.
+
+        If the arguments are not vectors or ``None``s an error is raised.
+        """
+        if any((contravariant_order(a) != 1 or covariant_order(a)) and a is not None
+                for a in vector_fields):
+            raise ValueError('The arguments supplied to Differential should be vector fields or Nones.')
+        k = len(vector_fields)
+        if k == 1:
+            if vector_fields[0]:
+                return vector_fields[0].rcall(self._form_field)
+            return self
+        else:
+            # For higher form it is more complicated:
+            # Invariant formula:
+            # https://en.wikipedia.org/wiki/Exterior_derivative#Invariant_formula
+            # df(v1, ... vn) = +/- vi(f(v1..no i..vn))
+            #                  +/- f([vi,vj],v1..no i, no j..vn)
+            f = self._form_field
+            v = vector_fields
+            ret = 0
+            for i in range(k):
+                t = v[i].rcall(f.rcall(*v[:i] + v[i + 1:]))
+                ret += (-1)**i*t
+                for j in range(i + 1, k):
+                    c = Commutator(v[i], v[j])
+                    if c:  # TODO this is ugly - the Commutator can be Zero and
+                        # this causes the next line to fail
+                        t = f.rcall(*(c,) + v[:i] + v[i + 1:j] + v[j + 1:])
+                        ret += (-1)**(i + j)*t
+            return ret
+
+
+class TensorProduct(Expr):
+    """Tensor product of forms.
+
+    Explanation
+    ===========
+
+    The tensor product permits the creation of multilinear functionals (i.e.
+    higher order tensors) out of lower order fields (e.g. 1-forms and vector
+    fields). However, the higher tensors thus created lack the interesting
+    features provided by the other type of product, the wedge product, namely
+    they are not antisymmetric and hence are not form fields.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import TensorProduct
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> TensorProduct(dx, dy)(e_x, e_y)
+    1
+    >>> TensorProduct(dx, dy)(e_y, e_x)
+    0
+    >>> TensorProduct(dx, fx*dy)(fx*e_x, e_y)
+    x**2
+    >>> TensorProduct(e_x, e_y)(fx**2, fy**2)
+    4*x*y
+    >>> TensorProduct(e_y, dx)(fy)
+    dx
+
+    You can nest tensor products.
+
+    >>> tp1 = TensorProduct(dx, dy)
+    >>> TensorProduct(tp1, dx)(e_x, e_y, e_x)
+    1
+
+    You can make partial contraction for instance when 'raising an index'.
+    Putting ``None`` in the second argument of ``rcall`` means that the
+    respective position in the tensor product is left as it is.
+
+    >>> TP = TensorProduct
+    >>> metric = TP(dx, dx) + 3*TP(dy, dy)
+    >>> metric.rcall(e_y, None)
+    3*dy
+
+    Or automatically pad the args with ``None`` without specifying them.
+
+    >>> metric.rcall(e_y)
+    3*dy
+
+    """
+    def __new__(cls, *args):
+        scalar = Mul(*[m for m in args if covariant_order(m) + contravariant_order(m) == 0])
+        multifields = [m for m in args if covariant_order(m) + contravariant_order(m)]
+        if multifields:
+            if len(multifields) == 1:
+                return scalar*multifields[0]
+            return scalar*super().__new__(cls, *multifields)
+        else:
+            return scalar
+
+    def __call__(self, *fields):
+        """Apply on a list of fields.
+
+        If the number of input fields supplied is not equal to the order of
+        the tensor product field, the list of arguments is padded with ``None``'s.
+
+        The list of arguments is divided in sublists depending on the order of
+        the forms inside the tensor product. The sublists are provided as
+        arguments to these forms and the resulting expressions are given to the
+        constructor of ``TensorProduct``.
+
+        """
+        tot_order = covariant_order(self) + contravariant_order(self)
+        tot_args = len(fields)
+        if tot_args != tot_order:
+            fields = list(fields) + [None]*(tot_order - tot_args)
+        orders = [covariant_order(f) + contravariant_order(f) for f in self._args]
+        indices = [sum(orders[:i + 1]) for i in range(len(orders) - 1)]
+        fields = [fields[i:j] for i, j in zip([0] + indices, indices + [None])]
+        multipliers = [t[0].rcall(*t[1]) for t in zip(self._args, fields)]
+        return TensorProduct(*multipliers)
+
+
+class WedgeProduct(TensorProduct):
+    """Wedge product of forms.
+
+    Explanation
+    ===========
+
+    In the context of integration only completely antisymmetric forms make
+    sense. The wedge product permits the creation of such forms.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import WedgeProduct
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> WedgeProduct(dx, dy)(e_x, e_y)
+    1
+    >>> WedgeProduct(dx, dy)(e_y, e_x)
+    -1
+    >>> WedgeProduct(dx, fx*dy)(fx*e_x, e_y)
+    x**2
+    >>> WedgeProduct(e_x, e_y)(fy, None)
+    -e_x
+
+    You can nest wedge products.
+
+    >>> wp1 = WedgeProduct(dx, dy)
+    >>> WedgeProduct(wp1, dx)(e_x, e_y, e_x)
+    0
+
+    """
+    # TODO the calculation of signatures is slow
+    # TODO you do not need all these permutations (neither the prefactor)
+    def __call__(self, *fields):
+        """Apply on a list of vector_fields.
+        The expression is rewritten internally in terms of tensor products and evaluated."""
+        orders = (covariant_order(e) + contravariant_order(e) for e in self.args)
+        mul = 1/Mul(*(factorial(o) for o in orders))
+        perms = permutations(fields)
+        perms_par = (Permutation(
+            p).signature() for p in permutations(range(len(fields))))
+        tensor_prod = TensorProduct(*self.args)
+        return mul*Add(*[tensor_prod(*p[0])*p[1] for p in zip(perms, perms_par)])
+
+
+class LieDerivative(Expr):
+    """Lie derivative with respect to a vector field.
+
+    Explanation
+    ===========
+
+    The transport operator that defines the Lie derivative is the pushforward of
+    the field to be derived along the integral curve of the field with respect
+    to which one derives.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+    >>> from sympy.diffgeom import (LieDerivative, TensorProduct)
+
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> e_rho, e_theta = R2_p.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> LieDerivative(e_x, fy)
+    0
+    >>> LieDerivative(e_x, fx)
+    1
+    >>> LieDerivative(e_x, e_x)
+    0
+
+    The Lie derivative of a tensor field by another tensor field is equal to
+    their commutator:
+
+    >>> LieDerivative(e_x, e_rho)
+    Commutator(e_x, e_rho)
+    >>> LieDerivative(e_x + e_y, fx)
+    1
+
+    >>> tp = TensorProduct(dx, dy)
+    >>> LieDerivative(e_x, tp)
+    LieDerivative(e_x, TensorProduct(dx, dy))
+    >>> LieDerivative(e_x, tp)
+    LieDerivative(e_x, TensorProduct(dx, dy))
+
+    """
+    def __new__(cls, v_field, expr):
+        expr_form_ord = covariant_order(expr)
+        if contravariant_order(v_field) != 1 or covariant_order(v_field):
+            raise ValueError('Lie derivatives are defined only with respect to'
+                             ' vector fields. The supplied argument was not a '
+                             'vector field.')
+        if expr_form_ord > 0:
+            obj = super().__new__(cls, v_field, expr)
+            # deprecated assignments
+            obj._v_field = v_field
+            obj._expr = expr
+            return obj
+        if expr.atoms(BaseVectorField):
+            return Commutator(v_field, expr)
+        else:
+            return v_field.rcall(expr)
+
+    @property
+    def v_field(self):
+        return self.args[0]
+
+    @property
+    def expr(self):
+        return self.args[1]
+
+    def __call__(self, *args):
+        v = self.v_field
+        expr = self.expr
+        lead_term = v(expr(*args))
+        rest = Add(*[Mul(*args[:i] + (Commutator(v, args[i]),) + args[i + 1:])
+                     for i in range(len(args))])
+        return lead_term - rest
+
+
+class BaseCovarDerivativeOp(Expr):
+    """Covariant derivative operator with respect to a base vector.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import BaseCovarDerivativeOp
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+
+    >>> TP = TensorProduct
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+
+    >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
+    >>> ch
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
+    >>> cvd(fx)
+    1
+    >>> cvd(fx*e_x)
+    e_x
+    """
+
+    def __new__(cls, coord_sys, index, christoffel):
+        index = _sympify(index)
+        christoffel = ImmutableDenseNDimArray(christoffel)
+        obj = super().__new__(cls, coord_sys, index, christoffel)
+        # deprecated assignments
+        obj._coord_sys = coord_sys
+        obj._index = index
+        obj._christoffel = christoffel
+        return obj
+
+    @property
+    def coord_sys(self):
+        return self.args[0]
+
+    @property
+    def index(self):
+        return self.args[1]
+
+    @property
+    def christoffel(self):
+        return self.args[2]
+
+    def __call__(self, field):
+        """Apply on a scalar field.
+
+        The action of a vector field on a scalar field is a directional
+        differentiation.
+        If the argument is not a scalar field the behaviour is undefined.
+        """
+        if covariant_order(field) != 0:
+            raise NotImplementedError()
+
+        field = vectors_in_basis(field, self._coord_sys)
+
+        wrt_vector = self._coord_sys.base_vector(self._index)
+        wrt_scalar = self._coord_sys.coord_function(self._index)
+        vectors = list(field.atoms(BaseVectorField))
+
+        # First step: replace all vectors with something susceptible to
+        # derivation and do the derivation
+        # TODO: you need a real dummy function for the next line
+        d_funcs = [Function('_#_%s' % i)(wrt_scalar) for i,
+                   b in enumerate(vectors)]
+        d_result = field.subs(list(zip(vectors, d_funcs)))
+        d_result = wrt_vector(d_result)
+
+        # Second step: backsubstitute the vectors in
+        d_result = d_result.subs(list(zip(d_funcs, vectors)))
+
+        # Third step: evaluate the derivatives of the vectors
+        derivs = []
+        for v in vectors:
+            d = Add(*[(self._christoffel[k, wrt_vector._index, v._index]
+                       *v._coord_sys.base_vector(k))
+                      for k in range(v._coord_sys.dim)])
+            derivs.append(d)
+        to_subs = [wrt_vector(d) for d in d_funcs]
+        # XXX: This substitution can fail when there are Dummy symbols and the
+        # cache is disabled: https://github.com/sympy/sympy/issues/17794
+        result = d_result.subs(list(zip(to_subs, derivs)))
+
+        # Remove the dummies
+        result = result.subs(list(zip(d_funcs, vectors)))
+        return result.doit()
+
+
+class CovarDerivativeOp(Expr):
+    """Covariant derivative operator.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2_r
+    >>> from sympy.diffgeom import CovarDerivativeOp
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+    >>> TP = TensorProduct
+    >>> fx, fy = R2_r.base_scalars()
+    >>> e_x, e_y = R2_r.base_vectors()
+    >>> dx, dy = R2_r.base_oneforms()
+    >>> ch = metric_to_Christoffel_2nd(TP(dx, dx) + TP(dy, dy))
+
+    >>> ch
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> cvd = CovarDerivativeOp(fx*e_x, ch)
+    >>> cvd(fx)
+    x
+    >>> cvd(fx*e_x)
+    x*e_x
+
+    """
+
+    def __new__(cls, wrt, christoffel):
+        if len({v._coord_sys for v in wrt.atoms(BaseVectorField)}) > 1:
+            raise NotImplementedError()
+        if contravariant_order(wrt) != 1 or covariant_order(wrt):
+            raise ValueError('Covariant derivatives are defined only with '
+                             'respect to vector fields. The supplied argument '
+                             'was not a vector field.')
+        christoffel = ImmutableDenseNDimArray(christoffel)
+        obj = super().__new__(cls, wrt, christoffel)
+        # deprecated assignments
+        obj._wrt = wrt
+        obj._christoffel = christoffel
+        return obj
+
+    @property
+    def wrt(self):
+        return self.args[0]
+
+    @property
+    def christoffel(self):
+        return self.args[1]
+
+    def __call__(self, field):
+        vectors = list(self._wrt.atoms(BaseVectorField))
+        base_ops = [BaseCovarDerivativeOp(v._coord_sys, v._index, self._christoffel)
+                    for v in vectors]
+        return self._wrt.subs(list(zip(vectors, base_ops))).rcall(field)
+
+
+###############################################################################
+# Integral curves on vector fields
+###############################################################################
+def intcurve_series(vector_field, param, start_point, n=6, coord_sys=None, coeffs=False):
+    r"""Return the series expansion for an integral curve of the field.
+
+    Explanation
+    ===========
+
+    Integral curve is a function `\gamma` taking a parameter in `R` to a point
+    in the manifold. It verifies the equation:
+
+    `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)`
+
+    where the given ``vector_field`` is denoted as `V`. This holds for any
+    value `t` for the parameter and any scalar field `f`.
+
+    This equation can also be decomposed of a basis of coordinate functions
+    `V(f_i)\big(\gamma(t)\big) = \frac{d}{dt}f_i\big(\gamma(t)\big) \quad \forall i`
+
+    This function returns a series expansion of `\gamma(t)` in terms of the
+    coordinate system ``coord_sys``. The equations and expansions are necessarily
+    done in coordinate-system-dependent way as there is no other way to
+    represent movement between points on the manifold (i.e. there is no such
+    thing as a difference of points for a general manifold).
+
+    Parameters
+    ==========
+    vector_field
+        the vector field for which an integral curve will be given
+
+    param
+        the argument of the function `\gamma` from R to the curve
+
+    start_point
+        the point which corresponds to `\gamma(0)`
+
+    n
+        the order to which to expand
+
+    coord_sys
+        the coordinate system in which to expand
+        coeffs (default False) - if True return a list of elements of the expansion
+
+    Examples
+    ========
+
+    Use the predefined R2 manifold:
+
+    >>> from sympy.abc import t, x, y
+    >>> from sympy.diffgeom.rn import R2_p, R2_r
+    >>> from sympy.diffgeom import intcurve_series
+
+    Specify a starting point and a vector field:
+
+    >>> start_point = R2_r.point([x, y])
+    >>> vector_field = R2_r.e_x
+
+    Calculate the series:
+
+    >>> intcurve_series(vector_field, t, start_point, n=3)
+    Matrix([
+    [t + x],
+    [    y]])
+
+    Or get the elements of the expansion in a list:
+
+    >>> series = intcurve_series(vector_field, t, start_point, n=3, coeffs=True)
+    >>> series[0]
+    Matrix([
+    [x],
+    [y]])
+    >>> series[1]
+    Matrix([
+    [t],
+    [0]])
+    >>> series[2]
+    Matrix([
+    [0],
+    [0]])
+
+    The series in the polar coordinate system:
+
+    >>> series = intcurve_series(vector_field, t, start_point,
+    ...             n=3, coord_sys=R2_p, coeffs=True)
+    >>> series[0]
+    Matrix([
+    [sqrt(x**2 + y**2)],
+    [      atan2(y, x)]])
+    >>> series[1]
+    Matrix([
+    [t*x/sqrt(x**2 + y**2)],
+    [   -t*y/(x**2 + y**2)]])
+    >>> series[2]
+    Matrix([
+    [t**2*(-x**2/(x**2 + y**2)**(3/2) + 1/sqrt(x**2 + y**2))/2],
+    [                                t**2*x*y/(x**2 + y**2)**2]])
+
+    See Also
+    ========
+
+    intcurve_diffequ
+
+    """
+    if contravariant_order(vector_field) != 1 or covariant_order(vector_field):
+        raise ValueError('The supplied field was not a vector field.')
+
+    def iter_vfield(scalar_field, i):
+        """Return ``vector_field`` called `i` times on ``scalar_field``."""
+        return reduce(lambda s, v: v.rcall(s), [vector_field, ]*i, scalar_field)
+
+    def taylor_terms_per_coord(coord_function):
+        """Return the series for one of the coordinates."""
+        return [param**i*iter_vfield(coord_function, i).rcall(start_point)/factorial(i)
+                for i in range(n)]
+    coord_sys = coord_sys if coord_sys else start_point._coord_sys
+    coord_functions = coord_sys.coord_functions()
+    taylor_terms = [taylor_terms_per_coord(f) for f in coord_functions]
+    if coeffs:
+        return [Matrix(t) for t in zip(*taylor_terms)]
+    else:
+        return Matrix([sum(c) for c in taylor_terms])
+
+
+def intcurve_diffequ(vector_field, param, start_point, coord_sys=None):
+    r"""Return the differential equation for an integral curve of the field.
+
+    Explanation
+    ===========
+
+    Integral curve is a function `\gamma` taking a parameter in `R` to a point
+    in the manifold. It verifies the equation:
+
+    `V(f)\big(\gamma(t)\big) = \frac{d}{dt}f\big(\gamma(t)\big)`
+
+    where the given ``vector_field`` is denoted as `V`. This holds for any
+    value `t` for the parameter and any scalar field `f`.
+
+    This function returns the differential equation of `\gamma(t)` in terms of the
+    coordinate system ``coord_sys``. The equations and expansions are necessarily
+    done in coordinate-system-dependent way as there is no other way to
+    represent movement between points on the manifold (i.e. there is no such
+    thing as a difference of points for a general manifold).
+
+    Parameters
+    ==========
+
+    vector_field
+        the vector field for which an integral curve will be given
+
+    param
+        the argument of the function `\gamma` from R to the curve
+
+    start_point
+        the point which corresponds to `\gamma(0)`
+
+    coord_sys
+        the coordinate system in which to give the equations
+
+    Returns
+    =======
+
+    a tuple of (equations, initial conditions)
+
+    Examples
+    ========
+
+    Use the predefined R2 manifold:
+
+    >>> from sympy.abc import t
+    >>> from sympy.diffgeom.rn import R2, R2_p, R2_r
+    >>> from sympy.diffgeom import intcurve_diffequ
+
+    Specify a starting point and a vector field:
+
+    >>> start_point = R2_r.point([0, 1])
+    >>> vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
+
+    Get the equation:
+
+    >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
+    >>> equations
+    [f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]
+    >>> init_cond
+    [f_0(0), f_1(0) - 1]
+
+    The series in the polar coordinate system:
+
+    >>> equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
+    >>> equations
+    [Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]
+    >>> init_cond
+    [f_0(0) - 1, f_1(0) - pi/2]
+
+    See Also
+    ========
+
+    intcurve_series
+
+    """
+    if contravariant_order(vector_field) != 1 or covariant_order(vector_field):
+        raise ValueError('The supplied field was not a vector field.')
+    coord_sys = coord_sys if coord_sys else start_point._coord_sys
+    gammas = [Function('f_%d' % i)(param) for i in range(
+        start_point._coord_sys.dim)]
+    arbitrary_p = Point(coord_sys, gammas)
+    coord_functions = coord_sys.coord_functions()
+    equations = [simplify(diff(cf.rcall(arbitrary_p), param) - vector_field.rcall(cf).rcall(arbitrary_p))
+                 for cf in coord_functions]
+    init_cond = [simplify(cf.rcall(arbitrary_p).subs(param, 0) - cf.rcall(start_point))
+                 for cf in coord_functions]
+    return equations, init_cond
+
+
+###############################################################################
+# Helpers
+###############################################################################
+def dummyfy(args, exprs):
+    # TODO Is this a good idea?
+    d_args = Matrix([s.as_dummy() for s in args])
+    reps = dict(zip(args, d_args))
+    d_exprs = Matrix([_sympify(expr).subs(reps) for expr in exprs])
+    return d_args, d_exprs
+
+###############################################################################
+# Helpers
+###############################################################################
+def contravariant_order(expr, _strict=False):
+    """Return the contravariant order of an expression.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import contravariant_order
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.abc import a
+
+    >>> contravariant_order(a)
+    0
+    >>> contravariant_order(a*R2.x + 2)
+    0
+    >>> contravariant_order(a*R2.x*R2.e_y + R2.e_x)
+    1
+
+    """
+    # TODO move some of this to class methods.
+    # TODO rewrite using the .as_blah_blah methods
+    if isinstance(expr, Add):
+        orders = [contravariant_order(e) for e in expr.args]
+        if len(set(orders)) != 1:
+            raise ValueError('Misformed expression containing contravariant fields of varying order.')
+        return orders[0]
+    elif isinstance(expr, Mul):
+        orders = [contravariant_order(e) for e in expr.args]
+        not_zero = [o for o in orders if o != 0]
+        if len(not_zero) > 1:
+            raise ValueError('Misformed expression containing multiplication between vectors.')
+        return 0 if not not_zero else not_zero[0]
+    elif isinstance(expr, Pow):
+        if covariant_order(expr.base) or covariant_order(expr.exp):
+            raise ValueError(
+                'Misformed expression containing a power of a vector.')
+        return 0
+    elif isinstance(expr, BaseVectorField):
+        return 1
+    elif isinstance(expr, TensorProduct):
+        return sum(contravariant_order(a) for a in expr.args)
+    elif not _strict or expr.atoms(BaseScalarField):
+        return 0
+    else:  # If it does not contain anything related to the diffgeom module and it is _strict
+        return -1
+
+
+def covariant_order(expr, _strict=False):
+    """Return the covariant order of an expression.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import covariant_order
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.abc import a
+
+    >>> covariant_order(a)
+    0
+    >>> covariant_order(a*R2.x + 2)
+    0
+    >>> covariant_order(a*R2.x*R2.dy + R2.dx)
+    1
+
+    """
+    # TODO move some of this to class methods.
+    # TODO rewrite using the .as_blah_blah methods
+    if isinstance(expr, Add):
+        orders = [covariant_order(e) for e in expr.args]
+        if len(set(orders)) != 1:
+            raise ValueError('Misformed expression containing form fields of varying order.')
+        return orders[0]
+    elif isinstance(expr, Mul):
+        orders = [covariant_order(e) for e in expr.args]
+        not_zero = [o for o in orders if o != 0]
+        if len(not_zero) > 1:
+            raise ValueError('Misformed expression containing multiplication between forms.')
+        return 0 if not not_zero else not_zero[0]
+    elif isinstance(expr, Pow):
+        if covariant_order(expr.base) or covariant_order(expr.exp):
+            raise ValueError(
+                'Misformed expression containing a power of a form.')
+        return 0
+    elif isinstance(expr, Differential):
+        return covariant_order(*expr.args) + 1
+    elif isinstance(expr, TensorProduct):
+        return sum(covariant_order(a) for a in expr.args)
+    elif not _strict or expr.atoms(BaseScalarField):
+        return 0
+    else:  # If it does not contain anything related to the diffgeom module and it is _strict
+        return -1
+
+
+###############################################################################
+# Coordinate transformation functions
+###############################################################################
+def vectors_in_basis(expr, to_sys):
+    """Transform all base vectors in base vectors of a specified coord basis.
+    While the new base vectors are in the new coordinate system basis, any
+    coefficients are kept in the old system.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom import vectors_in_basis
+    >>> from sympy.diffgeom.rn import R2_r, R2_p
+
+    >>> vectors_in_basis(R2_r.e_x, R2_p)
+    -y*e_theta/(x**2 + y**2) + x*e_rho/sqrt(x**2 + y**2)
+    >>> vectors_in_basis(R2_p.e_r, R2_r)
+    sin(theta)*e_y + cos(theta)*e_x
+
+    """
+    vectors = list(expr.atoms(BaseVectorField))
+    new_vectors = []
+    for v in vectors:
+        cs = v._coord_sys
+        jac = cs.jacobian(to_sys, cs.coord_functions())
+        new = (jac.T*Matrix(to_sys.base_vectors()))[v._index]
+        new_vectors.append(new)
+    return expr.subs(list(zip(vectors, new_vectors)))
+
+
+###############################################################################
+# Coordinate-dependent functions
+###############################################################################
+def twoform_to_matrix(expr):
+    """Return the matrix representing the twoform.
+
+    For the twoform `w` return the matrix `M` such that `M[i,j]=w(e_i, e_j)`,
+    where `e_i` is the i-th base vector field for the coordinate system in
+    which the expression of `w` is given.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import twoform_to_matrix, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    Matrix([
+    [1, 0],
+    [0, 1]])
+    >>> twoform_to_matrix(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    Matrix([
+    [x, 0],
+    [0, 1]])
+    >>> twoform_to_matrix(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy) - TP(R2.dx, R2.dy)/2)
+    Matrix([
+    [   1, 0],
+    [-1/2, 1]])
+
+    """
+    if covariant_order(expr) != 2 or contravariant_order(expr):
+        raise ValueError('The input expression is not a two-form.')
+    coord_sys = _find_coords(expr)
+    if len(coord_sys) != 1:
+        raise ValueError('The input expression concerns more than one '
+                         'coordinate systems, hence there is no unambiguous '
+                         'way to choose a coordinate system for the matrix.')
+    coord_sys = coord_sys.pop()
+    vectors = coord_sys.base_vectors()
+    expr = expr.expand()
+    matrix_content = [[expr.rcall(v1, v2) for v1 in vectors]
+                      for v2 in vectors]
+    return Matrix(matrix_content)
+
+
+def metric_to_Christoffel_1st(expr):
+    """Return the nested list of Christoffel symbols for the given metric.
+    This returns the Christoffel symbol of first kind that represents the
+    Levi-Civita connection for the given metric.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Christoffel_1st, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Christoffel_1st(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> metric_to_Christoffel_1st(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[1/2, 0], [0, 0]], [[0, 0], [0, 0]]]
+
+    """
+    matrix = twoform_to_matrix(expr)
+    if not matrix.is_symmetric():
+        raise ValueError(
+            'The two-form representing the metric is not symmetric.')
+    coord_sys = _find_coords(expr).pop()
+    deriv_matrices = [matrix.applyfunc(d) for d in coord_sys.base_vectors()]
+    indices = list(range(coord_sys.dim))
+    christoffel = [[[(deriv_matrices[k][i, j] + deriv_matrices[j][i, k] - deriv_matrices[i][j, k])/2
+                     for k in indices]
+                    for j in indices]
+                   for i in indices]
+    return ImmutableDenseNDimArray(christoffel)
+
+
+def metric_to_Christoffel_2nd(expr):
+    """Return the nested list of Christoffel symbols for the given metric.
+    This returns the Christoffel symbol of second kind that represents the
+    Levi-Civita connection for the given metric.
+
+    Examples
+    ========
+
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Christoffel_2nd, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]
+    >>> metric_to_Christoffel_2nd(R2.x*TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[1/(2*x), 0], [0, 0]], [[0, 0], [0, 0]]]
+
+    """
+    ch_1st = metric_to_Christoffel_1st(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    # XXX workaround, inverting a matrix does not work if it contains non
+    # symbols
+    #matrix = twoform_to_matrix(expr).inv()
+    matrix = twoform_to_matrix(expr)
+    s_fields = set()
+    for e in matrix:
+        s_fields.update(e.atoms(BaseScalarField))
+    s_fields = list(s_fields)
+    dums = coord_sys.symbols
+    matrix = matrix.subs(list(zip(s_fields, dums))).inv().subs(list(zip(dums, s_fields)))
+    # XXX end of workaround
+    christoffel = [[[Add(*[matrix[i, l]*ch_1st[l, j, k] for l in indices])
+                     for k in indices]
+                    for j in indices]
+                   for i in indices]
+    return ImmutableDenseNDimArray(christoffel)
+
+
+def metric_to_Riemann_components(expr):
+    """Return the components of the Riemann tensor expressed in a given basis.
+
+    Given a metric it calculates the components of the Riemann tensor in the
+    canonical basis of the coordinate system in which the metric expression is
+    given.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Riemann_components, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Riemann_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[[[0, 0], [0, 0]], [[0, 0], [0, 0]]], [[[0, 0], [0, 0]], [[0, 0], [0, 0]]]]
+    >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + \
+        R2.r**2*TP(R2.dtheta, R2.dtheta)
+    >>> non_trivial_metric
+    exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
+    >>> riemann = metric_to_Riemann_components(non_trivial_metric)
+    >>> riemann[0, :, :, :]
+    [[[0, 0], [0, 0]], [[0, exp(-2*rho)*rho], [-exp(-2*rho)*rho, 0]]]
+    >>> riemann[1, :, :, :]
+    [[[0, -1/rho], [1/rho, 0]], [[0, 0], [0, 0]]]
+
+    """
+    ch_2nd = metric_to_Christoffel_2nd(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    deriv_ch = [[[[d(ch_2nd[i, j, k])
+                   for d in coord_sys.base_vectors()]
+                  for k in indices]
+                 for j in indices]
+                for i in indices]
+    riemann_a = [[[[deriv_ch[rho][sig][nu][mu] - deriv_ch[rho][sig][mu][nu]
+                    for nu in indices]
+                   for mu in indices]
+                  for sig in indices]
+                     for rho in indices]
+    riemann_b = [[[[Add(*[ch_2nd[rho, l, mu]*ch_2nd[l, sig, nu] - ch_2nd[rho, l, nu]*ch_2nd[l, sig, mu] for l in indices])
+                    for nu in indices]
+                   for mu in indices]
+                  for sig in indices]
+                 for rho in indices]
+    riemann = [[[[riemann_a[rho][sig][mu][nu] + riemann_b[rho][sig][mu][nu]
+                  for nu in indices]
+                     for mu in indices]
+                for sig in indices]
+               for rho in indices]
+    return ImmutableDenseNDimArray(riemann)
+
+
+def metric_to_Ricci_components(expr):
+
+    """Return the components of the Ricci tensor expressed in a given basis.
+
+    Given a metric it calculates the components of the Ricci tensor in the
+    canonical basis of the coordinate system in which the metric expression is
+    given.
+
+    Examples
+    ========
+
+    >>> from sympy import exp
+    >>> from sympy.diffgeom.rn import R2
+    >>> from sympy.diffgeom import metric_to_Ricci_components, TensorProduct
+    >>> TP = TensorProduct
+
+    >>> metric_to_Ricci_components(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    [[0, 0], [0, 0]]
+    >>> non_trivial_metric = exp(2*R2.r)*TP(R2.dr, R2.dr) + \
+                             R2.r**2*TP(R2.dtheta, R2.dtheta)
+    >>> non_trivial_metric
+    exp(2*rho)*TensorProduct(drho, drho) + rho**2*TensorProduct(dtheta, dtheta)
+    >>> metric_to_Ricci_components(non_trivial_metric)
+    [[1/rho, 0], [0, exp(-2*rho)*rho]]
+
+    """
+    riemann = metric_to_Riemann_components(expr)
+    coord_sys = _find_coords(expr).pop()
+    indices = list(range(coord_sys.dim))
+    ricci = [[Add(*[riemann[k, i, k, j] for k in indices])
+              for j in indices]
+             for i in indices]
+    return ImmutableDenseNDimArray(ricci)
+
+###############################################################################
+# Classes for deprecation
+###############################################################################
+
+class _deprecated_container:
+    # This class gives deprecation warning.
+    # When deprecated features are completely deleted, this should be removed as well.
+    # See https://github.com/sympy/sympy/pull/19368
+    def __init__(self, message, data):
+        super().__init__(data)
+        self.message = message
+
+    def warn(self):
+        sympy_deprecation_warning(
+            self.message,
+            deprecated_since_version="1.7",
+            active_deprecations_target="deprecated-diffgeom-mutable",
+            stacklevel=4
+        )
+
+    def __iter__(self):
+        self.warn()
+        return super().__iter__()
+
+    def __getitem__(self, key):
+        self.warn()
+        return super().__getitem__(key)
+
+    def __contains__(self, key):
+        self.warn()
+        return super().__contains__(key)
+
+
+class _deprecated_list(_deprecated_container, list):
+    pass
+
+
+class _deprecated_dict(_deprecated_container, dict):
+    pass
+
+
+# Import at end to avoid cyclic imports
+from sympy.simplify.simplify import simplify
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/rn.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/rn.py
new file mode 100644
index 0000000000000000000000000000000000000000..897c7e82bc804d260612f79c820af92632f3b281
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/rn.py
@@ -0,0 +1,143 @@
+"""Predefined R^n manifolds together with common coord. systems.
+
+Coordinate systems are predefined as well as the transformation laws between
+them.
+
+Coordinate functions can be accessed as attributes of the manifold (eg `R2.x`),
+as attributes of the coordinate systems (eg `R2_r.x` and `R2_p.theta`), or by
+using the usual `coord_sys.coord_function(index, name)` interface.
+"""
+
+from typing import Any
+import warnings
+
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, atan2, cos, sin)
+from .diffgeom import Manifold, Patch, CoordSystem
+
+__all__ = [
+    'R2', 'R2_origin', 'relations_2d', 'R2_r', 'R2_p',
+    'R3', 'R3_origin', 'relations_3d', 'R3_r', 'R3_c', 'R3_s'
+]
+
+###############################################################################
+# R2
+###############################################################################
+R2: Any = Manifold('R^2', 2)
+
+R2_origin: Any = Patch('origin', R2)
+
+x, y = symbols('x y', real=True)
+r, theta = symbols('rho theta', nonnegative=True)
+
+relations_2d = {
+    ('rectangular', 'polar'): [(x, y), (sqrt(x**2 + y**2), atan2(y, x))],
+    ('polar', 'rectangular'): [(r, theta), (r*cos(theta), r*sin(theta))],
+}
+
+R2_r: Any = CoordSystem('rectangular', R2_origin, (x, y), relations_2d)
+R2_p: Any = CoordSystem('polar', R2_origin, (r, theta), relations_2d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, r, theta = symbols('x y r theta', cls=Dummy)
+    R2_r.connect_to(R2_p, [x, y],
+                        [sqrt(x**2 + y**2), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R2_p.connect_to(R2_r, [r, theta],
+                        [r*cos(theta), r*sin(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions and adding shortcuts for them to the
+# manifold and the patch.
+R2.x, R2.y = R2_origin.x, R2_origin.y = R2_r.x, R2_r.y = R2_r.coord_functions()
+R2.r, R2.theta = R2_origin.r, R2_origin.theta = R2_p.r, R2_p.theta = R2_p.coord_functions()
+
+# Defining the basis vector fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.e_x, R2.e_y = R2_origin.e_x, R2_origin.e_y = R2_r.e_x, R2_r.e_y = R2_r.base_vectors()
+R2.e_r, R2.e_theta = R2_origin.e_r, R2_origin.e_theta = R2_p.e_r, R2_p.e_theta = R2_p.base_vectors()
+
+# Defining the basis oneform fields and adding shortcuts for them to the
+# manifold and the patch.
+R2.dx, R2.dy = R2_origin.dx, R2_origin.dy = R2_r.dx, R2_r.dy = R2_r.base_oneforms()
+R2.dr, R2.dtheta = R2_origin.dr, R2_origin.dtheta = R2_p.dr, R2_p.dtheta = R2_p.base_oneforms()
+
+###############################################################################
+# R3
+###############################################################################
+R3: Any = Manifold('R^3', 3)
+
+R3_origin: Any = Patch('origin', R3)
+
+x, y, z = symbols('x y z', real=True)
+rho, psi, r, theta, phi = symbols('rho psi r theta phi', nonnegative=True)
+
+relations_3d = {
+    ('rectangular', 'cylindrical'): [(x, y, z),
+                                     (sqrt(x**2 + y**2), atan2(y, x), z)],
+    ('cylindrical', 'rectangular'): [(rho, psi, z),
+                                     (rho*cos(psi), rho*sin(psi), z)],
+    ('rectangular', 'spherical'): [(x, y, z),
+                                   (sqrt(x**2 + y**2 + z**2),
+                                    acos(z/sqrt(x**2 + y**2 + z**2)),
+                                    atan2(y, x))],
+    ('spherical', 'rectangular'): [(r, theta, phi),
+                                   (r*sin(theta)*cos(phi),
+                                    r*sin(theta)*sin(phi),
+                                    r*cos(theta))],
+    ('cylindrical', 'spherical'): [(rho, psi, z),
+                                   (sqrt(rho**2 + z**2),
+                                    acos(z/sqrt(rho**2 + z**2)),
+                                    psi)],
+    ('spherical', 'cylindrical'): [(r, theta, phi),
+                                   (r*sin(theta), phi, r*cos(theta))],
+}
+
+R3_r: Any = CoordSystem('rectangular', R3_origin, (x, y, z), relations_3d)
+R3_c: Any = CoordSystem('cylindrical', R3_origin, (rho, psi, z), relations_3d)
+R3_s: Any = CoordSystem('spherical', R3_origin, (r, theta, phi), relations_3d)
+
+# support deprecated feature
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore")
+    x, y, z, rho, psi, r, theta, phi = symbols('x y z rho psi r theta phi', cls=Dummy)
+    R3_r.connect_to(R3_c, [x, y, z],
+                        [sqrt(x**2 + y**2), atan2(y, x), z],
+                    inverse=False, fill_in_gaps=False)
+    R3_c.connect_to(R3_r, [rho, psi, z],
+                        [rho*cos(psi), rho*sin(psi), z],
+                    inverse=False, fill_in_gaps=False)
+    ## rectangular <-> spherical
+    R3_r.connect_to(R3_s, [x, y, z],
+                        [sqrt(x**2 + y**2 + z**2), acos(z/
+                                sqrt(x**2 + y**2 + z**2)), atan2(y, x)],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_r, [r, theta, phi],
+                        [r*sin(theta)*cos(phi), r*sin(
+                            theta)*sin(phi), r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+    ## cylindrical <-> spherical
+    R3_c.connect_to(R3_s, [rho, psi, z],
+                        [sqrt(rho**2 + z**2), acos(z/sqrt(rho**2 + z**2)), psi],
+                    inverse=False, fill_in_gaps=False)
+    R3_s.connect_to(R3_c, [r, theta, phi],
+                        [r*sin(theta), phi, r*cos(theta)],
+                    inverse=False, fill_in_gaps=False)
+
+# Defining the basis coordinate functions.
+R3_r.x, R3_r.y, R3_r.z = R3_r.coord_functions()
+R3_c.rho, R3_c.psi, R3_c.z = R3_c.coord_functions()
+R3_s.r, R3_s.theta, R3_s.phi = R3_s.coord_functions()
+
+# Defining the basis vector fields.
+R3_r.e_x, R3_r.e_y, R3_r.e_z = R3_r.base_vectors()
+R3_c.e_rho, R3_c.e_psi, R3_c.e_z = R3_c.base_vectors()
+R3_s.e_r, R3_s.e_theta, R3_s.e_phi = R3_s.base_vectors()
+
+# Defining the basis oneform fields.
+R3_r.dx, R3_r.dy, R3_r.dz = R3_r.base_oneforms()
+R3_c.drho, R3_c.dpsi, R3_c.dz = R3_c.base_oneforms()
+R3_s.dr, R3_s.dtheta, R3_s.dphi = R3_s.base_oneforms()
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..730615199de9e07d269c4bfc731eaf4806bd16d1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_class_structure.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_class_structure.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6b1e19ec14eabcd96f580753fc1fa483ddfcb916
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_class_structure.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_diffgeom.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_diffgeom.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73100b1cd4357e9d9efd4e0a4e01d25a244c16f5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_diffgeom.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_function_diffgeom_book.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_function_diffgeom_book.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a653a6ff4c8fc3eaf5b5d2db5083116fffb2f58b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_function_diffgeom_book.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_hyperbolic_space.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_hyperbolic_space.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a984a54929badb865096a6b4c52f6f9e2370f938
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/__pycache__/test_hyperbolic_space.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_class_structure.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_class_structure.py
new file mode 100644
index 0000000000000000000000000000000000000000..c649fd9fcb9acdf1f410a021966c6e0fee62cc2b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_class_structure.py
@@ -0,0 +1,33 @@
+from sympy.diffgeom import Manifold, Patch, CoordSystem, Point
+from sympy.core.function import Function
+from sympy.core.symbol import symbols
+from sympy.testing.pytest import warns_deprecated_sympy
+
+m = Manifold('m', 2)
+p = Patch('p', m)
+a, b = symbols('a b')
+cs = CoordSystem('cs', p, [a, b])
+x, y = symbols('x y')
+f = Function('f')
+s1, s2 = cs.coord_functions()
+v1, v2 = cs.base_vectors()
+f1, f2 = cs.base_oneforms()
+
+def test_point():
+    point = Point(cs, [x, y])
+    assert point != Point(cs, [2, y])
+    #TODO assert point.subs(x, 2) == Point(cs, [2, y])
+    #TODO assert point.free_symbols == set([x, y])
+
+def test_subs():
+    assert s1.subs(s1, s2) == s2
+    assert v1.subs(v1, v2) == v2
+    assert f1.subs(f1, f2) == f2
+    assert (x*f(s1) + y).subs(s1, s2) == x*f(s2) + y
+    assert (f(s1)*v1).subs(v1, v2) == f(s1)*v2
+    assert (y*f(s1)*f1).subs(f1, f2) == y*f(s1)*f2
+
+def test_deprecated():
+    with warns_deprecated_sympy():
+        cs_wname = CoordSystem('cs', p, ['a', 'b'])
+        assert cs_wname == cs_wname.func(*cs_wname.args)
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_diffgeom.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_diffgeom.py
new file mode 100644
index 0000000000000000000000000000000000000000..7c3c9265785896b8f4ffa3a2b41816ca90579758
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_diffgeom.py
@@ -0,0 +1,342 @@
+from sympy.core import Lambda, Symbol, symbols
+from sympy.diffgeom.rn import R2, R2_p, R2_r, R3_r, R3_c, R3_s, R2_origin
+from sympy.diffgeom import (Manifold, Patch, CoordSystem, Commutator, Differential, TensorProduct,
+        WedgeProduct, BaseCovarDerivativeOp, CovarDerivativeOp, LieDerivative,
+        covariant_order, contravariant_order, twoform_to_matrix, metric_to_Christoffel_1st,
+        metric_to_Christoffel_2nd, metric_to_Riemann_components,
+        metric_to_Ricci_components, intcurve_diffequ, intcurve_series)
+from sympy.simplify import trigsimp, simplify
+from sympy.functions import sqrt, atan2, sin
+from sympy.matrices import Matrix
+from sympy.testing.pytest import raises, nocache_fail
+from sympy.testing.pytest import warns_deprecated_sympy
+
+TP = TensorProduct
+
+
+def test_coordsys_transform():
+    # test inverse transforms
+    p, q, r, s = symbols('p q r s')
+    rel = {('first', 'second'): [(p, q), (q, -p)]}
+    R2_pq = CoordSystem('first', R2_origin, [p, q], rel)
+    R2_rs = CoordSystem('second', R2_origin, [r, s], rel)
+    r, s = R2_rs.symbols
+    assert R2_rs.transform(R2_pq) == Matrix([[-s], [r]])
+
+    # inverse transform impossible case
+    a, b = symbols('a b', positive=True)
+    rel = {('first', 'second'): [(a,), (-a,)]}
+    R2_a = CoordSystem('first', R2_origin, [a], rel)
+    R2_b = CoordSystem('second', R2_origin, [b], rel)
+    # This transformation is uninvertible because there is no positive a, b satisfying a = -b
+    with raises(NotImplementedError):
+        R2_b.transform(R2_a)
+
+    # inverse transform ambiguous case
+    c, d = symbols('c d')
+    rel = {('first', 'second'): [(c,), (c**2,)]}
+    R2_c = CoordSystem('first', R2_origin, [c], rel)
+    R2_d = CoordSystem('second', R2_origin, [d], rel)
+    # The transform method should throw if it finds multiple inverses for a coordinate transformation.
+    with raises(ValueError):
+        R2_d.transform(R2_c)
+
+    # test indirect transformation
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b)],
+        ('C2', 'C3'): [(c, d), (3*c, 2*d)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, d/3])
+    assert C1.transform(C3) == Matrix([6*a, 6*b])
+    assert C3.transform(C1) == Matrix([e/6, f/6])
+    assert C3.transform(C2) == Matrix([e/3, f/2])
+
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): [(a, b), (2*a, 3*b + 1)],
+        ('C3', 'C2'): [(e, f), (-e - 2, 2*f)]}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+    # old signature uses Lambda
+    a, b, c, d, e, f = symbols('a, b, c, d, e, f')
+    rel = {('C1', 'C2'): Lambda((a, b), (2*a, 3*b + 1)),
+        ('C3', 'C2'): Lambda((e, f), (-e - 2, 2*f))}
+    C1 = CoordSystem('C1', R2_origin, (a, b), rel)
+    C2 = CoordSystem('C2', R2_origin, (c, d), rel)
+    C3 = CoordSystem('C3', R2_origin, (e, f), rel)
+    a, b = C1.symbols
+    c, d = C2.symbols
+    e, f = C3.symbols
+    assert C2.transform(C1) == Matrix([c/2, (d - 1)/3])
+    assert C1.transform(C3) == Matrix([-2*a - 2, (3*b + 1)/2])
+    assert C3.transform(C1) == Matrix([-e/2 - 1, (2*f - 1)/3])
+    assert C3.transform(C2) == Matrix([-e - 2, 2*f])
+
+
+def test_R2():
+    x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0', real=True)
+    point_r = R2_r.point([x0, y0])
+    point_p = R2_p.point([r0, theta0])
+
+    # r**2 = x**2 + y**2
+    assert (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_r) == 0
+    assert trigsimp( (R2.r**2 - R2.x**2 - R2.y**2).rcall(point_p) ) == 0
+    assert trigsimp(R2.e_r(R2.x**2 + R2.y**2).rcall(point_p).doit()) == 2*r0
+
+    # polar->rect->polar == Id
+    a, b = symbols('a b', positive=True)
+    m = Matrix([[a], [b]])
+
+    #TODO assert m == R2_r.transform(R2_p, R2_p.transform(R2_r, [a, b])).applyfunc(simplify)
+    assert m == R2_p.transform(R2_r, R2_r.transform(R2_p, m)).applyfunc(simplify)
+
+    # deprecated method
+    with warns_deprecated_sympy():
+        assert m == R2_p.coord_tuple_transform_to(
+            R2_r, R2_r.coord_tuple_transform_to(R2_p, m)).applyfunc(simplify)
+
+
+def test_R3():
+    a, b, c = symbols('a b c', positive=True)
+    m = Matrix([[a], [b], [c]])
+
+    assert m == R3_c.transform(R3_r, R3_r.transform(R3_c, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_c, R3_c.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_r, R3_r.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_r.transform(R3_s, R3_s.transform(R3_r, m)).applyfunc(simplify)
+    assert m == R3_s.transform(
+        R3_c, R3_c.transform(R3_s, m)).applyfunc(simplify)
+    #TODO assert m == R3_c.transform(R3_s, R3_s.transform(R3_c, m)).applyfunc(simplify)
+
+    with warns_deprecated_sympy():
+        assert m == R3_c.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_c, R3_c.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_r, R3_r.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_r.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_r, m)).applyfunc(simplify)
+        assert m == R3_s.coord_tuple_transform_to(
+            R3_c, R3_c.coord_tuple_transform_to(R3_s, m)).applyfunc(simplify)
+        #TODO assert m == R3_c.coord_tuple_transform_to(R3_s, R3_s.coord_tuple_transform_to(R3_c, m)).applyfunc(simplify)
+
+
+def test_CoordinateSymbol():
+    x, y = R2_r.symbols
+    r, theta = R2_p.symbols
+    assert y.rewrite(R2_p) == r*sin(theta)
+
+
+def test_point():
+    x, y = symbols('x, y')
+    p = R2_r.point([x, y])
+    assert p.free_symbols == {x, y}
+    assert p.coords(R2_r) == p.coords() == Matrix([x, y])
+    assert p.coords(R2_p) == Matrix([sqrt(x**2 + y**2), atan2(y, x)])
+
+
+def test_commutator():
+    assert Commutator(R2.e_x, R2.e_y) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_x) == 0
+    assert Commutator(R2.x*R2.e_x, R2.x*R2.e_y) == R2.x*R2.e_y
+    c = Commutator(R2.e_x, R2.e_r)
+    assert c(R2.x) == R2.y*(R2.x**2 + R2.y**2)**(-1)*sin(R2.theta)
+
+
+def test_differential():
+    xdy = R2.x*R2.dy
+    dxdy = Differential(xdy)
+    assert xdy.rcall(None) == xdy
+    assert dxdy(R2.e_x, R2.e_y) == 1
+    assert dxdy(R2.e_x, R2.x*R2.e_y) == R2.x
+    assert Differential(dxdy) == 0
+
+
+def test_products():
+    assert TensorProduct(
+        R2.dx, R2.dy)(R2.e_x, R2.e_y) == R2.dx(R2.e_x)*R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.dx, R2.dy)(None, R2.e_y) == R2.dx
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x, None) == R2.dy
+    assert TensorProduct(R2.dx, R2.dy)(R2.e_x) == R2.dy
+    assert TensorProduct(R2.x, R2.dx) == R2.x*R2.dx
+    assert TensorProduct(
+        R2.e_x, R2.e_y)(R2.x, R2.y) == R2.e_x(R2.x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.e_x, R2.e_y)(None, R2.y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x, None) == R2.e_y
+    assert TensorProduct(R2.e_x, R2.e_y)(R2.x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.dx, R2.e_y)(R2.e_x, R2.y) == R2.dx(R2.e_x) * R2.e_y(R2.y) == 1
+    assert TensorProduct(R2.dx, R2.e_y)(None, R2.y) == R2.dx
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x, None) == R2.e_y
+    assert TensorProduct(R2.dx, R2.e_y)(R2.e_x) == R2.e_y
+    assert TensorProduct(R2.x, R2.e_x) == R2.x * R2.e_x
+    assert TensorProduct(
+        R2.e_x, R2.dy)(R2.x, R2.e_y) == R2.e_x(R2.x) * R2.dy(R2.e_y) == 1
+    assert TensorProduct(R2.e_x, R2.dy)(None, R2.e_y) == R2.e_x
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x, None) == R2.dy
+    assert TensorProduct(R2.e_x, R2.dy)(R2.x) == R2.dy
+    assert TensorProduct(R2.e_y,R2.e_x)(R2.x**2 + R2.y**2,R2.x**2 + R2.y**2) == 4*R2.x*R2.y
+
+    assert WedgeProduct(R2.dx, R2.dy)(R2.e_x, R2.e_y) == 1
+    assert WedgeProduct(R2.e_x, R2.e_y)(R2.x, R2.y) == 1
+
+
+def test_lie_derivative():
+    assert LieDerivative(R2.e_x, R2.y) == R2.e_x(R2.y) == 0
+    assert LieDerivative(R2.e_x, R2.x) == R2.e_x(R2.x) == 1
+    assert LieDerivative(R2.e_x, R2.e_x) == Commutator(R2.e_x, R2.e_x) == 0
+    assert LieDerivative(R2.e_x, R2.e_r) == Commutator(R2.e_x, R2.e_r)
+    assert LieDerivative(R2.e_x + R2.e_y, R2.x) == 1
+    assert LieDerivative(
+        R2.e_x, TensorProduct(R2.dx, R2.dy))(R2.e_x, R2.e_y) == 0
+
+
+@nocache_fail
+def test_covar_deriv():
+    ch = metric_to_Christoffel_2nd(TP(R2.dx, R2.dx) + TP(R2.dy, R2.dy))
+    cvd = BaseCovarDerivativeOp(R2_r, 0, ch)
+    assert cvd(R2.x) == 1
+    # This line fails if the cache is disabled:
+    assert cvd(R2.x*R2.e_x) == R2.e_x
+    cvd = CovarDerivativeOp(R2.x*R2.e_x, ch)
+    assert cvd(R2.x) == R2.x
+    assert cvd(R2.x*R2.e_x) == R2.x*R2.e_x
+
+
+def test_intcurve_diffequ():
+    t = symbols('t')
+    start_point = R2_r.point([1, 0])
+    vector_field = -R2.y*R2.e_x + R2.x*R2.e_y
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point)
+    assert str(equations) == '[f_1(t) + Derivative(f_0(t), t), -f_0(t) + Derivative(f_1(t), t)]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+    equations, init_cond = intcurve_diffequ(vector_field, t, start_point, R2_p)
+    assert str(
+        equations) == '[Derivative(f_0(t), t), Derivative(f_1(t), t) - 1]'
+    assert str(init_cond) == '[f_0(0) - 1, f_1(0)]'
+
+
+def test_helpers_and_coordinate_dependent():
+    one_form = R2.dr + R2.dx
+    two_form = Differential(R2.x*R2.dr + R2.r*R2.dx)
+    three_form = Differential(
+        R2.y*two_form) + Differential(R2.x*Differential(R2.r*R2.dr))
+    metric = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dy, R2.dy)
+    metric_ambig = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dr, R2.dr)
+    misform_a = TensorProduct(R2.dr, R2.dr) + R2.dr
+    misform_b = R2.dr**4
+    misform_c = R2.dx*R2.dy
+    twoform_not_sym = TensorProduct(R2.dx, R2.dx) + TensorProduct(R2.dx, R2.dy)
+    twoform_not_TP = WedgeProduct(R2.dx, R2.dy)
+
+    one_vector = R2.e_x + R2.e_y
+    two_vector = TensorProduct(R2.e_x, R2.e_y)
+    three_vector = TensorProduct(R2.e_x, R2.e_y, R2.e_x)
+    two_wp = WedgeProduct(R2.e_x,R2.e_y)
+
+    assert covariant_order(one_form) == 1
+    assert covariant_order(two_form) == 2
+    assert covariant_order(three_form) == 3
+    assert covariant_order(two_form + metric) == 2
+    assert covariant_order(two_form + metric_ambig) == 2
+    assert covariant_order(two_form + twoform_not_sym) == 2
+    assert covariant_order(two_form + twoform_not_TP) == 2
+
+    assert contravariant_order(one_vector) == 1
+    assert contravariant_order(two_vector) == 2
+    assert contravariant_order(three_vector) == 3
+    assert contravariant_order(two_vector + two_wp) == 2
+
+    raises(ValueError, lambda: covariant_order(misform_a))
+    raises(ValueError, lambda: covariant_order(misform_b))
+    raises(ValueError, lambda: covariant_order(misform_c))
+
+    assert twoform_to_matrix(metric) == Matrix([[1, 0], [0, 1]])
+    assert twoform_to_matrix(twoform_not_sym) == Matrix([[1, 0], [1, 0]])
+    assert twoform_to_matrix(twoform_not_TP) == Matrix([[0, -1], [1, 0]])
+
+    raises(ValueError, lambda: twoform_to_matrix(one_form))
+    raises(ValueError, lambda: twoform_to_matrix(three_form))
+    raises(ValueError, lambda: twoform_to_matrix(metric_ambig))
+
+    raises(ValueError, lambda: metric_to_Christoffel_1st(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Christoffel_2nd(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Riemann_components(twoform_not_sym))
+    raises(ValueError, lambda: metric_to_Ricci_components(twoform_not_sym))
+
+
+def test_correct_arguments():
+    raises(ValueError, lambda: R2.e_x(R2.e_x))
+    raises(ValueError, lambda: R2.e_x(R2.dx))
+
+    raises(ValueError, lambda: Commutator(R2.e_x, R2.x))
+    raises(ValueError, lambda: Commutator(R2.dx, R2.e_x))
+
+    raises(ValueError, lambda: Differential(Differential(R2.e_x)))
+
+    raises(ValueError, lambda: R2.dx(R2.x))
+
+    raises(ValueError, lambda: LieDerivative(R2.dx, R2.dx))
+    raises(ValueError, lambda: LieDerivative(R2.x, R2.dx))
+
+    raises(ValueError, lambda: CovarDerivativeOp(R2.dx, []))
+    raises(ValueError, lambda: CovarDerivativeOp(R2.x, []))
+
+    a = Symbol('a')
+    raises(ValueError, lambda: intcurve_series(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_series(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: intcurve_diffequ(R2.dx, a, R2_r.point([1, 2])))
+    raises(ValueError, lambda: intcurve_diffequ(R2.x, a, R2_r.point([1, 2])))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x + R2.dx))
+    raises(ValueError, lambda: covariant_order(R2.e_x + R2.dx))
+
+    raises(ValueError, lambda: contravariant_order(R2.e_x*R2.e_y))
+    raises(ValueError, lambda: covariant_order(R2.dx*R2.dy))
+
+def test_simplify():
+    x, y = R2_r.coord_functions()
+    dx, dy = R2_r.base_oneforms()
+    ex, ey = R2_r.base_vectors()
+    assert simplify(x) == x
+    assert simplify(x*y) == x*y
+    assert simplify(dx*dy) == dx*dy
+    assert simplify(ex*ey) == ex*ey
+    assert ((1-x)*dx)/(1-x)**2 == dx/(1-x)
+
+
+def test_issue_17917():
+    X = R2.x*R2.e_x - R2.y*R2.e_y
+    Y = (R2.x**2 + R2.y**2)*R2.e_x - R2.x*R2.y*R2.e_y
+    assert LieDerivative(X, Y).expand() == (
+        R2.x**2*R2.e_x - 3*R2.y**2*R2.e_x - R2.x*R2.y*R2.e_y)
+
+def test_deprecations():
+    m = Manifold('M', 2)
+    p = Patch('P', m)
+    with warns_deprecated_sympy():
+        CoordSystem('Car2d', p, names=['x', 'y'])
+
+    with warns_deprecated_sympy():
+        c = CoordSystem('Car2d', p, ['x', 'y'])
+
+    with warns_deprecated_sympy():
+        list(m.patches)
+
+    with warns_deprecated_sympy():
+        list(c.transforms)
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_function_diffgeom_book.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_function_diffgeom_book.py
new file mode 100644
index 0000000000000000000000000000000000000000..44d9623bc34ab73c7d575d9d9fd5b6d84f8e4a94
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_function_diffgeom_book.py
@@ -0,0 +1,145 @@
+from sympy.diffgeom.rn import R2, R2_p, R2_r, R3_r
+from sympy.diffgeom import intcurve_series, Differential, WedgeProduct
+from sympy.core import symbols, Function, Derivative
+from sympy.simplify import trigsimp, simplify
+from sympy.functions import sqrt, atan2, sin, cos
+from sympy.matrices import Matrix
+
+# Most of the functionality is covered in the
+# test_functional_diffgeom_ch* tests which are based on the
+# example from the paper of Sussman and Wisdom.
+# If they do not cover something, additional tests are added in other test
+# functions.
+
+# From "Functional Differential Geometry" as of 2011
+# by Sussman and Wisdom.
+
+
+def test_functional_diffgeom_ch2():
+    x0, y0, r0, theta0 = symbols('x0, y0, r0, theta0', real=True)
+    x, y = symbols('x, y', real=True)
+    f = Function('f')
+
+    assert (R2_p.point_to_coords(R2_r.point([x0, y0])) ==
+           Matrix([sqrt(x0**2 + y0**2), atan2(y0, x0)]))
+    assert (R2_r.point_to_coords(R2_p.point([r0, theta0])) ==
+           Matrix([r0*cos(theta0), r0*sin(theta0)]))
+
+    assert R2_p.jacobian(R2_r, [r0, theta0]) == Matrix(
+        [[cos(theta0), -r0*sin(theta0)], [sin(theta0), r0*cos(theta0)]])
+
+    field = f(R2.x, R2.y)
+    p1_in_rect = R2_r.point([x0, y0])
+    p1_in_polar = R2_p.point([sqrt(x0**2 + y0**2), atan2(y0, x0)])
+    assert field.rcall(p1_in_rect) == f(x0, y0)
+    assert field.rcall(p1_in_polar) == f(x0, y0)
+
+    p_r = R2_r.point([x0, y0])
+    p_p = R2_p.point([r0, theta0])
+    assert R2.x(p_r) == x0
+    assert R2.x(p_p) == r0*cos(theta0)
+    assert R2.r(p_p) == r0
+    assert R2.r(p_r) == sqrt(x0**2 + y0**2)
+    assert R2.theta(p_r) == atan2(y0, x0)
+
+    h = R2.x*R2.r**2 + R2.y**3
+    assert h.rcall(p_r) == x0*(x0**2 + y0**2) + y0**3
+    assert h.rcall(p_p) == r0**3*sin(theta0)**3 + r0**3*cos(theta0)
+
+
+def test_functional_diffgeom_ch3():
+    x0, y0 = symbols('x0, y0', real=True)
+    x, y, t = symbols('x, y, t', real=True)
+    f = Function('f')
+    b1 = Function('b1')
+    b2 = Function('b2')
+    p_r = R2_r.point([x0, y0])
+
+    s_field = f(R2.x, R2.y)
+    v_field = b1(R2.x)*R2.e_x + b2(R2.y)*R2.e_y
+    assert v_field.rcall(s_field).rcall(p_r).doit() == b1(
+        x0)*Derivative(f(x0, y0), x0) + b2(y0)*Derivative(f(x0, y0), y0)
+
+    assert R2.e_x(R2.r**2).rcall(p_r) == 2*x0
+    v = R2.e_x + 2*R2.e_y
+    s = R2.r**2 + 3*R2.x
+    assert v.rcall(s).rcall(p_r).doit() == 2*x0 + 4*y0 + 3
+
+    circ = -R2.y*R2.e_x + R2.x*R2.e_y
+    series = intcurve_series(circ, t, R2_r.point([1, 0]), coeffs=True)
+    series_x, series_y = zip(*series)
+    assert all(
+        term == cos(t).taylor_term(i, t) for i, term in enumerate(series_x))
+    assert all(
+        term == sin(t).taylor_term(i, t) for i, term in enumerate(series_y))
+
+
+def test_functional_diffgeom_ch4():
+    x0, y0, theta0 = symbols('x0, y0, theta0', real=True)
+    x, y, r, theta = symbols('x, y, r, theta', real=True)
+    r0 = symbols('r0', positive=True)
+    f = Function('f')
+    b1 = Function('b1')
+    b2 = Function('b2')
+    p_r = R2_r.point([x0, y0])
+    p_p = R2_p.point([r0, theta0])
+
+    f_field = b1(R2.x, R2.y)*R2.dx + b2(R2.x, R2.y)*R2.dy
+    assert f_field.rcall(R2.e_x).rcall(p_r) == b1(x0, y0)
+    assert f_field.rcall(R2.e_y).rcall(p_r) == b2(x0, y0)
+
+    s_field_r = f(R2.x, R2.y)
+    df = Differential(s_field_r)
+    assert df(R2.e_x).rcall(p_r).doit() == Derivative(f(x0, y0), x0)
+    assert df(R2.e_y).rcall(p_r).doit() == Derivative(f(x0, y0), y0)
+
+    s_field_p = f(R2.r, R2.theta)
+    df = Differential(s_field_p)
+    assert trigsimp(df(R2.e_x).rcall(p_p).doit()) == (
+        cos(theta0)*Derivative(f(r0, theta0), r0) -
+        sin(theta0)*Derivative(f(r0, theta0), theta0)/r0)
+    assert trigsimp(df(R2.e_y).rcall(p_p).doit()) == (
+        sin(theta0)*Derivative(f(r0, theta0), r0) +
+        cos(theta0)*Derivative(f(r0, theta0), theta0)/r0)
+
+    assert R2.dx(R2.e_x).rcall(p_r) == 1
+    assert R2.dx(R2.e_x) == 1
+    assert R2.dx(R2.e_y).rcall(p_r) == 0
+    assert R2.dx(R2.e_y) == 0
+
+    circ = -R2.y*R2.e_x + R2.x*R2.e_y
+    assert R2.dx(circ).rcall(p_r).doit() == -y0
+    assert R2.dy(circ).rcall(p_r) == x0
+    assert R2.dr(circ).rcall(p_r) == 0
+    assert simplify(R2.dtheta(circ).rcall(p_r)) == 1
+
+    assert (circ - R2.e_theta).rcall(s_field_r).rcall(p_r) == 0
+
+
+def test_functional_diffgeom_ch6():
+    u0, u1, u2, v0, v1, v2, w0, w1, w2 = symbols('u0:3, v0:3, w0:3', real=True)
+
+    u = u0*R2.e_x + u1*R2.e_y
+    v = v0*R2.e_x + v1*R2.e_y
+    wp = WedgeProduct(R2.dx, R2.dy)
+    assert wp(u, v) == u0*v1 - u1*v0
+
+    u = u0*R3_r.e_x + u1*R3_r.e_y + u2*R3_r.e_z
+    v = v0*R3_r.e_x + v1*R3_r.e_y + v2*R3_r.e_z
+    w = w0*R3_r.e_x + w1*R3_r.e_y + w2*R3_r.e_z
+    wp = WedgeProduct(R3_r.dx, R3_r.dy, R3_r.dz)
+    assert wp(
+        u, v, w) == Matrix(3, 3, [u0, u1, u2, v0, v1, v2, w0, w1, w2]).det()
+
+    a, b, c = symbols('a, b, c', cls=Function)
+    a_f = a(R3_r.x, R3_r.y, R3_r.z)
+    b_f = b(R3_r.x, R3_r.y, R3_r.z)
+    c_f = c(R3_r.x, R3_r.y, R3_r.z)
+    theta = a_f*R3_r.dx + b_f*R3_r.dy + c_f*R3_r.dz
+    dtheta = Differential(theta)
+    da = Differential(a_f)
+    db = Differential(b_f)
+    dc = Differential(c_f)
+    expr = dtheta - WedgeProduct(
+        da, R3_r.dx) - WedgeProduct(db, R3_r.dy) - WedgeProduct(dc, R3_r.dz)
+    assert expr.rcall(R3_r.e_x, R3_r.e_y) == 0
diff --git a/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_hyperbolic_space.py b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_hyperbolic_space.py
new file mode 100644
index 0000000000000000000000000000000000000000..48ddc7f8065f2b69bcd8eca4726a21c5901514ec
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/diffgeom/tests/test_hyperbolic_space.py
@@ -0,0 +1,91 @@
+r'''
+unit test describing the hyperbolic half-plane with the Poincare metric. This
+is a basic model of hyperbolic geometry on the (positive) half-space
+
+{(x,y) \in R^2 | y > 0}
+
+with the Riemannian metric
+
+ds^2 = (dx^2 + dy^2)/y^2
+
+It has constant negative scalar curvature = -2
+
+https://en.wikipedia.org/wiki/Poincare_half-plane_model
+'''
+from sympy.matrices.dense import diag
+from sympy.diffgeom import (twoform_to_matrix,
+                            metric_to_Christoffel_1st, metric_to_Christoffel_2nd,
+                            metric_to_Riemann_components, metric_to_Ricci_components)
+import sympy.diffgeom.rn
+from sympy.tensor.array import ImmutableDenseNDimArray
+
+
+def test_H2():
+    TP = sympy.diffgeom.TensorProduct
+    R2 = sympy.diffgeom.rn.R2
+    y = R2.y
+    dy = R2.dy
+    dx = R2.dx
+    g = (TP(dx, dx) + TP(dy, dy))*y**(-2)
+    automat = twoform_to_matrix(g)
+    mat = diag(y**(-2), y**(-2))
+    assert mat == automat
+
+    gamma1 = metric_to_Christoffel_1st(g)
+    assert gamma1[0, 0, 0] == 0
+    assert gamma1[0, 0, 1] == -y**(-3)
+    assert gamma1[0, 1, 0] == -y**(-3)
+    assert gamma1[0, 1, 1] == 0
+
+    assert gamma1[1, 1, 1] == -y**(-3)
+    assert gamma1[1, 1, 0] == 0
+    assert gamma1[1, 0, 1] == 0
+    assert gamma1[1, 0, 0] == y**(-3)
+
+    gamma2 = metric_to_Christoffel_2nd(g)
+    assert gamma2[0, 0, 0] == 0
+    assert gamma2[0, 0, 1] == -y**(-1)
+    assert gamma2[0, 1, 0] == -y**(-1)
+    assert gamma2[0, 1, 1] == 0
+
+    assert gamma2[1, 1, 1] == -y**(-1)
+    assert gamma2[1, 1, 0] == 0
+    assert gamma2[1, 0, 1] == 0
+    assert gamma2[1, 0, 0] == y**(-1)
+
+    Rm = metric_to_Riemann_components(g)
+    assert Rm[0, 0, 0, 0] == 0
+    assert Rm[0, 0, 0, 1] == 0
+    assert Rm[0, 0, 1, 0] == 0
+    assert Rm[0, 0, 1, 1] == 0
+
+    assert Rm[0, 1, 0, 0] == 0
+    assert Rm[0, 1, 0, 1] == -y**(-2)
+    assert Rm[0, 1, 1, 0] == y**(-2)
+    assert Rm[0, 1, 1, 1] == 0
+
+    assert Rm[1, 0, 0, 0] == 0
+    assert Rm[1, 0, 0, 1] == y**(-2)
+    assert Rm[1, 0, 1, 0] == -y**(-2)
+    assert Rm[1, 0, 1, 1] == 0
+
+    assert Rm[1, 1, 0, 0] == 0
+    assert Rm[1, 1, 0, 1] == 0
+    assert Rm[1, 1, 1, 0] == 0
+    assert Rm[1, 1, 1, 1] == 0
+
+    Ric = metric_to_Ricci_components(g)
+    assert Ric[0, 0] == -y**(-2)
+    assert Ric[0, 1] == 0
+    assert Ric[1, 0] == 0
+    assert Ric[0, 0] == -y**(-2)
+
+    assert Ric == ImmutableDenseNDimArray([-y**(-2), 0, 0, -y**(-2)], (2, 2))
+
+    ## scalar curvature is -2
+    #TODO - it would be nice to have index contraction built-in
+    R = (Ric[0, 0] + Ric[1, 1])*y**2
+    assert R == -2
+
+    ## Gauss curvature is -1
+    assert R/2 == -1
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/__init__.py b/.venv/lib/python3.12/site-packages/sympy/discrete/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..968c4caa0d4562b71285f414bfb70f43d0b35111
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/__init__.py
@@ -0,0 +1,20 @@
+"""This module contains functions which operate on discrete sequences.
+
+Transforms - ``fft``, ``ifft``, ``ntt``, ``intt``, ``fwht``, ``ifwht``,
+            ``mobius_transform``, ``inverse_mobius_transform``
+
+Convolutions - ``convolution``, ``convolution_fft``, ``convolution_ntt``,
+            ``convolution_fwht``, ``convolution_subset``,
+            ``covering_product``, ``intersecting_product``
+"""
+
+from .transforms import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from .convolutions import convolution, covering_product, intersecting_product
+
+__all__ = [
+    'fft', 'ifft', 'ntt', 'intt', 'fwht', 'ifwht', 'mobius_transform',
+    'inverse_mobius_transform',
+
+    'convolution', 'covering_product', 'intersecting_product',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1164fc0379d173ecc95d4637cd797c0b3798257f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/convolutions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/convolutions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28788b2d74d2c4f4a1bfe828a98c3870f24d36e7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/convolutions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/recurrences.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/recurrences.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..32a70329b7411cffdb715c4d21285e171b79a3f6
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/recurrences.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/transforms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/transforms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8cb5d2b0cd1273eb25a9cf49ec4794ac421e9d50
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/__pycache__/transforms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/convolutions.py b/.venv/lib/python3.12/site-packages/sympy/discrete/convolutions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac9a3dbbb26b8b117ea1ee99cf7ebabbd21322cc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/convolutions.py
@@ -0,0 +1,597 @@
+"""
+Convolution (using **FFT**, **NTT**, **FWHT**), Subset Convolution,
+Covering Product, Intersecting Product
+"""
+
+from sympy.core import S, sympify, Rational
+from sympy.core.function import expand_mul
+from sympy.discrete.transforms import (
+    fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.external.gmpy import MPZ, lcm
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def convolution(a, b, cycle=0, dps=None, prime=None, dyadic=None, subset=None):
+    """
+    Performs convolution by determining the type of desired
+    convolution using hints.
+
+    Exactly one of ``dps``, ``prime``, ``dyadic``, ``subset`` arguments
+    should be specified explicitly for identifying the type of convolution,
+    and the argument ``cycle`` can be specified optionally.
+
+    For the default arguments, linear convolution is performed using **FFT**.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    cycle : Integer
+        Specifies the length for doing cyclic convolution.
+    dps : Integer
+        Specifies the number of decimal digits for precision for
+        performing **FFT** on the sequence.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for
+        performing **NTT** on the sequence.
+    dyadic : bool
+        Identifies the convolution type as dyadic (*bitwise-XOR*)
+        convolution, which is performed using **FWHT**.
+    subset : bool
+        Identifies the convolution type as subset convolution.
+
+    Examples
+    ========
+
+    >>> from sympy import convolution, symbols, S, I
+    >>> u, v, w, x, y, z = symbols('u v w x y z')
+
+    >>> convolution([1 + 2*I, 4 + 3*I], [S(5)/4, 6], dps=3)
+    [1.25 + 2.5*I, 11.0 + 15.8*I, 24.0 + 18.0*I]
+    >>> convolution([1, 2, 3], [4, 5, 6], cycle=3)
+    [31, 31, 28]
+
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1)
+    [1283, 19351, 14219]
+    >>> convolution([111, 777], [888, 444], prime=19*2**10 + 1, cycle=2)
+    [15502, 19351]
+
+    >>> convolution([u, v], [x, y, z], dyadic=True)
+    [u*x + v*y, u*y + v*x, u*z, v*z]
+    >>> convolution([u, v], [x, y, z], dyadic=True, cycle=2)
+    [u*x + u*z + v*y, u*y + v*x + v*z]
+
+    >>> convolution([u, v, w], [x, y, z], subset=True)
+    [u*x, u*y + v*x, u*z + w*x, v*z + w*y]
+    >>> convolution([u, v, w], [x, y, z], subset=True, cycle=3)
+    [u*x + v*z + w*y, u*y + v*x, u*z + w*x]
+
+    """
+
+    c = as_int(cycle)
+    if c < 0:
+        raise ValueError("The length for cyclic convolution "
+                        "must be non-negative")
+
+    dyadic = True if dyadic else None
+    subset = True if subset else None
+    if sum(x is not None for x in (prime, dps, dyadic, subset)) > 1:
+        raise TypeError("Ambiguity in determining the type of convolution")
+
+    if prime is not None:
+        ls = convolution_ntt(a, b, prime=prime)
+        return ls if not c else [sum(ls[i::c]) % prime for i in range(c)]
+
+    if dyadic:
+        ls = convolution_fwht(a, b)
+    elif subset:
+        ls = convolution_subset(a, b)
+    else:
+        def loop(a):
+            dens = []
+            for i in a:
+                if isinstance(i, Rational) and i.q - 1:
+                    dens.append(i.q)
+                elif not isinstance(i, int):
+                    return
+            if dens:
+                l = lcm(*dens)
+                return [i*l if type(i) is int else i.p*(l//i.q) for i in a], l
+            # no lcm of den to deal with
+            return a, 1
+        ls = None
+        da = loop(a)
+        if da is not None:
+            db = loop(b)
+            if db is not None:
+                (ia, ma), (ib, mb) = da, db
+                den = ma*mb
+                ls = convolution_int(ia, ib)
+                if den != 1:
+                    ls = [Rational(i, den) for i in ls]
+        if ls is None:
+            ls = convolution_fft(a, b, dps)
+
+    return ls if not c else [sum(ls[i::c]) for i in range(c)]
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                       Convolution for Complex domain                       #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fft(a, b, dps=None):
+    """
+    Performs linear convolution using Fast Fourier Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import S, I
+    >>> from sympy.discrete.convolutions import convolution_fft
+
+    >>> convolution_fft([2, 3], [4, 5])
+    [8, 22, 15]
+    >>> convolution_fft([2, 5], [6, 7, 3])
+    [12, 44, 41, 15]
+    >>> convolution_fft([1 + 2*I, 4 + 3*I], [S(5)/4, 6])
+    [5/4 + 5*I/2, 11 + 63*I/4, 24 + 18*I]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b = a[:], b[:]
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fft(a, dps), fft(b, dps)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifft(a, dps)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Convolution for GF(p)                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_ntt(a, b, prime):
+    """
+    Performs linear convolution using Number Theoretic Transform.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.convolutions import convolution_ntt
+    >>> convolution_ntt([2, 3], [4, 5], prime=19*2**10 + 1)
+    [8, 22, 15]
+    >>> convolution_ntt([2, 5], [6, 7, 3], prime=19*2**10 + 1)
+    [12, 44, 41, 15]
+    >>> convolution_ntt([333, 555], [222, 666], prime=19*2**10 + 1)
+    [15555, 14219, 19404]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Convolution_theorem
+    .. [2] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    a, b, p = a[:], b[:], as_int(prime)
+    n = m = len(a) + len(b) - 1 # convolution size
+
+    if n > 0 and n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [0]*(n - len(a))
+    b += [0]*(n - len(b))
+
+    a, b = ntt(a, p), ntt(b, p)
+    a = [x*y % p for x, y in zip(a, b)]
+    a = intt(a, p)[:m]
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Convolution for 2**n-group                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_fwht(a, b):
+    """
+    Performs dyadic (*bitwise-XOR*) convolution using Fast Walsh Hadamard
+    Transform.
+
+    The convolution is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I
+    >>> from sympy.discrete.convolutions import convolution_fwht
+
+    >>> u, v, x, y = symbols('u v x y')
+    >>> convolution_fwht([u, v], [x, y])
+    [u*x + v*y, u*y + v*x]
+
+    >>> convolution_fwht([2, 3], [4, 5])
+    [23, 22]
+    >>> convolution_fwht([2, 5 + 4*I, 7], [6*I, 7, 3 + 4*I])
+    [56 + 68*I, -10 + 30*I, 6 + 50*I, 48 + 32*I]
+
+    >>> convolution_fwht([S(33)/7, S(55)/6, S(7)/4], [S(2)/3, 5])
+    [2057/42, 1870/63, 7/6, 35/4]
+
+    References
+    ==========
+
+    .. [1] https://www.radioeng.cz/fulltexts/2002/02_03_40_42.pdf
+    .. [2] https://en.wikipedia.org/wiki/Hadamard_transform
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = fwht(a), fwht(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = ifwht(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Subset Convolution                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_subset(a, b):
+    """
+    Performs Subset Convolution of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which convolution is performed.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S
+    >>> from sympy.discrete.convolutions import convolution_subset
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> convolution_subset([u, v], [x, y])
+    [u*x, u*y + v*x]
+    >>> convolution_subset([u, v, x], [y, z])
+    [u*y, u*z + v*y, x*y, x*z]
+
+    >>> convolution_subset([1, S(2)/3], [3, 4])
+    [3, 6]
+    >>> convolution_subset([1, 3, S(5)/7], [7])
+    [7, 21, 5, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    if not iterable(a) or not iterable(b):
+        raise TypeError("Expected a sequence of coefficients for convolution")
+
+    a = [sympify(arg) for arg in a]
+    b = [sympify(arg) for arg in b]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    c = [S.Zero]*n
+
+    for mask in range(n):
+        smask = mask
+        while smask > 0:
+            c[mask] += expand_mul(a[smask] * b[mask^smask])
+            smask = (smask - 1)&mask
+
+        c[mask] += expand_mul(a[smask] * b[mask^smask])
+
+    return c
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Covering Product                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def covering_product(a, b):
+    """
+    Returns the covering product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The covering product of given sequences is a sequence which contains
+    the sum of products of the elements of the given sequences grouped by
+    the *bitwise-OR* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which covering product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, covering_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> covering_product([u, v], [x, y])
+    [u*x, u*y + v*x + v*y]
+    >>> covering_product([u, v, x], [y, z])
+    [u*y, u*z + v*y + v*z, x*y, x*z]
+
+    >>> covering_product([1, S(2)/3], [3, 4 + 5*I])
+    [3, 26/3 + 25*I/3]
+    >>> covering_product([1, 3, S(5)/7], [7, 8])
+    [7, 53, 5, 40/7]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a), mobius_transform(b)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Intersecting Product                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def intersecting_product(a, b):
+    """
+    Returns the intersecting product of given sequences.
+
+    The indices of each argument, considered as bit strings, correspond to
+    subsets of a finite set.
+
+    The intersecting product of given sequences is the sequence which
+    contains the sum of products of the elements of the given sequences
+    grouped by the *bitwise-AND* of the corresponding indices.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset based on bitmasks (indices) requires the size of
+    sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    a, b : iterables
+        The sequences for which intersecting product is to be obtained.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols, S, I, intersecting_product
+    >>> u, v, x, y, z = symbols('u v x y z')
+
+    >>> intersecting_product([u, v], [x, y])
+    [u*x + u*y + v*x, v*y]
+    >>> intersecting_product([u, v, x], [y, z])
+    [u*y + u*z + v*y + x*y + x*z, v*z, 0, 0]
+
+    >>> intersecting_product([1, S(2)/3], [3, 4 + 5*I])
+    [9 + 5*I, 8/3 + 10*I/3]
+    >>> intersecting_product([1, 3, S(5)/7], [7, 8])
+    [327/7, 24, 0, 0]
+
+    References
+    ==========
+
+    .. [1] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+
+    """
+
+    if not a or not b:
+        return []
+
+    a, b = a[:], b[:]
+    n = max(len(a), len(b))
+
+    if n&(n - 1): # not a power of 2
+        n = 2**n.bit_length()
+
+    # padding with zeros
+    a += [S.Zero]*(n - len(a))
+    b += [S.Zero]*(n - len(b))
+
+    a, b = mobius_transform(a, subset=False), mobius_transform(b, subset=False)
+    a = [expand_mul(x*y) for x, y in zip(a, b)]
+    a = inverse_mobius_transform(a, subset=False)
+
+    return a
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                            Integer Convolutions                            #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def convolution_int(a, b):
+    """Return the convolution of two sequences as a list.
+
+    The iterables must consist solely of integers.
+
+    Parameters
+    ==========
+
+    a, b : Sequence
+        The sequences for which convolution is performed.
+
+    Explanation
+    ===========
+
+    This function performs the convolution of ``a`` and ``b`` by packing
+    each into a single integer, multiplying them together, and then
+    unpacking the result from the product.  The intuition behind this is
+    that if we evaluate some polynomial [1]:
+
+    .. math ::
+        1156x^6 + 3808x^5 + 8440x^4 + 14856x^3 + 16164x^2 + 14040x + 8100
+
+    at say $x = 10^5$ we obtain $1156038080844014856161641404008100$.
+    Note we can read of the coefficients for each term every five digits.
+    If the $x$ we chose to evaluate at is large enough, the same will hold
+    for the product.
+
+    The idea now is since big integer multiplication in libraries such
+    as GMP is highly optimised, this will be reasonably fast.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.convolutions import convolution_int
+
+    >>> convolution_int([2, 3], [4, 5])
+    [8, 22, 15]
+    >>> convolution_int([1, 1, -1], [1, 1])
+    [1, 2, 0, -1]
+
+    References
+    ==========
+
+    .. [1] Fateman, Richard J.
+           Can you save time in multiplying polynomials by encoding them as integers?
+           University of California, Berkeley, California (2004).
+           https://people.eecs.berkeley.edu/~fateman/papers/polysbyGMP.pdf
+    """
+    # An upper bound on the largest coefficient in p(x)q(x) is given by (1 + min(dp, dq))N(p)N(q)
+    # where dp = deg(p), dq = deg(q), N(f) denotes the coefficient of largest modulus in f [1]
+    B = max(abs(c) for c in a)*max(abs(c) for c in b)*(1 + min(len(a) - 1, len(b) - 1))
+    x, power = MPZ(1), 0
+    while x <= (2*B):  # multiply by two for negative coefficients, see [1]
+        x <<= 1
+        power += 1
+
+    def to_integer(poly):
+        n, mul = MPZ(0), 0
+        for c in reversed(poly):
+            if c and not mul: mul = -1 if c < 0 else 1
+            n <<= power
+            n += mul*int(c)
+        return mul, n
+
+    # Perform packing and multiplication
+    (a_mul, a_packed), (b_mul, b_packed) = to_integer(a), to_integer(b)
+    result = a_packed * b_packed
+
+    # Perform unpacking
+    mul = a_mul * b_mul
+    mask, half, borrow, poly = x - 1, x >> 1, 0, []
+    while result or borrow:
+        coeff = (result & mask) + borrow
+        result >>= power
+        borrow = coeff >= half
+        poly.append(mul * int(coeff if coeff < half else coeff - x))
+    return poly or [0]
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/recurrences.py b/.venv/lib/python3.12/site-packages/sympy/discrete/recurrences.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b0ed80d304161cf9ca298321aedc094c8cae1b3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/recurrences.py
@@ -0,0 +1,166 @@
+"""
+Recurrences
+"""
+
+from sympy.core import S, sympify
+from sympy.utilities.iterables import iterable
+from sympy.utilities.misc import as_int
+
+
+def linrec(coeffs, init, n):
+    r"""
+    Evaluation of univariate linear recurrences of homogeneous type
+    having coefficients independent of the recurrence variable.
+
+    Parameters
+    ==========
+
+    coeffs : iterable
+        Coefficients of the recurrence
+    init : iterable
+        Initial values of the recurrence
+    n : Integer
+        Point of evaluation for the recurrence
+
+    Notes
+    =====
+
+    Let `y(n)` be the recurrence of given type, ``c`` be the sequence
+    of coefficients, ``b`` be the sequence of initial/base values of the
+    recurrence and ``k`` (equal to ``len(c)``) be the order of recurrence.
+    Then,
+
+    .. math :: y(n) = \begin{cases} b_n & 0 \le n < k \\
+        c_0 y(n-1) + c_1 y(n-2) + \cdots + c_{k-1} y(n-k) & n \ge k
+        \end{cases}
+
+    Let `x_0, x_1, \ldots, x_n` be a sequence and consider the transformation
+    that maps each polynomial `f(x)` to `T(f(x))` where each power `x^i` is
+    replaced by the corresponding value `x_i`. The sequence is then a solution
+    of the recurrence if and only if `T(x^i p(x)) = 0` for each `i \ge 0` where
+    `p(x) = x^k - c_0 x^(k-1) - \cdots - c_{k-1}` is the characteristic
+    polynomial.
+
+    Then `T(f(x)p(x)) = 0` for each polynomial `f(x)` (as it is a linear
+    combination of powers `x^i`). Now, if `x^n` is congruent to
+    `g(x) = a_0 x^0 + a_1 x^1 + \cdots + a_{k-1} x^{k-1}` modulo `p(x)`, then
+    `T(x^n) = x_n` is equal to
+    `T(g(x)) = a_0 x_0 + a_1 x_1 + \cdots + a_{k-1} x_{k-1}`.
+
+    Computation of `x^n`,
+    given `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+    is performed using exponentiation by squaring (refer to [1_]) with
+    an additional reduction step performed to retain only first `k` powers
+    of `x` in the representation of `x^n`.
+
+    Examples
+    ========
+
+    >>> from sympy.discrete.recurrences import linrec
+    >>> from sympy.abc import x, y, z
+
+    >>> linrec(coeffs=[1, 1], init=[0, 1], n=10)
+    55
+
+    >>> linrec(coeffs=[1, 1], init=[x, y], n=10)
+    34*x + 55*y
+
+    >>> linrec(coeffs=[x, y], init=[0, 1], n=5)
+    x**2*y + x*(x**3 + 2*x*y) + y**2
+
+    >>> linrec(coeffs=[1, 2, 3, 0, 0, 4], init=[x, y, z], n=16)
+    13576*x + 5676*y + 2356*z
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Exponentiation_by_squaring
+    .. [2] https://en.wikipedia.org/w/index.php?title=Modular_exponentiation§ion=6#Matrices
+
+    See Also
+    ========
+
+    sympy.polys.agca.extensions.ExtensionElement.__pow__
+
+    """
+
+    if not coeffs:
+        return S.Zero
+
+    if not iterable(coeffs):
+        raise TypeError("Expected a sequence of coefficients for"
+                        " the recurrence")
+
+    if not iterable(init):
+        raise TypeError("Expected a sequence of values for the initialization"
+                        " of the recurrence")
+
+    n = as_int(n)
+    if n < 0:
+        raise ValueError("Point of evaluation of recurrence must be a "
+                        "non-negative integer")
+
+    c = [sympify(arg) for arg in coeffs]
+    b = [sympify(arg) for arg in init]
+    k = len(c)
+
+    if len(b) > k:
+        raise TypeError("Count of initial values should not exceed the "
+                        "order of the recurrence")
+    else:
+        b += [S.Zero]*(k - len(b)) # remaining initial values default to zero
+
+    if n < k:
+        return b[n]
+    terms = [u*v for u, v in zip(linrec_coeffs(c, n), b)]
+    return sum(terms[:-1], terms[-1])
+
+
+def linrec_coeffs(c, n):
+    r"""
+    Compute the coefficients of n'th term in linear recursion
+    sequence defined by c.
+
+    `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`.
+
+    It computes the coefficients by using binary exponentiation.
+    This function is used by `linrec` and `_eval_pow_by_cayley`.
+
+    Parameters
+    ==========
+
+    c = coefficients of the divisor polynomial
+    n = exponent of x, so dividend is x^n
+
+    """
+
+    k = len(c)
+
+    def _square_and_reduce(u, offset):
+        # squares `(u_0 + u_1 x + u_2 x^2 + \cdots + u_{k-1} x^k)` (and
+        # multiplies by `x` if offset is 1) and reduces the above result of
+        # length upto `2k` to `k` using the characteristic equation of the
+        # recurrence given by, `x^k = c_0 x^{k-1} + c_1 x^{k-2} + \cdots + c_{k-1}`
+
+        w = [S.Zero]*(2*len(u) - 1 + offset)
+        for i, p in enumerate(u):
+            for j, q in enumerate(u):
+                w[offset + i + j] += p*q
+
+        for j in range(len(w) - 1, k - 1, -1):
+            for i in range(k):
+                w[j - i - 1] += w[j]*c[i]
+
+        return w[:k]
+
+    def _final_coeffs(n):
+        # computes the final coefficient list - `cf` corresponding to the
+        # point at which recurrence is to be evalauted - `n`, such that,
+        # `y(n) = cf_0 y(k-1) + cf_1 y(k-2) + \cdots + cf_{k-1} y(0)`
+
+        if n < k:
+            return [S.Zero]*n + [S.One] + [S.Zero]*(k - n - 1)
+        else:
+            return _square_and_reduce(_final_coeffs(n // 2), n % 2)
+
+    return _final_coeffs(n)
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..361cf4efe0a351f5aba74725910d031d6878d9be
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_convolutions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_convolutions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9b61d69dcd7602f3c597129121baa14d1d502b27
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_convolutions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_recurrences.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_recurrences.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6783025c23c3d6c24bb1c977f3e94956d20bfd0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_recurrences.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_transforms.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_transforms.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9be982fef4d509bb54f451f090637a1bfc189065
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/__pycache__/test_transforms.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_convolutions.py b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_convolutions.py
new file mode 100644
index 0000000000000000000000000000000000000000..96e5fc801ac63f95c01eb18d48143ae3a1ac6222
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_convolutions.py
@@ -0,0 +1,392 @@
+from sympy.core.numbers import (E, Rational, pi)
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, symbols, I
+from sympy.discrete.convolutions import (
+    convolution, convolution_fft, convolution_ntt, convolution_fwht,
+    convolution_subset, covering_product, intersecting_product,
+    convolution_int)
+from sympy.testing.pytest import raises
+from sympy.abc import x, y
+
+def test_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+    c = [3, 5, 3, 7, 8]
+    d = [1422, 6572, 3213, 5552]
+    e = [-1, Rational(5, 3), Rational(7, 5)]
+
+    assert convolution(a, b) == convolution_fft(a, b)
+    assert convolution(a, b, dps=9) == convolution_fft(a, b, dps=9)
+    assert convolution(a, d, dps=7) == convolution_fft(d, a, dps=7)
+    assert convolution(a, d[1:], dps=3) == convolution_fft(d[1:], a, dps=3)
+
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+
+    # ntt
+    assert convolution(d, b, prime=q) == convolution_ntt(b, d, prime=q)
+    assert convolution(c, b, prime=p) == convolution_ntt(b, c, prime=p)
+    assert convolution(d, c, prime=p) == convolution_ntt(c, d, prime=p)
+    raises(TypeError, lambda: convolution(b, d, dps=5, prime=q))
+    raises(TypeError, lambda: convolution(b, d, dps=6, prime=q))
+
+    # fwht
+    assert convolution(a, b, dyadic=True) == convolution_fwht(a, b)
+    assert convolution(a, b, dyadic=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(b, d, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, d, prime=p, dyadic=True))
+    raises(TypeError, lambda: convolution(a, b, dps=2, dyadic=True))
+    raises(TypeError, lambda: convolution(b, c, prime=p, dyadic=True))
+
+    # subset
+    assert convolution(a, b, subset=True) == convolution_subset(a, b) == \
+            convolution(a, b, subset=True, dyadic=False) == \
+                convolution(a, b, subset=True)
+    assert convolution(a, b, subset=False) == convolution(a, b)
+    raises(TypeError, lambda: convolution(a, b, subset=True, dyadic=True))
+    raises(TypeError, lambda: convolution(c, d, subset=True, dps=6))
+    raises(TypeError, lambda: convolution(a, c, subset=True, prime=q))
+
+    # integer
+    assert convolution([0], [0]) == convolution_int([0], [0])
+    assert convolution(b, c) == convolution_int(b, c)
+
+    # rational
+    assert convolution([Rational(1,2)], [Rational(1,2)]) == [Rational(1, 4)]
+    assert convolution(b, e) == [-9, 10, Rational(239, 15), Rational(34, 3),
+                                 Rational(32, 3), Rational(43, 5), Rational(113, 15),
+                                 Rational(14, 5)]
+
+
+def test_cyclic_convolution():
+    # fft
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5)]
+    b = [9, 5, 5, 4, 3, 2]
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=0) == \
+            convolution([1, 2, 3], [4, 5, 6], cycle=5) == \
+                convolution([1, 2, 3], [4, 5, 6])
+
+    assert convolution([1, 2, 3], [4, 5, 6], cycle=3) == [31, 31, 28]
+
+    a = [Rational(1, 3), Rational(7, 3), Rational(5, 9), Rational(2, 7), Rational(5, 8)]
+    b = [Rational(3, 5), Rational(4, 7), Rational(7, 8), Rational(8, 9)]
+
+    assert convolution(a, b, cycle=0) == \
+            convolution(a, b, cycle=len(a) + len(b) - 1)
+
+    assert convolution(a, b, cycle=4) == [Rational(87277, 26460), Rational(30521, 11340),
+                            Rational(11125, 4032), Rational(3653, 1080)]
+
+    assert convolution(a, b, cycle=6) == [Rational(20177, 20160), Rational(676, 315), Rational(47, 24),
+                            Rational(3053, 1080), Rational(16397, 5292), Rational(2497, 2268)]
+
+    assert convolution(a, b, cycle=9) == \
+                convolution(a, b, cycle=0) + [S.Zero]
+
+    # ntt
+    a = [2313, 5323532, S(3232), 42142, 42242421]
+    b = [S(33456), 56757, 45754, 432423]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=0) == \
+            convolution(a, b, prime=19*2**10 + 1, cycle=8) == \
+                convolution(a, b, prime=19*2**10 + 1)
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=5) == [96, 17146, 2664,
+                                                                    15534, 3517]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=7) == [4643, 3458, 1260,
+                                                        15534, 3517, 16314, 13688]
+
+    assert convolution(a, b, prime=19*2**10 + 1, cycle=9) == \
+            convolution(a, b, prime=19*2**10 + 1) + [0]
+
+    # fwht
+    u, v, w, x, y = symbols('u v w x y')
+    p, q, r, s, t = symbols('p q r s t')
+    c = [u, v, w, x, y]
+    d = [p, q, r, s, t]
+
+    assert convolution(a, b, dyadic=True, cycle=3) == \
+                        [2499522285783, 19861417974796, 4702176579021]
+
+    assert convolution(a, b, dyadic=True, cycle=5) == [2718149225143,
+            2114320852171, 20571217906407, 246166418903, 1413262436976]
+
+    assert convolution(c, d, dyadic=True, cycle=4) == \
+            [p*u + p*y + q*v + r*w + s*x + t*u + t*y,
+             p*v + q*u + q*y + r*x + s*w + t*v,
+             p*w + q*x + r*u + r*y + s*v + t*w,
+             p*x + q*w + r*v + s*u + s*y + t*x]
+
+    assert convolution(c, d, dyadic=True, cycle=6) == \
+            [p*u + q*v + r*w + r*y + s*x + t*w + t*y,
+             p*v + q*u + r*x + s*w + s*y + t*x,
+             p*w + q*x + r*u + s*v,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u,
+             q*y + t*v]
+
+    # subset
+    assert convolution(a, b, subset=True, cycle=7) == [18266671799811,
+                    178235365533, 213958794, 246166418903, 1413262436976,
+                    2397553088697, 1932759730434]
+
+    assert convolution(a[1:], b, subset=True, cycle=4) == \
+            [178104086592, 302255835516, 244982785880, 3717819845434]
+
+    assert convolution(a, b[:-1], subset=True, cycle=6) == [1932837114162,
+            178235365533, 213958794, 245166224504, 1413262436976, 2397553088697]
+
+    assert convolution(c, d, subset=True, cycle=3) == \
+            [p*u + p*x + q*w + r*v + r*y + s*u + t*w,
+             p*v + p*y + q*u + s*y + t*u + t*x,
+             p*w + q*y + r*u + t*v]
+
+    assert convolution(c, d, subset=True, cycle=5) == \
+            [p*u + q*y + t*v,
+             p*v + q*u + r*y + t*w,
+             p*w + r*u + s*y + t*x,
+             p*x + q*w + r*v + s*u,
+             p*y + t*u]
+
+    raises(ValueError, lambda: convolution([1, 2, 3], [4, 5, 6], cycle=-1))
+
+
+def test_convolution_fft():
+    assert all(convolution_fft([], x, dps=y) == [] for x in ([], [1]) for y in (None, 3))
+    assert convolution_fft([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_fft([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_fft([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+
+    assert convolution_fft([1 + 2*I], [2 + 3*I]) == [-4 + 7*I]
+    assert convolution_fft([1 + 2*I, 3 + 4*I, 5 + 3*I/5], [Rational(2, 5) + 4*I/7]) == \
+            [Rational(-26, 35) + I*48/35, Rational(-38, 35) + I*116/35, Rational(58, 35) + I*542/175]
+
+    assert convolution_fft([Rational(3, 4), Rational(5, 6)], [Rational(7, 8), Rational(1, 3), Rational(2, 5)]) == \
+                                    [Rational(21, 32), Rational(47, 48), Rational(26, 45), Rational(1, 3)]
+
+    assert convolution_fft([Rational(1, 9), Rational(2, 3), Rational(3, 5)], [Rational(2, 5), Rational(3, 7), Rational(4, 9)]) == \
+                                [Rational(2, 45), Rational(11, 35), Rational(8152, 14175), Rational(523, 945), Rational(4, 15)]
+
+    assert convolution_fft([pi, E, sqrt(2)], [sqrt(3), 1/pi, 1/E]) == \
+                    [sqrt(3)*pi, 1 + sqrt(3)*E, E/pi + pi*exp(-1) + sqrt(6),
+                                            sqrt(2)/pi + 1, sqrt(2)*exp(-1)]
+
+    assert convolution_fft([2321, 33123], [5321, 6321, 71323]) == \
+                        [12350041, 190918524, 374911166, 2362431729]
+
+    assert convolution_fft([312313, 31278232], [32139631, 319631]) == \
+                        [10037624576503, 1005370659728895, 9997492572392]
+
+    raises(TypeError, lambda: convolution_fft(x, y))
+    raises(ValueError, lambda: convolution_fft([x, y], [y, x]))
+
+
+def test_convolution_ntt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 19*2**10 + 1
+    r = 2*500000003 + 1 # only for sequences of length 1 or 2
+    # s = 2*3*5*7 # composite modulus
+
+    assert all(convolution_ntt([], x, prime=y) == [] for x in ([], [1]) for y in (p, q, r))
+    assert convolution_ntt([2], [3], r) == [6]
+    assert convolution_ntt([2, 3], [4], r) == [8, 12]
+
+    assert convolution_ntt([32121, 42144, 4214, 4241], [32132, 3232, 87242], p) == [33867619,
+                                    459741727, 79180879, 831885249, 381344700, 369993322]
+    assert convolution_ntt([121913, 3171831, 31888131, 12], [17882, 21292, 29921, 312], q) == \
+                                                [8158, 3065, 3682, 7090, 1239, 2232, 3744]
+
+    assert convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [2, 6, 7, 8, 9], q)
+    assert convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], p) == \
+                    convolution_ntt([12, 19, 21, 98, 67], [21, 76, 17, 78, 69], q)
+
+    raises(ValueError, lambda: convolution_ntt([2, 3], [4, 5], r))
+    raises(ValueError, lambda: convolution_ntt([x, y], [y, x], q))
+    raises(TypeError, lambda: convolution_ntt(x, y, p))
+
+
+def test_convolution_fwht():
+    assert convolution_fwht([], []) == []
+    assert convolution_fwht([], [1]) == []
+    assert convolution_fwht([1, 2, 3], [4, 5, 6]) == [32, 13, 18, 27]
+
+    assert convolution_fwht([Rational(5, 7), Rational(6, 8), Rational(7, 3)], [2, 4, Rational(6, 7)]) == \
+                                    [Rational(45, 7), Rational(61, 14), Rational(776, 147), Rational(419, 42)]
+
+    a = [1, Rational(5, 3), sqrt(3), Rational(7, 5), 4 + 5*I]
+    b = [94, 51, 53, 45, 31, 27, 13]
+    c = [3 + 4*I, 5 + 7*I, 3, Rational(7, 6), 8]
+
+    assert convolution_fwht(a, b) == [53*sqrt(3) + 366 + 155*I,
+                                    45*sqrt(3) + Rational(5848, 15) + 135*I,
+                                    94*sqrt(3) + Rational(1257, 5) + 65*I,
+                                    51*sqrt(3) + Rational(3974, 15),
+                                    13*sqrt(3) + 452 + 470*I,
+                                    Rational(4513, 15) + 255*I,
+                                    31*sqrt(3) + Rational(1314, 5) + 265*I,
+                                    27*sqrt(3) + Rational(3676, 15) + 225*I]
+
+    assert convolution_fwht(b, c) == [Rational(1993, 2) + 733*I, Rational(6215, 6) + 862*I,
+        Rational(1659, 2) + 527*I, Rational(1988, 3) + 551*I, 1019 + 313*I, Rational(3955, 6) + 325*I,
+        Rational(1175, 2) + 52*I, Rational(3253, 6) + 91*I]
+
+    assert convolution_fwht(a[3:], c) == [Rational(-54, 5) + I*293/5, -1 + I*204/5,
+            Rational(133, 15) + I*35/6, Rational(409, 30) + 15*I, Rational(56, 5), 32 + 40*I, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_fwht([u, v], [x, y]) == [u*x + v*y, u*y + v*x]
+
+    assert convolution_fwht([u, v, w], [x, y]) == \
+        [u*x + v*y, u*y + v*x, w*x, w*y]
+
+    assert convolution_fwht([u, v, w], [x, y, z]) == \
+        [u*x + v*y + w*z, u*y + v*x, u*z + w*x, v*z + w*y]
+
+    raises(TypeError, lambda: convolution_fwht(x, y))
+    raises(TypeError, lambda: convolution_fwht(x*y, u + v))
+
+
+def test_convolution_subset():
+    assert convolution_subset([], []) == []
+    assert convolution_subset([], [Rational(1, 3)]) == []
+    assert convolution_subset([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 3), sqrt(3), 4 + 5*I]
+    b = [64, 71, 55, 47, 33, 29, 15]
+    c = [3 + I*2/3, 5 + 7*I, 7, Rational(7, 5), 9]
+
+    assert convolution_subset(a, b) == [64, Rational(533, 3), 55 + 64*sqrt(3),
+                                        71*sqrt(3) + Rational(1184, 3) + 320*I, 33, 84,
+                                        15 + 33*sqrt(3), 29*sqrt(3) + 157 + 165*I]
+
+    assert convolution_subset(b, c) == [192 + I*128/3, 533 + I*1486/3,
+                                        613 + I*110/3, Rational(5013, 5) + I*1249/3,
+                                        675 + 22*I, 891 + I*751/3,
+                                        771 + 10*I, Rational(3736, 5) + 105*I]
+
+    assert convolution_subset(a, c) == convolution_subset(c, a)
+    assert convolution_subset(a[:2], b) == \
+            [64, Rational(533, 3), 55, Rational(416, 3), 33, 84, 15, 25]
+
+    assert convolution_subset(a[:2], c) == \
+            [3 + I*2/3, 10 + I*73/9, 7, Rational(196, 15), 9, 15, 0, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert convolution_subset([u, v, w], [x, y]) == [u*x, u*y + v*x, w*x, w*y]
+    assert convolution_subset([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y, w*y, w*z + x*y]
+
+    assert convolution_subset([u, v], [x, y, z]) == \
+                    convolution_subset([x, y, z], [u, v])
+
+    raises(TypeError, lambda: convolution_subset(x, z))
+    raises(TypeError, lambda: convolution_subset(Rational(7, 3), u))
+
+
+def test_covering_product():
+    assert covering_product([], []) == []
+    assert covering_product([], [Rational(1, 3)]) == []
+    assert covering_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, Rational(5, 8), sqrt(7), 4 + 9*I]
+    b = [66, 81, 95, 49, 37, 89, 17]
+    c = [3 + I*2/3, 51 + 72*I, 7, Rational(7, 15), 91]
+
+    assert covering_product(a, b) == [66, Rational(1383, 8), 95 + 161*sqrt(7),
+                                        130*sqrt(7) + 1303 + 2619*I, 37,
+                                        Rational(671, 4), 17 + 54*sqrt(7),
+                                        89*sqrt(7) + Rational(4661, 8) + 1287*I]
+
+    assert covering_product(b, c) == [198 + 44*I, 7740 + 10638*I,
+                                        1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                        9484 + I*74/3, 22163 + I*27394/3,
+                                        10621 + I*34/3, Rational(90236, 15) + 1224*I]
+
+    assert covering_product(a, c) == covering_product(c, a)
+    assert covering_product(b, c[:-1]) == [198 + 44*I, 7740 + 10638*I,
+                                         1412 + I*190/3, Rational(42684, 5) + I*31202/3,
+                                         111 + I*74/3, 6693 + I*27394/3,
+                                         429 + I*34/3, Rational(23351, 15) + 1224*I]
+
+    assert covering_product(a, c[:-1]) == [3 + I*2/3,
+                            Rational(339, 4) + I*1409/12, 7 + 10*sqrt(7) + 2*sqrt(7)*I/3,
+                            -403 + 772*sqrt(7)/15 + 72*sqrt(7)*I + I*12658/15]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert covering_product([u, v, w], [x, y]) == \
+                            [u*x, u*y + v*x + v*y, w*x, w*y]
+
+    assert covering_product([u, v, w, x], [y, z]) == \
+                            [u*y, u*z + v*y + v*z, w*y, w*z + x*y + x*z]
+
+    assert covering_product([u, v], [x, y, z]) == \
+                    covering_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: covering_product(x, z))
+    raises(TypeError, lambda: covering_product(Rational(7, 3), u))
+
+
+def test_intersecting_product():
+    assert intersecting_product([], []) == []
+    assert intersecting_product([], [Rational(1, 3)]) == []
+    assert intersecting_product([6 + I*3/7], [Rational(2, 3)]) == [4 + I*2/7]
+
+    a = [1, sqrt(5), Rational(3, 8) + 5*I, 4 + 7*I]
+    b = [67, 51, 65, 48, 36, 79, 27]
+    c = [3 + I*2/5, 5 + 9*I, 7, Rational(7, 19), 13]
+
+    assert intersecting_product(a, b) == [195*sqrt(5) + Rational(6979, 8) + 1886*I,
+                                178*sqrt(5) + 520 + 910*I, Rational(841, 2) + 1344*I,
+                                192 + 336*I, 0, 0, 0, 0]
+
+    assert intersecting_product(b, c) == [Rational(128553, 19) + I*9521/5,
+                Rational(17820, 19) + 1602*I, Rational(19264, 19), Rational(336, 19), 1846, 0, 0, 0]
+
+    assert intersecting_product(a, c) == intersecting_product(c, a)
+    assert intersecting_product(b[1:], c[:-1]) == [Rational(64788, 19) + I*8622/5,
+                    Rational(12804, 19) + 1152*I, Rational(11508, 19), Rational(252, 19), 0, 0, 0, 0]
+
+    assert intersecting_product(a, c[:-2]) == \
+                    [Rational(-99, 5) + 10*sqrt(5) + 2*sqrt(5)*I/5 + I*3021/40,
+                    -43 + 5*sqrt(5) + 9*sqrt(5)*I + 71*I, Rational(245, 8) + 84*I, 0]
+
+    u, v, w, x, y, z = symbols('u v w x y z')
+
+    assert intersecting_product([u, v, w], [x, y]) == \
+                            [u*x + u*y + v*x + w*x + w*y, v*y, 0, 0]
+
+    assert intersecting_product([u, v, w, x], [y, z]) == \
+                        [u*y + u*z + v*y + w*y + w*z + x*y, v*z + x*z, 0, 0]
+
+    assert intersecting_product([u, v], [x, y, z]) == \
+                    intersecting_product([x, y, z], [u, v])
+
+    raises(TypeError, lambda: intersecting_product(x, z))
+    raises(TypeError, lambda: intersecting_product(u, Rational(8, 3)))
+
+
+def test_convolution_int():
+    assert convolution_int([1], [1]) == [1]
+    assert convolution_int([1, 1], [0]) == [0]
+    assert convolution_int([1, 2, 3], [4, 5, 6]) == [4, 13, 28, 27, 18]
+    assert convolution_int([1], [5, 6, 7]) == [5, 6, 7]
+    assert convolution_int([1, 3], [5, 6, 7]) == [5, 21, 25, 21]
+    assert convolution_int([10, -5, 1, 3], [-5, 6, 7]) == [-50, 85, 35, -44, 25, 21]
+    assert convolution_int([0, 1, 0, -1], [1, 0, -1, 0]) == [0, 1, 0, -2, 0, 1]
+    assert convolution_int(
+        [-341, -5, 1, 3, -71, -99, 43, 87],
+        [5, 6, 7, 12, 345, 21, -78, -7, -89]
+    ) == [-1705, -2071, -2412, -4106, -118035, -9774, 25998, 2981, 5509,
+          -34317, 19228, 38870, 5485, 1724, -4436, -7743]
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_recurrences.py b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_recurrences.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c2186ca525b6680350a03edbe44ca88f8f95c3c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_recurrences.py
@@ -0,0 +1,59 @@
+from sympy.core.numbers import Rational
+from sympy.functions.combinatorial.numbers import fibonacci
+from sympy.core import S, symbols
+from sympy.testing.pytest import raises
+from sympy.discrete.recurrences import linrec
+
+def test_linrec():
+    assert linrec(coeffs=[1, 1], init=[1, 1], n=20) == 10946
+    assert linrec(coeffs=[1, 2, 3, 4, 5], init=[1, 1, 0, 2], n=10) == 1040
+    assert linrec(coeffs=[0, 0, 11, 13], init=[23, 27], n=25) == 59628567384
+    assert linrec(coeffs=[0, 0, 1, 1, 2], init=[1, 5, 3], n=15) == 165
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=70) == \
+        56889923441670659718376223533331214868804815612050381493741233489928913241
+    assert linrec(coeffs=[0]*55 + [1, 1, 2, 3], init=[0]*50 + [1, 2, 3], n=4000) == \
+        702633573874937994980598979769135096432444135301118916539
+
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**4)
+    assert linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4], n=10**5)
+
+    assert all(linrec(coeffs=[1, 1], init=[0, 1], n=n) == fibonacci(n)
+                                                    for n in range(95, 115))
+
+    assert all(linrec(coeffs=[1, 1], init=[1, 1], n=n) == fibonacci(n + 1)
+                                                    for n in range(595, 615))
+
+    a = [S.Half, Rational(3, 4), Rational(5, 6), 7, Rational(8, 9), Rational(3, 5)]
+    b = [1, 2, 8, Rational(5, 7), Rational(3, 7), Rational(2, 9), 6]
+    x, y, z = symbols('x y z')
+
+    assert linrec(coeffs=a[:5], init=b[:4], n=80) == \
+        Rational(1726244235456268979436592226626304376013002142588105090705187189,
+            1960143456748895967474334873705475211264)
+
+    assert linrec(coeffs=a[:4], init=b[:4], n=50) == \
+        Rational(368949940033050147080268092104304441, 504857282956046106624)
+
+    assert linrec(coeffs=a[3:], init=b[:3], n=35) == \
+        Rational(97409272177295731943657945116791049305244422833125109,
+            814315512679031689453125)
+
+    assert linrec(coeffs=[0]*60 + [Rational(2, 3), Rational(4, 5)], init=b, n=3000) == \
+        Rational(26777668739896791448594650497024, 48084516708184142230517578125)
+
+    raises(TypeError, lambda: linrec(coeffs=[11, 13, 15, 17], init=[1, 2, 3, 4, 5], n=1))
+    raises(TypeError, lambda: linrec(coeffs=a[:4], init=b[:5], n=10000))
+    raises(ValueError, lambda: linrec(coeffs=a[:4], init=b[:4], n=-10000))
+    raises(TypeError, lambda: linrec(x, b, n=10000))
+    raises(TypeError, lambda: linrec(a, y, n=10000))
+
+    assert linrec(coeffs=[x, y, z], init=[1, 1, 1], n=4) == \
+        x**2  + x*y + x*z + y + z
+    assert linrec(coeffs=[1, 2, 1], init=[x, y, z], n=20) == \
+        269542*x + 664575*y + 578949*z
+    assert linrec(coeffs=[0, 3, 1, 2], init=[x, y], n=30) == \
+        58516436*x + 56372788*y
+    assert linrec(coeffs=[0]*50 + [1, 2, 3], init=[x, y, z], n=1000) == \
+        11477135884896*x + 25999077948732*y + 41975630244216*z
+    assert linrec(coeffs=[], init=[1, 1], n=20) == 0
+    assert linrec(coeffs=[x, y, z], init=[1, 2, 3], n=2) == 3
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_transforms.py b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_transforms.py
new file mode 100644
index 0000000000000000000000000000000000000000..385514be4cdec2f19cf3a750bdbe0f4f6e21cc6e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/tests/test_transforms.py
@@ -0,0 +1,154 @@
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import S, Symbol, symbols, I, Rational
+from sympy.discrete import (fft, ifft, ntt, intt, fwht, ifwht,
+    mobius_transform, inverse_mobius_transform)
+from sympy.testing.pytest import raises
+
+
+def test_fft_ifft():
+    assert all(tf(ls) == ls for tf in (fft, ifft)
+                            for ls in ([], [Rational(5, 3)]))
+
+    ls = list(range(6))
+    fls = [15, -7*sqrt(2)/2 - 4 - sqrt(2)*I/2 + 2*I, 2 + 3*I,
+             -4 + 7*sqrt(2)/2 - 2*I - sqrt(2)*I/2, -3,
+             -4 + 7*sqrt(2)/2 + sqrt(2)*I/2 + 2*I,
+              2 - 3*I, -7*sqrt(2)/2 - 4 - 2*I + sqrt(2)*I/2]
+
+    assert fft(ls) == fls
+    assert ifft(fls) == ls + [S.Zero]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    ifls = [Rational(9, 4) + 3*I, I*Rational(-7, 4), Rational(3, 4) + I, -2 - I/4]
+
+    assert ifft(ls) == ifls
+    assert fft(ifls) == ls + [S.Zero]
+
+    x = Symbol('x', real=True)
+    raises(TypeError, lambda: fft(x))
+    raises(ValueError, lambda: ifft([x, 2*x, 3*x**2, 4*x**3]))
+
+
+def test_ntt_intt():
+    # prime moduli of the form (m*2**k + 1), sequence length
+    # should be a divisor of 2**k
+    p = 7*17*2**23 + 1
+    q = 2*500000003 + 1 # only for sequences of length 1 or 2
+    r = 2*3*5*7 # composite modulus
+
+    assert all(tf(ls, p) == ls for tf in (ntt, intt)
+                                for ls in ([], [5]))
+
+    ls = list(range(6))
+    nls = [15, 801133602, 738493201, 334102277, 998244350, 849020224,
+            259751156, 12232587]
+
+    assert ntt(ls, p) == nls
+    assert intt(nls, p) == ls + [0]*2
+
+    ls = [1 + 2*I, 3 + 4*I, 5 + 6*I]
+    x = Symbol('x', integer=True)
+
+    raises(TypeError, lambda: ntt(x, p))
+    raises(ValueError, lambda: intt([x, 2*x, 3*x**2, 4*x**3], p))
+    raises(ValueError, lambda: intt(ls, p))
+    raises(ValueError, lambda: ntt([1.2, 2.1, 3.5], p))
+    raises(ValueError, lambda: ntt([3, 5, 6], q))
+    raises(ValueError, lambda: ntt([4, 5, 7], r))
+    raises(ValueError, lambda: ntt([1.0, 2.0, 3.0], p))
+
+
+def test_fwht_ifwht():
+    assert all(tf(ls) == ls for tf in (fwht, ifwht) \
+                        for ls in ([], [Rational(7, 4)]))
+
+    ls = [213, 321, 43235, 5325, 312, 53]
+    fls = [49459, 38061, -47661, -37759, 48729, 37543, -48391, -38277]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*2
+
+    ls = [S.Half + 2*I, Rational(3, 7) + 4*I, Rational(5, 6) + 6*I, Rational(7, 3), Rational(9, 4)]
+    ifls = [Rational(533, 672) + I*3/2, Rational(23, 224) + I/2, Rational(1, 672), Rational(107, 224) - I,
+        Rational(155, 672) + I*3/2, Rational(-103, 224) + I/2, Rational(-377, 672), Rational(-19, 224) - I]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls + [S.Zero]*3
+
+    x, y = symbols('x y')
+
+    raises(TypeError, lambda: fwht(x))
+
+    ls = [x, 2*x, 3*x**2, 4*x**3]
+    ifls = [x**3 + 3*x**2/4 + x*Rational(3, 4),
+        -x**3 + 3*x**2/4 - x/4,
+        -x**3 - 3*x**2/4 + x*Rational(3, 4),
+        x**3 - 3*x**2/4 - x/4]
+
+    assert ifwht(ls) == ifls
+    assert fwht(ifls) == ls
+
+    ls = [x, y, x**2, y**2, x*y]
+    fls = [x**2 + x*y + x + y**2 + y,
+        x**2 + x*y + x - y**2 - y,
+        -x**2 + x*y + x - y**2 + y,
+        -x**2 + x*y + x + y**2 - y,
+        x**2 - x*y + x + y**2 + y,
+        x**2 - x*y + x - y**2 - y,
+        -x**2 - x*y + x - y**2 + y,
+        -x**2 - x*y + x + y**2 - y]
+
+    assert fwht(ls) == fls
+    assert ifwht(fls) == ls + [S.Zero]*3
+
+    ls = list(range(6))
+
+    assert fwht(ls) == [x*8 for x in ifwht(ls)]
+
+
+def test_mobius_transform():
+    assert all(tf(ls, subset=subset) == ls
+                for ls in ([], [Rational(7, 4)]) for subset in (True, False)
+                for tf in (mobius_transform, inverse_mobius_transform))
+
+    w, x, y, z = symbols('w x y z')
+
+    assert mobius_transform([x, y]) == [x, x + y]
+    assert inverse_mobius_transform([x, x + y]) == [x, y]
+    assert mobius_transform([x, y], subset=False) == [x + y, y]
+    assert inverse_mobius_transform([x + y, y], subset=False) == [x, y]
+
+    assert mobius_transform([w, x, y, z]) == [w, w + x, w + y, w + x + y + z]
+    assert inverse_mobius_transform([w, w + x, w + y, w + x + y + z]) == \
+            [w, x, y, z]
+    assert mobius_transform([w, x, y, z], subset=False) == \
+            [w + x + y + z, x + z, y + z, z]
+    assert inverse_mobius_transform([w + x + y + z, x + z, y + z, z], subset=False) == \
+            [w, x, y, z]
+
+    ls = [Rational(2, 3), Rational(6, 7), Rational(5, 8), 9, Rational(5, 3) + 7*I]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168),
+            Rational(7, 3) + 7*I, Rational(67, 21) + 7*I, Rational(71, 24) + 7*I,
+            Rational(2153, 168) + 7*I]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls + [S.Zero]*3
+
+    mls = [Rational(2153, 168) + 7*I, Rational(69, 7), Rational(77, 8), 9, Rational(5, 3) + 7*I, 0, 0, 0]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls + [S.Zero]*3
+
+    ls = ls[:-1]
+    mls = [Rational(2, 3), Rational(32, 21), Rational(31, 24), Rational(1873, 168)]
+
+    assert mobius_transform(ls) == mls
+    assert inverse_mobius_transform(mls) == ls
+
+    mls = [Rational(1873, 168), Rational(69, 7), Rational(77, 8), 9]
+
+    assert mobius_transform(ls, subset=False) == mls
+    assert inverse_mobius_transform(mls, subset=False) == ls
+
+    raises(TypeError, lambda: mobius_transform(x, subset=True))
+    raises(TypeError, lambda: inverse_mobius_transform(y, subset=False))
diff --git a/.venv/lib/python3.12/site-packages/sympy/discrete/transforms.py b/.venv/lib/python3.12/site-packages/sympy/discrete/transforms.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb3550837021a4cf99e38c6b15f89ce8bb69b25a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/discrete/transforms.py
@@ -0,0 +1,425 @@
+"""
+Discrete Fourier Transform, Number Theoretic Transform,
+Walsh Hadamard Transform, Mobius Transform
+"""
+
+from sympy.core import S, Symbol, sympify
+from sympy.core.function import expand_mul
+from sympy.core.numbers import pi, I
+from sympy.functions.elementary.trigonometric import sin, cos
+from sympy.ntheory import isprime, primitive_root
+from sympy.utilities.iterables import ibin, iterable
+from sympy.utilities.misc import as_int
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Discrete Fourier Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _fourier_transform(seq, dps, inverse=False):
+    """Utility function for the Discrete Fourier Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of numeric coefficients "
+                        "for Fourier Transform")
+
+    a = [sympify(arg) for arg in seq]
+    if any(x.has(Symbol) for x in a):
+        raise ValueError("Expected non-symbolic coefficients")
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1): # not a power of 2
+        b += 1
+        n = 2**b
+
+    a += [S.Zero]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    ang = -2*pi/n if inverse else 2*pi/n
+
+    if dps is not None:
+        ang = ang.evalf(dps + 2)
+
+    w = [cos(ang*i) + I*sin(ang*i) for i in range(n // 2)]
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], expand_mul(a[i + j + hf]*w[ut * j])
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [(x/n).evalf(dps) for x in a] if dps is not None \
+                            else [x/n for x in a]
+
+    return a
+
+
+def fft(seq, dps=None):
+    r"""
+    Performs the Discrete Fourier Transform (**DFT**) in the complex domain.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FFT* requires the number of sample points to be a power of 2.
+
+    This method should be used with default arguments only for short sequences
+    as the complexity of expressions increases with the size of the sequence.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    dps : Integer
+        Specifies the number of decimal digits for precision.
+
+    Examples
+    ========
+
+    >>> from sympy import fft, ifft
+
+    >>> fft([1, 2, 3, 4])
+    [10, -2 - 2*I, -2, -2 + 2*I]
+    >>> ifft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 2, 3, 4])
+    [5/2, -1/2 + I/2, -1/2, -1/2 - I/2]
+    >>> fft(_)
+    [1, 2, 3, 4]
+
+    >>> ifft([1, 7, 3, 4], dps=15)
+    [3.75, -0.5 - 0.75*I, -1.75, -0.5 + 0.75*I]
+    >>> fft(_)
+    [1.0, 7.0, 3.0, 4.0]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cooley%E2%80%93Tukey_FFT_algorithm
+    .. [2] https://mathworld.wolfram.com/FastFourierTransform.html
+
+    """
+
+    return _fourier_transform(seq, dps=dps)
+
+
+def ifft(seq, dps=None):
+    return _fourier_transform(seq, dps=dps, inverse=True)
+
+ifft.__doc__ = fft.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                         Number Theoretic Transform                         #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _number_theoretic_transform(seq, prime, inverse=False):
+    """Utility function for the Number Theoretic Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of integer coefficients "
+                        "for Number Theoretic Transform")
+
+    p = as_int(prime)
+    if not isprime(p):
+        raise ValueError("Expected prime modulus for "
+                        "Number Theoretic Transform")
+
+    a = [as_int(x) % p for x in seq]
+
+    n = len(a)
+    if n < 1:
+        return a
+
+    b = n.bit_length() - 1
+    if n&(n - 1):
+        b += 1
+        n = 2**b
+
+    if (p - 1) % n:
+        raise ValueError("Expected prime modulus of the form (m*2**k + 1)")
+
+    a += [0]*(n - len(a))
+    for i in range(1, n):
+        j = int(ibin(i, b, str=True)[::-1], 2)
+        if i < j:
+            a[i], a[j] = a[j], a[i]
+
+    pr = primitive_root(p)
+
+    rt = pow(pr, (p - 1) // n, p)
+    if inverse:
+        rt = pow(rt, p - 2, p)
+
+    w = [1]*(n // 2)
+    for i in range(1, n // 2):
+        w[i] = w[i - 1]*rt % p
+
+    h = 2
+    while h <= n:
+        hf, ut = h // 2, n // h
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]*w[ut * j]
+                a[i + j], a[i + j + hf] = (u + v) % p, (u - v) % p
+        h *= 2
+
+    if inverse:
+        rv = pow(n, p - 2, p)
+        a = [x*rv % p for x in a]
+
+    return a
+
+
+def ntt(seq, prime):
+    r"""
+    Performs the Number Theoretic Transform (**NTT**), which specializes the
+    Discrete Fourier Transform (**DFT**) over quotient ring `Z/pZ` for prime
+    `p` instead of complex numbers `C`.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 NTT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which **DFT** is to be applied.
+    prime : Integer
+        Prime modulus of the form `(m 2^k + 1)` to be used for performing
+        **NTT** on the sequence.
+
+    Examples
+    ========
+
+    >>> from sympy import ntt, intt
+    >>> ntt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [10, 643, 767, 122]
+    >>> intt(_, 3*2**8 + 1)
+    [1, 2, 3, 4]
+    >>> intt([1, 2, 3, 4], prime=3*2**8 + 1)
+    [387, 415, 384, 353]
+    >>> ntt(_, prime=3*2**8 + 1)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] http://www.apfloat.org/ntt.html
+    .. [2] https://mathworld.wolfram.com/NumberTheoreticTransform.html
+    .. [3] https://en.wikipedia.org/wiki/Discrete_Fourier_transform_(general%29
+
+    """
+
+    return _number_theoretic_transform(seq, prime=prime)
+
+
+def intt(seq, prime):
+    return _number_theoretic_transform(seq, prime=prime, inverse=True)
+
+intt.__doc__ = ntt.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                          Walsh Hadamard Transform                          #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _walsh_hadamard_transform(seq, inverse=False):
+    """Utility function for the Walsh Hadamard Transform"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients "
+                        "for Walsh Hadamard Transform")
+
+    a = [sympify(arg) for arg in seq]
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+    h = 2
+    while h <= n:
+        hf = h // 2
+        for i in range(0, n, h):
+            for j in range(hf):
+                u, v = a[i + j], a[i + j + hf]
+                a[i + j], a[i + j + hf] = u + v, u - v
+        h *= 2
+
+    if inverse:
+        a = [x/n for x in a]
+
+    return a
+
+
+def fwht(seq):
+    r"""
+    Performs the Walsh Hadamard Transform (**WHT**), and uses Hadamard
+    ordering for the sequence.
+
+    The sequence is automatically padded to the right with zeros, as the
+    *radix-2 FWHT* requires the number of sample points to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which WHT is to be applied.
+
+    Examples
+    ========
+
+    >>> from sympy import fwht, ifwht
+    >>> fwht([4, 2, 2, 0, 0, 2, -2, 0])
+    [8, 0, 8, 0, 8, 8, 0, 0]
+    >>> ifwht(_)
+    [4, 2, 2, 0, 0, 2, -2, 0]
+
+    >>> ifwht([19, -1, 11, -9, -7, 13, -15, 5])
+    [2, 0, 4, 0, 3, 10, 0, 0]
+    >>> fwht(_)
+    [19, -1, 11, -9, -7, 13, -15, 5]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hadamard_transform
+    .. [2] https://en.wikipedia.org/wiki/Fast_Walsh%E2%80%93Hadamard_transform
+
+    """
+
+    return _walsh_hadamard_transform(seq)
+
+
+def ifwht(seq):
+    return _walsh_hadamard_transform(seq, inverse=True)
+
+ifwht.__doc__ = fwht.__doc__
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                    Mobius Transform for Subset Lattice                     #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def _mobius_transform(seq, sgn, subset):
+    r"""Utility function for performing Mobius Transform using
+    Yate's Dynamic Programming method"""
+
+    if not iterable(seq):
+        raise TypeError("Expected a sequence of coefficients")
+
+    a = [sympify(arg) for arg in seq]
+
+    n = len(a)
+    if n < 2:
+        return a
+
+    if n&(n - 1):
+        n = 2**n.bit_length()
+
+    a += [S.Zero]*(n - len(a))
+
+    if subset:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    else:
+        i = 1
+        while i < n:
+            for j in range(n):
+                if j & i:
+                    continue
+                a[j] += sgn*a[j ^ i]
+            i *= 2
+
+    return a
+
+
+def mobius_transform(seq, subset=True):
+    r"""
+    Performs the Mobius Transform for subset lattice with indices of
+    sequence as bitmasks.
+
+    The indices of each argument, considered as bit strings, correspond
+    to subsets of a finite set.
+
+    The sequence is automatically padded to the right with zeros, as the
+    definition of subset/superset based on bitmasks (indices) requires
+    the size of sequence to be a power of 2.
+
+    Parameters
+    ==========
+
+    seq : iterable
+        The sequence on which Mobius Transform is to be applied.
+    subset : bool
+        Specifies if Mobius Transform is applied by enumerating subsets
+        or supersets of the given set.
+
+    Examples
+    ========
+
+    >>> from sympy import symbols
+    >>> from sympy import mobius_transform, inverse_mobius_transform
+    >>> x, y, z = symbols('x y z')
+
+    >>> mobius_transform([x, y, z])
+    [x, x + y, x + z, x + y + z]
+    >>> inverse_mobius_transform(_)
+    [x, y, z, 0]
+
+    >>> mobius_transform([x, y, z], subset=False)
+    [x + y + z, y, z, 0]
+    >>> inverse_mobius_transform(_, subset=False)
+    [x, y, z, 0]
+
+    >>> mobius_transform([1, 2, 3, 4])
+    [1, 3, 4, 10]
+    >>> inverse_mobius_transform(_)
+    [1, 2, 3, 4]
+    >>> mobius_transform([1, 2, 3, 4], subset=False)
+    [10, 6, 7, 4]
+    >>> inverse_mobius_transform(_, subset=False)
+    [1, 2, 3, 4]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_inversion_formula
+    .. [2] https://people.csail.mit.edu/rrw/presentations/subset-conv.pdf
+    .. [3] https://arxiv.org/pdf/1211.0189.pdf
+
+    """
+
+    return _mobius_transform(seq, sgn=+1, subset=subset)
+
+def inverse_mobius_transform(seq, subset=True):
+    return _mobius_transform(seq, sgn=-1, subset=subset)
+
+inverse_mobius_transform.__doc__ = mobius_transform.__doc__
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__init__.py b/.venv/lib/python3.12/site-packages/sympy/external/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..549b4b96cdce0ee4d31960e89cb9dc26af0e105d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/__init__.py
@@ -0,0 +1,20 @@
+"""
+Unified place for determining if external dependencies are installed or not.
+
+You should import all external modules using the import_module() function.
+
+For example
+
+>>> from sympy.external import import_module
+>>> numpy = import_module('numpy')
+
+If the resulting library is not installed, or if the installed version
+is less than a given minimum version, the function will return None.
+Otherwise, it will return the library. See the docstring of
+import_module() for more information.
+
+"""
+
+from sympy.external.importtools import import_module
+
+__all__ = ['import_module']
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..737e85829065fe2f329249440c2f867e2cda9601
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/gmpy.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/gmpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22ec93e6b4a726931ce62a502a379e1fae5fecda
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/gmpy.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/importtools.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/importtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d3c78f825947a9d517c81fdcce064eaf2dee45b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/importtools.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/ntheory.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/ntheory.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..283f2e33d106734b77cb79b91f387d161664f77a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/ntheory.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/pythonmpq.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/pythonmpq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e64a0b1eff5d0d5cd290b2be9b2ccb0915562e9c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/__pycache__/pythonmpq.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/gmpy.py b/.venv/lib/python3.12/site-packages/sympy/external/gmpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..d26942864bf4786e72198d3640d488857b3313f4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/gmpy.py
@@ -0,0 +1,342 @@
+from __future__ import annotations
+import os
+from ctypes import c_long, sizeof
+from functools import reduce
+from typing import Type
+from warnings import warn
+
+from sympy.external import import_module
+
+from .pythonmpq import PythonMPQ
+
+from .ntheory import (
+    bit_scan1 as python_bit_scan1,
+    bit_scan0 as python_bit_scan0,
+    remove as python_remove,
+    factorial as python_factorial,
+    sqrt as python_sqrt,
+    sqrtrem as python_sqrtrem,
+    gcd as python_gcd,
+    lcm as python_lcm,
+    gcdext as python_gcdext,
+    is_square as python_is_square,
+    invert as python_invert,
+    legendre as python_legendre,
+    jacobi as python_jacobi,
+    kronecker as python_kronecker,
+    iroot as python_iroot,
+    is_fermat_prp as python_is_fermat_prp,
+    is_euler_prp as python_is_euler_prp,
+    is_strong_prp as python_is_strong_prp,
+    is_fibonacci_prp as python_is_fibonacci_prp,
+    is_lucas_prp as python_is_lucas_prp,
+    is_selfridge_prp as python_is_selfridge_prp,
+    is_strong_lucas_prp as python_is_strong_lucas_prp,
+    is_strong_selfridge_prp as python_is_strong_selfridge_prp,
+    is_bpsw_prp as python_is_bpsw_prp,
+    is_strong_bpsw_prp as python_is_strong_bpsw_prp,
+)
+
+
+__all__ = [
+    # GROUND_TYPES is either 'gmpy' or 'python' depending on which is used. If
+    # gmpy is installed then it will be used unless the environment variable
+    # SYMPY_GROUND_TYPES is set to something other than 'auto', 'gmpy', or
+    # 'gmpy2'.
+    'GROUND_TYPES',
+
+    # If HAS_GMPY is 0, no supported version of gmpy is available. Otherwise,
+    # HAS_GMPY will be 2 for gmpy2 if GROUND_TYPES is 'gmpy'. It used to be
+    # possible for HAS_GMPY to be 1 for gmpy but gmpy is no longer supported.
+    'HAS_GMPY',
+
+    # SYMPY_INTS is a tuple containing the base types for valid integer types.
+    # This is either (int,) or (int, type(mpz(0))) depending on GROUND_TYPES.
+    'SYMPY_INTS',
+
+    # MPQ is either gmpy.mpq or the Python equivalent from
+    # sympy.external.pythonmpq
+    'MPQ',
+
+    # MPZ is either gmpy.mpz or int.
+    'MPZ',
+
+    'bit_scan1',
+    'bit_scan0',
+    'remove',
+    'factorial',
+    'sqrt',
+    'is_square',
+    'sqrtrem',
+    'gcd',
+    'lcm',
+    'gcdext',
+    'invert',
+    'legendre',
+    'jacobi',
+    'kronecker',
+    'iroot',
+    'is_fermat_prp',
+    'is_euler_prp',
+    'is_strong_prp',
+    'is_fibonacci_prp',
+    'is_lucas_prp',
+    'is_selfridge_prp',
+    'is_strong_lucas_prp',
+    'is_strong_selfridge_prp',
+    'is_bpsw_prp',
+    'is_strong_bpsw_prp',
+]
+
+
+#
+# Tested python-flint version. Future versions might work but we will only use
+# them if explicitly requested by SYMPY_GROUND_TYPES=flint.
+#
+_PYTHON_FLINT_VERSION_NEEDED = ["0.6", "0.7", "0.8", "0.9", "0.10"]
+
+
+def _flint_version_okay(flint_version):
+    major, minor = flint_version.split('.')[:2]
+    flint_ver = f'{major}.{minor}'
+    return flint_ver in _PYTHON_FLINT_VERSION_NEEDED
+
+#
+# We will only use gmpy2 >= 2.0.0
+#
+_GMPY2_MIN_VERSION = '2.0.0'
+
+
+def _get_flint(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'flint'):
+        return None
+
+    try:
+        import flint
+        # Earlier versions of python-flint may not have __version__.
+        from flint import __version__ as _flint_version
+    except ImportError:
+        if sympy_ground_types == 'flint':
+            warn("SYMPY_GROUND_TYPES was set to flint but python-flint is not "
+                 "installed. Falling back to other ground types.")
+        return None
+
+    if _flint_version_okay(_flint_version):
+        return flint
+    elif sympy_ground_types == 'auto':
+        return None
+    else:
+        warn(f"Using python-flint {_flint_version} because SYMPY_GROUND_TYPES "
+             f"is set to flint but this version of SymPy is only tested "
+             f"with python-flint versions {_PYTHON_FLINT_VERSION_NEEDED}.")
+        return flint
+
+
+def _get_gmpy2(sympy_ground_types):
+    if sympy_ground_types not in ('auto', 'gmpy', 'gmpy2'):
+        return None
+
+    gmpy = import_module('gmpy2', min_module_version=_GMPY2_MIN_VERSION,
+            module_version_attr='version', module_version_attr_call_args=())
+
+    if sympy_ground_types != 'auto' and gmpy is None:
+        warn("gmpy2 library is not installed, switching to 'python' ground types")
+
+    return gmpy
+
+
+#
+# SYMPY_GROUND_TYPES can be flint, gmpy, gmpy2, python or auto (default)
+#
+_SYMPY_GROUND_TYPES = os.environ.get('SYMPY_GROUND_TYPES', 'auto').lower()
+_flint = None
+_gmpy = None
+
+#
+# First handle auto-detection of flint/gmpy2. We will prefer flint if available
+# or otherwise gmpy2 if available and then lastly the python types.
+#
+if _SYMPY_GROUND_TYPES in ('auto', 'flint'):
+    _flint = _get_flint(_SYMPY_GROUND_TYPES)
+    if _flint is not None:
+        _SYMPY_GROUND_TYPES = 'flint'
+    else:
+        _SYMPY_GROUND_TYPES = 'auto'
+
+if _SYMPY_GROUND_TYPES in ('auto', 'gmpy', 'gmpy2'):
+    _gmpy = _get_gmpy2(_SYMPY_GROUND_TYPES)
+    if _gmpy is not None:
+        _SYMPY_GROUND_TYPES = 'gmpy'
+    else:
+        _SYMPY_GROUND_TYPES = 'python'
+
+if _SYMPY_GROUND_TYPES not in ('flint', 'gmpy', 'python'):
+    warn("SYMPY_GROUND_TYPES environment variable unrecognised. "
+         "Should be 'auto', 'flint', 'gmpy', 'gmpy2' or 'python'.")
+    _SYMPY_GROUND_TYPES = 'python'
+
+#
+# At this point _SYMPY_GROUND_TYPES is either flint, gmpy or python. The blocks
+# below define the values exported by this module in each case.
+#
+
+#
+# In gmpy2 and flint, there are functions that take a long (or unsigned long)
+# argument. That is, it is not possible to input a value larger than that.
+#
+LONG_MAX = (1 << (8*sizeof(c_long) - 1)) - 1
+
+#
+# Type checkers are confused by what SYMPY_INTS is. There may be a better type
+# hint for this like Type[Integral] or something.
+#
+SYMPY_INTS: tuple[Type, ...]
+
+if _SYMPY_GROUND_TYPES == 'gmpy':
+
+    assert _gmpy is not None
+
+    flint = None
+    gmpy = _gmpy
+
+    HAS_GMPY = 2
+    GROUND_TYPES = 'gmpy'
+    SYMPY_INTS = (int, type(gmpy.mpz(0)))
+    MPZ = gmpy.mpz
+    MPQ = gmpy.mpq
+
+    bit_scan1 = gmpy.bit_scan1
+    bit_scan0 = gmpy.bit_scan0
+    remove = gmpy.remove
+    factorial = gmpy.fac
+    sqrt = gmpy.isqrt
+    is_square = gmpy.is_square
+    sqrtrem = gmpy.isqrt_rem
+    gcd = gmpy.gcd
+    lcm = gmpy.lcm
+    gcdext = gmpy.gcdext
+    invert = gmpy.invert
+    legendre = gmpy.legendre
+    jacobi = gmpy.jacobi
+    kronecker = gmpy.kronecker
+
+    def iroot(x, n):
+        # In the latest gmpy2, the threshold for n is ULONG_MAX,
+        # but adjust to the older one.
+        if n <= LONG_MAX:
+            return gmpy.iroot(x, n)
+        return python_iroot(x, n)
+
+    is_fermat_prp = gmpy.is_fermat_prp
+    is_euler_prp = gmpy.is_euler_prp
+    is_strong_prp = gmpy.is_strong_prp
+    is_fibonacci_prp = gmpy.is_fibonacci_prp
+    is_lucas_prp = gmpy.is_lucas_prp
+    is_selfridge_prp = gmpy.is_selfridge_prp
+    is_strong_lucas_prp = gmpy.is_strong_lucas_prp
+    is_strong_selfridge_prp = gmpy.is_strong_selfridge_prp
+    is_bpsw_prp = gmpy.is_bpsw_prp
+    is_strong_bpsw_prp = gmpy.is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'flint':
+
+    assert _flint is not None
+
+    flint = _flint
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'flint'
+    SYMPY_INTS = (int, flint.fmpz) # type: ignore
+    MPZ = flint.fmpz # type: ignore
+    MPQ = flint.fmpq # type: ignore
+
+    bit_scan1 = python_bit_scan1
+    bit_scan0 = python_bit_scan0
+    remove = python_remove
+    factorial = python_factorial
+
+    def sqrt(x):
+        return flint.fmpz(x).isqrt()
+
+    def is_square(x):
+        if x < 0:
+            return False
+        return flint.fmpz(x).sqrtrem()[1] == 0
+
+    def sqrtrem(x):
+        return flint.fmpz(x).sqrtrem()
+
+    def gcd(*args):
+        return reduce(flint.fmpz.gcd, args, flint.fmpz(0))
+
+    def lcm(*args):
+        return reduce(flint.fmpz.lcm, args, flint.fmpz(1))
+
+    gcdext = python_gcdext
+    invert = python_invert
+    legendre = python_legendre
+
+    def jacobi(x, y):
+        if y <= 0 or not y % 2:
+            raise ValueError("y should be an odd positive integer")
+        return flint.fmpz(x).jacobi(y)
+
+    kronecker = python_kronecker
+
+    def iroot(x, n):
+        if n <= LONG_MAX:
+            y = flint.fmpz(x).root(n)
+            return y, y**n == x
+        return python_iroot(x, n)
+
+    is_fermat_prp = python_is_fermat_prp
+    is_euler_prp = python_is_euler_prp
+    is_strong_prp = python_is_strong_prp
+    is_fibonacci_prp = python_is_fibonacci_prp
+    is_lucas_prp = python_is_lucas_prp
+    is_selfridge_prp = python_is_selfridge_prp
+    is_strong_lucas_prp = python_is_strong_lucas_prp
+    is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    is_bpsw_prp = python_is_bpsw_prp
+    is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+elif _SYMPY_GROUND_TYPES == 'python':
+
+    flint = None
+    gmpy = None
+
+    HAS_GMPY = 0
+    GROUND_TYPES = 'python'
+    SYMPY_INTS = (int,)
+    MPZ = int
+    MPQ = PythonMPQ
+
+    bit_scan1 = python_bit_scan1
+    bit_scan0 = python_bit_scan0
+    remove = python_remove
+    factorial = python_factorial
+    sqrt = python_sqrt
+    is_square = python_is_square
+    sqrtrem = python_sqrtrem
+    gcd = python_gcd
+    lcm = python_lcm
+    gcdext = python_gcdext
+    invert = python_invert
+    legendre = python_legendre
+    jacobi = python_jacobi
+    kronecker = python_kronecker
+    iroot = python_iroot
+    is_fermat_prp = python_is_fermat_prp
+    is_euler_prp = python_is_euler_prp
+    is_strong_prp = python_is_strong_prp
+    is_fibonacci_prp = python_is_fibonacci_prp
+    is_lucas_prp = python_is_lucas_prp
+    is_selfridge_prp = python_is_selfridge_prp
+    is_strong_lucas_prp = python_is_strong_lucas_prp
+    is_strong_selfridge_prp = python_is_strong_selfridge_prp
+    is_bpsw_prp = python_is_bpsw_prp
+    is_strong_bpsw_prp = python_is_strong_bpsw_prp
+
+else:
+    assert False
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/importtools.py b/.venv/lib/python3.12/site-packages/sympy/external/importtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..5008b3dd4634d3cee10744a0a92b1204051f07cc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/importtools.py
@@ -0,0 +1,187 @@
+"""Tools to assist importing optional external modules."""
+
+import sys
+import re
+
+# Override these in the module to change the default warning behavior.
+# For example, you might set both to False before running the tests so that
+# warnings are not printed to the console, or set both to True for debugging.
+
+WARN_NOT_INSTALLED = None  # Default is False
+WARN_OLD_VERSION = None  # Default is True
+
+
+def __sympy_debug():
+    # helper function from sympy/__init__.py
+    # We don't just import SYMPY_DEBUG from that file because we don't want to
+    # import all of SymPy just to use this module.
+    import os
+    debug_str = os.getenv('SYMPY_DEBUG', 'False')
+    if debug_str in ('True', 'False'):
+        return eval(debug_str)
+    else:
+        raise RuntimeError("unrecognized value for SYMPY_DEBUG: %s" %
+                           debug_str)
+
+if __sympy_debug():
+    WARN_OLD_VERSION = True
+    WARN_NOT_INSTALLED = True
+
+
+_component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)
+
+def version_tuple(vstring):
+    # Parse a version string to a tuple e.g. '1.2' -> (1, 2)
+    # Simplified from distutils.version.LooseVersion which was deprecated in
+    # Python 3.10.
+    components = []
+    for x in _component_re.split(vstring):
+        if x and x != '.':
+            try:
+                x = int(x)
+            except ValueError:
+                pass
+            components.append(x)
+    return tuple(components)
+
+
+def import_module(module, min_module_version=None, min_python_version=None,
+        warn_not_installed=None, warn_old_version=None,
+        module_version_attr='__version__', module_version_attr_call_args=None,
+        import_kwargs={}, catch=()):
+    """
+    Import and return a module if it is installed.
+
+    If the module is not installed, it returns None.
+
+    A minimum version for the module can be given as the keyword argument
+    min_module_version.  This should be comparable against the module version.
+    By default, module.__version__ is used to get the module version.  To
+    override this, set the module_version_attr keyword argument.  If the
+    attribute of the module to get the version should be called (e.g.,
+    module.version()), then set module_version_attr_call_args to the args such
+    that module.module_version_attr(*module_version_attr_call_args) returns the
+    module's version.
+
+    If the module version is less than min_module_version using the Python <
+    comparison, None will be returned, even if the module is installed. You can
+    use this to keep from importing an incompatible older version of a module.
+
+    You can also specify a minimum Python version by using the
+    min_python_version keyword argument.  This should be comparable against
+    sys.version_info.
+
+    If the keyword argument warn_not_installed is set to True, the function will
+    emit a UserWarning when the module is not installed.
+
+    If the keyword argument warn_old_version is set to True, the function will
+    emit a UserWarning when the library is installed, but cannot be imported
+    because of the min_module_version or min_python_version options.
+
+    Note that because of the way warnings are handled, a warning will be
+    emitted for each module only once.  You can change the default warning
+    behavior by overriding the values of WARN_NOT_INSTALLED and WARN_OLD_VERSION
+    in sympy.external.importtools.  By default, WARN_NOT_INSTALLED is False and
+    WARN_OLD_VERSION is True.
+
+    This function uses __import__() to import the module.  To pass additional
+    options to __import__(), use the import_kwargs keyword argument.  For
+    example, to import a submodule A.B, you must pass a nonempty fromlist option
+    to __import__.  See the docstring of __import__().
+
+    This catches ImportError to determine if the module is not installed.  To
+    catch additional errors, pass them as a tuple to the catch keyword
+    argument.
+
+    Examples
+    ========
+
+    >>> from sympy.external import import_module
+
+    >>> numpy = import_module('numpy')
+
+    >>> numpy = import_module('numpy', min_python_version=(2, 7),
+    ... warn_old_version=False)
+
+    >>> numpy = import_module('numpy', min_module_version='1.5',
+    ... warn_old_version=False) # numpy.__version__ is a string
+
+    >>> # gmpy does not have __version__, but it does have gmpy.version()
+
+    >>> gmpy = import_module('gmpy', min_module_version='1.14',
+    ... module_version_attr='version', module_version_attr_call_args=(),
+    ... warn_old_version=False)
+
+    >>> # To import a submodule, you must pass a nonempty fromlist to
+    >>> # __import__().  The values do not matter.
+    >>> p3 = import_module('mpl_toolkits.mplot3d',
+    ... import_kwargs={'fromlist':['something']})
+
+    >>> # matplotlib.pyplot can raise RuntimeError when the display cannot be opened
+    >>> matplotlib = import_module('matplotlib',
+    ... import_kwargs={'fromlist':['pyplot']}, catch=(RuntimeError,))
+
+    """
+    # keyword argument overrides default, and global variable overrides
+    # keyword argument.
+    warn_old_version = (WARN_OLD_VERSION if WARN_OLD_VERSION is not None
+        else warn_old_version or True)
+    warn_not_installed = (WARN_NOT_INSTALLED if WARN_NOT_INSTALLED is not None
+        else warn_not_installed or False)
+
+    import warnings
+
+    # Check Python first so we don't waste time importing a module we can't use
+    if min_python_version:
+        if sys.version_info < min_python_version:
+            if warn_old_version:
+                warnings.warn("Python version is too old to use %s "
+                    "(%s or newer required)" % (
+                        module, '.'.join(map(str, min_python_version))),
+                    UserWarning, stacklevel=2)
+            return
+
+    try:
+        mod = __import__(module, **import_kwargs)
+
+        ## there's something funny about imports with matplotlib and py3k. doing
+        ##    from matplotlib import collections
+        ## gives python's stdlib collections module. explicitly re-importing
+        ## the module fixes this.
+        from_list = import_kwargs.get('fromlist', ())
+        for submod in from_list:
+            if submod == 'collections' and mod.__name__ == 'matplotlib':
+                __import__(module + '.' + submod)
+    except ImportError:
+        if warn_not_installed:
+            warnings.warn("%s module is not installed" % module, UserWarning,
+                    stacklevel=2)
+        return
+    except catch as e:
+        if warn_not_installed:
+            warnings.warn(
+                "%s module could not be used (%s)" % (module, repr(e)),
+                stacklevel=2)
+        return
+
+    if min_module_version:
+        modversion = getattr(mod, module_version_attr)
+        if module_version_attr_call_args is not None:
+            modversion = modversion(*module_version_attr_call_args)
+        if version_tuple(modversion) < version_tuple(min_module_version):
+            if warn_old_version:
+                # Attempt to create a pretty string version of the version
+                if isinstance(min_module_version, str):
+                    verstr = min_module_version
+                elif isinstance(min_module_version, (tuple, list)):
+                    verstr = '.'.join(map(str, min_module_version))
+                else:
+                    # Either don't know what this is.  Hopefully
+                    # it's something that has a nice str version, like an int.
+                    verstr = str(min_module_version)
+                warnings.warn("%s version is too old to use "
+                    "(%s or newer required)" % (module, verstr),
+                    UserWarning, stacklevel=2)
+            return
+
+    return mod
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/ntheory.py b/.venv/lib/python3.12/site-packages/sympy/external/ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0c9bf813cf02b311f9a12ee7fbc4932ed551f3b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/ntheory.py
@@ -0,0 +1,618 @@
+# sympy.external.ntheory
+#
+# This module provides pure Python implementations of some number theory
+# functions that are alternately used from gmpy2 if it is installed.
+
+import math
+
+import mpmath.libmp as mlib
+
+
+_small_trailing = [0] * 256
+for j in range(1, 8):
+    _small_trailing[1 << j :: 1 << (j + 1)] = [j] * (1 << (7 - j))
+
+
+def bit_scan1(x, n=0):
+    if not x:
+        return
+    x = abs(x >> n)
+    low_byte = x & 0xFF
+    if low_byte:
+        return _small_trailing[low_byte] + n
+
+    t = 8 + n
+    x >>= 8
+    # 2**m is quick for z up through 2**30
+    z = x.bit_length() - 1
+    if x == 1 << z:
+        return z + t
+
+    if z < 300:
+        # fixed 8-byte reduction
+        while not x & 0xFF:
+            x >>= 8
+            t += 8
+    else:
+        # binary reduction important when there might be a large
+        # number of trailing 0s
+        p = z >> 1
+        while not x & 0xFF:
+            while x & ((1 << p) - 1):
+                p >>= 1
+            x >>= p
+            t += p
+    return t + _small_trailing[x & 0xFF]
+
+
+def bit_scan0(x, n=0):
+    return bit_scan1(x + (1 << n), n)
+
+
+def remove(x, f):
+    if f < 2:
+        raise ValueError("factor must be > 1")
+    if x == 0:
+        return 0, 0
+    if f == 2:
+        b = bit_scan1(x)
+        return x >> b, b
+    m = 0
+    y, rem = divmod(x, f)
+    while not rem:
+        x = y
+        m += 1
+        if m > 5:
+            pow_list = [f**2]
+            while pow_list:
+                _f = pow_list[-1]
+                y, rem = divmod(x, _f)
+                if not rem:
+                    m += 1 << len(pow_list)
+                    x = y
+                    pow_list.append(_f**2)
+                else:
+                    pow_list.pop()
+        y, rem = divmod(x, f)
+    return x, m
+
+
+def factorial(x):
+    """Return x!."""
+    return int(mlib.ifac(int(x)))
+
+
+def sqrt(x):
+    """Integer square root of x."""
+    return int(mlib.isqrt(int(x)))
+
+
+def sqrtrem(x):
+    """Integer square root of x and remainder."""
+    s, r = mlib.sqrtrem(int(x))
+    return (int(s), int(r))
+
+
+gcd = math.gcd
+lcm = math.lcm
+
+
+def _sign(n):
+    if n < 0:
+        return -1, -n
+    return 1, n
+
+
+def gcdext(a, b):
+    if not a or not b:
+        g = abs(a) or abs(b)
+        if not g:
+            return (0, 0, 0)
+        return (g, a // g, b // g)
+
+    x_sign, a = _sign(a)
+    y_sign, b = _sign(b)
+    x, r = 1, 0
+    y, s = 0, 1
+
+    while b:
+        q, c = divmod(a, b)
+        a, b = b, c
+        x, r = r, x - q*r
+        y, s = s, y - q*s
+
+    return (a, x * x_sign, y * y_sign)
+
+
+def is_square(x):
+    """Return True if x is a square number."""
+    if x < 0:
+        return False
+
+    # Note that the possible values of y**2 % n for a given n are limited.
+    # For example, when n=4, y**2 % n can only take 0 or 1.
+    # In other words, if x % 4 is 2 or 3, then x is not a square number.
+    # Mathematically, it determines if it belongs to the set {y**2 % n},
+    # but implementationally, it can be realized as a logical conjunction
+    # with an n-bit integer.
+    # see https://mersenneforum.org/showpost.php?p=110896
+    # def magic(n):
+    #     s = {y**2 % n for y in range(n)}
+    #     s = set(range(n)) - s
+    #     return sum(1 << bit for bit in s)
+    # >>> print(hex(magic(128)))
+    # 0xfdfdfdedfdfdfdecfdfdfdedfdfcfdec
+    # >>> print(hex(magic(99)))
+    # 0x5f6f9ffb6fb7ddfcb75befdec
+    # >>> print(hex(magic(91)))
+    # 0x6fd1bfcfed5f3679d3ebdec
+    # >>> print(hex(magic(85)))
+    # 0xdef9ae771ffe3b9d67dec
+    if 0xfdfdfdedfdfdfdecfdfdfdedfdfcfdec & (1 << (x & 127)):
+        return False  # e.g. 2, 3
+    m = x % 765765 # 765765 = 99 * 91 * 85
+    if 0x5f6f9ffb6fb7ddfcb75befdec & (1 << (m % 99)):
+        return False  # e.g. 17, 68
+    if 0x6fd1bfcfed5f3679d3ebdec & (1 << (m % 91)):
+        return False  # e.g. 97, 388
+    if 0xdef9ae771ffe3b9d67dec & (1 << (m % 85)):
+        return False  # e.g. 793, 1408
+    return mlib.sqrtrem(int(x))[1] == 0
+
+
+def invert(x, m):
+    """Modular inverse of x modulo m.
+
+    Returns y such that x*y == 1 mod m.
+
+    Uses ``math.pow`` but reproduces the behaviour of ``gmpy2.invert``
+    which raises ZeroDivisionError if no inverse exists.
+    """
+    try:
+        return pow(x, -1, m)
+    except ValueError:
+        raise ZeroDivisionError("invert() no inverse exists")
+
+
+def legendre(x, y):
+    """Legendre symbol (x / y).
+
+    Following the implementation of gmpy2,
+    the error is raised only when y is an even number.
+    """
+    if y <= 0 or not y % 2:
+        raise ValueError("y should be an odd prime")
+    x %= y
+    if not x:
+        return 0
+    if pow(x, (y - 1) // 2, y) == 1:
+        return 1
+    return -1
+
+
+def jacobi(x, y):
+    """Jacobi symbol (x / y)."""
+    if y <= 0 or not y % 2:
+        raise ValueError("y should be an odd positive integer")
+    x %= y
+    if not x:
+        return int(y == 1)
+    if y == 1 or x == 1:
+        return 1
+    if gcd(x, y) != 1:
+        return 0
+    j = 1
+    while x != 0:
+        while x % 2 == 0 and x > 0:
+            x >>= 1
+            if y % 8 in [3, 5]:
+                j = -j
+        x, y = y, x
+        if x % 4 == y % 4 == 3:
+            j = -j
+        x %= y
+    return j
+
+
+def kronecker(x, y):
+    """Kronecker symbol (x / y)."""
+    if gcd(x, y) != 1:
+        return 0
+    if y == 0:
+        return 1
+    sign = -1 if y < 0 and x < 0 else 1
+    y = abs(y)
+    s = bit_scan1(y)
+    y >>= s
+    if s % 2 and x % 8 in [3, 5]:
+        sign = -sign
+    return sign * jacobi(x, y)
+
+
+def iroot(y, n):
+    if y < 0:
+        raise ValueError("y must be nonnegative")
+    if n < 1:
+        raise ValueError("n must be positive")
+    if y in (0, 1):
+        return y, True
+    if n == 1:
+        return y, True
+    if n == 2:
+        x, rem = mlib.sqrtrem(y)
+        return int(x), not rem
+    if n >= y.bit_length():
+        return 1, False
+    # Get initial estimate for Newton's method. Care must be taken to
+    # avoid overflow
+    try:
+        guess = int(y**(1./n) + 0.5)
+    except OverflowError:
+        exp = math.log2(y)/n
+        if exp > 53:
+            shift = int(exp - 53)
+            guess = int(2.0**(exp - shift) + 1) << shift
+        else:
+            guess = int(2.0**exp)
+    if guess > 2**50:
+        # Newton iteration
+        xprev, x = -1, guess
+        while 1:
+            t = x**(n - 1)
+            xprev, x = x, ((n - 1)*x + y//t)//n
+            if abs(x - xprev) < 2:
+                break
+    else:
+        x = guess
+    # Compensate
+    t = x**n
+    while t < y:
+        x += 1
+        t = x**n
+    while t > y:
+        x -= 1
+        t = x**n
+    return x, t == y
+
+
+def is_fermat_prp(n, a):
+    if a < 2:
+        raise ValueError("is_fermat_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_fermat_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_fermat_prp() requires gcd(n,a) == 1")
+    return pow(a, n - 1, n) == 1
+
+
+def is_euler_prp(n, a):
+    if a < 2:
+        raise ValueError("is_euler_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_euler_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_euler_prp() requires gcd(n,a) == 1")
+    return pow(a, n >> 1, n) == jacobi(a, n) % n
+
+
+def _is_strong_prp(n, a):
+    s = bit_scan1(n - 1)
+    a = pow(a, n >> s, n)
+    if a == 1 or a == n - 1:
+        return True
+    for _ in range(s - 1):
+        a = pow(a, 2, n)
+        if a == n - 1:
+            return True
+        if a == 1:
+            return False
+    return False
+
+
+def is_strong_prp(n, a):
+    if a < 2:
+        raise ValueError("is_strong_prp() requires 'a' greater than or equal to 2")
+    if n < 1:
+        raise ValueError("is_strong_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    a %= n
+    if gcd(n, a) != 1:
+        raise ValueError("is_strong_prp() requires gcd(n,a) == 1")
+    return _is_strong_prp(n, a)
+
+
+def _lucas_sequence(n, P, Q, k):
+    r"""Return the modular Lucas sequence (U_k, V_k, Q_k).
+
+    Explanation
+    ===========
+
+    Given a Lucas sequence defined by P, Q, returns the kth values for
+    U and V, along with Q^k, all modulo n. This is intended for use with
+    possibly very large values of n and k, where the combinatorial functions
+    would be completely unusable.
+
+    .. math ::
+        U_k = \begin{cases}
+             0 & \text{if } k = 0\\
+             1 & \text{if } k = 1\\
+             PU_{k-1} - QU_{k-2} & \text{if } k > 1
+        \end{cases}\\
+        V_k = \begin{cases}
+             2 & \text{if } k = 0\\
+             P & \text{if } k = 1\\
+             PV_{k-1} - QV_{k-2} & \text{if } k > 1
+        \end{cases}
+
+    The modular Lucas sequences are used in numerous places in number theory,
+    especially in the Lucas compositeness tests and the various n + 1 proofs.
+
+    Parameters
+    ==========
+
+    n : int
+        n is an odd number greater than or equal to 3
+    P : int
+    Q : int
+        D determined by D = P**2 - 4*Q is non-zero
+    k : int
+        k is a nonnegative integer
+
+    Returns
+    =======
+
+    U, V, Qk : (int, int, int)
+        `(U_k \bmod{n}, V_k \bmod{n}, Q^k \bmod{n})`
+
+    Examples
+    ========
+
+    >>> from sympy.external.ntheory import _lucas_sequence
+    >>> N = 10**2000 + 4561
+    >>> sol = U, V, Qk = _lucas_sequence(N, 3, 1, N//2); sol
+    (0, 2, 1)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lucas_sequence
+
+    """
+    if k == 0:
+        return (0, 2, 1)
+    D = P**2 - 4*Q
+    U = 1
+    V = P
+    Qk = Q % n
+    if Q == 1:
+        # Optimization for extra strong tests.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2) % n
+            if b == "1":
+                U, V = U*P + V, V*P + U*D
+                if U & 1:
+                    U += n
+                if V & 1:
+                    V += n
+                U, V = U >> 1, V >> 1
+    elif P == 1 and Q == -1:
+        # Small optimization for 50% of Selfridge parameters.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            if Qk == 1:
+                V = (V*V - 2) % n
+            else:
+                V = (V*V + 2) % n
+                Qk = 1
+            if b == "1":
+                # new_U = (U + V) // 2
+                # new_V = (5*U + V) // 2 = 2*U + new_U
+                U, V  = U + V, U << 1
+                if U & 1:
+                    U += n
+                U >>= 1
+                V += U
+                Qk = -1
+        Qk %= n
+    elif P == 1:
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2*Qk) % n
+            Qk *= Qk
+            if b == "1":
+                # new_U = (U + V) // 2
+                # new_V = new_U - 2*Q*U
+                U, V  = U + V, (Q*U) << 1
+                if U & 1:
+                    U += n
+                U >>= 1
+                V = U - V
+                Qk *= Q
+            Qk %= n
+    else:
+        # The general case with any P and Q.
+        for b in bin(k)[3:]:
+            U = (U*V) % n
+            V = (V*V - 2*Qk) % n
+            Qk *= Qk
+            if b == "1":
+                U, V = U*P + V, V*P + U*D
+                if U & 1:
+                    U += n
+                if V & 1:
+                    V += n
+                U, V = U >> 1, V >> 1
+                Qk *= Q
+            Qk %= n
+    return (U % n, V % n, Qk)
+
+
+def is_fibonacci_prp(n, p, q):
+    d = p**2 - 4*q
+    if d == 0 or p <= 0 or q not in [1, -1]:
+        raise ValueError("invalid values for p,q in is_fibonacci_prp()")
+    if n < 1:
+        raise ValueError("is_fibonacci_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _lucas_sequence(n, p, q, n)[1] == p % n
+
+
+def is_lucas_prp(n, p, q):
+    d = p**2 - 4*q
+    if d == 0:
+        raise ValueError("invalid values for p,q in is_lucas_prp()")
+    if n < 1:
+        raise ValueError("is_lucas_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    if gcd(n, q*d) not in [1, n]:
+        raise ValueError("is_lucas_prp() requires gcd(n,2*q*D) == 1")
+    return _lucas_sequence(n, p, q, n - jacobi(d, n))[0] == 0
+
+
+def _is_selfridge_prp(n):
+    """Lucas compositeness test with the Selfridge parameters for n.
+
+    Explanation
+    ===========
+
+    The Lucas compositeness test checks whether n is a prime number.
+    The test can be run with arbitrary parameters ``P`` and ``Q``, which also change the performance of the test.
+    So, which parameters are most effective for running the Lucas compositeness test?
+    As an algorithm for determining ``P`` and ``Q``, Selfridge proposed method A [1]_ page 1401
+    (Since two methods were proposed, referred to simply as A and B in the paper,
+    we will refer to one of them as "method A").
+
+    method A fixes ``P = 1``. Then, ``D`` defined by ``D = P**2 - 4Q`` is varied from 5, -7, 9, -11, 13, and so on,
+    with the first ``D`` being ``jacobi(D, n) == -1``. Once ``D`` is determined,
+    ``Q`` is determined to be ``(P**2 - D)//4``.
+
+    References
+    ==========
+
+    .. [1] Robert Baillie, Samuel S. Wagstaff, Lucas Pseudoprimes,
+           Math. Comp. Vol 35, Number 152 (1980), pp. 1391-1417,
+           https://doi.org/10.1090%2FS0025-5718-1980-0583518-6
+           http://mpqs.free.fr/LucasPseudoprimes.pdf
+
+    """
+    for D in range(5, 1_000_000, 2):
+        if D & 2: # if D % 4 == 3
+            D = -D
+        j = jacobi(D, n)
+        if j == -1:
+            return _lucas_sequence(n, 1, (1-D) // 4, n + 1)[0] == 0
+        if j == 0 and D % n:
+            return False
+        # When j == -1 is hard to find, suspect a square number
+        if D == 13 and is_square(n):
+            return False
+    raise ValueError("appropriate value for D cannot be found in is_selfridge_prp()")
+
+
+def is_selfridge_prp(n):
+    if n < 1:
+        raise ValueError("is_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_selfridge_prp(n)
+
+
+def is_strong_lucas_prp(n, p, q):
+    D = p**2 - 4*q
+    if D == 0:
+        raise ValueError("invalid values for p,q in is_strong_lucas_prp()")
+    if n < 1:
+        raise ValueError("is_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    if gcd(n, q*D) not in [1, n]:
+        raise ValueError("is_strong_lucas_prp() requires gcd(n,2*q*D) == 1")
+    j = jacobi(D, n)
+    s = bit_scan1(n - j)
+    U, V, Qk = _lucas_sequence(n, p, q, (n - j) >> s)
+    if U == 0 or V == 0:
+        return True
+    for _ in range(s - 1):
+        V = (V*V - 2*Qk) % n
+        if V == 0:
+            return True
+        Qk = pow(Qk, 2, n)
+    return False
+
+
+def _is_strong_selfridge_prp(n):
+    for D in range(5, 1_000_000, 2):
+        if D & 2: # if D % 4 == 3
+            D = -D
+        j = jacobi(D, n)
+        if j == -1:
+            s = bit_scan1(n + 1)
+            U, V, Qk = _lucas_sequence(n, 1, (1-D) // 4, (n + 1) >> s)
+            if U == 0 or V == 0:
+                return True
+            for _ in range(s - 1):
+                V = (V*V - 2*Qk) % n
+                if V == 0:
+                    return True
+                Qk = pow(Qk, 2, n)
+            return False
+        if j == 0 and D % n:
+            return False
+        # When j == -1 is hard to find, suspect a square number
+        if D == 13 and is_square(n):
+            return False
+    raise ValueError("appropriate value for D cannot be found in is_strong_selfridge_prp()")
+
+
+def is_strong_selfridge_prp(n):
+    if n < 1:
+        raise ValueError("is_strong_selfridge_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_selfridge_prp(n)
+
+
+def is_bpsw_prp(n):
+    if n < 1:
+        raise ValueError("is_bpsw_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_prp(n, 2) and _is_selfridge_prp(n)
+
+
+def is_strong_bpsw_prp(n):
+    if n < 1:
+        raise ValueError("is_strong_bpsw_prp() requires 'n' be greater than 0")
+    if n == 1:
+        return False
+    if n % 2 == 0:
+        return n == 2
+    return _is_strong_prp(n, 2) and _is_strong_selfridge_prp(n)
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/pythonmpq.py b/.venv/lib/python3.12/site-packages/sympy/external/pythonmpq.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f2d102974e04e139c00a39057976b5a5bf90776
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/pythonmpq.py
@@ -0,0 +1,341 @@
+"""
+PythonMPQ: Rational number type based on Python integers.
+
+This class is intended as a pure Python fallback for when gmpy2 is not
+installed. If gmpy2 is installed then its mpq type will be used instead. The
+mpq type is around 20x faster. We could just use the stdlib Fraction class
+here but that is slower:
+
+    from fractions import Fraction
+    from sympy.external.pythonmpq import PythonMPQ
+    nums = range(1000)
+    dens = range(5, 1005)
+    rats = [Fraction(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <--- 24 milliseconds
+    rats = [PythonMPQ(n, d) for n, d in zip(nums, dens)]
+    sum(rats) # <---  7 milliseconds
+
+Both mpq and Fraction have some awkward features like the behaviour of
+division with // and %:
+
+    >>> from fractions import Fraction
+    >>> Fraction(2, 3) % Fraction(1, 4)
+    1/6
+
+For the QQ domain we do not want this behaviour because there should be no
+remainder when dividing rational numbers. SymPy does not make use of this
+aspect of mpq when gmpy2 is installed. Since this class is a fallback for that
+case we do not bother implementing e.g. __mod__ so that we can be sure we
+are not using it when gmpy2 is installed either.
+"""
+
+from __future__ import annotations
+import operator
+from math import gcd
+from decimal import Decimal
+from fractions import Fraction
+import sys
+from typing import Type
+
+
+# Used for __hash__
+_PyHASH_MODULUS = sys.hash_info.modulus
+_PyHASH_INF = sys.hash_info.inf
+
+
+class PythonMPQ:
+    """Rational number implementation that is intended to be compatible with
+    gmpy2's mpq.
+
+    Also slightly faster than fractions.Fraction.
+
+    PythonMPQ should be treated as immutable although no effort is made to
+    prevent mutation (since that might slow down calculations).
+    """
+    __slots__ = ('numerator', 'denominator')
+
+    def __new__(cls, numerator, denominator=None):
+        """Construct PythonMPQ with gcd computation and checks"""
+        if denominator is not None:
+            #
+            # PythonMPQ(n, d): require n and d to be int and d != 0
+            #
+            if isinstance(numerator, int) and isinstance(denominator, int):
+                # This is the slow part:
+                divisor = gcd(numerator, denominator)
+                numerator //= divisor
+                denominator //= divisor
+                return cls._new_check(numerator, denominator)
+        else:
+            #
+            # PythonMPQ(q)
+            #
+            # Here q can be PythonMPQ, int, Decimal, float, Fraction or str
+            #
+            if isinstance(numerator, int):
+                return cls._new(numerator, 1)
+            elif isinstance(numerator, PythonMPQ):
+                return cls._new(numerator.numerator, numerator.denominator)
+
+            # Let Fraction handle Decimal/float conversion and str parsing
+            if isinstance(numerator, (Decimal, float, str)):
+                numerator = Fraction(numerator)
+            if isinstance(numerator, Fraction):
+                return cls._new(numerator.numerator, numerator.denominator)
+        #
+        # Reject everything else. This is more strict than mpq which allows
+        # things like mpq(Fraction, Fraction) or mpq(Decimal, any). The mpq
+        # behaviour is somewhat inconsistent so we choose to accept only a
+        # more strict subset of what mpq allows.
+        #
+        raise TypeError("PythonMPQ() requires numeric or string argument")
+
+    @classmethod
+    def _new_check(cls, numerator, denominator):
+        """Construct PythonMPQ, check divide by zero and canonicalize signs"""
+        if not denominator:
+            raise ZeroDivisionError(f'Zero divisor {numerator}/{denominator}')
+        elif denominator < 0:
+            numerator = -numerator
+            denominator = -denominator
+        return cls._new(numerator, denominator)
+
+    @classmethod
+    def _new(cls, numerator, denominator):
+        """Construct PythonMPQ efficiently (no checks)"""
+        obj = super().__new__(cls)
+        obj.numerator = numerator
+        obj.denominator = denominator
+        return obj
+
+    def __int__(self):
+        """Convert to int (truncates towards zero)"""
+        p, q = self.numerator, self.denominator
+        if p < 0:
+            return -(-p//q)
+        return p//q
+
+    def __float__(self):
+        """Convert to float (approximately)"""
+        return self.numerator / self.denominator
+
+    def __bool__(self):
+        """True/False if nonzero/zero"""
+        return bool(self.numerator)
+
+    def __eq__(self, other):
+        """Compare equal with PythonMPQ, int, float, Decimal or Fraction"""
+        if isinstance(other, PythonMPQ):
+            return (self.numerator == other.numerator
+                and self.denominator == other.denominator)
+        elif isinstance(other, self._compatible_types):
+            return self.__eq__(PythonMPQ(other))
+        else:
+            return NotImplemented
+
+    def __hash__(self):
+        """hash - same as mpq/Fraction"""
+        try:
+            dinv = pow(self.denominator, -1, _PyHASH_MODULUS)
+        except ValueError:
+            hash_ = _PyHASH_INF
+        else:
+            hash_ = hash(hash(abs(self.numerator)) * dinv)
+        result = hash_ if self.numerator >= 0 else -hash_
+        return -2 if result == -1 else result
+
+    def __reduce__(self):
+        """Deconstruct for pickling"""
+        return type(self), (self.numerator, self.denominator)
+
+    def __str__(self):
+        """Convert to string"""
+        if self.denominator != 1:
+            return f"{self.numerator}/{self.denominator}"
+        else:
+            return f"{self.numerator}"
+
+    def __repr__(self):
+        """Convert to string"""
+        return f"MPQ({self.numerator},{self.denominator})"
+
+    def _cmp(self, other, op):
+        """Helper for lt/le/gt/ge"""
+        if not isinstance(other, self._compatible_types):
+            return NotImplemented
+        lhs = self.numerator * other.denominator
+        rhs = other.numerator * self.denominator
+        return op(lhs, rhs)
+
+    def __lt__(self, other):
+        """self < other"""
+        return self._cmp(other, operator.lt)
+
+    def __le__(self, other):
+        """self <= other"""
+        return self._cmp(other, operator.le)
+
+    def __gt__(self, other):
+        """self > other"""
+        return self._cmp(other, operator.gt)
+
+    def __ge__(self, other):
+        """self >= other"""
+        return self._cmp(other, operator.ge)
+
+    def __abs__(self):
+        """abs(q)"""
+        return self._new(abs(self.numerator), self.denominator)
+
+    def __pos__(self):
+        """+q"""
+        return self
+
+    def __neg__(self):
+        """-q"""
+        return self._new(-self.numerator, self.denominator)
+
+    def __add__(self, other):
+        """q1 + q2"""
+        if isinstance(other, PythonMPQ):
+            #
+            # This is much faster than the naive method used in the stdlib
+            # fractions module. Not sure where this method comes from
+            # though...
+            #
+            # Compare timings for something like:
+            #   nums = range(1000)
+            #   rats = [PythonMPQ(n, d) for n, d in zip(nums[:-5], nums[5:])]
+            #   sum(rats) # <-- time this
+            #
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq + aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 + bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+
+        elif isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __radd__(self, other):
+        """z1 + q2"""
+        if isinstance(other, int):
+            p = self.numerator + self.denominator * other
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __sub__(self ,other):
+        """q1 - q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            g = gcd(aq, bq)
+            if g == 1:
+                p = ap*bq - aq*bp
+                q = bq*aq
+            else:
+                q1, q2 = aq//g, bq//g
+                p, q = ap*q2 - bp*q1, q1*q2
+                g2 = gcd(p, g)
+                p, q = (p // g2), q * (g // g2)
+        elif isinstance(other, int):
+            p = self.numerator - self.denominator*other
+            q = self.denominator
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rsub__(self, other):
+        """z1 - q2"""
+        if isinstance(other, int):
+            p = self.denominator * other - self.numerator
+            q = self.denominator
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __mul__(self, other):
+        """q1 * q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bq)
+            x2 = gcd(bp, aq)
+            p, q = ((ap//x1)*(bp//x2), (aq//x2)*(bq//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.denominator)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+        else:
+            return NotImplemented
+
+        return self._new(p, q)
+
+    def __rmul__(self, other):
+        """z1 * q2"""
+        if isinstance(other, int):
+            x = gcd(self.denominator, other)
+            p = self.numerator*(other//x)
+            q = self.denominator//x
+            return self._new(p, q)
+        else:
+            return NotImplemented
+
+    def __pow__(self, exp):
+        """q ** z"""
+        p, q = self.numerator, self.denominator
+
+        if exp < 0:
+            p, q, exp = q, p, -exp
+
+        return self._new_check(p**exp, q**exp)
+
+    def __truediv__(self, other):
+        """q1 / q2"""
+        if isinstance(other, PythonMPQ):
+            ap, aq = self.numerator, self.denominator
+            bp, bq = other.numerator, other.denominator
+            x1 = gcd(ap, bp)
+            x2 = gcd(bq, aq)
+            p, q = ((ap//x1)*(bq//x2), (aq//x2)*(bp//x1))
+        elif isinstance(other, int):
+            x = gcd(other, self.numerator)
+            p = self.numerator//x
+            q = self.denominator*(other//x)
+        else:
+            return NotImplemented
+
+        return self._new_check(p, q)
+
+    def __rtruediv__(self, other):
+        """z / q"""
+        if isinstance(other, int):
+            x = gcd(self.numerator, other)
+            p = self.denominator*(other//x)
+            q = self.numerator//x
+            return self._new_check(p, q)
+        else:
+            return NotImplemented
+
+    _compatible_types: tuple[Type, ...] = ()
+
+#
+# These are the types that PythonMPQ will interoperate with for operations
+# and comparisons such as ==, + etc. We define this down here so that we can
+# include PythonMPQ in the list as well.
+#
+PythonMPQ._compatible_types = (PythonMPQ, int, Decimal, Fraction)
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ff151e2d4d623e84255bc97ea6e8787bc5a7a910
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_autowrap.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_autowrap.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c101354d9f3e9f028995520cf0bf1ea7d2c27153
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_autowrap.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_codegen.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_codegen.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c03607db948218cb6bedacd78ce52f7eac200401
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_codegen.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_gmpy.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_gmpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d3323e2ca5fe1a7f3998f72a7095d6382b05c64
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_gmpy.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_importtools.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_importtools.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a8429e3e1c1eaad5226424b869d0b6b72153c775
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_importtools.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_ntheory.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_ntheory.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ebd74d27efe4024bf1fe2e44bbf0b935049297ea
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_ntheory.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_numpy.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_numpy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6780ed52ff159e66e7b570e0bf7afc556b7275b2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_numpy.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_pythonmpq.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_pythonmpq.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1f50f78e9d1a06544f2de05c9adbec923579a45
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_pythonmpq.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_scipy.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_scipy.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..774ffaee4d29978abd85aa3b22502d1f0aed1913
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/external/tests/__pycache__/test_scipy.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_autowrap.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_autowrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..d469b552995b7625f786f3296089e41f42da75cb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_autowrap.py
@@ -0,0 +1,313 @@
+import sympy
+import tempfile
+import os
+from pathlib import Path
+from sympy.core.mod import Mod
+from sympy.core.relational import Eq
+from sympy.core.symbol import symbols
+from sympy.external import import_module
+from sympy.tensor import IndexedBase, Idx
+from sympy.utilities.autowrap import autowrap, ufuncify, CodeWrapError
+from sympy.testing.pytest import skip
+
+numpy = import_module('numpy', min_module_version='1.6.1')
+Cython = import_module('Cython', min_module_version='0.15.1')
+f2py = import_module('numpy.f2py', import_kwargs={'fromlist': ['f2py']})
+
+f2pyworks = False
+if f2py:
+    try:
+        autowrap(symbols('x'), 'f95', 'f2py')
+    except (CodeWrapError, ImportError, OSError):
+        f2pyworks = False
+    else:
+        f2pyworks = True
+
+a, b, c = symbols('a b c')
+n, m, d = symbols('n m d', integer=True)
+A, B, C = symbols('A B C', cls=IndexedBase)
+i = Idx('i', m)
+j = Idx('j', n)
+k = Idx('k', d)
+
+
+def has_module(module):
+    """
+    Return True if module exists, otherwise run skip().
+
+    module should be a string.
+    """
+    # To give a string of the module name to skip(), this function takes a
+    # string.  So we don't waste time running import_module() more than once,
+    # just map the three modules tested here in this dict.
+    modnames = {'numpy': numpy, 'Cython': Cython, 'f2py': f2py}
+
+    if modnames[module]:
+        if module == 'f2py' and not f2pyworks:
+            skip("Couldn't run f2py.")
+        return True
+    skip("Couldn't import %s." % module)
+
+#
+# test runners used by several language-backend combinations
+#
+
+def runtest_autowrap_twice(language, backend):
+    f = autowrap((((a + b)/c)**5).expand(), language, backend)
+    g = autowrap((((a + b)/c)**4).expand(), language, backend)
+
+    # check that autowrap updates the module name.  Else, g gives the same as f
+    assert f(1, -2, 1) == -1.0
+    assert g(1, -2, 1) == 1.0
+
+
+def runtest_autowrap_trace(language, backend):
+    has_module('numpy')
+    trace = autowrap(A[i, i], language, backend)
+    assert trace(numpy.eye(100)) == 100
+
+
+def runtest_autowrap_matrix_vector(language, backend):
+    has_module('numpy')
+    x, y = symbols('x y', cls=IndexedBase)
+    expr = Eq(y[i], A[i, j]*x[j])
+    mv = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M = numpy.random.rand(10, 20)
+    x = numpy.random.rand(20)
+    y = numpy.dot(M, x)
+    assert numpy.sum(numpy.abs(y - mv(M, x))) < 1e-13
+
+
+def runtest_autowrap_matrix_matrix(language, backend):
+    has_module('numpy')
+    expr = Eq(C[i, j], A[i, k]*B[k, j])
+    matmat = autowrap(expr, language, backend)
+
+    # compare with numpy's dot product
+    M1 = numpy.random.rand(10, 20)
+    M2 = numpy.random.rand(20, 15)
+    M3 = numpy.dot(M1, M2)
+    assert numpy.sum(numpy.abs(M3 - matmat(M1, M2))) < 1e-13
+
+
+def runtest_ufuncify(language, backend):
+    has_module('numpy')
+    a, b, c = symbols('a b c')
+    fabc = ufuncify([a, b, c], a*b + c, backend=backend)
+    facb = ufuncify([a, c, b], a*b + c, backend=backend)
+    grid = numpy.linspace(-2, 2, 50)
+    b = numpy.linspace(-5, 4, 50)
+    c = numpy.linspace(-1, 1, 50)
+    expected = grid*b + c
+    numpy.testing.assert_allclose(fabc(grid, b, c), expected)
+    numpy.testing.assert_allclose(facb(grid, c, b), expected)
+
+
+def runtest_issue_10274(language, backend):
+    expr = (a - b + c)**(13)
+    tmp = tempfile.mkdtemp()
+    f = autowrap(expr, language, backend, tempdir=tmp,
+                 helpers=('helper', a - b + c, (a, b, c)))
+    assert f(1, 1, 1) == 1
+
+    for file in os.listdir(tmp):
+        if not (file.startswith("wrapped_code_") and file.endswith(".c")):
+            continue
+
+        with open(tmp + '/' + file) as fil:
+            lines = fil.readlines()
+            assert lines[0] == "/******************************************************************************\n"
+            assert "Code generated with SymPy " + sympy.__version__ in lines[1]
+            assert lines[2:] == [
+                " *                                                                            *\n",
+                " *              See http://www.sympy.org/ for more information.               *\n",
+                " *                                                                            *\n",
+                " *                      This file is part of 'autowrap'                       *\n",
+                " ******************************************************************************/\n",
+                "#include " + '"' + file[:-1]+ 'h"' + "\n",
+                "#include \n",
+                "\n",
+                "double helper(double a, double b, double c) {\n",
+                "\n",
+                "   double helper_result;\n",
+                "   helper_result = a - b + c;\n",
+                "   return helper_result;\n",
+                "\n",
+                "}\n",
+                "\n",
+                "double autofunc(double a, double b, double c) {\n",
+                "\n",
+                "   double autofunc_result;\n",
+                "   autofunc_result = pow(helper(a, b, c), 13);\n",
+                "   return autofunc_result;\n",
+                "\n",
+                "}\n",
+                ]
+
+
+def runtest_issue_15337(language, backend):
+    has_module('numpy')
+    # NOTE : autowrap was originally designed to only accept an iterable for
+    # the kwarg "helpers", but in issue 10274 the user mistakenly thought that
+    # if there was only a single helper it did not need to be passed via an
+    # iterable that wrapped the helper tuple. There were no tests for this
+    # behavior so when the code was changed to accept a single tuple it broke
+    # the original behavior. These tests below ensure that both now work.
+    a, b, c, d, e = symbols('a, b, c, d, e')
+    expr = (a - b + c - d + e)**13
+    exp_res = (1. - 2. + 3. - 4. + 5.)**13
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=('f1', a - b + c, (a, b, c)))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+    f = autowrap(expr, language, backend, args=(a, b, c, d, e),
+                 helpers=(('f1', a - b, (a, b)), ('f2', c - d, (c, d))))
+    numpy.testing.assert_allclose(f(1, 2, 3, 4, 5), exp_res)
+
+
+def test_issue_15230():
+    has_module('f2py')
+
+    x, y = symbols('x, y')
+    expr = Mod(x, 3.0) - Mod(y, -2.0)
+    f = autowrap(expr, args=[x, y], language='F95')
+    exp_res = float(expr.xreplace({x: 3.5, y: 2.7}).evalf())
+    assert abs(f(3.5, 2.7) - exp_res) < 1e-14
+
+    x, y = symbols('x, y', integer=True)
+    expr = Mod(x, 3) - Mod(y, -2)
+    f = autowrap(expr, args=[x, y], language='F95')
+    assert f(3, 2) == expr.xreplace({x: 3, y: 2})
+
+#
+# tests of language-backend combinations
+#
+
+# f2py
+
+
+def test_wrap_twice_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_twice('f95', 'f2py')
+
+
+def test_autowrap_trace_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_trace('f95', 'f2py')
+
+
+def test_autowrap_matrix_vector_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_vector('f95', 'f2py')
+
+
+def test_autowrap_matrix_matrix_f95_f2py():
+    has_module('f2py')
+    runtest_autowrap_matrix_matrix('f95', 'f2py')
+
+
+def test_ufuncify_f95_f2py():
+    has_module('f2py')
+    runtest_ufuncify('f95', 'f2py')
+
+
+def test_issue_15337_f95_f2py():
+    has_module('f2py')
+    runtest_issue_15337('f95', 'f2py')
+
+# Cython
+
+
+def test_wrap_twice_c_cython():
+    has_module('Cython')
+    runtest_autowrap_twice('C', 'cython')
+
+
+def test_autowrap_trace_C_Cython():
+    has_module('Cython')
+    runtest_autowrap_trace('C99', 'cython')
+
+
+def test_autowrap_matrix_vector_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_vector('C99', 'cython')
+
+
+def test_autowrap_matrix_matrix_C_cython():
+    has_module('Cython')
+    runtest_autowrap_matrix_matrix('C99', 'cython')
+
+
+def test_ufuncify_C_Cython():
+    has_module('Cython')
+    runtest_ufuncify('C99', 'cython')
+
+
+def test_issue_10274_C_cython():
+    has_module('Cython')
+    runtest_issue_10274('C89', 'cython')
+
+
+def test_issue_15337_C_cython():
+    has_module('Cython')
+    runtest_issue_15337('C89', 'cython')
+
+
+def test_autowrap_custom_printer():
+    has_module('Cython')
+
+    from sympy.core.numbers import pi
+    from sympy.utilities.codegen import C99CodeGen
+    from sympy.printing.c import C99CodePrinter
+
+    class PiPrinter(C99CodePrinter):
+        def _print_Pi(self, expr):
+            return "S_PI"
+
+    printer = PiPrinter()
+    gen = C99CodeGen(printer=printer)
+    gen.preprocessor_statements.append('#include "shortpi.h"')
+
+    expr = pi * a
+
+    expected = (
+        '#include "%s"\n'
+        '#include \n'
+        '#include "shortpi.h"\n'
+        '\n'
+        'double autofunc(double a) {\n'
+        '\n'
+        '   double autofunc_result;\n'
+        '   autofunc_result = S_PI*a;\n'
+        '   return autofunc_result;\n'
+        '\n'
+        '}\n'
+    )
+
+    tmpdir = tempfile.mkdtemp()
+    # write a trivial header file to use in the generated code
+    Path(os.path.join(tmpdir, 'shortpi.h')).write_text('#define S_PI 3.14')
+
+    func = autowrap(expr, backend='cython', tempdir=tmpdir, code_gen=gen)
+
+    assert func(4.2) == 3.14 * 4.2
+
+    # check that the generated code is correct
+    for filename in os.listdir(tmpdir):
+        if filename.startswith('wrapped_code') and filename.endswith('.c'):
+            with open(os.path.join(tmpdir, filename)) as f:
+                lines = f.readlines()
+                expected = expected % filename.replace('.c', '.h')
+                assert ''.join(lines[7:]) == expected
+
+
+# Numpy
+
+def test_ufuncify_numpy():
+    # This test doesn't use Cython, but if Cython works, then there is a valid
+    # C compiler, which is needed.
+    has_module('Cython')
+    runtest_ufuncify('C99', 'numpy')
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_codegen.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_codegen.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a4fe28300b86fb0b38d98fcf2fcbbe514cf720f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_codegen.py
@@ -0,0 +1,375 @@
+# This tests the compilation and execution of the source code generated with
+# utilities.codegen. The compilation takes place in a temporary directory that
+# is removed after the test. By default the test directory is always removed,
+# but this behavior can be changed by setting the environment variable
+# SYMPY_TEST_CLEAN_TEMP to:
+#   export SYMPY_TEST_CLEAN_TEMP=always   : the default behavior.
+#   export SYMPY_TEST_CLEAN_TEMP=success  : only remove the directories of working tests.
+#   export SYMPY_TEST_CLEAN_TEMP=never    : never remove the directories with the test code.
+# When a directory is not removed, the necessary information is printed on
+# screen to find the files that belong to the (failed) tests. If a test does
+# not fail, py.test captures all the output and you will not see the directories
+# corresponding to the successful tests. Use the --nocapture option to see all
+# the output.
+
+# All tests below have a counterpart in utilities/test/test_codegen.py. In the
+# latter file, the resulting code is compared with predefined strings, without
+# compilation or execution.
+
+# All the generated Fortran code should conform with the Fortran 95 standard,
+# and all the generated C code should be ANSI C, which facilitates the
+# incorporation in various projects. The tests below assume that the binary cc
+# is somewhere in the path and that it can compile ANSI C code.
+
+from sympy.abc import x, y, z
+from sympy.testing.pytest import IS_WASM, skip
+from sympy.utilities.codegen import codegen, make_routine, get_code_generator
+import sys
+import os
+import tempfile
+import subprocess
+from pathlib import Path
+
+
+# templates for the main program that will test the generated code.
+
+main_template = {}
+main_template['F95'] = """
+program main
+  include "codegen.h"
+  integer :: result;
+  result = 0
+
+  %(statements)s
+
+  call exit(result)
+end program
+"""
+
+main_template['C89'] = """
+#include "codegen.h"
+#include 
+#include 
+
+int main() {
+  int result = 0;
+
+  %(statements)s
+
+  return result;
+}
+"""
+main_template['C99'] = main_template['C89']
+# templates for the numerical tests
+
+numerical_test_template = {}
+numerical_test_template['C89'] = """
+  if (fabs(%(call)s)>%(threshold)s) {
+    printf("Numerical validation failed: %(call)s=%%e threshold=%(threshold)s\\n", %(call)s);
+    result = -1;
+  }
+"""
+numerical_test_template['C99'] = numerical_test_template['C89']
+
+numerical_test_template['F95'] = """
+  if (abs(%(call)s)>%(threshold)s) then
+    write(6,"('Numerical validation failed:')")
+    write(6,"('%(call)s=',e15.5,'threshold=',e15.5)") %(call)s, %(threshold)s
+    result = -1;
+  end if
+"""
+# command sequences for supported compilers
+
+compile_commands = {}
+compile_commands['cc'] = [
+    "cc -c codegen.c -o codegen.o",
+    "cc -c main.c -o main.o",
+    "cc main.o codegen.o -lm -o test.exe"
+]
+
+compile_commands['gfortran'] = [
+    "gfortran -c codegen.f90 -o codegen.o",
+    "gfortran -ffree-line-length-none -c main.f90 -o main.o",
+    "gfortran main.o codegen.o -o test.exe"
+]
+
+compile_commands['g95'] = [
+    "g95 -c codegen.f90 -o codegen.o",
+    "g95 -ffree-line-length-huge -c main.f90 -o main.o",
+    "g95 main.o codegen.o -o test.exe"
+]
+
+compile_commands['ifort'] = [
+    "ifort -c codegen.f90 -o codegen.o",
+    "ifort -c main.f90 -o main.o",
+    "ifort main.o codegen.o -o test.exe"
+]
+
+combinations_lang_compiler = [
+    ('C89', 'cc'),
+    ('C99', 'cc'),
+    ('F95', 'ifort'),
+    ('F95', 'gfortran'),
+    ('F95', 'g95')
+]
+
+def try_run(commands):
+    """Run a series of commands and only return True if all ran fine."""
+    if IS_WASM:
+        return False
+    with open(os.devnull, 'w') as null:
+        for command in commands:
+            retcode = subprocess.call(command, stdout=null, shell=True,
+                    stderr=subprocess.STDOUT)
+            if retcode != 0:
+                return False
+    return True
+
+
+def run_test(label, routines, numerical_tests, language, commands, friendly=True):
+    """A driver for the codegen tests.
+
+       This driver assumes that a compiler ifort is present in the PATH and that
+       ifort is (at least) a Fortran 90 compiler. The generated code is written in
+       a temporary directory, together with a main program that validates the
+       generated code. The test passes when the compilation and the validation
+       run correctly.
+    """
+
+    # Check input arguments before touching the file system
+    language = language.upper()
+    assert language in main_template
+    assert language in numerical_test_template
+
+    # Check that environment variable makes sense
+    clean = os.getenv('SYMPY_TEST_CLEAN_TEMP', 'always').lower()
+    if clean not in ('always', 'success', 'never'):
+        raise ValueError("SYMPY_TEST_CLEAN_TEMP must be one of the following: 'always', 'success' or 'never'.")
+
+    # Do all the magic to compile, run and validate the test code
+    # 1) prepare the temporary working directory, switch to that dir
+    work = tempfile.mkdtemp("_sympy_%s_test" % language, "%s_" % label)
+    oldwork = os.getcwd()
+    os.chdir(work)
+
+    # 2) write the generated code
+    if friendly:
+        # interpret the routines as a name_expr list and call the friendly
+        # function codegen
+        codegen(routines, language, "codegen", to_files=True)
+    else:
+        code_gen = get_code_generator(language, "codegen")
+        code_gen.write(routines, "codegen", to_files=True)
+
+    # 3) write a simple main program that links to the generated code, and that
+    #    includes the numerical tests
+    test_strings = []
+    for fn_name, args, expected, threshold in numerical_tests:
+        call_string = "%s(%s)-(%s)" % (
+            fn_name, ",".join(str(arg) for arg in args), expected)
+        if language == "F95":
+            call_string = fortranize_double_constants(call_string)
+            threshold = fortranize_double_constants(str(threshold))
+        test_strings.append(numerical_test_template[language] % {
+            "call": call_string,
+            "threshold": threshold,
+        })
+
+    if language == "F95":
+        f_name = "main.f90"
+    elif language.startswith("C"):
+        f_name = "main.c"
+    else:
+        raise NotImplementedError(
+            "FIXME: filename extension unknown for language: %s" % language)
+
+    Path(f_name).write_text(
+        main_template[language] % {'statements': "".join(test_strings)})
+
+    # 4) Compile and link
+    compiled = try_run(commands)
+
+    # 5) Run if compiled
+    if compiled:
+        executed = try_run(["./test.exe"])
+    else:
+        executed = False
+
+    # 6) Clean up stuff
+    if clean == 'always' or (clean == 'success' and compiled and executed):
+        def safe_remove(filename):
+            if os.path.isfile(filename):
+                os.remove(filename)
+        safe_remove("codegen.f90")
+        safe_remove("codegen.c")
+        safe_remove("codegen.h")
+        safe_remove("codegen.o")
+        safe_remove("main.f90")
+        safe_remove("main.c")
+        safe_remove("main.o")
+        safe_remove("test.exe")
+        os.chdir(oldwork)
+        os.rmdir(work)
+    else:
+        print("TEST NOT REMOVED: %s" % work, file=sys.stderr)
+        os.chdir(oldwork)
+
+    # 7) Do the assertions in the end
+    assert compiled, "failed to compile %s code with:\n%s" % (
+        language, "\n".join(commands))
+    assert executed, "failed to execute %s code from:\n%s" % (
+        language, "\n".join(commands))
+
+
+def fortranize_double_constants(code_string):
+    """
+    Replaces every literal float with literal doubles
+    """
+    import re
+    pattern_exp = re.compile(r'\d+(\.)?\d*[eE]-?\d+')
+    pattern_float = re.compile(r'\d+\.\d*(?!\d*d)')
+
+    def subs_exp(matchobj):
+        return re.sub('[eE]', 'd', matchobj.group(0))
+
+    def subs_float(matchobj):
+        return "%sd0" % matchobj.group(0)
+
+    code_string = pattern_exp.sub(subs_exp, code_string)
+    code_string = pattern_float.sub(subs_float, code_string)
+
+    return code_string
+
+
+def is_feasible(language, commands):
+    # This test should always work, otherwise the compiler is not present.
+    routine = make_routine("test", x)
+    numerical_tests = [
+        ("test", ( 1.0,), 1.0, 1e-15),
+        ("test", (-1.0,), -1.0, 1e-15),
+    ]
+    try:
+        run_test("is_feasible", [routine], numerical_tests, language, commands,
+                 friendly=False)
+        return True
+    except AssertionError:
+        return False
+
+valid_lang_commands = []
+invalid_lang_compilers = []
+for lang, compiler in combinations_lang_compiler:
+    commands = compile_commands[compiler]
+    if is_feasible(lang, commands):
+        valid_lang_commands.append((lang, commands))
+    else:
+        invalid_lang_compilers.append((lang, compiler))
+
+# We test all language-compiler combinations, just to report what is skipped
+
+def test_C89_cc():
+    if ("C89", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C89)")
+
+
+def test_C99_cc():
+    if ("C99", 'cc') in invalid_lang_compilers:
+        skip("`cc' command didn't work as expected (C99)")
+
+
+def test_F95_ifort():
+    if ("F95", 'ifort') in invalid_lang_compilers:
+        skip("`ifort' command didn't work as expected")
+
+
+def test_F95_gfortran():
+    if ("F95", 'gfortran') in invalid_lang_compilers:
+        skip("`gfortran' command didn't work as expected")
+
+
+def test_F95_g95():
+    if ("F95", 'g95') in invalid_lang_compilers:
+        skip("`g95' command didn't work as expected")
+
+# Here comes the actual tests
+
+
+def test_basic_codegen():
+    numerical_tests = [
+        ("test", (1.0, 6.0, 3.0), 21.0, 1e-15),
+        ("test", (-1.0, 2.0, -2.5), -2.5, 1e-15),
+    ]
+    name_expr = [("test", (x + y)*z)]
+    for lang, commands in valid_lang_commands:
+        run_test("basic_codegen", name_expr, numerical_tests, lang, commands)
+
+
+def test_intrinsic_math1_codegen():
+    # not included: log10
+    from sympy.core.evalf import N
+    from sympy.functions import ln
+    from sympy.functions.elementary.exponential import log
+    from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+    from sympy.functions.elementary.integers import (ceiling, floor)
+    from sympy.functions.elementary.miscellaneous import sqrt
+    from sympy.functions.elementary.trigonometric import (acos, asin, atan, cos, sin, tan)
+    name_expr = [
+        ("test_fabs", abs(x)),
+        ("test_acos", acos(x)),
+        ("test_asin", asin(x)),
+        ("test_atan", atan(x)),
+        ("test_cos", cos(x)),
+        ("test_cosh", cosh(x)),
+        ("test_log", log(x)),
+        ("test_ln", ln(x)),
+        ("test_sin", sin(x)),
+        ("test_sinh", sinh(x)),
+        ("test_sqrt", sqrt(x)),
+        ("test_tan", tan(x)),
+        ("test_tanh", tanh(x)),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval in 0.2, 0.5, 0.8:
+            expected = N(expr.subs(x, xval))
+            numerical_tests.append((name, (xval,), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        if lang.startswith("C"):
+            name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))]
+        else:
+            name_expr_C = []
+        run_test("intrinsic_math1", name_expr + name_expr_C,
+                 numerical_tests, lang, commands)
+
+
+def test_instrinsic_math2_codegen():
+    # not included: frexp, ldexp, modf, fmod
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import atan2
+    name_expr = [
+        ("test_atan2", atan2(x, y)),
+        ("test_pow", x**y),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval in (0.2, 1.3), (0.5, -0.2), (0.8, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval))
+            numerical_tests.append((name, (xval, yval), expected, 1e-14))
+    for lang, commands in valid_lang_commands:
+        run_test("intrinsic_math2", name_expr, numerical_tests, lang, commands)
+
+
+def test_complicated_codegen():
+    from sympy.core.evalf import N
+    from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+    name_expr = [
+        ("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
+        ("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
+    ]
+    numerical_tests = []
+    for name, expr in name_expr:
+        for xval, yval, zval in (0.2, 1.3, -0.3), (0.5, -0.2, 0.0), (0.8, 2.1, 0.8):
+            expected = N(expr.subs(x, xval).subs(y, yval).subs(z, zval))
+            numerical_tests.append((name, (xval, yval, zval), expected, 1e-12))
+    for lang, commands in valid_lang_commands:
+        run_test(
+            "complicated_codegen", name_expr, numerical_tests, lang, commands)
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_gmpy.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_gmpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..d88f9da0c6c26c15f529ce485fff5b72342170ea
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_gmpy.py
@@ -0,0 +1,12 @@
+from sympy.external.gmpy import LONG_MAX, iroot
+from sympy.testing.pytest import raises
+
+
+def test_iroot():
+    assert iroot(2, LONG_MAX) == (1, False)
+    assert iroot(2, LONG_MAX + 1) == (1, False)
+    for x in range(3):
+        assert iroot(x, 1) == (x, True)
+    raises(ValueError, lambda: iroot(-1, 1))
+    raises(ValueError, lambda: iroot(0, 0))
+    raises(ValueError, lambda: iroot(0, -1))
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_importtools.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_importtools.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b954070c179282ed2bcf5735d802c5f22a3a261
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_importtools.py
@@ -0,0 +1,40 @@
+from sympy.external import import_module
+from sympy.testing.pytest import warns
+
+# fixes issue that arose in addressing issue 6533
+def test_no_stdlib_collections():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections2():
+    '''
+    make sure we get the right collections when it is not part of a
+    larger list
+    '''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['collections']},
+        min_module_version='1.1.0', catch=(RuntimeError,))
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_no_stdlib_collections3():
+    '''make sure we get the right collections with no catch'''
+    import collections
+    matplotlib = import_module('matplotlib',
+        import_kwargs={'fromlist': ['cm', 'collections']},
+        min_module_version='1.1.0')
+    if matplotlib:
+        assert collections != matplotlib.collections
+
+def test_min_module_version_python3_basestring_error():
+    with warns(UserWarning):
+        import_module('mpmath', min_module_version='1000.0.1')
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_ntheory.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_ntheory.py
new file mode 100644
index 0000000000000000000000000000000000000000..00824481ad27aa9071ea5801fb3bde75cacbc3c8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_ntheory.py
@@ -0,0 +1,307 @@
+from itertools import permutations
+
+from sympy.external.ntheory import (bit_scan1, remove, bit_scan0, is_fermat_prp,
+                                    is_euler_prp, is_strong_prp, gcdext, _lucas_sequence,
+                                    is_fibonacci_prp, is_lucas_prp, is_selfridge_prp,
+                                    is_strong_lucas_prp, is_strong_selfridge_prp,
+                                    is_bpsw_prp, is_strong_bpsw_prp)
+from sympy.testing.pytest import raises
+
+
+def test_bit_scan1():
+    assert bit_scan1(0) is None
+    assert bit_scan1(1) == 0
+    assert bit_scan1(-1) == 0
+    assert bit_scan1(2) == 1
+    assert bit_scan1(7) == 0
+    assert bit_scan1(-7) == 0
+    for i in range(100):
+        assert bit_scan1(1 << i) == i
+        assert bit_scan1((1 << i) * 31337) == i
+    for i in range(500):
+        n = (1 << 500) + (1 << i)
+        assert bit_scan1(n) == i
+    assert bit_scan1(1 << 1000001) == 1000001
+    assert bit_scan1((1 << 273956)*7**37) == 273956
+    # issue 12709
+    for i in range(1, 10):
+        big = 1 << i
+        assert bit_scan1(-big) == bit_scan1(big)
+
+
+def test_bit_scan0():
+    assert bit_scan0(-1) is None
+    assert bit_scan0(0) == 0
+    assert bit_scan0(1) == 1
+    assert bit_scan0(-2) == 0
+
+
+def test_remove():
+    raises(ValueError, lambda: remove(1, 1))
+    assert remove(0, 3) == (0, 0)
+    for f in range(2, 10):
+        for y in range(2, 1000):
+            for z in [1, 17, 101, 1009]:
+                assert remove(z*f**y, f) == (z, y)
+
+
+def test_gcdext():
+    assert gcdext(0, 0) == (0, 0, 0)
+    assert gcdext(3, 0) == (3, 1, 0)
+    assert gcdext(0, 4) == (4, 0, 1)
+
+    for n in range(1, 10):
+        assert gcdext(n, 1) == gcdext(-n, 1) == (1, 0, 1)
+        assert gcdext(n, -1) == gcdext(-n, -1) == (1, 0, -1)
+        assert gcdext(n, n) == gcdext(-n, n) == (n, 0, 1)
+        assert gcdext(n, -n) == gcdext(-n, -n) == (n, 0, -1)
+
+    for n in range(2, 10):
+        assert gcdext(1, n) == gcdext(1, -n) == (1, 1, 0)
+        assert gcdext(-1, n) == gcdext(-1, -n) == (1, -1, 0)
+
+    for a, b in permutations([2**5, 3, 5, 7**2, 11], 2):
+        g, x, y = gcdext(a, b)
+        assert g == a*x + b*y == 1
+
+
+def test_is_fermat_prp():
+    # invalid input
+    raises(ValueError, lambda: is_fermat_prp(0, 10))
+    raises(ValueError, lambda: is_fermat_prp(5, 1))
+
+    # n = 1
+    assert not is_fermat_prp(1, 3)
+
+    # n is prime
+    assert is_fermat_prp(2, 4)
+    assert is_fermat_prp(3, 2)
+    assert is_fermat_prp(11, 3)
+    assert is_fermat_prp(2**31-1, 5)
+
+    # A001567
+    pseudorpime = [341, 561, 645, 1105, 1387, 1729, 1905, 2047,
+                   2465, 2701, 2821, 3277, 4033, 4369, 4371, 4681]
+    for n in pseudorpime:
+        assert is_fermat_prp(n, 2)
+
+    # A020136
+    pseudorpime = [15, 85, 91, 341, 435, 451, 561, 645, 703, 1105,
+                   1247, 1271, 1387, 1581, 1695, 1729, 1891, 1905]
+    for n in pseudorpime:
+        assert is_fermat_prp(n, 4)
+
+
+def test_is_euler_prp():
+    # invalid input
+    raises(ValueError, lambda: is_euler_prp(0, 10))
+    raises(ValueError, lambda: is_euler_prp(5, 1))
+
+    # n = 1
+    assert not is_euler_prp(1, 3)
+
+    # n is prime
+    assert is_euler_prp(2, 4)
+    assert is_euler_prp(3, 2)
+    assert is_euler_prp(11, 3)
+    assert is_euler_prp(2**31-1, 5)
+
+    # A047713
+    pseudorpime = [561, 1105, 1729, 1905, 2047, 2465, 3277, 4033,
+                   4681, 6601, 8321, 8481, 10585, 12801, 15841]
+    for n in pseudorpime:
+        assert is_euler_prp(n, 2)
+
+    # A048950
+    pseudorpime = [121, 703, 1729, 1891, 2821, 3281, 7381, 8401,
+                   8911, 10585, 12403, 15457, 15841, 16531, 18721]
+    for n in pseudorpime:
+        assert is_euler_prp(n, 3)
+
+
+def test_is_strong_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_prp(0, 10))
+    raises(ValueError, lambda: is_strong_prp(5, 1))
+
+    # n = 1
+    assert not is_strong_prp(1, 3)
+
+    # n is prime
+    assert is_strong_prp(2, 4)
+    assert is_strong_prp(3, 2)
+    assert is_strong_prp(11, 3)
+    assert is_strong_prp(2**31-1, 5)
+
+    # A001262
+    pseudorpime = [2047, 3277, 4033, 4681, 8321, 15841, 29341,
+                   42799, 49141, 52633, 65281, 74665, 80581]
+    for n in pseudorpime:
+        assert is_strong_prp(n, 2)
+
+    # A020229
+    pseudorpime = [121, 703, 1891, 3281, 8401, 8911, 10585, 12403,
+                   16531, 18721, 19345, 23521, 31621, 44287, 47197]
+    for n in pseudorpime:
+        assert is_strong_prp(n, 3)
+
+
+def test_lucas_sequence():
+    def lucas_u(P, Q, length):
+        array = [0] * length
+        array[1] = 1
+        for k in range(2, length):
+            array[k] = P * array[k - 1] - Q * array[k - 2]
+        return array
+
+    def lucas_v(P, Q, length):
+        array = [0] * length
+        array[0] = 2
+        array[1] = P
+        for k in range(2, length):
+            array[k] = P * array[k - 1] - Q * array[k - 2]
+        return array
+
+    length = 20
+    for P in range(-10, 10):
+        for Q in range(-10, 10):
+            D = P**2 - 4*Q
+            if D == 0:
+                continue
+            us = lucas_u(P, Q, length)
+            vs = lucas_v(P, Q, length)
+            for n in range(3, 100, 2):
+                for k in range(length):
+                    U, V, Qk = _lucas_sequence(n, P, Q, k)
+                    assert U == us[k] % n
+                    assert V == vs[k] % n
+                    assert pow(Q, k, n) == Qk
+
+
+def test_is_fibonacci_prp():
+    # invalid input
+    raises(ValueError, lambda: is_fibonacci_prp(3, 2, 1))
+    raises(ValueError, lambda: is_fibonacci_prp(3, -5, 1))
+    raises(ValueError, lambda: is_fibonacci_prp(3, 5, 2))
+    raises(ValueError, lambda: is_fibonacci_prp(0, 5, -1))
+
+    # n = 1
+    assert not is_fibonacci_prp(1, 3, 1)
+
+    # n is prime
+    assert is_fibonacci_prp(2, 5, 1)
+    assert is_fibonacci_prp(3, 6, -1)
+    assert is_fibonacci_prp(11, 7, 1)
+    assert is_fibonacci_prp(2**31-1, 8, -1)
+
+    # A005845
+    pseudorpime = [705, 2465, 2737, 3745, 4181, 5777, 6721,
+                   10877, 13201, 15251, 24465, 29281, 34561]
+    for n in pseudorpime:
+        assert is_fibonacci_prp(n, 1, -1)
+
+
+def test_is_lucas_prp():
+    # invalid input
+    raises(ValueError, lambda: is_lucas_prp(3, 2, 1))
+    raises(ValueError, lambda: is_lucas_prp(0, 5, -1))
+    raises(ValueError, lambda: is_lucas_prp(15, 3, 1))
+
+    # n = 1
+    assert not is_lucas_prp(1, 3, 1)
+
+    # n is prime
+    assert is_lucas_prp(2, 5, 2)
+    assert is_lucas_prp(3, 6, -1)
+    assert is_lucas_prp(11, 7, 5)
+    assert is_lucas_prp(2**31-1, 8, -3)
+
+    # A081264
+    pseudorpime = [323, 377, 1891, 3827, 4181, 5777, 6601, 6721,
+                   8149, 10877, 11663, 13201, 13981, 15251, 17119]
+    for n in pseudorpime:
+        assert is_lucas_prp(n, 1, -1)
+
+
+def test_is_selfridge_prp():
+    # invalid input
+    raises(ValueError, lambda: is_selfridge_prp(0))
+
+    # n = 1
+    assert not is_selfridge_prp(1)
+
+    # n is prime
+    assert is_selfridge_prp(2)
+    assert is_selfridge_prp(3)
+    assert is_selfridge_prp(11)
+    assert is_selfridge_prp(2**31-1)
+
+    # A217120
+    pseudorpime = [323, 377, 1159, 1829, 3827, 5459, 5777, 9071,
+                   9179, 10877, 11419, 11663, 13919, 14839, 16109]
+    for n in pseudorpime:
+        assert is_selfridge_prp(n)
+
+
+def test_is_strong_lucas_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_lucas_prp(3, 2, 1))
+    raises(ValueError, lambda: is_strong_lucas_prp(0, 5, -1))
+    raises(ValueError, lambda: is_strong_lucas_prp(15, 3, 1))
+
+    # n = 1
+    assert not is_strong_lucas_prp(1, 3, 1)
+
+    # n is prime
+    assert is_strong_lucas_prp(2, 5, 2)
+    assert is_strong_lucas_prp(3, 6, -1)
+    assert is_strong_lucas_prp(11, 7, 5)
+    assert is_strong_lucas_prp(2**31-1, 8, -3)
+
+
+def test_is_strong_selfridge_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_selfridge_prp(0))
+
+    # n = 1
+    assert not is_strong_selfridge_prp(1)
+
+    # n is prime
+    assert is_strong_selfridge_prp(2)
+    assert is_strong_selfridge_prp(3)
+    assert is_strong_selfridge_prp(11)
+    assert is_strong_selfridge_prp(2**31-1)
+
+    # A217255
+    pseudorpime = [5459, 5777, 10877, 16109, 18971, 22499, 24569,
+                   25199, 40309, 58519, 75077, 97439, 100127, 113573]
+    for n in pseudorpime:
+        assert is_strong_selfridge_prp(n)
+
+
+def test_is_bpsw_prp():
+    # invalid input
+    raises(ValueError, lambda: is_bpsw_prp(0))
+
+    # n = 1
+    assert not is_bpsw_prp(1)
+
+    # n is prime
+    assert is_bpsw_prp(2)
+    assert is_bpsw_prp(3)
+    assert is_bpsw_prp(11)
+    assert is_bpsw_prp(2**31-1)
+
+
+def test_is_strong_bpsw_prp():
+    # invalid input
+    raises(ValueError, lambda: is_strong_bpsw_prp(0))
+
+    # n = 1
+    assert not is_strong_bpsw_prp(1)
+
+    # n is prime
+    assert is_strong_bpsw_prp(2)
+    assert is_strong_bpsw_prp(3)
+    assert is_strong_bpsw_prp(11)
+    assert is_strong_bpsw_prp(2**31-1)
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_numpy.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_numpy.py
new file mode 100644
index 0000000000000000000000000000000000000000..cd456d0d6cc49138c29d7ab28ee02694448d578f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_numpy.py
@@ -0,0 +1,335 @@
+# This testfile tests SymPy <-> NumPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with NumPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without numpy). Here we test everything, that a user may need when
+# using SymPy with NumPy
+from sympy.external.importtools import version_tuple
+from sympy.external import import_module
+
+numpy = import_module('numpy')
+if numpy:
+    array, matrix, ndarray = numpy.array, numpy.matrix, numpy.ndarray
+else:
+    #bin/test will not execute any tests now
+    disabled = True
+
+
+from sympy.core.numbers import (Float, Integer, Rational)
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.trigonometric import sin
+from sympy.matrices.dense import (Matrix, list2numpy, matrix2numpy, symarray)
+from sympy.utilities.lambdify import lambdify
+import sympy
+
+import mpmath
+from sympy.abc import x, y, z
+from sympy.utilities.decorator import conserve_mpmath_dps
+from sympy.utilities.exceptions import ignore_warnings
+from sympy.testing.pytest import raises
+
+
+# first, systematically check, that all operations are implemented and don't
+# raise an exception
+
+
+def test_systematic_basic():
+    def s(sympy_object, numpy_array):
+        _ = [sympy_object + numpy_array,
+        numpy_array + sympy_object,
+        sympy_object - numpy_array,
+        numpy_array - sympy_object,
+        sympy_object * numpy_array,
+        numpy_array * sympy_object,
+        sympy_object / numpy_array,
+        numpy_array / sympy_object,
+        sympy_object ** numpy_array,
+        numpy_array ** sympy_object]
+    x = Symbol("x")
+    y = Symbol("y")
+    sympy_objs = [
+        Rational(2, 3),
+        Float("1.3"),
+        x,
+        y,
+        pow(x, y)*y,
+        Integer(5),
+        Float(5.5),
+    ]
+    numpy_objs = [
+        array([1]),
+        array([3, 8, -1]),
+        array([x, x**2, Rational(5)]),
+        array([x/y*sin(y), 5, Rational(5)]),
+    ]
+    for x in sympy_objs:
+        for y in numpy_objs:
+            s(x, y)
+
+
+# now some random tests, that test particular problems and that also
+# check that the results of the operations are correct
+
+def test_basics():
+    one = Rational(1)
+    zero = Rational(0)
+    assert array(1) == array(one)
+    assert array([one]) == array([one])
+    assert array([x]) == array([x])
+    assert array(x) == array(Symbol("x"))
+    assert array(one + x) == array(1 + x)
+
+    X = array([one, zero, zero])
+    assert (X == array([one, zero, zero])).all()
+    assert (X == array([one, 0, 0])).all()
+
+
+def test_arrays():
+    one = Rational(1)
+    zero = Rational(0)
+    X = array([one, zero, zero])
+    Y = one*X
+    X = array([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_conversion1():
+    a = list2numpy([x**2, x])
+    #looks like an array?
+    assert isinstance(a, ndarray)
+    assert a[0] == x**2
+    assert a[1] == x
+    assert len(a) == 2
+    #yes, it's the array
+
+
+def test_conversion2():
+    a = 2*list2numpy([x**2, x])
+    b = list2numpy([2*x**2, 2*x])
+    assert (a == b).all()
+
+    one = Rational(1)
+    zero = Rational(0)
+    X = list2numpy([one, zero, zero])
+    Y = one*X
+    X = list2numpy([Symbol("a") + Rational(1, 2)])
+    Y = X + X
+    assert Y == array([1 + 2*Symbol("a")])
+    Y = Y + 1
+    assert Y == array([2 + 2*Symbol("a")])
+    Y = X - X
+    assert Y == array([0])
+
+
+def test_list2numpy():
+    assert (array([x**2, x]) == list2numpy([x**2, x])).all()
+
+
+def test_Matrix1():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    assert (array(m.subs(x, 2)) == array([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix2():
+    m = Matrix([[x, x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[2, 4], [5, 1]])).all()
+    m = Matrix([[sin(x), x**2], [5, 2/x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        assert (matrix(m.subs(x, 2)) == matrix([[sin(2), 4], [5, 1]])).all()
+
+
+def test_Matrix3():
+    a = array([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    a = array([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix4():
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[2, 4], [5, 1]])
+    assert Matrix(a) == Matrix([[2, 4], [5, 1]])
+    assert Matrix(a) != Matrix([[2, 4], [5, 2]])
+    with ignore_warnings(PendingDeprecationWarning):
+        a = matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) == Matrix([[sin(2), 4], [5, 1]])
+    assert Matrix(a) != Matrix([[sin(0), 4], [5, 1]])
+
+
+def test_Matrix_sum():
+    M = Matrix([[1, 2, 3], [x, y, x], [2*y, -50, z*x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 3, 4], [x, 5, 6], [x, y, z**2]])
+    assert M + m == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert m + M == Matrix([[3, 5, 7], [2*x, y + 5, x + 6], [2*y + x, y - 50, z*x + z**2]])
+    assert M + m == M.add(m)
+
+
+def test_Matrix_mul():
+    M = Matrix([[1, 2, 3], [x, y, x]])
+    with ignore_warnings(PendingDeprecationWarning):
+        m = matrix([[2, 4], [x, 6], [x, z**2]])
+    assert M*m == Matrix([
+        [         2 + 5*x,        16 + 3*z**2],
+        [2*x + x*y + x**2, 4*x + 6*y + x*z**2],
+    ])
+
+    assert m*M == Matrix([
+        [   2 + 4*x,      4 + 4*y,      6 + 4*x],
+        [       7*x,    2*x + 6*y,          9*x],
+        [x + x*z**2, 2*x + y*z**2, 3*x + x*z**2],
+    ])
+    a = array([2])
+    assert a[0] * M == 2 * M
+    assert M * a[0] == 2 * M
+
+
+def test_Matrix_array():
+    class matarray:
+        def __array__(self, dtype=object, copy=None):
+            if copy is not None and not copy:
+                raise TypeError("Cannot implement copy=False when converting Matrix to ndarray")
+            from numpy import array
+            return array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    matarr = matarray()
+    assert Matrix(matarr) == Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+
+
+def test_matrix2numpy():
+    a = matrix2numpy(Matrix([[1, x**2], [3*sin(x), 0]]))
+    assert isinstance(a, ndarray)
+    assert a.shape == (2, 2)
+    assert a[0, 0] == 1
+    assert a[0, 1] == x**2
+    assert a[1, 0] == 3*sin(x)
+    assert a[1, 1] == 0
+
+
+def test_matrix2numpy_conversion():
+    a = Matrix([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    b = array([[1, 2, sin(x)], [x**2, x, Rational(1, 2)]])
+    assert (matrix2numpy(a) == b).all()
+    assert matrix2numpy(a).dtype == numpy.dtype('object')
+
+    c = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='int8')
+    d = matrix2numpy(Matrix([[1, 2], [10, 20]]), dtype='float64')
+    assert c.dtype == numpy.dtype('int8')
+    assert d.dtype == numpy.dtype('float64')
+
+
+def test_issue_3728():
+    assert (Rational(1, 2)*array([2*x, 0]) == array([x, 0])).all()
+    assert (Rational(1, 2) + array(
+        [2*x, 0]) == array([2*x + Rational(1, 2), Rational(1, 2)])).all()
+    assert (Float("0.5")*array([2*x, 0]) == array([Float("1.0")*x, 0])).all()
+    assert (Float("0.5") + array(
+        [2*x, 0]) == array([2*x + Float("0.5"), Float("0.5")])).all()
+
+
+@conserve_mpmath_dps
+def test_lambdify():
+    mpmath.mp.dps = 16
+    sin02 = mpmath.mpf("0.198669330795061215459412627")
+    f = lambdify(x, sin(x), "numpy")
+    prec = 1e-15
+    assert -prec < f(0.2) - sin02 < prec
+
+    # if this succeeds, it can't be a numpy function
+
+    if version_tuple(numpy.__version__) >= version_tuple('1.17'):
+        with raises(TypeError):
+            f(x)
+    else:
+        with raises(AttributeError):
+            f(x)
+
+
+def test_lambdify_matrix():
+    f = lambdify(x, Matrix([[x, 2*x], [1, 2]]), [{'ImmutableMatrix': numpy.array}, "numpy"])
+    assert (f(1) == array([[1, 2], [1, 2]])).all()
+
+
+def test_lambdify_matrix_multi_input():
+    M = sympy.Matrix([[x**2, x*y, x*z],
+                      [y*x, y**2, y*z],
+                      [z*x, z*y, z**2]])
+    f = lambdify((x, y, z), M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    xh, yh, zh = 1.0, 2.0, 3.0
+    expected = array([[xh**2, xh*yh, xh*zh],
+                      [yh*xh, yh**2, yh*zh],
+                      [zh*xh, zh*yh, zh**2]])
+    actual = f(xh, yh, zh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_matrix_vec_input():
+    X = sympy.DeferredVector('X')
+    M = Matrix([
+        [X[0]**2, X[0]*X[1], X[0]*X[2]],
+        [X[1]*X[0], X[1]**2, X[1]*X[2]],
+        [X[2]*X[0], X[2]*X[1], X[2]**2]])
+    f = lambdify(X, M, [{'ImmutableMatrix': numpy.array}, "numpy"])
+
+    Xh = array([1.0, 2.0, 3.0])
+    expected = array([[Xh[0]**2, Xh[0]*Xh[1], Xh[0]*Xh[2]],
+                      [Xh[1]*Xh[0], Xh[1]**2, Xh[1]*Xh[2]],
+                      [Xh[2]*Xh[0], Xh[2]*Xh[1], Xh[2]**2]])
+    actual = f(Xh)
+    assert numpy.allclose(actual, expected)
+
+
+def test_lambdify_transl():
+    from sympy.utilities.lambdify import NUMPY_TRANSLATIONS
+    for sym, mat in NUMPY_TRANSLATIONS.items():
+        assert sym in sympy.__dict__
+        assert mat in numpy.__dict__
+
+
+def test_symarray():
+    """Test creation of numpy arrays of SymPy symbols."""
+
+    import numpy as np
+    import numpy.testing as npt
+
+    syms = symbols('_0,_1,_2')
+    s1 = symarray("", 3)
+    s2 = symarray("", 3)
+    npt.assert_array_equal(s1, np.array(syms, dtype=object))
+    assert s1[0] == s2[0]
+
+    a = symarray('a', 3)
+    b = symarray('b', 3)
+    assert not(a[0] == b[0])
+
+    asyms = symbols('a_0,a_1,a_2')
+    npt.assert_array_equal(a, np.array(asyms, dtype=object))
+
+    # Multidimensional checks
+    a2d = symarray('a', (2, 3))
+    assert a2d.shape == (2, 3)
+    a00, a12 = symbols('a_0_0,a_1_2')
+    assert a2d[0, 0] == a00
+    assert a2d[1, 2] == a12
+
+    a3d = symarray('a', (2, 3, 2))
+    assert a3d.shape == (2, 3, 2)
+    a000, a120, a121 = symbols('a_0_0_0,a_1_2_0,a_1_2_1')
+    assert a3d[0, 0, 0] == a000
+    assert a3d[1, 2, 0] == a120
+    assert a3d[1, 2, 1] == a121
+
+
+def test_vectorize():
+    assert (numpy.vectorize(
+        sin)([1, 2, 3]) == numpy.array([sin(1), sin(2), sin(3)])).all()
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_pythonmpq.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_pythonmpq.py
new file mode 100644
index 0000000000000000000000000000000000000000..137cfdf5c858544f0811ae666f000cfb368787a0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_pythonmpq.py
@@ -0,0 +1,176 @@
+"""
+test_pythonmpq.py
+
+Test the PythonMPQ class for consistency with gmpy2's mpq type. If gmpy2 is
+installed run the same tests for both.
+"""
+from fractions import Fraction
+from decimal import Decimal
+import pickle
+from typing import Callable, List, Tuple, Type
+
+from sympy.testing.pytest import raises
+
+from sympy.external.pythonmpq import PythonMPQ
+
+#
+# If gmpy2 is installed then run the tests for both mpq and PythonMPQ.
+# That should ensure consistency between the implementation here and mpq.
+#
+rational_types: List[Tuple[Callable, Type, Callable, Type]]
+rational_types = [(PythonMPQ, PythonMPQ, int, int)]
+try:
+    from gmpy2 import mpq, mpz
+    rational_types.append((mpq, type(mpq(1)), mpz, type(mpz(1))))
+except ImportError:
+    pass
+
+
+def test_PythonMPQ():
+    #
+    # Test PythonMPQ and also mpq if gmpy/gmpy2 is installed.
+    #
+    for Q, TQ, Z, TZ in rational_types:
+
+        def check_Q(q):
+            assert isinstance(q, TQ)
+            assert isinstance(q.numerator, TZ)
+            assert isinstance(q.denominator, TZ)
+            return q.numerator, q.denominator
+
+        # Check construction from different types
+        assert check_Q(Q(3)) == (3, 1)
+        assert check_Q(Q(3, 5)) == (3, 5)
+        assert check_Q(Q(Q(3, 5))) == (3, 5)
+        assert check_Q(Q(0.5)) == (1, 2)
+        assert check_Q(Q('0.5')) == (1, 2)
+        assert check_Q(Q(Fraction(3, 5))) == (3, 5)
+
+        # https://github.com/aleaxit/gmpy/issues/327
+        if Q is PythonMPQ:
+            assert check_Q(Q(Decimal('0.6'))) == (3, 5)
+
+        # Invalid types
+        raises(TypeError, lambda: Q([]))
+        raises(TypeError, lambda: Q([], []))
+
+        # Check normalisation of signs
+        assert check_Q(Q(2, 3)) == (2, 3)
+        assert check_Q(Q(-2, 3)) == (-2, 3)
+        assert check_Q(Q(2, -3)) == (-2, 3)
+        assert check_Q(Q(-2, -3)) == (2, 3)
+
+        # Check gcd calculation
+        assert check_Q(Q(12, 8)) == (3, 2)
+
+        # __int__/__float__
+        assert int(Q(5, 3)) == 1
+        assert int(Q(-5, 3)) == -1
+        assert float(Q(5, 2)) == 2.5
+        assert float(Q(-5, 2)) == -2.5
+
+        # __str__/__repr__
+        assert str(Q(2, 1)) == "2"
+        assert str(Q(1, 2)) == "1/2"
+        if Q is PythonMPQ:
+            assert repr(Q(2, 1)) == "MPQ(2,1)"
+            assert repr(Q(1, 2)) == "MPQ(1,2)"
+        else:
+            assert repr(Q(2, 1)) == "mpq(2,1)"
+            assert repr(Q(1, 2)) == "mpq(1,2)"
+
+        # __bool__
+        assert bool(Q(1, 2)) is True
+        assert bool(Q(0)) is False
+
+        # __eq__/__ne__
+        assert (Q(2, 3) == Q(2, 3)) is True
+        assert (Q(2, 3) == Q(2, 5)) is False
+        assert (Q(2, 3) != Q(2, 3)) is False
+        assert (Q(2, 3) != Q(2, 5)) is True
+
+        # __hash__
+        assert hash(Q(3, 5)) == hash(Fraction(3, 5))
+
+        # __reduce__
+        q = Q(2, 3)
+        assert pickle.loads(pickle.dumps(q)) == q
+
+        # __ge__/__gt__/__le__/__lt__
+        assert (Q(1, 3) < Q(2, 3)) is True
+        assert (Q(2, 3) < Q(2, 3)) is False
+        assert (Q(2, 3) < Q(1, 3)) is False
+        assert (Q(-2, 3) < Q(1, 3)) is True
+        assert (Q(1, 3) < Q(-2, 3)) is False
+
+        assert (Q(1, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(2, 3)) is True
+        assert (Q(2, 3) <= Q(1, 3)) is False
+        assert (Q(-2, 3) <= Q(1, 3)) is True
+        assert (Q(1, 3) <= Q(-2, 3)) is False
+
+        assert (Q(1, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(2, 3)) is False
+        assert (Q(2, 3) > Q(1, 3)) is True
+        assert (Q(-2, 3) > Q(1, 3)) is False
+        assert (Q(1, 3) > Q(-2, 3)) is True
+
+        assert (Q(1, 3) >= Q(2, 3)) is False
+        assert (Q(2, 3) >= Q(2, 3)) is True
+        assert (Q(2, 3) >= Q(1, 3)) is True
+        assert (Q(-2, 3) >= Q(1, 3)) is False
+        assert (Q(1, 3) >= Q(-2, 3)) is True
+
+        # __abs__/__pos__/__neg__
+        assert abs(Q(2, 3)) == abs(Q(-2, 3)) == Q(2, 3)
+        assert +Q(2, 3) == Q(2, 3)
+        assert -Q(2, 3) == Q(-2, 3)
+
+        # __add__/__radd__
+        assert Q(2, 3) + Q(5, 7) == Q(29, 21)
+        assert Q(2, 3) + 1 == Q(5, 3)
+        assert 1 + Q(2, 3) == Q(5, 3)
+        raises(TypeError, lambda: [] + Q(1))
+        raises(TypeError, lambda: Q(1) + [])
+
+        # __sub__/__rsub__
+        assert Q(2, 3) - Q(5, 7) == Q(-1, 21)
+        assert Q(2, 3) - 1 == Q(-1, 3)
+        assert 1 - Q(2, 3) == Q(1, 3)
+        raises(TypeError, lambda: [] - Q(1))
+        raises(TypeError, lambda: Q(1) - [])
+
+        # __mul__/__rmul__
+        assert Q(2, 3) * Q(5, 7) == Q(10, 21)
+        assert Q(2, 3) * 1 == Q(2, 3)
+        assert 1 * Q(2, 3) == Q(2, 3)
+        raises(TypeError, lambda: [] * Q(1))
+        raises(TypeError, lambda: Q(1) * [])
+
+        # __pow__/__rpow__
+        assert Q(2, 3) ** 2 == Q(4, 9)
+        assert Q(2, 3) ** 1 == Q(2, 3)
+        assert Q(-2, 3) ** 2 == Q(4, 9)
+        assert Q(-2, 3) ** -1 == Q(-3, 2)
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: 1 ** Q(2, 3))
+            raises(TypeError, lambda: Q(1, 4) ** Q(1, 2))
+        raises(TypeError, lambda: [] ** Q(1))
+        raises(TypeError, lambda: Q(1) ** [])
+
+        # __div__/__rdiv__
+        assert Q(2, 3) / Q(5, 7) == Q(14, 15)
+        assert Q(2, 3) / 1 == Q(2, 3)
+        assert 1 / Q(2, 3) == Q(3, 2)
+        raises(TypeError, lambda: [] / Q(1))
+        raises(TypeError, lambda: Q(1) / [])
+        raises(ZeroDivisionError, lambda: Q(1, 2) / Q(0))
+
+        # __divmod__
+        if Q is PythonMPQ:
+            raises(TypeError, lambda: Q(2, 3) // Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) % Q(1, 3))
+            raises(TypeError, lambda: 1 // Q(1, 3))
+            raises(TypeError, lambda: 1 % Q(1, 3))
+            raises(TypeError, lambda: Q(2, 3) // 1)
+            raises(TypeError, lambda: Q(2, 3) % 1)
diff --git a/.venv/lib/python3.12/site-packages/sympy/external/tests/test_scipy.py b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_scipy.py
new file mode 100644
index 0000000000000000000000000000000000000000..3746d1a311eb68bb1af16e18ab152c7236b42bb5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/external/tests/test_scipy.py
@@ -0,0 +1,35 @@
+# This testfile tests SymPy <-> SciPy compatibility
+
+# Don't test any SymPy features here. Just pure interaction with SciPy.
+# Always write regular SymPy tests for anything, that can be tested in pure
+# Python (without scipy). Here we test everything, that a user may need when
+# using SymPy with SciPy
+
+from sympy.external import import_module
+
+scipy = import_module('scipy')
+if not scipy:
+    #bin/test will not execute any tests now
+    disabled = True
+
+from sympy.functions.special.bessel import jn_zeros
+
+
+def eq(a, b, tol=1e-6):
+    for x, y in zip(a, b):
+        if not (abs(x - y) < tol):
+            return False
+    return True
+
+
+def test_jn_zeros():
+    assert eq(jn_zeros(0, 4, method="scipy"),
+            [3.141592, 6.283185, 9.424777, 12.566370])
+    assert eq(jn_zeros(1, 4, method="scipy"),
+            [4.493409, 7.725251, 10.904121, 14.066193])
+    assert eq(jn_zeros(2, 4, method="scipy"),
+            [5.763459, 9.095011, 12.322940, 15.514603])
+    assert eq(jn_zeros(3, 4, method="scipy"),
+            [6.987932, 10.417118, 13.698023, 16.923621])
+    assert eq(jn_zeros(4, 4, method="scipy"),
+            [8.182561, 11.704907, 15.039664, 18.301255])
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed93b2a11754aa26af5eef3932d177374b3ddfd6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/__init__.py
@@ -0,0 +1,115 @@
+"""A functions module, includes all the standard functions.
+
+Combinatorial - factorial, fibonacci, harmonic, bernoulli...
+Elementary - hyperbolic, trigonometric, exponential, floor and ceiling, sqrt...
+Special - gamma, zeta,spherical harmonics...
+"""
+
+from sympy.functions.combinatorial.factorials import (factorial, factorial2,
+        rf, ff, binomial, RisingFactorial, FallingFactorial, subfactorial)
+from sympy.functions.combinatorial.numbers import (carmichael, fibonacci, lucas, tribonacci,
+        harmonic, bernoulli, bell, euler, catalan, genocchi, andre, partition, divisor_sigma,
+        udivisor_sigma, legendre_symbol, jacobi_symbol, kronecker_symbol, mobius,
+        primenu, primeomega, totient, reduced_totient, primepi, motzkin)
+from sympy.functions.elementary.miscellaneous import (sqrt, root, Min, Max,
+        Id, real_root, cbrt, Rem)
+from sympy.functions.elementary.complexes import (re, im, sign, Abs,
+        conjugate, arg, polar_lift, periodic_argument, unbranched_argument,
+        principal_branch, transpose, adjoint, polarify, unpolarify)
+from sympy.functions.elementary.trigonometric import (sin, cos, tan,
+        sec, csc, cot, sinc, asin, acos, atan, asec, acsc, acot, atan2)
+from sympy.functions.elementary.exponential import (exp_polar, exp, log,
+        LambertW)
+from sympy.functions.elementary.hyperbolic import (sinh, cosh, tanh, coth,
+        sech, csch, asinh, acosh, atanh, acoth, asech, acsch)
+from sympy.functions.elementary.integers import floor, ceiling, frac
+from sympy.functions.elementary.piecewise import (Piecewise, piecewise_fold,
+                                                  piecewise_exclusive)
+from sympy.functions.special.error_functions import (erf, erfc, erfi, erf2,
+        erfinv, erfcinv, erf2inv, Ei, expint, E1, li, Li, Si, Ci, Shi, Chi,
+        fresnels, fresnelc)
+from sympy.functions.special.gamma_functions import (gamma, lowergamma,
+        uppergamma, polygamma, loggamma, digamma, trigamma, multigamma)
+from sympy.functions.special.zeta_functions import (dirichlet_eta, zeta,
+        lerchphi, polylog, stieltjes, riemann_xi)
+from sympy.functions.special.tensor_functions import (Eijk, LeviCivita,
+        KroneckerDelta)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.functions.special.delta_functions import DiracDelta, Heaviside
+from sympy.functions.special.bsplines import bspline_basis, bspline_basis_set, interpolating_spline
+from sympy.functions.special.bessel import (besselj, bessely, besseli, besselk,
+        hankel1, hankel2, jn, yn, jn_zeros, hn1, hn2, airyai, airybi, airyaiprime, airybiprime, marcumq)
+from sympy.functions.special.hyper import hyper, meijerg, appellf1
+from sympy.functions.special.polynomials import (legendre, assoc_legendre,
+        hermite, hermite_prob, chebyshevt, chebyshevu, chebyshevu_root,
+        chebyshevt_root, laguerre, assoc_laguerre, gegenbauer, jacobi, jacobi_normalized)
+from sympy.functions.special.spherical_harmonics import Ynm, Ynm_c, Znm
+from sympy.functions.special.elliptic_integrals import (elliptic_k,
+        elliptic_f, elliptic_e, elliptic_pi)
+from sympy.functions.special.beta_functions import beta, betainc, betainc_regularized
+from sympy.functions.special.mathieu_functions import (mathieus, mathieuc,
+        mathieusprime, mathieucprime)
+ln = log
+
+__all__ = [
+    'factorial', 'factorial2', 'rf', 'ff', 'binomial', 'RisingFactorial',
+    'FallingFactorial', 'subfactorial',
+
+    'carmichael', 'fibonacci', 'lucas', 'motzkin', 'tribonacci', 'harmonic',
+    'bernoulli', 'bell', 'euler', 'catalan', 'genocchi', 'andre', 'partition',
+    'divisor_sigma', 'udivisor_sigma', 'legendre_symbol', 'jacobi_symbol', 'kronecker_symbol',
+    'mobius', 'primenu', 'primeomega', 'totient', 'reduced_totient', 'primepi',
+
+    'sqrt', 'root', 'Min', 'Max', 'Id', 'real_root', 'cbrt', 'Rem',
+
+    're', 'im', 'sign', 'Abs', 'conjugate', 'arg', 'polar_lift',
+    'periodic_argument', 'unbranched_argument', 'principal_branch',
+    'transpose', 'adjoint', 'polarify', 'unpolarify',
+
+    'sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinc', 'asin', 'acos', 'atan',
+    'asec', 'acsc', 'acot', 'atan2',
+
+    'exp_polar', 'exp', 'ln', 'log', 'LambertW',
+
+    'sinh', 'cosh', 'tanh', 'coth', 'sech', 'csch', 'asinh', 'acosh', 'atanh',
+    'acoth', 'asech', 'acsch',
+
+    'floor', 'ceiling', 'frac',
+
+    'Piecewise', 'piecewise_fold', 'piecewise_exclusive',
+
+    'erf', 'erfc', 'erfi', 'erf2', 'erfinv', 'erfcinv', 'erf2inv', 'Ei',
+    'expint', 'E1', 'li', 'Li', 'Si', 'Ci', 'Shi', 'Chi', 'fresnels',
+    'fresnelc',
+
+    'gamma', 'lowergamma', 'uppergamma', 'polygamma', 'loggamma', 'digamma',
+    'trigamma', 'multigamma',
+
+    'dirichlet_eta', 'zeta', 'lerchphi', 'polylog', 'stieltjes', 'riemann_xi',
+
+    'Eijk', 'LeviCivita', 'KroneckerDelta',
+
+    'SingularityFunction',
+
+    'DiracDelta', 'Heaviside',
+
+    'bspline_basis', 'bspline_basis_set', 'interpolating_spline',
+
+    'besselj', 'bessely', 'besseli', 'besselk', 'hankel1', 'hankel2', 'jn',
+    'yn', 'jn_zeros', 'hn1', 'hn2', 'airyai', 'airybi', 'airyaiprime',
+    'airybiprime', 'marcumq',
+
+    'hyper', 'meijerg', 'appellf1',
+
+    'legendre', 'assoc_legendre', 'hermite', 'hermite_prob', 'chebyshevt',
+    'chebyshevu', 'chebyshevu_root', 'chebyshevt_root', 'laguerre',
+    'assoc_laguerre', 'gegenbauer', 'jacobi', 'jacobi_normalized',
+
+    'Ynm', 'Ynm_c', 'Znm',
+
+    'elliptic_k', 'elliptic_f', 'elliptic_e', 'elliptic_pi',
+
+    'beta', 'betainc', 'betainc_regularized',
+
+    'mathieus', 'mathieuc', 'mathieusprime', 'mathieucprime',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c53bfc3655e85e477cbe33ac830bb31622fab14
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..584b3c8d46b5c7600d85efc7db46d7aa190397f8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__init__.py
@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.combinatorial
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0c0ac9e683eaad339d7a77ac9817657f5a98869
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/factorials.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/factorials.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b812b6dbbd8fe9bc0e6edc20607c803630f7e6e7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/factorials.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d8ca0d3885cb1726ca65787a3a4a5956b9c81b0f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/__pycache__/numbers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c548434cb3b512dc9dc9319f385e04fb4f969f6a0f59bec8e6541b4e63b2eb97
+size 129346
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/factorials.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/factorials.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c6d2f09524debca29d3040b28a019127a244b33
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/factorials.py
@@ -0,0 +1,1133 @@
+from __future__ import annotations
+from functools import reduce
+
+from sympy.core import S, sympify, Dummy, Mod
+from sympy.core.cache import cacheit
+from sympy.core.function import DefinedFunction, ArgumentIndexError, PoleError
+from sympy.core.logic import fuzzy_and
+from sympy.core.numbers import Integer, pi, I
+from sympy.core.relational import Eq
+from sympy.external.gmpy import gmpy as _gmpy
+from sympy.ntheory import sieve
+from sympy.ntheory.residue_ntheory import binomial_mod
+from sympy.polys.polytools import Poly
+
+from math import factorial as _factorial, prod, sqrt as _sqrt
+
+class CombinatorialFunction(DefinedFunction):
+    """Base class for combinatorial functions. """
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.combsimp import combsimp
+        # combinatorial function with non-integer arguments is
+        # automatically passed to gammasimp
+        expr = combsimp(self)
+        measure = kwargs['measure']
+        if measure(expr) <= kwargs['ratio']*measure(self):
+            return expr
+        return self
+
+
+###############################################################################
+######################## FACTORIAL and MULTI-FACTORIAL ########################
+###############################################################################
+
+
+class factorial(CombinatorialFunction):
+    r"""Implementation of factorial function over nonnegative integers.
+       By convention (consistent with the gamma function and the binomial
+       coefficients), factorial of a negative integer is complex infinity.
+
+       The factorial is very important in combinatorics where it gives
+       the number of ways in which `n` objects can be permuted. It also
+       arises in calculus, probability, number theory, etc.
+
+       There is strict relation of factorial with gamma function. In
+       fact `n! = gamma(n+1)` for nonnegative integers. Rewrite of this
+       kind is very useful in case of combinatorial simplification.
+
+       Computation of the factorial is done using two algorithms. For
+       small arguments a precomputed look up table is used. However for bigger
+       input algorithm Prime-Swing is used. It is the fastest algorithm
+       known and computes `n!` via prime factorization of special class
+       of numbers, called here the 'Swing Numbers'.
+
+       Examples
+       ========
+
+       >>> from sympy import Symbol, factorial, S
+       >>> n = Symbol('n', integer=True)
+
+       >>> factorial(0)
+       1
+
+       >>> factorial(7)
+       5040
+
+       >>> factorial(-2)
+       zoo
+
+       >>> factorial(n)
+       factorial(n)
+
+       >>> factorial(2*n)
+       factorial(2*n)
+
+       >>> factorial(S(1)/2)
+       factorial(1/2)
+
+       See Also
+       ========
+
+       factorial2, RisingFactorial, FallingFactorial
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import (gamma, polygamma)
+        if argindex == 1:
+            return gamma(self.args[0] + 1)*polygamma(0, self.args[0] + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    _small_swing = [
+        1, 1, 1, 3, 3, 15, 5, 35, 35, 315, 63, 693, 231, 3003, 429, 6435, 6435, 109395,
+        12155, 230945, 46189, 969969, 88179, 2028117, 676039, 16900975, 1300075,
+        35102025, 5014575, 145422675, 9694845, 300540195, 300540195
+    ]
+
+    _small_factorials: list[int] = []
+
+    @classmethod
+    def _swing(cls, n):
+        if n < 33:
+            return cls._small_swing[n]
+        else:
+            N, primes = int(_sqrt(n)), []
+
+            for prime in sieve.primerange(3, N + 1):
+                p, q = 1, n
+
+                while True:
+                    q //= prime
+
+                    if q > 0:
+                        if q & 1 == 1:
+                            p *= prime
+                    else:
+                        break
+
+                if p > 1:
+                    primes.append(p)
+
+            for prime in sieve.primerange(N + 1, n//3 + 1):
+                if (n // prime) & 1 == 1:
+                    primes.append(prime)
+
+            L_product = prod(sieve.primerange(n//2 + 1, n + 1))
+            R_product = prod(primes)
+
+            return L_product*R_product
+
+    @classmethod
+    def _recursive(cls, n):
+        if n < 2:
+            return 1
+        else:
+            return (cls._recursive(n//2)**2)*cls._swing(n)
+
+    @classmethod
+    def eval(cls, n):
+        n = sympify(n)
+
+        if n.is_Number:
+            if n.is_zero:
+                return S.One
+            elif n is S.Infinity:
+                return S.Infinity
+            elif n.is_Integer:
+                if n.is_negative:
+                    return S.ComplexInfinity
+                else:
+                    n = n.p
+
+                    if n < 20:
+                        if not cls._small_factorials:
+                            result = 1
+                            for i in range(1, 20):
+                                result *= i
+                                cls._small_factorials.append(result)
+                        result = cls._small_factorials[n-1]
+
+                    # GMPY factorial is faster, use it when available
+                    #
+                    # XXX: There is a sympy.external.gmpy.factorial function
+                    # which provides gmpy.fac if available or the flint version
+                    # if flint is used. It could be used here to avoid the
+                    # conditional logic but it needs to be checked whether the
+                    # pure Python fallback used there is as fast as the
+                    # fallback used here (perhaps the fallback here should be
+                    # moved to sympy.external.ntheory).
+                    elif _gmpy is not None:
+                        result = _gmpy.fac(n)
+
+                    else:
+                        bits = bin(n).count('1')
+                        result = cls._recursive(n)*2**(n - bits)
+
+                    return Integer(result)
+
+    def _facmod(self, n, q):
+        res, N = 1, int(_sqrt(n))
+
+        # Exponent of prime p in n! is e_p(n) = [n/p] + [n/p**2] + ...
+        # for p > sqrt(n), e_p(n) < sqrt(n), the primes with [n/p] = m,
+        # occur consecutively and are grouped together in pw[m] for
+        # simultaneous exponentiation at a later stage
+        pw = [1]*N
+
+        m = 2 # to initialize the if condition below
+        for prime in sieve.primerange(2, n + 1):
+            if m > 1:
+                m, y = 0, n // prime
+                while y:
+                    m += y
+                    y //= prime
+            if m < N:
+                pw[m] = pw[m]*prime % q
+            else:
+                res = res*pow(prime, m, q) % q
+
+        for ex, bs in enumerate(pw):
+            if ex == 0 or bs == 1:
+                continue
+            if bs == 0:
+                return 0
+            res = res*pow(bs, ex, q) % q
+
+        return res
+
+    def _eval_Mod(self, q):
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative and q.is_integer:
+            aq = abs(q)
+            d = aq - n
+            if d.is_nonpositive:
+                return S.Zero
+            else:
+                isprime = aq.is_prime
+                if d == 1:
+                    # Apply Wilson's theorem (if a natural number n > 1
+                    # is a prime number, then (n-1)! = -1 mod n) and
+                    # its inverse (if n > 4 is a composite number, then
+                    # (n-1)! = 0 mod n)
+                    if isprime:
+                        return -1 % q
+                    elif isprime is False and (aq - 6).is_nonnegative:
+                        return S.Zero
+                elif n.is_Integer and q.is_Integer:
+                    n, d, aq = map(int, (n, d, aq))
+                    if isprime and (d - 1 < n):
+                        fc = self._facmod(d - 1, aq)
+                        fc = pow(fc, aq - 2, aq)
+                        if d%2:
+                            fc = -fc
+                    else:
+                        fc = self._facmod(n, aq)
+
+                    return fc % q
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)
+
+    def _eval_rewrite_as_Product(self, n, **kwargs):
+        from sympy.concrete.products import Product
+        if n.is_nonnegative and n.is_integer:
+            i = Dummy('i', integer=True)
+            return Product(i, (i, 1, n))
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_even(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 2).is_nonnegative
+
+    def _eval_is_composite(self):
+        x = self.args[0]
+        if x.is_integer and x.is_nonnegative:
+            return (x - 3).is_nonnegative
+
+    def _eval_is_real(self):
+        x = self.args[0]
+        if x.is_nonnegative or x.is_noninteger:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x)
+        arg0 = arg.subs(x, 0)
+        if arg0.is_zero:
+            return S.One
+        elif not arg0.is_infinite:
+            return self.func(arg)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+class MultiFactorial(CombinatorialFunction):
+    pass
+
+
+class subfactorial(CombinatorialFunction):
+    r"""The subfactorial counts the derangements of $n$ items and is
+    defined for non-negative integers as:
+
+    .. math:: !n = \begin{cases} 1 & n = 0 \\ 0 & n = 1 \\
+                    (n-1)(!(n-1) + !(n-2)) & n > 1 \end{cases}
+
+    It can also be written as ``int(round(n!/exp(1)))`` but the
+    recursive definition with caching is implemented for this function.
+
+    An interesting analytic expression is the following [2]_
+
+    .. math:: !x = \Gamma(x + 1, -1)/e
+
+    which is valid for non-negative integers `x`. The above formula
+    is not very useful in case of non-integers. `\Gamma(x + 1, -1)` is
+    single-valued only for integral arguments `x`, elsewhere on the positive
+    real axis it has an infinite number of branches none of which are real.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Subfactorial
+    .. [2] https://mathworld.wolfram.com/Subfactorial.html
+
+    Examples
+    ========
+
+    >>> from sympy import subfactorial
+    >>> from sympy.abc import n
+    >>> subfactorial(n + 1)
+    subfactorial(n + 1)
+    >>> subfactorial(5)
+    44
+
+    See Also
+    ========
+
+    factorial, uppergamma,
+    sympy.utilities.iterables.generate_derangements
+    """
+
+    @classmethod
+    @cacheit
+    def _eval(self, n):
+        if not n:
+            return S.One
+        elif n == 1:
+            return S.Zero
+        else:
+            z1, z2 = 1, 0
+            for i in range(2, n + 1):
+                z1, z2 = z2, (i - 1)*(z2 + z1)
+            return z2
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg.is_Integer and arg.is_nonnegative:
+                return cls._eval(arg)
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+
+    def _eval_is_even(self):
+        if self.args[0].is_odd and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_rewrite_as_factorial(self, arg, **kwargs):
+        from sympy.concrete.summations import summation
+        i = Dummy('i')
+        f = S.NegativeOne**i / factorial(i)
+        return factorial(arg) * summation(f, (i, 0, arg))
+
+    def _eval_rewrite_as_gamma(self, arg, piecewise=True, **kwargs):
+        from sympy.functions.elementary.exponential import exp
+        from sympy.functions.special.gamma_functions import (gamma, lowergamma)
+        return (S.NegativeOne**(arg + 1)*exp(-I*pi*arg)*lowergamma(arg + 1, -1)
+                + gamma(arg + 1))*exp(-1)
+
+    def _eval_rewrite_as_uppergamma(self, arg, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return uppergamma(arg + 1, -1)/S.Exp1
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_odd(self):
+        if self.args[0].is_even and self.args[0].is_nonnegative:
+            return True
+
+
+class factorial2(CombinatorialFunction):
+    r"""The double factorial `n!!`, not to be confused with `(n!)!`
+
+    The double factorial is defined for nonnegative integers and for odd
+    negative integers as:
+
+    .. math:: n!! = \begin{cases} 1 & n = 0 \\
+                    n(n-2)(n-4) \cdots 1 & n\ \text{positive odd} \\
+                    n(n-2)(n-4) \cdots 2 & n\ \text{positive even} \\
+                    (n+2)!!/(n+2) & n\ \text{negative odd} \end{cases}
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Double_factorial
+
+    Examples
+    ========
+
+    >>> from sympy import factorial2, var
+    >>> n = var('n')
+    >>> n
+    n
+    >>> factorial2(n + 1)
+    factorial2(n + 1)
+    >>> factorial2(5)
+    15
+    >>> factorial2(-1)
+    1
+    >>> factorial2(-5)
+    1/3
+
+    See Also
+    ========
+
+    factorial, RisingFactorial, FallingFactorial
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        # TODO: extend this to complex numbers?
+
+        if arg.is_Number:
+            if not arg.is_Integer:
+                raise ValueError("argument must be nonnegative integer "
+                                    "or negative odd integer")
+
+            # This implementation is faster than the recursive one
+            # It also avoids "maximum recursion depth exceeded" runtime error
+            if arg.is_nonnegative:
+                if arg.is_even:
+                    k = arg / 2
+                    return 2**k * factorial(k)
+                return factorial(arg) / factorial2(arg - 1)
+
+
+            if arg.is_odd:
+                return arg*(S.NegativeOne)**((1 - arg)/2) / factorial2(-arg)
+            raise ValueError("argument must be nonnegative integer "
+                                "or negative odd integer")
+
+
+    def _eval_is_even(self):
+        # Double factorial is even for every positive even input
+        n = self.args[0]
+        if n.is_integer:
+            if n.is_odd:
+                return False
+            if n.is_even:
+                if n.is_positive:
+                    return True
+                if n.is_zero:
+                    return False
+
+    def _eval_is_integer(self):
+        # Double factorial is an integer for every nonnegative input, and for
+        # -1 and -3
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return (n + 3).is_nonnegative
+
+    def _eval_is_odd(self):
+        # Double factorial is odd for every odd input not smaller than -3, and
+        # for 0
+        n = self.args[0]
+        if n.is_odd:
+            return (n + 3).is_nonnegative
+        if n.is_even:
+            if n.is_positive:
+                return False
+            if n.is_zero:
+                return True
+
+    def _eval_is_positive(self):
+        # Double factorial is positive for every nonnegative input, and for
+        # every odd negative input which is of the form -1-4k for an
+        # nonnegative integer k
+        n = self.args[0]
+        if n.is_integer:
+            if (n + 1).is_nonnegative:
+                return True
+            if n.is_odd:
+                return ((n + 1) / 2).is_even
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        return 2**(n/2)*gamma(n/2 + 1) * Piecewise((1, Eq(Mod(n, 2), 0)),
+                (sqrt(2/pi), Eq(Mod(n, 2), 1)))
+
+
+###############################################################################
+######################## RISING and FALLING FACTORIALS ########################
+###############################################################################
+
+
+class RisingFactorial(CombinatorialFunction):
+    r"""
+    Rising factorial (also called Pochhammer symbol [1]_) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by:
+
+    .. math:: \texttt{rf(y, k)} = (x)^k = x \cdot (x+1) \cdots (x+k-1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or visit https://mathworld.wolfram.com/RisingFactorial.html page.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with a single variable,
+    `(x)^k = x(y) \cdot x(y+1) \cdots x(y+k-1)`, where `y` is the
+    variable of `x`. This is as described in [2]_.
+
+    Examples
+    ========
+
+    >>> from sympy import rf, Poly
+    >>> from sympy.abc import x
+    >>> rf(x, 0)
+    1
+    >>> rf(1, 5)
+    120
+    >>> rf(x, 5) == x*(1 + x)*(2 + x)*(3 + x)*(4 + x)
+    True
+    >>> rf(Poly(x**3, x), 2)
+    Poly(x**6 + 3*x**5 + 3*x**4 + x**3, x, domain='ZZ')
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but rising factorial can
+    be rewritten in terms of gamma, factorial, binomial,
+    and falling factorial.
+
+    >>> from sympy import Symbol, factorial, ff, binomial, gamma
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> R = rf(n, n + 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  R.rewrite(i)
+    ...
+    RisingFactorial(n, n + 2)
+    FallingFactorial(2*n + 1, n + 2)
+    factorial(2*n + 1)/factorial(n - 1)
+    binomial(2*n + 1, n + 2)*factorial(n + 2)
+    gamma(2*n + 2)/gamma(n)
+
+    See Also
+    ========
+
+    factorial, factorial2, FallingFactorial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Pochhammer_symbol
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif x is S.One:
+            return factorial(k)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x + i),
+                                          range(int(k)), 1)
+
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(-i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i:
+                                            r*(x - i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+        if k.is_integer == False:
+            if x.is_integer and x.is_negative:
+                return S.Zero
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x <= 0) == True:
+                return S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1)
+            return gamma(x + k) / gamma(x)
+        return Piecewise(
+            (gamma(x + k) / gamma(x), x > 0),
+            (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1), True))
+
+    def _eval_rewrite_as_FallingFactorial(self, x, k, **kwargs):
+        return FallingFactorial(x + k - 1, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(k + x - 1)/factorial(x - 1), x > 0),
+                (S.NegativeOne**k*factorial(-x)/factorial(-k - x), True))
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x + k - 1, k)
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (gamma(x + k).rewrite('tractable', deep=True) / gamma(x))
+            elif k_lim is S.NegativeInfinity:
+                return (S.NegativeOne**k*gamma(1 - x) / gamma(-k - x + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+class FallingFactorial(CombinatorialFunction):
+    r"""
+    Falling factorial (related to rising factorial) is a double valued
+    function arising in concrete mathematics, hypergeometric functions
+    and series expansions. It is defined by
+
+    .. math:: \texttt{ff(x, k)} = (x)_k = x \cdot (x-1) \cdots (x-k+1)
+
+    where `x` can be arbitrary expression and `k` is an integer. For
+    more information check "Concrete mathematics" by Graham, pp. 66
+    or [1]_.
+
+    When `x` is a `~.Poly` instance of degree $\ge 1$ with single variable,
+    `(x)_k = x(y) \cdot x(y-1) \cdots x(y-k+1)`, where `y` is the
+    variable of `x`. This is as described in
+
+    >>> from sympy import ff, Poly, Symbol
+    >>> from sympy.abc import x
+    >>> n = Symbol('n', integer=True)
+
+    >>> ff(x, 0)
+    1
+    >>> ff(5, 5)
+    120
+    >>> ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+    True
+    >>> ff(Poly(x**2, x), 2)
+    Poly(x**4 - 2*x**3 + x**2, x, domain='ZZ')
+    >>> ff(n, n)
+    factorial(n)
+
+    Rewriting is complicated unless the relationship between
+    the arguments is known, but falling factorial can
+    be rewritten in terms of gamma, factorial and binomial
+    and rising factorial.
+
+    >>> from sympy import factorial, rf, gamma, binomial, Symbol
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> F = ff(n, n - 2)
+    >>> for i in (rf, ff, factorial, binomial, gamma):
+    ...  F.rewrite(i)
+    ...
+    RisingFactorial(3, n - 2)
+    FallingFactorial(n, n - 2)
+    factorial(n)/2
+    binomial(n, n - 2)*factorial(n - 2)
+    gamma(n + 1)/2
+
+    See Also
+    ========
+
+    factorial, factorial2, RisingFactorial
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/FallingFactorial.html
+    .. [2] Peter Paule, "Greatest Factorial Factorization and Symbolic
+           Summation", Journal of Symbolic Computation, vol. 20, pp. 235-268,
+           1995.
+
+    """
+
+    @classmethod
+    def eval(cls, x, k):
+        x = sympify(x)
+        k = sympify(k)
+
+        if x is S.NaN or k is S.NaN:
+            return S.NaN
+        elif k.is_integer and x == k:
+            return factorial(x)
+        elif k.is_Integer:
+            if k.is_zero:
+                return S.One
+            else:
+                if k.is_positive:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        if k.is_odd:
+                            return S.NegativeInfinity
+                        else:
+                            return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("ff only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return reduce(lambda r, i:
+                                              r*(x.shift(-i)),
+                                              range(int(k)), 1)
+                        else:
+                            return reduce(lambda r, i: r*(x - i),
+                                          range(int(k)), 1)
+                else:
+                    if x is S.Infinity:
+                        return S.Infinity
+                    elif x is S.NegativeInfinity:
+                        return S.Infinity
+                    else:
+                        if isinstance(x, Poly):
+                            gens = x.gens
+                            if len(gens)!= 1:
+                                raise ValueError("rf only defined for "
+                                            "polynomials on one generator")
+                            else:
+                                return 1/reduce(lambda r, i:
+                                                r*(x.shift(i)),
+                                                range(1, abs(int(k)) + 1), 1)
+                        else:
+                            return 1/reduce(lambda r, i: r*(x + i),
+                                            range(1, abs(int(k)) + 1), 1)
+
+    def _eval_rewrite_as_gamma(self, x, k, piecewise=True, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        from sympy.functions.special.gamma_functions import gamma
+        if not piecewise:
+            if (x < 0) == True:
+                return S.NegativeOne**k*gamma(k - x) / gamma(-x)
+            return gamma(x + 1) / gamma(x - k + 1)
+        return Piecewise(
+            (gamma(x + 1) / gamma(x - k + 1), x >= 0),
+            (S.NegativeOne**k*gamma(k - x) / gamma(-x), True))
+
+    def _eval_rewrite_as_RisingFactorial(self, x, k, **kwargs):
+        return rf(x - k + 1, k)
+
+    def _eval_rewrite_as_binomial(self, x, k, **kwargs):
+        if k.is_integer:
+            return factorial(k) * binomial(x, k)
+
+    def _eval_rewrite_as_factorial(self, x, k, **kwargs):
+        from sympy.functions.elementary.piecewise import Piecewise
+        if x.is_integer and k.is_integer:
+            return Piecewise(
+                (factorial(x)/factorial(-k + x), x >= 0),
+                (S.NegativeOne**k*factorial(k - x - 1)/factorial(-x - 1), True))
+
+    def _eval_rewrite_as_tractable(self, x, k, limitvar=None, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        if limitvar:
+            k_lim = k.subs(limitvar, S.Infinity)
+            if k_lim is S.Infinity:
+                return (S.NegativeOne**k*gamma(k - x).rewrite('tractable', deep=True) / gamma(-x))
+            elif k_lim is S.NegativeInfinity:
+                return (gamma(x + 1) / gamma(x - k + 1).rewrite('tractable', deep=True))
+        return self.rewrite(gamma).rewrite('tractable', deep=True)
+
+    def _eval_is_integer(self):
+        return fuzzy_and((self.args[0].is_integer, self.args[1].is_integer,
+                          self.args[1].is_nonnegative))
+
+
+rf = RisingFactorial
+ff = FallingFactorial
+
+###############################################################################
+########################### BINOMIAL COEFFICIENTS #############################
+###############################################################################
+
+
+class binomial(CombinatorialFunction):
+    r"""Implementation of the binomial coefficient. It can be defined
+    in two ways depending on its desired interpretation:
+
+    .. math:: \binom{n}{k} = \frac{n!}{k!(n-k)!}\ \text{or}\
+                \binom{n}{k} = \frac{(n)_k}{k!}
+
+    First, in a strict combinatorial sense it defines the
+    number of ways we can choose `k` elements from a set of
+    `n` elements. In this case both arguments are nonnegative
+    integers and binomial is computed using an efficient
+    algorithm based on prime factorization.
+
+    The other definition is generalization for arbitrary `n`,
+    however `k` must also be nonnegative. This case is very
+    useful when evaluating summations.
+
+    For the sake of convenience, for negative integer `k` this function
+    will return zero no matter the other argument.
+
+    To expand the binomial when `n` is a symbol, use either
+    ``expand_func()`` or ``expand(func=True)``. The former will keep
+    the polynomial in factored form while the latter will expand the
+    polynomial itself. See examples for details.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, Rational, binomial, expand_func
+    >>> n = Symbol('n', integer=True, positive=True)
+
+    >>> binomial(15, 8)
+    6435
+
+    >>> binomial(n, -1)
+    0
+
+    Rows of Pascal's triangle can be generated with the binomial function:
+
+    >>> for N in range(8):
+    ...     print([binomial(N, i) for i in range(N + 1)])
+    ...
+    [1]
+    [1, 1]
+    [1, 2, 1]
+    [1, 3, 3, 1]
+    [1, 4, 6, 4, 1]
+    [1, 5, 10, 10, 5, 1]
+    [1, 6, 15, 20, 15, 6, 1]
+    [1, 7, 21, 35, 35, 21, 7, 1]
+
+    As can a given diagonal, e.g. the 4th diagonal:
+
+    >>> N = -4
+    >>> [binomial(N, i) for i in range(1 - N)]
+    [1, -4, 10, -20, 35]
+
+    >>> binomial(Rational(5, 4), 3)
+    -5/128
+    >>> binomial(Rational(-5, 4), 3)
+    -195/128
+
+    >>> binomial(n, 3)
+    binomial(n, 3)
+
+    >>> binomial(n, 3).expand(func=True)
+    n**3/6 - n**2/2 + n/3
+
+    >>> expand_func(binomial(n, 3))
+    n*(n - 2)*(n - 1)/6
+
+    In many cases, we can also compute binomial coefficients modulo a
+    prime p quickly using Lucas' Theorem [2]_, though we need to include
+    `evaluate=False` to postpone evaluation:
+
+    >>> from sympy import Mod
+    >>> Mod(binomial(156675, 4433, evaluate=False), 10**5 + 3)
+    28625
+
+    Using a generalisation of Lucas's Theorem given by Granville [3]_,
+    we can extend this to arbitrary n:
+
+    >>> Mod(binomial(10**18, 10**12, evaluate=False), (10**5 + 3)**2)
+    3744312326
+
+    References
+    ==========
+
+    .. [1] https://www.johndcook.com/blog/binomial_coefficients/
+    .. [2] https://en.wikipedia.org/wiki/Lucas%27s_theorem
+    .. [3] Binomial coefficients modulo prime powers, Andrew Granville,
+        Available: https://web.archive.org/web/20170202003812/http://www.dms.umontreal.ca/~andrew/PDF/BinCoeff.pdf
+    """
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.gamma_functions import polygamma
+        if argindex == 1:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/01/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n + 1) - \
+                polygamma(0, n - k + 1))
+        elif argindex == 2:
+            # https://functions.wolfram.com/GammaBetaErf/Binomial/20/01/02/
+            n, k = self.args
+            return binomial(n, k)*(polygamma(0, n - k + 1) - \
+                polygamma(0, k + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def _eval(self, n, k):
+        # n.is_Number and k.is_Integer and k != 1 and n != k
+
+        if k.is_Integer:
+            if n.is_Integer and n >= 0:
+                n, k = int(n), int(k)
+
+                if k > n:
+                    return S.Zero
+                elif k > n // 2:
+                    k = n - k
+
+                # XXX: This conditional logic should be moved to
+                # sympy.external.gmpy and the pure Python version of bincoef
+                # should be moved to sympy.external.ntheory.
+                if _gmpy is not None:
+                    return Integer(_gmpy.bincoef(n, k))
+
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result = result * d // i
+                return Integer(result)
+            else:
+                d, result = n - k, 1
+                for i in range(1, k + 1):
+                    d += 1
+                    result *= d
+                return result / _factorial(k)
+
+    @classmethod
+    def eval(cls, n, k):
+        n, k = map(sympify, (n, k))
+        d = n - k
+        n_nonneg, n_isint = n.is_nonnegative, n.is_integer
+        if k.is_zero or ((n_nonneg or n_isint is False)
+                and d.is_zero):
+            return S.One
+        if (k - 1).is_zero or ((n_nonneg or n_isint is False)
+                and (d - 1).is_zero):
+            return n
+        if k.is_integer:
+            if k.is_negative or (n_nonneg and n_isint and d.is_negative):
+                return S.Zero
+            elif n.is_number:
+                res = cls._eval(n, k)
+                return res.expand(basic=True) if res else res
+        elif n_nonneg is False and n_isint:
+            # a special case when binomial evaluates to complex infinity
+            return S.ComplexInfinity
+        elif k.is_number:
+            from sympy.functions.special.gamma_functions import gamma
+            return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_Mod(self, q):
+        n, k = self.args
+
+        if any(x.is_integer is False for x in (n, k, q)):
+            raise ValueError("Integers expected for binomial Mod")
+
+        if all(x.is_Integer for x in (n, k, q)):
+            n, k = map(int, (n, k))
+            aq, res = abs(q), 1
+
+            # handle negative integers k or n
+            if k < 0:
+                return S.Zero
+            if n < 0:
+                n = -n + k - 1
+                res = -1 if k%2 else 1
+
+            # non negative integers k and n
+            if k > n:
+                return S.Zero
+
+            isprime = aq.is_prime
+            aq = int(aq)
+            if isprime:
+                if aq < n:
+                    # use Lucas Theorem
+                    N, K = n, k
+                    while N or K:
+                        res = res*binomial(N % aq, K % aq) % aq
+                        N, K = N // aq, K // aq
+
+                else:
+                    # use Factorial Modulo
+                    d = n - k
+                    if k > d:
+                        k, d = d, k
+                    kf = 1
+                    for i in range(2, k + 1):
+                        kf = kf*i % aq
+                    df = kf
+                    for i in range(k + 1, d + 1):
+                        df = df*i % aq
+                    res *= df
+                    for i in range(d + 1, n + 1):
+                        res = res*i % aq
+
+                    res *= pow(kf*df % aq, aq - 2, aq)
+                    res %= aq
+
+            elif _sqrt(q) < k and q != 1:
+                res = binomial_mod(n, k, q)
+
+            else:
+                # Binomial Factorization is performed by calculating the
+                # exponents of primes <= n in `n! /(k! (n - k)!)`,
+                # for non-negative integers n and k. As the exponent of
+                # prime in n! is e_p(n) = [n/p] + [n/p**2] + ...
+                # the exponent of prime in binomial(n, k) would be
+                # e_p(n) - e_p(k) - e_p(n - k)
+                M = int(_sqrt(n))
+                for prime in sieve.primerange(2, n + 1):
+                    if prime > n - k:
+                        res = res*prime % aq
+                    elif prime > n // 2:
+                        continue
+                    elif prime > M:
+                        if n % prime < k % prime:
+                            res = res*prime % aq
+                    else:
+                        N, K = n, k
+                        exp = a = 0
+
+                        while N > 0:
+                            a = int((N % prime) < (K % prime + a))
+                            N, K = N // prime, K // prime
+                            exp += a
+
+                        if exp > 0:
+                            res *= pow(prime, exp, aq)
+                            res %= aq
+
+            return S(res % q)
+
+    def _eval_expand_func(self, **hints):
+        """
+        Function to expand binomial(n, k) when m is positive integer
+        Also,
+        n is self.args[0] and k is self.args[1] while using binomial(n, k)
+        """
+        n = self.args[0]
+        if n.is_Number:
+            return binomial(*self.args)
+
+        k = self.args[1]
+        if (n-k).is_Integer:
+            k = n - k
+
+        if k.is_Integer:
+            if k.is_zero:
+                return S.One
+            elif k.is_negative:
+                return S.Zero
+            else:
+                n, result = self.args[0], 1
+                for i in range(1, k + 1):
+                    result *= n - k + i
+                return result / _factorial(k)
+        else:
+            return binomial(*self.args)
+
+    def _eval_rewrite_as_factorial(self, n, k, **kwargs):
+        return factorial(n)/(factorial(k)*factorial(n - k))
+
+    def _eval_rewrite_as_gamma(self, n, k, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+
+    def _eval_rewrite_as_tractable(self, n, k, limitvar=None, **kwargs):
+        return self._eval_rewrite_as_gamma(n, k).rewrite('tractable')
+
+    def _eval_rewrite_as_FallingFactorial(self, n, k, **kwargs):
+        if k.is_integer:
+            return ff(n, k) / factorial(k)
+
+    def _eval_is_integer(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            return True
+        elif k.is_integer is False:
+            return False
+
+    def _eval_is_nonnegative(self):
+        n, k = self.args
+        if n.is_integer and k.is_integer:
+            if n.is_nonnegative or k.is_negative or k.is_even:
+                return True
+            elif k.is_even is False:
+                return  False
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.functions.special.gamma_functions import gamma
+        return self.rewrite(gamma)._eval_as_leading_term(x, logx=logx, cdir=cdir)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/numbers.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0dfc518d4a6784712341edaa5731145469a8d1e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/numbers.py
@@ -0,0 +1,3196 @@
+"""
+This module implements some special functions that commonly appear in
+combinatorial contexts (e.g. in power series); in particular,
+sequences of rational numbers such as Bernoulli and Fibonacci numbers.
+
+Factorials, binomial coefficients and related functions are located in
+the separate 'factorials' module.
+"""
+from __future__ import annotations
+from math import prod
+from collections import defaultdict
+from typing import Callable
+
+from sympy.core import S, Symbol, Add, Dummy
+from sympy.core.cache import cacheit
+from sympy.core.containers import Dict
+from sympy.core.expr import Expr
+from sympy.core.function import ArgumentIndexError, DefinedFunction, expand_mul
+from sympy.core.logic import fuzzy_not
+from sympy.core.mul import Mul
+from sympy.core.numbers import E, I, pi, oo, Rational, Integer
+from sympy.core.relational import Eq, is_le, is_gt, is_lt
+from sympy.external.gmpy import SYMPY_INTS, remove, lcm, legendre, jacobi, kronecker
+from sympy.functions.combinatorial.factorials import (binomial,
+    factorial, subfactorial)
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.ntheory.factor_ import (factorint, _divisor_sigma, is_carmichael,
+                                   find_carmichael_numbers_in_range, find_first_n_carmichaels)
+from sympy.ntheory.generate import _primepi
+from sympy.ntheory.partitions_ import _partition, _partition_rec
+from sympy.ntheory.primetest import isprime, is_square
+from sympy.polys.appellseqs import bernoulli_poly, euler_poly, genocchi_poly
+from sympy.polys.polytools import cancel
+from sympy.utilities.enumerative import MultisetPartitionTraverser
+from sympy.utilities.exceptions import sympy_deprecation_warning
+from sympy.utilities.iterables import multiset, multiset_derangements, iterable
+from sympy.utilities.memoization import recurrence_memo
+from sympy.utilities.misc import as_int
+
+from mpmath import mp, workprec
+from mpmath.libmp import ifib as _ifib
+
+
+def _product(a, b):
+    return prod(range(a, b + 1))
+
+
+# Dummy symbol used for computing polynomial sequences
+_sym = Symbol('x')
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Carmichael numbers                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+class carmichael(DefinedFunction):
+    r"""
+    Carmichael Numbers:
+
+    Certain cryptographic algorithms make use of big prime numbers.
+    However, checking whether a big number is prime is not so easy.
+    Randomized prime number checking tests exist that offer a high degree of
+    confidence of accurate determination at low cost, such as the Fermat test.
+
+    Let 'a' be a random number between $2$ and $n - 1$, where $n$ is the
+    number whose primality we are testing. Then, $n$ is probably prime if it
+    satisfies the modular arithmetic congruence relation:
+
+    .. math :: a^{n-1} = 1 \pmod{n}
+
+    (where mod refers to the modulo operation)
+
+    If a number passes the Fermat test several times, then it is prime with a
+    high probability.
+
+    Unfortunately, certain composite numbers (non-primes) still pass the Fermat
+    test with every number smaller than themselves.
+    These numbers are called Carmichael numbers.
+
+    A Carmichael number will pass a Fermat primality test to every base $b$
+    relatively prime to the number, even though it is not actually prime.
+    This makes tests based on Fermat's Little Theorem less effective than
+    strong probable prime tests such as the Baillie-PSW primality test and
+    the Miller-Rabin primality test.
+
+    Examples
+    ========
+
+    >>> from sympy.ntheory.factor_ import find_first_n_carmichaels, find_carmichael_numbers_in_range
+    >>> find_first_n_carmichaels(5)
+    [561, 1105, 1729, 2465, 2821]
+    >>> find_carmichael_numbers_in_range(0, 562)
+    [561]
+    >>> find_carmichael_numbers_in_range(0,1000)
+    [561]
+    >>> find_carmichael_numbers_in_range(0,2000)
+    [561, 1105, 1729]
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Carmichael_number
+    .. [2] https://en.wikipedia.org/wiki/Fermat_primality_test
+    .. [3] https://www.jstor.org/stable/23248683?seq=1#metadata_info_tab_contents
+    """
+
+    @staticmethod
+    def is_perfect_square(n):
+        sympy_deprecation_warning(
+        """
+is_perfect_square is just a wrapper around sympy.ntheory.primetest.is_square
+so use that directly instead.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return is_square(n)
+
+    @staticmethod
+    def divides(p, n):
+        sympy_deprecation_warning(
+        """
+        divides can be replaced by directly testing n % p == 0.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return n % p == 0
+
+    @staticmethod
+    def is_prime(n):
+        sympy_deprecation_warning(
+        """
+is_prime is just a wrapper around sympy.ntheory.primetest.isprime so use that
+directly instead.
+        """,
+        deprecated_since_version="1.11",
+        active_deprecations_target='deprecated-carmichael-static-methods',
+        )
+        return isprime(n)
+
+    @staticmethod
+    def is_carmichael(n):
+        sympy_deprecation_warning(
+        """
+is_carmichael is just a wrapper around sympy.ntheory.factor_.is_carmichael so use that
+directly instead.
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target='deprecated-ntheory-symbolic-functions',
+        )
+        return is_carmichael(n)
+
+    @staticmethod
+    def find_carmichael_numbers_in_range(x, y):
+        sympy_deprecation_warning(
+        """
+find_carmichael_numbers_in_range is just a wrapper around sympy.ntheory.factor_.find_carmichael_numbers_in_range so use that
+directly instead.
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target='deprecated-ntheory-symbolic-functions',
+        )
+        return find_carmichael_numbers_in_range(x, y)
+
+    @staticmethod
+    def find_first_n_carmichaels(n):
+        sympy_deprecation_warning(
+        """
+find_first_n_carmichaels is just a wrapper around sympy.ntheory.factor_.find_first_n_carmichaels so use that
+directly instead.
+        """,
+        deprecated_since_version="1.13",
+        active_deprecations_target='deprecated-ntheory-symbolic-functions',
+        )
+        return find_first_n_carmichaels(n)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Fibonacci numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class fibonacci(DefinedFunction):
+    r"""
+    Fibonacci numbers / Fibonacci polynomials
+
+    The Fibonacci numbers are the integer sequence defined by the
+    initial terms `F_0 = 0`, `F_1 = 1` and the two-term recurrence
+    relation `F_n = F_{n-1} + F_{n-2}`.  This definition
+    extended to arbitrary real and complex arguments using
+    the formula
+
+    .. math :: F_z = \frac{\phi^z - \cos(\pi z) \phi^{-z}}{\sqrt 5}
+
+    The Fibonacci polynomials are defined by `F_1(x) = 1`,
+    `F_2(x) = x`, and `F_n(x) = x*F_{n-1}(x) + F_{n-2}(x)` for `n > 2`.
+    For all positive integers `n`, `F_n(1) = F_n`.
+
+    * ``fibonacci(n)`` gives the `n^{th}` Fibonacci number, `F_n`
+    * ``fibonacci(n, x)`` gives the `n^{th}` Fibonacci polynomial in `x`, `F_n(x)`
+
+    Examples
+    ========
+
+    >>> from sympy import fibonacci, Symbol
+
+    >>> [fibonacci(x) for x in range(11)]
+    [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+    >>> fibonacci(5, Symbol('t'))
+    t**4 + 3*t**2 + 1
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, harmonic, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fibonacci_number
+    .. [2] https://mathworld.wolfram.com/FibonacciNumber.html
+
+    """
+
+    @staticmethod
+    def _fib(n):
+        return _ifib(n)
+
+    @staticmethod
+    @recurrence_memo([None, S.One, _sym])
+    def _fibpoly(n, prev):
+        return (prev[-2] + _sym*prev[-1]).expand()
+
+    @classmethod
+    def eval(cls, n, sym=None):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            if sym is None:
+                n = int(n)
+                if n < 0:
+                    return S.NegativeOne**(n + 1) * fibonacci(-n)
+                else:
+                    return Integer(cls._fib(n))
+            else:
+                if n < 1:
+                    raise ValueError("Fibonacci polynomials are defined "
+                       "only for positive integer indices.")
+                return cls._fibpoly(n).subs(_sym, sym)
+
+    def _eval_rewrite_as_tractable(self, n, **kwargs):
+        from sympy.functions import sqrt, cos
+        return (S.GoldenRatio**n - cos(S.Pi*n)/S.GoldenRatio**n)/sqrt(5)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        return 2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+
+    def _eval_rewrite_as_GoldenRatio(self,n, **kwargs):
+        return (S.GoldenRatio**n - 1/(-S.GoldenRatio)**n)/(2*S.GoldenRatio-1)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                               Lucas numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class lucas(DefinedFunction):
+    """
+    Lucas numbers
+
+    Lucas numbers satisfy a recurrence relation similar to that of
+    the Fibonacci sequence, in which each term is the sum of the
+    preceding two. They are generated by choosing the initial
+    values `L_0 = 2` and `L_1 = 1`.
+
+    * ``lucas(n)`` gives the `n^{th}` Lucas number
+
+    Examples
+    ========
+
+    >>> from sympy import lucas
+
+    >>> [lucas(x) for x in range(11)]
+    [2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123]
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lucas_number
+    .. [2] https://mathworld.wolfram.com/LucasNumber.html
+
+    """
+
+    @classmethod
+    def eval(cls, n):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            return fibonacci(n + 1) + fibonacci(n - 1)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+        from sympy.functions.elementary.miscellaneous import sqrt
+        return 2**(-n)*((1 + sqrt(5))**n + (-sqrt(5) + 1)**n)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                             Tribonacci numbers                             #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class tribonacci(DefinedFunction):
+    r"""
+    Tribonacci numbers / Tribonacci polynomials
+
+    The Tribonacci numbers are the integer sequence defined by the
+    initial terms `T_0 = 0`, `T_1 = 1`, `T_2 = 1` and the three-term
+    recurrence relation `T_n = T_{n-1} + T_{n-2} + T_{n-3}`.
+
+    The Tribonacci polynomials are defined by `T_0(x) = 0`, `T_1(x) = 1`,
+    `T_2(x) = x^2`, and `T_n(x) = x^2 T_{n-1}(x) + x T_{n-2}(x) + T_{n-3}(x)`
+    for `n > 2`.  For all positive integers `n`, `T_n(1) = T_n`.
+
+    * ``tribonacci(n)`` gives the `n^{th}` Tribonacci number, `T_n`
+    * ``tribonacci(n, x)`` gives the `n^{th}` Tribonacci polynomial in `x`, `T_n(x)`
+
+    Examples
+    ========
+
+    >>> from sympy import tribonacci, Symbol
+
+    >>> [tribonacci(x) for x in range(11)]
+    [0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149]
+    >>> tribonacci(5, Symbol('t'))
+    t**8 + 3*t**5 + 3*t**2
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Generalizations_of_Fibonacci_numbers#Tribonacci_numbers
+    .. [2] https://mathworld.wolfram.com/TribonacciNumber.html
+    .. [3] https://oeis.org/A000073
+
+    """
+
+    @staticmethod
+    @recurrence_memo([S.Zero, S.One, S.One])
+    def _trib(n, prev):
+        return (prev[-3] + prev[-2] + prev[-1])
+
+    @staticmethod
+    @recurrence_memo([S.Zero, S.One, _sym**2])
+    def _tribpoly(n, prev):
+        return (prev[-3] + _sym*prev[-2] + _sym**2*prev[-1]).expand()
+
+    @classmethod
+    def eval(cls, n, sym=None):
+        if n is S.Infinity:
+            return S.Infinity
+
+        if n.is_Integer:
+            n = int(n)
+            if n < 0:
+                raise ValueError("Tribonacci polynomials are defined "
+                       "only for non-negative integer indices.")
+            if sym is None:
+                return Integer(cls._trib(n))
+            else:
+                return cls._tribpoly(n).subs(_sym, sym)
+
+    def _eval_rewrite_as_sqrt(self, n, **kwargs):
+        from sympy.functions.elementary.miscellaneous import cbrt, sqrt
+        w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+        a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+        b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+        c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+        Tn = (a**(n + 1)/((a - b)*(a - c))
+            + b**(n + 1)/((b - a)*(b - c))
+            + c**(n + 1)/((c - a)*(c - b)))
+        return Tn
+
+    def _eval_rewrite_as_TribonacciConstant(self, n, **kwargs):
+        from sympy.functions.elementary.integers import floor
+        from sympy.functions.elementary.miscellaneous import cbrt, sqrt
+        b = cbrt(586 + 102*sqrt(33))
+        Tn = 3 * b * S.TribonacciConstant**n / (b**2 - 2*b + 4)
+        return floor(Tn + S.Half)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Bernoulli numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class bernoulli(DefinedFunction):
+    r"""
+    Bernoulli numbers / Bernoulli polynomials / Bernoulli function
+
+    The Bernoulli numbers are a sequence of rational numbers
+    defined by `B_0 = 1` and the recursive relation (`n > 0`):
+
+    .. math :: n+1 = \sum_{k=0}^n \binom{n+1}{k} B_k
+
+    They are also commonly defined by their exponential generating
+    function, which is `\frac{x}{1 - e^{-x}}`. For odd indices > 1,
+    the Bernoulli numbers are zero.
+
+    The Bernoulli polynomials satisfy the analogous formula:
+
+    .. math :: B_n(x) = \sum_{k=0}^n (-1)^k \binom{n}{k} B_k x^{n-k}
+
+    Bernoulli numbers and Bernoulli polynomials are related as
+    `B_n(1) = B_n`.
+
+    The generalized Bernoulli function `\operatorname{B}(s, a)`
+    is defined for any complex `s` and `a`, except where `a` is a
+    nonpositive integer and `s` is not a nonnegative integer. It is
+    an entire function of `s` for fixed `a`, related to the Hurwitz
+    zeta function by
+
+    .. math:: \operatorname{B}(s, a) = \begin{cases}
+              -s \zeta(1-s, a) & s \ne 0 \\ 1 & s = 0 \end{cases}
+
+    When `s` is a nonnegative integer this function reduces to the
+    Bernoulli polynomials: `\operatorname{B}(n, x) = B_n(x)`. When
+    `a` is omitted it is assumed to be 1, yielding the (ordinary)
+    Bernoulli function which interpolates the Bernoulli numbers and is
+    related to the Riemann zeta function.
+
+    We compute Bernoulli numbers using Ramanujan's formula:
+
+    .. math :: B_n = \frac{A(n) - S(n)}{\binom{n+3}{n}}
+
+    where:
+
+    .. math :: A(n) = \begin{cases} \frac{n+3}{3} &
+        n \equiv 0\ \text{or}\ 2 \pmod{6} \\
+        -\frac{n+3}{6} & n \equiv 4 \pmod{6} \end{cases}
+
+    and:
+
+    .. math :: S(n) = \sum_{k=1}^{[n/6]} \binom{n+3}{n-6k} B_{n-6k}
+
+    This formula is similar to the sum given in the definition, but
+    cuts `\frac{2}{3}` of the terms. For Bernoulli polynomials, we use
+    Appell sequences.
+
+    For `n` a nonnegative integer and `s`, `a`, `x` arbitrary complex numbers,
+
+    * ``bernoulli(n)`` gives the nth Bernoulli number, `B_n`
+    * ``bernoulli(s)`` gives the Bernoulli function `\operatorname{B}(s)`
+    * ``bernoulli(n, x)`` gives the nth Bernoulli polynomial in `x`, `B_n(x)`
+    * ``bernoulli(s, a)`` gives the generalized Bernoulli function
+      `\operatorname{B}(s, a)`
+
+    .. versionchanged:: 1.12
+        ``bernoulli(1)`` gives `+\frac{1}{2}` instead of `-\frac{1}{2}`.
+        This choice of value confers several theoretical advantages [5]_,
+        including the extension to complex parameters described above
+        which this function now implements. The previous behavior, defined
+        only for nonnegative integers `n`, can be obtained with
+        ``(-1)**n*bernoulli(n)``.
+
+    Examples
+    ========
+
+    >>> from sympy import bernoulli
+    >>> from sympy.abc import x
+    >>> [bernoulli(n) for n in range(11)]
+    [1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66]
+    >>> bernoulli(1000001)
+    0
+    >>> bernoulli(3, x)
+    x**3 - 3*x**2/2 + x/2
+
+    See Also
+    ========
+
+    andre, bell, catalan, euler, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.polys.appellseqs.bernoulli_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bernoulli_number
+    .. [2] https://en.wikipedia.org/wiki/Bernoulli_polynomial
+    .. [3] https://mathworld.wolfram.com/BernoulliNumber.html
+    .. [4] https://mathworld.wolfram.com/BernoulliPolynomial.html
+    .. [5] Peter Luschny, "The Bernoulli Manifesto",
+           https://luschny.de/math/zeta/The-Bernoulli-Manifesto.html
+    .. [6] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    args: tuple[Integer]
+
+    # Calculates B_n for positive even n
+    @staticmethod
+    def _calc_bernoulli(n):
+        s = 0
+        a = int(binomial(n + 3, n - 6))
+        for j in range(1, n//6 + 1):
+            s += a * bernoulli(n - 6*j)
+            # Avoid computing each binomial coefficient from scratch
+            a *= _product(n - 6 - 6*j + 1, n - 6*j)
+            a //= _product(6*j + 4, 6*j + 9)
+        if n % 6 == 4:
+            s = -Rational(n + 3, 6) - s
+        else:
+            s = Rational(n + 3, 3) - s
+        return s / binomial(n + 3, n)
+
+    # We implement a specialized memoization scheme to handle each
+    # case modulo 6 separately
+    _cache = {0: S.One, 1: Rational(1, 2), 2: Rational(1, 6), 4: Rational(-1, 30)}
+    _highest = {0: 0, 1: 1, 2: 2, 4: 4}
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if x is S.One:
+            return cls(n)
+        elif n.is_zero:
+            return S.One
+        elif n.is_integer is False or n.is_nonnegative is False:
+            if x is not None and x.is_Integer and x.is_nonpositive:
+                return S.NaN
+            return
+        # Bernoulli numbers
+        elif x is None:
+            if n is S.One:
+                return S.Half
+            elif n.is_odd and (n-1).is_positive:
+                return S.Zero
+            elif n.is_Number:
+                n = int(n)
+                # Use mpmath for enormous Bernoulli numbers
+                if n > 500:
+                    p, q = mp.bernfrac(n)
+                    return Rational(int(p), int(q))
+                case = n % 6
+                highest_cached = cls._highest[case]
+                if n <= highest_cached:
+                    return cls._cache[n]
+                # To avoid excessive recursion when, say, bernoulli(1000) is
+                # requested, calculate and cache the entire sequence ... B_988,
+                # B_994, B_1000 in increasing order
+                for i in range(highest_cached + 6, n + 6, 6):
+                    b = cls._calc_bernoulli(i)
+                    cls._cache[i] = b
+                    cls._highest[case] = i
+                return b
+        # Bernoulli polynomials
+        elif n.is_Number:
+            return bernoulli_poly(n, x)
+
+    def _eval_rewrite_as_zeta(self, n, x=1, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        return Piecewise((1, Eq(n, 0)), (-n * zeta(1-n, x), True))
+
+    def _eval_evalf(self, prec):
+        if not all(x.is_number for x in self.args):
+            return
+        n = self.args[0]._to_mpmath(prec)
+        x = (self.args[1] if len(self.args) > 1 else S.One)._to_mpmath(prec)
+        with workprec(prec):
+            if n == 0:
+                res = mp.mpf(1)
+            elif n == 1:
+                res = x - mp.mpf(0.5)
+            elif mp.isint(n) and n >= 0:
+                res = mp.bernoulli(n) if x == 1 else mp.bernpoly(n, x)
+            else:
+                res = -n * mp.zeta(1-n, x)
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                Bell numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class bell(DefinedFunction):
+    r"""
+    Bell numbers / Bell polynomials
+
+    The Bell numbers satisfy `B_0 = 1` and
+
+    .. math:: B_n = \sum_{k=0}^{n-1} \binom{n-1}{k} B_k.
+
+    They are also given by:
+
+    .. math:: B_n = \frac{1}{e} \sum_{k=0}^{\infty} \frac{k^n}{k!}.
+
+    The Bell polynomials are given by `B_0(x) = 1` and
+
+    .. math:: B_n(x) = x \sum_{k=1}^{n-1} \binom{n-1}{k-1} B_{k-1}(x).
+
+    The second kind of Bell polynomials (are sometimes called "partial" Bell
+    polynomials or incomplete Bell polynomials) are defined as
+
+    .. math:: B_{n,k}(x_1, x_2,\dotsc x_{n-k+1}) =
+            \sum_{j_1+j_2+j_2+\dotsb=k \atop j_1+2j_2+3j_2+\dotsb=n}
+                \frac{n!}{j_1!j_2!\dotsb j_{n-k+1}!}
+                \left(\frac{x_1}{1!} \right)^{j_1}
+                \left(\frac{x_2}{2!} \right)^{j_2} \dotsb
+                \left(\frac{x_{n-k+1}}{(n-k+1)!} \right) ^{j_{n-k+1}}.
+
+    * ``bell(n)`` gives the `n^{th}` Bell number, `B_n`.
+    * ``bell(n, x)`` gives the `n^{th}` Bell polynomial, `B_n(x)`.
+    * ``bell(n, k, (x1, x2, ...))`` gives Bell polynomials of the second kind,
+      `B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1})`.
+
+    Notes
+    =====
+
+    Not to be confused with Bernoulli numbers and Bernoulli polynomials,
+    which use the same notation.
+
+    Examples
+    ========
+
+    >>> from sympy import bell, Symbol, symbols
+
+    >>> [bell(n) for n in range(11)]
+    [1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]
+    >>> bell(30)
+    846749014511809332450147
+    >>> bell(4, Symbol('t'))
+    t**4 + 6*t**3 + 7*t**2 + t
+    >>> bell(6, 2, symbols('x:6')[1:])
+    6*x1*x5 + 15*x2*x4 + 10*x3**2
+
+    See Also
+    ========
+
+    bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Bell_number
+    .. [2] https://mathworld.wolfram.com/BellNumber.html
+    .. [3] https://mathworld.wolfram.com/BellPolynomial.html
+
+    """
+
+    @staticmethod
+    @recurrence_memo([1, 1])
+    def _bell(n, prev):
+        s = 1
+        a = 1
+        for k in range(1, n):
+            a = a * (n - k) // k
+            s += a * prev[k]
+        return s
+
+    @staticmethod
+    @recurrence_memo([S.One, _sym])
+    def _bell_poly(n, prev):
+        s = 1
+        a = 1
+        for k in range(2, n + 1):
+            a = a * (n - k + 1) // (k - 1)
+            s += a * prev[k - 1]
+        return expand_mul(_sym * s)
+
+    @staticmethod
+    def _bell_incomplete_poly(n, k, symbols):
+        r"""
+        The second kind of Bell polynomials (incomplete Bell polynomials).
+
+        Calculated by recurrence formula:
+
+        .. math:: B_{n,k}(x_1, x_2, \dotsc, x_{n-k+1}) =
+                \sum_{m=1}^{n-k+1}
+                \x_m \binom{n-1}{m-1} B_{n-m,k-1}(x_1, x_2, \dotsc, x_{n-m-k})
+
+        where
+            `B_{0,0} = 1;`
+            `B_{n,0} = 0; for n \ge 1`
+            `B_{0,k} = 0; for k \ge 1`
+
+        """
+        if (n == 0) and (k == 0):
+            return S.One
+        elif (n == 0) or (k == 0):
+            return S.Zero
+        s = S.Zero
+        a = S.One
+        for m in range(1, n - k + 2):
+            s += a * bell._bell_incomplete_poly(
+                n - m, k - 1, symbols) * symbols[m - 1]
+            a = a * (n - m) / m
+        return expand_mul(s)
+
+    @classmethod
+    def eval(cls, n, k_sym=None, symbols=None):
+        if n is S.Infinity:
+            if k_sym is None:
+                return S.Infinity
+            else:
+                raise ValueError("Bell polynomial is not defined")
+
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("a non-negative integer expected")
+
+        if n.is_Integer and n.is_nonnegative:
+            if k_sym is None:
+                return Integer(cls._bell(int(n)))
+            elif symbols is None:
+                return cls._bell_poly(int(n)).subs(_sym, k_sym)
+            else:
+                r = cls._bell_incomplete_poly(int(n), int(k_sym), symbols)
+                return r
+
+    def _eval_rewrite_as_Sum(self, n, k_sym=None, symbols=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        if (k_sym is not None) or (symbols is not None):
+            return self
+
+        # Dobinski's formula
+        if not n.is_nonnegative:
+            return self
+        k = Dummy('k', integer=True, nonnegative=True)
+        return 1 / E * Sum(k**n / factorial(k), (k, 0, S.Infinity))
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Harmonic numbers                              #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class harmonic(DefinedFunction):
+    r"""
+    Harmonic numbers
+
+    The nth harmonic number is given by `\operatorname{H}_{n} =
+    1 + \frac{1}{2} + \frac{1}{3} + \ldots + \frac{1}{n}`.
+
+    More generally:
+
+    .. math:: \operatorname{H}_{n,m} = \sum_{k=1}^{n} \frac{1}{k^m}
+
+    As `n \rightarrow \infty`, `\operatorname{H}_{n,m} \rightarrow \zeta(m)`,
+    the Riemann zeta function.
+
+    * ``harmonic(n)`` gives the nth harmonic number, `\operatorname{H}_n`
+
+    * ``harmonic(n, m)`` gives the nth generalized harmonic number
+      of order `m`, `\operatorname{H}_{n,m}`, where
+      ``harmonic(n) == harmonic(n, 1)``
+
+    This function can be extended to complex `n` and `m` where `n` is not a
+    negative integer or `m` is a nonpositive integer as
+
+    .. math:: \operatorname{H}_{n,m} = \begin{cases} \zeta(m) - \zeta(m, n+1)
+            & m \ne 1 \\ \psi(n+1) + \gamma & m = 1 \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy import harmonic, oo
+
+    >>> [harmonic(n) for n in range(6)]
+    [0, 1, 3/2, 11/6, 25/12, 137/60]
+    >>> [harmonic(n, 2) for n in range(6)]
+    [0, 1, 5/4, 49/36, 205/144, 5269/3600]
+    >>> harmonic(oo, 2)
+    pi**2/6
+
+    >>> from sympy import Symbol, Sum
+    >>> n = Symbol("n")
+
+    >>> harmonic(n).rewrite(Sum)
+    Sum(1/_k, (_k, 1, n))
+
+    We can evaluate harmonic numbers for all integral and positive
+    rational arguments:
+
+    >>> from sympy import S, expand_func, simplify
+    >>> harmonic(8)
+    761/280
+    >>> harmonic(11)
+    83711/27720
+
+    >>> H = harmonic(1/S(3))
+    >>> H
+    harmonic(1/3)
+    >>> He = expand_func(H)
+    >>> He
+    -log(6) - sqrt(3)*pi/6 + 2*Sum(log(sin(_k*pi/3))*cos(2*_k*pi/3), (_k, 1, 1))
+                           + 3*Sum(1/(3*_k + 1), (_k, 0, 0))
+    >>> He.doit()
+    -log(6) - sqrt(3)*pi/6 - log(sqrt(3)/2) + 3
+    >>> H = harmonic(25/S(7))
+    >>> He = simplify(expand_func(H).doit())
+    >>> He
+    log(sin(2*pi/7)**(2*cos(16*pi/7))/(14*sin(pi/7)**(2*cos(pi/7))*cos(pi/14)**(2*sin(pi/14)))) + pi*tan(pi/14)/2 + 30247/9900
+    >>> He.n(40)
+    1.983697455232980674869851942390639915940
+    >>> harmonic(25/S(7)).n(40)
+    1.983697455232980674869851942390639915940
+
+    We can rewrite harmonic numbers in terms of polygamma functions:
+
+    >>> from sympy import digamma, polygamma
+    >>> m = Symbol("m", integer=True, positive=True)
+
+    >>> harmonic(n).rewrite(digamma)
+    polygamma(0, n + 1) + EulerGamma
+
+    >>> harmonic(n).rewrite(polygamma)
+    polygamma(0, n + 1) + EulerGamma
+
+    >>> harmonic(n,3).rewrite(polygamma)
+    polygamma(2, n + 1)/2 + zeta(3)
+
+    >>> simplify(harmonic(n,m).rewrite(polygamma))
+    Piecewise((polygamma(0, n + 1) + EulerGamma, Eq(m, 1)),
+    (-(-1)**m*polygamma(m - 1, n + 1)/factorial(m - 1) + zeta(m), True))
+
+    Integer offsets in the argument can be pulled out:
+
+    >>> from sympy import expand_func
+
+    >>> expand_func(harmonic(n+4))
+    harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+
+    >>> expand_func(harmonic(n-4))
+    harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    Some limits can be computed as well:
+
+    >>> from sympy import limit, oo
+
+    >>> limit(harmonic(n), n, oo)
+    oo
+
+    >>> limit(harmonic(n, 2), n, oo)
+    pi**2/6
+
+    >>> limit(harmonic(n, 3), n, oo)
+    zeta(3)
+
+    For `m > 1`, `H_{n,m}` tends to `\zeta(m)` in the limit of infinite `n`:
+
+    >>> m = Symbol("m", positive=True)
+    >>> limit(harmonic(n, m+1), n, oo)
+    zeta(m + 1)
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, lucas, genocchi, partition, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Harmonic_number
+    .. [2] https://functions.wolfram.com/GammaBetaErf/HarmonicNumber/
+    .. [3] https://functions.wolfram.com/GammaBetaErf/HarmonicNumber2/
+
+    """
+
+    # This prevents redundant recalculations and speeds up harmonic number computations.
+    harmonic_cache: dict[Integer, Callable[[int], Rational]] = {}
+
+    @classmethod
+    def eval(cls, n, m=None):
+        from sympy.functions.special.zeta_functions import zeta
+        if m is S.One:
+            return cls(n)
+        if m is None:
+            m = S.One
+        if n.is_zero:
+            return S.Zero
+        elif m.is_zero:
+            return n
+        elif n is S.Infinity:
+            if m.is_negative:
+                return S.NaN
+            elif is_le(m, S.One):
+                return S.Infinity
+            elif is_gt(m, S.One):
+                return zeta(m)
+        elif m.is_Integer and m.is_nonpositive:
+            return (bernoulli(1-m, n+1) - bernoulli(1-m)) / (1-m)
+        elif n.is_Integer:
+            if n.is_negative and (m.is_integer is False or m.is_nonpositive is False):
+                return S.ComplexInfinity if m is S.One else S.NaN
+            if n.is_nonnegative:
+                if m.is_Integer:
+                    if m not in cls.harmonic_cache:
+                        @recurrence_memo([0])
+                        def f(n, prev):
+                            return prev[-1] + S.One / n**m
+                        cls.harmonic_cache[m] = f
+                    return cls.harmonic_cache[m](int(n))
+                return Add(*(k**(-m) for k in range(1, int(n) + 1)))
+
+    def _eval_rewrite_as_polygamma(self, n, m=S.One, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma, polygamma
+        if m.is_integer and m.is_positive:
+            return Piecewise((polygamma(0, n+1) + S.EulerGamma, Eq(m, 1)),
+                    (S.NegativeOne**m * (polygamma(m-1, 1) - polygamma(m-1, n+1)) /
+                    gamma(m), True))
+
+    def _eval_rewrite_as_digamma(self, n, m=1, **kwargs):
+        from sympy.functions.special.gamma_functions import polygamma
+        return self.rewrite(polygamma)
+
+    def _eval_rewrite_as_trigamma(self, n, m=1, **kwargs):
+        from sympy.functions.special.gamma_functions import polygamma
+        return self.rewrite(polygamma)
+
+    def _eval_rewrite_as_Sum(self, n, m=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k", integer=True)
+        if m is None:
+            m = S.One
+        return Sum(k**(-m), (k, 1, n))
+
+    def _eval_rewrite_as_zeta(self, n, m=S.One, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((digamma(n + 1) + S.EulerGamma, Eq(m, 1)),
+                         (zeta(m) - zeta(m, n+1), True))
+
+    def _eval_expand_func(self, **hints):
+        from sympy.concrete.summations import Sum
+        n = self.args[0]
+        m = self.args[1] if len(self.args) == 2 else 1
+
+        if m == S.One:
+            if n.is_Add:
+                off = n.args[0]
+                nnew = n - off
+                if off.is_Integer and off.is_positive:
+                    result = [S.One/(nnew + i) for i in range(off, 0, -1)] + [harmonic(nnew)]
+                    return Add(*result)
+                elif off.is_Integer and off.is_negative:
+                    result = [-S.One/(nnew + i) for i in range(0, off, -1)] + [harmonic(nnew)]
+                    return Add(*result)
+
+            if n.is_Rational:
+                # Expansions for harmonic numbers at general rational arguments (u + p/q)
+                # Split n as u + p/q with p < q
+                p, q = n.as_numer_denom()
+                u = p // q
+                p = p - u * q
+                if u.is_nonnegative and p.is_positive and q.is_positive and p < q:
+                    from sympy.functions.elementary.exponential import log
+                    from sympy.functions.elementary.integers import floor
+                    from sympy.functions.elementary.trigonometric import sin, cos, cot
+                    k = Dummy("k")
+                    t1 = q * Sum(1 / (q * k + p), (k, 0, u))
+                    t2 = 2 * Sum(cos((2 * pi * p * k) / S(q)) *
+                                   log(sin((pi * k) / S(q))),
+                                   (k, 1, floor((q - 1) / S(2))))
+                    t3 = (pi / 2) * cot((pi * p) / q) + log(2 * q)
+                    return t1 + t2 - t3
+
+        return self
+
+    def _eval_rewrite_as_tractable(self, n, m=1, limitvar=None, **kwargs):
+        from sympy.functions.special.zeta_functions import zeta
+        from sympy.functions.special.gamma_functions import polygamma
+        pg = self.rewrite(polygamma)
+        if not isinstance(pg, harmonic):
+            return pg.rewrite("tractable", deep=True)
+        arg = m - S.One
+        if arg.is_nonzero:
+            return (zeta(m) - zeta(m, n+1)).rewrite("tractable", deep=True)
+
+    def _eval_evalf(self, prec):
+        if not all(x.is_number for x in self.args):
+            return
+        n = self.args[0]._to_mpmath(prec)
+        m = (self.args[1] if len(self.args) > 1 else S.One)._to_mpmath(prec)
+        if mp.isint(n) and n < 0:
+            return S.NaN
+        with workprec(prec):
+            if m == 1:
+                res = mp.harmonic(n)
+            else:
+                res = mp.zeta(m) - mp.zeta(m, n+1)
+        return Expr._from_mpmath(res, prec)
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.special.zeta_functions import zeta
+        if len(self.args) == 2:
+            n, m = self.args
+        else:
+            n, m = self.args + (1,)
+        if argindex == 1:
+            return m * zeta(m+1, n+1)
+        else:
+            raise ArgumentIndexError
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Euler numbers                                    #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class euler(DefinedFunction):
+    r"""
+    Euler numbers / Euler polynomials / Euler function
+
+    The Euler numbers are given by:
+
+    .. math:: E_{2n} = I \sum_{k=1}^{2n+1} \sum_{j=0}^k \binom{k}{j}
+        \frac{(-1)^j (k-2j)^{2n+1}}{2^k I^k k}
+
+    .. math:: E_{2n+1} = 0
+
+    Euler numbers and Euler polynomials are related by
+
+    .. math:: E_n = 2^n E_n\left(\frac{1}{2}\right).
+
+    We compute symbolic Euler polynomials using Appell sequences,
+    but numerical evaluation of the Euler polynomial is computed
+    more efficiently (and more accurately) using the mpmath library.
+
+    The Euler polynomials are special cases of the generalized Euler function,
+    related to the Genocchi function as
+
+    .. math:: \operatorname{E}(s, a) = -\frac{\operatorname{G}(s+1, a)}{s+1}
+
+    with the limit of `\psi\left(\frac{a+1}{2}\right) - \psi\left(\frac{a}{2}\right)`
+    being taken when `s = -1`. The (ordinary) Euler function interpolating
+    the Euler numbers is then obtained as
+    `\operatorname{E}(s) = 2^s \operatorname{E}\left(s, \frac{1}{2}\right)`.
+
+    * ``euler(n)`` gives the nth Euler number `E_n`.
+    * ``euler(s)`` gives the Euler function `\operatorname{E}(s)`.
+    * ``euler(n, x)`` gives the nth Euler polynomial `E_n(x)`.
+    * ``euler(s, a)`` gives the generalized Euler function `\operatorname{E}(s, a)`.
+
+    Examples
+    ========
+
+    >>> from sympy import euler, Symbol, S
+    >>> [euler(n) for n in range(10)]
+    [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0]
+    >>> [2**n*euler(n,1) for n in range(10)]
+    [1, 1, 0, -2, 0, 16, 0, -272, 0, 7936]
+    >>> n = Symbol("n")
+    >>> euler(n + 2*n)
+    euler(3*n)
+
+    >>> x = Symbol("x")
+    >>> euler(n, x)
+    euler(n, x)
+
+    >>> euler(0, x)
+    1
+    >>> euler(1, x)
+    x - 1/2
+    >>> euler(2, x)
+    x**2 - x
+    >>> euler(3, x)
+    x**3 - 3*x**2/2 + 1/4
+    >>> euler(4, x)
+    x**4 - 2*x**3 + x
+
+    >>> euler(12, S.Half)
+    2702765/4096
+    >>> euler(12)
+    2702765
+
+    See Also
+    ========
+
+    andre, bell, bernoulli, catalan, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.polys.appellseqs.euler_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler_numbers
+    .. [2] https://mathworld.wolfram.com/EulerNumber.html
+    .. [3] https://en.wikipedia.org/wiki/Alternating_permutation
+    .. [4] https://mathworld.wolfram.com/AlternatingPermutation.html
+
+    """
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if n.is_zero:
+            return S.One
+        elif n is S.NegativeOne:
+            if x is None:
+                return S.Pi/2
+            from sympy.functions.special.gamma_functions import digamma
+            return digamma((x+1)/2) - digamma(x/2)
+        elif n.is_integer is False or n.is_nonnegative is False:
+            return
+        # Euler numbers
+        elif x is None:
+            if n.is_odd and n.is_positive:
+                return S.Zero
+            elif n.is_Number:
+                from mpmath import mp
+                n = n._to_mpmath(mp.prec)
+                res = mp.eulernum(n, exact=True)
+                return Integer(res)
+        # Euler polynomials
+        elif n.is_Number:
+            from sympy.core.evalf import pure_complex
+            n = int(n)
+            reim = pure_complex(x, or_real=True)
+            if reim and all(a.is_Float or a.is_Integer for a in reim) \
+                    and any(a.is_Float for a in reim):
+                from mpmath import mp
+                prec = min([a._prec for a in reim if a.is_Float])
+                with workprec(prec):
+                    res = mp.eulerpoly(n, x)
+                return Expr._from_mpmath(res, prec)
+            return euler_poly(n, x)
+
+    def _eval_rewrite_as_Sum(self, n, x=None, **kwargs):
+        from sympy.concrete.summations import Sum
+        if x is None and n.is_even:
+            k = Dummy("k", integer=True)
+            j = Dummy("j", integer=True)
+            n = n / 2
+            Em = (S.ImaginaryUnit * Sum(Sum(binomial(k, j) * (S.NegativeOne**j *
+                                                              (k - 2*j)**(2*n + 1)) /
+                  (2**k*S.ImaginaryUnit**k * k), (j, 0, k)), (k, 1, 2*n + 1)))
+            return Em
+        if x:
+            k = Dummy("k", integer=True)
+            return Sum(binomial(n, k)*euler(k)/2**k*(x - S.Half)**(n - k), (k, 0, n))
+
+    def _eval_rewrite_as_genocchi(self, n, x=None, **kwargs):
+        if x is None:
+            return Piecewise((S.Pi/2, Eq(n, -1)),
+                             (-2**n * genocchi(n+1, S.Half) / (n+1), True))
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((digamma((x+1)/2) - digamma(x/2), Eq(n, -1)),
+                         (-genocchi(n+1, x) / (n+1), True))
+
+    def _eval_evalf(self, prec):
+        if not all(i.is_number for i in self.args):
+            return
+        from mpmath import mp
+        m, x = (self.args[0], None) if len(self.args) == 1 else self.args
+        m = m._to_mpmath(prec)
+        if x is not None:
+            x = x._to_mpmath(prec)
+        with workprec(prec):
+            if mp.isint(m) and m >= 0:
+                res = mp.eulernum(m) if x is None else mp.eulerpoly(m, x)
+            else:
+                if m == -1:
+                    res = mp.pi if x is None else mp.digamma((x+1)/2) - mp.digamma(x/2)
+                else:
+                    y = 0.5 if x is None else x
+                    res = 2 * (mp.zeta(-m, y) - 2**(m+1) * mp.zeta(-m, (y+1)/2))
+                if x is None:
+                    res *= 2**m
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Catalan numbers                               #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class catalan(DefinedFunction):
+    r"""
+    Catalan numbers
+
+    The `n^{th}` catalan number is given by:
+
+    .. math :: C_n = \frac{1}{n+1} \binom{2n}{n}
+
+    * ``catalan(n)`` gives the `n^{th}` Catalan number, `C_n`
+
+    Examples
+    ========
+
+    >>> from sympy import (Symbol, binomial, gamma, hyper,
+    ...     catalan, diff, combsimp, Rational, I)
+
+    >>> [catalan(i) for i in range(1,10)]
+    [1, 2, 5, 14, 42, 132, 429, 1430, 4862]
+
+    >>> n = Symbol("n", integer=True)
+
+    >>> catalan(n)
+    catalan(n)
+
+    Catalan numbers can be transformed into several other, identical
+    expressions involving other mathematical functions
+
+    >>> catalan(n).rewrite(binomial)
+    binomial(2*n, n)/(n + 1)
+
+    >>> catalan(n).rewrite(gamma)
+    4**n*gamma(n + 1/2)/(sqrt(pi)*gamma(n + 2))
+
+    >>> catalan(n).rewrite(hyper)
+    hyper((-n, 1 - n), (2,), 1)
+
+    For some non-integer values of n we can get closed form
+    expressions by rewriting in terms of gamma functions:
+
+    >>> catalan(Rational(1, 2)).rewrite(gamma)
+    8/(3*pi)
+
+    We can differentiate the Catalan numbers C(n) interpreted as a
+    continuous real function in n:
+
+    >>> diff(catalan(n), n)
+    (polygamma(0, n + 1/2) - polygamma(0, n + 2) + log(4))*catalan(n)
+
+    As a more advanced example consider the following ratio
+    between consecutive numbers:
+
+    >>> combsimp((catalan(n + 1)/catalan(n)).rewrite(binomial))
+    2*(2*n + 1)/(n + 2)
+
+    The Catalan numbers can be generalized to complex numbers:
+
+    >>> catalan(I).rewrite(gamma)
+    4**I*gamma(1/2 + I)/(sqrt(pi)*gamma(2 + I))
+
+    and evaluated with arbitrary precision:
+
+    >>> catalan(I).evalf(20)
+    0.39764993382373624267 - 0.020884341620842555705*I
+
+    See Also
+    ========
+
+    andre, bell, bernoulli, euler, fibonacci, harmonic, lucas, genocchi,
+    partition, tribonacci, sympy.functions.combinatorial.factorials.binomial
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Catalan_number
+    .. [2] https://mathworld.wolfram.com/CatalanNumber.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/CatalanNumber/
+    .. [4] http://geometer.org/mathcircles/catalan.pdf
+
+    """
+
+    @classmethod
+    def eval(cls, n):
+        from sympy.functions.special.gamma_functions import gamma
+        if (n.is_Integer and n.is_nonnegative) or \
+           (n.is_noninteger and n.is_negative):
+            return 4**n*gamma(n + S.Half)/(gamma(S.Half)*gamma(n + 2))
+
+        if (n.is_integer and n.is_negative):
+            if (n + 1).is_negative:
+                return S.Zero
+            if (n + 1).is_zero:
+                return Rational(-1, 2)
+
+    def fdiff(self, argindex=1):
+        from sympy.functions.elementary.exponential import log
+        from sympy.functions.special.gamma_functions import polygamma
+        n = self.args[0]
+        return catalan(n)*(polygamma(0, n + S.Half) - polygamma(0, n + 2) + log(4))
+
+    def _eval_rewrite_as_binomial(self, n, **kwargs):
+        return binomial(2*n, n)/(n + 1)
+
+    def _eval_rewrite_as_factorial(self, n, **kwargs):
+        return factorial(2*n) / (factorial(n+1) * factorial(n))
+
+    def _eval_rewrite_as_gamma(self, n, piecewise=True, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        # The gamma function allows to generalize Catalan numbers to complex n
+        return 4**n*gamma(n + S.Half)/(gamma(S.Half)*gamma(n + 2))
+
+    def _eval_rewrite_as_hyper(self, n, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        return hyper([1 - n, -n], [2], 1)
+
+    def _eval_rewrite_as_Product(self, n, **kwargs):
+        from sympy.concrete.products import Product
+        if not (n.is_integer and n.is_nonnegative):
+            return self
+        k = Dummy('k', integer=True, positive=True)
+        return Product((n + k) / k, (k, 2, n))
+
+    def _eval_is_integer(self):
+        if self.args[0].is_integer and self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_composite(self):
+        if self.args[0].is_integer and (self.args[0] - 3).is_positive:
+            return True
+
+    def _eval_evalf(self, prec):
+        from sympy.functions.special.gamma_functions import gamma
+        if self.args[0].is_number:
+            return self.rewrite(gamma)._eval_evalf(prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Genocchi numbers                                 #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class genocchi(DefinedFunction):
+    r"""
+    Genocchi numbers / Genocchi polynomials / Genocchi function
+
+    The Genocchi numbers are a sequence of integers `G_n` that satisfy the
+    relation:
+
+    .. math:: \frac{-2t}{1 + e^{-t}} = \sum_{n=0}^\infty \frac{G_n t^n}{n!}
+
+    They are related to the Bernoulli numbers by
+
+    .. math:: G_n = 2 (1 - 2^n) B_n
+
+    and generalize like the Bernoulli numbers to the Genocchi polynomials and
+    function as
+
+    .. math:: \operatorname{G}(s, a) = 2 \left(\operatorname{B}(s, a) -
+              2^s \operatorname{B}\left(s, \frac{a+1}{2}\right)\right)
+
+    .. versionchanged:: 1.12
+        ``genocchi(1)`` gives `-1` instead of `1`.
+
+    Examples
+    ========
+
+    >>> from sympy import genocchi, Symbol
+    >>> [genocchi(n) for n in range(9)]
+    [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    >>> n = Symbol('n', integer=True, positive=True)
+    >>> genocchi(2*n + 1)
+    0
+    >>> x = Symbol('x')
+    >>> genocchi(4, x)
+    -4*x**3 + 6*x**2 - 1
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, partition, tribonacci
+    sympy.polys.appellseqs.genocchi_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Genocchi_number
+    .. [2] https://mathworld.wolfram.com/GenocchiNumber.html
+    .. [3] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    @classmethod
+    def eval(cls, n, x=None):
+        if x is S.One:
+            return cls(n)
+        elif n.is_integer is False or n.is_nonnegative is False:
+            return
+        # Genocchi numbers
+        elif x is None:
+            if n.is_odd and (n-1).is_positive:
+                return S.Zero
+            elif n.is_Number:
+                return 2 * (1-S(2)**n) * bernoulli(n)
+        # Genocchi polynomials
+        elif n.is_Number:
+            return genocchi_poly(n, x)
+
+    def _eval_rewrite_as_bernoulli(self, n, x=1, **kwargs):
+        if x == 1 and n.is_integer and n.is_nonnegative:
+            return 2 * (1-S(2)**n) * bernoulli(n)
+        return 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+
+    def _eval_rewrite_as_dirichlet_eta(self, n, x=1, **kwargs):
+        from sympy.functions.special.zeta_functions import dirichlet_eta
+        return -2*n * dirichlet_eta(1-n, x)
+
+    def _eval_is_integer(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            return True
+
+    def _eval_is_negative(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_odd:
+                return fuzzy_not((n-1).is_positive)
+            return (n/2).is_odd
+
+    def _eval_is_positive(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_zero or n.is_odd:
+                return False
+            return (n/2).is_even
+
+    def _eval_is_even(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_even:
+                return n.is_zero
+            return (n-1).is_positive
+
+    def _eval_is_odd(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            if n.is_even:
+                return fuzzy_not(n.is_zero)
+            return fuzzy_not((n-1).is_positive)
+
+    def _eval_is_prime(self):
+        if len(self.args) > 1 and self.args[1] != 1:
+            return
+        n = self.args[0]
+        # only G_6 = -3 and G_8 = 17 are prime,
+        # but SymPy does not consider negatives as prime
+        # so only n=8 is tested
+        return (n-8).is_zero
+
+    def _eval_evalf(self, prec):
+        if all(i.is_number for i in self.args):
+            return self.rewrite(bernoulli)._eval_evalf(prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                              Andre numbers                                 #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+class andre(DefinedFunction):
+    r"""
+    Andre numbers / Andre function
+
+    The Andre number `\mathcal{A}_n` is Luschny's name for half the number of
+    *alternating permutations* on `n` elements, where a permutation is alternating
+    if adjacent elements alternately compare "greater" and "smaller" going from
+    left to right. For example, `2 < 3 > 1 < 4` is an alternating permutation.
+
+    This sequence is A000111 in the OEIS, which assigns the names *up/down numbers*
+    and *Euler zigzag numbers*. It satisfies a recurrence relation similar to that
+    for the Catalan numbers, with `\mathcal{A}_0 = 1` and
+
+    .. math:: 2 \mathcal{A}_{n+1} = \sum_{k=0}^n \binom{n}{k} \mathcal{A}_k \mathcal{A}_{n-k}
+
+    The Bernoulli and Euler numbers are signed transformations of the odd- and
+    even-indexed elements of this sequence respectively:
+
+    .. math :: \operatorname{B}_{2k} = \frac{2k \mathcal{A}_{2k-1}}{(-4)^k - (-16)^k}
+
+    .. math :: \operatorname{E}_{2k} = (-1)^k \mathcal{A}_{2k}
+
+    Like the Bernoulli and Euler numbers, the Andre numbers are interpolated by the
+    entire Andre function:
+
+    .. math :: \mathcal{A}(s) = (-i)^{s+1} \operatorname{Li}_{-s}(i) +
+            i^{s+1} \operatorname{Li}_{-s}(-i) = \\ \frac{2 \Gamma(s+1)}{(2\pi)^{s+1}}
+            (\zeta(s+1, 1/4) - \zeta(s+1, 3/4) \cos{\pi s})
+
+    Examples
+    ========
+
+    >>> from sympy import andre, euler, bernoulli
+    >>> [andre(n) for n in range(11)]
+    [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    >>> [(-1)**k * andre(2*k) for k in range(7)]
+    [1, -1, 5, -61, 1385, -50521, 2702765]
+    >>> [euler(2*k) for k in range(7)]
+    [1, -1, 5, -61, 1385, -50521, 2702765]
+    >>> [andre(2*k-1) * (2*k) / ((-4)**k - (-16)**k) for k in range(1, 8)]
+    [1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
+    >>> [bernoulli(2*k) for k in range(1, 8)]
+    [1/6, -1/30, 1/42, -1/30, 5/66, -691/2730, 7/6]
+
+    See Also
+    ========
+
+    bernoulli, catalan, euler, sympy.polys.appellseqs.andre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Alternating_permutation
+    .. [2] https://mathworld.wolfram.com/EulerZigzagNumber.html
+    .. [3] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+    """
+
+    @classmethod
+    def eval(cls, n):
+        if n is S.NaN:
+            return S.NaN
+        elif n is S.Infinity:
+            return S.Infinity
+        if n.is_zero:
+            return S.One
+        elif n == -1:
+            return -log(2)
+        elif n == -2:
+            return -2*S.Catalan
+        elif n.is_Integer:
+            if n.is_nonnegative and n.is_even:
+                return abs(euler(n))
+            elif n.is_odd:
+                from sympy.functions.special.zeta_functions import zeta
+                m = -n-1
+                return I**m * Rational(1-2**m, 4**m) * zeta(-n)
+
+    def _eval_rewrite_as_zeta(self, s, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        from sympy.functions.special.gamma_functions import gamma
+        from sympy.functions.special.zeta_functions import zeta
+        return 2 * gamma(s+1) / (2*pi)**(s+1) * \
+                (zeta(s+1, S.One/4) - cos(pi*s) * zeta(s+1, S(3)/4))
+
+    def _eval_rewrite_as_polylog(self, s, **kwargs):
+        from sympy.functions.special.zeta_functions import polylog
+        return (-I)**(s+1) * polylog(-s, I) + I**(s+1) * polylog(-s, -I)
+
+    def _eval_is_integer(self):
+        n = self.args[0]
+        if n.is_integer and n.is_nonnegative:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_evalf(self, prec):
+        if not self.args[0].is_number:
+            return
+        s = self.args[0]._to_mpmath(prec+12)
+        with workprec(prec+12):
+            sp, cp = mp.sinpi(s/2), mp.cospi(s/2)
+            res = 2*mp.dirichlet(-s, (-sp, cp, sp, -cp))
+        return Expr._from_mpmath(res, prec)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                           Partition numbers                                #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+class partition(DefinedFunction):
+    r"""
+    Partition numbers
+
+    The Partition numbers are a sequence of integers `p_n` that represent the
+    number of distinct ways of representing `n` as a sum of natural numbers
+    (with order irrelevant). The generating function for `p_n` is given by:
+
+    .. math:: \sum_{n=0}^\infty p_n x^n = \prod_{k=1}^\infty (1 - x^k)^{-1}
+
+    Examples
+    ========
+
+    >>> from sympy import partition, Symbol
+    >>> [partition(n) for n in range(9)]
+    [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    >>> n = Symbol('n', integer=True, negative=True)
+    >>> partition(n)
+    0
+
+    See Also
+    ========
+
+    bell, bernoulli, catalan, euler, fibonacci, harmonic, lucas, genocchi, tribonacci
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Partition_(number_theory%29
+    .. [2] https://en.wikipedia.org/wiki/Pentagonal_number_theorem
+
+    """
+    is_integer = True
+    is_nonnegative = True
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_negative is True:
+            return S.Zero
+        if n.is_zero is True or n is S.One:
+            return S.One
+        if n.is_Integer is True:
+            return S(_partition(as_int(n)))
+
+    def _eval_is_positive(self):
+        if self.args[0].is_nonnegative is True:
+            return True
+
+    def _eval_Mod(self, q):
+        # Ramanujan's congruences
+        n = self.args[0]
+        for p, rem in [(5, 4), (7, 5), (11, 6)]:
+            if q == p and n % q == rem:
+                return S.Zero
+
+
+class divisor_sigma(DefinedFunction):
+    r"""
+    Calculate the divisor function `\sigma_k(n)` for positive integer n
+
+    ``divisor_sigma(n, k)`` is equal to ``sum([x**k for x in divisors(n)])``
+
+    If n's prime factorization is:
+
+    .. math ::
+        n = \prod_{i=1}^\omega p_i^{m_i},
+
+    then
+
+    .. math ::
+        \sigma_k(n) = \prod_{i=1}^\omega (1+p_i^k+p_i^{2k}+\cdots
+        + p_i^{m_ik}).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import divisor_sigma
+    >>> divisor_sigma(18, 0)
+    6
+    >>> divisor_sigma(39, 1)
+    56
+    >>> divisor_sigma(12, 2)
+    210
+    >>> divisor_sigma(37)
+    38
+
+    See Also
+    ========
+
+    sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors, sympy.ntheory.factor_.factorint
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Divisor_function
+
+    """
+    is_integer = True
+    is_positive = True
+
+    @classmethod
+    def eval(cls, n, k=S.One):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if k.is_integer is False:
+            raise TypeError("k should be an integer")
+        if k.is_nonnegative is False:
+            raise ValueError("k should be a nonnegative integer")
+        if n.is_prime is True:
+            return 1 + n**k
+        if n is S.One:
+            return S.One
+        if n.is_Integer is True:
+            if k.is_zero is True:
+                return Mul(*[e + 1 for e in factorint(n).values()])
+            if k.is_Integer is True:
+                return S(_divisor_sigma(as_int(n), as_int(k)))
+            if k.is_zero is False:
+                return Mul(*[cancel((p**(k*(e + 1)) - 1) / (p**k - 1)) for p, e in factorint(n).items()])
+
+
+class udivisor_sigma(DefinedFunction):
+    r"""
+    Calculate the unitary divisor function `\sigma_k^*(n)` for positive integer n
+
+    ``udivisor_sigma(n, k)`` is equal to ``sum([x**k for x in udivisors(n)])``
+
+    If n's prime factorization is:
+
+    .. math ::
+        n = \prod_{i=1}^\omega p_i^{m_i},
+
+    then
+
+    .. math ::
+        \sigma_k^*(n) = \prod_{i=1}^\omega (1+ p_i^{m_ik}).
+
+    Parameters
+    ==========
+
+    k : power of divisors in the sum
+
+        for k = 0, 1:
+        ``udivisor_sigma(n, 0)`` is equal to ``udivisor_count(n)``
+        ``udivisor_sigma(n, 1)`` is equal to ``sum(udivisors(n))``
+
+        Default for k is 1.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import udivisor_sigma
+    >>> udivisor_sigma(18, 0)
+    4
+    >>> udivisor_sigma(74, 1)
+    114
+    >>> udivisor_sigma(36, 3)
+    47450
+    >>> udivisor_sigma(111)
+    152
+
+    See Also
+    ========
+
+    sympy.ntheory.factor_.divisor_count, totient, sympy.ntheory.factor_.divisors,
+    sympy.ntheory.factor_.udivisors, sympy.ntheory.factor_.udivisor_count, divisor_sigma,
+    sympy.ntheory.factor_.factorint
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/UnitaryDivisorFunction.html
+
+    """
+    is_integer = True
+    is_positive = True
+
+    @classmethod
+    def eval(cls, n, k=S.One):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if k.is_integer is False:
+            raise TypeError("k should be an integer")
+        if k.is_nonnegative is False:
+            raise ValueError("k should be a nonnegative integer")
+        if n.is_prime is True:
+            return 1 + n**k
+        if n.is_Integer:
+            return Mul(*[1+p**(k*e) for p, e in factorint(n).items()])
+
+
+class legendre_symbol(DefinedFunction):
+    r"""
+    Returns the Legendre symbol `(a / p)`.
+
+    For an integer ``a`` and an odd prime ``p``, the Legendre symbol is
+    defined as
+
+    .. math ::
+        \genfrac(){}{}{a}{p} = \begin{cases}
+             0 & \text{if } p \text{ divides } a\\
+             1 & \text{if } a \text{ is a quadratic residue modulo } p\\
+            -1 & \text{if } a \text{ is a quadratic nonresidue modulo } p
+        \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import legendre_symbol
+    >>> [legendre_symbol(i, 7) for i in range(7)]
+    [0, 1, 1, -1, 1, -1, -1]
+    >>> sorted(set([i**2 % 7 for i in range(7)]))
+    [0, 1, 2, 4]
+
+    See Also
+    ========
+
+    sympy.ntheory.residue_ntheory.is_quad_residue, jacobi_symbol
+
+    """
+    is_integer = True
+    is_prime = False
+
+    @classmethod
+    def eval(cls, a, p):
+        if a.is_integer is False:
+            raise TypeError("a should be an integer")
+        if p.is_integer is False:
+            raise TypeError("p should be an integer")
+        if p.is_prime is False or p.is_odd is False:
+            raise ValueError("p should be an odd prime integer")
+        if (a % p).is_zero is True:
+            return S.Zero
+        if a is S.One:
+            return S.One
+        if a.is_Integer is True and p.is_Integer is True:
+            return S(legendre(as_int(a), as_int(p)))
+
+
+class jacobi_symbol(DefinedFunction):
+    r"""
+    Returns the Jacobi symbol `(m / n)`.
+
+    For any integer ``m`` and any positive odd integer ``n`` the Jacobi symbol
+    is defined as the product of the Legendre symbols corresponding to the
+    prime factors of ``n``:
+
+    .. math ::
+        \genfrac(){}{}{m}{n} =
+            \genfrac(){}{}{m}{p^{1}}^{\alpha_1}
+            \genfrac(){}{}{m}{p^{2}}^{\alpha_2}
+            ...
+            \genfrac(){}{}{m}{p^{k}}^{\alpha_k}
+            \text{ where } n =
+                p_1^{\alpha_1}
+                p_2^{\alpha_2}
+                ...
+                p_k^{\alpha_k}
+
+    Like the Legendre symbol, if the Jacobi symbol `\genfrac(){}{}{m}{n} = -1`
+    then ``m`` is a quadratic nonresidue modulo ``n``.
+
+    But, unlike the Legendre symbol, if the Jacobi symbol
+    `\genfrac(){}{}{m}{n} = 1` then ``m`` may or may not be a quadratic residue
+    modulo ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import jacobi_symbol, legendre_symbol
+    >>> from sympy import S
+    >>> jacobi_symbol(45, 77)
+    -1
+    >>> jacobi_symbol(60, 121)
+    1
+
+    The relationship between the ``jacobi_symbol`` and ``legendre_symbol`` can
+    be demonstrated as follows:
+
+    >>> L = legendre_symbol
+    >>> S(45).factors()
+    {3: 2, 5: 1}
+    >>> jacobi_symbol(7, 45) == L(7, 3)**2 * L(7, 5)**1
+    True
+
+    See Also
+    ========
+
+    sympy.ntheory.residue_ntheory.is_quad_residue, legendre_symbol
+
+    """
+    is_integer = True
+    is_prime = False
+
+    @classmethod
+    def eval(cls, m, n):
+        if m.is_integer is False:
+            raise TypeError("m should be an integer")
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False or n.is_odd is False:
+            raise ValueError("n should be an odd positive integer")
+        if m is S.One or n is S.One:
+            return S.One
+        if (m % n).is_zero is True:
+            return S.Zero
+        if m.is_Integer is True and n.is_Integer is True:
+            return S(jacobi(as_int(m), as_int(n)))
+
+
+class kronecker_symbol(DefinedFunction):
+    r"""
+    Returns the Kronecker symbol `(a / n)`.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import kronecker_symbol
+    >>> kronecker_symbol(45, 77)
+    -1
+    >>> kronecker_symbol(13, -120)
+    1
+
+    See Also
+    ========
+
+    jacobi_symbol, legendre_symbol
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Kronecker_symbol
+
+    """
+    is_integer = True
+    is_prime = False
+
+    @classmethod
+    def eval(cls, a, n):
+        if a.is_integer is False:
+            raise TypeError("a should be an integer")
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if a is S.One or n is S.One:
+            return S.One
+        if a.is_Integer is True and n.is_Integer is True:
+            return S(kronecker(as_int(a), as_int(n)))
+
+
+class mobius(DefinedFunction):
+    """
+    Mobius function maps natural number to {-1, 0, 1}
+
+    It is defined as follows:
+        1) `1` if `n = 1`.
+        2) `0` if `n` has a squared prime factor.
+        3) `(-1)^k` if `n` is a square-free positive integer with `k`
+           number of prime factors.
+
+    It is an important multiplicative function in number theory
+    and combinatorics.  It has applications in mathematical series,
+    algebraic number theory and also physics (Fermion operator has very
+    concrete realization with Mobius Function model).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import mobius
+    >>> mobius(13*7)
+    1
+    >>> mobius(1)
+    1
+    >>> mobius(13*7*5)
+    -1
+    >>> mobius(13**2)
+    0
+
+    Even in the case of a symbol, if it clearly contains a squared prime factor, it will be zero.
+
+    >>> from sympy import Symbol
+    >>> n = Symbol("n", integer=True, positive=True)
+    >>> mobius(4*n)
+    0
+    >>> mobius(n**2)
+    0
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/M%C3%B6bius_function
+    .. [2] Thomas Koshy "Elementary Number Theory with Applications"
+    .. [3] https://oeis.org/A008683
+
+    """
+    is_integer = True
+    is_prime = False
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if n.is_prime is True:
+            return S.NegativeOne
+        if n is S.One:
+            return S.One
+        result = None
+        for m, e in (_.as_base_exp() for _ in Mul.make_args(n)):
+            if m.is_integer is True and m.is_positive is True and \
+               e.is_integer is True and e.is_positive is True:
+                lt = is_lt(S.One, e) # 1 < e
+                if lt is True:
+                    result = S.Zero
+                elif m.is_Integer is True:
+                    factors = factorint(m)
+                    if any(v > 1 for v in factors.values()):
+                        result = S.Zero
+                    elif lt is False:
+                        s = S.NegativeOne if len(factors) % 2 else S.One
+                        if result is None:
+                            result = s
+                        else:
+                            result *= s
+            else:
+                return
+        return result
+
+
+class primenu(DefinedFunction):
+    r"""
+    Calculate the number of distinct prime factors for a positive integer n.
+
+    If n's prime factorization is:
+
+    .. math ::
+        n = \prod_{i=1}^k p_i^{m_i},
+
+    then ``primenu(n)`` or `\nu(n)` is:
+
+    .. math ::
+        \nu(n) = k.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import primenu
+    >>> primenu(1)
+    0
+    >>> primenu(30)
+    3
+
+    See Also
+    ========
+
+    sympy.ntheory.factor_.factorint
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/PrimeFactor.html
+    .. [2] https://oeis.org/A001221
+
+    """
+    is_integer = True
+    is_nonnegative = True
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if n.is_prime is True:
+            return S.One
+        if n is S.One:
+            return S.Zero
+        if n.is_Integer is True:
+            return S(len(factorint(n)))
+
+
+class primeomega(DefinedFunction):
+    r"""
+    Calculate the number of prime factors counting multiplicities for a
+    positive integer n.
+
+    If n's prime factorization is:
+
+    .. math ::
+        n = \prod_{i=1}^k p_i^{m_i},
+
+    then ``primeomega(n)``  or `\Omega(n)` is:
+
+    .. math ::
+        \Omega(n) = \sum_{i=1}^k m_i.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import primeomega
+    >>> primeomega(1)
+    0
+    >>> primeomega(20)
+    3
+
+    See Also
+    ========
+
+    sympy.ntheory.factor_.factorint
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/PrimeFactor.html
+    .. [2] https://oeis.org/A001222
+
+    """
+    is_integer = True
+    is_nonnegative = True
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if n.is_prime is True:
+            return S.One
+        if n is S.One:
+            return S.Zero
+        if n.is_Integer is True:
+            return S(sum(factorint(n).values()))
+
+
+class totient(DefinedFunction):
+    r"""
+    Calculate the Euler totient function phi(n)
+
+    ``totient(n)`` or `\phi(n)` is the number of positive integers `\leq` n
+    that are relatively prime to n.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import totient
+    >>> totient(1)
+    1
+    >>> totient(25)
+    20
+    >>> totient(45) == totient(5)*totient(9)
+    True
+
+    See Also
+    ========
+
+    sympy.ntheory.factor_.divisor_count
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Euler%27s_totient_function
+    .. [2] https://mathworld.wolfram.com/TotientFunction.html
+    .. [3] https://oeis.org/A000010
+
+    """
+    is_integer = True
+    is_positive = True
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if n is S.One:
+            return S.One
+        if n.is_prime is True:
+            return n - 1
+        if isinstance(n, Dict):
+            return S(prod(p**(k-1)*(p-1) for p, k in n.items()))
+        if n.is_Integer is True:
+            return S(prod(p**(k-1)*(p-1) for p, k in factorint(n).items()))
+
+
+class reduced_totient(DefinedFunction):
+    r"""
+    Calculate the Carmichael reduced totient function lambda(n)
+
+    ``reduced_totient(n)`` or `\lambda(n)` is the smallest m > 0 such that
+    `k^m \equiv 1 \mod n` for all k relatively prime to n.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import reduced_totient
+    >>> reduced_totient(1)
+    1
+    >>> reduced_totient(8)
+    2
+    >>> reduced_totient(30)
+    4
+
+    See Also
+    ========
+
+    totient
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Carmichael_function
+    .. [2] https://mathworld.wolfram.com/CarmichaelFunction.html
+    .. [3] https://oeis.org/A002322
+
+    """
+    is_integer = True
+    is_positive = True
+
+    @classmethod
+    def eval(cls, n):
+        if n.is_integer is False:
+            raise TypeError("n should be an integer")
+        if n.is_positive is False:
+            raise ValueError("n should be a positive integer")
+        if n is S.One:
+            return S.One
+        if n.is_prime is True:
+            return n - 1
+        if isinstance(n, Dict):
+            t = 1
+            if 2 in n:
+                t = (1 << (n[2] - 2)) if 2 < n[2] else n[2]
+            return S(lcm(int(t), *(int(p-1)*int(p)**int(k-1) for p, k in n.items() if p != 2)))
+        if n.is_Integer is True:
+            n, t = remove(int(n), 2)
+            if not t:
+                t = 1
+            elif 2 < t:
+                t = 1 << (t - 2)
+            return S(lcm(t, *((p-1)*p**(k-1) for p, k in factorint(n).items())))
+
+
+class primepi(DefinedFunction):
+    r""" Represents the prime counting function pi(n) = the number
+    of prime numbers less than or equal to n.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import primepi
+    >>> from sympy import prime, prevprime, isprime
+    >>> primepi(25)
+    9
+
+    So there are 9 primes less than or equal to 25. Is 25 prime?
+
+    >>> isprime(25)
+    False
+
+    It is not. So the first prime less than 25 must be the
+    9th prime:
+
+    >>> prevprime(25) == prime(9)
+    True
+
+    See Also
+    ========
+
+    sympy.ntheory.primetest.isprime : Test if n is prime
+    sympy.ntheory.generate.primerange : Generate all primes in a given range
+    sympy.ntheory.generate.prime : Return the nth prime
+
+    References
+    ==========
+
+    .. [1] https://oeis.org/A000720
+
+    """
+    is_integer = True
+    is_nonnegative = True
+
+    @classmethod
+    def eval(cls, n):
+        if n is S.Infinity:
+            return S.Infinity
+        if n is S.NegativeInfinity:
+            return S.Zero
+        if n.is_real is False:
+            raise TypeError("n should be a real")
+        if is_lt(n, S(2)) is True:
+            return S.Zero
+        try:
+            n = int(n)
+        except TypeError:
+            return
+        return S(_primepi(n))
+
+
+#######################################################################
+###
+### Functions for enumerating partitions, permutations and combinations
+###
+#######################################################################
+
+
+class _MultisetHistogram(tuple):
+    __slots__ = ()
+
+
+_N = -1
+_ITEMS = -2
+_M = slice(None, _ITEMS)
+
+
+def _multiset_histogram(n):
+    """Return tuple used in permutation and combination counting. Input
+    is a dictionary giving items with counts as values or a sequence of
+    items (which need not be sorted).
+
+    The data is stored in a class deriving from tuple so it is easily
+    recognized and so it can be converted easily to a list.
+    """
+    if isinstance(n, dict):  # item: count
+        if not all(isinstance(v, int) and v >= 0 for v in n.values()):
+            raise ValueError
+        tot = sum(n.values())
+        items = sum(1 for k in n if n[k] > 0)
+        return _MultisetHistogram([n[k] for k in n if n[k] > 0] + [items, tot])
+    else:
+        n = list(n)
+        s = set(n)
+        lens = len(s)
+        lenn = len(n)
+        if lens == lenn:
+            n = [1]*lenn + [lenn, lenn]
+            return _MultisetHistogram(n)
+        m = dict(zip(s, range(lens)))
+        d = dict(zip(range(lens), (0,)*lens))
+        for i in n:
+            d[m[i]] += 1
+        return _multiset_histogram(d)
+
+
+def nP(n, k=None, replacement=False):
+    """Return the number of permutations of ``n`` items taken ``k`` at a time.
+
+    Possible values for ``n``:
+
+        integer - set of length ``n``
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    If ``k`` is None then the total of all permutations of length 0
+    through the number of items represented by ``n`` will be returned.
+
+    If ``replacement`` is True then a given item can appear more than once
+    in the ``k`` items. (For example, for 'ab' permutations of 2 would
+    include 'aa', 'ab', 'ba' and 'bb'.) The multiplicity of elements in
+    ``n`` is ignored when ``replacement`` is True but the total number
+    of elements is considered since no element can appear more times than
+    the number of elements in ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nP
+    >>> from sympy.utilities.iterables import multiset_permutations, multiset
+    >>> nP(3, 2)
+    6
+    >>> nP('abc', 2) == nP(multiset('abc'), 2) == 6
+    True
+    >>> nP('aab', 2)
+    3
+    >>> nP([1, 2, 2], 2)
+    3
+    >>> [nP(3, i) for i in range(4)]
+    [1, 3, 6, 6]
+    >>> nP(3) == sum(_)
+    True
+
+    When ``replacement`` is True, each item can have multiplicity
+    equal to the length represented by ``n``:
+
+    >>> nP('aabc', replacement=True)
+    121
+    >>> [len(list(multiset_permutations('aaaabbbbcccc', i))) for i in range(5)]
+    [1, 3, 9, 27, 81]
+    >>> sum(_)
+    121
+
+    See Also
+    ========
+    sympy.utilities.iterables.multiset_permutations
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Permutation
+
+    """
+    try:
+        n = as_int(n)
+    except ValueError:
+        return Integer(_nP(_multiset_histogram(n), k, replacement))
+    return Integer(_nP(n, k, replacement))
+
+
+@cacheit
+def _nP(n, k=None, replacement=False):
+
+    if k == 0:
+        return 1
+    if isinstance(n, SYMPY_INTS):  # n different items
+        # assert n >= 0
+        if k is None:
+            return sum(_nP(n, i, replacement) for i in range(n + 1))
+        elif replacement:
+            return n**k
+        elif k > n:
+            return 0
+        elif k == n:
+            return factorial(k)
+        elif k == 1:
+            return n
+        else:
+            # assert k >= 0
+            return _product(n - k + 1, n)
+    elif isinstance(n, _MultisetHistogram):
+        if k is None:
+            return sum(_nP(n, i, replacement) for i in range(n[_N] + 1))
+        elif replacement:
+            return n[_ITEMS]**k
+        elif k == n[_N]:
+            return factorial(k)/prod([factorial(i) for i in n[_M] if i > 1])
+        elif k > n[_N]:
+            return 0
+        elif k == 1:
+            return n[_ITEMS]
+        else:
+            # assert k >= 0
+            tot = 0
+            n = list(n)
+            for i in range(len(n[_M])):
+                if not n[i]:
+                    continue
+                n[_N] -= 1
+                if n[i] == 1:
+                    n[i] = 0
+                    n[_ITEMS] -= 1
+                    tot += _nP(_MultisetHistogram(n), k - 1)
+                    n[_ITEMS] += 1
+                    n[i] = 1
+                else:
+                    n[i] -= 1
+                    tot += _nP(_MultisetHistogram(n), k - 1)
+                    n[i] += 1
+                n[_N] += 1
+            return tot
+
+
+@cacheit
+def _AOP_product(n):
+    """for n = (m1, m2, .., mk) return the coefficients of the polynomial,
+    prod(sum(x**i for i in range(nj + 1)) for nj in n); i.e. the coefficients
+    of the product of AOPs (all-one polynomials) or order given in n.  The
+    resulting coefficient corresponding to x**r is the number of r-length
+    combinations of sum(n) elements with multiplicities given in n.
+    The coefficients are given as a default dictionary (so if a query is made
+    for a key that is not present, 0 will be returned).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import _AOP_product
+    >>> from sympy.abc import x
+    >>> n = (2, 2, 3)  # e.g. aabbccc
+    >>> prod = ((x**2 + x + 1)*(x**2 + x + 1)*(x**3 + x**2 + x + 1)).expand()
+    >>> c = _AOP_product(n); dict(c)
+    {0: 1, 1: 3, 2: 6, 3: 8, 4: 8, 5: 6, 6: 3, 7: 1}
+    >>> [c[i] for i in range(8)] == [prod.coeff(x, i) for i in range(8)]
+    True
+
+    The generating poly used here is the same as that listed in
+    https://tinyurl.com/cep849r, but in a refactored form.
+
+    """
+
+    n = list(n)
+    ord = sum(n)
+    need = (ord + 2)//2
+    rv = [1]*(n.pop() + 1)
+    rv.extend((0,) * (need - len(rv)))
+    rv = rv[:need]
+    while n:
+        ni = n.pop()
+        N = ni + 1
+        was = rv[:]
+        for i in range(1, min(N, len(rv))):
+            rv[i] += rv[i - 1]
+        for i in range(N, need):
+            rv[i] += rv[i - 1] - was[i - N]
+    rev = list(reversed(rv))
+    if ord % 2:
+        rv = rv + rev
+    else:
+        rv[-1:] = rev
+    d = defaultdict(int)
+    for i, r in enumerate(rv):
+        d[i] = r
+    return d
+
+
+def nC(n, k=None, replacement=False):
+    """Return the number of combinations of ``n`` items taken ``k`` at a time.
+
+    Possible values for ``n``:
+
+        integer - set of length ``n``
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    If ``k`` is None then the total of all combinations of length 0
+    through the number of items represented in ``n`` will be returned.
+
+    If ``replacement`` is True then a given item can appear more than once
+    in the ``k`` items. (For example, for 'ab' sets of 2 would include 'aa',
+    'ab', and 'bb'.) The multiplicity of elements in ``n`` is ignored when
+    ``replacement`` is True but the total number of elements is considered
+    since no element can appear more times than the number of elements in
+    ``n``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nC
+    >>> from sympy.utilities.iterables import multiset_combinations
+    >>> nC(3, 2)
+    3
+    >>> nC('abc', 2)
+    3
+    >>> nC('aab', 2)
+    2
+
+    When ``replacement`` is True, each item can have multiplicity
+    equal to the length represented by ``n``:
+
+    >>> nC('aabc', replacement=True)
+    35
+    >>> [len(list(multiset_combinations('aaaabbbbcccc', i))) for i in range(5)]
+    [1, 3, 6, 10, 15]
+    >>> sum(_)
+    35
+
+    If there are ``k`` items with multiplicities ``m_1, m_2, ..., m_k``
+    then the total of all combinations of length 0 through ``k`` is the
+    product, ``(m_1 + 1)*(m_2 + 1)*...*(m_k + 1)``. When the multiplicity
+    of each item is 1 (i.e., k unique items) then there are 2**k
+    combinations. For example, if there are 4 unique items, the total number
+    of combinations is 16:
+
+    >>> sum(nC(4, i) for i in range(5))
+    16
+
+    See Also
+    ========
+
+    sympy.utilities.iterables.multiset_combinations
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Combination
+    .. [2] https://tinyurl.com/cep849r
+
+    """
+
+    if isinstance(n, SYMPY_INTS):
+        if k is None:
+            if not replacement:
+                return 2**n
+            return sum(nC(n, i, replacement) for i in range(n + 1))
+        if k < 0:
+            raise ValueError("k cannot be negative")
+        if replacement:
+            return binomial(n + k - 1, k)
+        return binomial(n, k)
+    if isinstance(n, _MultisetHistogram):
+        N = n[_N]
+        if k is None:
+            if not replacement:
+                return prod(m + 1 for m in n[_M])
+            return sum(nC(n, i, replacement) for i in range(N + 1))
+        elif replacement:
+            return nC(n[_ITEMS], k, replacement)
+        # assert k >= 0
+        elif k in (1, N - 1):
+            return n[_ITEMS]
+        elif k in (0, N):
+            return 1
+        return _AOP_product(tuple(n[_M]))[k]
+    else:
+        return nC(_multiset_histogram(n), k, replacement)
+
+
+def _eval_stirling1(n, k):
+    if n == k == 0:
+        return S.One
+    if 0 in (n, k):
+        return S.Zero
+
+    # some special values
+    if n == k:
+        return S.One
+    elif k == n - 1:
+        return binomial(n, 2)
+    elif k == n - 2:
+        return (3*n - 1)*binomial(n, 3)/4
+    elif k == n - 3:
+        return binomial(n, 2)*binomial(n, 4)
+
+    return _stirling1(n, k)
+
+
+@cacheit
+def _stirling1(n, k):
+    row = [0, 1]+[0]*(k-1) # for n = 1
+    for i in range(2, n+1):
+        for j in range(min(k,i), 0, -1):
+            row[j] = (i-1) * row[j] + row[j-1]
+    return Integer(row[k])
+
+
+def _eval_stirling2(n, k):
+    if n == k == 0:
+        return S.One
+    if 0 in (n, k):
+        return S.Zero
+
+    # some special values
+    if n == k:
+        return S.One
+    elif k == n - 1:
+        return binomial(n, 2)
+    elif k == 1:
+        return S.One
+    elif k == 2:
+        return Integer(2**(n - 1) - 1)
+
+    return _stirling2(n, k)
+
+
+@cacheit
+def _stirling2(n, k):
+    row = [0, 1]+[0]*(k-1) # for n = 1
+    for i in range(2, n+1):
+        for j in range(min(k,i), 0, -1):
+            row[j] = j * row[j] + row[j-1]
+    return Integer(row[k])
+
+
+def stirling(n, k, d=None, kind=2, signed=False):
+    r"""Return Stirling number $S(n, k)$ of the first or second (default) kind.
+
+    The sum of all Stirling numbers of the second kind for $k = 1$
+    through $n$ is ``bell(n)``. The recurrence relationship for these numbers
+    is:
+
+    .. math :: {0 \brace 0} = 1; {n \brace 0} = {0 \brace k} = 0;
+
+    .. math :: {{n+1} \brace k} = j {n \brace k} + {n \brace {k-1}}
+
+    where $j$ is:
+        $n$ for Stirling numbers of the first kind,
+        $-n$ for signed Stirling numbers of the first kind,
+        $k$ for Stirling numbers of the second kind.
+
+    The first kind of Stirling number counts the number of permutations of
+    ``n`` distinct items that have ``k`` cycles; the second kind counts the
+    ways in which ``n`` distinct items can be partitioned into ``k`` parts.
+    If ``d`` is given, the "reduced Stirling number of the second kind" is
+    returned: $S^{d}(n, k) = S(n - d + 1, k - d + 1)$ with $n \ge k \ge d$.
+    (This counts the ways to partition $n$ consecutive integers into $k$
+    groups with no pairwise difference less than $d$. See example below.)
+
+    To obtain the signed Stirling numbers of the first kind, use keyword
+    ``signed=True``. Using this keyword automatically sets ``kind`` to 1.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import stirling, bell
+    >>> from sympy.combinatorics import Permutation
+    >>> from sympy.utilities.iterables import multiset_partitions, permutations
+
+    First kind (unsigned by default):
+
+    >>> [stirling(6, i, kind=1) for i in range(7)]
+    [0, 120, 274, 225, 85, 15, 1]
+    >>> perms = list(permutations(range(4)))
+    >>> [sum(Permutation(p).cycles == i for p in perms) for i in range(5)]
+    [0, 6, 11, 6, 1]
+    >>> [stirling(4, i, kind=1) for i in range(5)]
+    [0, 6, 11, 6, 1]
+
+    First kind (signed):
+
+    >>> [stirling(4, i, signed=True) for i in range(5)]
+    [0, -6, 11, -6, 1]
+
+    Second kind:
+
+    >>> [stirling(10, i) for i in range(12)]
+    [0, 1, 511, 9330, 34105, 42525, 22827, 5880, 750, 45, 1, 0]
+    >>> sum(_) == bell(10)
+    True
+    >>> len(list(multiset_partitions(range(4), 2))) == stirling(4, 2)
+    True
+
+    Reduced second kind:
+
+    >>> from sympy import subsets, oo
+    >>> def delta(p):
+    ...    if len(p) == 1:
+    ...        return oo
+    ...    return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    >>> parts = multiset_partitions(range(5), 3)
+    >>> d = 2
+    >>> sum(1 for p in parts if all(delta(i) >= d for i in p))
+    7
+    >>> stirling(5, 3, 2)
+    7
+
+    See Also
+    ========
+    sympy.utilities.iterables.multiset_partitions
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    .. [2] https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+
+    """
+    # TODO: make this a class like bell()
+
+    n = as_int(n)
+    k = as_int(k)
+    if n < 0:
+        raise ValueError('n must be nonnegative')
+    if k > n:
+        return S.Zero
+    if d:
+        # assert k >= d
+        # kind is ignored -- only kind=2 is supported
+        return _eval_stirling2(n - d + 1, k - d + 1)
+    elif signed:
+        # kind is ignored -- only kind=1 is supported
+        return S.NegativeOne**(n - k)*_eval_stirling1(n, k)
+
+    if kind == 1:
+        return _eval_stirling1(n, k)
+    elif kind == 2:
+        return _eval_stirling2(n, k)
+    else:
+        raise ValueError('kind must be 1 or 2, not %s' % k)
+
+
+@cacheit
+def _nT(n, k):
+    """Return the partitions of ``n`` items into ``k`` parts. This
+    is used by ``nT`` for the case when ``n`` is an integer."""
+    # really quick exits
+    if k > n or k < 0:
+        return 0
+    if k in (1, n):
+        return 1
+    if k == 0:
+        return 0
+    # exits that could be done below but this is quicker
+    if k == 2:
+        return n//2
+    d = n - k
+    if d <= 3:
+        return d
+    # quick exit
+    if 3*k >= n:  # or, equivalently, 2*k >= d
+        # all the information needed in this case
+        # will be in the cache needed to calculate
+        # partition(d), so...
+        # update cache
+        tot = _partition_rec(d)
+        # and correct for values not needed
+        if d - k > 0:
+            tot -= sum(_partition_rec.fetch_item(slice(d - k)))
+        return tot
+    # regular exit
+    # nT(n, k) = Sum(nT(n - k, m), (m, 1, k));
+    # calculate needed nT(i, j) values
+    p = [1]*d
+    for i in range(2, k + 1):
+        for m  in range(i + 1, d):
+            p[m] += p[m - i]
+        d -= 1
+    # if p[0] were appended to the end of p then the last
+    # k values of p are the nT(n, j) values for 0 < j < k in reverse
+    # order p[-1] = nT(n, 1), p[-2] = nT(n, 2), etc.... Instead of
+    # putting the 1 from p[0] there, however, it is simply added to
+    # the sum below which is valid for 1 < k <= n//2
+    return (1 + sum(p[1 - k:]))
+
+
+def nT(n, k=None):
+    """Return the number of ``k``-sized partitions of ``n`` items.
+
+    Possible values for ``n``:
+
+        integer - ``n`` identical items
+
+        sequence - converted to a multiset internally
+
+        multiset - {element: multiplicity}
+
+    Note: the convention for ``nT`` is different than that of ``nC`` and
+    ``nP`` in that
+    here an integer indicates ``n`` *identical* items instead of a set of
+    length ``n``; this is in keeping with the ``partitions`` function which
+    treats its integer-``n`` input like a list of ``n`` 1s. One can use
+    ``range(n)`` for ``n`` to indicate ``n`` distinct items.
+
+    If ``k`` is None then the total number of ways to partition the elements
+    represented in ``n`` will be returned.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.combinatorial.numbers import nT
+
+    Partitions of the given multiset:
+
+    >>> [nT('aabbc', i) for i in range(1, 7)]
+    [1, 8, 11, 5, 1, 0]
+    >>> nT('aabbc') == sum(_)
+    True
+
+    >>> [nT("mississippi", i) for i in range(1, 12)]
+    [1, 74, 609, 1521, 1768, 1224, 579, 197, 50, 9, 1]
+
+    Partitions when all items are identical:
+
+    >>> [nT(5, i) for i in range(1, 6)]
+    [1, 2, 2, 1, 1]
+    >>> nT('1'*5) == sum(_)
+    True
+
+    When all items are different:
+
+    >>> [nT(range(5), i) for i in range(1, 6)]
+    [1, 15, 25, 10, 1]
+    >>> nT(range(5)) == sum(_)
+    True
+
+    Partitions of an integer expressed as a sum of positive integers:
+
+    >>> from sympy import partition
+    >>> partition(4)
+    5
+    >>> nT(4, 1) + nT(4, 2) + nT(4, 3) + nT(4, 4)
+    5
+    >>> nT('1'*4)
+    5
+
+    See Also
+    ========
+    sympy.utilities.iterables.partitions
+    sympy.utilities.iterables.multiset_partitions
+    sympy.functions.combinatorial.numbers.partition
+
+    References
+    ==========
+
+    .. [1] https://web.archive.org/web/20210507012732/https://teaching.csse.uwa.edu.au/units/CITS7209/partition.pdf
+
+    """
+
+    if isinstance(n, SYMPY_INTS):
+        # n identical items
+        if k is None:
+            return partition(n)
+        if isinstance(k, SYMPY_INTS):
+            n = as_int(n)
+            k = as_int(k)
+            return Integer(_nT(n, k))
+    if not isinstance(n, _MultisetHistogram):
+        try:
+            # if n contains hashable items there is some
+            # quick handling that can be done
+            u = len(set(n))
+            if u <= 1:
+                return nT(len(n), k)
+            elif u == len(n):
+                n = range(u)
+            raise TypeError
+        except TypeError:
+            n = _multiset_histogram(n)
+    N = n[_N]
+    if k is None and N == 1:
+        return 1
+    if k in (1, N):
+        return 1
+    if k == 2 or N == 2 and k is None:
+        m, r = divmod(N, 2)
+        rv = sum(nC(n, i) for i in range(1, m + 1))
+        if not r:
+            rv -= nC(n, m)//2
+        if k is None:
+            rv += 1  # for k == 1
+        return rv
+    if N == n[_ITEMS]:
+        # all distinct
+        if k is None:
+            return bell(N)
+        return stirling(N, k)
+    m = MultisetPartitionTraverser()
+    if k is None:
+        return m.count_partitions(n[_M])
+    # MultisetPartitionTraverser does not have a range-limited count
+    # method, so need to enumerate and count
+    tot = 0
+    for discard in m.enum_range(n[_M], k-1, k):
+        tot += 1
+    return tot
+
+
+#-----------------------------------------------------------------------------#
+#                                                                             #
+#                          Motzkin numbers                                    #
+#                                                                             #
+#-----------------------------------------------------------------------------#
+
+
+class motzkin(DefinedFunction):
+    """
+    The nth Motzkin number is the number
+    of ways of drawing non-intersecting chords
+    between n points on a circle (not necessarily touching
+    every point by a chord). The Motzkin numbers are named
+    after Theodore Motzkin and have diverse applications
+    in geometry, combinatorics and number theory.
+
+    Motzkin numbers are the integer sequence defined by the
+    initial terms `M_0 = 1`, `M_1 = 1` and the two-term recurrence relation
+    `M_n = \frac{2*n + 1}{n + 2} * M_{n-1} + \frac{3n - 3}{n + 2} * M_{n-2}`.
+
+
+    Examples
+    ========
+
+    >>> from sympy import motzkin
+
+    >>> motzkin.is_motzkin(5)
+    False
+    >>> motzkin.find_motzkin_numbers_in_range(2,300)
+    [2, 4, 9, 21, 51, 127]
+    >>> motzkin.find_motzkin_numbers_in_range(2,900)
+    [2, 4, 9, 21, 51, 127, 323, 835]
+    >>> motzkin.find_first_n_motzkins(10)
+    [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Motzkin_number
+    .. [2] https://mathworld.wolfram.com/MotzkinNumber.html
+
+    """
+
+    @staticmethod
+    def is_motzkin(n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            return False
+        if n > 0:
+            if n in (1, 2):
+                return True
+
+            tn1 = 1
+            tn = 2
+            i = 3
+            while tn < n:
+                a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+                i += 1
+                tn1 = tn
+                tn = a
+
+            if tn == n:
+                return True
+            else:
+                return False
+
+        else:
+            return False
+
+    @staticmethod
+    def find_motzkin_numbers_in_range(x, y):
+        if 0 <= x <= y:
+            motzkins = []
+            if x <= 1 <= y:
+                motzkins.append(1)
+            tn1 = 1
+            tn = 2
+            i = 3
+            while tn <= y:
+                if tn >= x:
+                    motzkins.append(tn)
+                a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+                i += 1
+                tn1 = tn
+                tn = int(a)
+
+            return motzkins
+
+        else:
+            raise ValueError('The provided range is not valid. This condition should satisfy x <= y')
+
+    @staticmethod
+    def find_first_n_motzkins(n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            raise ValueError('The provided number must be a positive integer')
+        if n < 0:
+            raise ValueError('The provided number must be a positive integer')
+        motzkins = [1]
+        if n >= 1:
+            motzkins.append(1)
+        tn1 = 1
+        tn = 2
+        i = 3
+        while i <= n:
+            motzkins.append(tn)
+            a = ((2*i + 1)*tn + (3*i - 3)*tn1)/(i + 2)
+            i += 1
+            tn1 = tn
+            tn = int(a)
+
+        return motzkins
+
+    @staticmethod
+    @recurrence_memo([S.One, S.One])
+    def _motzkin(n, prev):
+        return ((2*n + 1)*prev[-1] + (3*n - 3)*prev[-2]) // (n + 2)
+
+    @classmethod
+    def eval(cls, n):
+        try:
+            n = as_int(n)
+        except ValueError:
+            raise ValueError('The provided number must be a positive integer')
+        if n < 0:
+            raise ValueError('The provided number must be a positive integer')
+        return Integer(cls._motzkin(n - 1))
+
+
+def nD(i=None, brute=None, *, n=None, m=None):
+    """return the number of derangements for: ``n`` unique items, ``i``
+    items (as a sequence or multiset), or multiplicities, ``m`` given
+    as a sequence or multiset.
+
+    Examples
+    ========
+
+    >>> from sympy.utilities.iterables import generate_derangements as enum
+    >>> from sympy.functions.combinatorial.numbers import nD
+
+    A derangement ``d`` of sequence ``s`` has all ``d[i] != s[i]``:
+
+    >>> set([''.join(i) for i in enum('abc')])
+    {'bca', 'cab'}
+    >>> nD('abc')
+    2
+
+    Input as iterable or dictionary (multiset form) is accepted:
+
+    >>> assert nD([1, 2, 2, 3, 3, 3]) == nD({1: 1, 2: 2, 3: 3})
+
+    By default, a brute-force enumeration and count of multiset permutations
+    is only done if there are fewer than 9 elements. There may be cases when
+    there is high multiplicity with few unique elements that will benefit
+    from a brute-force enumeration, too. For this reason, the `brute`
+    keyword (default None) is provided. When False, the brute-force
+    enumeration will never be used. When True, it will always be used.
+
+    >>> nD('1111222233', brute=True)
+    44
+
+    For convenience, one may specify ``n`` distinct items using the
+    ``n`` keyword:
+
+    >>> assert nD(n=3) == nD('abc') == 2
+
+    Since the number of derangments depends on the multiplicity of the
+    elements and not the elements themselves, it may be more convenient
+    to give a list or multiset of multiplicities using keyword ``m``:
+
+    >>> assert nD('abc') == nD(m=(1,1,1)) == nD(m={1:3}) == 2
+
+    """
+    from sympy.integrals.integrals import integrate
+    from sympy.functions.special.polynomials import laguerre
+    from sympy.abc import x
+    def ok(x):
+        if not isinstance(x, SYMPY_INTS):
+            raise TypeError('expecting integer values')
+        if x < 0:
+            raise ValueError('value must not be negative')
+        return True
+
+    if (i, n, m).count(None) != 2:
+        raise ValueError('enter only 1 of i, n, or m')
+    if i is not None:
+        if isinstance(i, SYMPY_INTS):
+            raise TypeError('items must be a list or dictionary')
+        if not i:
+            return S.Zero
+        if type(i) is not dict:
+            s = list(i)
+            ms = multiset(s)
+        elif type(i) is dict:
+            all(ok(_) for _ in i.values())
+            ms = {k: v for k, v in i.items() if v}
+            s = None
+        if not ms:
+            return S.Zero
+        N = sum(ms.values())
+        counts = multiset(ms.values())
+        nkey = len(ms)
+    elif n is not None:
+        ok(n)
+        if not n:
+            return S.Zero
+        return subfactorial(n)
+    elif m is not None:
+        if isinstance(m, dict):
+            all(ok(i) and ok(j) for i, j in m.items())
+            counts = {k: v for k, v in m.items() if k*v}
+        elif iterable(m) or isinstance(m, str):
+            m = list(m)
+            all(ok(i) for i in m)
+            counts = multiset([i for i in m if i])
+        else:
+            raise TypeError('expecting iterable')
+        if not counts:
+            return S.Zero
+        N = sum(k*v for k, v in counts.items())
+        nkey = sum(counts.values())
+        s = None
+    big = int(max(counts))
+    if big == 1:  # no repetition
+        return subfactorial(nkey)
+    nval = len(counts)
+    if big*2 > N:
+        return S.Zero
+    if big*2 == N:
+        if nkey == 2 and nval == 1:
+            return S.One  # aaabbb
+        if nkey - 1 == big:  # one element repeated
+            return factorial(big)  # e.g. abc part of abcddd
+    if N < 9 and brute is None or brute:
+        # for all possibilities, this was found to be faster
+        if s is None:
+            s = []
+            i = 0
+            for m, v in counts.items():
+                for j in range(v):
+                    s.extend([i]*m)
+                    i += 1
+        return Integer(sum(1 for i in multiset_derangements(s)))
+    from sympy.functions.elementary.exponential import exp
+    return Integer(abs(integrate(exp(-x)*Mul(*[
+        laguerre(i, x)**m for i, m in counts.items()]), (x, 0, oo))))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73873dfda0cf08f1ff2d605e3b770a9891737be1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_factorials.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_factorials.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e029fad08da4aface523c3422b42455a049ec611
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_factorials.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70e94fb0718e3cca0890d17bc3d748643d9e4f41
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/__pycache__/test_comb_numbers.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:13cebb940a20581561cdc327ea893b8c43a4292374cfaf95d5c603aed7206c82
+size 104167
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e3986c56736cccec0b3370007e047a1f38f06d1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_factorials.py
@@ -0,0 +1,653 @@
+from sympy.concrete.products import Product
+from sympy.core.function import expand_func
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core import EulerGamma
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.factorials import (ff, rf, binomial, factorial, factorial2)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.gamma_functions import (gamma, polygamma)
+from sympy.polys.polytools import Poly
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.combinatorial.factorials import subfactorial
+from sympy.functions.special.gamma_functions import uppergamma
+from sympy.testing.pytest import XFAIL, raises, slow
+
+#Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+
+def test_rf_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert rf(nan, y) is nan
+    assert rf(x, nan) is nan
+
+    assert unchanged(rf, x, y)
+
+    assert rf(oo, 0) == 1
+    assert rf(-oo, 0) == 1
+
+    assert rf(oo, 6) is oo
+    assert rf(-oo, 7) is -oo
+    assert rf(-oo, 6) is oo
+
+    assert rf(oo, -6) is oo
+    assert rf(-oo, -7) is oo
+
+    assert rf(-1, pi) == 0
+    assert rf(-5, 1 + I) == 0
+
+    assert unchanged(rf, -3, k)
+    assert unchanged(rf, x, Symbol('k', integer=False))
+    assert rf(-3, Symbol('k', integer=False)) == 0
+    assert rf(Symbol('x', negative=True, integer=True), Symbol('k', integer=False)) == 0
+
+    assert rf(x, 0) == 1
+    assert rf(x, 1) == x
+    assert rf(x, 2) == x*(x + 1)
+    assert rf(x, 3) == x*(x + 1)*(x + 2)
+    assert rf(x, 5) == x*(x + 1)*(x + 2)*(x + 3)*(x + 4)
+
+    assert rf(x, -1) == 1/(x - 1)
+    assert rf(x, -2) == 1/((x - 1)*(x - 2))
+    assert rf(x, -3) == 1/((x - 1)*(x - 2)*(x - 3))
+
+    assert rf(1, 100) == factorial(100)
+
+    assert rf(x**2 + 3*x, 2) == (x**2 + 3*x)*(x**2 + 3*x + 1)
+    assert isinstance(rf(x**2 + 3*x, 2), Mul)
+    assert rf(x**3 + x, -2) == 1/((x**3 + x - 1)*(x**3 + x - 2))
+
+    assert rf(Poly(x**2 + 3*x, x), 2) == Poly(x**4 + 8*x**3 + 19*x**2 + 12*x, x)
+    assert isinstance(rf(Poly(x**2 + 3*x, x), 2), Poly)
+    raises(ValueError, lambda: rf(Poly(x**2 + 3*x, x, y), 2))
+    assert rf(Poly(x**3 + x, x), -2) == 1/(x**6 - 9*x**5 + 35*x**4 - 75*x**3 + 94*x**2 - 66*x + 20)
+    raises(ValueError, lambda: rf(Poly(x**3 + x, x, y), -2))
+
+    assert rf(x, m).is_integer is None
+    assert rf(n, k).is_integer is None
+    assert rf(n, m).is_integer is True
+    assert rf(n, k + pi).is_integer is False
+    assert rf(n, m + pi).is_integer is False
+    assert rf(pi, m).is_integer is False
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+            for j in range(-5,5):
+                assert o(i, j) == r(i, j), (o, n, i, j)
+    check(x, k, rf, ff)
+    check(x, k, rf, binomial)
+    check(n, k, rf, factorial)
+    check(x, y, rf, factorial)
+    check(x, y, rf, binomial)
+
+    assert rf(x, k).rewrite(ff) == ff(x + k - 1, k)
+    assert rf(x, k).rewrite(gamma) == Piecewise(
+        (gamma(k + x)/gamma(x), x > 0),
+        ((-1)**k*gamma(1 - x)/gamma(-k - x + 1), True))
+    assert rf(5, k).rewrite(gamma) == gamma(k + 5)/24
+    assert rf(x, k).rewrite(binomial) == factorial(k)*binomial(x + k - 1, k)
+    assert rf(n, k).rewrite(factorial) == Piecewise(
+        (factorial(k + n - 1)/factorial(n - 1), n > 0),
+        ((-1)**k*factorial(-n)/factorial(-k - n), True))
+    assert rf(5, k).rewrite(factorial) == factorial(k + 4)/24
+    assert rf(x, y).rewrite(factorial) == rf(x, y)
+    assert rf(x, y).rewrite(binomial) == rf(x, y)
+
+    import random
+    from mpmath import rf as mpmath_rf
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        assert (abs(mpmath_rf(x, k) - rf(x, k)) < 10**(-15))
+
+
+def test_ff_eval_apply():
+    x, y = symbols('x,y')
+    n, k = symbols('n k', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+
+    assert ff(nan, y) is nan
+    assert ff(x, nan) is nan
+
+    assert unchanged(ff, x, y)
+
+    assert ff(oo, 0) == 1
+    assert ff(-oo, 0) == 1
+
+    assert ff(oo, 6) is oo
+    assert ff(-oo, 7) is -oo
+    assert ff(-oo, 6) is oo
+
+    assert ff(oo, -6) is oo
+    assert ff(-oo, -7) is oo
+
+    assert ff(x, 0) == 1
+    assert ff(x, 1) == x
+    assert ff(x, 2) == x*(x - 1)
+    assert ff(x, 3) == x*(x - 1)*(x - 2)
+    assert ff(x, 5) == x*(x - 1)*(x - 2)*(x - 3)*(x - 4)
+
+    assert ff(x, -1) == 1/(x + 1)
+    assert ff(x, -2) == 1/((x + 1)*(x + 2))
+    assert ff(x, -3) == 1/((x + 1)*(x + 2)*(x + 3))
+
+    assert ff(100, 100) == factorial(100)
+
+    assert ff(2*x**2 - 5*x, 2) == (2*x**2  - 5*x)*(2*x**2 - 5*x - 1)
+    assert isinstance(ff(2*x**2 - 5*x, 2), Mul)
+    assert ff(x**2 + 3*x, -2) == 1/((x**2 + 3*x + 1)*(x**2 + 3*x + 2))
+
+    assert ff(Poly(2*x**2 - 5*x, x), 2) == Poly(4*x**4 - 28*x**3 + 59*x**2 - 35*x, x)
+    assert isinstance(ff(Poly(2*x**2 - 5*x, x), 2), Poly)
+    raises(ValueError, lambda: ff(Poly(2*x**2 - 5*x, x, y), 2))
+    assert ff(Poly(x**2 + 3*x, x), -2) == 1/(x**4 + 12*x**3 + 49*x**2 + 78*x + 40)
+    raises(ValueError, lambda: ff(Poly(x**2 + 3*x, x, y), -2))
+
+
+    assert ff(x, m).is_integer is None
+    assert ff(n, k).is_integer is None
+    assert ff(n, m).is_integer is True
+    assert ff(n, k + pi).is_integer is False
+    assert ff(n, m + pi).is_integer is False
+    assert ff(pi, m).is_integer is False
+
+    assert isinstance(ff(x, x), ff)
+    assert ff(n, n) == factorial(n)
+
+    def check(x, k, o, n):
+        a, b = Dummy(), Dummy()
+        r = lambda x, k: o(a, b).rewrite(n).subs({a:x,b:k})
+        for i in range(-5,5):
+            for j in range(-5,5):
+                assert o(i, j) == r(i, j), (o, n)
+    check(x, k, ff, rf)
+    check(x, k, ff, gamma)
+    check(n, k, ff, factorial)
+    check(x, k, ff, binomial)
+    check(x, y, ff, factorial)
+    check(x, y, ff, binomial)
+
+    assert ff(x, k).rewrite(rf) == rf(x - k + 1, k)
+    assert ff(x, k).rewrite(gamma) == Piecewise(
+        (gamma(x + 1)/gamma(-k + x + 1), x >= 0),
+        ((-1)**k*gamma(k - x)/gamma(-x), True))
+    assert ff(5, k).rewrite(gamma) == 120/gamma(6 - k)
+    assert ff(n, k).rewrite(factorial) == Piecewise(
+        (factorial(n)/factorial(-k + n), n >= 0),
+        ((-1)**k*factorial(k - n - 1)/factorial(-n - 1), True))
+    assert ff(5, k).rewrite(factorial) == 120/factorial(5 - k)
+    assert ff(x, k).rewrite(binomial) == factorial(k) * binomial(x, k)
+    assert ff(x, y).rewrite(factorial) == ff(x, y)
+    assert ff(x, y).rewrite(binomial) == ff(x, y)
+
+    import random
+    from mpmath import ff as mpmath_ff
+    for i in range(100):
+        x = -500 + 500 * random.random()
+        k = -500 + 500 * random.random()
+        a = mpmath_ff(x, k)
+        b = ff(x, k)
+        assert (abs(a - b) < abs(a) * 10**(-15))
+
+
+def test_rf_ff_eval_hiprec():
+    maple = Float('6.9109401292234329956525265438452')
+    us = ff(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('6.8261540131125511557924466355367')
+    us = rf(18, Rational(2, 3)).evalf(32)
+    assert abs(us - maple)/us < 1e-31
+
+    maple = Float('34.007346127440197150854651814225')
+    us = rf(Float('4.4', 32), Float('2.2', 32))
+    assert abs(us - maple)/us < 1e-31
+
+
+def test_rf_lambdify_mpmath():
+    from sympy.utilities.lambdify import lambdify
+    x, y = symbols('x,y')
+    f = lambdify((x,y), rf(x, y), 'mpmath')
+    maple = Float('34.007346127440197')
+    us = f(4.4, 2.2)
+    assert abs(us - maple)/us < 1e-15
+
+
+def test_factorial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    r = Symbol('r', integer=False)
+    s = Symbol('s', integer=False, negative=True)
+    t = Symbol('t', nonnegative=True)
+    u = Symbol('u', noninteger=True)
+
+    assert factorial(-2) is zoo
+    assert factorial(0) == 1
+    assert factorial(7) == 5040
+    assert factorial(19) == 121645100408832000
+    assert factorial(31) == 8222838654177922817725562880000000
+    assert factorial(n).func == factorial
+    assert factorial(2*n).func == factorial
+
+    assert factorial(x).is_integer is None
+    assert factorial(n).is_integer is None
+    assert factorial(k).is_integer
+    assert factorial(r).is_integer is None
+
+    assert factorial(n).is_positive is None
+    assert factorial(k).is_positive
+
+    assert factorial(x).is_real is None
+    assert factorial(n).is_real is None
+    assert factorial(k).is_real is True
+    assert factorial(r).is_real is None
+    assert factorial(s).is_real is True
+    assert factorial(t).is_real is True
+    assert factorial(u).is_real is True
+
+    assert factorial(x).is_composite is None
+    assert factorial(n).is_composite is None
+    assert factorial(k).is_composite is None
+    assert factorial(k + 3).is_composite is True
+    assert factorial(r).is_composite is None
+    assert factorial(s).is_composite is None
+    assert factorial(t).is_composite is None
+    assert factorial(u).is_composite is None
+
+    assert factorial(oo) is oo
+
+
+def test_factorial_Mod():
+    pr = Symbol('pr', prime=True)
+    p, q = 10**9 + 9, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+    assert Mod(factorial(pr - 1), pr) == pr - 1
+    assert Mod(factorial(pr - 1), -pr) == -1
+    assert Mod(factorial(r - 1, evaluate=False), r) == 0
+    assert Mod(factorial(s - 1, evaluate=False), s) == 0
+    assert Mod(factorial(p - 1, evaluate=False), p) == p - 1
+    assert Mod(factorial(q - 1, evaluate=False), q) == q - 1
+    assert Mod(factorial(p - 50, evaluate=False), p) == 854928834
+    assert Mod(factorial(q - 1800, evaluate=False), q) == 905504050
+    assert Mod(factorial(153, evaluate=False), r) == Mod(factorial(153), r)
+    assert Mod(factorial(255, evaluate=False), s) == Mod(factorial(255), s)
+    assert Mod(factorial(4, evaluate=False), 3) == S.Zero
+    assert Mod(factorial(5, evaluate=False), 6) == S.Zero
+
+
+def test_factorial_diff():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).diff(n) == \
+        gamma(1 + n)*polygamma(0, 1 + n)
+    assert factorial(n**2).diff(n) == \
+        2*n*gamma(1 + n**2)*polygamma(0, 1 + n**2)
+    raises(ArgumentIndexError, lambda: factorial(n**2).fdiff(2))
+
+
+def test_factorial_series():
+    n = Symbol('n', integer=True)
+
+    assert factorial(n).series(n, 0, 3) == \
+        1 - n*EulerGamma + n**2*(EulerGamma**2/2 + pi**2/12) + O(n**3)
+
+
+def test_factorial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+
+    assert factorial(n).rewrite(gamma) == gamma(n + 1)
+    _i = Dummy('i')
+    assert factorial(k).rewrite(Product).dummy_eq(Product(_i, (_i, 1, k)))
+    assert factorial(n).rewrite(Product) == factorial(n)
+
+
+def test_factorial2():
+    n = Symbol('n', integer=True)
+
+    assert factorial2(-1) == 1
+    assert factorial2(0) == 1
+    assert factorial2(7) == 105
+    assert factorial2(8) == 384
+
+    # The following is exhaustive
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tte = Symbol('tte', even=True, nonnegative=True)
+    tpe = Symbol('tpe', even=True, positive=True)
+    tto = Symbol('tto', odd=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tfe = Symbol('tfe', even=True, nonnegative=False)
+    tfo = Symbol('tfo', odd=True, nonnegative=False)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('fn', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nn')
+    z = Symbol('z', zero=True)
+    #Solves and Fixes Issue #10388 - This is the updated test for the same solved issue
+    raises(ValueError, lambda: factorial2(oo))
+    raises(ValueError, lambda: factorial2(Rational(5, 2)))
+    raises(ValueError, lambda: factorial2(-4))
+    assert factorial2(n).is_integer is None
+    assert factorial2(tt - 1).is_integer
+    assert factorial2(tte - 1).is_integer
+    assert factorial2(tpe - 3).is_integer
+    assert factorial2(tto - 4).is_integer
+    assert factorial2(tto - 2).is_integer
+    assert factorial2(tf).is_integer is None
+    assert factorial2(tfe).is_integer is None
+    assert factorial2(tfo).is_integer is None
+    assert factorial2(ft).is_integer is None
+    assert factorial2(ff).is_integer is None
+    assert factorial2(fn).is_integer is None
+    assert factorial2(nt).is_integer is None
+    assert factorial2(nf).is_integer is None
+    assert factorial2(nn).is_integer is None
+
+    assert factorial2(n).is_positive is None
+    assert factorial2(tt - 1).is_positive is True
+    assert factorial2(tte - 1).is_positive is True
+    assert factorial2(tpe - 3).is_positive is True
+    assert factorial2(tpe - 1).is_positive is True
+    assert factorial2(tto - 2).is_positive is True
+    assert factorial2(tto - 1).is_positive is True
+    assert factorial2(tf).is_positive is None
+    assert factorial2(tfe).is_positive is None
+    assert factorial2(tfo).is_positive is None
+    assert factorial2(ft).is_positive is None
+    assert factorial2(ff).is_positive is None
+    assert factorial2(fn).is_positive is None
+    assert factorial2(nt).is_positive is None
+    assert factorial2(nf).is_positive is None
+    assert factorial2(nn).is_positive is None
+
+    assert factorial2(tt).is_even is None
+    assert factorial2(tt).is_odd is None
+    assert factorial2(tte).is_even is None
+    assert factorial2(tte).is_odd is None
+    assert factorial2(tte + 2).is_even is True
+    assert factorial2(tpe).is_even is True
+    assert factorial2(tpe).is_odd is False
+    assert factorial2(tto).is_odd is True
+    assert factorial2(tf).is_even is None
+    assert factorial2(tf).is_odd is None
+    assert factorial2(tfe).is_even is None
+    assert factorial2(tfe).is_odd is None
+    assert factorial2(tfo).is_even is False
+    assert factorial2(tfo).is_odd is None
+    assert factorial2(z).is_even is False
+    assert factorial2(z).is_odd is True
+
+
+def test_factorial2_rewrite():
+    n = Symbol('n', integer=True)
+    assert factorial2(n).rewrite(gamma) == \
+        2**(n/2)*Piecewise((1, Eq(Mod(n, 2), 0)), (sqrt(2)/sqrt(pi), Eq(Mod(n, 2), 1)))*gamma(n/2 + 1)
+    assert factorial2(2*n).rewrite(gamma) == 2**n*gamma(n + 1)
+    assert factorial2(2*n + 1).rewrite(gamma) == \
+        sqrt(2)*2**(n + S.Half)*gamma(n + Rational(3, 2))/sqrt(pi)
+
+
+def test_binomial():
+    x = Symbol('x')
+    n = Symbol('n', integer=True)
+    nz = Symbol('nz', integer=True, nonzero=True)
+    k = Symbol('k', integer=True)
+    kp = Symbol('kp', integer=True, positive=True)
+    kn = Symbol('kn', integer=True, negative=True)
+    u = Symbol('u', negative=True)
+    v = Symbol('v', nonnegative=True)
+    p = Symbol('p', positive=True)
+    z = Symbol('z', zero=True)
+    nt = Symbol('nt', integer=False)
+    kt = Symbol('kt', integer=False)
+    a = Symbol('a', integer=True, nonnegative=True)
+    b = Symbol('b', integer=True, nonnegative=True)
+
+    assert binomial(0, 0) == 1
+    assert binomial(1, 1) == 1
+    assert binomial(10, 10) == 1
+    assert binomial(n, z) == 1
+    assert binomial(1, 2) == 0
+    assert binomial(-1, 2) == 1
+    assert binomial(1, -1) == 0
+    assert binomial(-1, 1) == -1
+    assert binomial(-1, -1) == 0
+    assert binomial(S.Half, S.Half) == 1
+    assert binomial(-10, 1) == -10
+    assert binomial(-10, 7) == -11440
+    assert binomial(n, -1) == 0 # holds for all integers (negative, zero, positive)
+    assert binomial(kp, -1) == 0
+    assert binomial(nz, 0) == 1
+    assert expand_func(binomial(n, 1)) == n
+    assert expand_func(binomial(n, 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 2)) == n*(n - 1)/2
+    assert expand_func(binomial(n, n - 1)) == n
+    assert binomial(n, 3).func == binomial
+    assert binomial(n, 3).expand(func=True) ==  n**3/6 - n**2/2 + n/3
+    assert expand_func(binomial(n, 3)) ==  n*(n - 2)*(n - 1)/6
+    assert binomial(n, n).func == binomial # e.g. (-1, -1) == 0, (2, 2) == 1
+    assert binomial(n, n + 1).func == binomial  # e.g. (-1, 0) == 1
+    assert binomial(kp, kp + 1) == 0
+    assert binomial(kn, kn) == 0 # issue #14529
+    assert binomial(n, u).func == binomial
+    assert binomial(kp, u).func == binomial
+    assert binomial(n, p).func == binomial
+    assert binomial(n, k).func == binomial
+    assert binomial(n, n + p).func == binomial
+    assert binomial(kp, kp + p).func == binomial
+
+    assert expand_func(binomial(n, n - 3)) == n*(n - 2)*(n - 1)/6
+
+    assert binomial(n, k).is_integer
+    assert binomial(nt, k).is_integer is None
+    assert binomial(x, nt).is_integer is False
+
+    assert binomial(gamma(25), 6) == 79232165267303928292058750056084441948572511312165380965440075720159859792344339983120618959044048198214221915637090855535036339620413440000
+    assert binomial(1324, 47) == 906266255662694632984994480774946083064699457235920708992926525848438478406790323869952
+    assert binomial(1735, 43) == 190910140420204130794758005450919715396159959034348676124678207874195064798202216379800
+    assert binomial(2512, 53) == 213894469313832631145798303740098720367984955243020898718979538096223399813295457822575338958939834177325304000
+    assert binomial(3383, 52) == 27922807788818096863529701501764372757272890613101645521813434902890007725667814813832027795881839396839287659777235
+    assert binomial(4321, 51) == 124595639629264868916081001263541480185227731958274383287107643816863897851139048158022599533438936036467601690983780576
+
+    assert binomial(a, b).is_nonnegative is True
+    assert binomial(-1, 2, evaluate=False).is_nonnegative is True
+    assert binomial(10, 5, evaluate=False).is_nonnegative is True
+    assert binomial(10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, -3, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 2, evaluate=False).is_nonnegative is True
+    assert binomial(-10, 1, evaluate=False).is_nonnegative is False
+    assert binomial(-10, 7, evaluate=False).is_nonnegative is False
+
+    # issue #14625
+    for _ in (pi, -pi, nt, v, a):
+        assert binomial(_, _) == 1
+        assert binomial(_, _ - 1) == _
+    assert isinstance(binomial(u, u), binomial)
+    assert isinstance(binomial(u, u - 1), binomial)
+    assert isinstance(binomial(x, x), binomial)
+    assert isinstance(binomial(x, x - 1), binomial)
+
+    #issue #18802
+    assert expand_func(binomial(x + 1, x)) == x + 1
+    assert expand_func(binomial(x, x - 1)) == x
+    assert expand_func(binomial(x + 1, x - 1)) == x*(x + 1)/2
+    assert expand_func(binomial(x**2 + 1, x**2)) == x**2 + 1
+
+    # issue #13980 and #13981
+    assert binomial(-7, -5) == 0
+    assert binomial(-23, -12) == 0
+    assert binomial(Rational(13, 2), -10) == 0
+    assert binomial(-49, -51) == 0
+
+    assert binomial(19, Rational(-7, 2)) == S(-68719476736)/(911337863661225*pi)
+    assert binomial(0, Rational(3, 2)) == S(-2)/(3*pi)
+    assert binomial(-3, Rational(-7, 2)) is zoo
+    assert binomial(kn, kt) is zoo
+
+    assert binomial(nt, kt).func == binomial
+    assert binomial(nt, Rational(15, 6)) == 8*gamma(nt + 1)/(15*sqrt(pi)*gamma(nt - Rational(3, 2)))
+    assert binomial(Rational(20, 3), Rational(-10, 8)) == gamma(Rational(23, 3))/(gamma(Rational(-1, 4))*gamma(Rational(107, 12)))
+    assert binomial(Rational(19, 2), Rational(-7, 2)) == Rational(-1615, 8388608)
+    assert binomial(Rational(-13, 5), Rational(-7, 8)) == gamma(Rational(-8, 5))/(gamma(Rational(-29, 40))*gamma(Rational(1, 8)))
+    assert binomial(Rational(-19, 8), Rational(-13, 5)) == gamma(Rational(-11, 8))/(gamma(Rational(-8, 5))*gamma(Rational(49, 40)))
+
+    # binomial for complexes
+    assert binomial(I, Rational(-89, 8)) == gamma(1 + I)/(gamma(Rational(-81, 8))*gamma(Rational(97, 8) + I))
+    assert binomial(I, 2*I) == gamma(1 + I)/(gamma(1 - I)*gamma(1 + 2*I))
+    assert binomial(-7, I) is zoo
+    assert binomial(Rational(-7, 6), I) == gamma(Rational(-1, 6))/(gamma(Rational(-1, 6) - I)*gamma(1 + I))
+    assert binomial((1+2*I), (1+3*I)) == gamma(2 + 2*I)/(gamma(1 - I)*gamma(2 + 3*I))
+    assert binomial(I, 5) == Rational(1, 3) - I/S(12)
+    assert binomial((2*I + 3), 7) == -13*I/S(63)
+    assert isinstance(binomial(I, n), binomial)
+    assert expand_func(binomial(3, 2, evaluate=False)) == 3
+    assert expand_func(binomial(n, 0, evaluate=False)) == 1
+    assert expand_func(binomial(n, -2, evaluate=False)) == 0
+    assert expand_func(binomial(n, k)) == binomial(n, k)
+
+
+def test_binomial_Mod():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r = 10**7 + 5 # composite modulo
+
+    # A few tests to get coverage
+    # Lucas Theorem
+    assert Mod(binomial(156675, 4433, evaluate=False), p) == Mod(binomial(156675, 4433), p)
+
+    # factorial Mod
+    assert Mod(binomial(1234, 432, evaluate=False), q) == Mod(binomial(1234, 432), q)
+
+    # binomial factorize
+    assert Mod(binomial(253, 113, evaluate=False), r) == Mod(binomial(253, 113), r)
+
+    # using Granville's generalisation of Lucas' Theorem
+    assert Mod(binomial(10**18, 10**12, evaluate=False), p*p) == 3744312326
+
+
+@slow
+def test_binomial_Mod_slow():
+    p, q = 10**5 + 3, 10**9 + 33 # prime modulo
+    r, s = 10**7 + 5, 33333333 # composite modulo
+
+    n, k, m = symbols('n k m')
+    assert (binomial(n, k) % q).subs({n: s, k: p}) == Mod(binomial(s, p), q)
+    assert (binomial(n, k) % m).subs({n: 8, k: 5, m: 13}) == 4
+    assert (binomial(9, k) % 7).subs(k, 2) == 1
+
+    # Lucas Theorem
+    assert Mod(binomial(123456, 43253, evaluate=False), p) == Mod(binomial(123456, 43253), p)
+    assert Mod(binomial(-178911, 237, evaluate=False), p) == Mod(-binomial(178911 + 237 - 1, 237), p)
+    assert Mod(binomial(-178911, 238, evaluate=False), p) == Mod(binomial(178911 + 238 - 1, 238), p)
+
+    # factorial Mod
+    assert Mod(binomial(9734, 451, evaluate=False), q) == Mod(binomial(9734, 451), q)
+    assert Mod(binomial(-10733, 4459, evaluate=False), q) == Mod(binomial(-10733, 4459), q)
+    assert Mod(binomial(-15733, 4458, evaluate=False), q) == Mod(binomial(-15733, 4458), q)
+    assert Mod(binomial(23, -38, evaluate=False), q) is S.Zero
+    assert Mod(binomial(23, 38, evaluate=False), q) is S.Zero
+
+    # binomial factorize
+    assert Mod(binomial(753, 119, evaluate=False), r) == Mod(binomial(753, 119), r)
+    assert Mod(binomial(3781, 948, evaluate=False), s) == Mod(binomial(3781, 948), s)
+    assert Mod(binomial(25773, 1793, evaluate=False), s) == Mod(binomial(25773, 1793), s)
+    assert Mod(binomial(-753, 118, evaluate=False), r) == Mod(binomial(-753, 118), r)
+    assert Mod(binomial(-25773, 1793, evaluate=False), s) == Mod(binomial(-25773, 1793), s)
+
+
+def test_binomial_diff():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert binomial(n, k).diff(n) == \
+        (-polygamma(0, 1 + n - k) + polygamma(0, 1 + n))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(n) == \
+        2*n*(-polygamma(
+            0, 1 + n**2 - k**3) + polygamma(0, 1 + n**2))*binomial(n**2, k**3)
+
+    assert binomial(n, k).diff(k) == \
+        (-polygamma(0, 1 + k) + polygamma(0, 1 + n - k))*binomial(n, k)
+    assert binomial(n**2, k**3).diff(k) == \
+        3*k**2*(-polygamma(
+            0, 1 + k**3) + polygamma(0, 1 + n**2 - k**3))*binomial(n**2, k**3)
+    raises(ArgumentIndexError, lambda: binomial(n, k).fdiff(3))
+
+
+def test_binomial_rewrite():
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+    x = Symbol('x')
+
+    assert binomial(n, k).rewrite(
+        factorial) == factorial(n)/(factorial(k)*factorial(n - k))
+    assert binomial(
+        n, k).rewrite(gamma) == gamma(n + 1)/(gamma(k + 1)*gamma(n - k + 1))
+    assert binomial(n, k).rewrite(ff) == ff(n, k) / factorial(k)
+    assert binomial(n, x).rewrite(ff) == binomial(n, x)
+
+
+@XFAIL
+def test_factorial_simplify_fail():
+    # simplify(factorial(x + 1).diff(x) - ((x + 1)*factorial(x)).diff(x))) == 0
+    from sympy.abc import x
+    assert simplify(x*polygamma(0, x + 1) - x*polygamma(0, x + 2) +
+                    polygamma(0, x + 1) - polygamma(0, x + 2) + 1) == 0
+
+
+def test_subfactorial():
+    assert all(subfactorial(i) == ans for i, ans in enumerate(
+        [1, 0, 1, 2, 9, 44, 265, 1854, 14833, 133496]))
+    assert subfactorial(oo) is oo
+    assert subfactorial(nan) is nan
+    assert subfactorial(23) == 9510425471055777937262
+    assert unchanged(subfactorial, 2.2)
+
+    x = Symbol('x')
+    assert subfactorial(x).rewrite(uppergamma) == uppergamma(x + 1, -1)/S.Exp1
+
+    tt = Symbol('tt', integer=True, nonnegative=True)
+    tf = Symbol('tf', integer=True, nonnegative=False)
+    tn = Symbol('tf', integer=True)
+    ft = Symbol('ft', integer=False, nonnegative=True)
+    ff = Symbol('ff', integer=False, nonnegative=False)
+    fn = Symbol('ff', integer=False)
+    nt = Symbol('nt', nonnegative=True)
+    nf = Symbol('nf', nonnegative=False)
+    nn = Symbol('nf')
+    te = Symbol('te', even=True, nonnegative=True)
+    to = Symbol('to', odd=True, nonnegative=True)
+    assert subfactorial(tt).is_integer
+    assert subfactorial(tf).is_integer is None
+    assert subfactorial(tn).is_integer is None
+    assert subfactorial(ft).is_integer is None
+    assert subfactorial(ff).is_integer is None
+    assert subfactorial(fn).is_integer is None
+    assert subfactorial(nt).is_integer is None
+    assert subfactorial(nf).is_integer is None
+    assert subfactorial(nn).is_integer is None
+    assert subfactorial(tt).is_nonnegative
+    assert subfactorial(tf).is_nonnegative is None
+    assert subfactorial(tn).is_nonnegative is None
+    assert subfactorial(ft).is_nonnegative is None
+    assert subfactorial(ff).is_nonnegative is None
+    assert subfactorial(fn).is_nonnegative is None
+    assert subfactorial(nt).is_nonnegative is None
+    assert subfactorial(nf).is_nonnegative is None
+    assert subfactorial(nn).is_nonnegative is None
+    assert subfactorial(tt).is_even is None
+    assert subfactorial(tt).is_odd is None
+    assert subfactorial(te).is_odd is True
+    assert subfactorial(to).is_even is True
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..83a7de89ed8e4fcc433d29f41fc87b9d0d397539
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/combinatorial/tests/test_comb_numbers.py
@@ -0,0 +1,1250 @@
+import string
+
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core import (EulerGamma, TribonacciConstant)
+from sympy.core.numbers import (Float, I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.combinatorial.numbers import carmichael
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.integers import floor
+from sympy.polys.polytools import cancel
+from sympy.series.limits import limit, Limit
+from sympy.series.order import O
+from sympy.functions import (
+    bernoulli, harmonic, bell, fibonacci, tribonacci, lucas, euler, catalan,
+    genocchi, andre, partition, divisor_sigma, udivisor_sigma, legendre_symbol,
+    jacobi_symbol, kronecker_symbol, mobius,
+    primenu, primeomega, totient, reduced_totient, primepi,
+    motzkin, binomial, gamma, sqrt, cbrt, hyper, log, digamma,
+    trigamma, polygamma, factorial, sin, cos, cot, polylog, zeta, dirichlet_eta)
+from sympy.functions.combinatorial.numbers import _nT
+from sympy.ntheory.factor_ import factorint
+
+from sympy.core.expr import unchanged
+from sympy.core.numbers import GoldenRatio, Integer
+
+from sympy.testing.pytest import raises, nocache_fail, warns_deprecated_sympy
+from sympy.abc import x
+
+
+def test_carmichael():
+    with warns_deprecated_sympy():
+        assert carmichael.is_prime(2821) == False
+
+
+def test_bernoulli():
+    assert bernoulli(0) == 1
+    assert bernoulli(1) == Rational(1, 2)
+    assert bernoulli(2) == Rational(1, 6)
+    assert bernoulli(3) == 0
+    assert bernoulli(4) == Rational(-1, 30)
+    assert bernoulli(5) == 0
+    assert bernoulli(6) == Rational(1, 42)
+    assert bernoulli(7) == 0
+    assert bernoulli(8) == Rational(-1, 30)
+    assert bernoulli(10) == Rational(5, 66)
+    assert bernoulli(1000001) == 0
+
+    assert bernoulli(0, x) == 1
+    assert bernoulli(1, x) == x - S.Half
+    assert bernoulli(2, x) == x**2 - x + Rational(1, 6)
+    assert bernoulli(3, x) == x**3 - (3*x**2)/2 + x/2
+
+    # Should be fast; computed with mpmath
+    b = bernoulli(1000)
+    assert b.p % 10**10 == 7950421099
+    assert b.q == 342999030
+
+    b = bernoulli(10**6, evaluate=False).evalf()
+    assert str(b) == '-2.23799235765713e+4767529'
+
+    # Issue #8527
+    l = Symbol('l', integer=True)
+    m = Symbol('m', integer=True, nonnegative=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert isinstance(bernoulli(2 * l + 1), bernoulli)
+    assert isinstance(bernoulli(2 * m + 1), bernoulli)
+    assert bernoulli(2 * n + 1) == 0
+
+    assert bernoulli(x, 1) == bernoulli(x)
+
+    assert str(bernoulli(0.0, 2.3).evalf(n=10)) == '1.000000000'
+    assert str(bernoulli(1.0).evalf(n=10)) == '0.5000000000'
+    assert str(bernoulli(1.2).evalf(n=10)) == '0.4195995367'
+    assert str(bernoulli(1.2, 0.8).evalf(n=10)) == '0.2144830348'
+    assert str(bernoulli(1.2, -0.8).evalf(n=10)) == '-1.158865646 - 0.6745558744*I'
+    assert str(bernoulli(3.0, 1j).evalf(n=10)) == '1.5 - 0.5*I'
+    assert str(bernoulli(I).evalf(n=10)) == '0.9268485643 - 0.5821580598*I'
+    assert str(bernoulli(I, I).evalf(n=10)) == '0.1267792071 + 0.01947413152*I'
+    assert bernoulli(x).evalf() == bernoulli(x)
+
+
+def test_bernoulli_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol('n', integer=True, nonnegative=True)
+
+    assert bernoulli(-1).rewrite(zeta) == pi**2/6
+    assert bernoulli(-2).rewrite(zeta) == 2*zeta(3)
+    assert not bernoulli(n, -3).rewrite(zeta).has(harmonic)
+    assert bernoulli(-4, x).rewrite(zeta) == 4*zeta(5, x)
+    assert isinstance(bernoulli(n, x).rewrite(zeta), Piecewise)
+    assert bernoulli(n+1, x).rewrite(zeta) == -(n+1) * zeta(-n, x)
+
+
+def test_fibonacci():
+    assert [fibonacci(n) for n in range(-3, 5)] == [2, -1, 1, 0, 1, 1, 2, 3]
+    assert fibonacci(100) == 354224848179261915075
+    assert [lucas(n) for n in range(-3, 5)] == [-4, 3, -1, 2, 1, 3, 4, 7]
+    assert lucas(100) == 792070839848372253127
+
+    assert fibonacci(1, x) == 1
+    assert fibonacci(2, x) == x
+    assert fibonacci(3, x) == x**2 + 1
+    assert fibonacci(4, x) == x**3 + 2*x
+
+    # issue #8800
+    n = Dummy('n')
+    assert fibonacci(n).limit(n, S.Infinity) is S.Infinity
+    assert lucas(n).limit(n, S.Infinity) is S.Infinity
+
+    assert fibonacci(n).rewrite(sqrt) == \
+        2**(-n)*sqrt(5)*((1 + sqrt(5))**n - (-sqrt(5) + 1)**n) / 5
+    assert fibonacci(n).rewrite(sqrt).subs(n, 10).expand() == fibonacci(10)
+    assert fibonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(fibonacci(10))
+    assert lucas(n).rewrite(sqrt) == \
+        (fibonacci(n-1).rewrite(sqrt) + fibonacci(n+1).rewrite(sqrt)).simplify()
+    assert lucas(n).rewrite(sqrt).subs(n, 10).expand() == lucas(10)
+    raises(ValueError, lambda: fibonacci(-3, x))
+
+
+def test_tribonacci():
+    assert [tribonacci(n) for n in range(8)] == [0, 1, 1, 2, 4, 7, 13, 24]
+    assert tribonacci(100) == 98079530178586034536500564
+
+    assert tribonacci(0, x) == 0
+    assert tribonacci(1, x) == 1
+    assert tribonacci(2, x) == x**2
+    assert tribonacci(3, x) == x**4 + x
+    assert tribonacci(4, x) == x**6 + 2*x**3 + 1
+    assert tribonacci(5, x) == x**8 + 3*x**5 + 3*x**2
+
+    n = Dummy('n')
+    assert tribonacci(n).limit(n, S.Infinity) is S.Infinity
+
+    w = (-1 + S.ImaginaryUnit * sqrt(3)) / 2
+    a = (1 + cbrt(19 + 3*sqrt(33)) + cbrt(19 - 3*sqrt(33))) / 3
+    b = (1 + w*cbrt(19 + 3*sqrt(33)) + w**2*cbrt(19 - 3*sqrt(33))) / 3
+    c = (1 + w**2*cbrt(19 + 3*sqrt(33)) + w*cbrt(19 - 3*sqrt(33))) / 3
+    assert tribonacci(n).rewrite(sqrt) == \
+      (a**(n + 1)/((a - b)*(a - c))
+      + b**(n + 1)/((b - a)*(b - c))
+      + c**(n + 1)/((c - a)*(c - b)))
+    assert tribonacci(n).rewrite(sqrt).subs(n, 4).simplify() == tribonacci(4)
+    assert tribonacci(n).rewrite(GoldenRatio).subs(n,10).evalf() == \
+        Float(tribonacci(10))
+    assert tribonacci(n).rewrite(TribonacciConstant) == floor(
+            3*TribonacciConstant**n*(102*sqrt(33) + 586)**Rational(1, 3)/
+            (-2*(102*sqrt(33) + 586)**Rational(1, 3) + 4 + (102*sqrt(33)
+            + 586)**Rational(2, 3)) + S.Half)
+    raises(ValueError, lambda: tribonacci(-1, x))
+
+
+@nocache_fail
+def test_bell():
+    assert [bell(n) for n in range(8)] == [1, 1, 2, 5, 15, 52, 203, 877]
+
+    assert bell(0, x) == 1
+    assert bell(1, x) == x
+    assert bell(2, x) == x**2 + x
+    assert bell(5, x) == x**5 + 10*x**4 + 25*x**3 + 15*x**2 + x
+    assert bell(oo) is S.Infinity
+    raises(ValueError, lambda: bell(oo, x))
+
+    raises(ValueError, lambda: bell(-1))
+    raises(ValueError, lambda: bell(S.Half))
+
+    X = symbols('x:6')
+    # X = (x0, x1, .. x5)
+    # at the same time: X[1] = x1, X[2] = x2 for standard readablity.
+    # but we must supply zero-based indexed object X[1:] = (x1, .. x5)
+
+    assert bell(6, 2, X[1:]) == 6*X[5]*X[1] + 15*X[4]*X[2] + 10*X[3]**2
+    assert bell(
+        6, 3, X[1:]) == 15*X[4]*X[1]**2 + 60*X[3]*X[2]*X[1] + 15*X[2]**3
+
+    X = (1, 10, 100, 1000, 10000)
+    assert bell(6, 2, X) == (6 + 15 + 10)*10000
+
+    X = (1, 2, 3, 3, 5)
+    assert bell(6, 2, X) == 6*5 + 15*3*2 + 10*3**2
+
+    X = (1, 2, 3, 5)
+    assert bell(6, 3, X) == 15*5 + 60*3*2 + 15*2**3
+
+    # Dobinski's formula
+    n = Symbol('n', integer=True, nonnegative=True)
+    # For large numbers, this is too slow
+    # For nonintegers, there are significant precision errors
+    for i in [0, 2, 3, 7, 13, 42, 55]:
+        # Running without the cache this is either very slow or goes into an
+        # infinite loop.
+        assert bell(i).evalf() == bell(n).rewrite(Sum).evalf(subs={n: i})
+
+    m = Symbol("m")
+    assert bell(m).rewrite(Sum) == bell(m)
+    assert bell(n, m).rewrite(Sum) == bell(n, m)
+    # issue 9184
+    n = Dummy('n')
+    assert bell(n).limit(n, S.Infinity) is S.Infinity
+
+
+def test_harmonic():
+    n = Symbol("n")
+    m = Symbol("m")
+
+    assert harmonic(n, 0) == n
+    assert harmonic(n).evalf() == harmonic(n)
+    assert harmonic(n, 1) == harmonic(n)
+    assert harmonic(1, n) == 1
+
+    assert harmonic(0, 1) == 0
+    assert harmonic(1, 1) == 1
+    assert harmonic(2, 1) == Rational(3, 2)
+    assert harmonic(3, 1) == Rational(11, 6)
+    assert harmonic(4, 1) == Rational(25, 12)
+    assert harmonic(0, 2) == 0
+    assert harmonic(1, 2) == 1
+    assert harmonic(2, 2) == Rational(5, 4)
+    assert harmonic(3, 2) == Rational(49, 36)
+    assert harmonic(4, 2) == Rational(205, 144)
+    assert harmonic(0, 3) == 0
+    assert harmonic(1, 3) == 1
+    assert harmonic(2, 3) == Rational(9, 8)
+    assert harmonic(3, 3) == Rational(251, 216)
+    assert harmonic(4, 3) == Rational(2035, 1728)
+
+    assert harmonic(oo, -1) is S.NaN
+    assert harmonic(oo, 0) is oo
+    assert harmonic(oo, S.Half) is oo
+    assert harmonic(oo, 1) is oo
+    assert harmonic(oo, 2) == (pi**2)/6
+    assert harmonic(oo, 3) == zeta(3)
+    assert harmonic(oo, Dummy(negative=True)) is S.NaN
+    ip = Dummy(integer=True, positive=True)
+    if (1/ip <= 1) is True:  #---------------------------------+
+        assert None, 'delete this if-block and the next line' #|
+    ip = Dummy(even=True, positive=True)  #--------------------+
+    assert harmonic(oo, 1/ip) is oo
+    assert harmonic(oo, 1 + ip) is zeta(1 + ip)
+
+    assert harmonic(0, m) == 0
+    assert harmonic(-1, -1) == 0
+    assert harmonic(-1, 0) == -1
+    assert harmonic(-1, 1) is S.ComplexInfinity
+    assert harmonic(-1, 2) is S.NaN
+    assert harmonic(-3, -2) == -5
+    assert harmonic(-3, -3) == 9
+
+
+def test_harmonic_rational():
+    ne = S(6)
+    no = S(5)
+    pe = S(8)
+    po = S(9)
+    qe = S(10)
+    qo = S(13)
+
+    Heee = harmonic(ne + pe/qe)
+    Aeee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(13944145, 4720968))
+
+    Heeo = harmonic(ne + pe/qo)
+    Aeeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2 - 2*log(sin(pi/13))*cos(pi*Rational(3, 13))
+             + Rational(2422020029, 702257080))
+
+    Heoe = harmonic(ne + po/qe)
+    Aeoe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(11818877030, 4286604231) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Heoo = harmonic(ne + po/qo)
+    Aeoo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(3, 13)) + Rational(11669332571, 3628714320))
+
+    Hoee = harmonic(no + pe/qe)
+    Aoee = (-log(10) + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + pi*sqrt(2*sqrt(5)/5 + 1)/2 + Rational(779405, 277704))
+
+    Hoeo = harmonic(no + pe/qo)
+    Aoeo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(4, 13)) + 2*log(sin(pi*Rational(2, 13)))*cos(pi*Rational(32, 13))
+             + 2*log(sin(pi*Rational(5, 13)))*cos(pi*Rational(80, 13)) - 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(5, 13))
+             - 2*log(sin(pi*Rational(4, 13)))*cos(pi/13) + pi*cot(pi*Rational(5, 13))/2
+             - 2*log(sin(pi/13))*cos(pi*Rational(3, 13)) + Rational(53857323, 16331560))
+
+    Hooe = harmonic(no + po/qe)
+    Aooe = (-log(20) + 2*(Rational(1, 4) + sqrt(5)/4)*log(Rational(-1, 4) + sqrt(5)/4)
+             + 2*(Rational(-1, 4) + sqrt(5)/4)*log(sqrt(-sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 - Rational(1, 4))*log(sqrt(sqrt(5)/8 + Rational(5, 8)))
+             + 2*(-sqrt(5)/4 + Rational(1, 4))*log(Rational(1, 4) + sqrt(5)/4)
+             + Rational(486853480, 186374097) + pi*sqrt(2*sqrt(5) + 5)/2)
+
+    Hooo = harmonic(no + po/qo)
+    Aooo = (-log(26) + 2*log(sin(pi*Rational(3, 13)))*cos(pi*Rational(54, 13)) + 2*log(sin(pi*Rational(4, 13)))*cos(pi*Rational(6, 13))
+             + 2*log(sin(pi*Rational(6, 13)))*cos(pi*Rational(108, 13)) - 2*log(sin(pi*Rational(5, 13)))*cos(pi/13)
+             - 2*log(sin(pi/13))*cos(pi*Rational(5, 13)) + pi*cot(pi*Rational(4, 13))/2
+             - 2*log(sin(pi*Rational(2, 13)))*cos(3*pi/13) + Rational(383693479, 125128080))
+
+    H = [Heee, Heeo, Heoe, Heoo, Hoee, Hoeo, Hooe, Hooo]
+    A = [Aeee, Aeeo, Aeoe, Aeoo, Aoee, Aoeo, Aooe, Aooo]
+    for h, a in zip(H, A):
+        e = expand_func(h).doit()
+        assert cancel(e/a) == 1
+        assert abs(h.n() - a.n()) < 1e-12
+
+
+def test_harmonic_evalf():
+    assert str(harmonic(1.5).evalf(n=10)) == '1.280372306'
+    assert str(harmonic(1.5, 2).evalf(n=10)) == '1.154576311'  # issue 7443
+    assert str(harmonic(4.0, -3).evalf(n=10)) == '100.0000000'
+    assert str(harmonic(7.0, 1.0).evalf(n=10)) == '2.592857143'
+    assert str(harmonic(1, pi).evalf(n=10)) == '1.000000000'
+    assert str(harmonic(2, pi).evalf(n=10)) == '1.113314732'
+    assert str(harmonic(1000.0, pi).evalf(n=10)) == '1.176241563'
+    assert str(harmonic(I).evalf(n=10)) == '0.6718659855 + 1.076674047*I'
+    assert str(harmonic(I, I).evalf(n=10)) == '-0.3970915266 + 1.9629689*I'
+
+    assert harmonic(-1.0, 1).evalf() is S.NaN
+    assert harmonic(-2.0, 2.0).evalf() is S.NaN
+
+def test_harmonic_rewrite():
+    from sympy.functions.elementary.piecewise import Piecewise
+    n = Symbol("n")
+    m = Symbol("m", integer=True, positive=True)
+    x1 = Symbol("x1", positive=True)
+    x2 = Symbol("x2", negative=True)
+
+    assert harmonic(n).rewrite(digamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(trigamma) == polygamma(0, n + 1) + EulerGamma
+    assert harmonic(n).rewrite(polygamma) == polygamma(0, n + 1) + EulerGamma
+
+    assert harmonic(n,3).rewrite(polygamma) == polygamma(2, n + 1)/2 - polygamma(2, 1)/2
+    assert isinstance(harmonic(n,m).rewrite(polygamma), Piecewise)
+
+    assert expand_func(harmonic(n+4)) == harmonic(n) + 1/(n + 4) + 1/(n + 3) + 1/(n + 2) + 1/(n + 1)
+    assert expand_func(harmonic(n-4)) == harmonic(n) - 1/(n - 1) - 1/(n - 2) - 1/(n - 3) - 1/n
+
+    assert harmonic(n, m).rewrite("tractable") == harmonic(n, m).rewrite(polygamma)
+    assert harmonic(n, x1).rewrite("tractable") == harmonic(n, x1)
+    assert harmonic(n, x1 + 1).rewrite("tractable") == zeta(x1 + 1) - zeta(x1 + 1, n + 1)
+    assert harmonic(n, x2).rewrite("tractable") == zeta(x2) - zeta(x2, n + 1)
+
+    _k = Dummy("k")
+    assert harmonic(n).rewrite(Sum).dummy_eq(Sum(1/_k, (_k, 1, n)))
+    assert harmonic(n, m).rewrite(Sum).dummy_eq(Sum(_k**(-m), (_k, 1, n)))
+
+
+def test_harmonic_calculus():
+    y = Symbol("y", positive=True)
+    z = Symbol("z", negative=True)
+    assert harmonic(x, 1).limit(x, 0) == 0
+    assert harmonic(x, y).limit(x, 0) == 0
+    assert harmonic(x, 1).series(x, y, 2) == \
+            harmonic(y) + (x - y)*zeta(2, y + 1) + O((x - y)**2, (x, y))
+    assert limit(harmonic(x, y), x, oo) == harmonic(oo, y)
+    assert limit(harmonic(x, y + 1), x, oo) == zeta(y + 1)
+    assert limit(harmonic(x, y - 1), x, oo) == harmonic(oo, y - 1)
+    assert limit(harmonic(x, z), x, oo) == Limit(harmonic(x, z), x, oo, dir='-')
+    assert limit(harmonic(x, z + 1), x, oo) == oo
+    assert limit(harmonic(x, z + 2), x, oo) == harmonic(oo, z + 2)
+    assert limit(harmonic(x, z - 1), x, oo) == Limit(harmonic(x, z - 1), x, oo, dir='-')
+
+
+def test_euler():
+    assert euler(0) == 1
+    assert euler(1) == 0
+    assert euler(2) == -1
+    assert euler(3) == 0
+    assert euler(4) == 5
+    assert euler(6) == -61
+    assert euler(8) == 1385
+
+    assert euler(20, evaluate=False) != 370371188237525
+
+    n = Symbol('n', integer=True)
+    assert euler(n) != -1
+    assert euler(n).subs(n, 2) == -1
+
+    assert euler(-1) == S.Pi / 2
+    assert euler(-1, 1) == 2*log(2)
+    assert euler(-2).evalf() == (2*S.Catalan).evalf()
+    assert euler(-3).evalf() == (S.Pi**3 / 16).evalf()
+    assert str(euler(2.3).evalf(n=10)) == '-1.052850274'
+    assert str(euler(1.2, 3.4).evalf(n=10)) == '3.575613489'
+    assert str(euler(I).evalf(n=10)) == '1.248446443 - 0.7675445124*I'
+    assert str(euler(I, I).evalf(n=10)) == '0.04812930469 + 0.01052411008*I'
+
+    assert euler(20).evalf() == 370371188237525.0
+    assert euler(20, evaluate=False).evalf() == 370371188237525.0
+
+    assert euler(n).rewrite(Sum) == euler(n)
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert euler(2*n + 1).rewrite(Sum) == 0
+    _j = Dummy('j')
+    _k = Dummy('k')
+    assert euler(2*n).rewrite(Sum).dummy_eq(
+            I*Sum((-1)**_j*2**(-_k)*I**(-_k)*(-2*_j + _k)**(2*n + 1)*
+                  binomial(_k, _j)/_k, (_j, 0, _k), (_k, 1, 2*n + 1)))
+
+
+def test_euler_odd():
+    n = Symbol('n', odd=True, positive=True)
+    assert euler(n) == 0
+    n = Symbol('n', odd=True)
+    assert euler(n) != 0
+
+
+def test_euler_polynomials():
+    assert euler(0, x) == 1
+    assert euler(1, x) == x - S.Half
+    assert euler(2, x) == x**2 - x
+    assert euler(3, x) == x**3 - (3*x**2)/2 + Rational(1, 4)
+    m = Symbol('m')
+    assert isinstance(euler(m, x), euler)
+    from sympy.core.numbers import Float
+    A = Float('-0.46237208575048694923364757452876131e8')  # from Maple
+    B = euler(19, S.Pi).evalf(32)
+    assert abs((A - B)/A) < 1e-31
+    z = Float(0.1) + Float(0.2)*I
+    expected = Float(-3126.54721663773 ) + Float(565.736261497056) * I
+    assert abs(euler(13, z) - expected) < 1e-10
+
+
+def test_euler_polynomial_rewrite():
+    m = Symbol('m')
+    A = euler(m, x).rewrite('Sum')
+    assert A.subs({m:3, x:5}).doit() == euler(3, 5)
+
+
+def test_catalan():
+    n = Symbol('n', integer=True)
+    m = Symbol('m', integer=True, positive=True)
+    k = Symbol('k', integer=True, nonnegative=True)
+    p = Symbol('p', nonnegative=True)
+
+    catalans = [1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786]
+    for i, c in enumerate(catalans):
+        assert catalan(i) == c
+        assert catalan(n).rewrite(factorial).subs(n, i) == c
+        assert catalan(n).rewrite(Product).subs(n, i).doit() == c
+
+    assert unchanged(catalan, x)
+    assert catalan(2*x).rewrite(binomial) == binomial(4*x, 2*x)/(2*x + 1)
+    assert catalan(S.Half).rewrite(gamma) == 8/(3*pi)
+    assert catalan(S.Half).rewrite(factorial).rewrite(gamma) ==\
+        8 / (3 * pi)
+    assert catalan(3*x).rewrite(gamma) == 4**(
+        3*x)*gamma(3*x + S.Half)/(sqrt(pi)*gamma(3*x + 2))
+    assert catalan(x).rewrite(hyper) == hyper((-x + 1, -x), (2,), 1)
+
+    assert catalan(n).rewrite(factorial) == factorial(2*n) / (factorial(n + 1)
+                                                              * factorial(n))
+    assert isinstance(catalan(n).rewrite(Product), catalan)
+    assert isinstance(catalan(m).rewrite(Product), Product)
+
+    assert diff(catalan(x), x) == (polygamma(
+        0, x + S.Half) - polygamma(0, x + 2) + log(4))*catalan(x)
+
+    assert catalan(x).evalf() == catalan(x)
+    c = catalan(S.Half).evalf()
+    assert str(c) == '0.848826363156775'
+    c = catalan(I).evalf(3)
+    assert str((re(c), im(c))) == '(0.398, -0.0209)'
+
+    # Assumptions
+    assert catalan(p).is_positive is True
+    assert catalan(k).is_integer is True
+    assert catalan(m+3).is_composite is True
+
+
+def test_genocchi():
+    genocchis = [0, -1, -1, 0, 1, 0, -3, 0, 17]
+    for n, g in enumerate(genocchis):
+        assert genocchi(n) == g
+
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, positive=True)
+    assert unchanged(genocchi, m)
+    assert genocchi(2*n + 1) == 0
+    gn = 2 * (1 - 2**n) * bernoulli(n)
+    assert genocchi(n).rewrite(bernoulli).factor() == gn.factor()
+    gnx = 2 * (bernoulli(n, x) - 2**n * bernoulli(n, (x+1) / 2))
+    assert genocchi(n, x).rewrite(bernoulli).factor() == gnx.factor()
+    assert genocchi(2 * n).is_odd
+    assert genocchi(2 * n).is_even is False
+    assert genocchi(2 * n + 1).is_even
+    assert genocchi(n).is_integer
+    assert genocchi(4 * n).is_positive
+    # these are the only 2 prime Genocchi numbers
+    assert genocchi(6, evaluate=False).is_prime == S(-3).is_prime
+    assert genocchi(8, evaluate=False).is_prime
+    assert genocchi(4 * n + 2).is_negative
+    assert genocchi(4 * n + 1).is_negative is False
+    assert genocchi(4 * n - 2).is_negative
+
+    g0 = genocchi(0, evaluate=False)
+    assert g0.is_positive is False
+    assert g0.is_negative is False
+    assert g0.is_even is True
+    assert g0.is_odd is False
+
+    assert genocchi(0, x) == 0
+    assert genocchi(1, x) == -1
+    assert genocchi(2, x) == 1 - 2*x
+    assert genocchi(3, x) == 3*x - 3*x**2
+    assert genocchi(4, x) == -1 + 6*x**2 - 4*x**3
+    y = Symbol("y")
+    assert genocchi(5, (x+y)**100) == -5*(x+y)**400 + 10*(x+y)**300 - 5*(x+y)**100
+
+    assert str(genocchi(5.0, 4.0).evalf(n=10)) == '-660.0000000'
+    assert str(genocchi(Rational(5, 4)).evalf(n=10)) == '-1.104286457'
+    assert str(genocchi(-2).evalf(n=10)) == '3.606170709'
+    assert str(genocchi(1.3, 3.7).evalf(n=10)) == '-1.847375373'
+    assert str(genocchi(I, 1.0).evalf(n=10)) == '-0.3161917278 - 1.45311955*I'
+
+    n = Symbol('n')
+    assert genocchi(n, x).rewrite(dirichlet_eta) == -2*n * dirichlet_eta(1-n, x)
+
+
+def test_andre():
+    nums = [1, 1, 1, 2, 5, 16, 61, 272, 1385, 7936, 50521]
+    for n, a in enumerate(nums):
+        assert andre(n) == a
+    assert andre(S.Infinity) == S.Infinity
+    assert andre(-1) == -log(2)
+    assert andre(-2) == -2*S.Catalan
+    assert andre(-3) == 3*zeta(3)/16
+    assert andre(-5) == -15*zeta(5)/256
+    # In fact andre(-2*n) is related to the Dirichlet *beta* function
+    # at 2*n, but SymPy doesn't implement that (or general L-functions)
+    assert unchanged(andre, -4)
+
+    n = Symbol('n', integer=True, nonnegative=True)
+    assert unchanged(andre, n)
+    assert andre(n).is_integer is True
+    assert andre(n).is_positive is True
+
+    assert str(andre(10, evaluate=False).evalf(n=10)) == '50521.00000'
+    assert str(andre(-1, evaluate=False).evalf(n=10)) == '-0.6931471806'
+    assert str(andre(-2, evaluate=False).evalf(n=10)) == '-1.831931188'
+    assert str(andre(-4, evaluate=False).evalf(n=10)) == '1.977889103'
+    assert str(andre(I, evaluate=False).evalf(n=10)) == '2.378417833 + 0.6343322845*I'
+
+    assert andre(x).rewrite(polylog) == \
+            (-I)**(x+1) * polylog(-x, I) + I**(x+1) * polylog(-x, -I)
+    assert andre(x).rewrite(zeta) == \
+            2 * gamma(x+1) / (2*pi)**(x+1) * \
+            (zeta(x+1, Rational(1,4)) - cos(pi*x) * zeta(x+1, Rational(3,4)))
+
+
+@nocache_fail
+def test_partition():
+    partition_nums = [1, 1, 2, 3, 5, 7, 11, 15, 22]
+    for n, p in enumerate(partition_nums):
+        assert partition(n) == p
+
+    x = Symbol('x')
+    y = Symbol('y', real=True)
+    m = Symbol('m', integer=True)
+    n = Symbol('n', integer=True, negative=True)
+    p = Symbol('p', integer=True, nonnegative=True)
+    assert partition(m).is_integer
+    assert not partition(m).is_negative
+    assert partition(m).is_nonnegative
+    assert partition(n).is_zero
+    assert partition(p).is_positive
+    assert partition(x).subs(x, 7) == 15
+    assert partition(y).subs(y, 8) == 22
+    raises(TypeError, lambda: partition(Rational(5, 4)))
+    assert partition(9, evaluate=False) % 5 == 0
+    assert partition(5*m + 4) % 5 == 0
+    assert partition(47, evaluate=False) % 7 == 0
+    assert partition(7*m + 5) % 7 == 0
+    assert partition(50, evaluate=False) % 11 == 0
+    assert partition(11*m + 6) % 11 == 0
+
+
+def test_divisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: divisor_sigma(m))
+    raises(TypeError, lambda: divisor_sigma(4.5))
+    raises(TypeError, lambda: divisor_sigma(1, m))
+    raises(TypeError, lambda: divisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: divisor_sigma(m))
+    raises(ValueError, lambda: divisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: divisor_sigma(1, m))
+    raises(ValueError, lambda: divisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert divisor_sigma(p, 1) == p + 1
+    assert divisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert divisor_sigma(n).is_integer is True
+    assert divisor_sigma(n).is_positive is True
+
+    # symbolic
+    k = Symbol('k', integer=True, zero=False)
+    assert divisor_sigma(4, k) == 2**(2*k) + 2**k + 1
+    assert divisor_sigma(6, k) == (2**k + 1) * (3**k + 1)
+
+    # Integer
+    assert divisor_sigma(23450) == 50592
+    assert divisor_sigma(23450, 0) == 24
+    assert divisor_sigma(23450, 1) == 50592
+    assert divisor_sigma(23450, 2) == 730747500
+    assert divisor_sigma(23450, 3) == 14666785333344
+
+
+def test_udivisor_sigma():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: udivisor_sigma(m))
+    raises(TypeError, lambda: udivisor_sigma(4.5))
+    raises(TypeError, lambda: udivisor_sigma(1, m))
+    raises(TypeError, lambda: udivisor_sigma(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: udivisor_sigma(m))
+    raises(ValueError, lambda: udivisor_sigma(0))
+    m = Symbol('m', negative=True)
+    raises(ValueError, lambda: udivisor_sigma(1, m))
+    raises(ValueError, lambda: udivisor_sigma(1, -1))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert udivisor_sigma(p, 1) == p + 1
+    assert udivisor_sigma(p, k) == p**k + 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert udivisor_sigma(n).is_integer is True
+    assert udivisor_sigma(n).is_positive is True
+
+    # Integer
+    A034444 = [1, 2, 2, 2, 2, 4, 2, 2, 2, 4, 2, 4, 2, 4, 4, 2, 2, 4, 2, 4,
+               4, 4, 2, 4, 2, 4, 2, 4, 2, 8, 2, 2, 4, 4, 4, 4, 2, 4, 4, 4,
+               2, 8, 2, 4, 4, 4, 2, 4, 2, 4, 4, 4, 2, 4, 4, 4, 4, 4, 2, 8]
+    for n, val in enumerate(A034444, 1):
+        assert udivisor_sigma(n, 0) == val
+    A034448 = [1, 3, 4, 5, 6, 12, 8, 9, 10, 18, 12, 20, 14, 24, 24, 17, 18,
+               30, 20, 30, 32, 36, 24, 36, 26, 42, 28, 40, 30, 72, 32, 33,
+               48, 54, 48, 50, 38, 60, 56, 54, 42, 96, 44, 60, 60, 72, 48]
+    for n, val in enumerate(A034448, 1):
+        assert udivisor_sigma(n, 1) == val
+    A034676 = [1, 5, 10, 17, 26, 50, 50, 65, 82, 130, 122, 170, 170, 250,
+               260, 257, 290, 410, 362, 442, 500, 610, 530, 650, 626, 850,
+               730, 850, 842, 1300, 962, 1025, 1220, 1450, 1300, 1394, 1370]
+    for n, val in enumerate(A034676, 1):
+        assert udivisor_sigma(n, 2) == val
+
+
+def test_legendre_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: legendre_symbol(m, 3))
+    raises(TypeError, lambda: legendre_symbol(4.5, 3))
+    raises(TypeError, lambda: legendre_symbol(1, m))
+    raises(TypeError, lambda: legendre_symbol(1, 4.5))
+    m = Symbol('m', prime=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: legendre_symbol(1, m))
+    raises(ValueError, lambda: legendre_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', prime=True)
+    k = Symbol('k', integer=True)
+    assert legendre_symbol(p*k, p) == 0
+    assert legendre_symbol(1, p) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert legendre_symbol(m, n).is_integer is True
+    assert legendre_symbol(m, n).is_prime is False
+
+    # Integer
+    assert legendre_symbol(5, 11) == 1
+    assert legendre_symbol(25, 41) == 1
+    assert legendre_symbol(67, 101) == -1
+    assert legendre_symbol(0, 13) == 0
+    assert legendre_symbol(9, 3) == 0
+
+
+def test_jacobi_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: jacobi_symbol(m, 3))
+    raises(TypeError, lambda: jacobi_symbol(4.5, 3))
+    raises(TypeError, lambda: jacobi_symbol(1, m))
+    raises(TypeError, lambda: jacobi_symbol(1, 4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, -6))
+    m = Symbol('m', odd=False)
+    raises(ValueError, lambda: jacobi_symbol(1, m))
+    raises(ValueError, lambda: jacobi_symbol(1, 2))
+
+    # special case
+    p = Symbol('p', integer=True)
+    k = Symbol('k', integer=True)
+    assert jacobi_symbol(p*k, p) == 0
+    assert jacobi_symbol(1, p) == 1
+    assert jacobi_symbol(1, 1) == 1
+    assert jacobi_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert jacobi_symbol(m, n).is_integer is True
+    assert jacobi_symbol(m, n).is_prime is False
+
+    # Integer
+    assert jacobi_symbol(25, 41) == 1
+    assert jacobi_symbol(-23, 83) == -1
+    assert jacobi_symbol(3, 9) == 0
+    assert jacobi_symbol(42, 97) == -1
+    assert jacobi_symbol(3, 5) == -1
+    assert jacobi_symbol(7, 9) == 1
+    assert jacobi_symbol(0, 3) == 0
+    assert jacobi_symbol(0, 1) == 1
+    assert jacobi_symbol(2, 1) == 1
+    assert jacobi_symbol(1, 3) == 1
+
+
+def test_kronecker_symbol():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: kronecker_symbol(m, 3))
+    raises(TypeError, lambda: kronecker_symbol(4.5, 3))
+    raises(TypeError, lambda: kronecker_symbol(1, m))
+    raises(TypeError, lambda: kronecker_symbol(1, 4.5))
+
+    # special case
+    p = Symbol('p', integer=True)
+    assert kronecker_symbol(1, p) == 1
+    assert kronecker_symbol(1, 1) == 1
+    assert kronecker_symbol(0, 1) == 1
+
+    # property
+    n = Symbol('n')
+    m = Symbol('m')
+    assert kronecker_symbol(m, n).is_integer is True
+    assert kronecker_symbol(m, n).is_prime is False
+
+    # Integer
+    for n in range(3, 10, 2):
+        for a in range(-n, n):
+            val = kronecker_symbol(a, n)
+            assert val == jacobi_symbol(a, n)
+            minus = kronecker_symbol(a, -n)
+            if a < 0:
+                assert -minus == val
+            else:
+                assert minus == val
+            even = kronecker_symbol(a, 2 * n)
+            if a % 2 == 0:
+                assert even == 0
+            elif a % 8 in [1, 7]:
+                assert even == val
+            else:
+                assert -even == val
+    assert kronecker_symbol(1, 0) == kronecker_symbol(-1, 0) == 1
+    assert kronecker_symbol(0, 0) == 0
+
+
+def test_mobius():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: mobius(m))
+    raises(TypeError, lambda: mobius(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: mobius(m))
+    raises(ValueError, lambda: mobius(-3))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert mobius(p) == -1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert mobius(n).is_integer is True
+    assert mobius(n).is_prime is False
+
+    # symbolic
+    n = Symbol('n', integer=True, positive=True)
+    k = Symbol('k', integer=True, positive=True)
+    assert mobius(n**2) == 0
+    assert mobius(4*n) == 0
+    assert isinstance(mobius(n**k), mobius)
+    assert mobius(n**(k+1)) == 0
+    assert isinstance(mobius(3**k), mobius)
+    assert mobius(3**(k+1)) == 0
+    m = Symbol('m')
+    assert isinstance(mobius(4*m), mobius)
+
+    # Integer
+    assert mobius(13*7) == 1
+    assert mobius(1) == 1
+    assert mobius(13*7*5) == -1
+    assert mobius(13**2) == 0
+    A008683 = [1, -1, -1, 0, -1, 1, -1, 0, 0, 1, -1, 0, -1, 1, 1, 0, -1, 0,
+               -1, 0, 1, 1, -1, 0, 0, 1, 0, 0, -1, -1, -1, 0, 1, 1, 1, 0, -1,
+               1, 1, 0, -1, -1, -1, 0, 0, 1, -1, 0, 0, 0, 1, 0, -1, 0, 1, 0]
+    for n, val in enumerate(A008683, 1):
+        assert mobius(n) == val
+
+
+def test_primenu():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primenu(m))
+    raises(TypeError, lambda: primenu(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primenu(m))
+    raises(ValueError, lambda: primenu(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primenu(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primenu(n).is_integer is True
+    assert primenu(n).is_nonnegative is True
+
+    # Integer
+    assert primenu(7*13) == 2
+    assert primenu(2*17*19) == 3
+    assert primenu(2**3 * 17 * 19**2) == 3
+    A001221 = [0, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 2, 1, 1, 2,
+               1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 1, 2, 2, 2, 2]
+    for n, val in enumerate(A001221, 1):
+        assert primenu(n) == val
+
+
+def test_primeomega():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: primeomega(m))
+    raises(TypeError, lambda: primeomega(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: primeomega(m))
+    raises(ValueError, lambda: primeomega(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert primeomega(p) == 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primeomega(n).is_integer is True
+    assert primeomega(n).is_nonnegative is True
+
+    # Integer
+    assert primeomega(7*13) == 2
+    assert primeomega(2*17*19) == 3
+    assert primeomega(2**3 * 17 * 19**2) == 6
+    A001222 = [0, 1, 1, 2, 1, 2, 1, 3, 2, 2, 1, 3, 1, 2, 2, 4, 1, 3,
+               1, 3, 2, 2, 1, 4, 2, 2, 3, 3, 1, 3, 1, 5, 2, 2, 2, 4]
+    for n, val in enumerate(A001222, 1):
+        assert primeomega(n) == val
+
+
+def test_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: totient(m))
+    raises(TypeError, lambda: totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: totient(m))
+    raises(ValueError, lambda: totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert totient(n).is_integer is True
+    assert totient(n).is_positive is True
+
+    # Integer
+    assert totient(7*13) == totient(factorint(7*13)) == (7-1)*(13-1)
+    assert totient(2*17*19) == totient(factorint(2*17*19)) == (17-1)*(19-1)
+    assert totient(2**3 * 17 * 19**2) == totient({2: 3, 17: 1, 19: 2}) == 2**2 * (17-1) * 19*(19-1)
+    A000010 = [1, 1, 2, 2, 4, 2, 6, 4, 6, 4, 10, 4, 12, 6, 8, 8, 16,
+               6, 18, 8, 12, 10, 22, 8, 20, 12, 18, 12, 28, 8, 30, 16,
+               20, 16, 24, 12, 36, 18, 24, 16, 40, 12, 42, 20, 24, 22]
+    for n, val in enumerate(A000010, 1):
+        assert totient(n) == val
+
+
+def test_reduced_totient():
+    # error
+    m = Symbol('m', integer=False)
+    raises(TypeError, lambda: reduced_totient(m))
+    raises(TypeError, lambda: reduced_totient(4.5))
+    m = Symbol('m', positive=False)
+    raises(ValueError, lambda: reduced_totient(m))
+    raises(ValueError, lambda: reduced_totient(0))
+
+    # special case
+    p = Symbol('p', prime=True)
+    assert reduced_totient(p) == p - 1
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert reduced_totient(n).is_integer is True
+    assert reduced_totient(n).is_positive is True
+
+    # Integer
+    assert reduced_totient(7*13) == reduced_totient(factorint(7*13)) == 12
+    assert reduced_totient(2*17*19) == reduced_totient(factorint(2*17*19)) == 144
+    assert reduced_totient(2**2 * 11) == reduced_totient({2: 2, 11: 1}) == 10
+    assert reduced_totient(2**3 * 17 * 19**2) == reduced_totient({2: 3, 17: 1, 19: 2}) == 2736
+    A002322 = [1, 1, 2, 2, 4, 2, 6, 2, 6, 4, 10, 2, 12, 6, 4, 4, 16, 6,
+               18, 4, 6, 10, 22, 2, 20, 12, 18, 6, 28, 4, 30, 8, 10, 16,
+               12, 6, 36, 18, 12, 4, 40, 6, 42, 10, 12, 22, 46, 4, 42]
+    for n, val in enumerate(A002322, 1):
+        assert reduced_totient(n) == val
+
+
+def test_primepi():
+    # error
+    z = Symbol('z', real=False)
+    raises(TypeError, lambda: primepi(z))
+    raises(TypeError, lambda: primepi(I))
+
+    # property
+    n = Symbol('n', integer=True, positive=True)
+    assert primepi(n).is_integer is True
+    assert primepi(n).is_nonnegative is True
+
+    # infinity
+    assert primepi(oo) == oo
+    assert primepi(-oo) == 0
+
+    # symbol
+    x = Symbol('x')
+    assert isinstance(primepi(x), primepi)
+
+    # Integer
+    assert primepi(0) == 0
+    A000720 = [0, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 8,
+               8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 11, 11, 11, 11, 11, 11,
+               12, 12, 12, 12, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15]
+    for n, val in enumerate(A000720, 1):
+        assert primepi(n) == primepi(n + 0.5) == val
+
+
+def test__nT():
+    assert [_nT(i, j) for i in range(5) for j in range(i + 2)] == [
+            1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 2, 1, 1, 0]
+    check = [_nT(10, i) for i in range(11)]
+    assert check == [0, 1, 5, 8, 9, 7, 5, 3, 2, 1, 1]
+    assert all(type(i) is int for i in check)
+    assert _nT(10, 5) == 7
+    assert _nT(100, 98) == 2
+    assert _nT(100, 100) == 1
+    assert _nT(10, 3) == 8
+
+
+def test_nC_nP_nT():
+    from sympy.utilities.iterables import (
+        multiset_permutations, multiset_combinations, multiset_partitions,
+        partitions, subsets, permutations)
+    from sympy.functions.combinatorial.numbers import (
+        nP, nC, nT, stirling, _stirling1, _stirling2, _multiset_histogram, _AOP_product)
+
+    from sympy.combinatorics.permutations import Permutation
+    from sympy.core.random import choice
+
+    c = string.ascii_lowercase
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nP(s, i)
+                tot += check
+                assert len(list(multiset_permutations(s, i))) == check
+                if u:
+                    assert nP(len(s), i) == check
+            assert nP(s) == tot
+        except AssertionError:
+            print(s, i, 'failed perm test')
+            raise ValueError()
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(8):
+                check = nC(s, i)
+                tot += check
+                assert len(list(multiset_combinations(s, i))) == check
+                if u:
+                    assert nC(len(s), i) == check
+            assert nC(s) == tot
+            if u:
+                assert nC(len(s)) == tot
+        except AssertionError:
+            print(s, i, 'failed combo test')
+            raise ValueError()
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(i, j)
+            assert check.is_Integer
+            tot += check
+            assert sum(1 for p in partitions(i, j, size=True) if p[0] == j) == check
+        assert nT(i) == tot
+
+    for i in range(1, 10):
+        tot = 0
+        for j in range(1, i + 2):
+            check = nT(range(i), j)
+            tot += check
+            assert len(list(multiset_partitions(list(range(i)), j))) == check
+        assert nT(range(i)) == tot
+
+    for i in range(100):
+        s = ''.join(choice(c) for i in range(7))
+        u = len(s) == len(set(s))
+        try:
+            tot = 0
+            for i in range(1, 8):
+                check = nT(s, i)
+                tot += check
+                assert len(list(multiset_partitions(s, i))) == check
+                if u:
+                    assert nT(range(len(s)), i) == check
+            if u:
+                assert nT(range(len(s))) == tot
+            assert nT(s) == tot
+        except AssertionError:
+            print(s, i, 'failed partition test')
+            raise ValueError()
+
+    # tests for Stirling numbers of the first kind that are not tested in the
+    # above
+    assert [stirling(9, i, kind=1) for i in range(11)] == [
+        0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1, 0]
+    perms = list(permutations(range(4)))
+    assert [sum(1 for p in perms if Permutation(p).cycles == i)
+            for i in range(5)] == [0, 6, 11, 6, 1] == [
+            stirling(4, i, kind=1) for i in range(5)]
+    # http://oeis.org/A008275
+    assert [stirling(n, k, signed=1)
+        for n in range(10) for k in range(1, n + 1)] == [
+            1, -1,
+            1, 2, -3,
+            1, -6, 11, -6,
+            1, 24, -50, 35, -10,
+            1, -120, 274, -225, 85, -15,
+            1, 720, -1764, 1624, -735, 175, -21,
+            1, -5040, 13068, -13132, 6769, -1960, 322, -28,
+            1, 40320, -109584, 118124, -67284, 22449, -4536, 546, -36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_first_kind
+    assert  [stirling(n, k, kind=1)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 2, 3, 1,
+            0, 6, 11, 6, 1,
+            0, 24, 50, 35, 10, 1,
+            0, 120, 274, 225, 85, 15, 1,
+            0, 720, 1764, 1624, 735, 175, 21, 1,
+            0, 5040, 13068, 13132, 6769, 1960, 322, 28, 1,
+            0, 40320, 109584, 118124, 67284, 22449, 4536, 546, 36, 1]
+    # https://en.wikipedia.org/wiki/Stirling_numbers_of_the_second_kind
+    assert [stirling(n, k, kind=2)
+        for n in range(10) for k in range(n+1)] == [
+            1,
+            0, 1,
+            0, 1, 1,
+            0, 1, 3, 1,
+            0, 1, 7, 6, 1,
+            0, 1, 15, 25, 10, 1,
+            0, 1, 31, 90, 65, 15, 1,
+            0, 1, 63, 301, 350, 140, 21, 1,
+            0, 1, 127, 966, 1701, 1050, 266, 28, 1,
+            0, 1, 255, 3025, 7770, 6951, 2646, 462, 36, 1]
+    assert stirling(3, 4, kind=1) == stirling(3, 4, kind=1) == 0
+    raises(ValueError, lambda: stirling(-2, 2))
+
+    # Assertion that the return type is SymPy Integer.
+    assert isinstance(_stirling1(6, 3), Integer)
+    assert isinstance(_stirling2(6, 3), Integer)
+
+    def delta(p):
+        if len(p) == 1:
+            return oo
+        return min(abs(i[0] - i[1]) for i in subsets(p, 2))
+    parts = multiset_partitions(range(5), 3)
+    d = 2
+    assert (sum(1 for p in parts if all(delta(i) >= d for i in p)) ==
+            stirling(5, 3, d=d) == 7)
+
+    # other coverage tests
+    assert nC('abb', 2) == nC('aab', 2) == 2
+    assert nP(3, 3, replacement=True) == nP('aabc', 3, replacement=True) == 27
+    assert nP(3, 4) == 0
+    assert nP('aabc', 5) == 0
+    assert nC(4, 2, replacement=True) == nC('abcdd', 2, replacement=True) == \
+        len(list(multiset_combinations('aabbccdd', 2))) == 10
+    assert nC('abcdd') == sum(nC('abcdd', i) for i in range(6)) == 24
+    assert nC(list('abcdd'), 4) == 4
+    assert nT('aaaa') == nT(4) == len(list(partitions(4))) == 5
+    assert nT('aaab') == len(list(multiset_partitions('aaab'))) == 7
+    assert nC('aabb'*3, 3) == 4  # aaa, bbb, abb, baa
+    assert dict(_AOP_product((4,1,1,1))) == {
+        0: 1, 1: 4, 2: 7, 3: 8, 4: 8, 5: 7, 6: 4, 7: 1}
+    # the following was the first t that showed a problem in a previous form of
+    # the function, so it's not as random as it may appear
+    t = (3, 9, 4, 6, 6, 5, 5, 2, 10, 4)
+    assert sum(_AOP_product(t)[i] for i in range(55)) == 58212000
+    raises(ValueError, lambda: _multiset_histogram({1:'a'}))
+
+
+def test_PR_14617():
+    from sympy.functions.combinatorial.numbers import nT
+    for n in (0, []):
+        for k in (-1, 0, 1):
+            if k == 0:
+                assert nT(n, k) == 1
+            else:
+                assert nT(n, k) == 0
+
+
+def test_issue_8496():
+    n = Symbol("n")
+    k = Symbol("k")
+
+    raises(TypeError, lambda: catalan(n, k))
+
+
+def test_issue_8601():
+    n = Symbol('n', integer=True, negative=True)
+
+    assert catalan(n - 1) is S.Zero
+    assert catalan(Rational(-1, 2)) is S.ComplexInfinity
+    assert catalan(-S.One) == Rational(-1, 2)
+    c1 = catalan(-5.6).evalf()
+    assert str(c1) == '6.93334070531408e-5'
+    c2 = catalan(-35.4).evalf()
+    assert str(c2) == '-4.14189164517449e-24'
+
+
+def test_motzkin():
+    assert motzkin.is_motzkin(4) == True
+    assert motzkin.is_motzkin(9) == True
+    assert motzkin.is_motzkin(10) == False
+    assert motzkin.find_motzkin_numbers_in_range(10,200) == [21, 51, 127]
+    assert motzkin.find_motzkin_numbers_in_range(10,400) == [21, 51, 127, 323]
+    assert motzkin.find_motzkin_numbers_in_range(10,1600) == [21, 51, 127, 323, 835]
+    assert motzkin.find_first_n_motzkins(5) == [1, 1, 2, 4, 9]
+    assert motzkin.find_first_n_motzkins(7) == [1, 1, 2, 4, 9, 21, 51]
+    assert motzkin.find_first_n_motzkins(10) == [1, 1, 2, 4, 9, 21, 51, 127, 323, 835]
+    raises(ValueError, lambda: motzkin.eval(77.58))
+    raises(ValueError, lambda: motzkin.eval(-8))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(-2,7))
+    raises(ValueError, lambda: motzkin.find_motzkin_numbers_in_range(13,7))
+    raises(ValueError, lambda: motzkin.find_first_n_motzkins(112.8))
+
+
+def test_nD_derangements():
+    from sympy.utilities.iterables import (partitions, multiset,
+        multiset_derangements, multiset_permutations)
+    from sympy.functions.combinatorial.numbers import nD
+
+    got = []
+    for i in partitions(8, k=4):
+        s = []
+        it = 0
+        for k, v in i.items():
+            for i in range(v):
+                s.extend([it]*k)
+                it += 1
+        ms = multiset(s)
+        c1 = sum(1 for i in multiset_permutations(s) if
+            all(i != j for i, j in zip(i, s)))
+        assert c1 == nD(ms) == nD(ms, 0) == nD(ms, 1)
+        v = [tuple(i) for i in multiset_derangements(s)]
+        c2 = len(v)
+        assert c2 == len(set(v))
+        assert c1 == c2
+        got.append(c1)
+    assert got == [1, 4, 6, 12, 24, 24, 61, 126, 315, 780, 297, 772,
+        2033, 5430, 14833]
+
+    assert nD('1112233456', brute=True) == nD('1112233456') == 16356
+    assert nD('') == nD([]) == nD({}) == 0
+    assert nD({1: 0}) == 0
+    raises(ValueError, lambda: nD({1: -1}))
+    assert nD('112') == 0
+    assert nD(i='112') == 0
+    assert [nD(n=i) for i in range(6)] == [0, 0, 1, 2, 9, 44]
+    assert nD((i for i in range(4))) == nD('0123') == 9
+    assert nD(m=(i for i in range(4))) == 3
+    assert nD(m={0: 1, 1: 1, 2: 1, 3: 1}) == 3
+    assert nD(m=[0, 1, 2, 3]) == 3
+    raises(TypeError, lambda: nD(m=0))
+    raises(TypeError, lambda: nD(-1))
+    assert nD({-1: 1, -2: 1}) == 1
+    assert nD(m={0: 3}) == 0
+    raises(ValueError, lambda: nD(i='123', n=3))
+    raises(ValueError, lambda: nD(i='123', m=(1,2)))
+    raises(ValueError, lambda: nD(n=0, m=(1,2)))
+    raises(ValueError, lambda: nD({1: -1}))
+    raises(ValueError, lambda: nD(m={-1: 1, 2: 1}))
+    raises(ValueError, lambda: nD(m={1: -1, 2: 1}))
+    raises(ValueError, lambda: nD(m=[-1, 2]))
+    raises(TypeError, lambda: nD({1: x}))
+    raises(TypeError, lambda: nD(m={1: x}))
+    raises(TypeError, lambda: nD(m={x: 1}))
+
+
+def test_deprecated_ntheory_symbolic_functions():
+    from sympy.testing.pytest import warns_deprecated_sympy
+
+    with warns_deprecated_sympy():
+        assert not carmichael.is_carmichael(3)
+    with warns_deprecated_sympy():
+        assert carmichael.find_carmichael_numbers_in_range(10, 20) == []
+    with warns_deprecated_sympy():
+        assert carmichael.find_first_n_carmichaels(1)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..78034e72ef2ed722c3ae685a87cf4df618a982b0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__init__.py
@@ -0,0 +1 @@
+# Stub __init__.py for sympy.functions.elementary
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3fa98f9e415d1f7aeec96eca65dc59e4542c84ba
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/_trigonometric_special.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/_trigonometric_special.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9fdeaed325c16aa0893bd5b4fe9ff25de91f4455
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/_trigonometric_special.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/complexes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/complexes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8188d9e10fae79ea090b0b23337015960aa12554
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/complexes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/exponential.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/exponential.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca5040f2318813f0b1c74455b18dc70d9def2139
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/exponential.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/hyperbolic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/hyperbolic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5268068f0a2bb90428ce1c1626134854ee2edf3a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/hyperbolic.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72fc84592c7b274648adbde5dd92096e8debee88561ccd1c29ccec53e4f4b72f
+size 108861
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/integers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/integers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef76539ca25f0642ef33ceadd11e5b6d546c9570
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/integers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/miscellaneous.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/miscellaneous.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be116359ae3d0f2667cc4f750701b6c605a8521a
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/miscellaneous.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/piecewise.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/piecewise.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efca46242e52f15f290d399d2fc910bea8d679c5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/piecewise.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/trigonometric.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/trigonometric.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58392d79406a7607d32d3345199af4eec27b1c2d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/__pycache__/trigonometric.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e4f1015d53c130858856991a51945872d7f866cf5f9cbf9fae27c6818033113
+size 170949
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/_trigonometric_special.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/_trigonometric_special.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdf8c9d06241b46e791afe76836ea33e6d4fb1c8
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/_trigonometric_special.py
@@ -0,0 +1,261 @@
+r"""A module for special angle formulas for trigonometric functions
+
+TODO
+====
+
+This module should be developed in the future to contain direct square root
+representation of
+
+.. math
+    F(\frac{n}{m} \pi)
+
+for every
+
+- $m \in \{ 3, 5, 17, 257, 65537 \}$
+- $n \in \mathbb{N}$, $0 \le n < m$
+- $F \in \{\sin, \cos, \tan, \csc, \sec, \cot\}$
+
+Without multi-step rewrites
+(e.g. $\tan \to \cos/\sin \to \cos/\sqrt \to \ sqrt$)
+or using chebyshev identities
+(e.g. $\cos \to \cos + \cos^2 + \cdots \to \sqrt{} + \sqrt{}^2 + \cdots $),
+which are trivial to implement in sympy,
+and had used to give overly complicated expressions.
+
+The reference can be found below, if anyone may need help implementing them.
+
+References
+==========
+
+.. [*] Gottlieb, Christian. (1999). The Simple and straightforward construction
+   of the regular 257-gon. The Mathematical Intelligencer. 21. 31-37.
+   10.1007/BF03024829.
+.. [*] https://resources.wolframcloud.com/FunctionRepository/resources/Cos2PiOverFermatPrime
+"""
+from __future__ import annotations
+from typing import Callable
+from functools import reduce
+from sympy.core.expr import Expr
+from sympy.core.singleton import S
+from sympy.core.intfunc import igcdex
+from sympy.core.numbers import Integer
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core.cache import cacheit
+
+
+def migcdex(*x: int) -> tuple[tuple[int, ...], int]:
+    r"""Compute extended gcd for multiple integers.
+
+    Explanation
+    ===========
+
+    Given the integers $x_1, \cdots, x_n$ and
+    an extended gcd for multiple arguments are defined as a solution
+    $(y_1, \cdots, y_n), g$ for the diophantine equation
+    $x_1 y_1 + \cdots + x_n y_n = g$ such that
+    $g = \gcd(x_1, \cdots, x_n)$.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary._trigonometric_special import migcdex
+    >>> migcdex()
+    ((), 0)
+    >>> migcdex(4)
+    ((1,), 4)
+    >>> migcdex(4, 6)
+    ((-1, 1), 2)
+    >>> migcdex(6, 10, 15)
+    ((1, 1, -1), 1)
+    """
+    if not x:
+        return (), 0
+
+    if len(x) == 1:
+        return (1,), x[0]
+
+    if len(x) == 2:
+        u, v, h = igcdex(x[0], x[1])
+        return (u, v), h
+
+    y, g = migcdex(*x[1:])
+    u, v, h = igcdex(x[0], g)
+    return (u, *(v * i for i in y)), h
+
+
+def ipartfrac(*denoms: int) -> tuple[int, ...]:
+    r"""Compute the partial fraction decomposition.
+
+    Explanation
+    ===========
+
+    Given a rational number $\frac{1}{q_1 \cdots q_n}$ where all
+    $q_1, \cdots, q_n$ are pairwise coprime,
+
+    A partial fraction decomposition is defined as
+
+    .. math::
+        \frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}
+
+    And it can be derived from solving the following diophantine equation for
+    the $p_1, \cdots, p_n$
+
+    .. math::
+        1 = p_1 \prod_{i \ne 1}q_i + \cdots + p_n \prod_{i \ne n}q_i
+
+    Where $q_1, \cdots, q_n$ being pairwise coprime implies
+    $\gcd(\prod_{i \ne 1}q_i, \cdots, \prod_{i \ne n}q_i) = 1$,
+    which guarantees the existence of the solution.
+
+    It is sufficient to compute partial fraction decomposition only
+    for numerator $1$ because partial fraction decomposition for any
+    $\frac{n}{q_1 \cdots q_n}$ can be easily computed by multiplying
+    the result by $n$ afterwards.
+
+    Parameters
+    ==========
+
+    denoms : int
+        The pairwise coprime integer denominators $q_i$ which defines the
+        rational number $\frac{1}{q_1 \cdots q_n}$
+
+    Returns
+    =======
+
+    tuple[int, ...]
+        The list of numerators which semantically corresponds to $p_i$ of the
+        partial fraction decomposition
+        $\frac{1}{q_1 \cdots q_n} = \frac{p_1}{q_1} + \cdots + \frac{p_n}{q_n}$
+
+    Examples
+    ========
+
+    >>> from sympy import Rational, Mul
+    >>> from sympy.functions.elementary._trigonometric_special import ipartfrac
+
+    >>> denoms = 2, 3, 5
+    >>> numers = ipartfrac(2, 3, 5)
+    >>> numers
+    (1, 7, -14)
+
+    >>> Rational(1, Mul(*denoms))
+    1/30
+    >>> out = 0
+    >>> for n, d in zip(numers, denoms):
+    ...    out += Rational(n, d)
+    >>> out
+    1/30
+    """
+    if not denoms:
+        return ()
+
+    def mul(x: int, y: int) -> int:
+        return x * y
+
+    denom = reduce(mul, denoms)
+    a = [denom // x for x in denoms]
+    h, _ = migcdex(*a)
+    return h
+
+
+def fermat_coords(n: int) -> list[int] | None:
+    """If n can be factored in terms of Fermat primes with
+    multiplicity of each being 1, return those primes, else
+    None
+    """
+    primes = []
+    for p in [3, 5, 17, 257, 65537]:
+        quotient, remainder = divmod(n, p)
+        if remainder == 0:
+            n = quotient
+            primes.append(p)
+            if n == 1:
+                return primes
+    return None
+
+
+@cacheit
+def cos_3() -> Expr:
+    r"""Computes $\cos \frac{\pi}{3}$ in square roots"""
+    return S.Half
+
+
+@cacheit
+def cos_5() -> Expr:
+    r"""Computes $\cos \frac{\pi}{5}$ in square roots"""
+    return (sqrt(5) + 1) / 4
+
+
+@cacheit
+def cos_17() -> Expr:
+    r"""Computes $\cos \frac{\pi}{17}$ in square roots"""
+    return sqrt(
+        (15 + sqrt(17)) / 32 + sqrt(2) * (sqrt(17 - sqrt(17)) +
+        sqrt(sqrt(2) * (-8 * sqrt(17 + sqrt(17)) - (1 - sqrt(17))
+        * sqrt(17 - sqrt(17))) + 6 * sqrt(17) + 34)) / 32)
+
+
+@cacheit
+def cos_257() -> Expr:
+    r"""Computes $\cos \frac{\pi}{257}$ in square roots
+
+    References
+    ==========
+
+    .. [*] https://math.stackexchange.com/questions/516142/how-does-cos2-pi-257-look-like-in-real-radicals
+    .. [*] https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    def f1(a: Expr, b: Expr) -> tuple[Expr, Expr]:
+        return (a + sqrt(a**2 + b)) / 2, (a - sqrt(a**2 + b)) / 2
+
+    def f2(a: Expr, b: Expr) -> Expr:
+        return (a - sqrt(a**2 + b))/2
+
+    t1, t2 = f1(S.NegativeOne, Integer(256))
+    z1, z3 = f1(t1, Integer(64))
+    z2, z4 = f1(t2, Integer(64))
+    y1, y5 = f1(z1, 4*(5 + t1 + 2*z1))
+    y6, y2 = f1(z2, 4*(5 + t2 + 2*z2))
+    y3, y7 = f1(z3, 4*(5 + t1 + 2*z3))
+    y8, y4 = f1(z4, 4*(5 + t2 + 2*z4))
+    x1, x9 = f1(y1, -4*(t1 + y1 + y3 + 2*y6))
+    x2, x10 = f1(y2, -4*(t2 + y2 + y4 + 2*y7))
+    x3, x11 = f1(y3, -4*(t1 + y3 + y5 + 2*y8))
+    x4, x12 = f1(y4, -4*(t2 + y4 + y6 + 2*y1))
+    x5, x13 = f1(y5, -4*(t1 + y5 + y7 + 2*y2))
+    x6, x14 = f1(y6, -4*(t2 + y6 + y8 + 2*y3))
+    x15, x7 = f1(y7, -4*(t1 + y7 + y1 + 2*y4))
+    x8, x16 = f1(y8, -4*(t2 + y8 + y2 + 2*y5))
+    v1 = f2(x1, -4*(x1 + x2 + x3 + x6))
+    v2 = f2(x2, -4*(x2 + x3 + x4 + x7))
+    v3 = f2(x8, -4*(x8 + x9 + x10 + x13))
+    v4 = f2(x9, -4*(x9 + x10 + x11 + x14))
+    v5 = f2(x10, -4*(x10 + x11 + x12 + x15))
+    v6 = f2(x16, -4*(x16 + x1 + x2 + x5))
+    u1 = -f2(-v1, -4*(v2 + v3))
+    u2 = -f2(-v4, -4*(v5 + v6))
+    w1 = -2*f2(-u1, -4*u2)
+    return sqrt(sqrt(2)*sqrt(w1 + 4)/8 + S.Half)
+
+
+def cos_table() -> dict[int, Callable[[], Expr]]:
+    r"""Lazily evaluated table for $\cos \frac{\pi}{n}$ in square roots for
+    $n \in \{3, 5, 17, 257, 65537\}$.
+
+    Notes
+    =====
+
+    65537 is the only other known Fermat prime and it is nearly impossible to
+    build in the current SymPy due to performance issues.
+
+    References
+    ==========
+
+    https://r-knott.surrey.ac.uk/Fibonacci/simpleTrig.html
+    """
+    return {
+        3: cos_3,
+        5: cos_5,
+        17: cos_17,
+        257: cos_257
+    }
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf56e108b8cc293afc24598a94e05fdbbfeadb5d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/bench_exp.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/bench_exp.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a73f4daac042c7a418ac8babcd8a8f67f1f61574
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/__pycache__/bench_exp.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/bench_exp.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/bench_exp.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa18d29f87bcd249baec1d278a030fa7a133c3ba
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/benchmarks/bench_exp.py
@@ -0,0 +1,11 @@
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import exp
+
+x, y = symbols('x,y')
+
+e = exp(2*x)
+q = exp(3*x)
+
+
+def timeit_exp_subs():
+    e.subs(q, y)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/complexes.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/complexes.py
new file mode 100644
index 0000000000000000000000000000000000000000..dd837e4e242057050370f38c4b4e9c26aa5d06c9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/complexes.py
@@ -0,0 +1,1492 @@
+from __future__ import annotations
+
+from sympy.core import S, Add, Mul, sympify, Symbol, Dummy, Basic
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.function import (DefinedFunction, Derivative, ArgumentIndexError,
+    AppliedUndef, expand_mul, PoleError)
+from sympy.core.logic import fuzzy_not, fuzzy_or
+from sympy.core.numbers import pi, I, oo
+from sympy.core.power import Pow
+from sympy.core.relational import Eq
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+
+###############################################################################
+######################### REAL and IMAGINARY PARTS ############################
+###############################################################################
+
+
+class re(DefinedFunction):
+    """
+    Returns real part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly
+    more complicated expressions. If completely simplified result
+    is needed then use ``Basic.as_real_imag()`` or perform complex
+    expansion on instance of this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, I, E, symbols
+    >>> x, y = symbols('x y', real=True)
+    >>> re(2*E)
+    2*E
+    >>> re(2*I + 17)
+    17
+    >>> re(2*I)
+    0
+    >>> re(im(x) + x*I + 2)
+    2
+    >>> re(5 + I + 2)
+    7
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Real part of expression.
+
+    See Also
+    ========
+
+    im
+    """
+
+    args: tuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return arg
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return S.Zero
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[0]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return re(arg.args[0])
+        else:
+
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                elif not term.has(I) and term.is_extended_real:
+                    excluded.append(term)
+                else:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do re(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[0])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) - im(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns the real number with a zero imaginary part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return re(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * im(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_im(self, arg, **kwargs):
+        return self.args[0] - I*im(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        # is_imaginary implies nonzero
+        return fuzzy_or([self.args[0].is_imaginary, self.args[0].is_zero])
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+
+class im(DefinedFunction):
+    """
+    Returns imaginary part of expression. This function performs only
+    elementary analysis and so it will fail to decompose properly more
+    complicated expressions. If completely simplified result is needed then
+    use ``Basic.as_real_imag()`` or perform complex expansion on instance of
+    this function.
+
+    Examples
+    ========
+
+    >>> from sympy import re, im, E, I
+    >>> from sympy.abc import x, y
+    >>> im(2*E)
+    0
+    >>> im(2*I + 17)
+    2
+    >>> im(x*I)
+    re(x)
+    >>> im(re(x) + y)
+    im(y)
+    >>> im(2 + 3*I)
+    3
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Imaginary part of expression.
+
+    See Also
+    ========
+
+    re
+    """
+
+    args: tuple[Expr]
+
+    is_extended_real = True
+    unbranched = True  # implicitly works on the projection to C
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        if arg is S.NaN:
+            return S.NaN
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif arg.is_extended_real:
+            return S.Zero
+        elif arg.is_imaginary or (I*arg).is_extended_real:
+            return -I * arg
+        elif arg.is_Matrix:
+            return arg.as_real_imag()[1]
+        elif arg.is_Function and isinstance(arg, conjugate):
+            return -im(arg.args[0])
+        else:
+            included, reverted, excluded = [], [], []
+            args = Add.make_args(arg)
+            for term in args:
+                coeff = term.as_coefficient(I)
+
+                if coeff is not None:
+                    if not coeff.is_extended_real:
+                        reverted.append(coeff)
+                    else:
+                        excluded.append(coeff)
+                elif term.has(I) or not term.is_extended_real:
+                    # Try to do some advanced expansion.  If
+                    # impossible, don't try to do im(arg) again
+                    # (because this is what we are trying to do now).
+                    real_imag = term.as_real_imag(ignore=arg)
+                    if real_imag:
+                        excluded.append(real_imag[1])
+                    else:
+                        included.append(term)
+
+            if len(args) != len(included):
+                a, b, c = (Add(*xs) for xs in [included, reverted, excluded])
+
+                return cls(a) + re(b) + c
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Return the imaginary part with a zero real part.
+
+        """
+        return (self, S.Zero)
+
+    def _eval_derivative(self, x):
+        if x.is_extended_real or self.args[0].is_extended_real:
+            return im(Derivative(self.args[0], x, evaluate=True))
+        if x.is_imaginary or self.args[0].is_imaginary:
+            return -I \
+                * re(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_rewrite_as_re(self, arg, **kwargs):
+        return -I*(self.args[0] - re(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_is_zero(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_finite:
+            return True
+
+###############################################################################
+############### SIGN, ABSOLUTE VALUE, ARGUMENT and CONJUGATION ################
+###############################################################################
+
+class sign(DefinedFunction):
+    """
+    Returns the complex sign of an expression:
+
+    Explanation
+    ===========
+
+    If the expression is real the sign will be:
+
+        * $1$ if expression is positive
+        * $0$ if expression is equal to zero
+        * $-1$ if expression is negative
+
+    If the expression is imaginary the sign will be:
+
+        * $I$ if im(expression) is positive
+        * $-I$ if im(expression) is negative
+
+    Otherwise an unevaluated expression will be returned. When evaluated, the
+    result (in general) will be ``cos(arg(expr)) + I*sin(arg(expr))``.
+
+    Examples
+    ========
+
+    >>> from sympy import sign, I
+
+    >>> sign(-1)
+    -1
+    >>> sign(0)
+    0
+    >>> sign(-3*I)
+    -I
+    >>> sign(1 + I)
+    sign(1 + I)
+    >>> _.evalf()
+    0.707106781186548 + 0.707106781186548*I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or imaginary expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Complex sign of expression.
+
+    See Also
+    ========
+
+    Abs, conjugate
+    """
+
+    is_complex = True
+    _singularities = True
+
+    def doit(self, **hints):
+        s = super().doit()
+        if s == self and self.args[0].is_zero is False:
+            return self.args[0] / Abs(self.args[0])
+        return s
+
+    @classmethod
+    def eval(cls, arg):
+        # handle what we can
+        if arg.is_Mul:
+            c, args = arg.as_coeff_mul()
+            unk = []
+            s = sign(c)
+            for a in args:
+                if a.is_extended_negative:
+                    s = -s
+                elif a.is_extended_positive:
+                    pass
+                else:
+                    if a.is_imaginary:
+                        ai = im(a)
+                        if ai.is_comparable:  # i.e. a = I*real
+                            s *= I
+                            if ai.is_extended_negative:
+                                # can't use sign(ai) here since ai might not be
+                                # a Number
+                                s = -s
+                        else:
+                            unk.append(a)
+                    else:
+                        unk.append(a)
+            if c is S.One and len(unk) == len(args):
+                return None
+            return s * cls(arg._new_rawargs(*unk))
+        if arg is S.NaN:
+            return S.NaN
+        if arg.is_zero:  # it may be an Expr that is zero
+            return S.Zero
+        if arg.is_extended_positive:
+            return S.One
+        if arg.is_extended_negative:
+            return S.NegativeOne
+        if arg.is_Function:
+            if isinstance(arg, sign):
+                return arg
+        if arg.is_imaginary:
+            if arg.is_Pow and arg.exp is S.Half:
+                # we catch this because non-trivial sqrt args are not expanded
+                # e.g. sqrt(1-sqrt(2)) --x-->  to I*sqrt(sqrt(2) - 1)
+                return I
+            arg2 = -I * arg
+            if arg2.is_extended_positive:
+                return I
+            if arg2.is_extended_negative:
+                return -I
+
+    def _eval_Abs(self):
+        if fuzzy_not(self.args[0].is_zero):
+            return S.One
+
+    def _eval_conjugate(self):
+        return sign(conjugate(self.args[0]))
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(self.args[0])
+        elif self.args[0].is_imaginary:
+            from sympy.functions.special.delta_functions import DiracDelta
+            return 2 * Derivative(self.args[0], x, evaluate=True) \
+                * DiracDelta(-I * self.args[0])
+
+    def _eval_is_nonnegative(self):
+        if self.args[0].is_nonnegative:
+            return True
+
+    def _eval_is_nonpositive(self):
+        if self.args[0].is_nonpositive:
+            return True
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_power(self, other):
+        if (
+            fuzzy_not(self.args[0].is_zero) and
+            other.is_integer and
+            other.is_even
+        ):
+            return S.One
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg0 = self.args[0]
+        x0 = arg0.subs(x, 0)
+        if x0 != 0:
+            return self.func(x0)
+        if cdir != 0:
+            cdir = arg0.dir(x, cdir)
+        return -S.One if re(cdir) < 0 else S.One
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((1, arg > 0), (-1, arg < 0), (0, True))
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return Heaviside(arg) * 2 - 1
+
+    def _eval_rewrite_as_Abs(self, arg, **kwargs):
+        return Piecewise((0, Eq(arg, 0)), (arg / Abs(arg), True))
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(factor_terms(self.args[0]))  # XXX include doit?
+
+
+class Abs(DefinedFunction):
+    """
+    Return the absolute value of the argument.
+
+    Explanation
+    ===========
+
+    This is an extension of the built-in function ``abs()`` to accept symbolic
+    values.  If you pass a SymPy expression to the built-in ``abs()``, it will
+    pass it automatically to ``Abs()``.
+
+    Examples
+    ========
+
+    >>> from sympy import Abs, Symbol, S, I
+    >>> Abs(-1)
+    1
+    >>> x = Symbol('x', real=True)
+    >>> Abs(-x)
+    Abs(x)
+    >>> Abs(x**2)
+    x**2
+    >>> abs(-x) # The Python built-in
+    Abs(x)
+    >>> Abs(3*x + 2*I)
+    sqrt(9*x**2 + 4)
+    >>> Abs(8*I)
+    8
+
+    Note that the Python built-in will return either an Expr or int depending on
+    the argument::
+
+        >>> type(abs(-1))
+        <... 'int'>
+        >>> type(abs(S.NegativeOne))
+        
+
+    Abs will always return a SymPy object.
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    expr : Expr
+        Absolute value returned can be an expression or integer depending on
+        input arg.
+
+    See Also
+    ========
+
+    sign, conjugate
+    """
+
+    args: tuple[Expr]
+
+    is_extended_real = True
+    is_extended_negative = False
+    is_extended_nonnegative = True
+    unbranched = True
+    _singularities = True  # non-holomorphic
+
+    def fdiff(self, argindex=1):
+        """
+        Get the first derivative of the argument to Abs().
+
+        """
+        if argindex == 1:
+            return sign(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.simplify.simplify import signsimp
+
+        if hasattr(arg, '_eval_Abs'):
+            obj = arg._eval_Abs()
+            if obj is not None:
+                return obj
+        if not isinstance(arg, Expr):
+            raise TypeError("Bad argument type for Abs(): %s" % type(arg))
+
+        # handle what we can
+        arg = signsimp(arg, evaluate=False)
+        n, d = arg.as_numer_denom()
+        if d.free_symbols and not n.free_symbols:
+            return cls(n)/cls(d)
+
+        if arg.is_Mul:
+            known = []
+            unk = []
+            for t in arg.args:
+                if t.is_Pow and t.exp.is_integer and t.exp.is_negative:
+                    bnew = cls(t.base)
+                    if isinstance(bnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(Pow(bnew, t.exp))
+                else:
+                    tnew = cls(t)
+                    if isinstance(tnew, cls):
+                        unk.append(t)
+                    else:
+                        known.append(tnew)
+            known = Mul(*known)
+            unk = cls(Mul(*unk), evaluate=False) if unk else S.One
+            return known*unk
+        if arg is S.NaN:
+            return S.NaN
+        if arg is S.ComplexInfinity:
+            return oo
+        from sympy.functions.elementary.exponential import exp, log
+
+        if arg.is_Pow:
+            base, exponent = arg.as_base_exp()
+            if base.is_extended_real:
+                if exponent.is_integer:
+                    if exponent.is_even:
+                        return arg
+                    if base is S.NegativeOne:
+                        return S.One
+                    return Abs(base)**exponent
+                if base.is_extended_nonnegative:
+                    return base**re(exponent)
+                if base.is_extended_negative:
+                    return (-base)**re(exponent)*exp(-pi*im(exponent))
+                return
+            elif not base.has(Symbol): # complex base
+                # express base**exponent as exp(exponent*log(base))
+                a, b = log(base).as_real_imag()
+                z = a + I*b
+                return exp(re(exponent*z))
+        if isinstance(arg, exp):
+            return exp(re(arg.args[0]))
+        if isinstance(arg, AppliedUndef):
+            if arg.is_positive:
+                return arg
+            elif arg.is_negative:
+                return -arg
+            return
+        if arg.is_Add and arg.has(oo, S.NegativeInfinity):
+            if any(a.is_infinite for a in arg.as_real_imag()):
+                return oo
+        if arg.is_zero:
+            return S.Zero
+        if arg.is_extended_nonnegative:
+            return arg
+        if arg.is_extended_nonpositive:
+            return -arg
+        if arg.is_imaginary:
+            arg2 = -I * arg
+            if arg2.is_extended_nonnegative:
+                return arg2
+        if arg.is_extended_real:
+            return
+        # reject result if all new conjugates are just wrappers around
+        # an expression that was already in the arg
+        conj = signsimp(arg.conjugate(), evaluate=False)
+        new_conj = conj.atoms(conjugate) - arg.atoms(conjugate)
+        if new_conj and all(arg.has(i.args[0]) for i in new_conj):
+            return
+        if arg != conj and arg != -conj:
+            ignore = arg.atoms(Abs)
+            abs_free_arg = arg.xreplace({i: Dummy(real=True) for i in ignore})
+            unk = [a for a in abs_free_arg.free_symbols if a.is_extended_real is None]
+            if not unk or not all(conj.has(conjugate(u)) for u in unk):
+                return sqrt(expand_mul(arg*conj))
+
+    def _eval_is_real(self):
+        if self.args[0].is_finite:
+            return True
+
+    def _eval_is_integer(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_integer
+
+    def _eval_is_extended_nonzero(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_zero(self):
+        return self._args[0].is_zero
+
+    def _eval_is_extended_positive(self):
+        return fuzzy_not(self._args[0].is_zero)
+
+    def _eval_is_rational(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_rational
+
+    def _eval_is_even(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_even
+
+    def _eval_is_odd(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_odd
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+    def _eval_power(self, exponent):
+        if self.args[0].is_extended_real and exponent.is_integer:
+            if exponent.is_even:
+                return self.args[0]**exponent
+            elif exponent is not S.NegativeOne and exponent.is_Integer:
+                return self.args[0]**(exponent - 1)*self
+        return
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.functions.elementary.exponential import log
+        direction = self.args[0].leadterm(x)[0]
+        if direction.has(log(x)):
+            direction = direction.subs(log(x), logx)
+        s = self.args[0]._eval_nseries(x, n=n, logx=logx)
+        return (sign(direction)*s).expand()
+
+    def _eval_derivative(self, x):
+        if self.args[0].is_extended_real or self.args[0].is_imaginary:
+            return Derivative(self.args[0], x, evaluate=True) \
+                * sign(conjugate(self.args[0]))
+        rv = (re(self.args[0]) * Derivative(re(self.args[0]), x,
+            evaluate=True) + im(self.args[0]) * Derivative(im(self.args[0]),
+                x, evaluate=True)) / Abs(self.args[0])
+        return rv.rewrite(sign)
+
+    def _eval_rewrite_as_Heaviside(self, arg, **kwargs):
+        # Note this only holds for real arg (since Heaviside is not defined
+        # for complex arguments).
+        from sympy.functions.special.delta_functions import Heaviside
+        if arg.is_extended_real:
+            return arg*(Heaviside(arg) - Heaviside(-arg))
+
+    def _eval_rewrite_as_Piecewise(self, arg, **kwargs):
+        if arg.is_extended_real:
+            return Piecewise((arg, arg >= 0), (-arg, True))
+        elif arg.is_imaginary:
+            return Piecewise((I*arg, I*arg >= 0), (-I*arg, True))
+
+    def _eval_rewrite_as_sign(self, arg, **kwargs):
+        return arg/sign(arg)
+
+    def _eval_rewrite_as_conjugate(self, arg, **kwargs):
+        return sqrt(arg*conjugate(arg))
+
+
+class arg(DefinedFunction):
+    r"""
+    Returns the argument (in radians) of a complex number. The argument is
+    evaluated in consistent convention with ``atan2`` where the branch-cut is
+    taken along the negative real axis and ``arg(z)`` is in the interval
+    $(-\pi,\pi]$. For a positive number, the argument is always 0; the
+    argument of a negative number is $\pi$; and the argument of 0
+    is undefined and returns ``nan``. So the ``arg`` function will never nest
+    greater than 3 levels since at the 4th application, the result must be
+    nan; for a real number, nan is returned on the 3rd application.
+
+    Examples
+    ========
+
+    >>> from sympy import arg, I, sqrt, Dummy
+    >>> from sympy.abc import x
+    >>> arg(2.0)
+    0
+    >>> arg(I)
+    pi/2
+    >>> arg(sqrt(2) + I*sqrt(2))
+    pi/4
+    >>> arg(sqrt(3)/2 + I/2)
+    pi/6
+    >>> arg(4 + 3*I)
+    atan(3/4)
+    >>> arg(0.8 + 0.6*I)
+    0.643501108793284
+    >>> arg(arg(arg(arg(x))))
+    nan
+    >>> real = Dummy(real=True)
+    >>> arg(arg(arg(real)))
+    nan
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    value : Expr
+        Returns arc tangent of arg measured in radians.
+
+    """
+
+    is_extended_real = True
+    is_real = True
+    is_finite = True
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        a = arg
+        for i in range(3):
+            if isinstance(a, cls):
+                a = a.args[0]
+            else:
+                if i == 2 and a.is_extended_real:
+                    return S.NaN
+                break
+        else:
+            return S.NaN
+        from sympy.functions.elementary.exponential import exp, exp_polar
+        if isinstance(arg, exp_polar):
+            return periodic_argument(arg, oo)
+        elif isinstance(arg, exp):
+            i_ = im(arg.args[0])
+            if i_.is_comparable:
+                i_ %= 2*S.Pi
+                if i_ > S.Pi:
+                    i_ -= 2*S.Pi
+                return i_
+
+        if not arg.is_Atom:
+            c, arg_ = factor_terms(arg).as_coeff_Mul()
+            if arg_.is_Mul:
+                arg_ = Mul(*[a if (sign(a) not in (-1, 1)) else
+                    sign(a) for a in arg_.args])
+            arg_ = sign(c)*arg_
+        else:
+            arg_ = arg
+        if any(i.is_extended_positive is None for i in arg_.atoms(AppliedUndef)):
+            return
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = arg_.as_real_imag()
+        rv = atan2(y, x)
+        if rv.is_number:
+            return rv
+        if arg_ != arg:
+            return cls(arg_, evaluate=False)
+
+    def _eval_derivative(self, t):
+        x, y = self.args[0].as_real_imag()
+        return (x * Derivative(y, t, evaluate=True) - y *
+                    Derivative(x, t, evaluate=True)) / (x**2 + y**2)
+
+    def _eval_rewrite_as_atan2(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import atan2
+        x, y = self.args[0].as_real_imag()
+        return atan2(y, x)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg0 = self.args[0]
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg0.subs(x, cdir*t)
+        if z.is_positive:
+            return S.Zero
+        elif z.is_negative:
+            return S.Pi
+        else:
+            raise PoleError("Cannot expand %s around 0" % (self))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        if n <= 0:
+            return Order(1)
+        return self._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+
+class conjugate(DefinedFunction):
+    """
+    Returns the *complex conjugate* [1]_ of an argument.
+    In mathematics, the complex conjugate of a complex number
+    is given by changing the sign of the imaginary part.
+
+    Thus, the conjugate of the complex number
+    :math:`a + ib` (where $a$ and $b$ are real numbers) is :math:`a - ib`
+
+    Examples
+    ========
+
+    >>> from sympy import conjugate, I
+    >>> conjugate(2)
+    2
+    >>> conjugate(I)
+    -I
+    >>> conjugate(3 + 2*I)
+    3 - 2*I
+    >>> conjugate(5 - I)
+    5 + I
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    Returns
+    =======
+
+    arg : Expr
+        Complex conjugate of arg as real, imaginary or mixed expression.
+
+    See Also
+    ========
+
+    sign, Abs
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Complex_conjugation
+    """
+    _singularities = True  # non-holomorphic
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_conjugate()
+        if obj is not None:
+            return obj
+
+    def inverse(self):
+        return conjugate
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+    def _eval_adjoint(self):
+        return transpose(self.args[0])
+
+    def _eval_conjugate(self):
+        return self.args[0]
+
+    def _eval_derivative(self, x):
+        if x.is_real:
+            return conjugate(Derivative(self.args[0], x, evaluate=True))
+        elif x.is_imaginary:
+            return -conjugate(Derivative(self.args[0], x, evaluate=True))
+
+    def _eval_transpose(self):
+        return adjoint(self.args[0])
+
+    def _eval_is_algebraic(self):
+        return self.args[0].is_algebraic
+
+
+class transpose(DefinedFunction):
+    """
+    Linear map transposition.
+
+    Examples
+    ========
+
+    >>> from sympy import transpose, Matrix, MatrixSymbol
+    >>> A = MatrixSymbol('A', 25, 9)
+    >>> transpose(A)
+    A.T
+    >>> B = MatrixSymbol('B', 9, 22)
+    >>> transpose(B)
+    B.T
+    >>> transpose(A*B)
+    B.T*A.T
+    >>> M = Matrix([[4, 5], [2, 1], [90, 12]])
+    >>> M
+    Matrix([
+    [ 4,  5],
+    [ 2,  1],
+    [90, 12]])
+    >>> transpose(M)
+    Matrix([
+    [4, 2, 90],
+    [5, 1, 12]])
+
+    Parameters
+    ==========
+
+    arg : Matrix
+         Matrix or matrix expression to take the transpose of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Transpose of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return obj
+
+    def _eval_adjoint(self):
+        return conjugate(self.args[0])
+
+    def _eval_conjugate(self):
+        return adjoint(self.args[0])
+
+    def _eval_transpose(self):
+        return self.args[0]
+
+
+class adjoint(DefinedFunction):
+    """
+    Conjugate transpose or Hermite conjugation.
+
+    Examples
+    ========
+
+    >>> from sympy import adjoint, MatrixSymbol
+    >>> A = MatrixSymbol('A', 10, 5)
+    >>> adjoint(A)
+    Adjoint(A)
+
+    Parameters
+    ==========
+
+    arg : Matrix
+        Matrix or matrix expression to take the adjoint of.
+
+    Returns
+    =======
+
+    value : Matrix
+        Represents the conjugate transpose or Hermite
+        conjugation of arg.
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        obj = arg._eval_adjoint()
+        if obj is not None:
+            return obj
+        obj = arg._eval_transpose()
+        if obj is not None:
+            return conjugate(obj)
+
+    def _eval_adjoint(self):
+        return self.args[0]
+
+    def _eval_conjugate(self):
+        return transpose(self.args[0])
+
+    def _eval_transpose(self):
+        return conjugate(self.args[0])
+
+    def _latex(self, printer, exp=None, *args):
+        arg = printer._print(self.args[0])
+        tex = r'%s^{\dagger}' % arg
+        if exp:
+            tex = r'\left(%s\right)^{%s}' % (tex, exp)
+        return tex
+
+    def _pretty(self, printer, *args):
+        from sympy.printing.pretty.stringpict import prettyForm
+        pform = printer._print(self.args[0], *args)
+        if printer._use_unicode:
+            pform = pform**prettyForm('\N{DAGGER}')
+        else:
+            pform = pform**prettyForm('+')
+        return pform
+
+###############################################################################
+############### HANDLING OF POLAR NUMBERS #####################################
+###############################################################################
+
+
+class polar_lift(DefinedFunction):
+    """
+    Lift argument to the Riemann surface of the logarithm, using the
+    standard branch.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, polar_lift, I
+    >>> p = Symbol('p', polar=True)
+    >>> x = Symbol('x')
+    >>> polar_lift(4)
+    4*exp_polar(0)
+    >>> polar_lift(-4)
+    4*exp_polar(I*pi)
+    >>> polar_lift(-I)
+    exp_polar(-I*pi/2)
+    >>> polar_lift(I + 2)
+    polar_lift(2 + I)
+
+    >>> polar_lift(4*x)
+    4*polar_lift(x)
+    >>> polar_lift(4*p)
+    4*p
+
+    Parameters
+    ==========
+
+    arg : Expr
+        Real or complex expression.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # Cannot be evalf'd.
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.complexes import arg as argument
+        if arg.is_number:
+            ar = argument(arg)
+            # In general we want to affirm that something is known,
+            # e.g. `not ar.has(argument) and not ar.has(atan)`
+            # but for now we will just be more restrictive and
+            # see that it has evaluated to one of the known values.
+            if ar in (0, pi/2, -pi/2, pi):
+                from sympy.functions.elementary.exponential import exp_polar
+                return exp_polar(I*ar)*abs(arg)
+
+        if arg.is_Mul:
+            args = arg.args
+        else:
+            args = [arg]
+        included = []
+        excluded = []
+        positive = []
+        for arg in args:
+            if arg.is_polar:
+                included += [arg]
+            elif arg.is_positive:
+                positive += [arg]
+            else:
+                excluded += [arg]
+        if len(excluded) < len(args):
+            if excluded:
+                return Mul(*(included + positive))*polar_lift(Mul(*excluded))
+            elif included:
+                return Mul(*(included + positive))
+            else:
+                from sympy.functions.elementary.exponential import exp_polar
+                return Mul(*positive)*exp_polar(0)
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        return self.args[0]._eval_evalf(prec)
+
+    def _eval_Abs(self):
+        return Abs(self.args[0], evaluate=True)
+
+
+class periodic_argument(DefinedFunction):
+    r"""
+    Represent the argument on a quotient of the Riemann surface of the
+    logarithm. That is, given a period $P$, always return a value in
+    $(-P/2, P/2]$, by using $\exp(PI) = 1$.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(10*I*pi), 2*pi)
+    0
+    >>> periodic_argument(exp_polar(5*I*pi), 4*pi)
+    pi
+    >>> from sympy import exp_polar, periodic_argument
+    >>> from sympy import I, pi
+    >>> periodic_argument(exp_polar(5*I*pi), 2*pi)
+    pi
+    >>> periodic_argument(exp_polar(5*I*pi), 3*pi)
+    -pi
+    >>> periodic_argument(exp_polar(5*I*pi), pi)
+    0
+
+    Parameters
+    ==========
+
+    ar : Expr
+        A polar number.
+
+    period : Expr
+        The period $P$.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    principal_branch
+    """
+
+    @classmethod
+    def _getunbranched(cls, ar):
+        from sympy.functions.elementary.exponential import exp_polar, log
+        if ar.is_Mul:
+            args = ar.args
+        else:
+            args = [ar]
+        unbranched = 0
+        for a in args:
+            if not a.is_polar:
+                unbranched += arg(a)
+            elif isinstance(a, exp_polar):
+                unbranched += a.exp.as_real_imag()[1]
+            elif a.is_Pow:
+                re, im = a.exp.as_real_imag()
+                unbranched += re*unbranched_argument(
+                    a.base) + im*log(abs(a.base))
+            elif isinstance(a, polar_lift):
+                unbranched += arg(a.args[0])
+            else:
+                return None
+        return unbranched
+
+    @classmethod
+    def eval(cls, ar, period):
+        # Our strategy is to evaluate the argument on the Riemann surface of the
+        # logarithm, and then reduce.
+        # NOTE evidently this means it is a rather bad idea to use this with
+        # period != 2*pi and non-polar numbers.
+        if not period.is_extended_positive:
+            return None
+        if period == oo and isinstance(ar, principal_branch):
+            return periodic_argument(*ar.args)
+        if isinstance(ar, polar_lift) and period >= 2*pi:
+            return periodic_argument(ar.args[0], period)
+        if ar.is_Mul:
+            newargs = [x for x in ar.args if not x.is_positive]
+            if len(newargs) != len(ar.args):
+                return periodic_argument(Mul(*newargs), period)
+        unbranched = cls._getunbranched(ar)
+        if unbranched is None:
+            return None
+        from sympy.functions.elementary.trigonometric import atan, atan2
+        if unbranched.has(periodic_argument, atan2, atan):
+            return None
+        if period == oo:
+            return unbranched
+        if period != oo:
+            from sympy.functions.elementary.integers import ceiling
+            n = ceiling(unbranched/period - S.Half)*period
+            if not n.has(ceiling):
+                return unbranched - n
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        if period == oo:
+            unbranched = periodic_argument._getunbranched(z)
+            if unbranched is None:
+                return self
+            return unbranched._eval_evalf(prec)
+        ub = periodic_argument(z, oo)._eval_evalf(prec)
+        from sympy.functions.elementary.integers import ceiling
+        return (ub - ceiling(ub/period - S.Half)*period)._eval_evalf(prec)
+
+
+def unbranched_argument(arg):
+    '''
+    Returns periodic argument of arg with period as infinity.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, unbranched_argument
+    >>> from sympy import I, pi
+    >>> unbranched_argument(exp_polar(15*I*pi))
+    15*pi
+    >>> unbranched_argument(exp_polar(7*I*pi))
+    7*pi
+
+    See also
+    ========
+
+    periodic_argument
+    '''
+    return periodic_argument(arg, oo)
+
+
+class principal_branch(DefinedFunction):
+    """
+    Represent a polar number reduced to its principal branch on a quotient
+    of the Riemann surface of the logarithm.
+
+    Explanation
+    ===========
+
+    This is a function of two arguments. The first argument is a polar
+    number `z`, and the second one a positive real number or infinity, `p`.
+    The result is ``z mod exp_polar(I*p)``.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, principal_branch, oo, I, pi
+    >>> from sympy.abc import z
+    >>> principal_branch(z, oo)
+    z
+    >>> principal_branch(exp_polar(2*pi*I)*3, 2*pi)
+    3*exp_polar(0)
+    >>> principal_branch(exp_polar(2*pi*I)*3*z, 2*pi)
+    3*principal_branch(z, 2*pi)
+
+    Parameters
+    ==========
+
+    x : Expr
+        A polar number.
+
+    period : Expr
+        Positive real number or infinity.
+
+    See Also
+    ========
+
+    sympy.functions.elementary.exponential.exp_polar
+    polar_lift : Lift argument to the Riemann surface of the logarithm
+    periodic_argument
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot always be evalf'd
+
+    @classmethod
+    def eval(self, x, period):
+        from sympy.functions.elementary.exponential import exp_polar
+        if isinstance(x, polar_lift):
+            return principal_branch(x.args[0], period)
+        if period == oo:
+            return x
+        ub = periodic_argument(x, oo)
+        barg = periodic_argument(x, period)
+        if ub != barg and not ub.has(periodic_argument) \
+                and not barg.has(periodic_argument):
+            pl = polar_lift(x)
+
+            def mr(expr):
+                if not isinstance(expr, Symbol):
+                    return polar_lift(expr)
+                return expr
+            pl = pl.replace(polar_lift, mr)
+            # Recompute unbranched argument
+            ub = periodic_argument(pl, oo)
+            if not pl.has(polar_lift):
+                if ub != barg:
+                    res = exp_polar(I*(barg - ub))*pl
+                else:
+                    res = pl
+                if not res.is_polar and not res.has(exp_polar):
+                    res *= exp_polar(0)
+                return res
+
+        if not x.free_symbols:
+            c, m = x, ()
+        else:
+            c, m = x.as_coeff_mul(*x.free_symbols)
+        others = []
+        for y in m:
+            if y.is_positive:
+                c *= y
+            else:
+                others += [y]
+        m = tuple(others)
+        arg = periodic_argument(c, period)
+        if arg.has(periodic_argument):
+            return None
+        if arg.is_number and (unbranched_argument(c) != arg or
+                              (arg == 0 and m != () and c != 1)):
+            if arg == 0:
+                return abs(c)*principal_branch(Mul(*m), period)
+            return principal_branch(exp_polar(I*arg)*Mul(*m), period)*abs(c)
+        if arg.is_number and ((abs(arg) < period/2) == True or arg == period/2) \
+                and m == ():
+            return exp_polar(arg*I)*abs(c)
+
+    def _eval_evalf(self, prec):
+        z, period = self.args
+        p = periodic_argument(z, period)._eval_evalf(prec)
+        if abs(p) > pi or p == -pi:
+            return self  # Cannot evalf for this argument.
+        from sympy.functions.elementary.exponential import exp
+        return (abs(z)*exp(I*p))._eval_evalf(prec)
+
+
+def _polarify(eq, lift, pause=False):
+    from sympy.integrals.integrals import Integral
+    if eq.is_polar:
+        return eq
+    if eq.is_number and not pause:
+        return polar_lift(eq)
+    if isinstance(eq, Symbol) and not pause and lift:
+        return polar_lift(eq)
+    elif eq.is_Atom:
+        return eq
+    elif eq.is_Add:
+        r = eq.func(*[_polarify(arg, lift, pause=True) for arg in eq.args])
+        if lift:
+            return polar_lift(r)
+        return r
+    elif eq.is_Pow and eq.base == S.Exp1:
+        return eq.func(S.Exp1, _polarify(eq.exp, lift, pause=False))
+    elif eq.is_Function:
+        return eq.func(*[_polarify(arg, lift, pause=False) for arg in eq.args])
+    elif isinstance(eq, Integral):
+        # Don't lift the integration variable
+        func = _polarify(eq.function, lift, pause=pause)
+        limits = []
+        for limit in eq.args[1:]:
+            var = _polarify(limit[0], lift=False, pause=pause)
+            rest = _polarify(limit[1:], lift=lift, pause=pause)
+            limits.append((var,) + rest)
+        return Integral(*((func,) + tuple(limits)))
+    else:
+        return eq.func(*[_polarify(arg, lift, pause=pause)
+                         if isinstance(arg, Expr) else arg for arg in eq.args])
+
+
+def polarify(eq, subs=True, lift=False):
+    """
+    Turn all numbers in eq into their polar equivalents (under the standard
+    choice of argument).
+
+    Note that no attempt is made to guess a formal convention of adding
+    polar numbers, expressions like $1 + x$ will generally not be altered.
+
+    Note also that this function does not promote ``exp(x)`` to ``exp_polar(x)``.
+
+    If ``subs`` is ``True``, all symbols which are not already polar will be
+    substituted for polar dummies; in this case the function behaves much
+    like :func:`~.posify`.
+
+    If ``lift`` is ``True``, both addition statements and non-polar symbols are
+    changed to their ``polar_lift()``ed versions.
+    Note that ``lift=True`` implies ``subs=False``.
+
+    Examples
+    ========
+
+    >>> from sympy import polarify, sin, I
+    >>> from sympy.abc import x, y
+    >>> expr = (-x)**y
+    >>> expr.expand()
+    (-x)**y
+    >>> polarify(expr)
+    ((_x*exp_polar(I*pi))**_y, {_x: x, _y: y})
+    >>> polarify(expr)[0].expand()
+    _x**_y*exp_polar(_y*I*pi)
+    >>> polarify(x, lift=True)
+    polar_lift(x)
+    >>> polarify(x*(1+y), lift=True)
+    polar_lift(x)*polar_lift(y + 1)
+
+    Adds are treated carefully:
+
+    >>> polarify(1 + sin((1 + I)*x))
+    (sin(_x*polar_lift(1 + I)) + 1, {_x: x})
+    """
+    if lift:
+        subs = False
+    eq = _polarify(sympify(eq), lift)
+    if not subs:
+        return eq
+    reps = {s: Dummy(s.name, polar=True) for s in eq.free_symbols}
+    eq = eq.subs(reps)
+    return eq, {r: s for s, r in reps.items()}
+
+
+def _unpolarify(eq, exponents_only, pause=False):
+    if not isinstance(eq, Basic) or eq.is_Atom:
+        return eq
+
+    if not pause:
+        from sympy.functions.elementary.exponential import exp, exp_polar
+        if isinstance(eq, exp_polar):
+            return exp(_unpolarify(eq.exp, exponents_only))
+        if isinstance(eq, principal_branch) and eq.args[1] == 2*pi:
+            return _unpolarify(eq.args[0], exponents_only)
+        if (
+            eq.is_Add or eq.is_Mul or eq.is_Boolean or
+            eq.is_Relational and (
+                eq.rel_op in ('==', '!=') and 0 in eq.args or
+                eq.rel_op not in ('==', '!='))
+        ):
+            return eq.func(*[_unpolarify(x, exponents_only) for x in eq.args])
+        if isinstance(eq, polar_lift):
+            return _unpolarify(eq.args[0], exponents_only)
+
+    if eq.is_Pow:
+        expo = _unpolarify(eq.exp, exponents_only)
+        base = _unpolarify(eq.base, exponents_only,
+            not (expo.is_integer and not pause))
+        return base**expo
+
+    if eq.is_Function and getattr(eq.func, 'unbranched', False):
+        return eq.func(*[_unpolarify(x, exponents_only, exponents_only)
+            for x in eq.args])
+
+    return eq.func(*[_unpolarify(x, exponents_only, True) for x in eq.args])
+
+
+def unpolarify(eq, subs=None, exponents_only=False):
+    """
+    If `p` denotes the projection from the Riemann surface of the logarithm to
+    the complex line, return a simplified version `eq'` of `eq` such that
+    `p(eq') = p(eq)`.
+    Also apply the substitution subs in the end. (This is a convenience, since
+    ``unpolarify``, in a certain sense, undoes :func:`polarify`.)
+
+    Examples
+    ========
+
+    >>> from sympy import unpolarify, polar_lift, sin, I
+    >>> unpolarify(polar_lift(I + 2))
+    2 + I
+    >>> unpolarify(sin(polar_lift(I + 7)))
+    sin(7 + I)
+    """
+    if isinstance(eq, bool):
+        return eq
+
+    eq = sympify(eq)
+    if subs is not None:
+        return unpolarify(eq.subs(subs))
+    changed = True
+    pause = False
+    if exponents_only:
+        pause = True
+    while changed:
+        changed = False
+        res = _unpolarify(eq, exponents_only, pause)
+        if res != eq:
+            changed = True
+            eq = res
+        if isinstance(res, bool):
+            return res
+    # Finally, replacing Exp(0) by 1 is always correct.
+    # So is polar_lift(0) -> 0.
+    from sympy.functions.elementary.exponential import exp_polar
+    return res.subs({exp_polar(0): 1, polar_lift(0): 0})
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/exponential.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/exponential.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bb0333cb34a35a96248c12a4640e848986f2feb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/exponential.py
@@ -0,0 +1,1286 @@
+from __future__ import annotations
+from itertools import product
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import (DefinedFunction, ArgumentIndexError, expand_log,
+    expand_mul, FunctionClass, PoleError, expand_multinomial, expand_complex)
+from sympy.core.logic import fuzzy_and, fuzzy_not, fuzzy_or
+from sympy.core.mul import Mul
+from sympy.core.numbers import Integer, Rational, pi, I
+from sympy.core.parameters import global_parameters
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Wild, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import arg, unpolarify, im, re, Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.ntheory import multiplicity, perfect_power
+from sympy.ntheory.factor_ import factorint
+
+# NOTE IMPORTANT
+# The series expansion code in this file is an important part of the gruntz
+# algorithm for determining limits. _eval_nseries has to return a generalized
+# power series with coefficients in C(log(x), log).
+# In more detail, the result of _eval_nseries(self, x, n) must be
+#   c_0*x**e_0 + ... (finitely many terms)
+# where e_i are numbers (not necessarily integers) and c_i involve only
+# numbers, the function log, and log(x). [This also means it must not contain
+# log(x(1+p)), this *has* to be expanded to log(x)+log(1+p) if x.is_positive and
+# p.is_positive.]
+
+
+class ExpBase(DefinedFunction):
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    @property
+    def kind(self):
+        return self.exp.kind
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse function of ``exp(x)``.
+        """
+        return log
+
+    def as_numer_denom(self):
+        """
+        Returns this with a positive exponent as a 2-tuple (a fraction).
+
+        Examples
+        ========
+
+        >>> from sympy import exp
+        >>> from sympy.abc import x
+        >>> exp(-x).as_numer_denom()
+        (1, exp(x))
+        >>> exp(x).as_numer_denom()
+        (exp(x), 1)
+        """
+        # this should be the same as Pow.as_numer_denom wrt
+        # exponent handling
+        if not self.is_commutative:
+            return self, S.One
+        exp = self.exp
+        neg_exp = exp.is_negative
+        if not neg_exp and not (-exp).is_negative:
+            neg_exp = exp.could_extract_minus_sign()
+        if neg_exp:
+            return S.One, self.func(-exp)
+        return self, S.One
+
+    @property
+    def exp(self):
+        """
+        Returns the exponent of the function.
+        """
+        return self.args[0]
+
+    def as_base_exp(self):
+        """
+        Returns the 2-tuple (base, exponent).
+        """
+        return self.func(1), Mul(*self.args)
+
+    def _eval_adjoint(self):
+        return self.func(self.exp.adjoint())
+
+    def _eval_conjugate(self):
+        return self.func(self.exp.conjugate())
+
+    def _eval_transpose(self):
+        return self.func(self.exp.transpose())
+
+    def _eval_is_finite(self):
+        arg = self.exp
+        if arg.is_infinite:
+            if arg.is_extended_negative:
+                return True
+            if arg.is_extended_positive:
+                return False
+        if arg.is_finite:
+            return True
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            z = s.exp.is_zero
+            if z:
+                return True
+            elif s.exp.is_rational and fuzzy_not(z):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_zero(self):
+        return self.exp is S.NegativeInfinity
+
+    def _eval_power(self, other):
+        """exp(arg)**e -> exp(arg*e) if assumptions allow it.
+        """
+        b, e = self.as_base_exp()
+        return Pow._eval_power(Pow(b, e, evaluate=False), other)
+
+    def _eval_expand_power_exp(self, **hints):
+        from sympy.concrete.products import Product
+        from sympy.concrete.summations import Sum
+        arg = self.args[0]
+        if arg.is_Add and arg.is_commutative:
+            return Mul.fromiter(self.func(x) for x in arg.args)
+        elif isinstance(arg, Sum) and arg.is_commutative:
+            return Product(self.func(arg.function), *arg.limits)
+        return self.func(arg)
+
+
+class exp_polar(ExpBase):
+    r"""
+    Represent a *polar number* (see g-function Sphinx documentation).
+
+    Explanation
+    ===========
+
+    ``exp_polar`` represents the function
+    `Exp: \mathbb{C} \rightarrow \mathcal{S}`, sending the complex number
+    `z = a + bi` to the polar number `r = exp(a), \theta = b`. It is one of
+    the main functions to construct polar numbers.
+
+    Examples
+    ========
+
+    >>> from sympy import exp_polar, pi, I, exp
+
+    The main difference is that polar numbers do not "wrap around" at `2 \pi`:
+
+    >>> exp(2*pi*I)
+    1
+    >>> exp_polar(2*pi*I)
+    exp_polar(2*I*pi)
+
+    apart from that they behave mostly like classical complex numbers:
+
+    >>> exp_polar(2)*exp_polar(3)
+    exp_polar(5)
+
+    See Also
+    ========
+
+    sympy.simplify.powsimp.powsimp
+    polar_lift
+    periodic_argument
+    principal_branch
+    """
+
+    is_polar = True
+    is_comparable = False  # cannot be evalf'd
+
+    def _eval_Abs(self):   # Abs is never a polar number
+        return exp(re(self.args[0]))
+
+    def _eval_evalf(self, prec):
+        """ Careful! any evalf of polar numbers is flaky """
+        i = im(self.args[0])
+        try:
+            bad = (i <= -pi or i > pi)
+        except TypeError:
+            bad = True
+        if bad:
+            return self  # cannot evalf for this argument
+        res = exp(self.args[0])._eval_evalf(prec)
+        if i > 0 and im(res) < 0:
+            # i ~ pi, but exp(I*i) evaluated to argument slightly bigger than pi
+            return re(res)
+        return res
+
+    def _eval_power(self, other):
+        return self.func(self.args[0]*other)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def as_base_exp(self):
+        # XXX exp_polar(0) is special!
+        if self.args[0] == 0:
+            return self, S.One
+        return ExpBase.as_base_exp(self)
+
+
+class ExpMeta(FunctionClass):
+    def __instancecheck__(cls, instance):
+        if exp in instance.__class__.__mro__:
+            return True
+        return isinstance(instance, Pow) and instance.base is S.Exp1
+
+
+class exp(ExpBase, metaclass=ExpMeta):
+    """
+    The exponential function, :math:`e^x`.
+
+    Examples
+    ========
+
+    >>> from sympy import exp, I, pi
+    >>> from sympy.abc import x
+    >>> exp(x)
+    exp(x)
+    >>> exp(x).diff(x)
+    exp(x)
+    >>> exp(I*pi)
+    -1
+
+    Parameters
+    ==========
+
+    arg : Expr
+
+    See Also
+    ========
+
+    log
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return self
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_refine(self, assumptions):
+        from sympy.assumptions import ask, Q
+        arg = self.args[0]
+        if arg.is_Mul:
+            Ioo = I*S.Infinity
+            if arg in [Ioo, -Ioo]:
+                return S.NaN
+
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if ask(Q.integer(2*coeff)):
+                    if ask(Q.even(coeff)):
+                        return S.One
+                    elif ask(Q.odd(coeff)):
+                        return S.NegativeOne
+                    elif ask(Q.even(coeff + S.Half)):
+                        return -I
+                    elif ask(Q.odd(coeff + S.Half)):
+                        return I
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus import AccumBounds
+        from sympy.matrices.matrixbase import MatrixBase
+        from sympy.sets.setexpr import SetExpr
+        from sympy.simplify.simplify import logcombine
+        if isinstance(arg, MatrixBase):
+            return arg.exp()
+        elif global_parameters.exp_is_pow:
+            return Pow(S.Exp1, arg)
+        elif arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.One
+            elif arg is S.One:
+                return S.Exp1
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+        elif arg is S.ComplexInfinity:
+            return S.NaN
+        elif isinstance(arg, log):
+            return arg.args[0]
+        elif isinstance(arg, AccumBounds):
+            return AccumBounds(exp(arg.min), exp(arg.max))
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+        elif arg.is_Mul:
+            coeff = arg.as_coefficient(pi*I)
+            if coeff:
+                if (2*coeff).is_integer:
+                    if coeff.is_even:
+                        return S.One
+                    elif coeff.is_odd:
+                        return S.NegativeOne
+                    elif (coeff + S.Half).is_even:
+                        return -I
+                    elif (coeff + S.Half).is_odd:
+                        return I
+                elif coeff.is_Rational:
+                    ncoeff = coeff % 2 # restrict to [0, 2pi)
+                    if ncoeff > 1: # restrict to (-pi, pi]
+                        ncoeff -= 2
+                    if ncoeff != coeff:
+                        return cls(ncoeff*pi*I)
+
+            # Warning: code in risch.py will be very sensitive to changes
+            # in this (see DifferentialExtension).
+
+            # look for a single log factor
+
+            coeff, terms = arg.as_coeff_Mul()
+
+            # but it can't be multiplied by oo
+            if coeff in [S.NegativeInfinity, S.Infinity]:
+                if terms.is_number:
+                    if coeff is S.NegativeInfinity:
+                        terms = -terms
+                    if re(terms).is_zero and terms is not S.Zero:
+                        return S.NaN
+                    if re(terms).is_positive and im(terms) is not S.Zero:
+                        return S.ComplexInfinity
+                    if re(terms).is_negative:
+                        return S.Zero
+                return None
+
+            coeffs, log_term = [coeff], None
+            for term in Mul.make_args(terms):
+                term_ = logcombine(term)
+                if isinstance(term_, log):
+                    if log_term is None:
+                        log_term = term_.args[0]
+                    else:
+                        return None
+                elif term.is_comparable:
+                    coeffs.append(term)
+                else:
+                    return None
+
+            return log_term**Mul(*coeffs) if log_term else None
+
+        elif arg.is_Add:
+            out = []
+            add = []
+            argchanged = False
+            for a in arg.args:
+                if a is S.One:
+                    add.append(a)
+                    continue
+                newa = cls(a)
+                if isinstance(newa, cls):
+                    if newa.args[0] != a:
+                        add.append(newa.args[0])
+                        argchanged = True
+                    else:
+                        add.append(a)
+                else:
+                    out.append(newa)
+            if out or argchanged:
+                return Mul(*out)*cls(Add(*add), evaluate=False)
+
+        if arg.is_zero:
+            return S.One
+
+    @property
+    def base(self):
+        """
+        Returns the base of the exponential function.
+        """
+        return S.Exp1
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Calculates the next term in the Taylor series expansion.
+        """
+        if n < 0:
+            return S.Zero
+        if n == 0:
+            return S.One
+        x = sympify(x)
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return p * x / n
+        return x**n/factorial(n)
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a 2-tuple representing a complex number.
+
+        Examples
+        ========
+
+        >>> from sympy import exp, I
+        >>> from sympy.abc import x
+        >>> exp(x).as_real_imag()
+        (exp(re(x))*cos(im(x)), exp(re(x))*sin(im(x)))
+        >>> exp(1).as_real_imag()
+        (E, 0)
+        >>> exp(I).as_real_imag()
+        (cos(1), sin(1))
+        >>> exp(1+I).as_real_imag()
+        (E*cos(1), E*sin(1))
+
+        See Also
+        ========
+
+        sympy.functions.elementary.complexes.re
+        sympy.functions.elementary.complexes.im
+        """
+        from sympy.functions.elementary.trigonometric import cos, sin
+        re, im = self.args[0].as_real_imag()
+        if deep:
+            re = re.expand(deep, **hints)
+            im = im.expand(deep, **hints)
+        cos, sin = cos(im), sin(im)
+        return (exp(re)*cos, exp(re)*sin)
+
+    def _eval_subs(self, old, new):
+        # keep processing of power-like args centralized in Pow
+        if old.is_Pow:  # handle (exp(3*log(x))).subs(x**2, z) -> z**(3/2)
+            old = exp(old.exp*log(old.base))
+        elif old is S.Exp1 and new.is_Function:
+            old = exp
+        if isinstance(old, exp) or old is S.Exp1:
+            f = lambda a: Pow(*a.as_base_exp(), evaluate=False) if (
+                a.is_Pow or isinstance(a, exp)) else a
+            return Pow._eval_subs(f(self), f(old), new)
+
+        if old is exp and not new.is_Function:
+            return new**self.exp._subs(old, new)
+        return super()._eval_subs(old, new)
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+        elif self.args[0].is_imaginary:
+            arg2 = -S(2) * I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_is_complex(self):
+        def complex_extended_negative(arg):
+            yield arg.is_complex
+            yield arg.is_extended_negative
+        return fuzzy_or(complex_extended_negative(self.args[0]))
+
+    def _eval_is_algebraic(self):
+        if (self.exp / pi / I).is_rational:
+            return True
+        if fuzzy_not(self.exp.is_zero):
+            if self.exp.is_algebraic:
+                return False
+            elif (self.exp / pi).is_rational:
+                return False
+
+    def _eval_is_extended_positive(self):
+        if self.exp.is_extended_real:
+            return self.args[0] is not S.NegativeInfinity
+        elif self.exp.is_imaginary:
+            arg2 = -I * self.args[0] / pi
+            return arg2.is_even
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.functions.elementary.complexes import sign
+        from sympy.functions.elementary.integers import ceiling
+        from sympy.series.limits import limit
+        from sympy.series.order import Order
+        from sympy.simplify.powsimp import powsimp
+        arg = self.exp
+        arg_series = arg._eval_nseries(x, n=n, logx=logx)
+        if arg_series.is_Order:
+            return 1 + arg_series
+        arg0 = limit(arg_series.removeO(), x, 0)
+        if arg0 is S.NegativeInfinity:
+            return Order(x**n, x)
+        if arg0 is S.Infinity:
+            return self
+        if arg0.is_infinite:
+            raise PoleError("Cannot expand %s around 0" % (self))
+        # checking for indecisiveness/ sign terms in arg0
+        if any(isinstance(arg, sign) for arg in arg0.args):
+            return self
+        t = Dummy("t")
+        nterms = n
+        try:
+            cf = Order(arg.as_leading_term(x, logx=logx), x).getn()
+        except (NotImplementedError, PoleError):
+            cf = 0
+        if cf and cf > 0:
+            nterms = ceiling(n/cf)
+        exp_series = exp(t)._taylor(t, nterms)
+        r = exp(arg0)*exp_series.subs(t, arg_series - arg0)
+        rep = {logx: log(x)} if logx is not None else {}
+        if r.subs(rep) == self:
+            return r
+        if cf and cf > 1:
+            r += Order((arg_series - arg0)**n, x)/x**((cf-1)*n)
+        else:
+            r += Order((arg_series - arg0)**n, x)
+        r = r.expand()
+        r = powsimp(r, deep=True, combine='exp')
+        # powsimp may introduce unexpanded (-1)**Rational; see PR #17201
+        simplerat = lambda x: x.is_Rational and x.q in [3, 4, 6]
+        w = Wild('w', properties=[simplerat])
+        r = r.replace(S.NegativeOne**w, expand_complex(S.NegativeOne**w))
+        return r
+
+    def _taylor(self, x, n):
+        l = []
+        g = None
+        for i in range(n):
+            g = self.taylor_term(i, self.args[0], g)
+            g = g.nseries(x, n=n)
+            l.append(g.removeO())
+        return Add(*l)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.util import AccumBounds
+        arg = self.args[0].cancel().as_leading_term(x, logx=logx)
+        arg0 = arg.subs(x, 0)
+        if arg is S.NaN:
+            return S.NaN
+        if isinstance(arg0, AccumBounds):
+            # This check addresses a corner case involving AccumBounds.
+            # if isinstance(arg, AccumBounds) is True, then arg0 can either be 0,
+            # AccumBounds(-oo, 0) or AccumBounds(-oo, oo).
+            # Check out function: test_issue_18473() in test_exponential.py and
+            # test_limits.py for more information.
+            if re(cdir) < S.Zero:
+                return exp(-arg0)
+            return exp(arg0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0)
+        if arg0.is_infinite is False:
+            return exp(arg0)
+        raise PoleError("Cannot expand %s around 0" % (self))
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin
+        return sin(I*arg + pi/2) - I*sin(I*arg)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import cos
+        return cos(I*arg) + I*cos(I*arg + pi/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        from sympy.functions.elementary.hyperbolic import tanh
+        return (1 + tanh(arg/2))/(1 - tanh(arg/2))
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        from sympy.functions.elementary.trigonometric import sin, cos
+        if arg.is_Mul:
+            coeff = arg.coeff(pi*I)
+            if coeff and coeff.is_number:
+                cosine, sine = cos(pi*coeff), sin(pi*coeff)
+                if not isinstance(cosine, cos) and not isinstance (sine, sin):
+                    return cosine + I*sine
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if arg.is_Mul:
+            logs = [a for a in arg.args if isinstance(a, log) and len(a.args) == 1]
+            if logs:
+                return Pow(logs[0].args[0], arg.coeff(logs[0]))
+
+
+def match_real_imag(expr):
+    r"""
+    Try to match expr with $a + Ib$ for real $a$ and $b$.
+
+    ``match_real_imag`` returns a tuple containing the real and imaginary
+    parts of expr or ``(None, None)`` if direct matching is not possible. Contrary
+    to :func:`~.re`, :func:`~.im``, and ``as_real_imag()``, this helper will not force things
+    by returning expressions themselves containing ``re()`` or ``im()`` and it
+    does not expand its argument either.
+
+    """
+    r_, i_ = expr.as_independent(I, as_Add=True)
+    if i_ == 0 and r_.is_real:
+        return (r_, i_)
+    i_ = i_.as_coefficient(I)
+    if i_ and i_.is_real and r_.is_real:
+        return (r_, i_)
+    else:
+        return (None, None) # simpler to check for than None
+
+
+class log(DefinedFunction):
+    r"""
+    The natural logarithm function `\ln(x)` or `\log(x)`.
+
+    Explanation
+    ===========
+
+    Logarithms are taken with the natural base, `e`. To get
+    a logarithm of a different base ``b``, use ``log(x, b)``,
+    which is essentially short-hand for ``log(x)/log(b)``.
+
+    ``log`` represents the principal branch of the natural
+    logarithm. As such it has a branch cut along the negative
+    real axis and returns values having a complex argument in
+    `(-\pi, \pi]`.
+
+    Examples
+    ========
+
+    >>> from sympy import log, sqrt, S, I
+    >>> log(8, 2)
+    3
+    >>> log(S(8)/3, 2)
+    -log(3)/log(2) + 3
+    >>> log(-1 + I*sqrt(3))
+    log(2) + 2*I*pi/3
+
+    See Also
+    ========
+
+    exp
+
+    """
+
+    args: tuple[Expr]
+
+    _singularities = (S.Zero, S.ComplexInfinity)
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of the function.
+        """
+        if argindex == 1:
+            return 1/self.args[0]
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        r"""
+        Returns `e^x`, the inverse function of `\log(x)`.
+        """
+        return exp
+
+    @classmethod
+    def eval(cls, arg, base=None):
+        from sympy.calculus import AccumBounds
+        from sympy.sets.setexpr import SetExpr
+
+        arg = sympify(arg)
+
+        if base is not None:
+            base = sympify(base)
+            if base == 1:
+                if arg == 1:
+                    return S.NaN
+                else:
+                    return S.ComplexInfinity
+            try:
+                # handle extraction of powers of the base now
+                # or else expand_log in Mul would have to handle this
+                n = multiplicity(base, arg)
+                if n:
+                    return n + log(arg / base**n) / log(base)
+                else:
+                    return log(arg)/log(base)
+            except ValueError:
+                pass
+            if base is not S.Exp1:
+                return cls(arg)/cls(base)
+            else:
+                return cls(arg)
+
+        if arg.is_Number:
+            if arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg is S.NaN:
+                return S.NaN
+            elif arg.is_Rational and arg.p == 1:
+                return -cls(arg.q)
+
+        if arg.is_Pow and arg.base is S.Exp1 and arg.exp.is_extended_real:
+            return arg.exp
+        if isinstance(arg, exp) and arg.exp.is_extended_real:
+            return arg.exp
+        elif isinstance(arg, exp) and arg.exp.is_number:
+            r_, i_ = match_real_imag(arg.exp)
+            if i_ and i_.is_comparable:
+                i_ %= 2*pi
+                if i_ > pi:
+                    i_ -= 2*pi
+                return r_ + expand_mul(i_ * I, deep=False)
+        elif isinstance(arg, exp_polar):
+            return unpolarify(arg.exp)
+        elif isinstance(arg, AccumBounds):
+            if arg.min.is_positive:
+                return AccumBounds(log(arg.min), log(arg.max))
+            elif arg.min.is_zero:
+                return AccumBounds(S.NegativeInfinity, log(arg.max))
+            else:
+                return S.NaN
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+
+        if arg.is_number:
+            if arg.is_negative:
+                return pi * I + cls(-arg)
+            elif arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+            elif arg is S.Exp1:
+                return S.One
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        # don't autoexpand Pow or Mul (see the issue 3351):
+        if not arg.is_Add:
+            coeff = arg.as_coefficient(I)
+
+            if coeff is not None:
+                if coeff is S.Infinity:
+                    return S.Infinity
+                elif coeff is S.NegativeInfinity:
+                    return S.Infinity
+                elif coeff.is_Rational:
+                    if coeff.is_nonnegative:
+                        return pi * I * S.Half + cls(coeff)
+                    else:
+                        return -pi * I * S.Half + cls(-coeff)
+
+        if arg.is_number and arg.is_algebraic:
+            # Match arg = coeff*(r_ + i_*I) with coeff>0, r_ and i_ real.
+            coeff, arg_ = arg.as_independent(I, as_Add=False)
+            if coeff.is_negative:
+                coeff *= -1
+                arg_ *= -1
+            arg_ = expand_mul(arg_, deep=False)
+            r_, i_ = arg_.as_independent(I, as_Add=True)
+            i_ = i_.as_coefficient(I)
+            if coeff.is_real and i_ and i_.is_real and r_.is_real:
+                if r_.is_zero:
+                    if i_.is_positive:
+                        return pi * I * S.Half + cls(coeff * i_)
+                    elif i_.is_negative:
+                        return -pi * I * S.Half + cls(coeff * -i_)
+                else:
+                    from sympy.simplify import ratsimp
+                    # Check for arguments involving rational multiples of pi
+                    t = (i_/r_).cancel()
+                    t1 = (-t).cancel()
+                    atan_table = _log_atan_table()
+                    if t in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * atan_table[t]
+                        else:
+                            return cls(modulus) + I * (atan_table[t] - pi)
+                    elif t1 in atan_table:
+                        modulus = ratsimp(coeff * Abs(arg_))
+                        if r_.is_positive:
+                            return cls(modulus) + I * (-atan_table[t1])
+                        else:
+                            return cls(modulus) + I * (pi - atan_table[t1])
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):  # of log(1+x)
+        r"""
+        Returns the next term in the Taylor series expansion of `\log(1+x)`.
+        """
+        from sympy.simplify.powsimp import powsimp
+        if n < 0:
+            return S.Zero
+        x = sympify(x)
+        if n == 0:
+            return x
+        if previous_terms:
+            p = previous_terms[-1]
+            if p is not None:
+                return powsimp((-n) * p * x / (n + 1), deep=True, combine='exp')
+        return (1 - 2*(n % 2)) * x**(n + 1)/(n + 1)
+
+    def _eval_expand_log(self, deep=True, **hints):
+        from sympy.concrete import Sum, Product
+        force = hints.get('force', False)
+        factor = hints.get('factor', False)
+        if (len(self.args) == 2):
+            return expand_log(self.func(*self.args), deep=deep, force=force)
+        arg = self.args[0]
+        if arg.is_Integer:
+            # remove perfect powers
+            p = perfect_power(arg)
+            logarg = None
+            coeff = 1
+            if p is not False:
+                arg, coeff = p
+                logarg = self.func(arg)
+            # expand as product of its prime factors if factor=True
+            if factor:
+                p = factorint(arg)
+                if arg not in p.keys():
+                    logarg = sum(n*log(val) for val, n in p.items())
+            if logarg is not None:
+                return coeff*logarg
+        elif arg.is_Rational:
+            return log(arg.p) - log(arg.q)
+        elif arg.is_Mul:
+            expr = []
+            nonpos = []
+            for x in arg.args:
+                if force or x.is_positive or x.is_polar:
+                    a = self.func(x)
+                    if isinstance(a, log):
+                        expr.append(self.func(x)._eval_expand_log(**hints))
+                    else:
+                        expr.append(a)
+                elif x.is_negative:
+                    a = self.func(-x)
+                    expr.append(a)
+                    nonpos.append(S.NegativeOne)
+                else:
+                    nonpos.append(x)
+            return Add(*expr) + log(Mul(*nonpos))
+        elif arg.is_Pow or isinstance(arg, exp):
+            if force or (arg.exp.is_extended_real and (arg.base.is_positive or ((arg.exp+1)
+                .is_positive and (arg.exp-1).is_nonpositive))) or arg.base.is_polar:
+                b = arg.base
+                e = arg.exp
+                a = self.func(b)
+                if isinstance(a, log):
+                    return unpolarify(e) * a._eval_expand_log(**hints)
+                else:
+                    return unpolarify(e) * a
+        elif isinstance(arg, Product):
+            if force or arg.function.is_positive:
+                return Sum(log(arg.function), *arg.limits)
+
+        return self.func(arg)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import expand_log, simplify, inversecombine
+        if len(self.args) == 2:  # it's unevaluated
+            return simplify(self.func(*self.args), **kwargs)
+
+        expr = self.func(simplify(self.args[0], **kwargs))
+        if kwargs['inverse']:
+            expr = inversecombine(expr)
+        expr = expand_log(expr, deep=True)
+        return min([expr, self], key=kwargs['measure'])
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+
+        Examples
+        ========
+
+        >>> from sympy import I, log
+        >>> from sympy.abc import x
+        >>> log(x).as_real_imag()
+        (log(Abs(x)), arg(x))
+        >>> log(I).as_real_imag()
+        (0, pi/2)
+        >>> log(1 + I).as_real_imag()
+        (log(sqrt(2)), pi/4)
+        >>> log(I*x).as_real_imag()
+        (log(Abs(x)), arg(I*x))
+
+        """
+        sarg = self.args[0]
+        if deep:
+            sarg = self.args[0].expand(deep, **hints)
+        sarg_abs = Abs(sarg)
+        if sarg_abs == sarg:
+            return self, S.Zero
+        sarg_arg = arg(sarg)
+        if hints.get('log', False):  # Expand the log
+            hints['complex'] = False
+            return (log(sarg_abs).expand(deep, **hints), sarg_arg)
+        else:
+            return log(sarg_abs), sarg_arg
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            if s.args[0].is_rational and fuzzy_not((self.args[0] - 1).is_zero):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if (self.args[0] - 1).is_zero:
+                return True
+            elif fuzzy_not((self.args[0] - 1).is_zero):
+                if self.args[0].is_algebraic:
+                    return False
+        else:
+            return s.is_algebraic
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_positive
+
+    def _eval_is_complex(self):
+        z = self.args[0]
+        return fuzzy_and([z.is_complex, fuzzy_not(z.is_zero)])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return False
+        return arg.is_finite
+
+    def _eval_is_extended_positive(self):
+        return (self.args[0] - 1).is_extended_positive
+
+    def _eval_is_zero(self):
+        return (self.args[0] - 1).is_zero
+
+    def _eval_is_extended_nonnegative(self):
+        return (self.args[0] - 1).is_extended_nonnegative
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE Please see the comment at the beginning of this file, labelled
+        #      IMPORTANT.
+        from sympy.series.order import Order
+        from sympy.simplify.simplify import logcombine
+        from sympy.core.symbol import Dummy
+
+        if self.args[0] == x:
+            return log(x) if logx is None else logx
+        arg = self.args[0]
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg.subs(x, cdir*t)
+
+        k, l = Wild("k"), Wild("l")
+        r = z.match(k*t**l)
+        if r is not None:
+            k, l = r[k], r[l]
+            if l != 0 and not l.has(t) and not k.has(t):
+                r = l*log(x) if logx is None else l*logx
+                r += log(k) - l*log(cdir) # XXX true regardless of assumptions?
+                return r
+
+        def coeff_exp(term, x):
+            coeff, exp = S.One, S.Zero
+            for factor in Mul.make_args(term):
+                if factor.has(x):
+                    base, exp = factor.as_base_exp()
+                    if base != x:
+                        try:
+                            return term.leadterm(x)
+                        except ValueError:
+                            return term, S.Zero
+                else:
+                    coeff *= factor
+            return coeff, exp
+
+        # TODO new and probably slow
+        try:
+            a, b = z.leadterm(t, logx=logx, cdir=1)
+        except (ValueError, NotImplementedError, PoleError):
+            s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            while s.is_Order:
+                n += 1
+                s = z._eval_nseries(t, n=n, logx=logx, cdir=1)
+            try:
+                a, b = s.removeO().leadterm(t, cdir=1)
+            except ValueError:
+                a, b = s.removeO().as_leading_term(t, cdir=1), S.Zero
+
+        p = (z/(a*t**b) - 1).cancel()._eval_nseries(t, n=n, logx=logx, cdir=1)
+        if p.has(exp):
+            p = logcombine(p)
+        if isinstance(p, Order):
+            n = p.getn()
+        _, d = coeff_exp(p, t)
+        logx = log(x) if logx is None else logx
+
+        if not d.is_positive:
+            res = log(a) - b*log(cdir) + b*logx
+            _res = res
+            logflags = {"deep": True, "log": True, "mul": False, "power_exp": False,
+                "power_base": False, "multinomial": False, "basic": False, "force": True,
+                "factor": False}
+            expr = self.expand(**logflags)
+            if (not a.could_extract_minus_sign() and
+                logx.could_extract_minus_sign()):
+                _res = _res.subs(-logx, -log(x)).expand(**logflags)
+            else:
+                _res = _res.subs(logx, log(x)).expand(**logflags)
+            if _res == expr:
+                return res
+            return res + Order(x**n, x)
+
+        def mul(d1, d2):
+            res = {}
+            for e1, e2 in product(d1, d2):
+                ex = e1 + e2
+                if ex < n:
+                    res[ex] = res.get(ex, S.Zero) + d1[e1]*d2[e2]
+            return res
+
+        pterms = {}
+
+        for term in Add.make_args(p.removeO()):
+            co1, e1 = coeff_exp(term, t)
+            pterms[e1] = pterms.get(e1, S.Zero) + co1
+
+        k = S.One
+        terms = {}
+        pk = pterms
+
+        while k*d < n:
+            coeff = -S.NegativeOne**k/k
+            for ex in pk:
+                terms[ex] = terms.get(ex, S.Zero) + coeff*pk[ex]
+            pk = mul(pk, pterms)
+            k += S.One
+
+        res = log(a) - b*log(cdir) + b*logx
+        for ex in terms:
+            res += terms[ex].cancel()*t**(ex)
+
+        if a.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+
+        res = res.subs(t, x/cdir)
+        return res + Order(x**n, x)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        # NOTE
+        # Refer https://github.com/sympy/sympy/pull/23592 for more information
+        # on each of the following steps involved in this method.
+        arg0 = self.args[0].together()
+
+        # STEP 1
+        t = Dummy('t', positive=True)
+        if cdir == 0:
+            cdir = 1
+        z = arg0.subs(x, cdir*t)
+
+        # STEP 2
+        try:
+            c, e = z.leadterm(t, logx=logx, cdir=1)
+        except ValueError:
+            arg = arg0.as_leading_term(x, logx=logx, cdir=cdir)
+            return log(arg)
+        if c.has(t):
+            c = c.subs(t, x/cdir)
+            if e != 0:
+                raise PoleError("Cannot expand %s around 0" % (self))
+            return log(c)
+
+        # STEP 3
+        if c == S.One and e == S.Zero:
+            return (arg0 - S.One).as_leading_term(x, logx=logx)
+
+        # STEP 4
+        res = log(c) - e*log(cdir)
+        logx = log(x) if logx is None else logx
+        res += e*logx
+
+        # STEP 5
+        if c.is_negative and im(z) != 0:
+            from sympy.functions.special.delta_functions import Heaviside
+            for i, term in enumerate(z.lseries(t)):
+                if not term.is_real or i == 5:
+                    break
+            if i < 5:
+                coeff, _ = term.as_coeff_exponent(t)
+                res += -2*I*pi*Heaviside(-im(coeff), 0)
+        return res
+
+
+class LambertW(DefinedFunction):
+    r"""
+    The Lambert W function $W(z)$ is defined as the inverse
+    function of $w \exp(w)$ [1]_.
+
+    Explanation
+    ===========
+
+    In other words, the value of $W(z)$ is such that $z = W(z) \exp(W(z))$
+    for any complex number $z$.  The Lambert W function is a multivalued
+    function with infinitely many branches $W_k(z)$, indexed by
+    $k \in \mathbb{Z}$.  Each branch gives a different solution $w$
+    of the equation $z = w \exp(w)$.
+
+    The Lambert W function has two partially real branches: the
+    principal branch ($k = 0$) is real for real $z > -1/e$, and the
+    $k = -1$ branch is real for $-1/e < z < 0$. All branches except
+    $k = 0$ have a logarithmic singularity at $z = 0$.
+
+    Examples
+    ========
+
+    >>> from sympy import LambertW
+    >>> LambertW(1.2)
+    0.635564016364870
+    >>> LambertW(1.2, -1).n()
+    -1.34747534407696 - 4.41624341514535*I
+    >>> LambertW(-1).is_real
+    False
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Lambert_W_function
+    """
+    _singularities = (-Pow(S.Exp1, -1, evaluate=False), S.ComplexInfinity)
+
+    @classmethod
+    def eval(cls, x, k=None):
+        if k == S.Zero:
+            return cls(x)
+        elif k is None:
+            k = S.Zero
+
+        if k.is_zero:
+            if x.is_zero:
+                return S.Zero
+            if x is S.Exp1:
+                return S.One
+            if x == -1/S.Exp1:
+                return S.NegativeOne
+            if x == -log(2)/2:
+                return -log(2)
+            if x == 2*log(2):
+                return log(2)
+            if x == -pi/2:
+                return I*pi/2
+            if x == exp(1 + S.Exp1):
+                return S.Exp1
+            if x is S.Infinity:
+                return S.Infinity
+
+        if fuzzy_not(k.is_zero):
+            if x.is_zero:
+                return S.NegativeInfinity
+        if k is S.NegativeOne:
+            if x == -pi/2:
+                return -I*pi/2
+            elif x == -1/S.Exp1:
+                return S.NegativeOne
+            elif x == -2*exp(-2):
+                return -Integer(2)
+
+    def fdiff(self, argindex=1):
+        """
+        Return the first derivative of this function.
+        """
+        x = self.args[0]
+
+        if len(self.args) == 1:
+            if argindex == 1:
+                return LambertW(x)/(x*(1 + LambertW(x)))
+        else:
+            k = self.args[1]
+            if argindex == 1:
+                return LambertW(x, k)/(x*(1 + LambertW(x, k)))
+
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            k = S.Zero
+        else:
+            k = self.args[1]
+        if k.is_zero:
+            if (x + 1/S.Exp1).is_positive:
+                return True
+            elif (x + 1/S.Exp1).is_nonpositive:
+                return False
+        elif (k + 1).is_zero:
+            if x.is_negative and (x + 1/S.Exp1).is_positive:
+                return True
+            elif x.is_nonpositive or (x + 1/S.Exp1).is_nonnegative:
+                return False
+        elif fuzzy_not(k.is_zero) and fuzzy_not((k + 1).is_zero):
+            if x.is_extended_real:
+                return False
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if fuzzy_not(self.args[0].is_zero) and self.args[0].is_algebraic:
+                return False
+        else:
+            return s.is_algebraic
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        if len(self.args) == 1:
+            arg = self.args[0]
+            arg0 = arg.subs(x, 0).cancel()
+            if not arg0.is_zero:
+                return self.func(arg0)
+            return arg.as_leading_term(x)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if len(self.args) == 1:
+            from sympy.functions.elementary.integers import ceiling
+            from sympy.series.order import Order
+            arg = self.args[0].nseries(x, n=n, logx=logx)
+            lt = arg.as_leading_term(x, logx=logx)
+            lte = 1
+            if lt.is_Pow:
+                lte = lt.exp
+            if ceiling(n/lte) >= 1:
+                s = Add(*[(-S.One)**(k - 1)*Integer(k)**(k - 2)/
+                          factorial(k - 1)*arg**k for k in range(1, ceiling(n/lte))])
+                s = expand_multinomial(s)
+            else:
+                s = S.Zero
+
+            return s + Order(x**n, x)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_is_zero(self):
+        x = self.args[0]
+        if len(self.args) == 1:
+            return x.is_zero
+        else:
+            return fuzzy_and([x.is_zero, self.args[1].is_zero])
+
+
+@cacheit
+def _log_atan_table():
+    return {
+        # first quadrant only
+        sqrt(3): pi / 3,
+        1: pi / 4,
+        sqrt(5 - 2 * sqrt(5)): pi / 5,
+        sqrt(2) * sqrt(5 - sqrt(5)) / (1 + sqrt(5)): pi / 5,
+        sqrt(5 + 2 * sqrt(5)): pi * Rational(2, 5),
+        sqrt(2) * sqrt(sqrt(5) + 5) / (-1 + sqrt(5)): pi * Rational(2, 5),
+        sqrt(3) / 3: pi / 6,
+        sqrt(2) - 1: pi / 8,
+        sqrt(2 - sqrt(2)) / sqrt(sqrt(2) + 2): pi / 8,
+        sqrt(2) + 1: pi * Rational(3, 8),
+        sqrt(sqrt(2) + 2) / sqrt(2 - sqrt(2)): pi * Rational(3, 8),
+        sqrt(1 - 2 * sqrt(5) / 5): pi / 10,
+        (-sqrt(2) + sqrt(10)) / (2 * sqrt(sqrt(5) + 5)): pi / 10,
+        sqrt(1 + 2 * sqrt(5) / 5): pi * Rational(3, 10),
+        (sqrt(2) + sqrt(10)) / (2 * sqrt(5 - sqrt(5))): pi * Rational(3, 10),
+        2 - sqrt(3): pi / 12,
+        (-1 + sqrt(3)) / (1 + sqrt(3)): pi / 12,
+        2 + sqrt(3): pi * Rational(5, 12),
+        (1 + sqrt(3)) / (-1 + sqrt(3)): pi * Rational(5, 12)
+    }
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/hyperbolic.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/hyperbolic.py
new file mode 100644
index 0000000000000000000000000000000000000000..1031d035373bb641d26e61a395e6048906285bfe
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/hyperbolic.py
@@ -0,0 +1,2285 @@
+from sympy.core import S, sympify, cacheit
+from sympy.core.add import Add
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_or, fuzzy_and, fuzzy_not, FuzzyBool
+from sympy.core.numbers import I, pi, Rational
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import (binomial, factorial,
+                                                      RisingFactorial)
+from sympy.functions.combinatorial.numbers import bernoulli, euler, nC
+from sympy.functions.elementary.complexes import Abs, im, re
+from sympy.functions.elementary.exponential import exp, log, match_real_imag
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (
+    acos, acot, asin, atan, cos, cot, csc, sec, sin, tan,
+    _imaginary_unit_as_coefficient)
+from sympy.polys.specialpolys import symmetric_poly
+
+
+def _rewrite_hyperbolics_as_exp(expr):
+    return expr.xreplace({h: h.rewrite(exp)
+        for h in expr.atoms(HyperbolicFunction)})
+
+
+@cacheit
+def _acosh_table():
+    return {
+        I: log(I*(1 + sqrt(2))),
+        -I: log(-I*(1 + sqrt(2))),
+        S.Half: pi/3,
+        Rational(-1, 2): pi*Rational(2, 3),
+        sqrt(2)/2: pi/4,
+        -sqrt(2)/2: pi*Rational(3, 4),
+        1/sqrt(2): pi/4,
+        -1/sqrt(2): pi*Rational(3, 4),
+        sqrt(3)/2: pi/6,
+        -sqrt(3)/2: pi*Rational(5, 6),
+        (sqrt(3) - 1)/sqrt(2**3): pi*Rational(5, 12),
+        -(sqrt(3) - 1)/sqrt(2**3): pi*Rational(7, 12),
+        sqrt(2 + sqrt(2))/2: pi/8,
+        -sqrt(2 + sqrt(2))/2: pi*Rational(7, 8),
+        sqrt(2 - sqrt(2))/2: pi*Rational(3, 8),
+        -sqrt(2 - sqrt(2))/2: pi*Rational(5, 8),
+        (1 + sqrt(3))/(2*sqrt(2)): pi/12,
+        -(1 + sqrt(3))/(2*sqrt(2)): pi*Rational(11, 12),
+        (sqrt(5) + 1)/4: pi/5,
+        -(sqrt(5) + 1)/4: pi*Rational(4, 5)
+    }
+
+
+@cacheit
+def _acsch_table():
+    return {
+            I: -pi / 2,
+            I*(sqrt(2) + sqrt(6)): -pi / 12,
+            I*(1 + sqrt(5)): -pi / 10,
+            I*2 / sqrt(2 - sqrt(2)): -pi / 8,
+            I*2: -pi / 6,
+            I*sqrt(2 + 2/sqrt(5)): -pi / 5,
+            I*sqrt(2): -pi / 4,
+            I*(sqrt(5)-1): -3*pi / 10,
+            I*2 / sqrt(3): -pi / 3,
+            I*2 / sqrt(2 + sqrt(2)): -3*pi / 8,
+            I*sqrt(2 - 2/sqrt(5)): -2*pi / 5,
+            I*(sqrt(6) - sqrt(2)): -5*pi / 12,
+            S(2): -I*log((1+sqrt(5))/2),
+        }
+
+
+@cacheit
+def _asech_table():
+        return {
+            I: - (pi*I / 2) + log(1 + sqrt(2)),
+            -I: (pi*I / 2) + log(1 + sqrt(2)),
+            (sqrt(6) - sqrt(2)): pi / 12,
+            (sqrt(2) - sqrt(6)): 11*pi / 12,
+            sqrt(2 - 2/sqrt(5)): pi / 10,
+            -sqrt(2 - 2/sqrt(5)): 9*pi / 10,
+            2 / sqrt(2 + sqrt(2)): pi / 8,
+            -2 / sqrt(2 + sqrt(2)): 7*pi / 8,
+            2 / sqrt(3): pi / 6,
+            -2 / sqrt(3): 5*pi / 6,
+            (sqrt(5) - 1): pi / 5,
+            (1 - sqrt(5)): 4*pi / 5,
+            sqrt(2): pi / 4,
+            -sqrt(2): 3*pi / 4,
+            sqrt(2 + 2/sqrt(5)): 3*pi / 10,
+            -sqrt(2 + 2/sqrt(5)): 7*pi / 10,
+            S(2): pi / 3,
+            -S(2): 2*pi / 3,
+            sqrt(2*(2 + sqrt(2))): 3*pi / 8,
+            -sqrt(2*(2 + sqrt(2))): 5*pi / 8,
+            (1 + sqrt(5)): 2*pi / 5,
+            (-1 - sqrt(5)): 3*pi / 5,
+            (sqrt(6) + sqrt(2)): 5*pi / 12,
+            (-sqrt(6) - sqrt(2)): 7*pi / 12,
+            I*S.Infinity: -pi*I / 2,
+            I*S.NegativeInfinity: pi*I / 2,
+        }
+
+###############################################################################
+########################### HYPERBOLIC FUNCTIONS ##############################
+###############################################################################
+
+
+class HyperbolicFunction(DefinedFunction):
+    """
+    Base class for hyperbolic functions.
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth
+    """
+
+    unbranched = True
+
+
+def _peeloff_ipi(arg):
+    r"""
+    Split ARG into two parts, a "rest" and a multiple of $I\pi$.
+    This assumes ARG to be an ``Add``.
+    The multiple of $I\pi$ returned in the second position is always a ``Rational``.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.hyperbolic import _peeloff_ipi as peel
+    >>> from sympy import pi, I
+    >>> from sympy.abc import x, y
+    >>> peel(x + I*pi/2)
+    (x, 1/2)
+    >>> peel(x + I*2*pi/3 + I*pi*y)
+    (x + I*pi*y + I*pi/6, 1/2)
+    """
+    ipi = pi*I
+    for a in Add.make_args(arg):
+        if a == ipi:
+            K = S.One
+            break
+        elif a.is_Mul:
+            K, p = a.as_two_terms()
+            if p == ipi and K.is_Rational:
+                break
+    else:
+        return arg, S.Zero
+
+    m1 = (K % S.Half)
+    m2 = K - m1
+    return arg - m2*ipi, m2
+
+
+class sinh(HyperbolicFunction):
+    r"""
+    ``sinh(x)`` is the hyperbolic sine of ``x``.
+
+    The hyperbolic sine function is $\frac{e^x - e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import sinh
+    >>> from sympy.abc import x
+    >>> sinh(x)
+    sinh(x)
+
+    See Also
+    ========
+
+    cosh, tanh, asinh
+    """
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function.
+        """
+        if argindex == 1:
+            return cosh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return asinh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * sin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return sinh(m)*cosh(x) + cosh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                return arg.args[0]
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1)
+
+            if arg.func == atanh:
+                x = arg.args[0]
+                return x/sqrt(1 - x**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return 1/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion.
+        """
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n) / factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        """
+        Returns this function as a complex coordinate.
+        """
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        return (sinh(re)*cos(im), cosh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (sinh(x)*cosh(y) + sinh(y)*cosh(x)).expand(trig=True)
+        return sinh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) - exp(-arg)) / 2
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return -I * sin(I * arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return -I / csc(I * arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg + pi*I/2)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)
+        return 2*tanh_half/(1 - tanh_half**2)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)
+        return 2*coth_half/(coth_half**2 - 1)
+
+    def _eval_rewrite_as_csch(self, arg, **kwargs):
+        return 1 / csch(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        # if `im` is of the form n*pi
+        # else, check if it is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if rest.is_zero:
+            return ipi_mult.is_integer
+
+
+class cosh(HyperbolicFunction):
+    r"""
+    ``cosh(x)`` is the hyperbolic cosine of ``x``.
+
+    The hyperbolic cosine function is $\frac{e^x + e^{-x}}{2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import cosh
+    >>> from sympy.abc import x
+    >>> cosh(x)
+    cosh(x)
+
+    See Also
+    ========
+
+    sinh, tanh, acosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return sinh(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.elementary.trigonometric import cos
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return S.One
+            elif arg.is_negative:
+                return cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return cos(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    m = m*pi*I
+                    return cosh(m)*cosh(x) + sinh(m)*sinh(x)
+
+            if arg.is_zero:
+                return S.One
+
+            if arg.func == asinh:
+                return sqrt(1 + arg.args[0]**2)
+
+            if arg.func == acosh:
+                return arg.args[0]
+
+            if arg.func == atanh:
+                return 1/sqrt(1 - arg.args[0]**2)
+
+            if arg.func == acoth:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return p * x**2 / (n*(n - 1))
+            else:
+                return x**(n)/factorial(n)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+
+        return (cosh(re)*cos(im), sinh(re)*sin(im))
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+    def _eval_expand_trig(self, deep=True, **hints):
+        if deep:
+            arg = self.args[0].expand(deep, **hints)
+        else:
+            arg = self.args[0]
+        x = None
+        if arg.is_Add: # TODO, implement more if deep stuff here
+            x, y = arg.as_two_terms()
+        else:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff is not S.One and coeff.is_Integer and terms is not S.One:
+                x = terms
+                y = (coeff - 1)*x
+        if x is not None:
+            return (cosh(x)*cosh(y) + sinh(x)*sinh(y)).expand(trig=True)
+        return cosh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return (exp(arg) + exp(-arg)) / 2
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return cos(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1 / sec(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(arg + pi*I/2, evaluate=False)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        tanh_half = tanh(S.Half*arg)**2
+        return (1 + tanh_half)/(1 - tanh_half)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        coth_half = coth(S.Half*arg)**2
+        return (coth_half + 1)/(coth_half - 1)
+
+    def _eval_rewrite_as_sech(self, arg, **kwargs):
+        return 1 / sech(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if cdir.is_negative else '+')
+        if arg0.is_zero:
+            return S.One
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+
+        # `cosh(x)` is real for real OR purely imaginary `x`
+        if arg.is_real or arg.is_imaginary:
+            return True
+
+        # cosh(a+ib) = cos(b)*cosh(a) + i*sin(b)*sinh(a)
+        # the imaginary part can be an expression like n*pi
+        # if not, check if the imaginary part is a number
+        re, im = arg.as_real_imag()
+        return (im%pi).is_zero
+
+    def _eval_is_positive(self):
+        # cosh(x+I*y) = cos(y)*cosh(x) + I*sin(y)*sinh(x)
+        # cosh(z) is positive iff it is real and the real part is positive.
+        # So we need sin(y)*sinh(x) = 0 which gives x=0 or y=n*pi
+        # Case 1 (y=n*pi): cosh(z) = (-1)**n * cosh(x) -> positive for n even
+        # Case 2 (x=0): cosh(z) = cos(y) -> positive when cos(y) is positive
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod < pi/2, ymod > 3*pi/2])
+                ])
+            ])
+
+
+    def _eval_is_nonnegative(self):
+        z = self.args[0]
+
+        x, y = z.as_real_imag()
+        ymod = y % (2*pi)
+
+        yzero = ymod.is_zero
+        # shortcut if ymod is zero
+        if yzero:
+            return True
+
+        xzero = x.is_zero
+        # shortcut x is not zero
+        if xzero is False:
+            return yzero
+
+        return fuzzy_or([
+                # Case 1:
+                yzero,
+                # Case 2:
+                fuzzy_and([
+                    xzero,
+                    fuzzy_or([ymod <= pi/2, ymod >= 3*pi/2])
+                ])
+            ])
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        return arg.is_finite
+
+    def _eval_is_zero(self):
+        rest, ipi_mult = _peeloff_ipi(self.args[0])
+        if ipi_mult and rest.is_zero:
+            return (ipi_mult - S.Half).is_integer
+
+
+class tanh(HyperbolicFunction):
+    r"""
+    ``tanh(x)`` is the hyperbolic tangent of ``x``.
+
+    The hyperbolic tangent function is $\frac{\sinh(x)}{\cosh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import tanh
+    >>> from sympy.abc import x
+    >>> tanh(x)
+    tanh(x)
+
+    See Also
+    ========
+
+    sinh, cosh, atanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return S.One - tanh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return atanh
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.Zero
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return -I * tan(-i_coeff)
+                return I * tan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    tanhm = tanh(m*pi*I)
+                    if tanhm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # tanhm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.Zero
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return x/sqrt(1 + x**2)
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return sqrt(x - 1) * sqrt(x + 1) / x
+
+            if arg.func == atanh:
+                return arg.args[0]
+
+            if arg.func == acoth:
+                return 1/arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            a = 2**(n + 1)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return a*(a - 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + cos(im)**2
+        return (sinh(re)*cosh(re)/denom, sin(im)*cos(im)/denom)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            n = len(arg.args)
+            TX = [tanh(x, evaluate=False)._eval_expand_trig()
+                for x in arg.args]
+            p = [0, 0]  # [den, num]
+            for i in range(n + 1):
+                p[i % 2] += symmetric_poly(i, TX)
+            return p[1]/p[0]
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul()
+            if coeff.is_Integer and coeff > 1:
+                T = tanh(terms)
+                n = [nC(range(coeff), k)*T**k for k in range(1, coeff + 1, 2)]
+                d = [nC(range(coeff), k)*T**k for k in range(0, coeff + 1, 2)]
+                return Add(*n)/Add(*d)
+        return tanh(arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp - neg_exp)/(pos_exp + neg_exp)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return -I * tan(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        return -I / cot(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I*sinh(arg)/sinh(pi*I/2 - arg, evaluate=False)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I*cosh(pi*I/2 - arg, evaluate=False)/cosh(arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return 1/coth(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return arg
+        else:
+            return self.func(arg)
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real:
+            return True
+
+        re, im = arg.as_real_imag()
+
+        # if denom = 0, tanh(arg) = zoo
+        if re == 0 and im % pi == pi/2:
+            return None
+
+        # check if im is of the form n*pi/2 to make sin(2*im) = 0
+        # if not, im could be a number, return False in that case
+        return (im % (pi/2)).is_zero
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+
+        re, im = arg.as_real_imag()
+        denom = cos(im)**2 + sinh(re)**2
+        if denom == 0:
+            return False
+        elif denom.is_number:
+            return True
+        if arg.is_extended_real:
+            return True
+
+    def _eval_is_zero(self):
+        arg = self.args[0]
+        if arg.is_zero:
+            return True
+
+
+class coth(HyperbolicFunction):
+    r"""
+    ``coth(x)`` is the hyperbolic cotangent of ``x``.
+
+    The hyperbolic cotangent function is $\frac{\cosh(x)}{\sinh(x)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import coth
+    >>> from sympy.abc import x
+    >>> coth(x)
+    coth(x)
+
+    See Also
+    ========
+
+    sinh, cosh, acoth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/sinh(self.args[0])**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return acoth
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.NaN
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                if i_coeff.could_extract_minus_sign():
+                    return I * cot(-i_coeff)
+                return -I * cot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+            if arg.is_Add:
+                x, m = _peeloff_ipi(arg)
+                if m:
+                    cothm = coth(m*pi*I)
+                    if cothm is S.ComplexInfinity:
+                        return coth(x)
+                    else: # cothm == 0
+                        return tanh(x)
+
+            if arg.is_zero:
+                return S.ComplexInfinity
+
+            if arg.func == asinh:
+                x = arg.args[0]
+                return sqrt(1 + x**2)/x
+
+            if arg.func == acosh:
+                x = arg.args[0]
+                return x/(sqrt(x - 1) * sqrt(x + 1))
+
+            if arg.func == atanh:
+                return 1/arg.args[0]
+
+            if arg.func == acoth:
+                return arg.args[0]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return 1 / sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2**(n + 1) * B/F * x**n
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.trigonometric import (cos, sin)
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.expand(deep, **hints), S.Zero)
+            else:
+                return (self, S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        denom = sinh(re)**2 + sin(im)**2
+        return (sinh(re)*cosh(re)/denom, -sin(im)*cos(im)/denom)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        neg_exp, pos_exp = exp(-arg), exp(arg)
+        return (pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return -I*sinh(pi*I/2 - arg, evaluate=False)/sinh(arg)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return -I*cosh(arg)/cosh(pi*I/2 - arg, evaluate=False)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return 1/tanh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x)
+
+        if x in arg.free_symbols and Order(1, x).contains(arg):
+            return 1/arg
+        else:
+            return self.func(arg)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        if arg.is_Add:
+            CX = [coth(x, evaluate=False)._eval_expand_trig() for x in arg.args]
+            p = [[], []]
+            n = len(arg.args)
+            for i in range(n, -1, -1):
+                p[(n - i) % 2].append(symmetric_poly(i, CX))
+            return Add(*p[0])/Add(*p[1])
+        elif arg.is_Mul:
+            coeff, x = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer and coeff > 1:
+                c = coth(x, evaluate=False)
+                p = [[], []]
+                for i in range(coeff, -1, -1):
+                    p[(coeff - i) % 2].append(binomial(coeff, i)*c**i)
+                return Add(*p[0])/Add(*p[1])
+        return coth(arg)
+
+
+class ReciprocalHyperbolicFunction(HyperbolicFunction):
+    """Base class for reciprocal functions of hyperbolic functions. """
+
+    #To be defined in class
+    _reciprocal_of = None
+    _is_even: FuzzyBool = None
+    _is_odd: FuzzyBool = None
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.could_extract_minus_sign():
+            if cls._is_even:
+                return cls(-arg)
+            if cls._is_odd:
+                return -cls(-arg)
+
+        t = cls._reciprocal_of.eval(arg)
+        if hasattr(arg, 'inverse') and arg.inverse() == cls:
+            return arg.args[0]
+        return 1/t if t is not None else t
+
+    def _call_reciprocal(self, method_name, *args, **kwargs):
+        # Calls method_name on _reciprocal_of
+        o = self._reciprocal_of(self.args[0])
+        return getattr(o, method_name)(*args, **kwargs)
+
+    def _calculate_reciprocal(self, method_name, *args, **kwargs):
+        # If calling method_name on _reciprocal_of returns a value != None
+        # then return the reciprocal of that value
+        t = self._call_reciprocal(method_name, *args, **kwargs)
+        return 1/t if t is not None else t
+
+    def _rewrite_reciprocal(self, method_name, arg):
+        # Special handling for rewrite functions. If reciprocal rewrite returns
+        # unmodified expression, then return None
+        t = self._call_reciprocal(method_name, arg)
+        if t is not None and t != self._reciprocal_of(arg):
+            return 1/t
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_exp", arg)
+
+    def _eval_rewrite_as_tractable(self, arg, limitvar=None, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tractable", arg)
+
+    def _eval_rewrite_as_tanh(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tanh", arg)
+
+    def _eval_rewrite_as_coth(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_coth", arg)
+
+    def as_real_imag(self, deep = True, **hints):
+        return (1 / self._reciprocal_of(self.args[0])).as_real_imag(deep, **hints)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=True, **hints)
+        return re_part + I*im_part
+
+    def _eval_expand_trig(self, **hints):
+        return self._calculate_reciprocal("_eval_expand_trig", **hints)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        return (1/self._reciprocal_of(self.args[0]))._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_extended_real(self):
+        return self._reciprocal_of(self.args[0]).is_extended_real
+
+    def _eval_is_finite(self):
+        return (1/self._reciprocal_of(self.args[0])).is_finite
+
+
+class csch(ReciprocalHyperbolicFunction):
+    r"""
+    ``csch(x)`` is the hyperbolic cosecant of ``x``.
+
+    The hyperbolic cosecant function is $\frac{2}{e^x - e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import csch
+    >>> from sympy.abc import x
+    >>> csch(x)
+    csch(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, sech, asinh, acosh
+    """
+
+    _reciprocal_of = sinh
+    _is_odd = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of this function
+        """
+        if argindex == 1:
+            return -coth(self.args[0]) * csch(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        """
+        Returns the next term in the Taylor series expansion
+        """
+        if n == 0:
+            return 1/sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return 2 * (1 - 2**n) * B/F * x**n
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return I / sin(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return I * csc(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return I / cosh(arg + I * pi / 2, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return 1 / sinh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real:
+            return self.args[0].is_negative
+
+
+class sech(ReciprocalHyperbolicFunction):
+    r"""
+    ``sech(x)`` is the hyperbolic secant of ``x``.
+
+    The hyperbolic secant function is $\frac{2}{e^x + e^{-x}}$
+
+    Examples
+    ========
+
+    >>> from sympy import sech
+    >>> from sympy.abc import x
+    >>> sech(x)
+    sech(x)
+
+    See Also
+    ========
+
+    sinh, cosh, tanh, coth, csch, asinh, acosh
+    """
+
+    _reciprocal_of = cosh
+    _is_even = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return - tanh(self.args[0])*sech(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return euler(n) / factorial(n) * x**(n)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return 1 / cos(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return sec(I * arg, evaluate=False)
+
+    def _eval_rewrite_as_sinh(self, arg, **kwargs):
+        return I / sinh(arg + I * pi /2, evaluate=False)
+
+    def _eval_rewrite_as_cosh(self, arg, **kwargs):
+        return 1 / cosh(arg)
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real:
+            return True
+
+
+###############################################################################
+############################# HYPERBOLIC INVERSES #############################
+###############################################################################
+
+class InverseHyperbolicFunction(DefinedFunction):
+    """Base class for inverse hyperbolic functions."""
+
+    pass
+
+
+class asinh(InverseHyperbolicFunction):
+    """
+    ``asinh(x)`` is the inverse hyperbolic sine of ``x``.
+
+    The inverse hyperbolic sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import asinh
+    >>> from sympy.abc import x
+    >>> asinh(x).diff(x)
+    1/sqrt(x**2 + 1)
+    >>> asinh(1)
+    log(1 + sqrt(2))
+
+    See Also
+    ========
+
+    acosh, atanh, sinh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/sqrt(self.args[0]**2 + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return log(sqrt(2) + 1)
+            elif arg is S.NegativeOne:
+                return log(sqrt(2) - 1)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.ComplexInfinity
+
+            if arg.is_zero:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * asin(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if isinstance(arg, sinh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor((i + pi/2)/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    return m
+                elif even is False:
+                    return -m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return S.NegativeOne**k * R / F * x**n / n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # Handling branch points
+        if x0 in (-I, I, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_negative:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_positive:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asinh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (I, -I):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_negative:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_positive:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(x/sqrt(1 + x**2))
+
+    def _eval_rewrite_as_acosh(self, x, **kwargs):
+        ix = I*x
+        return I*(sqrt(1 - ix)/sqrt(ix - 1) * acosh(ix) - pi/2)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return -I * asin(I * x, evaluate=False)
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return I * acos(I * x, evaluate=False) - I*pi/2
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sinh
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+class acosh(InverseHyperbolicFunction):
+    """
+    ``acosh(x)`` is the inverse hyperbolic cosine of ``x``.
+
+    The inverse hyperbolic cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import acosh
+    >>> from sympy.abc import x
+    >>> acosh(x).diff(x)
+    1/(sqrt(x - 1)*sqrt(x + 1))
+    >>> acosh(1)
+    0
+
+    See Also
+    ========
+
+    asinh, atanh, cosh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            arg = self.args[0]
+            return 1/(sqrt(arg - 1)*sqrt(arg + 1))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Infinity
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _acosh_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            return S.ComplexInfinity
+        if arg == I*S.Infinity:
+            return S.Infinity + I*pi/2
+        if arg == -I*S.Infinity:
+            return S.Infinity - I*pi/2
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+        if isinstance(arg, cosh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return Abs(z)
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(i/pi)
+                m = z - I*pi*f
+                even = f.is_even
+                if even is True:
+                    if r.is_nonnegative:
+                        return m
+                    elif r.is_negative:
+                        return -m
+                elif even is False:
+                    m -= I*pi
+                    if r.is_nonpositive:
+                        return -m
+                    elif r.is_positive:
+                        return m
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return p * (n - 2)**2/(n*(n - 1)) * x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return -R / F * I * x**n / n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # Handling points lying on branch cuts (-oo, 1)
+        if (x0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (x0 + 1).is_negative:
+                    return self.func(x0) - 2*I*pi
+                return -self.func(x0)
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acosh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 1)
+        if (arg0 - 1).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if (arg0 + 1).is_negative:
+                    return res - 2*I*pi
+                return -res
+            elif not im(ndir).is_positive:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return log(x + sqrt(x + 1) * sqrt(x - 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * acos(x)
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 - asin(x))
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return sqrt(x - 1)/sqrt(1 - x) * (pi/2 + I*asinh(I*x, evaluate=False))
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        sxm1 = sqrt(x - 1)
+        s1mx = sqrt(1 - x)
+        sx2m1 = sqrt(x**2 - 1)
+        return (pi/2*sxm1/s1mx*(1 - x * sqrt(1/x**2)) +
+                sxm1*sqrt(x + 1)/sx2m1 * atanh(sx2m1/x))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return cosh
+
+    def _eval_is_zero(self):
+        if (self.args[0] - 1).is_zero:
+            return True
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, (self.args[0] - 1).is_extended_nonnegative])
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+
+class atanh(InverseHyperbolicFunction):
+    """
+    ``atanh(x)`` is the inverse hyperbolic tangent of ``x``.
+
+    The inverse hyperbolic tangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import atanh
+    >>> from sympy.abc import x
+    >>> atanh(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, tanh
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg is S.Infinity:
+                return -I * atan(arg)
+            elif arg is S.NegativeInfinity:
+                return I * atan(-arg)
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                from sympy.calculus.accumulationbounds import AccumBounds
+                return I*AccumBounds(-pi/2, pi/2)
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return I * atan(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, tanh) and arg.args[0].is_number:
+            z = arg.args[0]
+            if z.is_real:
+                return z
+            r, i = match_real_imag(z)
+            if r is not None and i is not None:
+                f = floor(2*i/pi)
+                even = f.is_even
+                m = z - I*f*pi/2
+                if even is True:
+                    return m
+                elif even is False:
+                    return m - I*pi/2
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            elif im(ndir).is_positive:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # atanh
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, -1] U [1, oo)
+        if (1 - arg0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_negative:
+                    return res - I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_positive:
+                    return res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + x) - log(1 - x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        f = sqrt(1/(x**2 - 1))
+        return (pi*x/(2*sqrt(-x**2)) -
+                sqrt(-x)*sqrt(1 - x**2)/sqrt(x)*f*asinh(f))
+
+    def _eval_is_zero(self):
+        if self.args[0].is_zero:
+            return True
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, (1 - self.args[0]).is_nonnegative, (self.args[0] + 1).is_nonnegative])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(fuzzy_or([(self.args[0] - 1).is_zero, (self.args[0] + 1).is_zero]))
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return tanh
+
+
+class acoth(InverseHyperbolicFunction):
+    """
+    ``acoth(x)`` is the inverse hyperbolic cotangent of ``x``.
+
+    The inverse hyperbolic cotangent function.
+
+    Examples
+    ========
+
+    >>> from sympy import acoth
+    >>> from sympy.abc import x
+    >>> acoth(x).diff(x)
+    1/(1 - x**2)
+
+    See Also
+    ========
+
+    asinh, acosh, coth
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return pi*I / 2
+            elif arg is S.One:
+                return S.Infinity
+            elif arg is S.NegativeOne:
+                return S.NegativeInfinity
+            elif arg.is_negative:
+                return -cls(-arg)
+        else:
+            if arg is S.ComplexInfinity:
+                return S.Zero
+
+            i_coeff = _imaginary_unit_as_coefficient(arg)
+
+            if i_coeff is not None:
+                return -I * acot(i_coeff)
+            else:
+                if arg.could_extract_minus_sign():
+                    return -cls(-arg)
+
+        if arg.is_zero:
+            return pi*I*S.Half
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return -I*pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return x**n / n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts [-1, 1]
+        if x0.is_real and (1 - x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_positive:
+                    return self.func(x0) + I*pi
+            elif im(ndir).is_positive:
+                if x0.is_negative:
+                    return self.func(x0) - I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acoth
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.One, S.NegativeOne):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts [-1, 1]
+        if arg0.is_real and (1 - arg0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_positive:
+                    return res + I*pi
+            elif im(ndir).is_positive:
+                if arg0.is_negative:
+                    return res - I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return (log(1 + 1/x) - log(1 - 1/x)) / 2
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return atanh(1/x)
+
+    def _eval_rewrite_as_asinh(self, x, **kwargs):
+        return (pi*I/2*(sqrt((x - 1)/x)*sqrt(x/(x - 1)) - sqrt(1 + 1/x)*sqrt(x/(x + 1))) +
+                x*sqrt(1/x**2)*asinh(sqrt(1/(x**2 - 1))))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return coth
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, fuzzy_or([(self.args[0] - 1).is_extended_nonnegative, (self.args[0] + 1).is_extended_nonpositive])])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(fuzzy_or([(self.args[0] - 1).is_zero, (self.args[0] + 1).is_zero]))
+
+
+class asech(InverseHyperbolicFunction):
+    """
+    ``asech(x)`` is the inverse hyperbolic secant of ``x``.
+
+    The inverse hyperbolic secant function.
+
+    Examples
+    ========
+
+    >>> from sympy import asech, sqrt, S
+    >>> from sympy.abc import x
+    >>> asech(x).diff(x)
+    -1/(x*sqrt(1 - x**2))
+    >>> asech(1).diff(x)
+    0
+    >>> asech(1)
+    0
+    >>> asech(S(2))
+    I*pi/3
+    >>> asech(-sqrt(2))
+    3*I*pi/4
+    >>> asech((sqrt(6) - sqrt(2)))
+    I*pi/12
+
+    See Also
+    ========
+
+    asinh, atanh, cosh, acoth
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcSech/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z*sqrt(1 - z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return pi*I / 2
+            elif arg is S.NegativeInfinity:
+                return pi*I / 2
+            elif arg.is_zero:
+                return S.Infinity
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi*I
+
+        if arg.is_number:
+            cst_table = _asech_table()
+
+            if arg in cst_table:
+                if arg.is_extended_real:
+                    return cst_table[arg]*I
+                return cst_table[arg]
+
+        if arg is S.ComplexInfinity:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            return I*AccumBounds(-pi/2, pi/2)
+
+        if arg.is_zero:
+            return S.Infinity
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) * n
+                F = factorial(k) * n // 2 * n // 2
+                return -1 * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-S.One, S.Zero, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if x0.is_negative or (1 - x0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if x0.is_positive or (x0 + 1).is_negative:
+                    return -self.func(x0)
+                return self.func(x0) - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asech
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = asech(S.One - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = asech(S.NegativeOne + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-oo, 0] U (1, oo)
+        if arg0.is_negative or (1 - arg0).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_positive:
+                if arg0.is_positive or (arg0 + 1).is_negative:
+                    return -res
+                return res - 2*I*pi
+            elif not im(ndir).is_negative:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sech
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg - 1) * sqrt(1/arg + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return acosh(1/arg)
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return sqrt(1/arg - 1)/sqrt(1 - 1/arg)*(I*asinh(I/arg, evaluate=False)
+                                                + pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, x, **kwargs):
+        return (I*pi*(1 - sqrt(x)*sqrt(1/x) - I/2*sqrt(-x)/sqrt(x) - I/2*sqrt(x**2)/sqrt(-x**2))
+                + sqrt(1/(x + 1))*sqrt(x + 1)*atanh(sqrt(1 - x**2)))
+
+    def _eval_rewrite_as_acsch(self, x, **kwargs):
+        return sqrt(1/x - 1)/sqrt(1 - 1/x)*(pi/2 - I*acsch(I*x, evaluate=False))
+
+    def _eval_is_extended_real(self):
+        return fuzzy_and([self.args[0].is_extended_real, self.args[0].is_nonnegative, (1 - self.args[0]).is_nonnegative])
+
+    def _eval_is_finite(self):
+        return fuzzy_not(self.args[0].is_zero)
+
+
+class acsch(InverseHyperbolicFunction):
+    """
+    ``acsch(x)`` is the inverse hyperbolic cosecant of ``x``.
+
+    The inverse hyperbolic cosecant function.
+
+    Examples
+    ========
+
+    >>> from sympy import acsch, sqrt, I
+    >>> from sympy.abc import x
+    >>> acsch(x).diff(x)
+    -1/(x**2*sqrt(1 + x**(-2)))
+    >>> acsch(1).diff(x)
+    0
+    >>> acsch(1)
+    log(1 + sqrt(2))
+    >>> acsch(I)
+    -I*pi/2
+    >>> acsch(-2*I)
+    I*pi/6
+    >>> acsch(I*(sqrt(6) - sqrt(2)))
+    -5*I*pi/12
+
+    See Also
+    ========
+
+    asinh
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hyperbolic_function
+    .. [2] https://dlmf.nist.gov/4.37
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcCsch/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -1/(z**2*sqrt(1 + 1/z**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.ComplexInfinity
+            elif arg is S.One:
+                return log(1 + sqrt(2))
+            elif arg is S.NegativeOne:
+                return - log(1 + sqrt(2))
+
+        if arg.is_number:
+            cst_table = _acsch_table()
+
+            if arg in cst_table:
+                return cst_table[arg]*I
+
+        if arg is S.ComplexInfinity:
+            return S.Zero
+
+        if arg.is_infinite:
+            return S.Zero
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return -p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) *  n
+                F = factorial(k) * n // 2 * n // 2
+                return S.NegativeOne**(k +1) * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        # Handling branch points
+        if x0 in (-I, I, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+        if x0 is S.NaN:
+            expr = self.func(arg.as_leading_term(x))
+            if expr.is_finite:
+                return expr
+            else:
+                return self
+
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling points lying on branch cuts (-I, I)
+        if x0.is_imaginary and (1 + x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_positive:
+                    return -self.func(x0) - I*pi
+            elif re(ndir).is_negative:
+                if im(x0).is_negative:
+                    return -self.func(x0) + I*pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acsch
+        from sympy.series.order import O
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+
+        # Handling branch points
+        if arg0 is I:
+            t = Dummy('t', positive=True)
+            ser = acsch(I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = -I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else -I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            res = ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+            return res
+
+        if arg0 == S.NegativeOne*I:
+            t = Dummy('t', positive=True)
+            ser = acsch(-I + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = I + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else I*pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+
+        # Handling points lying on branch cuts (-I, I)
+        if arg0.is_imaginary and (1 + arg0**2).is_positive:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(arg0).is_positive:
+                    return -res - I*pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_negative:
+                    return -res + I*pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return csch
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return log(1/arg + sqrt(1/arg**2 + 1))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asinh(self, arg, **kwargs):
+        return asinh(1/arg)
+
+    def _eval_rewrite_as_acosh(self, arg, **kwargs):
+        return I*(sqrt(1 - I/arg)/sqrt(I/arg - 1)*
+                                acosh(I/arg, evaluate=False) - pi*S.Half)
+
+    def _eval_rewrite_as_atanh(self, arg, **kwargs):
+        arg2 = arg**2
+        arg2p1 = arg2 + 1
+        return sqrt(-arg2)/arg*(pi*S.Half -
+                                sqrt(-arg2p1**2)/arg2p1*atanh(sqrt(arg2p1)))
+
+    def _eval_is_zero(self):
+        return self.args[0].is_infinite
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_finite(self):
+        return fuzzy_not(self.args[0].is_zero)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/integers.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/integers.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0b58d32399144c39133855475d70c01b70b1a3f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/integers.py
@@ -0,0 +1,710 @@
+from __future__ import annotations
+
+from sympy.core.basic import Basic
+from sympy.core.expr import Expr
+
+from sympy.core import Add, S
+from sympy.core.evalf import get_integer_part, PrecisionExhausted
+from sympy.core.function import DefinedFunction
+from sympy.core.logic import fuzzy_or, fuzzy_and
+from sympy.core.numbers import Integer, int_valued
+from sympy.core.relational import Gt, Lt, Ge, Le, Relational, is_eq, is_le, is_lt
+from sympy.core.sympify import _sympify
+from sympy.functions.elementary.complexes import im, re
+from sympy.multipledispatch import dispatch
+
+###############################################################################
+######################### FLOOR and CEILING FUNCTIONS #########################
+###############################################################################
+
+
+class RoundFunction(DefinedFunction):
+    """Abstract base class for rounding functions."""
+
+    args: tuple[Expr]
+
+    @classmethod
+    def eval(cls, arg):
+        if (v := cls._eval_number(arg)) is not None:
+            return v
+        if (v := cls._eval_const_number(arg)) is not None:
+            return v
+
+        if arg.is_integer or arg.is_finite is False:
+            return arg
+        if arg.is_imaginary or (S.ImaginaryUnit*arg).is_real:
+            i = im(arg)
+            if not i.has(S.ImaginaryUnit):
+                return cls(i)*S.ImaginaryUnit
+            return cls(arg, evaluate=False)
+
+        # Integral, numerical, symbolic part
+        ipart = npart = spart = S.Zero
+
+        # Extract integral (or complex integral) terms
+        intof = lambda x: int(x) if int_valued(x) else (
+            x if x.is_integer else None)
+        for t in Add.make_args(arg):
+            if t.is_imaginary and (i := intof(im(t))) is not None:
+                ipart += i*S.ImaginaryUnit
+            elif (i := intof(t)) is not None:
+                ipart += i
+            elif t.is_number:
+                npart += t
+            else:
+                spart += t
+
+        if not (npart or spart):
+            return ipart
+
+        # Evaluate npart numerically if independent of spart
+        if npart and (
+            not spart or
+            npart.is_real and (spart.is_imaginary or (S.ImaginaryUnit*spart).is_real) or
+                npart.is_imaginary and spart.is_real):
+            try:
+                r, i = get_integer_part(
+                    npart, cls._dir, {}, return_ints=True)
+                ipart += Integer(r) + Integer(i)*S.ImaginaryUnit
+                npart = S.Zero
+            except (PrecisionExhausted, NotImplementedError):
+                pass
+
+        spart += npart
+        if not spart:
+            return ipart
+        elif spart.is_imaginary or (S.ImaginaryUnit*spart).is_real:
+            return ipart + cls(im(spart), evaluate=False)*S.ImaginaryUnit
+        elif isinstance(spart, (floor, ceiling)):
+            return ipart + spart
+        else:
+            return ipart + cls(spart, evaluate=False)
+
+    @classmethod
+    def _eval_number(cls, arg):
+        raise NotImplementedError()
+
+    def _eval_is_finite(self):
+        return self.args[0].is_finite
+
+    def _eval_is_real(self):
+        return self.args[0].is_real
+
+    def _eval_is_integer(self):
+        return self.args[0].is_real
+
+
+class floor(RoundFunction):
+    """
+    Floor is a univariate function which returns the largest integer
+    value not greater than its argument. This implementation
+    generalizes floor to complex numbers by taking the floor of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import floor, E, I, S, Float, Rational
+    >>> floor(17)
+    17
+    >>> floor(Rational(23, 10))
+    2
+    >>> floor(2*E)
+    5
+    >>> floor(-Float(0.567))
+    -1
+    >>> floor(-I/2)
+    -I
+    >>> floor(S(5)/2 + 5*I/2)
+    2 + 2*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/FloorFunction.html
+
+    """
+    _dir = -1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.floor()
+        if any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[0]
+
+    @classmethod
+    def _eval_const_number(cls, arg):
+        if arg.is_real:
+            if arg.is_zero:
+                return S.Zero
+            if arg.is_positive:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # 0 <= num/den < 1 -> 0
+                if is_lt(num, den):
+                    return S.Zero
+                # 1 <= num/den < 2 -> 1
+                if fuzzy_and([is_le(den, num), is_lt(num, 2*den)]):
+                    return S.One
+            if arg.is_negative:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # -1 <= num/den < 0 -> -1
+                if is_le(-den, num):
+                    return S.NegativeOne
+                # -2 <= num/den < -1 -> -2
+                if fuzzy_and([is_le(-2*den, num), is_lt(num, -den)]):
+                    return Integer(-2)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+                if ndir.is_negative:
+                    return r - 1
+                elif ndir.is_positive:
+                    return r
+                else:
+                    raise NotImplementedError("Not sure of sign of %s" % ndir)
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = floor(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(-1, 0)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            if ndir.is_negative:
+                return r - 1
+            elif ndir.is_positive:
+                return r
+            else:
+                raise NotImplementedError("Not sure of sign of %s" % ndir)
+        else:
+            return r
+
+    def _eval_is_negative(self):
+        return self.args[0].is_negative
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_nonnegative
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return -ceiling(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg - frac(arg)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real and other.is_noninteger:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] >= other + 1
+            if other.is_number and other.is_real:
+                return self.args[0] >= ceiling(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] < other
+            if other.is_number and other.is_real:
+                return self.args[0] < ceiling(other)
+        if self.args[0] == other and other.is_real and other.is_noninteger:
+            return S.true
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+
+@dispatch(floor, Expr)
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    return is_eq(lhs.rewrite(ceiling), rhs) or \
+        is_eq(lhs.rewrite(frac),rhs)
+
+
+class ceiling(RoundFunction):
+    """
+    Ceiling is a univariate function which returns the smallest integer
+    value not less than its argument. This implementation
+    generalizes ceiling to complex numbers by taking the ceiling of the
+    real and imaginary parts separately.
+
+    Examples
+    ========
+
+    >>> from sympy import ceiling, E, I, S, Float, Rational
+    >>> ceiling(17)
+    17
+    >>> ceiling(Rational(23, 10))
+    3
+    >>> ceiling(2*E)
+    6
+    >>> ceiling(-Float(0.567))
+    0
+    >>> ceiling(I/2)
+    I
+    >>> ceiling(S(5)/2 + 5*I/2)
+    3 + 3*I
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+
+    References
+    ==========
+
+    .. [1] "Concrete mathematics" by Graham, pp. 87
+    .. [2] https://mathworld.wolfram.com/CeilingFunction.html
+
+    """
+    _dir = 1
+
+    @classmethod
+    def _eval_number(cls, arg):
+        if arg.is_Number:
+            return arg.ceiling()
+        if any(isinstance(i, j)
+                for i in (arg, -arg) for j in (floor, ceiling)):
+            return arg
+        if arg.is_NumberSymbol:
+            return arg.approximation_interval(Integer)[1]
+
+    @classmethod
+    def _eval_const_number(cls, arg):
+        if arg.is_real:
+            if arg.is_zero:
+                return S.Zero
+            if arg.is_positive:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # 0 < num/den <= 1 -> 1
+                if is_le(num, den):
+                    return S.One
+                # 1 < num/den <= 2 -> 2
+                if fuzzy_and([is_lt(den, num), is_le(num, 2*den)]):
+                    return Integer(2)
+            if arg.is_negative:
+                num, den = arg.as_numer_denom()
+                s = den.is_negative
+                if s is None:
+                    return None
+                if s:
+                    num, den = -num, -den
+                # -1 < num/den <= 0 -> 0
+                if is_lt(-den, num):
+                    return S.Zero
+                # -2 < num/den <= -1 -> -1
+                if fuzzy_and([is_lt(-2*den, num), is_le(num, -den)]):
+                    return S.NegativeOne
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN or isinstance(arg0, AccumBounds):
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_finite:
+            if arg0 == r:
+                ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+                if ndir.is_negative:
+                    return r
+                elif ndir.is_positive:
+                    return r + 1
+                else:
+                    raise NotImplementedError("Not sure of sign of %s" % ndir)
+            else:
+                return r
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+            r = ceiling(arg0)
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            from sympy.series.order import Order
+            s = arg._eval_nseries(x, n, logx, cdir)
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1)
+            return s + o
+        if arg0 == r:
+            ndir = arg.dir(x, cdir=cdir if cdir != 0 else 1)
+            if ndir.is_negative:
+                return r
+            elif ndir.is_positive:
+                return r + 1
+            else:
+                raise NotImplementedError("Not sure of sign of %s" % ndir)
+        else:
+            return r
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return -floor(-arg)
+
+    def _eval_rewrite_as_frac(self, arg, **kwargs):
+        return arg + frac(-arg)
+
+    def _eval_is_positive(self):
+        return self.args[0].is_positive
+
+    def _eval_is_nonpositive(self):
+        return self.args[0].is_nonpositive
+
+    def __lt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Lt(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real and other.is_noninteger:
+            return S.true
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Gt(self, other, evaluate=False)
+
+    def __ge__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] > other - 1
+            if other.is_number and other.is_real:
+                return self.args[0] > floor(other)
+        if self.args[0] == other and other.is_real:
+            return S.true
+        if other is S.NegativeInfinity and self.is_finite:
+            return S.true
+
+        return Ge(self, other, evaluate=False)
+
+    def __le__(self, other):
+        other = S(other)
+        if self.args[0].is_real:
+            if other.is_integer:
+                return self.args[0] <= other
+            if other.is_number and other.is_real:
+                return self.args[0] <= floor(other)
+        if self.args[0] == other and other.is_real and other.is_noninteger:
+            return S.false
+        if other is S.Infinity and self.is_finite:
+            return S.true
+
+        return Le(self, other, evaluate=False)
+
+
+@dispatch(ceiling, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    return is_eq(lhs.rewrite(floor), rhs) or is_eq(lhs.rewrite(frac),rhs)
+
+
+class frac(DefinedFunction):
+    r"""Represents the fractional part of x
+
+    For real numbers it is defined [1]_ as
+
+    .. math::
+        x - \left\lfloor{x}\right\rfloor
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, frac, Rational, floor, I
+    >>> frac(Rational(4, 3))
+    1/3
+    >>> frac(-Rational(4, 3))
+    2/3
+
+    returns zero for integer arguments
+
+    >>> n = Symbol('n', integer=True)
+    >>> frac(n)
+    0
+
+    rewrite as floor
+
+    >>> x = Symbol('x')
+    >>> frac(x).rewrite(floor)
+    x - floor(x)
+
+    for complex arguments
+
+    >>> r = Symbol('r', real=True)
+    >>> t = Symbol('t', real=True)
+    >>> frac(t + I*r)
+    I*frac(r) + frac(t)
+
+    See Also
+    ========
+
+    sympy.functions.elementary.integers.floor
+    sympy.functions.elementary.integers.ceiling
+
+    References
+    ===========
+
+    .. [1] https://en.wikipedia.org/wiki/Fractional_part
+    .. [2] https://mathworld.wolfram.com/FractionalPart.html
+
+    """
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+
+        def _eval(arg):
+            if arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(0, 1)
+            if arg.is_integer:
+                return S.Zero
+            if arg.is_number:
+                if arg is S.NaN:
+                    return S.NaN
+                elif arg is S.ComplexInfinity:
+                    return S.NaN
+                else:
+                    return arg - floor(arg)
+            return cls(arg, evaluate=False)
+
+        real, imag = S.Zero, S.Zero
+        for t in Add.make_args(arg):
+            # Two checks are needed for complex arguments
+            # see issue-7649 for details
+            if t.is_imaginary or (S.ImaginaryUnit*t).is_real:
+                i = im(t)
+                if not i.has(S.ImaginaryUnit):
+                    imag += i
+                else:
+                    real += t
+            else:
+                real += t
+
+        real = _eval(real)
+        imag = _eval(imag)
+        return real + S.ImaginaryUnit*imag
+
+    def _eval_rewrite_as_floor(self, arg, **kwargs):
+        return arg - floor(arg)
+
+    def _eval_rewrite_as_ceiling(self, arg, **kwargs):
+        return arg + ceiling(-arg)
+
+    def _eval_is_finite(self):
+        return True
+
+    def _eval_is_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_imaginary(self):
+        return self.args[0].is_imaginary
+
+    def _eval_is_integer(self):
+        return self.args[0].is_integer
+
+    def _eval_is_zero(self):
+        return fuzzy_or([self.args[0].is_zero, self.args[0].is_integer])
+
+    def _eval_is_negative(self):
+        return False
+
+    def __ge__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.true
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+        return Ge(self, other, evaluate=False)
+
+    def __gt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return not(res)
+            # Check if other >= 1
+            if other.is_extended_negative:
+                return S.true
+        return Gt(self, other, evaluate=False)
+
+    def __le__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other < 0
+            if other.is_extended_negative:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Le(self, other, evaluate=False)
+
+    def __lt__(self, other):
+        if self.is_extended_real:
+            other = _sympify(other)
+            # Check if other <= 0
+            if other.is_extended_nonpositive:
+                return S.false
+            # Check if other >= 1
+            res = self._value_one_or_more(other)
+            if res is not None:
+                return res
+        return Lt(self, other, evaluate=False)
+
+    def _value_one_or_more(self, other):
+        if other.is_extended_real:
+            if other.is_number:
+                res = other >= 1
+                if res and not isinstance(res, Relational):
+                    return S.true
+            if other.is_integer and other.is_positive:
+                return S.true
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_finite:
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                if ndir.is_negative:
+                    return S.One
+                return (arg - arg0).as_leading_term(x, logx=logx, cdir=cdir)
+            else:
+                return r
+        elif arg0 in (S.ComplexInfinity, S.Infinity, S.NegativeInfinity):
+            return AccumBounds(0, 1)
+        return arg.as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        arg = self.args[0]
+        arg0 = arg.subs(x, 0)
+        r = self.subs(x, 0)
+
+        if arg0.is_infinite:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            o = Order(1, (x, 0)) if n <= 0 else AccumBounds(0, 1) + Order(x**n, (x, 0))
+            return o
+        else:
+            res = (arg - arg0)._eval_nseries(x, n, logx=logx, cdir=cdir)
+            if r.is_zero:
+                ndir = arg.dir(x, cdir=cdir)
+                res += S.One if ndir.is_negative else S.Zero
+            else:
+                res += r
+            return res
+
+
+@dispatch(frac, Basic)  # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa:F811
+    if (lhs.rewrite(floor) == rhs) or \
+        (lhs.rewrite(ceiling) == rhs):
+        return True
+    # Check if other < 0
+    if rhs.is_extended_negative:
+        return False
+    # Check if other >= 1
+    res = lhs._value_one_or_more(rhs)
+    if res is not None:
+        return False
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/miscellaneous.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/miscellaneous.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7f3016bc7ea0d5c4ad778cf9922c941acb7fc44
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/miscellaneous.py
@@ -0,0 +1,915 @@
+from sympy.core import S, sympify, NumberKind
+from sympy.utilities.iterables import sift
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.operations import LatticeOp, ShortCircuit
+from sympy.core.function import (Application, Lambda,
+    ArgumentIndexError, DefinedFunction)
+from sympy.core.expr import Expr
+from sympy.core.exprtools import factor_terms
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import Rational
+from sympy.core.power import Pow
+from sympy.core.relational import Eq, Relational
+from sympy.core.singleton import Singleton
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy
+from sympy.core.rules import Transform
+from sympy.core.logic import fuzzy_and, fuzzy_or, _torf
+from sympy.core.traversal import walk
+from sympy.core.numbers import Integer
+from sympy.logic.boolalg import And, Or
+
+
+def _minmax_as_Piecewise(op, *args):
+    # helper for Min/Max rewrite as Piecewise
+    from sympy.functions.elementary.piecewise import Piecewise
+    ec = []
+    for i, a in enumerate(args):
+        c = [Relational(a, args[j], op) for j in range(i + 1, len(args))]
+        ec.append((a, And(*c)))
+    return Piecewise(*ec)
+
+
+class IdentityFunction(Lambda, metaclass=Singleton):
+    """
+    The identity function
+
+    Examples
+    ========
+
+    >>> from sympy import Id, Symbol
+    >>> x = Symbol('x')
+    >>> Id(x)
+    x
+
+    """
+
+    _symbol = Dummy('x')
+
+    @property
+    def signature(self):
+        return Tuple(self._symbol)
+
+    @property
+    def expr(self):
+        return self._symbol
+
+
+Id = S.IdentityFunction
+
+###############################################################################
+############################# ROOT and SQUARE ROOT FUNCTION ###################
+###############################################################################
+
+
+def sqrt(arg, evaluate=None):
+    """Returns the principal square root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import sqrt, Symbol, S
+    >>> x = Symbol('x')
+
+    >>> sqrt(x)
+    sqrt(x)
+
+    >>> sqrt(x)**2
+    x
+
+    Note that sqrt(x**2) does not simplify to x.
+
+    >>> sqrt(x**2)
+    sqrt(x**2)
+
+    This is because the two are not equal to each other in general.
+    For example, consider x == -1:
+
+    >>> from sympy import Eq
+    >>> Eq(sqrt(x**2), x).subs(x, -1)
+    False
+
+    This is because sqrt computes the principal square root, so the square may
+    put the argument in a different branch.  This identity does hold if x is
+    positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> sqrt(y**2)
+    y
+
+    You can force this simplification by using the powdenest() function with
+    the force option set to True:
+
+    >>> from sympy import powdenest
+    >>> sqrt(x**2)
+    sqrt(x**2)
+    >>> powdenest(sqrt(x**2), force=True)
+    x
+
+    To get both branches of the square root you can use the rootof function:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2-3,i) for i in (0,1)]
+    [-sqrt(3), sqrt(3)]
+
+    Although ``sqrt`` is printed, there is no ``sqrt`` function so looking for
+    ``sqrt`` in an expression will fail:
+
+    >>> from sympy.utilities.misc import func_name
+    >>> func_name(sqrt(x))
+    'Pow'
+    >>> sqrt(x).has(sqrt)
+    False
+
+    To find ``sqrt`` look for ``Pow`` with an exponent of ``1/2``:
+
+    >>> (x + 1/sqrt(x)).find(lambda i: i.is_Pow and abs(i.exp) is S.Half)
+    {1/sqrt(x)}
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+    """
+    # arg = sympify(arg) is handled by Pow
+    return Pow(arg, S.Half, evaluate=evaluate)
+
+
+def cbrt(arg, evaluate=None):
+    """Returns the principal cube root.
+
+    Parameters
+    ==========
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import cbrt, Symbol
+    >>> x = Symbol('x')
+
+    >>> cbrt(x)
+    x**(1/3)
+
+    >>> cbrt(x)**3
+    x
+
+    Note that cbrt(x**3) does not simplify to x.
+
+    >>> cbrt(x**3)
+    (x**3)**(1/3)
+
+    This is because the two are not equal to each other in general.
+    For example, consider `x == -1`:
+
+    >>> from sympy import Eq
+    >>> Eq(cbrt(x**3), x).subs(x, -1)
+    False
+
+    This is because cbrt computes the principal cube root, this
+    identity does hold if `x` is positive:
+
+    >>> y = Symbol('y', positive=True)
+    >>> cbrt(y**3)
+    y
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof, root, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Cube_root
+    .. [2] https://en.wikipedia.org/wiki/Principal_value
+
+    """
+    return Pow(arg, Rational(1, 3), evaluate=evaluate)
+
+
+def root(arg, n, k=0, evaluate=None):
+    r"""Returns the *k*-th *n*-th root of ``arg``.
+
+    Parameters
+    ==========
+
+    k : int, optional
+        Should be an integer in $\{0, 1, ..., n-1\}$.
+        Defaults to the principal root if $0$.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, Rational
+    >>> from sympy.abc import x, n
+
+    >>> root(x, 2)
+    sqrt(x)
+
+    >>> root(x, 3)
+    x**(1/3)
+
+    >>> root(x, n)
+    x**(1/n)
+
+    >>> root(x, -Rational(2, 3))
+    x**(-3/2)
+
+    To get the k-th n-th root, specify k:
+
+    >>> root(-2, 3, 2)
+    -(-1)**(2/3)*2**(1/3)
+
+    To get all n n-th roots you can use the rootof function.
+    The following examples show the roots of unity for n
+    equal 2, 3 and 4:
+
+    >>> from sympy import rootof
+
+    >>> [rootof(x**2 - 1, i) for i in range(2)]
+    [-1, 1]
+
+    >>> [rootof(x**3 - 1,i) for i in range(3)]
+    [1, -1/2 - sqrt(3)*I/2, -1/2 + sqrt(3)*I/2]
+
+    >>> [rootof(x**4 - 1,i) for i in range(4)]
+    [-1, 1, -I, I]
+
+    SymPy, like other symbolic algebra systems, returns the
+    complex root of negative numbers. This is the principal
+    root and differs from the text-book result that one might
+    be expecting. For example, the cube root of -8 does not
+    come back as -2:
+
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+
+    The real_root function can be used to either make the principal
+    result real (or simply to return the real root directly):
+
+    >>> from sympy import real_root
+    >>> real_root(_)
+    -2
+    >>> real_root(-32, 5)
+    -2
+
+    Alternatively, the n//2-th n-th root of a negative number can be
+    computed with root:
+
+    >>> root(-32, 5, 5//2)
+    -2
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.intfunc.integer_nthroot
+    sqrt, real_root
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Square_root
+    .. [2] https://en.wikipedia.org/wiki/Real_root
+    .. [3] https://en.wikipedia.org/wiki/Root_of_unity
+    .. [4] https://en.wikipedia.org/wiki/Principal_value
+    .. [5] https://mathworld.wolfram.com/CubeRoot.html
+
+    """
+    n = sympify(n)
+    if k:
+        return Mul(Pow(arg, S.One/n, evaluate=evaluate), S.NegativeOne**(2*k/n), evaluate=evaluate)
+    return Pow(arg, 1/n, evaluate=evaluate)
+
+
+def real_root(arg, n=None, evaluate=None):
+    r"""Return the real *n*'th-root of *arg* if possible.
+
+    Parameters
+    ==========
+
+    n : int or None, optional
+        If *n* is ``None``, then all instances of
+        $(-n)^{1/\text{odd}}$ will be changed to $-n^{1/\text{odd}}$.
+        This will only create a real root of a principal root.
+        The presence of other factors may cause the result to not be
+        real.
+
+    evaluate : bool, optional
+        The parameter determines if the expression should be evaluated.
+        If ``None``, its value is taken from
+        ``global_parameters.evaluate``.
+
+    Examples
+    ========
+
+    >>> from sympy import root, real_root
+
+    >>> real_root(-8, 3)
+    -2
+    >>> root(-8, 3)
+    2*(-1)**(1/3)
+    >>> real_root(_)
+    -2
+
+    If one creates a non-principal root and applies real_root, the
+    result will not be real (so use with caution):
+
+    >>> root(-8, 3, 2)
+    -2*(-1)**(2/3)
+    >>> real_root(_)
+    -2*(-1)**(2/3)
+
+    See Also
+    ========
+
+    sympy.polys.rootoftools.rootof
+    sympy.core.intfunc.integer_nthroot
+    root, sqrt
+    """
+    from sympy.functions.elementary.complexes import Abs, im, sign
+    from sympy.functions.elementary.piecewise import Piecewise
+    if n is not None:
+        return Piecewise(
+            (root(arg, n, evaluate=evaluate), Or(Eq(n, S.One), Eq(n, S.NegativeOne))),
+            (Mul(sign(arg), root(Abs(arg), n, evaluate=evaluate), evaluate=evaluate),
+            And(Eq(im(arg), S.Zero), Eq(Mod(n, 2), S.One))),
+            (root(arg, n, evaluate=evaluate), True))
+    rv = sympify(arg)
+    n1pow = Transform(lambda x: -(-x.base)**x.exp,
+                      lambda x:
+                      x.is_Pow and
+                      x.base.is_negative and
+                      x.exp.is_Rational and
+                      x.exp.p == 1 and x.exp.q % 2)
+    return rv.xreplace(n1pow)
+
+###############################################################################
+############################# MINIMUM and MAXIMUM #############################
+###############################################################################
+
+
+class MinMaxBase(Expr, LatticeOp):
+    def __new__(cls, *args, **assumptions):
+        from sympy.core.parameters import global_parameters
+        evaluate = assumptions.pop('evaluate', global_parameters.evaluate)
+        args = (sympify(arg) for arg in args)
+
+        # first standard filter, for cls.zero and cls.identity
+        # also reshape Max(a, Max(b, c)) to Max(a, b, c)
+
+        if evaluate:
+            try:
+                args = frozenset(cls._new_args_filter(args))
+            except ShortCircuit:
+                return cls.zero
+            # remove redundant args that are easily identified
+            args = cls._collapse_arguments(args, **assumptions)
+            # find local zeros
+            args = cls._find_localzeros(args, **assumptions)
+        args = frozenset(args)
+
+        if not args:
+            return cls.identity
+
+        if len(args) == 1:
+            return list(args).pop()
+
+        # base creation
+        obj = Expr.__new__(cls, *ordered(args), **assumptions)
+        obj._argset = args
+        return obj
+
+    @classmethod
+    def _collapse_arguments(cls, args, **assumptions):
+        """Remove redundant args.
+
+        Examples
+        ========
+
+        >>> from sympy import Min, Max
+        >>> from sympy.abc import a, b, c, d, e
+
+        Any arg in parent that appears in any
+        parent-like function in any of the flat args
+        of parent can be removed from that sub-arg:
+
+        >>> Min(a, Max(b, Min(a, c, d)))
+        Min(a, Max(b, Min(c, d)))
+
+        If the arg of parent appears in an opposite-than parent
+        function in any of the flat args of parent that function
+        can be replaced with the arg:
+
+        >>> Min(a, Max(b, Min(c, d, Max(a, e))))
+        Min(a, Max(b, Min(a, c, d)))
+        """
+        if not args:
+            return args
+        args = list(ordered(args))
+        if cls == Min:
+            other = Max
+        else:
+            other = Min
+
+        # find global comparable max of Max and min of Min if a new
+        # value is being introduced in these args at position 0 of
+        # the ordered args
+        if args[0].is_number:
+            sifted = mins, maxs = [], []
+            for i in args:
+                for v in walk(i, Min, Max):
+                    if v.args[0].is_comparable:
+                        sifted[isinstance(v, Max)].append(v)
+            small = Min.identity
+            for i in mins:
+                v = i.args[0]
+                if v.is_number and (v < small) == True:
+                    small = v
+            big = Max.identity
+            for i in maxs:
+                v = i.args[0]
+                if v.is_number and (v > big) == True:
+                    big = v
+            # at the point when this function is called from __new__,
+            # there may be more than one numeric arg present since
+            # local zeros have not been handled yet, so look through
+            # more than the first arg
+            if cls == Min:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg < small) == True:
+                        small = arg
+            elif cls == Max:
+                for arg in args:
+                    if not arg.is_number:
+                        break
+                    if (arg > big) == True:
+                        big = arg
+            T = None
+            if cls == Min:
+                if small != Min.identity:
+                    other = Max
+                    T = small
+            elif big != Max.identity:
+                other = Min
+                T = big
+            if T is not None:
+                # remove numerical redundancy
+                for i in range(len(args)):
+                    a = args[i]
+                    if isinstance(a, other):
+                        a0 = a.args[0]
+                        if ((a0 > T) if other == Max else (a0 < T)) == True:
+                            args[i] = cls.identity
+
+        # remove redundant symbolic args
+        def do(ai, a):
+            if not isinstance(ai, (Min, Max)):
+                return ai
+            cond = a in ai.args
+            if not cond:
+                return ai.func(*[do(i, a) for i in ai.args],
+                    evaluate=False)
+            if isinstance(ai, cls):
+                return ai.func(*[do(i, a) for i in ai.args if i != a],
+                    evaluate=False)
+            return a
+        for i, a in enumerate(args):
+            args[i + 1:] = [do(ai, a) for ai in args[i + 1:]]
+
+        # factor out common elements as for
+        # Min(Max(x, y), Max(x, z)) -> Max(x, Min(y, z))
+        # and vice versa when swapping Min/Max -- do this only for the
+        # easy case where all functions contain something in common;
+        # trying to find some optimal subset of args to modify takes
+        # too long
+
+        def factor_minmax(args):
+            is_other = lambda arg: isinstance(arg, other)
+            other_args, remaining_args = sift(args, is_other, binary=True)
+            if not other_args:
+                return args
+
+            # Min(Max(x, y, z), Max(x, y, u, v)) -> {x,y}, ({z}, {u,v})
+            arg_sets = [set(arg.args) for arg in other_args]
+            common = set.intersection(*arg_sets)
+            if not common:
+                return args
+
+            new_other_args = list(common)
+            arg_sets_diff = [arg_set - common for arg_set in arg_sets]
+
+            # If any set is empty after removing common then all can be
+            # discarded e.g. Min(Max(a, b, c), Max(a, b)) -> Max(a, b)
+            if all(arg_sets_diff):
+                other_args_diff = [other(*s, evaluate=False) for s in arg_sets_diff]
+                new_other_args.append(cls(*other_args_diff, evaluate=False))
+
+            other_args_factored = other(*new_other_args, evaluate=False)
+            return remaining_args + [other_args_factored]
+
+        if len(args) > 1:
+            args = factor_minmax(args)
+
+        return args
+
+    @classmethod
+    def _new_args_filter(cls, arg_sequence):
+        """
+        Generator filtering args.
+
+        first standard filter, for cls.zero and cls.identity.
+        Also reshape ``Max(a, Max(b, c))`` to ``Max(a, b, c)``,
+        and check arguments for comparability
+        """
+        for arg in arg_sequence:
+            # pre-filter, checking comparability of arguments
+            if not isinstance(arg, Expr) or arg.is_extended_real is False or (
+                    arg.is_number and
+                    not arg.is_comparable):
+                raise ValueError("The argument '%s' is not comparable." % arg)
+
+            if arg == cls.zero:
+                raise ShortCircuit(arg)
+            elif arg == cls.identity:
+                continue
+            elif arg.func == cls:
+                yield from arg.args
+            else:
+                yield arg
+
+    @classmethod
+    def _find_localzeros(cls, values, **options):
+        """
+        Sequentially allocate values to localzeros.
+
+        When a value is identified as being more extreme than another member it
+        replaces that member; if this is never true, then the value is simply
+        appended to the localzeros.
+        """
+        localzeros = set()
+        for v in values:
+            is_newzero = True
+            localzeros_ = list(localzeros)
+            for z in localzeros_:
+                if id(v) == id(z):
+                    is_newzero = False
+                else:
+                    con = cls._is_connected(v, z)
+                    if con:
+                        is_newzero = False
+                        if con is True or con == cls:
+                            localzeros.remove(z)
+                            localzeros.update([v])
+            if is_newzero:
+                localzeros.update([v])
+        return localzeros
+
+    @classmethod
+    def _is_connected(cls, x, y):
+        """
+        Check if x and y are connected somehow.
+        """
+        for i in range(2):
+            if x == y:
+                return True
+            t, f = Max, Min
+            for op in "><":
+                for j in range(2):
+                    try:
+                        if op == ">":
+                            v = x >= y
+                        else:
+                            v = x <= y
+                    except TypeError:
+                        return False  # non-real arg
+                    if not v.is_Relational:
+                        return t if v else f
+                    t, f = f, t
+                    x, y = y, x
+                x, y = y, x  # run next pass with reversed order relative to start
+            # simplification can be expensive, so be conservative
+            # in what is attempted
+            x = factor_terms(x - y)
+            y = S.Zero
+
+        return False
+
+    def _eval_derivative(self, s):
+        # f(x).diff(s) -> x.diff(s) * f.fdiff(1)(s)
+        i = 0
+        l = []
+        for a in self.args:
+            i += 1
+            da = a.diff(s)
+            if da.is_zero:
+                continue
+            try:
+                df = self.fdiff(i)
+            except ArgumentIndexError:
+                df = super().fdiff(i)
+            l.append(df * da)
+        return Add(*l)
+
+    def _eval_rewrite_as_Abs(self, *args, **kwargs):
+        from sympy.functions.elementary.complexes import Abs
+        s = (args[0] + self.func(*args[1:]))/2
+        d = abs(args[0] - self.func(*args[1:]))/2
+        return (s + d if isinstance(self, Max) else s - d).rewrite(Abs)
+
+    def evalf(self, n=15, **options):
+        return self.func(*[a.evalf(n, **options) for a in self.args])
+
+    def n(self, *args, **kwargs):
+        return self.evalf(*args, **kwargs)
+
+    _eval_is_algebraic = lambda s: _torf(i.is_algebraic for i in s.args)
+    _eval_is_antihermitian = lambda s: _torf(i.is_antihermitian for i in s.args)
+    _eval_is_commutative = lambda s: _torf(i.is_commutative for i in s.args)
+    _eval_is_complex = lambda s: _torf(i.is_complex for i in s.args)
+    _eval_is_composite = lambda s: _torf(i.is_composite for i in s.args)
+    _eval_is_even = lambda s: _torf(i.is_even for i in s.args)
+    _eval_is_finite = lambda s: _torf(i.is_finite for i in s.args)
+    _eval_is_hermitian = lambda s: _torf(i.is_hermitian for i in s.args)
+    _eval_is_imaginary = lambda s: _torf(i.is_imaginary for i in s.args)
+    _eval_is_infinite = lambda s: _torf(i.is_infinite for i in s.args)
+    _eval_is_integer = lambda s: _torf(i.is_integer for i in s.args)
+    _eval_is_irrational = lambda s: _torf(i.is_irrational for i in s.args)
+    _eval_is_negative = lambda s: _torf(i.is_negative for i in s.args)
+    _eval_is_noninteger = lambda s: _torf(i.is_noninteger for i in s.args)
+    _eval_is_nonnegative = lambda s: _torf(i.is_nonnegative for i in s.args)
+    _eval_is_nonpositive = lambda s: _torf(i.is_nonpositive for i in s.args)
+    _eval_is_nonzero = lambda s: _torf(i.is_nonzero for i in s.args)
+    _eval_is_odd = lambda s: _torf(i.is_odd for i in s.args)
+    _eval_is_polar = lambda s: _torf(i.is_polar for i in s.args)
+    _eval_is_positive = lambda s: _torf(i.is_positive for i in s.args)
+    _eval_is_prime = lambda s: _torf(i.is_prime for i in s.args)
+    _eval_is_rational = lambda s: _torf(i.is_rational for i in s.args)
+    _eval_is_real = lambda s: _torf(i.is_real for i in s.args)
+    _eval_is_extended_real = lambda s: _torf(i.is_extended_real for i in s.args)
+    _eval_is_transcendental = lambda s: _torf(i.is_transcendental for i in s.args)
+    _eval_is_zero = lambda s: _torf(i.is_zero for i in s.args)
+
+
+class Max(MinMaxBase, Application):
+    r"""
+    Return, if possible, the maximum value of the list.
+
+    When number of arguments is equal one, then
+    return this argument.
+
+    When number of arguments is equal two, then
+    return, if possible, the value from (a, b) that is $\ge$ the other.
+
+    In common case, when the length of list greater than 2, the task
+    is more complicated. Return only the arguments, which are greater
+    than others, if it is possible to determine directional relation.
+
+    If is not possible to determine such a relation, return a partially
+    evaluated result.
+
+    Assumptions are used to make the decision too.
+
+    Also, only comparable arguments are permitted.
+
+    It is named ``Max`` and not ``max`` to avoid conflicts
+    with the built-in function ``max``.
+
+
+    Examples
+    ========
+
+    >>> from sympy import Max, Symbol, oo
+    >>> from sympy.abc import x, y, z
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Max(x, -2)
+    Max(-2, x)
+    >>> Max(x, -2).subs(x, 3)
+    3
+    >>> Max(p, -2)
+    p
+    >>> Max(x, y)
+    Max(x, y)
+    >>> Max(x, y) == Max(y, x)
+    True
+    >>> Max(x, Max(y, z))
+    Max(x, y, z)
+    >>> Max(n, 8, p, 7, -oo)
+    Max(8, p)
+    >>> Max (1, x, oo)
+    oo
+
+    * Algorithm
+
+    The task can be considered as searching of supremums in the
+    directed complete partial orders [1]_.
+
+    The source values are sequentially allocated by the isolated subsets
+    in which supremums are searched and result as Max arguments.
+
+    If the resulted supremum is single, then it is returned.
+
+    The isolated subsets are the sets of values which are only the comparable
+    with each other in the current set. E.g. natural numbers are comparable with
+    each other, but not comparable with the `x` symbol. Another example: the
+    symbol `x` with negative assumption is comparable with a natural number.
+
+    Also there are "least" elements, which are comparable with all others,
+    and have a zero property (maximum or minimum for all elements).
+    For example, in case of $\infty$, the allocation operation is terminated
+    and only this value is returned.
+
+    Assumption:
+       - if $A > B > C$ then $A > C$
+       - if $A = B$ then $B$ can be removed
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Directed_complete_partial_order
+    .. [2] https://en.wikipedia.org/wiki/Lattice_%28order%29
+
+    See Also
+    ========
+
+    Min : find minimum values
+    """
+    zero = S.Infinity
+    identity = S.NegativeInfinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside(self.args[argindex] - self.args[1 - argindex])
+            newargs = tuple([self.args[i] for i in range(n) if i != argindex])
+            return Heaviside(self.args[argindex] - Max(*newargs))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(j - i) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('>=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_or(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_or(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_and(a.is_negative for a in self.args)
+
+
+class Min(MinMaxBase, Application):
+    """
+    Return, if possible, the minimum value of the list.
+    It is named ``Min`` and not ``min`` to avoid conflicts
+    with the built-in function ``min``.
+
+    Examples
+    ========
+
+    >>> from sympy import Min, Symbol, oo
+    >>> from sympy.abc import x, y
+    >>> p = Symbol('p', positive=True)
+    >>> n = Symbol('n', negative=True)
+
+    >>> Min(x, -2)
+    Min(-2, x)
+    >>> Min(x, -2).subs(x, 3)
+    -2
+    >>> Min(p, -3)
+    -3
+    >>> Min(x, y)
+    Min(x, y)
+    >>> Min(n, 8, p, -7, p, oo)
+    Min(-7, n)
+
+    See Also
+    ========
+
+    Max : find maximum values
+    """
+    zero = S.NegativeInfinity
+    identity = S.Infinity
+
+    def fdiff( self, argindex ):
+        from sympy.functions.special.delta_functions import Heaviside
+        n = len(self.args)
+        if 0 < argindex and argindex <= n:
+            argindex -= 1
+            if n == 2:
+                return Heaviside( self.args[1-argindex] - self.args[argindex] )
+            newargs = tuple([ self.args[i] for i in range(n) if i != argindex])
+            return Heaviside( Min(*newargs) - self.args[argindex] )
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        from sympy.functions.special.delta_functions import Heaviside
+        return Add(*[j*Mul(*[Heaviside(i-j) for i in args if i!=j]) \
+                for j in args])
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        return _minmax_as_Piecewise('<=', *args)
+
+    def _eval_is_positive(self):
+        return fuzzy_and(a.is_positive for a in self.args)
+
+    def _eval_is_nonnegative(self):
+        return fuzzy_and(a.is_nonnegative for a in self.args)
+
+    def _eval_is_negative(self):
+        return fuzzy_or(a.is_negative for a in self.args)
+
+
+class Rem(DefinedFunction):
+    """Returns the remainder when ``p`` is divided by ``q`` where ``p`` is finite
+    and ``q`` is not equal to zero. The result, ``p - int(p/q)*q``, has the same sign
+    as the divisor.
+
+    Parameters
+    ==========
+
+    p : Expr
+        Dividend.
+
+    q : Expr
+        Divisor.
+
+    Notes
+    =====
+
+    ``Rem`` corresponds to the ``%`` operator in C.
+
+    Examples
+    ========
+
+    >>> from sympy.abc import x, y
+    >>> from sympy import Rem
+    >>> Rem(x**3, y)
+    Rem(x**3, y)
+    >>> Rem(x**3, y).subs({x: -5, y: 3})
+    -2
+
+    See Also
+    ========
+
+    Mod
+    """
+    kind = NumberKind
+
+    @classmethod
+    def eval(cls, p, q):
+        """Return the function remainder if both p, q are numbers and q is not
+        zero.
+        """
+
+        if q.is_zero:
+            raise ZeroDivisionError("Division by zero")
+        if p is S.NaN or q is S.NaN or p.is_finite is False or q.is_finite is False:
+            return S.NaN
+        if p is S.Zero or p in (q, -q) or (p.is_integer and q == 1):
+            return S.Zero
+
+        if q.is_Number:
+            if p.is_Number:
+                return p - Integer(p/q)*q
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/piecewise.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/piecewise.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe4a4d4f57e2c3af170dac994e11782b9ed54b8f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/piecewise.py
@@ -0,0 +1,1517 @@
+from sympy.core import S, diff, Tuple, Dummy, Mul
+from sympy.core.basic import Basic, as_Basic
+from sympy.core.function import DefinedFunction
+from sympy.core.numbers import Rational, NumberSymbol, _illegal
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import (Lt, Gt, Eq, Ne, Relational,
+    _canonical, _canonical_coeff)
+from sympy.core.sorting import ordered
+from sympy.functions.elementary.miscellaneous import Max, Min
+from sympy.logic.boolalg import (And, Boolean, distribute_and_over_or, Not,
+    true, false, Or, ITE, simplify_logic, to_cnf, distribute_or_over_and)
+from sympy.utilities.iterables import uniq, sift, common_prefix
+from sympy.utilities.misc import filldedent, func_name
+
+from itertools import product
+
+Undefined = S.NaN  # Piecewise()
+
+class ExprCondPair(Tuple):
+    """Represents an expression, condition pair."""
+
+    def __new__(cls, expr, cond):
+        expr = as_Basic(expr)
+        if cond == True:
+            return Tuple.__new__(cls, expr, true)
+        elif cond == False:
+            return Tuple.__new__(cls, expr, false)
+        elif isinstance(cond, Basic) and cond.has(Piecewise):
+            cond = piecewise_fold(cond)
+            if isinstance(cond, Piecewise):
+                cond = cond.rewrite(ITE)
+
+        if not isinstance(cond, Boolean):
+            raise TypeError(filldedent('''
+                Second argument must be a Boolean,
+                not `%s`''' % func_name(cond)))
+        return Tuple.__new__(cls, expr, cond)
+
+    @property
+    def expr(self):
+        """
+        Returns the expression of this pair.
+        """
+        return self.args[0]
+
+    @property
+    def cond(self):
+        """
+        Returns the condition of this pair.
+        """
+        return self.args[1]
+
+    @property
+    def is_commutative(self):
+        return self.expr.is_commutative
+
+    def __iter__(self):
+        yield self.expr
+        yield self.cond
+
+    def _eval_simplify(self, **kwargs):
+        return self.func(*[a.simplify(**kwargs) for a in self.args])
+
+
+class Piecewise(DefinedFunction):
+    """
+    Represents a piecewise function.
+
+    Usage:
+
+      Piecewise( (expr,cond), (expr,cond), ... )
+        - Each argument is a 2-tuple defining an expression and condition
+        - The conds are evaluated in turn returning the first that is True.
+          If any of the evaluated conds are not explicitly False,
+          e.g. ``x < 1``, the function is returned in symbolic form.
+        - If the function is evaluated at a place where all conditions are False,
+          nan will be returned.
+        - Pairs where the cond is explicitly False, will be removed and no pair
+          appearing after a True condition will ever be retained. If a single
+          pair with a True condition remains, it will be returned, even when
+          evaluation is False.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, log, piecewise_fold
+    >>> from sympy.abc import x, y
+    >>> f = x**2
+    >>> g = log(x)
+    >>> p = Piecewise((0, x < -1), (f, x <= 1), (g, True))
+    >>> p.subs(x,1)
+    1
+    >>> p.subs(x,5)
+    log(5)
+
+    Booleans can contain Piecewise elements:
+
+    >>> cond = (x < y).subs(x, Piecewise((2, x < 0), (3, True))); cond
+    Piecewise((2, x < 0), (3, True)) < y
+
+    The folded version of this results in a Piecewise whose
+    expressions are Booleans:
+
+    >>> folded_cond = piecewise_fold(cond); folded_cond
+    Piecewise((2 < y, x < 0), (3 < y, True))
+
+    When a Boolean containing Piecewise (like cond) or a Piecewise
+    with Boolean expressions (like folded_cond) is used as a condition,
+    it is converted to an equivalent :class:`~.ITE` object:
+
+    >>> Piecewise((1, folded_cond))
+    Piecewise((1, ITE(x < 0, y > 2, y > 3)))
+
+    When a condition is an ``ITE``, it will be converted to a simplified
+    Boolean expression:
+
+    >>> piecewise_fold(_)
+    Piecewise((1, ((x >= 0) | (y > 2)) & ((y > 3) | (x < 0))))
+
+    See Also
+    ========
+
+    piecewise_fold
+    piecewise_exclusive
+    ITE
+    """
+
+    nargs = None
+    is_Piecewise = True
+
+    def __new__(cls, *args, **options):
+        if len(args) == 0:
+            raise TypeError("At least one (expr, cond) pair expected.")
+        # (Try to) sympify args first
+        newargs = []
+        for ec in args:
+            # ec could be a ExprCondPair or a tuple
+            pair = ExprCondPair(*getattr(ec, 'args', ec))
+            cond = pair.cond
+            if cond is false:
+                continue
+            newargs.append(pair)
+            if cond is true:
+                break
+
+        eval = options.pop('evaluate', global_parameters.evaluate)
+        if eval:
+            r = cls.eval(*newargs)
+            if r is not None:
+                return r
+        elif len(newargs) == 1 and newargs[0].cond == True:
+            return newargs[0].expr
+
+        return Basic.__new__(cls, *newargs, **options)
+
+    @classmethod
+    def eval(cls, *_args):
+        """Either return a modified version of the args or, if no
+        modifications were made, return None.
+
+        Modifications that are made here:
+
+        1. relationals are made canonical
+        2. any False conditions are dropped
+        3. any repeat of a previous condition is ignored
+        4. any args past one with a true condition are dropped
+
+        If there are no args left, nan will be returned.
+        If there is a single arg with a True condition, its
+        corresponding expression will be returned.
+
+        EXAMPLES
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> cond = -x < -1
+        >>> args = [(1, cond), (4, cond), (3, False), (2, True), (5, x < 1)]
+        >>> Piecewise(*args, evaluate=False)
+        Piecewise((1, -x < -1), (4, -x < -1), (2, True))
+        >>> Piecewise(*args)
+        Piecewise((1, x > 1), (2, True))
+        """
+        if not _args:
+            return Undefined
+
+        if len(_args) == 1 and _args[0][-1] == True:
+            return _args[0][0]
+
+        newargs = _piecewise_collapse_arguments(_args)
+
+        # some conditions may have been redundant
+        missing = len(newargs) != len(_args)
+        # some conditions may have changed
+        same = all(a == b for a, b in zip(newargs, _args))
+        # if either change happened we return the expr with the
+        # updated args
+        if not newargs:
+            raise ValueError(filldedent('''
+                There are no conditions (or none that
+                are not trivially false) to define an
+                expression.'''))
+        if missing or not same:
+            return cls(*newargs)
+
+    def doit(self, **hints):
+        """
+        Evaluate this piecewise function.
+        """
+        newargs = []
+        for e, c in self.args:
+            if hints.get('deep', True):
+                if isinstance(e, Basic):
+                    newe = e.doit(**hints)
+                    if newe != self:
+                        e = newe
+                if isinstance(c, Basic):
+                    c = c.doit(**hints)
+            newargs.append((e, c))
+        return self.func(*newargs)
+
+    def _eval_simplify(self, **kwargs):
+        return piecewise_simplify(self, **kwargs)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        for e, c in self.args:
+            if c == True or c.subs(x, 0) == True:
+                return e.as_leading_term(x)
+
+    def _eval_adjoint(self):
+        return self.func(*[(e.adjoint(), c) for e, c in self.args])
+
+    def _eval_conjugate(self):
+        return self.func(*[(e.conjugate(), c) for e, c in self.args])
+
+    def _eval_derivative(self, x):
+        return self.func(*[(diff(e, x), c) for e, c in self.args])
+
+    def _eval_evalf(self, prec):
+        return self.func(*[(e._evalf(prec), c) for e, c in self.args])
+
+    def _eval_is_meromorphic(self, x, a):
+        # Conditions often implicitly assume that the argument is real.
+        # Hence, there needs to be some check for as_set.
+        if not a.is_real:
+            return None
+
+        # Then, scan ExprCondPairs in the given order to find a piece that would contain a,
+        # possibly as a boundary point.
+        for e, c in self.args:
+            cond = c.subs(x, a)
+
+            if cond.is_Relational:
+                return None
+            if a in c.as_set().boundary:
+                return None
+            # Apply expression if a is an interior point of the domain of e.
+            if cond:
+                return e._eval_is_meromorphic(x, a)
+
+    def piecewise_integrate(self, x, **kwargs):
+        """Return the Piecewise with each expression being
+        replaced with its antiderivative. To obtain a continuous
+        antiderivative, use the :func:`~.integrate` function or method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        Note that this does not give a continuous function, e.g.
+        at x = 1 the 3rd condition applies and the antiderivative
+        there is 2*x so the value of the antiderivative is 2:
+
+        >>> anti = _
+        >>> anti.subs(x, 1)
+        2
+
+        The continuous derivative accounts for the integral *up to*
+        the point of interest, however:
+
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> _.subs(x, 1)
+        1
+
+        See Also
+        ========
+        Piecewise._eval_integral
+        """
+        from sympy.integrals import integrate
+        return self.func(*[(integrate(e, x, **kwargs), c) for e, c in self.args])
+
+    def _handle_irel(self, x, handler):
+        """Return either None (if the conditions of self depend only on x) else
+        a Piecewise expression whose expressions (handled by the handler that
+        was passed) are paired with the governing x-independent relationals,
+        e.g. Piecewise((A, a(x) & b(y)), (B, c(x) | c(y)) ->
+        Piecewise(
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | True)), b(y) & c(y)),
+            (handler(Piecewise((A, a(x) & True), (B, c(x) | False)), b(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | True)), c(y)),
+            (handler(Piecewise((A, a(x) & False), (B, c(x) | False)), True))
+        """
+        # identify governing relationals
+        rel = self.atoms(Relational)
+        irel = list(ordered([r for r in rel if x not in r.free_symbols
+            and r not in (S.true, S.false)]))
+        if irel:
+            args = {}
+            exprinorder = []
+            for truth in product((1, 0), repeat=len(irel)):
+                reps = dict(zip(irel, truth))
+                # only store the true conditions since the false are implied
+                # when they appear lower in the Piecewise args
+                if 1 not in truth:
+                    cond = None  # flag this one so it doesn't get combined
+                else:
+                    andargs = Tuple(*[i for i in reps if reps[i]])
+                    free = list(andargs.free_symbols)
+                    if len(free) == 1:
+                        from sympy.solvers.inequalities import (
+                            reduce_inequalities, _solve_inequality)
+                        try:
+                            t = reduce_inequalities(andargs, free[0])
+                            # ValueError when there are potentially
+                            # nonvanishing imaginary parts
+                        except (ValueError, NotImplementedError):
+                            # at least isolate free symbol on left
+                            t = And(*[_solve_inequality(
+                                a, free[0], linear=True)
+                                for a in andargs])
+                    else:
+                        t = And(*andargs)
+                    if t is S.false:
+                        continue  # an impossible combination
+                    cond = t
+                expr = handler(self.xreplace(reps))
+                if isinstance(expr, self.func) and len(expr.args) == 1:
+                    expr, econd = expr.args[0]
+                    cond = And(econd, True if cond is None else cond)
+                # the ec pairs are being collected since all possibilities
+                # are being enumerated, but don't put the last one in since
+                # its expr might match a previous expression and it
+                # must appear last in the args
+                if cond is not None:
+                    args.setdefault(expr, []).append(cond)
+                    # but since we only store the true conditions we must maintain
+                    # the order so that the expression with the most true values
+                    # comes first
+                    exprinorder.append(expr)
+            # convert collected conditions as args of Or
+            for k in args:
+                args[k] = Or(*args[k])
+            # take them in the order obtained
+            args = [(e, args[e]) for e in uniq(exprinorder)]
+            # add in the last arg
+            args.append((expr, True))
+            return Piecewise(*args)
+
+    def _eval_integral(self, x, _first=True, **kwargs):
+        """Return the indefinite integral of the
+        Piecewise such that subsequent substitution of x with a
+        value will give the value of the integral (not including
+        the constant of integration) up to that point. To only
+        integrate the individual parts of Piecewise, use the
+        ``piecewise_integrate`` method.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise
+        >>> from sympy.abc import x
+        >>> p = Piecewise((0, x < 0), (1, x < 1), (2, True))
+        >>> p.integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x - 1, True))
+        >>> p.piecewise_integrate(x)
+        Piecewise((0, x < 0), (x, x < 1), (2*x, True))
+
+        See Also
+        ========
+        Piecewise.piecewise_integrate
+        """
+        from sympy.integrals.integrals import integrate
+
+        if _first:
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_integral(x, _first=False, **kwargs)
+                else:
+                    return ipw.integrate(x, **kwargs)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+        # handle a Piecewise from -oo to oo with and no x-independent relationals
+        # -----------------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            return Integral(self, x)  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        oo = S.Infinity
+        done = [(-oo, oo, -1)]
+        for k, p in enumerate(pieces):
+            if p == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # append an arg if there is a hole so a reference to
+        # argument -1 will give Undefined
+        if any(i == -1 for (a, b, i) in done):
+            abei.append((-oo, oo, Undefined, -1))
+
+        # return the sum of the intervals
+        args = []
+        sum = None
+        for a, b, i in done:
+            anti = integrate(abei[i][-2], x, **kwargs)
+            if sum is None:
+                sum = anti
+            else:
+                sum = sum.subs(x, a)
+                e = anti._eval_interval(x, a, x)
+                if sum.has(*_illegal) or e.has(*_illegal):
+                    sum = anti
+                else:
+                    sum += e
+            # see if we know whether b is contained in original
+            # condition
+            if b is S.Infinity:
+                cond = True
+            elif self.args[abei[i][-1]].cond.subs(x, b) == False:
+                cond = (x < b)
+            else:
+                cond = (x <= b)
+            args.append((sum, cond))
+        return Piecewise(*args)
+
+    def _eval_interval(self, sym, a, b, _first=True):
+        """Evaluates the function along the sym in a given interval [a, b]"""
+        # FIXME: Currently complex intervals are not supported.  A possible
+        # replacement algorithm, discussed in issue 5227, can be found in the
+        # following papers;
+        #     http://portal.acm.org/citation.cfm?id=281649
+        #     http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.70.4127&rep=rep1&type=pdf
+
+        if a is None or b is None:
+            # In this case, it is just simple substitution
+            return super()._eval_interval(sym, a, b)
+        else:
+            x, lo, hi = map(as_Basic, (sym, a, b))
+
+        if _first:  # get only x-dependent relationals
+            def handler(ipw):
+                if isinstance(ipw, self.func):
+                    return ipw._eval_interval(x, lo, hi, _first=None)
+                else:
+                    return ipw._eval_interval(x, lo, hi)
+            irv = self._handle_irel(x, handler)
+            if irv is not None:
+                return irv
+
+            if (lo < hi) is S.false or (
+                    lo is S.Infinity or hi is S.NegativeInfinity):
+                rv = self._eval_interval(x, hi, lo, _first=False)
+                if isinstance(rv, Piecewise):
+                    rv = Piecewise(*[(-e, c) for e, c in rv.args])
+                else:
+                    rv = -rv
+                return rv
+
+            if (lo < hi) is S.true or (
+                    hi is S.Infinity or lo is S.NegativeInfinity):
+                pass
+            else:
+                _a = Dummy('lo')
+                _b = Dummy('hi')
+                a = lo if lo.is_comparable else _a
+                b = hi if hi.is_comparable else _b
+                pos = self._eval_interval(x, a, b, _first=False)
+                if a == _a and b == _b:
+                    # it's purely symbolic so just swap lo and hi and
+                    # change the sign to get the value for when lo > hi
+                    neg, pos = (-pos.xreplace({_a: hi, _b: lo}),
+                        pos.xreplace({_a: lo, _b: hi}))
+                else:
+                    # at least one of the bounds was comparable, so allow
+                    # _eval_interval to use that information when computing
+                    # the interval with lo and hi reversed
+                    neg, pos = (-self._eval_interval(x, hi, lo, _first=False),
+                        pos.xreplace({_a: lo, _b: hi}))
+
+                # allow simplification based on ordering of lo and hi
+                p = Dummy('', positive=True)
+                if lo.is_Symbol:
+                    pos = pos.xreplace({lo: hi - p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({lo: hi + p}).xreplace({p: lo - hi})
+                elif hi.is_Symbol:
+                    pos = pos.xreplace({hi: lo + p}).xreplace({p: hi - lo})
+                    neg = neg.xreplace({hi: lo - p}).xreplace({p: lo - hi})
+                # evaluate limits that may have unevaluate Min/Max
+                touch = lambda _: _.replace(
+                    lambda x: isinstance(x, (Min, Max)),
+                    lambda x: x.func(*x.args))
+                neg = touch(neg)
+                pos = touch(pos)
+                # assemble return expression; make the first condition be Lt
+                # b/c then the first expression will look the same whether
+                # the lo or hi limit is symbolic
+                if a == _a:  # the lower limit was symbolic
+                    rv = Piecewise(
+                        (pos,
+                            lo < hi),
+                        (neg,
+                            True))
+                else:
+                    rv = Piecewise(
+                        (neg,
+                            hi < lo),
+                        (pos,
+                            True))
+
+                if rv == Undefined:
+                    raise ValueError("Can't integrate across undefined region.")
+                if any(isinstance(i, Piecewise) for i in (pos, neg)):
+                    rv = piecewise_fold(rv)
+                return rv
+
+        # handle a Piecewise with lo <= hi and no x-independent relationals
+        # -----------------------------------------------------------------
+        ok, abei = self._intervals(x)
+        if not ok:
+            from sympy.integrals.integrals import Integral
+            # not being able to do the interval of f(x) can
+            # be stated as not being able to do the integral
+            # of f'(x) over the same range
+            return Integral(self.diff(x), (x, lo, hi))  # unevaluated
+
+        pieces = [(a, b) for a, b, _, _ in abei]
+        done = [(lo, hi, -1)]
+        oo = S.Infinity
+        for k, p in enumerate(pieces):
+            if p[:2] == (-oo, oo):
+                # all undone intervals will get this key
+                for j, (a, b, i) in enumerate(done):
+                    if i == -1:
+                        done[j] = a, b, k
+                break  # nothing else to consider
+            N = len(done) - 1
+            for j, (a, b, i) in enumerate(reversed(done)):
+                if i == -1:
+                    j = N - j
+                    done[j: j + 1] = _clip(p, (a, b), k)
+        done = [(a, b, i) for a, b, i in done if a != b]
+
+        # return the sum of the intervals
+        sum = S.Zero
+        upto = None
+        for a, b, i in done:
+            if i == -1:
+                if upto is None:
+                    return Undefined
+                # TODO simplify hi <= upto
+                return Piecewise((sum, hi <= upto), (Undefined, True))
+            sum += abei[i][-2]._eval_interval(x, a, b)
+            upto = b
+        return sum
+
+    def _intervals(self, sym, err_on_Eq=False):
+        r"""Return a bool and a message (when bool is False), else a
+        list of unique tuples, (a, b, e, i), where a and b
+        are the lower and upper bounds in which the expression e of
+        argument i in self is defined and $a < b$ (when involving
+        numbers) or $a \le b$ when involving symbols.
+
+        If there are any relationals not involving sym, or any
+        relational cannot be solved for sym, the bool will be False
+        a message be given as the second return value. The calling
+        routine should have removed such relationals before calling
+        this routine.
+
+        The evaluated conditions will be returned as ranges.
+        Discontinuous ranges will be returned separately with
+        identical expressions. The first condition that evaluates to
+        True will be returned as the last tuple with a, b = -oo, oo.
+        """
+        from sympy.solvers.inequalities import _solve_inequality
+
+        assert isinstance(self, Piecewise)
+
+        def nonsymfail(cond):
+            return False, filldedent('''
+                A condition not involving
+                %s appeared: %s''' % (sym, cond))
+
+        def _solve_relational(r):
+            if sym not in r.free_symbols:
+                return nonsymfail(r)
+            try:
+                rv = _solve_inequality(r, sym)
+            except NotImplementedError:
+                return False, 'Unable to solve relational %s for %s.' % (r, sym)
+            if isinstance(rv, Relational):
+                free = rv.args[1].free_symbols
+                if rv.args[0] != sym or sym in free:
+                    return False, 'Unable to solve relational %s for %s.' % (r, sym)
+                if rv.rel_op == '==':
+                    # this equality has been affirmed to have the form
+                    # Eq(sym, rhs) where rhs is sym-free; it represents
+                    # a zero-width interval which will be ignored
+                    # whether it is an isolated condition or contained
+                    # within an And or an Or
+                    rv = S.false
+                elif rv.rel_op == '!=':
+                    try:
+                        rv = Or(sym < rv.rhs, sym > rv.rhs)
+                    except TypeError:
+                        # e.g. x != I ==> all real x satisfy
+                        rv = S.true
+            elif rv == (S.NegativeInfinity < sym) & (sym < S.Infinity):
+                rv = S.true
+            return True, rv
+
+        args = list(self.args)
+        # make self canonical wrt Relationals
+        keys = self.atoms(Relational)
+        reps = {}
+        for r in keys:
+            ok, s = _solve_relational(r)
+            if ok != True:
+                return False, ok
+            reps[r] = s
+        # process args individually so if any evaluate, their position
+        # in the original Piecewise will be known
+        args = [i.xreplace(reps) for i in self.args]
+
+        # precondition args
+        expr_cond = []
+        default = idefault = None
+        for i, (expr, cond) in enumerate(args):
+            if cond is S.false:
+                continue
+            if cond is S.true:
+                default = expr
+                idefault = i
+                break
+            if isinstance(cond, Eq):
+                # unanticipated condition, but it is here in case a
+                # replacement caused an Eq to appear
+                if err_on_Eq:
+                    return False, 'encountered Eq condition: %s' % cond
+                continue  # zero width interval
+
+            cond = to_cnf(cond)
+            if isinstance(cond, And):
+                cond = distribute_or_over_and(cond)
+
+            if isinstance(cond, Or):
+                expr_cond.extend(
+                    [(i, expr, o) for o in cond.args
+                    if not isinstance(o, Eq)])
+            elif cond is not S.false:
+                expr_cond.append((i, expr, cond))
+            elif cond is S.true:
+                default = expr
+                idefault = i
+                break
+
+        # determine intervals represented by conditions
+        int_expr = []
+        for iarg, expr, cond in expr_cond:
+            if isinstance(cond, And):
+                lower = S.NegativeInfinity
+                upper = S.Infinity
+                exclude = []
+                for cond2 in cond.args:
+                    if not isinstance(cond2, Relational):
+                        return False, 'expecting only Relationals'
+                    if isinstance(cond2, Eq):
+                        lower = upper  # ignore
+                        if err_on_Eq:
+                            return False, 'encountered secondary Eq condition'
+                        break
+                    elif isinstance(cond2, Ne):
+                        l, r = cond2.args
+                        if l == sym:
+                            exclude.append(r)
+                        elif r == sym:
+                            exclude.append(l)
+                        else:
+                            return nonsymfail(cond2)
+                        continue
+                    elif cond2.lts == sym:
+                        upper = Min(cond2.gts, upper)
+                    elif cond2.gts == sym:
+                        lower = Max(cond2.lts, lower)
+                    else:
+                        return nonsymfail(cond2)  # should never get here
+                if exclude:
+                    exclude = list(ordered(exclude))
+                    newcond = []
+                    for i, e in enumerate(exclude):
+                        if e < lower == True or e > upper == True:
+                            continue
+                        if not newcond:
+                            newcond.append((None, lower))  # add a primer
+                        newcond.append((newcond[-1][1], e))
+                    newcond.append((newcond[-1][1], upper))
+                    newcond.pop(0)  # remove the primer
+                    expr_cond.extend([(iarg, expr, And(i[0] < sym, sym < i[1])) for i in newcond])
+                    continue
+            elif isinstance(cond, Relational) and cond.rel_op != '!=':
+                lower, upper = cond.lts, cond.gts  # part 1: initialize with givens
+                if cond.lts == sym:                # part 1a: expand the side ...
+                    lower = S.NegativeInfinity   # e.g. x <= 0 ---> -oo <= 0
+                elif cond.gts == sym:            # part 1a: ... that can be expanded
+                    upper = S.Infinity           # e.g. x >= 0 --->  oo >= 0
+                else:
+                    return nonsymfail(cond)
+            else:
+                return False, 'unrecognized condition: %s' % cond
+
+            upper = Max(lower, upper)
+            if err_on_Eq and lower == upper:
+                return False, 'encountered Eq condition'
+            if (lower >= upper) is not S.true:
+                int_expr.append((lower, upper, expr, iarg))
+
+        if default is not None:
+            int_expr.append(
+                (S.NegativeInfinity, S.Infinity, default, idefault))
+
+        return True, list(uniq(int_expr))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        args = [(ec.expr._eval_nseries(x, n, logx), ec.cond) for ec in self.args]
+        return self.func(*args)
+
+    def _eval_power(self, s):
+        return self.func(*[(e**s, c) for e, c in self.args])
+
+    def _eval_subs(self, old, new):
+        # this is strictly not necessary, but we can keep track
+        # of whether True or False conditions arise and be
+        # somewhat more efficient by avoiding other substitutions
+        # and avoiding invalid conditions that appear after a
+        # True condition
+        args = list(self.args)
+        args_exist = False
+        for i, (e, c) in enumerate(args):
+            c = c._subs(old, new)
+            if c != False:
+                args_exist = True
+                e = e._subs(old, new)
+            args[i] = (e, c)
+            if c == True:
+                break
+        if not args_exist:
+            args = ((Undefined, True),)
+        return self.func(*args)
+
+    def _eval_transpose(self):
+        return self.func(*[(e.transpose(), c) for e, c in self.args])
+
+    def _eval_template_is_attr(self, is_attr):
+        b = None
+        for expr, _ in self.args:
+            a = getattr(expr, is_attr)
+            if a is None:
+                return
+            if b is None:
+                b = a
+            elif b is not a:
+                return
+        return b
+
+    _eval_is_finite = lambda self: self._eval_template_is_attr(
+        'is_finite')
+    _eval_is_complex = lambda self: self._eval_template_is_attr('is_complex')
+    _eval_is_even = lambda self: self._eval_template_is_attr('is_even')
+    _eval_is_imaginary = lambda self: self._eval_template_is_attr(
+        'is_imaginary')
+    _eval_is_integer = lambda self: self._eval_template_is_attr('is_integer')
+    _eval_is_irrational = lambda self: self._eval_template_is_attr(
+        'is_irrational')
+    _eval_is_negative = lambda self: self._eval_template_is_attr('is_negative')
+    _eval_is_nonnegative = lambda self: self._eval_template_is_attr(
+        'is_nonnegative')
+    _eval_is_nonpositive = lambda self: self._eval_template_is_attr(
+        'is_nonpositive')
+    _eval_is_nonzero = lambda self: self._eval_template_is_attr(
+        'is_nonzero')
+    _eval_is_odd = lambda self: self._eval_template_is_attr('is_odd')
+    _eval_is_polar = lambda self: self._eval_template_is_attr('is_polar')
+    _eval_is_positive = lambda self: self._eval_template_is_attr('is_positive')
+    _eval_is_extended_real = lambda self: self._eval_template_is_attr(
+            'is_extended_real')
+    _eval_is_extended_positive = lambda self: self._eval_template_is_attr(
+            'is_extended_positive')
+    _eval_is_extended_negative = lambda self: self._eval_template_is_attr(
+            'is_extended_negative')
+    _eval_is_extended_nonzero = lambda self: self._eval_template_is_attr(
+            'is_extended_nonzero')
+    _eval_is_extended_nonpositive = lambda self: self._eval_template_is_attr(
+            'is_extended_nonpositive')
+    _eval_is_extended_nonnegative = lambda self: self._eval_template_is_attr(
+            'is_extended_nonnegative')
+    _eval_is_real = lambda self: self._eval_template_is_attr('is_real')
+    _eval_is_zero = lambda self: self._eval_template_is_attr(
+        'is_zero')
+
+    @classmethod
+    def __eval_cond(cls, cond):
+        """Return the truth value of the condition."""
+        if cond == True:
+            return True
+        if isinstance(cond, Eq):
+            try:
+                diff = cond.lhs - cond.rhs
+                if diff.is_commutative:
+                    return diff.is_zero
+            except TypeError:
+                pass
+
+    def as_expr_set_pairs(self, domain=None):
+        """Return tuples for each argument of self that give
+        the expression and the interval in which it is valid
+        which is contained within the given domain.
+        If a condition cannot be converted to a set, an error
+        will be raised. The variable of the conditions is
+        assumed to be real; sets of real values are returned.
+
+        Examples
+        ========
+
+        >>> from sympy import Piecewise, Interval
+        >>> from sympy.abc import x
+        >>> p = Piecewise(
+        ...     (1, x < 2),
+        ...     (2,(x > 0) & (x < 4)),
+        ...     (3, True))
+        >>> p.as_expr_set_pairs()
+        [(1, Interval.open(-oo, 2)),
+         (2, Interval.Ropen(2, 4)),
+         (3, Interval(4, oo))]
+        >>> p.as_expr_set_pairs(Interval(0, 3))
+        [(1, Interval.Ropen(0, 2)),
+         (2, Interval(2, 3))]
+        """
+        if domain is None:
+            domain = S.Reals
+        exp_sets = []
+        U = domain
+        complex = not domain.is_subset(S.Reals)
+        cond_free = set()
+        for expr, cond in self.args:
+            cond_free |= cond.free_symbols
+            if len(cond_free) > 1:
+                raise NotImplementedError(filldedent('''
+                    multivariate conditions are not handled.'''))
+            if complex:
+                for i in cond.atoms(Relational):
+                    if not isinstance(i, (Eq, Ne)):
+                        raise ValueError(filldedent('''
+                            Inequalities in the complex domain are
+                            not supported. Try the real domain by
+                            setting domain=S.Reals'''))
+            cond_int = U.intersect(cond.as_set())
+            U = U - cond_int
+            if cond_int != S.EmptySet:
+                exp_sets.append((expr, cond_int))
+        return exp_sets
+
+    def _eval_rewrite_as_ITE(self, *args, **kwargs):
+        byfree = {}
+        args = list(args)
+        default = any(c == True for b, c in args)
+        for i, (b, c) in enumerate(args):
+            if not isinstance(b, Boolean) and b != True:
+                raise TypeError(filldedent('''
+                    Expecting Boolean or bool but got `%s`
+                    ''' % func_name(b)))
+            if c == True:
+                break
+            # loop over independent conditions for this b
+            for c in c.args if isinstance(c, Or) else [c]:
+                free = c.free_symbols
+                x = free.pop()
+                try:
+                    byfree[x] = byfree.setdefault(
+                        x, S.EmptySet).union(c.as_set())
+                except NotImplementedError:
+                    if not default:
+                        raise NotImplementedError(filldedent('''
+                            A method to determine whether a multivariate
+                            conditional is consistent with a complete coverage
+                            of all variables has not been implemented so the
+                            rewrite is being stopped after encountering `%s`.
+                            This error would not occur if a default expression
+                            like `(foo, True)` were given.
+                            ''' % c))
+                if byfree[x] in (S.UniversalSet, S.Reals):
+                    # collapse the ith condition to True and break
+                    args[i] = list(args[i])
+                    c = args[i][1] = True
+                    break
+            if c == True:
+                break
+        if c != True:
+            raise ValueError(filldedent('''
+                Conditions must cover all reals or a final default
+                condition `(foo, True)` must be given.
+                '''))
+        last, _ = args[i]  # ignore all past ith arg
+        for a, c in reversed(args[:i]):
+            last = ITE(c, a, last)
+        return _canonical(last)
+
+    def _eval_rewrite_as_KroneckerDelta(self, *args, **kwargs):
+        from sympy.functions.special.tensor_functions import KroneckerDelta
+
+        rules = {
+            And: [False, False],
+            Or: [True, True],
+            Not: [True, False],
+            Eq: [None, None],
+            Ne: [None, None]
+        }
+
+        class UnrecognizedCondition(Exception):
+            pass
+
+        def rewrite(cond):
+            if isinstance(cond, Eq):
+                return KroneckerDelta(*cond.args)
+            if isinstance(cond, Ne):
+                return 1 - KroneckerDelta(*cond.args)
+
+            cls, args = type(cond), cond.args
+            if cls not in rules:
+                raise UnrecognizedCondition(cls)
+
+            b1, b2 = rules[cls]
+            k = Mul(*[1 - rewrite(c) for c in args]) if b1 else Mul(*[rewrite(c) for c in args])
+
+            if b2:
+                return 1 - k
+            return k
+
+        conditions = []
+        true_value = None
+        for value, cond in args:
+            if type(cond) in rules:
+                conditions.append((value, cond))
+            elif cond is S.true:
+                if true_value is None:
+                    true_value = value
+            else:
+                return
+
+        if true_value is not None:
+            result = true_value
+
+            for value, cond in conditions[::-1]:
+                try:
+                    k = rewrite(cond)
+                    result = k * value + (1 - k) * result
+                except UnrecognizedCondition:
+                    return
+
+            return result
+
+
+def piecewise_fold(expr, evaluate=True):
+    """
+    Takes an expression containing a piecewise function and returns the
+    expression in piecewise form. In addition, any ITE conditions are
+    rewritten in negation normal form and simplified.
+
+    The final Piecewise is evaluated (default) but if the raw form
+    is desired, send ``evaluate=False``; if trivial evaluation is
+    desired, send ``evaluate=None`` and duplicate conditions and
+    processing of True and False will be handled.
+
+    Examples
+    ========
+
+    >>> from sympy import Piecewise, piecewise_fold, S
+    >>> from sympy.abc import x
+    >>> p = Piecewise((x, x < 1), (1, S(1) <= x))
+    >>> piecewise_fold(x*p)
+    Piecewise((x**2, x < 1), (x, True))
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_exclusive
+    """
+    if not isinstance(expr, Basic) or not expr.has(Piecewise):
+        return expr
+
+    new_args = []
+    if isinstance(expr, (ExprCondPair, Piecewise)):
+        for e, c in expr.args:
+            if not isinstance(e, Piecewise):
+                e = piecewise_fold(e)
+            # we don't keep Piecewise in condition because
+            # it has to be checked to see that it's complete
+            # and we convert it to ITE at that time
+            assert not c.has(Piecewise)  # pragma: no cover
+            if isinstance(c, ITE):
+                c = c.to_nnf()
+                c = simplify_logic(c, form='cnf')
+            if isinstance(e, Piecewise):
+                new_args.extend([(piecewise_fold(ei), And(ci, c))
+                    for ei, ci in e.args])
+            else:
+                new_args.append((e, c))
+    else:
+        # Given
+        #     P1 = Piecewise((e11, c1), (e12, c2), A)
+        #     P2 = Piecewise((e21, c1), (e22, c2), B)
+        #     ...
+        # the folding of f(P1, P2) is trivially
+        # Piecewise(
+        #   (f(e11, e21), c1),
+        #   (f(e12, e22), c2),
+        #   (f(Piecewise(A), Piecewise(B)), True))
+        # Certain objects end up rewriting themselves as thus, so
+        # we do that grouping before the more generic folding.
+        # The following applies this idea when f = Add or f = Mul
+        # (and the expression is commutative).
+        if expr.is_Add or expr.is_Mul and expr.is_commutative:
+            p, args = sift(expr.args, lambda x: x.is_Piecewise, binary=True)
+            pc = sift(p, lambda x: tuple([c for e,c in x.args]))
+            for c in list(ordered(pc)):
+                if len(pc[c]) > 1:
+                    pargs = [list(i.args) for i in pc[c]]
+                    # the first one is the same; there may be more
+                    com = common_prefix(*[
+                        [i.cond for i in j] for j in pargs])
+                    n = len(com)
+                    collected = []
+                    for i in range(n):
+                        collected.append((
+                            expr.func(*[ai[i].expr for ai in pargs]),
+                            com[i]))
+                    remains = []
+                    for a in pargs:
+                        if n == len(a):  # no more args
+                            continue
+                        if a[n].cond == True:  # no longer Piecewise
+                            remains.append(a[n].expr)
+                        else:  # restore the remaining Piecewise
+                            remains.append(
+                                Piecewise(*a[n:], evaluate=False))
+                    if remains:
+                        collected.append((expr.func(*remains), True))
+                    args.append(Piecewise(*collected, evaluate=False))
+                    continue
+                args.extend(pc[c])
+        else:
+            args = expr.args
+        # fold
+        folded = list(map(piecewise_fold, args))
+        for ec in product(*[
+                (i.args if isinstance(i, Piecewise) else
+                 [(i, true)]) for i in folded]):
+            e, c = zip(*ec)
+            new_args.append((expr.func(*e), And(*c)))
+
+    if evaluate is None:
+        # don't return duplicate conditions, otherwise don't evaluate
+        new_args = list(reversed([(e, c) for c, e in {
+            c: e for e, c in reversed(new_args)}.items()]))
+    rv = Piecewise(*new_args, evaluate=evaluate)
+    if evaluate is None and len(rv.args) == 1 and rv.args[0].cond == True:
+        return rv.args[0].expr
+    if any(s.expr.has(Piecewise) for p in rv.atoms(Piecewise) for s in p.args):
+        return piecewise_fold(rv)
+    return rv
+
+
+def _clip(A, B, k):
+    """Return interval B as intervals that are covered by A (keyed
+    to k) and all other intervals of B not covered by A keyed to -1.
+
+    The reference point of each interval is the rhs; if the lhs is
+    greater than the rhs then an interval of zero width interval will
+    result, e.g. (4, 1) is treated like (1, 1).
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.piecewise import _clip
+    >>> from sympy import Tuple
+    >>> A = Tuple(1, 3)
+    >>> B = Tuple(2, 4)
+    >>> _clip(A, B, 0)
+    [(2, 3, 0), (3, 4, -1)]
+
+    Interpretation: interval portion (2, 3) of interval (2, 4) is
+    covered by interval (1, 3) and is keyed to 0 as requested;
+    interval (3, 4) was not covered by (1, 3) and is keyed to -1.
+    """
+    a, b = B
+    c, d = A
+    c, d = Min(Max(c, a), b), Min(Max(d, a), b)
+    a = Min(a, b)
+    p = []
+    if a != c:
+        p.append((a, c, -1))
+    else:
+        pass
+    if c != d:
+        p.append((c, d, k))
+    else:
+        pass
+    if b != d:
+        if d == c and p and p[-1][-1] == -1:
+            p[-1] = p[-1][0], b, -1
+        else:
+            p.append((d, b, -1))
+    else:
+        pass
+
+    return p
+
+
+def piecewise_simplify_arguments(expr, **kwargs):
+    from sympy.simplify.simplify import simplify
+
+    # simplify conditions
+    f1 = expr.args[0].cond.free_symbols
+    args = None
+    if len(f1) == 1 and not expr.atoms(Eq):
+        x = f1.pop()
+        # this won't return intervals involving Eq
+        # and it won't handle symbols treated as
+        # booleans
+        ok, abe_ = expr._intervals(x, err_on_Eq=True)
+        def include(c, x, a):
+            "return True if c.subs(x, a) is True, else False"
+            try:
+                return c.subs(x, a) == True
+            except TypeError:
+                return False
+        if ok:
+            args = []
+            covered = S.EmptySet
+            from sympy.sets.sets import Interval
+            for a, b, e, i in abe_:
+                c = expr.args[i].cond
+                incl_a = include(c, x, a)
+                incl_b = include(c, x, b)
+                iv = Interval(a, b, not incl_a, not incl_b)
+                cset = iv - covered
+                if not cset:
+                    continue
+                try:
+                    a = cset.inf
+                except NotImplementedError:
+                    pass # continue with the given `a`
+                else:
+                    incl_a = include(c, x, a)
+                if incl_a and incl_b:
+                    if a.is_infinite and b.is_infinite:
+                        c = S.true
+                    elif b.is_infinite:
+                        c = (x > a) if a in covered else (x >= a)
+                    elif a.is_infinite:
+                        c = (x <= b)
+                    elif a in covered:
+                        c = And(a < x, x <= b)
+                    else:
+                        c = And(a <= x, x <= b)
+                elif incl_a:
+                    if a.is_infinite:
+                        c = (x < b)
+                    elif a in covered:
+                        c = And(a < x, x < b)
+                    else:
+                        c = And(a <= x, x < b)
+                elif incl_b:
+                    if b.is_infinite:
+                        c = (x > a)
+                    else:
+                        c = And(a < x, x <= b)
+                else:
+                    if a in covered:
+                        c = (x < b)
+                    else:
+                        c = And(a < x, x < b)
+                covered |= iv
+                if a is S.NegativeInfinity and incl_a:
+                    covered |= {S.NegativeInfinity}
+                if b is S.Infinity and incl_b:
+                    covered |= {S.Infinity}
+                args.append((e, c))
+            if not S.Reals.is_subset(covered):
+                args.append((Undefined, True))
+    if args is None:
+        args = list(expr.args)
+        for i in range(len(args)):
+            e, c  = args[i]
+            if isinstance(c, Basic):
+                c = simplify(c, **kwargs)
+            args[i] = (e, c)
+
+    # simplify expressions
+    doit = kwargs.pop('doit', None)
+    for i in range(len(args)):
+        e, c  = args[i]
+        if isinstance(e, Basic):
+            # Skip doit to avoid growth at every call for some integrals
+            # and sums, see sympy/sympy#17165
+            newe = simplify(e, doit=False, **kwargs)
+            if newe != e:
+                e = newe
+        args[i] = (e, c)
+
+    # restore kwargs flag
+    if doit is not None:
+        kwargs['doit'] = doit
+
+    return Piecewise(*args)
+
+
+def _piecewise_collapse_arguments(_args):
+    newargs = []  # the unevaluated conditions
+    current_cond = set()  # the conditions up to a given e, c pair
+    for expr, cond in _args:
+        cond = cond.replace(
+            lambda _: _.is_Relational, _canonical_coeff)
+        # Check here if expr is a Piecewise and collapse if one of
+        # the conds in expr matches cond. This allows the collapsing
+        # of Piecewise((Piecewise((x,x<0)),x<0)) to Piecewise((x,x<0)).
+        # This is important when using piecewise_fold to simplify
+        # multiple Piecewise instances having the same conds.
+        # Eventually, this code should be able to collapse Piecewise's
+        # having different intervals, but this will probably require
+        # using the new assumptions.
+        if isinstance(expr, Piecewise):
+            unmatching = []
+            for i, (e, c) in enumerate(expr.args):
+                if c in current_cond:
+                    # this would already have triggered
+                    continue
+                if c == cond:
+                    if c != True:
+                        # nothing past this condition will ever
+                        # trigger and only those args before this
+                        # that didn't match a previous condition
+                        # could possibly trigger
+                        if unmatching:
+                            expr = Piecewise(*(
+                                unmatching + [(e, c)]))
+                        else:
+                            expr = e
+                    break
+                else:
+                    unmatching.append((e, c))
+
+        # check for condition repeats
+        got = False
+        # -- if an And contains a condition that was
+        #    already encountered, then the And will be
+        #    False: if the previous condition was False
+        #    then the And will be False and if the previous
+        #    condition is True then then we wouldn't get to
+        #    this point. In either case, we can skip this condition.
+        for i in ([cond] +
+                  (list(cond.args) if isinstance(cond, And) else
+                  [])):
+            if i in current_cond:
+                got = True
+                break
+        if got:
+            continue
+
+        # -- if not(c) is already in current_cond then c is
+        #    a redundant condition in an And. This does not
+        #    apply to Or, however: (e1, c), (e2, Or(~c, d))
+        #    is not (e1, c), (e2, d) because if c and d are
+        #    both False this would give no results when the
+        #    true answer should be (e2, True)
+        if isinstance(cond, And):
+            nonredundant = []
+            for c in cond.args:
+                if isinstance(c, Relational):
+                    if c.negated.canonical in current_cond:
+                        continue
+                    # if a strict inequality appears after
+                    # a non-strict one, then the condition is
+                    # redundant
+                    if isinstance(c, (Lt, Gt)) and (
+                        c.weak in current_cond):
+                        cond = False
+                        break
+                nonredundant.append(c)
+            else:
+                cond = cond.func(*nonredundant)
+        elif isinstance(cond, Relational):
+            if cond.negated.canonical in current_cond:
+                cond = S.true
+
+        current_cond.add(cond)
+
+        # collect successive e,c pairs when exprs or cond match
+        if newargs:
+            if newargs[-1].expr == expr:
+                orcond = Or(cond, newargs[-1].cond)
+                if isinstance(orcond, (And, Or)):
+                    orcond = distribute_and_over_or(orcond)
+                newargs[-1] = ExprCondPair(expr, orcond)
+                continue
+            elif newargs[-1].cond == cond:
+                continue
+        newargs.append(ExprCondPair(expr, cond))
+    return newargs
+
+
+_blessed = lambda e: getattr(e.lhs, '_diff_wrt', False) and (
+    getattr(e.rhs, '_diff_wrt', None) or
+    isinstance(e.rhs, (Rational, NumberSymbol)))
+
+
+def piecewise_simplify(expr, **kwargs):
+    expr = piecewise_simplify_arguments(expr, **kwargs)
+    if not isinstance(expr, Piecewise):
+        return expr
+    args = list(expr.args)
+
+    args = _piecewise_simplify_eq_and(args)
+    args = _piecewise_simplify_equal_to_next_segment(args)
+    return Piecewise(*args)
+
+
+def _piecewise_simplify_equal_to_next_segment(args):
+    """
+    See if expressions valid for an Equal expression happens to evaluate
+    to the same function as in the next piecewise segment, see:
+    https://github.com/sympy/sympy/issues/8458
+    """
+    prevexpr = None
+    for i, (expr, cond) in reversed(list(enumerate(args))):
+        if prevexpr is not None:
+            if isinstance(cond, And):
+                eqs, other = sift(cond.args,
+                                  lambda i: isinstance(i, Eq), binary=True)
+            elif isinstance(cond, Eq):
+                eqs, other = [cond], []
+            else:
+                eqs = other = []
+            _prevexpr = prevexpr
+            _expr = expr
+            if eqs and not other:
+                eqs = list(ordered(eqs))
+                for e in eqs:
+                    # allow 2 args to collapse into 1 for any e
+                    # otherwise limit simplification to only simple-arg
+                    # Eq instances
+                    if len(args) == 2 or _blessed(e):
+                        _prevexpr = _prevexpr.subs(*e.args)
+                        _expr = _expr.subs(*e.args)
+            # Did it evaluate to the same?
+            if _prevexpr == _expr:
+                # Set the expression for the Not equal section to the same
+                # as the next. These will be merged when creating the new
+                # Piecewise
+                args[i] = args[i].func(args[i + 1][0], cond)
+            else:
+                # Update the expression that we compare against
+                prevexpr = expr
+        else:
+            prevexpr = expr
+    return args
+
+
+def _piecewise_simplify_eq_and(args):
+    """
+    Try to simplify conditions and the expression for
+    equalities that are part of the condition, e.g.
+    Piecewise((n, And(Eq(n,0), Eq(n + m, 0))), (1, True))
+    -> Piecewise((0, And(Eq(n, 0), Eq(m, 0))), (1, True))
+    """
+    for i, (expr, cond) in enumerate(args):
+        if isinstance(cond, And):
+            eqs, other = sift(cond.args,
+                              lambda i: isinstance(i, Eq), binary=True)
+        elif isinstance(cond, Eq):
+            eqs, other = [cond], []
+        else:
+            eqs = other = []
+        if eqs:
+            eqs = list(ordered(eqs))
+            for j, e in enumerate(eqs):
+                # these blessed lhs objects behave like Symbols
+                # and the rhs are simple replacements for the "symbols"
+                if _blessed(e):
+                    expr = expr.subs(*e.args)
+                    eqs[j + 1:] = [ei.subs(*e.args) for ei in eqs[j + 1:]]
+                    other = [ei.subs(*e.args) for ei in other]
+            cond = And(*(eqs + other))
+            args[i] = args[i].func(expr, cond)
+    return args
+
+
+def piecewise_exclusive(expr, *, skip_nan=False, deep=True):
+    """
+    Rewrite :class:`Piecewise` with mutually exclusive conditions.
+
+    Explanation
+    ===========
+
+    SymPy represents the conditions of a :class:`Piecewise` in an
+    "if-elif"-fashion, allowing more than one condition to be simultaneously
+    True. The interpretation is that the first condition that is True is the
+    case that holds. While this is a useful representation computationally it
+    is not how a piecewise formula is typically shown in a mathematical text.
+    The :func:`piecewise_exclusive` function can be used to rewrite any
+    :class:`Piecewise` with more typical mutually exclusive conditions.
+
+    Note that further manipulation of the resulting :class:`Piecewise`, e.g.
+    simplifying it, will most likely make it non-exclusive. Hence, this is
+    primarily a function to be used in conjunction with printing the Piecewise
+    or if one would like to reorder the expression-condition pairs.
+
+    If it is not possible to determine that all possibilities are covered by
+    the different cases of the :class:`Piecewise` then a final
+    :class:`~sympy.core.numbers.NaN` case will be included explicitly. This
+    can be prevented by passing ``skip_nan=True``.
+
+    Examples
+    ========
+
+    >>> from sympy import piecewise_exclusive, Symbol, Piecewise, S
+    >>> x = Symbol('x', real=True)
+    >>> p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
+    >>> piecewise_exclusive(p)
+    Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, x > 0))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)))
+    Piecewise((2, x > 1), (nan, x <= 1))
+    >>> piecewise_exclusive(Piecewise((2, x > 1)), skip_nan=True)
+    Piecewise((2, x > 1))
+
+    Parameters
+    ==========
+
+    expr: a SymPy expression.
+        Any :class:`Piecewise` in the expression will be rewritten.
+    skip_nan: ``bool`` (default ``False``)
+        If ``skip_nan`` is set to ``True`` then a final
+        :class:`~sympy.core.numbers.NaN` case will not be included.
+    deep:  ``bool`` (default ``True``)
+        If ``deep`` is ``True`` then :func:`piecewise_exclusive` will rewrite
+        any :class:`Piecewise` subexpressions in ``expr`` rather than just
+        rewriting ``expr`` itself.
+
+    Returns
+    =======
+
+    An expression equivalent to ``expr`` but where all :class:`Piecewise` have
+    been rewritten with mutually exclusive conditions.
+
+    See Also
+    ========
+
+    Piecewise
+    piecewise_fold
+    """
+
+    def make_exclusive(*pwargs):
+
+        cumcond = false
+        newargs = []
+
+        # Handle the first n-1 cases
+        for expr_i, cond_i in pwargs[:-1]:
+            cancond = And(cond_i, Not(cumcond)).simplify()
+            cumcond = Or(cond_i, cumcond).simplify()
+            newargs.append((expr_i, cancond))
+
+        # For the nth case defer simplification of cumcond
+        expr_n, cond_n = pwargs[-1]
+        cancond_n = And(cond_n, Not(cumcond)).simplify()
+        newargs.append((expr_n, cancond_n))
+
+        if not skip_nan:
+            cumcond = Or(cond_n, cumcond).simplify()
+            if cumcond is not true:
+                newargs.append((Undefined, Not(cumcond).simplify()))
+
+        return Piecewise(*newargs, evaluate=False)
+
+    if deep:
+        return expr.replace(Piecewise, make_exclusive)
+    elif isinstance(expr, Piecewise):
+        return make_exclusive(*expr.args)
+    else:
+        return expr
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d383f401debc283c0aa033223ec67201b945a826
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_complexes.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_complexes.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45c819d4457dcebf314e9dd850ce87048dfe083c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_complexes.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_exponential.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_exponential.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8086299662121e8aef31cb14451e3c799cd22c8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_exponential.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5a0c6c594b3ac01039270ec58cb4594627ae7911
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_hyperbolic.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df5d5a9737444fc1ac2f5ead1861010e940321364857579e738d1c82d055afa5
+size 156856
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_integers.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_integers.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fe768a93d80b9ea42631ad047f88f800ba09a34
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_integers.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_interface.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_interface.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4ba5c833f9f2e4312e467373e9f758ba00f8c994
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_interface.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_miscellaneous.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_miscellaneous.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..906d93d692afe3125851a6e2f74bf39c0f2827f0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_miscellaneous.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29c480f0c5517e6586ffdc93df9dc9bf75df585a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_piecewise.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86e032bba36869650c09b557772b7e8a409e8d05c80260ed2cb811cf9599ff7e
+size 131872
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae326b5e16a6e0d95cb7e119e9391aa74402d84a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/__pycache__/test_trigonometric.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:488acd0f7426cd1516e4453c85bbd97d37651005e22eaaae544f84d34634e03d
+size 261070
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_complexes.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_complexes.py
new file mode 100644
index 0000000000000000000000000000000000000000..699c0fef966c99147b713aaa80710b7b8cf21c73
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_complexes.py
@@ -0,0 +1,1030 @@
+from sympy.core.function import (Derivative, Function, Lambda, expand, PoleError)
+from sympy.core.numbers import (E, I, Rational, comp, nan, oo, pi, zoo)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (Abs, adjoint, arg, conjugate, im, re, sign, transpose)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (acos, atan, atan2, cos, sin)
+from sympy.functions.elementary.hyperbolic import sinh
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.integrals.integrals import Integral
+from sympy.matrices.dense import Matrix
+from sympy.matrices.expressions.funcmatrix import FunctionMatrix
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.matrices.immutable import (ImmutableMatrix, ImmutableSparseMatrix)
+from sympy.matrices import SparseMatrix
+from sympy.sets.sets import Interval
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.series.order import Order
+from sympy.testing.pytest import XFAIL, raises, _both_exp_pow
+
+
+def N_equals(a, b):
+    """Check whether two complex numbers are numerically close"""
+    return comp(a.n(), b.n(), 1.e-6)
+
+
+def test_re():
+    x, y = symbols('x,y')
+    a, b = symbols('a,b', real=True)
+
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+
+    assert re(nan) is nan
+
+    assert re(oo) is oo
+    assert re(-oo) is -oo
+
+    assert re(0) == 0
+
+    assert re(1) == 1
+    assert re(-1) == -1
+
+    assert re(E) == E
+    assert re(-E) == -E
+
+    assert unchanged(re, x)
+    assert re(x*I) == -im(x)
+    assert re(r*I) == 0
+    assert re(r) == r
+    assert re(i*I) == I * i
+    assert re(i) == 0
+
+    assert re(x + y) == re(x) + re(y)
+    assert re(x + r) == re(x) + r
+
+    assert re(re(x)) == re(x)
+
+    assert re(2 + I) == 2
+    assert re(x + I) == re(x)
+
+    assert re(x + y*I) == re(x) - im(y)
+    assert re(x + r*I) == re(x)
+
+    assert re(log(2*I)) == log(2)
+
+    assert re((2 + I)**2).expand(complex=True) == 3
+
+    assert re(conjugate(x)) == re(x)
+    assert conjugate(re(x)) == re(x)
+
+    assert re(x).as_real_imag() == (re(x), 0)
+
+    assert re(i*r*x).diff(r) == re(i*x)
+    assert re(i*r*x).diff(i) == I*r*im(x)
+
+    assert re(
+        sqrt(a + b*I)) == (a**2 + b**2)**Rational(1, 4)*cos(atan2(b, a)/2)
+    assert re(a * (2 + b*I)) == 2*a
+
+    assert re((1 + sqrt(a + b*I))/2) == \
+        (a**2 + b**2)**Rational(1, 4)*cos(atan2(b, a)/2)/2 + S.Half
+
+    assert re(x).rewrite(im) == x - S.ImaginaryUnit*im(x)
+    assert (x + re(y)).rewrite(re, im) == x + y - S.ImaginaryUnit*im(y)
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+    assert re(S.ComplexInfinity) is S.NaN
+
+    n, m, l = symbols('n m l')
+    A = MatrixSymbol('A',n,m)
+    assert re(A) == (S.Half) * (A + conjugate(A))
+
+    A = Matrix([[1 + 4*I,2],[0, -3*I]])
+    assert re(A) == Matrix([[1, 2],[0, 0]])
+
+    A = ImmutableMatrix([[1 + 3*I, 3-2*I],[0, 2*I]])
+    assert re(A) == ImmutableMatrix([[1, 3],[0, 0]])
+
+    X = SparseMatrix([[2*j + i*I for i in range(5)] for j in range(5)])
+    assert re(X) - Matrix([[0, 0, 0, 0, 0],
+                           [2, 2, 2, 2, 2],
+                           [4, 4, 4, 4, 4],
+                           [6, 6, 6, 6, 6],
+                           [8, 8, 8, 8, 8]]) == Matrix.zeros(5)
+
+    assert im(X) - Matrix([[0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4],
+                           [0, 1, 2, 3, 4]]) == Matrix.zeros(5)
+
+    X = FunctionMatrix(3, 3, Lambda((n, m), n + m*I))
+    assert re(X) == Matrix([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+
+
+def test_im():
+    x, y = symbols('x,y')
+    a, b = symbols('a,b', real=True)
+
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+
+    assert im(nan) is nan
+
+    assert im(oo*I) is oo
+    assert im(-oo*I) is -oo
+
+    assert im(0) == 0
+
+    assert im(1) == 0
+    assert im(-1) == 0
+
+    assert im(E*I) == E
+    assert im(-E*I) == -E
+
+    assert unchanged(im, x)
+    assert im(x*I) == re(x)
+    assert im(r*I) == r
+    assert im(r) == 0
+    assert im(i*I) == 0
+    assert im(i) == -I * i
+
+    assert im(x + y) == im(x) + im(y)
+    assert im(x + r) == im(x)
+    assert im(x + r*I) == im(x) + r
+
+    assert im(im(x)*I) == im(x)
+
+    assert im(2 + I) == 1
+    assert im(x + I) == im(x) + 1
+
+    assert im(x + y*I) == im(x) + re(y)
+    assert im(x + r*I) == im(x) + r
+
+    assert im(log(2*I)) == pi/2
+
+    assert im((2 + I)**2).expand(complex=True) == 4
+
+    assert im(conjugate(x)) == -im(x)
+    assert conjugate(im(x)) == im(x)
+
+    assert im(x).as_real_imag() == (im(x), 0)
+
+    assert im(i*r*x).diff(r) == im(i*x)
+    assert im(i*r*x).diff(i) == -I * re(r*x)
+
+    assert im(
+        sqrt(a + b*I)) == (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)
+    assert im(a * (2 + b*I)) == a*b
+
+    assert im((1 + sqrt(a + b*I))/2) == \
+        (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)/2
+
+    assert im(x).rewrite(re) == -S.ImaginaryUnit * (x - re(x))
+    assert (x + im(y)).rewrite(im, re) == x - S.ImaginaryUnit * (y - re(y))
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+    assert im(S.ComplexInfinity) is S.NaN
+
+    n, m, l = symbols('n m l')
+    A = MatrixSymbol('A',n,m)
+
+    assert im(A) == (S.One/(2*I)) * (A - conjugate(A))
+
+    A = Matrix([[1 + 4*I, 2],[0, -3*I]])
+    assert im(A) == Matrix([[4, 0],[0, -3]])
+
+    A = ImmutableMatrix([[1 + 3*I, 3-2*I],[0, 2*I]])
+    assert im(A) == ImmutableMatrix([[3, -2],[0, 2]])
+
+    X = ImmutableSparseMatrix(
+            [[i*I + i for i in range(5)] for i in range(5)])
+    Y = SparseMatrix([list(range(5)) for i in range(5)])
+    assert im(X).as_immutable() == Y
+
+    X = FunctionMatrix(3, 3, Lambda((n, m), n + m*I))
+    assert im(X) == Matrix([[0, 1, 2], [0, 1, 2], [0, 1, 2]])
+
+def test_sign():
+    assert sign(1.2) == 1
+    assert sign(-1.2) == -1
+    assert sign(3*I) == I
+    assert sign(-3*I) == -I
+    assert sign(0) == 0
+    assert sign(0, evaluate=False).doit() == 0
+    assert sign(oo, evaluate=False).doit() == 1
+    assert sign(nan) is nan
+    assert sign(2 + 2*I).doit() == sqrt(2)*(2 + 2*I)/4
+    assert sign(2 + 3*I).simplify() == sign(2 + 3*I)
+    assert sign(2 + 2*I).simplify() == sign(1 + I)
+    assert sign(im(sqrt(1 - sqrt(3)))) == 1
+    assert sign(sqrt(1 - sqrt(3))) == I
+
+    x = Symbol('x')
+    assert sign(x).is_finite is True
+    assert sign(x).is_complex is True
+    assert sign(x).is_imaginary is None
+    assert sign(x).is_integer is None
+    assert sign(x).is_real is None
+    assert sign(x).is_zero is None
+    assert sign(x).doit() == sign(x)
+    assert sign(1.2*x) == sign(x)
+    assert sign(2*x) == sign(x)
+    assert sign(I*x) == I*sign(x)
+    assert sign(-2*I*x) == -I*sign(x)
+    assert sign(conjugate(x)) == conjugate(sign(x))
+
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    m = Symbol('m', negative=True)
+    assert sign(2*p*x) == sign(x)
+    assert sign(n*x) == -sign(x)
+    assert sign(n*m*x) == sign(x)
+
+    x = Symbol('x', imaginary=True)
+    assert sign(x).is_imaginary is True
+    assert sign(x).is_integer is False
+    assert sign(x).is_real is False
+    assert sign(x).is_zero is False
+    assert sign(x).diff(x) == 2*DiracDelta(-I*x)
+    assert sign(x).doit() == x / Abs(x)
+    assert conjugate(sign(x)) == -sign(x)
+
+    x = Symbol('x', real=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is None
+    assert sign(x).diff(x) == 2*DiracDelta(x)
+    assert sign(x).doit() == sign(x)
+    assert conjugate(sign(x)) == sign(x)
+
+    x = Symbol('x', nonzero=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is False
+    assert sign(x).doit() == x / Abs(x)
+    assert sign(Abs(x)) == 1
+    assert Abs(sign(x)) == 1
+
+    x = Symbol('x', positive=True)
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is False
+    assert sign(x).doit() == x / Abs(x)
+    assert sign(Abs(x)) == 1
+    assert Abs(sign(x)) == 1
+
+    x = 0
+    assert sign(x).is_imaginary is False
+    assert sign(x).is_integer is True
+    assert sign(x).is_real is True
+    assert sign(x).is_zero is True
+    assert sign(x).doit() == 0
+    assert sign(Abs(x)) == 0
+    assert Abs(sign(x)) == 0
+
+    nz = Symbol('nz', nonzero=True, integer=True)
+    assert sign(nz).is_imaginary is False
+    assert sign(nz).is_integer is True
+    assert sign(nz).is_real is True
+    assert sign(nz).is_zero is False
+    assert sign(nz)**2 == 1
+    assert (sign(nz)**3).args == (sign(nz), 3)
+
+    assert sign(Symbol('x', nonnegative=True)).is_nonnegative
+    assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None
+    assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None
+    assert sign(Symbol('x', nonpositive=True)).is_nonpositive
+    assert sign(Symbol('x', real=True)).is_nonnegative is None
+    assert sign(Symbol('x', real=True)).is_nonpositive is None
+    assert sign(Symbol('x', real=True, zero=False)).is_nonpositive is None
+
+    x, y = Symbol('x', real=True), Symbol('y')
+    f = Function('f')
+    assert sign(x).rewrite(Piecewise) == \
+        Piecewise((1, x > 0), (-1, x < 0), (0, True))
+    assert sign(y).rewrite(Piecewise) == sign(y)
+    assert sign(x).rewrite(Heaviside) == 2*Heaviside(x, H0=S(1)/2) - 1
+    assert sign(y).rewrite(Heaviside) == sign(y)
+    assert sign(y).rewrite(Abs) == Piecewise((0, Eq(y, 0)), (y/Abs(y), True))
+    assert sign(f(y)).rewrite(Abs) == Piecewise((0, Eq(f(y), 0)), (f(y)/Abs(f(y)), True))
+
+    # evaluate what can be evaluated
+    assert sign(exp_polar(I*pi)*pi) is S.NegativeOne
+
+    eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
+    # if there is a fast way to know when and when you cannot prove an
+    # expression like this is zero then the equality to zero is ok
+    assert sign(eq).func is sign or sign(eq) == 0
+    # but sometimes it's hard to do this so it's better not to load
+    # abs down with tests that will be very slow
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
+    p = expand(q**3)**Rational(1, 3)
+    d = p - q
+    assert sign(d).func is sign or sign(d) == 0
+
+
+def test_as_real_imag():
+    n = pi**1000
+    # the special code for working out the real
+    # and complex parts of a power with Integer exponent
+    # should not run if there is no imaginary part, hence
+    # this should not hang
+    assert n.as_real_imag() == (n, 0)
+
+    # issue 6261
+    x = Symbol('x')
+    assert sqrt(x).as_real_imag() == \
+        ((re(x)**2 + im(x)**2)**Rational(1, 4)*cos(atan2(im(x), re(x))/2),
+     (re(x)**2 + im(x)**2)**Rational(1, 4)*sin(atan2(im(x), re(x))/2))
+
+    # issue 3853
+    a, b = symbols('a,b', real=True)
+    assert ((1 + sqrt(a + b*I))/2).as_real_imag() == \
+           (
+               (a**2 + b**2)**Rational(
+                   1, 4)*cos(atan2(b, a)/2)/2 + S.Half,
+               (a**2 + b**2)**Rational(1, 4)*sin(atan2(b, a)/2)/2)
+
+    assert sqrt(a**2).as_real_imag() == (sqrt(a**2), 0)
+    i = symbols('i', imaginary=True)
+    assert sqrt(i**2).as_real_imag() == (0, abs(i))
+
+    assert ((1 + I)/(1 - I)).as_real_imag() == (0, 1)
+    assert ((1 + I)**3/(1 - I)).as_real_imag() == (-2, 0)
+
+
+@XFAIL
+def test_sign_issue_3068():
+    n = pi**1000
+    i = int(n)
+    x = Symbol('x')
+    assert (n - i).round() == 1  # doesn't hang
+    assert sign(n - i) == 1
+    # perhaps it's not possible to get the sign right when
+    # only 1 digit is being requested for this situation;
+    # 2 digits works
+    assert (n - x).n(1, subs={x: i}) > 0
+    assert (n - x).n(2, subs={x: i}) > 0
+
+
+def test_Abs():
+    raises(TypeError, lambda: Abs(Interval(2, 3)))  # issue 8717
+
+    x, y = symbols('x,y')
+    assert sign(sign(x)) == sign(x)
+    assert sign(x*y).func is sign
+    assert Abs(0) == 0
+    assert Abs(1) == 1
+    assert Abs(-1) == 1
+    assert Abs(I) == 1
+    assert Abs(-I) == 1
+    assert Abs(nan) is nan
+    assert Abs(zoo) is oo
+    assert Abs(I * pi) == pi
+    assert Abs(-I * pi) == pi
+    assert Abs(I * x) == Abs(x)
+    assert Abs(-I * x) == Abs(x)
+    assert Abs(-2*x) == 2*Abs(x)
+    assert Abs(-2.0*x) == 2.0*Abs(x)
+    assert Abs(2*pi*x*y) == 2*pi*Abs(x*y)
+    assert Abs(conjugate(x)) == Abs(x)
+    assert conjugate(Abs(x)) == Abs(x)
+    assert Abs(x).expand(complex=True) == sqrt(re(x)**2 + im(x)**2)
+
+    a = Symbol('a', positive=True)
+    assert Abs(2*pi*x*a) == 2*pi*a*Abs(x)
+    assert Abs(2*pi*I*x*a) == 2*pi*a*Abs(x)
+
+    x = Symbol('x', real=True)
+    n = Symbol('n', integer=True)
+    assert Abs((-1)**n) == 1
+    assert x**(2*n) == Abs(x)**(2*n)
+    assert Abs(x).diff(x) == sign(x)
+    assert abs(x) == Abs(x)  # Python built-in
+    assert Abs(x)**3 == x**2*Abs(x)
+    assert Abs(x)**4 == x**4
+    assert (
+        Abs(x)**(3*n)).args == (Abs(x), 3*n)  # leave symbolic odd unchanged
+    assert (1/Abs(x)).args == (Abs(x), -1)
+    assert 1/Abs(x)**3 == 1/(x**2*Abs(x))
+    assert Abs(x)**-3 == Abs(x)/(x**4)
+    assert Abs(x**3) == x**2*Abs(x)
+    assert Abs(I**I) == exp(-pi/2)
+    assert Abs((4 + 5*I)**(6 + 7*I)) == 68921*exp(-7*atan(Rational(5, 4)))
+    y = Symbol('y', real=True)
+    assert Abs(I**y) == 1
+    y = Symbol('y')
+    assert Abs(I**y) == exp(-pi*im(y)/2)
+
+    x = Symbol('x', imaginary=True)
+    assert Abs(x).diff(x) == -sign(x)
+
+    eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3))
+    # if there is a fast way to know when you can and when you cannot prove an
+    # expression like this is zero then the equality to zero is ok
+    assert abs(eq).func is Abs or abs(eq) == 0
+    # but sometimes it's hard to do this so it's better not to load
+    # abs down with tests that will be very slow
+    q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6)
+    p = expand(q**3)**Rational(1, 3)
+    d = p - q
+    assert abs(d).func is Abs or abs(d) == 0
+
+    assert Abs(4*exp(pi*I/4)) == 4
+    assert Abs(3**(2 + I)) == 9
+    assert Abs((-3)**(1 - I)) == 3*exp(pi)
+
+    assert Abs(oo) is oo
+    assert Abs(-oo) is oo
+    assert Abs(oo + I) is oo
+    assert Abs(oo + I*oo) is oo
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    x = Symbol('x')
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+    assert Abs(x).fdiff() == sign(x)
+    raises(ArgumentIndexError, lambda: Abs(x).fdiff(2))
+
+    # doesn't have recursion error
+    arg = sqrt(acos(1 - I)*acos(1 + I))
+    assert abs(arg) == arg
+
+    # special handling to put Abs in denom
+    assert abs(1/x) == 1/Abs(x)
+    e = abs(2/x**2)
+    assert e.is_Mul and e == 2/Abs(x**2)
+    assert unchanged(Abs, y/x)
+    assert unchanged(Abs, x/(x + 1))
+    assert unchanged(Abs, x*y)
+    p = Symbol('p', positive=True)
+    assert abs(x/p) == abs(x)/p
+
+    # coverage
+    assert unchanged(Abs, Symbol('x', real=True)**y)
+    # issue 19627
+    f = Function('f', positive=True)
+    assert sqrt(f(x)**2) == f(x)
+    # issue 21625
+    assert unchanged(Abs, S("im(acos(-i + acosh(-g + i)))"))
+
+
+def test_Abs_rewrite():
+    x = Symbol('x', real=True)
+    a = Abs(x).rewrite(Heaviside).expand()
+    assert a == x*Heaviside(x) - x*Heaviside(-x)
+    for i in [-2, -1, 0, 1, 2]:
+        assert a.subs(x, i) == abs(i)
+    y = Symbol('y')
+    assert Abs(y).rewrite(Heaviside) == Abs(y)
+
+    x, y = Symbol('x', real=True), Symbol('y')
+    assert Abs(x).rewrite(Piecewise) == Piecewise((x, x >= 0), (-x, True))
+    assert Abs(y).rewrite(Piecewise) == Abs(y)
+    assert Abs(y).rewrite(sign) == y/sign(y)
+
+    i = Symbol('i', imaginary=True)
+    assert abs(i).rewrite(Piecewise) == Piecewise((I*i, I*i >= 0), (-I*i, True))
+
+
+    assert Abs(y).rewrite(conjugate) == sqrt(y*conjugate(y))
+    assert Abs(i).rewrite(conjugate) == sqrt(-i**2) #  == -I*i
+
+    y = Symbol('y', extended_real=True)
+    assert  (Abs(exp(-I*x)-exp(-I*y))**2).rewrite(conjugate) == \
+        -exp(I*x)*exp(-I*y) + 2 - exp(-I*x)*exp(I*y)
+
+
+def test_Abs_real():
+    # test some properties of abs that only apply
+    # to real numbers
+    x = Symbol('x', complex=True)
+    assert sqrt(x**2) != Abs(x)
+    assert Abs(x**2) != x**2
+
+    x = Symbol('x', real=True)
+    assert sqrt(x**2) == Abs(x)
+    assert Abs(x**2) == x**2
+
+    # if the symbol is zero, the following will still apply
+    nn = Symbol('nn', nonnegative=True, real=True)
+    np = Symbol('np', nonpositive=True, real=True)
+    assert Abs(nn) == nn
+    assert Abs(np) == -np
+
+
+def test_Abs_properties():
+    x = Symbol('x')
+    assert Abs(x).is_real is None
+    assert Abs(x).is_extended_real is True
+    assert Abs(x).is_rational is None
+    assert Abs(x).is_positive is None
+    assert Abs(x).is_nonnegative is None
+    assert Abs(x).is_extended_positive is None
+    assert Abs(x).is_extended_nonnegative is True
+
+    f = Symbol('x', finite=True)
+    assert Abs(f).is_real is True
+    assert Abs(f).is_extended_real is True
+    assert Abs(f).is_rational is None
+    assert Abs(f).is_positive is None
+    assert Abs(f).is_nonnegative is True
+    assert Abs(f).is_extended_positive is None
+    assert Abs(f).is_extended_nonnegative is True
+
+    z = Symbol('z', complex=True, zero=False)
+    assert Abs(z).is_real is True # since complex implies finite
+    assert Abs(z).is_extended_real is True
+    assert Abs(z).is_rational is None
+    assert Abs(z).is_positive is True
+    assert Abs(z).is_extended_positive is True
+    assert Abs(z).is_zero is False
+
+    p = Symbol('p', positive=True)
+    assert Abs(p).is_real is True
+    assert Abs(p).is_extended_real is True
+    assert Abs(p).is_rational is None
+    assert Abs(p).is_positive is True
+    assert Abs(p).is_zero is False
+
+    q = Symbol('q', rational=True)
+    assert Abs(q).is_real is True
+    assert Abs(q).is_rational is True
+    assert Abs(q).is_integer is None
+    assert Abs(q).is_positive is None
+    assert Abs(q).is_nonnegative is True
+
+    i = Symbol('i', integer=True)
+    assert Abs(i).is_real is True
+    assert Abs(i).is_integer is True
+    assert Abs(i).is_positive is None
+    assert Abs(i).is_nonnegative is True
+
+    e = Symbol('n', even=True)
+    ne = Symbol('ne', real=True, even=False)
+    assert Abs(e).is_even is True
+    assert Abs(ne).is_even is False
+    assert Abs(i).is_even is None
+
+    o = Symbol('n', odd=True)
+    no = Symbol('no', real=True, odd=False)
+    assert Abs(o).is_odd is True
+    assert Abs(no).is_odd is False
+    assert Abs(i).is_odd is None
+
+
+def test_abs():
+    # this tests that abs calls Abs; don't rename to
+    # test_Abs since that test is already above
+    a = Symbol('a', positive=True)
+    assert abs(I*(1 + a)**2) == (1 + a)**2
+
+
+def test_arg():
+    assert arg(0) is nan
+    assert arg(1) == 0
+    assert arg(-1) == pi
+    assert arg(I) == pi/2
+    assert arg(-I) == -pi/2
+    assert arg(1 + I) == pi/4
+    assert arg(-1 + I) == pi*Rational(3, 4)
+    assert arg(1 - I) == -pi/4
+    assert arg(exp_polar(4*pi*I)) == 4*pi
+    assert arg(exp_polar(-7*pi*I)) == -7*pi
+    assert arg(exp_polar(5 - 3*pi*I/4)) == pi*Rational(-3, 4)
+
+    assert arg(exp(I*pi/7)) == pi/7     # issue 17300
+    assert arg(exp(16*I)) == 16 - 6*pi
+    assert arg(exp(13*I*pi/12)) == -11*pi/12
+    assert arg(exp(123 - 5*I)) == -5 + 2*pi
+    assert arg(exp(sin(1 + 3*I))) == -2*pi + cos(1)*sinh(3)
+    r = Symbol('r', real=True)
+    assert arg(exp(r - 2*I)) == -2
+
+    f = Function('f')
+    assert not arg(f(0) + I*f(1)).atoms(re)
+
+    # check nesting
+    x = Symbol('x')
+    assert arg(arg(arg(x))) is not S.NaN
+    assert arg(arg(arg(arg(x)))) is S.NaN
+    r = Symbol('r', extended_real=True)
+    assert arg(arg(r)) is not S.NaN
+    assert arg(arg(arg(r))) is S.NaN
+
+    p = Function('p', extended_positive=True)
+    assert arg(p(x)) == 0
+    assert arg((3 + I)*p(x)) == arg(3  + I)
+
+    p = Symbol('p', positive=True)
+    assert arg(p) == 0
+    assert arg(p*I) == pi/2
+
+    n = Symbol('n', negative=True)
+    assert arg(n) == pi
+    assert arg(n*I) == -pi/2
+
+    x = Symbol('x')
+    assert conjugate(arg(x)) == arg(x)
+
+    e = p + I*p**2
+    assert arg(e) == arg(1 + p*I)
+    # make sure sign doesn't swap
+    e = -2*p + 4*I*p**2
+    assert arg(e) == arg(-1 + 2*p*I)
+    # make sure sign isn't lost
+    x = symbols('x', real=True)  # could be zero
+    e = x + I*x
+    assert arg(e) == arg(x*(1 + I))
+    assert arg(e/p) == arg(x*(1 + I))
+    e = p*cos(p) + I*log(p)*exp(p)
+    assert arg(e).args[0] == e
+    # keep it simple -- let the user do more advanced cancellation
+    e = (p + 1) + I*(p**2 - 1)
+    assert arg(e).args[0] == e
+
+    f = Function('f')
+    e = 2*x*(f(0) - 1) - 2*x*f(0)
+    assert arg(e) == arg(-2*x)
+    assert arg(f(0)).func == arg and arg(f(0)).args == (f(0),)
+
+
+def test_arg_rewrite():
+    assert arg(1 + I) == atan2(1, 1)
+
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    assert arg(x + I*y).rewrite(atan2) == atan2(y, x)
+
+
+def test_arg_leading_term_and_series():
+    x = Symbol('x')
+    assert arg(x).as_leading_term(x, cdir = 1) == 0
+    assert arg(x).as_leading_term(x, cdir = -1) == pi
+    raises(PoleError, lambda: arg(x + I).as_leading_term(x, cdir = 1))
+    raises(PoleError, lambda: arg(2*x).as_leading_term(x, cdir = I))
+
+    assert arg(x).nseries(x) == 0
+    assert arg(x).nseries(x, n=0) == Order(1)
+
+
+def test_adjoint():
+    a = Symbol('a', antihermitian=True)
+    b = Symbol('b', hermitian=True)
+    assert adjoint(a) == -a
+    assert adjoint(I*a) == I*a
+    assert adjoint(b) == b
+    assert adjoint(I*b) == -I*b
+    assert adjoint(a*b) == -b*a
+    assert adjoint(I*a*b) == I*b*a
+
+    x, y = symbols('x y')
+    assert adjoint(adjoint(x)) == x
+    assert adjoint(x + y) == conjugate(x) + conjugate(y)
+    assert adjoint(x - y) == conjugate(x) - conjugate(y)
+    assert adjoint(x * y) == conjugate(x) * conjugate(y)
+    assert adjoint(x / y) == conjugate(x) / conjugate(y)
+    assert adjoint(-x) == -conjugate(x)
+
+    x, y = symbols('x y', commutative=False)
+    assert adjoint(adjoint(x)) == x
+    assert adjoint(x + y) == adjoint(x) + adjoint(y)
+    assert adjoint(x - y) == adjoint(x) - adjoint(y)
+    assert adjoint(x * y) == adjoint(y) * adjoint(x)
+    assert adjoint(x / y) == 1 / adjoint(y) * adjoint(x)
+    assert adjoint(-x) == -adjoint(x)
+
+
+def test_conjugate():
+    a = Symbol('a', real=True)
+    b = Symbol('b', imaginary=True)
+    assert conjugate(a) == a
+    assert conjugate(I*a) == -I*a
+    assert conjugate(b) == -b
+    assert conjugate(I*b) == I*b
+    assert conjugate(a*b) == -a*b
+    assert conjugate(I*a*b) == I*a*b
+
+    x, y = symbols('x y')
+    assert conjugate(conjugate(x)) == x
+    assert conjugate(x).inverse() == conjugate
+    assert conjugate(x + y) == conjugate(x) + conjugate(y)
+    assert conjugate(x - y) == conjugate(x) - conjugate(y)
+    assert conjugate(x * y) == conjugate(x) * conjugate(y)
+    assert conjugate(x / y) == conjugate(x) / conjugate(y)
+    assert conjugate(-x) == -conjugate(x)
+
+    a = Symbol('a', algebraic=True)
+    t = Symbol('t', transcendental=True)
+    assert re(a).is_algebraic
+    assert re(x).is_algebraic is None
+    assert re(t).is_algebraic is False
+
+
+def test_conjugate_transpose():
+    x = Symbol('x', commutative=False)
+    assert conjugate(transpose(x)) == adjoint(x)
+    assert transpose(conjugate(x)) == adjoint(x)
+    assert adjoint(transpose(x)) == conjugate(x)
+    assert transpose(adjoint(x)) == conjugate(x)
+    assert adjoint(conjugate(x)) == transpose(x)
+    assert conjugate(adjoint(x)) == transpose(x)
+
+    x = Symbol('x')
+    assert conjugate(x) == adjoint(x)
+    assert transpose(x) == x
+
+
+def test_transpose():
+    a = Symbol('a', complex=True)
+    assert transpose(a) == a
+    assert transpose(I*a) == I*a
+
+    x, y = symbols('x y')
+    assert transpose(transpose(x)) == x
+    assert transpose(x + y) == x + y
+    assert transpose(x - y) == x - y
+    assert transpose(x * y) == x * y
+    assert transpose(x / y) == x / y
+    assert transpose(-x) == -x
+
+    x, y = symbols('x y', commutative=False)
+    assert transpose(transpose(x)) == x
+    assert transpose(x + y) == transpose(x) + transpose(y)
+    assert transpose(x - y) == transpose(x) - transpose(y)
+    assert transpose(x * y) == transpose(y) * transpose(x)
+    assert transpose(x / y) == 1 / transpose(y) * transpose(x)
+    assert transpose(-x) == -transpose(x)
+
+
+@_both_exp_pow
+def test_polarify():
+    from sympy.functions.elementary.complexes import (polar_lift, polarify)
+    x = Symbol('x')
+    z = Symbol('z', polar=True)
+    f = Function('f')
+    ES = {}
+
+    assert polarify(-1) == (polar_lift(-1), ES)
+    assert polarify(1 + I) == (polar_lift(1 + I), ES)
+
+    assert polarify(exp(x), subs=False) == exp(x)
+    assert polarify(1 + x, subs=False) == 1 + x
+    assert polarify(f(I) + x, subs=False) == f(polar_lift(I)) + x
+
+    assert polarify(x, lift=True) == polar_lift(x)
+    assert polarify(z, lift=True) == z
+    assert polarify(f(x), lift=True) == f(polar_lift(x))
+    assert polarify(1 + x, lift=True) == polar_lift(1 + x)
+    assert polarify(1 + f(x), lift=True) == polar_lift(1 + f(polar_lift(x)))
+
+    newex, subs = polarify(f(x) + z)
+    assert newex.subs(subs) == f(x) + z
+
+    mu = Symbol("mu")
+    sigma = Symbol("sigma", positive=True)
+
+    # Make sure polarify(lift=True) doesn't try to lift the integration
+    # variable
+    assert polarify(
+        Integral(sqrt(2)*x*exp(-(-mu + x)**2/(2*sigma**2))/(2*sqrt(pi)*sigma),
+        (x, -oo, oo)), lift=True) == Integral(sqrt(2)*(sigma*exp_polar(0))**exp_polar(I*pi)*
+        exp((sigma*exp_polar(0))**(2*exp_polar(I*pi))*exp_polar(I*pi)*polar_lift(-mu + x)**
+        (2*exp_polar(0))/2)*exp_polar(0)*polar_lift(x)/(2*sqrt(pi)), (x, -oo, oo))
+
+
+def test_unpolarify():
+    from sympy.functions.elementary.complexes import (polar_lift, principal_branch, unpolarify)
+    from sympy.core.relational import Ne
+    from sympy.functions.elementary.hyperbolic import tanh
+    from sympy.functions.special.error_functions import erf
+    from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+    from sympy.abc import x
+    p = exp_polar(7*I) + 1
+    u = exp(7*I) + 1
+
+    assert unpolarify(1) == 1
+    assert unpolarify(p) == u
+    assert unpolarify(p**2) == u**2
+    assert unpolarify(p**x) == p**x
+    assert unpolarify(p*x) == u*x
+    assert unpolarify(p + x) == u + x
+    assert unpolarify(sqrt(sin(p))) == sqrt(sin(u))
+
+    # Test reduction to principal branch 2*pi.
+    t = principal_branch(x, 2*pi)
+    assert unpolarify(t) == x
+    assert unpolarify(sqrt(t)) == sqrt(t)
+
+    # Test exponents_only.
+    assert unpolarify(p**p, exponents_only=True) == p**u
+    assert unpolarify(uppergamma(x, p**p)) == uppergamma(x, p**u)
+
+    # Test functions.
+    assert unpolarify(sin(p)) == sin(u)
+    assert unpolarify(tanh(p)) == tanh(u)
+    assert unpolarify(gamma(p)) == gamma(u)
+    assert unpolarify(erf(p)) == erf(u)
+    assert unpolarify(uppergamma(x, p)) == uppergamma(x, p)
+
+    assert unpolarify(uppergamma(sin(p), sin(p + exp_polar(0)))) == \
+        uppergamma(sin(u), sin(u + 1))
+    assert unpolarify(uppergamma(polar_lift(0), 2*exp_polar(0))) == \
+        uppergamma(0, 2)
+
+    assert unpolarify(Eq(p, 0)) == Eq(u, 0)
+    assert unpolarify(Ne(p, 0)) == Ne(u, 0)
+    assert unpolarify(polar_lift(x) > 0) == (x > 0)
+
+    # Test bools
+    assert unpolarify(True) is True
+
+
+def test_issue_4035():
+    x = Symbol('x')
+    assert Abs(x).expand(trig=True) == Abs(x)
+    assert sign(x).expand(trig=True) == sign(x)
+    assert arg(x).expand(trig=True) == arg(x)
+
+
+def test_issue_3206():
+    x = Symbol('x')
+    assert Abs(Abs(x)) == Abs(x)
+
+
+def test_issue_4754_derivative_conjugate():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    f = Function('f')
+    assert (f(x).conjugate()).diff(x) == (f(x).diff(x)).conjugate()
+    assert (f(y).conjugate()).diff(y) == -(f(y).diff(y)).conjugate()
+
+
+def test_derivatives_issue_4757():
+    x = Symbol('x', real=True)
+    y = Symbol('y', imaginary=True)
+    f = Function('f')
+    assert re(f(x)).diff(x) == re(f(x).diff(x))
+    assert im(f(x)).diff(x) == im(f(x).diff(x))
+    assert re(f(y)).diff(y) == -I*im(f(y).diff(y))
+    assert im(f(y)).diff(y) == -I*re(f(y).diff(y))
+    assert Abs(f(x)).diff(x).subs(f(x), 1 + I*x).doit() == x/sqrt(1 + x**2)
+    assert arg(f(x)).diff(x).subs(f(x), 1 + I*x**2).doit() == 2*x/(1 + x**4)
+    assert Abs(f(y)).diff(y).subs(f(y), 1 + y).doit() == -y/sqrt(1 - y**2)
+    assert arg(f(y)).diff(y).subs(f(y), I + y**2).doit() == 2*y/(1 + y**4)
+
+
+def test_issue_11413():
+    from sympy.simplify.simplify import simplify
+    v0 = Symbol('v0')
+    v1 = Symbol('v1')
+    v2 = Symbol('v2')
+    V = Matrix([[v0],[v1],[v2]])
+    U = V.normalized()
+    assert U == Matrix([
+    [v0/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)],
+    [v1/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)],
+    [v2/sqrt(Abs(v0)**2 + Abs(v1)**2 + Abs(v2)**2)]])
+    U.norm = sqrt(v0**2/(v0**2 + v1**2 + v2**2) + v1**2/(v0**2 + v1**2 + v2**2) + v2**2/(v0**2 + v1**2 + v2**2))
+    assert simplify(U.norm) == 1
+
+
+def test_periodic_argument():
+    from sympy.functions.elementary.complexes import (periodic_argument, polar_lift, principal_branch, unbranched_argument)
+    x = Symbol('x')
+    p = Symbol('p', positive=True)
+
+    assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
+    assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
+    assert N_equals(unbranched_argument((1 + I)**2), pi/2)
+    assert N_equals(unbranched_argument((1 - I)**2), -pi/2)
+    assert N_equals(periodic_argument((1 + I)**2, 3*pi), pi/2)
+    assert N_equals(periodic_argument((1 - I)**2, 3*pi), -pi/2)
+
+    assert unbranched_argument(principal_branch(x, pi)) == \
+        periodic_argument(x, pi)
+
+    assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
+    assert periodic_argument(polar_lift(2 + I), 2*pi) == \
+        periodic_argument(2 + I, 2*pi)
+    assert periodic_argument(polar_lift(2 + I), 3*pi) == \
+        periodic_argument(2 + I, 3*pi)
+    assert periodic_argument(polar_lift(2 + I), pi) == \
+        periodic_argument(polar_lift(2 + I), pi)
+
+    assert unbranched_argument(polar_lift(1 + I)) == pi/4
+    assert periodic_argument(2*p, p) == periodic_argument(p, p)
+    assert periodic_argument(pi*p, p) == periodic_argument(p, p)
+
+    assert Abs(polar_lift(1 + I)) == Abs(1 + I)
+
+
+@XFAIL
+def test_principal_branch_fail():
+    # TODO XXX why does abs(x)._eval_evalf() not fall back to global evalf?
+    from sympy.functions.elementary.complexes import principal_branch
+    assert N_equals(principal_branch((1 + I)**2, pi/2), 0)
+
+
+def test_principal_branch():
+    from sympy.functions.elementary.complexes import (polar_lift, principal_branch)
+    p = Symbol('p', positive=True)
+    x = Symbol('x')
+    neg = Symbol('x', negative=True)
+
+    assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
+    assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
+    assert principal_branch(2*x, p) == 2*principal_branch(x, p)
+    assert principal_branch(1, pi) == exp_polar(0)
+    assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
+    assert principal_branch(-1, pi) == exp_polar(0)
+    assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
+        principal_branch(exp_polar(I*pi)*x, 2*pi)
+    assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
+    # related to issue #14692
+    assert principal_branch(exp_polar(-I*pi/2)/polar_lift(neg), 2*pi) == \
+        exp_polar(-I*pi/2)/neg
+
+    assert N_equals(principal_branch((1 + I)**2, 2*pi), 2*I)
+    assert N_equals(principal_branch((1 + I)**2, 3*pi), 2*I)
+    assert N_equals(principal_branch((1 + I)**2, 1*pi), 2*I)
+
+    # test argument sanitization
+    assert principal_branch(x, I).func is principal_branch
+    assert principal_branch(x, -4).func is principal_branch
+    assert principal_branch(x, -oo).func is principal_branch
+    assert principal_branch(x, zoo).func is principal_branch
+
+
+@XFAIL
+def test_issue_6167_6151():
+    n = pi**1000
+    i = int(n)
+    assert sign(n - i) == 1
+    assert abs(n - i) == n - i
+    x = Symbol('x')
+    eps = pi**-1500
+    big = pi**1000
+    one = cos(x)**2 + sin(x)**2
+    e = big*one - big + eps
+    from sympy.simplify.simplify import simplify
+    assert sign(simplify(e)) == 1
+    for xi in (111, 11, 1, Rational(1, 10)):
+        assert sign(e.subs(x, xi)) == 1
+
+
+def test_issue_14216():
+    from sympy.functions.elementary.complexes import unpolarify
+    A = MatrixSymbol("A", 2, 2)
+    assert unpolarify(A[0, 0]) == A[0, 0]
+    assert unpolarify(A[0, 0]*A[1, 0]) == A[0, 0]*A[1, 0]
+
+
+def test_issue_14238():
+    # doesn't cause recursion error
+    r = Symbol('r', real=True)
+    assert Abs(r + Piecewise((0, r > 0), (1 - r, True)))
+
+
+def test_issue_22189():
+    x = Symbol('x')
+    for a in (sqrt(7 - 2*x) - 2, 1 - x):
+        assert Abs(a) - Abs(-a) == 0, a
+
+
+def test_zero_assumptions():
+    nr = Symbol('nonreal', real=False, finite=True)
+    ni = Symbol('nonimaginary', imaginary=False)
+    # imaginary implies not zero
+    nzni = Symbol('nonzerononimaginary', zero=False, imaginary=False)
+
+    assert re(nr).is_zero is None
+    assert im(nr).is_zero is False
+
+    assert re(ni).is_zero is None
+    assert im(ni).is_zero is None
+
+    assert re(nzni).is_zero is False
+    assert im(nzni).is_zero is None
+
+
+@_both_exp_pow
+def test_issue_15893():
+    f = Function('f', real=True)
+    x = Symbol('x', real=True)
+    eq = Derivative(Abs(f(x)), f(x))
+    assert eq.doit() == sign(f(x))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_exponential.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_exponential.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee8c311d01e98d7fd6831ad754e854fae409aa0c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_exponential.py
@@ -0,0 +1,810 @@
+from sympy.assumptions.refine import refine
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.concrete.products import Product
+from sympy.concrete.summations import Sum
+from sympy.core.function import expand_log
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (adjoint, conjugate, re, sign, transpose)
+from sympy.functions.elementary.exponential import (LambertW, exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, tan)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.polys.polytools import gcd
+from sympy.series.order import O
+from sympy.simplify.simplify import simplify
+from sympy.core.parameters import global_parameters
+from sympy.functions.elementary.exponential import match_real_imag
+from sympy.abc import x, y, z
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises, XFAIL, _both_exp_pow
+
+
+@_both_exp_pow
+def test_exp_values():
+    if global_parameters.exp_is_pow:
+        assert type(exp(x)) is Pow
+    else:
+        assert type(exp(x)) is exp
+
+    k = Symbol('k', integer=True)
+
+    assert exp(nan) is nan
+
+    assert exp(oo) is oo
+    assert exp(-oo) == 0
+
+    assert exp(0) == 1
+    assert exp(1) == E
+    assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1)
+    assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1)
+
+    assert exp(pi*I/2) == I
+    assert exp(pi*I) == -1
+    assert exp(pi*I*Rational(3, 2)) == -I
+    assert exp(2*pi*I) == 1
+
+    assert refine(exp(pi*I*2*k)) == 1
+    assert refine(exp(pi*I*2*(k + S.Half))) == -1
+    assert refine(exp(pi*I*2*(k + Rational(1, 4)))) == I
+    assert refine(exp(pi*I*2*(k + Rational(3, 4)))) == -I
+
+    assert exp(log(x)) == x
+    assert exp(2*log(x)) == x**2
+    assert exp(pi*log(x)) == x**pi
+
+    assert exp(17*log(x) + E*log(y)) == x**17 * y**E
+
+    assert exp(x*log(x)) != x**x
+    assert exp(sin(x)*log(x)) != x
+
+    assert exp(3*log(x) + oo*x) == exp(oo*x) * x**3
+    assert exp(4*log(x)*log(y) + 3*log(x)) == x**3 * exp(4*log(x)*log(y))
+
+    assert exp(-oo, evaluate=False).is_finite is True
+    assert exp(oo, evaluate=False).is_finite is False
+
+
+@_both_exp_pow
+def test_exp_period():
+    assert exp(I*pi*Rational(9, 4)) == exp(I*pi/4)
+    assert exp(I*pi*Rational(46, 18)) == exp(I*pi*Rational(5, 9))
+    assert exp(I*pi*Rational(25, 7)) == exp(I*pi*Rational(-3, 7))
+    assert exp(I*pi*Rational(-19, 3)) == exp(-I*pi/3)
+    assert exp(I*pi*Rational(37, 8)) - exp(I*pi*Rational(-11, 8)) == 0
+    assert exp(I*pi*Rational(-5, 3)) / exp(I*pi*Rational(11, 5)) * exp(I*pi*Rational(148, 15)) == 1
+
+    assert exp(2 - I*pi*Rational(17, 5)) == exp(2 + I*pi*Rational(3, 5))
+    assert exp(log(3) + I*pi*Rational(29, 9)) == 3 * exp(I*pi*Rational(-7, 9))
+
+    n = Symbol('n', integer=True)
+    e = Symbol('e', even=True)
+    assert exp(e*I*pi) == 1
+    assert exp((e + 1)*I*pi) == -1
+    assert exp((1 + 4*n)*I*pi/2) == I
+    assert exp((-1 + 4*n)*I*pi/2) == -I
+
+
+@_both_exp_pow
+def test_exp_log():
+    x = Symbol("x", real=True)
+    assert log(exp(x)) == x
+    assert exp(log(x)) == x
+
+    if not global_parameters.exp_is_pow:
+        assert log(x).inverse() == exp
+        assert exp(x).inverse() == log
+
+    y = Symbol("y", polar=True)
+    assert log(exp_polar(z)) == z
+    assert exp(log(y)) == y
+
+
+@_both_exp_pow
+def test_exp_expand():
+    e = exp(log(Rational(2))*(1 + x) - log(Rational(2))*x)
+    assert e.expand() == 2
+    assert exp(x + y) != exp(x)*exp(y)
+    assert exp(x + y).expand() == exp(x)*exp(y)
+
+
+@_both_exp_pow
+def test_exp__as_base_exp():
+    assert exp(x).as_base_exp() == (E, x)
+    assert exp(2*x).as_base_exp() == (E, 2*x)
+    assert exp(x*y).as_base_exp() == (E, x*y)
+    assert exp(-x).as_base_exp() == (E, -x)
+
+    # Pow( *expr.as_base_exp() ) == expr    invariant should hold
+    assert E**x == exp(x)
+    assert E**(2*x) == exp(2*x)
+    assert E**(x*y) == exp(x*y)
+
+    assert exp(x).base is S.Exp1
+    assert exp(x).exp == x
+
+
+@_both_exp_pow
+def test_exp_infinity():
+    assert exp(I*y) != nan
+    assert refine(exp(I*oo)) is nan
+    assert refine(exp(-I*oo)) is nan
+    assert exp(y*I*oo) != nan
+    assert exp(zoo) is nan
+    x = Symbol('x', extended_real=True, finite=False)
+    assert exp(x).is_complex is None
+
+
+@_both_exp_pow
+def test_exp_subs():
+    x = Symbol('x')
+    e = (exp(3*log(x), evaluate=False))  # evaluates to x**3
+    assert e.subs(x**3, y**3) == e
+    assert e.subs(x**2, 5) == e
+    assert (x**3).subs(x**2, y) != y**Rational(3, 2)
+    assert exp(exp(x) + exp(x**2)).subs(exp(exp(x)), y) == y * exp(exp(x**2))
+    assert exp(x).subs(E, y) == y**x
+    x = symbols('x', real=True)
+    assert exp(5*x).subs(exp(7*x), y) == y**Rational(5, 7)
+    assert exp(2*x + 7).subs(exp(3*x), y) == y**Rational(2, 3) * exp(7)
+    x = symbols('x', positive=True)
+    assert exp(3*log(x)).subs(x**2, y) == y**Rational(3, 2)
+    # differentiate between E and exp
+    assert exp(exp(x + E)).subs(exp, 3) == 3**(3**(x + E))
+    assert exp(exp(x + E)).subs(exp, sin) == sin(sin(x + E))
+    assert exp(exp(x + E)).subs(E, 3) == 3**(3**(x + 3))
+    assert exp(3).subs(E, sin) == sin(3)
+
+
+def test_exp_adjoint():
+    x = Symbol('x', commutative=False)
+    assert adjoint(exp(x)) == exp(adjoint(x))
+
+
+def test_exp_conjugate():
+    assert conjugate(exp(x)) == exp(conjugate(x))
+
+
+@_both_exp_pow
+def test_exp_transpose():
+    assert transpose(exp(x)) == exp(transpose(x))
+
+
+@_both_exp_pow
+def test_exp_rewrite():
+    assert exp(x).rewrite(sin) == sinh(x) + cosh(x)
+    assert exp(x*I).rewrite(cos) == cos(x) + I*sin(x)
+    assert exp(1).rewrite(cos) == sinh(1) + cosh(1)
+    assert exp(1).rewrite(sin) == sinh(1) + cosh(1)
+    assert exp(1).rewrite(sin) == sinh(1) + cosh(1)
+    assert exp(x).rewrite(tanh) == (1 + tanh(x/2))/(1 - tanh(x/2))
+    assert exp(pi*I/4).rewrite(sqrt) == sqrt(2)/2 + sqrt(2)*I/2
+    assert exp(pi*I/3).rewrite(sqrt) == S.Half + sqrt(3)*I/2
+    if not global_parameters.exp_is_pow:
+        assert exp(x*log(y)).rewrite(Pow) == y**x
+        assert exp(log(x)*log(y)).rewrite(Pow) in [x**log(y), y**log(x)]
+        assert exp(log(log(x))*y).rewrite(Pow) == log(x)**y
+
+    n = Symbol('n', integer=True)
+
+    assert Sum((exp(pi*I/2)/2)**n, (n, 0, oo)).rewrite(sqrt).doit() == Rational(4, 5) + I*2/5
+    assert Sum((exp(pi*I/4)/2)**n, (n, 0, oo)).rewrite(sqrt).doit() == 1/(1 - sqrt(2)*(1 + I)/4)
+    assert (Sum((exp(pi*I/3)/2)**n, (n, 0, oo)).rewrite(sqrt).doit().cancel()
+            == 4*I/(sqrt(3) + 3*I))
+
+
+@_both_exp_pow
+def test_exp_leading_term():
+    assert exp(x).as_leading_term(x) == 1
+    assert exp(2 + x).as_leading_term(x) == exp(2)
+    assert exp((2*x + 3) / (x+1)).as_leading_term(x) == exp(3)
+
+    # The following tests are commented, since now SymPy returns the
+    # original function when the leading term in the series expansion does
+    # not exist.
+    # raises(NotImplementedError, lambda: exp(1/x).as_leading_term(x))
+    # raises(NotImplementedError, lambda: exp((x + 1) / x**2).as_leading_term(x))
+    # raises(NotImplementedError, lambda: exp(x + 1/x).as_leading_term(x))
+
+
+@_both_exp_pow
+def test_exp_taylor_term():
+    x = symbols('x')
+    assert exp(x).taylor_term(1, x) == x
+    assert exp(x).taylor_term(3, x) == x**3/6
+    assert exp(x).taylor_term(4, x) == x**4/24
+    assert exp(x).taylor_term(-1, x) is S.Zero
+
+
+def test_exp_MatrixSymbol():
+    A = MatrixSymbol("A", 2, 2)
+    assert exp(A).has(exp)
+
+
+def test_exp_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: exp(x).fdiff(2))
+
+
+def test_log_values():
+    assert log(nan) is nan
+
+    assert log(oo) is oo
+    assert log(-oo) is oo
+
+    assert log(zoo) is zoo
+    assert log(-zoo) is zoo
+
+    assert log(0) is zoo
+
+    assert log(1) == 0
+    assert log(-1) == I*pi
+
+    assert log(E) == 1
+    assert log(-E).expand() == 1 + I*pi
+
+    assert unchanged(log, pi)
+    assert log(-pi).expand() == log(pi) + I*pi
+
+    assert unchanged(log, 17)
+    assert log(-17) == log(17) + I*pi
+
+    assert log(I) == I*pi/2
+    assert log(-I) == -I*pi/2
+
+    assert log(17*I) == I*pi/2 + log(17)
+    assert log(-17*I).expand() == -I*pi/2 + log(17)
+
+    assert log(oo*I) is oo
+    assert log(-oo*I) is oo
+    assert log(0, 2) is zoo
+    assert log(0, 5) is zoo
+
+    assert exp(-log(3))**(-1) == 3
+
+    assert log(S.Half) == -log(2)
+    assert log(2*3).func is log
+    assert log(2*3**2).func is log
+
+
+def test_match_real_imag():
+    x, y = symbols('x,y', real=True)
+    i = Symbol('i', imaginary=True)
+    assert match_real_imag(S.One) == (1, 0)
+    assert match_real_imag(I) == (0, 1)
+    assert match_real_imag(3 - 5*I) == (3, -5)
+    assert match_real_imag(-sqrt(3) + S.Half*I) == (-sqrt(3), S.Half)
+    assert match_real_imag(x + y*I) == (x, y)
+    assert match_real_imag(x*I + y*I) == (0, x + y)
+    assert match_real_imag((x + y)*I) == (0, x + y)
+    assert match_real_imag(Rational(-2, 3)*i*I) == (None, None)
+    assert match_real_imag(1 - 2*i) == (None, None)
+    assert match_real_imag(sqrt(2)*(3 - 5*I)) == (None, None)
+
+
+def test_log_exact():
+    # check for pi/2, pi/3, pi/4, pi/6, pi/8, pi/12; pi/5, pi/10:
+    for n in range(-23, 24):
+        if gcd(n, 24) != 1:
+            assert log(exp(n*I*pi/24).rewrite(sqrt)) == n*I*pi/24
+        for n in range(-9, 10):
+            assert log(exp(n*I*pi/10).rewrite(sqrt)) == n*I*pi/10
+
+    assert log(S.Half - I*sqrt(3)/2) == -I*pi/3
+    assert log(Rational(-1, 2) + I*sqrt(3)/2) == I*pi*Rational(2, 3)
+    assert log(-sqrt(2)/2 - I*sqrt(2)/2) == -I*pi*Rational(3, 4)
+    assert log(-sqrt(3)/2 - I*S.Half) == -I*pi*Rational(5, 6)
+
+    assert log(Rational(-1, 4) + sqrt(5)/4 - I*sqrt(sqrt(5)/8 + Rational(5, 8))) == -I*pi*Rational(2, 5)
+    assert log(sqrt(Rational(5, 8) - sqrt(5)/8) + I*(Rational(1, 4) + sqrt(5)/4)) == I*pi*Rational(3, 10)
+    assert log(-sqrt(sqrt(2)/4 + S.Half) + I*sqrt(S.Half - sqrt(2)/4)) == I*pi*Rational(7, 8)
+    assert log(-sqrt(6)/4 - sqrt(2)/4 + I*(-sqrt(6)/4 + sqrt(2)/4)) == -I*pi*Rational(11, 12)
+
+    assert log(-1 + I*sqrt(3)) == log(2) + I*pi*Rational(2, 3)
+    assert log(5 + 5*I) == log(5*sqrt(2)) + I*pi/4
+    assert log(sqrt(-12)) == log(2*sqrt(3)) + I*pi/2
+    assert log(-sqrt(6) + sqrt(2) - I*sqrt(6) - I*sqrt(2)) == log(4) - I*pi*Rational(7, 12)
+    assert log(-sqrt(6-3*sqrt(2)) - I*sqrt(6+3*sqrt(2))) == log(2*sqrt(3)) - I*pi*Rational(5, 8)
+    assert log(1 + I*sqrt(2-sqrt(2))/sqrt(2+sqrt(2))) == log(2/sqrt(sqrt(2) + 2)) + I*pi/8
+    assert log(cos(pi*Rational(7, 12)) + I*sin(pi*Rational(7, 12))) == I*pi*Rational(7, 12)
+    assert log(cos(pi*Rational(6, 5)) + I*sin(pi*Rational(6, 5))) == I*pi*Rational(-4, 5)
+
+    assert log(5*(1 + I)/sqrt(2)) == log(5) + I*pi/4
+    assert log(sqrt(2)*(-sqrt(3) + 1 - sqrt(3)*I - I)) == log(4) - I*pi*Rational(7, 12)
+    assert log(-sqrt(2)*(1 - I*sqrt(3))) == log(2*sqrt(2)) + I*pi*Rational(2, 3)
+    assert log(sqrt(3)*I*(-sqrt(6 - 3*sqrt(2)) - I*sqrt(3*sqrt(2) + 6))) == log(6) - I*pi/8
+
+    zero = (1 + sqrt(2))**2 - 3 - 2*sqrt(2)
+    assert log(zero - I*sqrt(3)) == log(sqrt(3)) - I*pi/2
+    assert unchanged(log, zero + I*zero) or log(zero + zero*I) is zoo
+
+    # bail quickly if no obvious simplification is possible:
+    assert unchanged(log, (sqrt(2)-1/sqrt(sqrt(3)+I))**1000)
+    # beware of non-real coefficients
+    assert unchanged(log, sqrt(2-sqrt(5))*(1 + I))
+
+
+def test_log_base():
+    assert log(1, 2) == 0
+    assert log(2, 2) == 1
+    assert log(3, 2) == log(3)/log(2)
+    assert log(6, 2) == 1 + log(3)/log(2)
+    assert log(6, 3) == 1 + log(2)/log(3)
+    assert log(2**3, 2) == 3
+    assert log(3**3, 3) == 3
+    assert log(5, 1) is zoo
+    assert log(1, 1) is nan
+    assert log(Rational(2, 3), 10) == log(Rational(2, 3))/log(10)
+    assert log(Rational(2, 3), Rational(1, 3)) == -log(2)/log(3) + 1
+    assert log(Rational(2, 3), Rational(2, 5)) == \
+        log(Rational(2, 3))/log(Rational(2, 5))
+    # issue 17148
+    assert log(Rational(8, 3), 2) == -log(3)/log(2) + 3
+
+
+def test_log_symbolic():
+    assert log(x, exp(1)) == log(x)
+    assert log(exp(x)) != x
+
+    assert log(x, exp(1)) == log(x)
+    assert log(x*y) != log(x) + log(y)
+    assert log(x/y).expand() != log(x) - log(y)
+    assert log(x/y).expand(force=True) == log(x) - log(y)
+    assert log(x**y).expand() != y*log(x)
+    assert log(x**y).expand(force=True) == y*log(x)
+
+    assert log(x, 2) == log(x)/log(2)
+    assert log(E, 2) == 1/log(2)
+
+    p, q = symbols('p,q', positive=True)
+    r = Symbol('r', real=True)
+
+    assert log(p**2) != 2*log(p)
+    assert log(p**2).expand() == 2*log(p)
+    assert log(x**2).expand() != 2*log(x)
+    assert log(p**q) != q*log(p)
+    assert log(exp(p)) == p
+    assert log(p*q) != log(p) + log(q)
+    assert log(p*q).expand() == log(p) + log(q)
+
+    assert log(-sqrt(3)) == log(sqrt(3)) + I*pi
+    assert log(-exp(p)) != p + I*pi
+    assert log(-exp(x)).expand() != x + I*pi
+    assert log(-exp(r)).expand() == r + I*pi
+
+    assert log(x**y) != y*log(x)
+
+    assert (log(x**-5)**-1).expand() != -1/log(x)/5
+    assert (log(p**-5)**-1).expand() == -1/log(p)/5
+    assert log(-x).func is log and log(-x).args[0] == -x
+    assert log(-p).func is log and log(-p).args[0] == -p
+
+
+def test_log_exp():
+    assert log(exp(4*I*pi)) == 0     # exp evaluates
+    assert log(exp(-5*I*pi)) == I*pi # exp evaluates
+    assert log(exp(I*pi*Rational(19, 4))) == I*pi*Rational(3, 4)
+    assert log(exp(I*pi*Rational(25, 7))) == I*pi*Rational(-3, 7)
+    assert log(exp(-5*I)) == -5*I + 2*I*pi
+
+
+@_both_exp_pow
+def test_exp_assumptions():
+    r = Symbol('r', real=True)
+    i = Symbol('i', imaginary=True)
+    for e in exp, exp_polar:
+        assert e(x).is_real is None
+        assert e(x).is_imaginary is None
+        assert e(i).is_real is None
+        assert e(i).is_imaginary is None
+        assert e(r).is_real is True
+        assert e(r).is_imaginary is False
+        assert e(re(x)).is_extended_real is True
+        assert e(re(x)).is_imaginary is False
+
+    assert Pow(E, I*pi, evaluate=False).is_imaginary == False
+    assert Pow(E, 2*I*pi, evaluate=False).is_imaginary == False
+    assert Pow(E, I*pi/2, evaluate=False).is_imaginary == True
+    assert Pow(E, I*pi/3, evaluate=False).is_imaginary is None
+
+    assert exp(0, evaluate=False).is_algebraic
+
+    a = Symbol('a', algebraic=True)
+    an = Symbol('an', algebraic=True, nonzero=True)
+    r = Symbol('r', rational=True)
+    rn = Symbol('rn', rational=True, nonzero=True)
+    assert exp(a).is_algebraic is None
+    assert exp(an).is_algebraic is False
+    assert exp(pi*r).is_algebraic is None
+    assert exp(pi*rn).is_algebraic is False
+
+    assert exp(0, evaluate=False).is_algebraic is True
+    assert exp(I*pi/3, evaluate=False).is_algebraic is True
+    assert exp(I*pi*r, evaluate=False).is_algebraic is True
+
+
+@_both_exp_pow
+def test_exp_AccumBounds():
+    assert exp(AccumBounds(1, 2)) == AccumBounds(E, E**2)
+
+
+def test_log_assumptions():
+    p = symbols('p', positive=True)
+    n = symbols('n', negative=True)
+    z = symbols('z', zero=True)
+    x = symbols('x', infinite=True, extended_positive=True)
+
+    assert log(z).is_positive is False
+    assert log(x).is_extended_positive is True
+    assert log(2) > 0
+    assert log(1, evaluate=False).is_zero
+    assert log(1 + z).is_zero
+    assert log(p).is_zero is None
+    assert log(n).is_zero is False
+    assert log(0.5).is_negative is True
+    assert log(exp(p) + 1).is_positive
+
+    assert log(1, evaluate=False).is_algebraic
+    assert log(42, evaluate=False).is_algebraic is False
+
+    assert log(1 + z).is_rational
+
+
+def test_log_hashing():
+    assert x != log(log(x))
+    assert hash(x) != hash(log(log(x)))
+    assert log(x) != log(log(log(x)))
+
+    e = 1/log(log(x) + log(log(x)))
+    assert e.base.func is log
+    e = 1/log(log(x) + log(log(log(x))))
+    assert e.base.func is log
+
+    e = log(log(x))
+    assert e.func is log
+    assert x.func is not log
+    assert hash(log(log(x))) != hash(x)
+    assert e != x
+
+
+def test_log_sign():
+    assert sign(log(2)) == 1
+
+
+def test_log_expand_complex():
+    assert log(1 + I).expand(complex=True) == log(2)/2 + I*pi/4
+    assert log(1 - sqrt(2)).expand(complex=True) == log(sqrt(2) - 1) + I*pi
+
+
+def test_log_apply_evalf():
+    value = (log(3)/log(2) - 1).evalf()
+    assert value.epsilon_eq(Float("0.58496250072115618145373"))
+
+
+def test_log_leading_term():
+    p = Symbol('p')
+
+    # Test for STEP 3
+    assert log(1 + x + x**2).as_leading_term(x, cdir=1) == x
+    # Test for STEP 4
+    assert log(2*x).as_leading_term(x, cdir=1) == log(x) + log(2)
+    assert log(2*x).as_leading_term(x, cdir=-1) == log(x) + log(2)
+    assert log(-2*x).as_leading_term(x, cdir=1, logx=p) == p + log(2) + I*pi
+    assert log(-2*x).as_leading_term(x, cdir=-1, logx=p) == p + log(2) - I*pi
+    # Test for STEP 5
+    assert log(-2*x + (3 - I)*x**2).as_leading_term(x, cdir=1) == log(x) + log(2) - I*pi
+    assert log(-2*x + (3 - I)*x**2).as_leading_term(x, cdir=-1) == log(x) + log(2) - I*pi
+    assert log(2*x + (3 - I)*x**2).as_leading_term(x, cdir=1) == log(x) + log(2)
+    assert log(2*x + (3 - I)*x**2).as_leading_term(x, cdir=-1) == log(x) + log(2) - 2*I*pi
+    assert log(-1 + x - I*x**2 + I*x**3).as_leading_term(x, cdir=1) == -I*pi
+    assert log(-1 + x - I*x**2 + I*x**3).as_leading_term(x, cdir=-1) == -I*pi
+    assert log(-1/(1 - x)).as_leading_term(x, cdir=1) == I*pi
+    assert log(-1/(1 - x)).as_leading_term(x, cdir=-1) == I*pi
+
+
+def test_log_nseries():
+    p = Symbol('p')
+    assert log(1/x)._eval_nseries(x, 4, logx=-p, cdir=1) == p
+    assert log(1/x)._eval_nseries(x, 4, logx=-p, cdir=-1) == p + 2*I*pi
+    assert log(x - 1)._eval_nseries(x, 4, None, I) == I*pi - x - x**2/2 - x**3/3 + O(x**4)
+    assert log(x - 1)._eval_nseries(x, 4, None, -I) == -I*pi - x - x**2/2 - x**3/3 + O(x**4)
+    assert log(I*x + I*x**3 - 1)._eval_nseries(x, 3, None, 1) == I*pi - I*x + x**2/2 + O(x**3)
+    assert log(I*x + I*x**3 - 1)._eval_nseries(x, 3, None, -1) == -I*pi - I*x + x**2/2 + O(x**3)
+    assert log(I*x**2 + I*x**3 - 1)._eval_nseries(x, 3, None, 1) == I*pi - I*x**2 + O(x**3)
+    assert log(I*x**2 + I*x**3 - 1)._eval_nseries(x, 3, None, -1) == I*pi - I*x**2 + O(x**3)
+    assert log(2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, 1) == log(2) + log(x) + \
+    x*(S(3)/2 - I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, -1) == -2*I*pi + log(2) + \
+    log(x) - x*(-S(3)/2 + I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(-2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, 1) == -I*pi + log(2) + log(x) + \
+    x*(-S(3)/2 + I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(-2*x + (3 - I)*x**2)._eval_nseries(x, 3, None, -1) == -I*pi + log(2) + log(x) - \
+    x*(S(3)/2 - I/2) + x**2*(-1 + 3*I/4) + O(x**3)
+    assert log(sqrt(-I*x**2 - 3)*sqrt(-I*x**2 - 1) - 2)._eval_nseries(x, 3, None, 1) == -I*pi + \
+    log(sqrt(3) + 2) + 2*sqrt(3)*I*x**2/(3*sqrt(3) + 6) + O(x**3)
+    assert log(-1/(1 - x))._eval_nseries(x, 3, None, 1) == I*pi + x + x**2/2 + O(x**3)
+    assert log(-1/(1 - x))._eval_nseries(x, 3, None, -1) == I*pi + x + x**2/2 + O(x**3)
+
+
+def test_log_series():
+    # Note Series at infinities other than oo/-oo were introduced as a part of
+    # pull request 23798. Refer https://github.com/sympy/sympy/pull/23798 for
+    # more information.
+    expr1 = log(1 + x)
+    expr2 = log(x + sqrt(x**2 + 1))
+
+    assert expr1.series(x, x0=I*oo, n=4) == 1/(3*x**3) - 1/(2*x**2) + 1/x + \
+    I*pi/2 - log(I/x) + O(x**(-4), (x, oo*I))
+    assert expr1.series(x, x0=-I*oo, n=4) == 1/(3*x**3) - 1/(2*x**2) + 1/x - \
+    I*pi/2 - log(-I/x) + O(x**(-4), (x, -oo*I))
+    assert expr2.series(x, x0=I*oo, n=4) == 1/(4*x**2) + I*pi/2 + log(2) - \
+    log(I/x) + O(x**(-4), (x, oo*I))
+    assert expr2.series(x, x0=-I*oo, n=4) == -1/(4*x**2) - I*pi/2 - log(2) + \
+    log(-I/x) + O(x**(-4), (x, -oo*I))
+
+
+def test_log_expand():
+    w = Symbol("w", positive=True)
+    e = log(w**(log(5)/log(3)))
+    assert e.expand() == log(5)/log(3) * log(w)
+    x, y, z = symbols('x,y,z', positive=True)
+    assert log(x*(y + z)).expand(mul=False) == log(x) + log(y + z)
+    assert log(log(x**2)*log(y*z)).expand() in [log(2*log(x)*log(y) +
+        2*log(x)*log(z)), log(log(x)*log(z) + log(y)*log(x)) + log(2),
+        log((log(y) + log(z))*log(x)) + log(2)]
+    assert log(x**log(x**2)).expand(deep=False) == log(x)*log(x**2)
+    assert log(x**log(x**2)).expand() == 2*log(x)**2
+    x, y = symbols('x,y')
+    assert log(x*y).expand(force=True) == log(x) + log(y)
+    assert log(x**y).expand(force=True) == y*log(x)
+    assert log(exp(x)).expand(force=True) == x
+
+    # there's generally no need to expand out logs since this requires
+    # factoring and if simplification is sought, it's cheaper to put
+    # logs together than it is to take them apart.
+    assert log(2*3**2).expand() != 2*log(3) + log(2)
+
+
+@XFAIL
+def test_log_expand_fail():
+    x, y, z = symbols('x,y,z', positive=True)
+    assert (log(x*(y + z))*(x + y)).expand(mul=True, log=True) == y*log(
+        x) + y*log(y + z) + z*log(x) + z*log(y + z)
+
+
+def test_log_simplify():
+    x = Symbol("x", positive=True)
+    assert log(x**2).expand() == 2*log(x)
+    assert expand_log(log(x**(2 + log(2)))) == (2 + log(2))*log(x)
+
+    z = Symbol('z')
+    assert log(sqrt(z)).expand() == log(z)/2
+    assert expand_log(log(z**(log(2) - 1))) == (log(2) - 1)*log(z)
+    assert log(z**(-1)).expand() != -log(z)
+    assert log(z**(x/(x+1))).expand() == x*log(z)/(x + 1)
+
+
+def test_log_AccumBounds():
+    assert log(AccumBounds(1, E)) == AccumBounds(0, 1)
+    assert log(AccumBounds(0, E)) == AccumBounds(-oo, 1)
+    assert log(AccumBounds(-1, E)) == S.NaN
+    assert log(AccumBounds(0, oo)) == AccumBounds(-oo, oo)
+    assert log(AccumBounds(-oo, 0)) == S.NaN
+    assert log(AccumBounds(-oo, oo)) == S.NaN
+
+
+@_both_exp_pow
+def test_lambertw():
+    k = Symbol('k')
+
+    assert LambertW(x, 0) == LambertW(x)
+    assert LambertW(x, 0, evaluate=False) != LambertW(x)
+    assert LambertW(0) == 0
+    assert LambertW(E) == 1
+    assert LambertW(-1/E) == -1
+    assert LambertW(-log(2)/2) == -log(2)
+    assert LambertW(oo) is oo
+    assert LambertW(0, 1) is -oo
+    assert LambertW(0, 42) is -oo
+    assert LambertW(-pi/2, -1) == -I*pi/2
+    assert LambertW(-1/E, -1) == -1
+    assert LambertW(-2*exp(-2), -1) == -2
+    assert LambertW(2*log(2)) == log(2)
+    assert LambertW(-pi/2) == I*pi/2
+    assert LambertW(exp(1 + E)) == E
+
+    assert LambertW(x**2).diff(x) == 2*LambertW(x**2)/x/(1 + LambertW(x**2))
+    assert LambertW(x, k).diff(x) == LambertW(x, k)/x/(1 + LambertW(x, k))
+
+    assert LambertW(sqrt(2)).evalf(30).epsilon_eq(
+        Float("0.701338383413663009202120278965", 30), 1e-29)
+    assert re(LambertW(2, -1)).evalf().epsilon_eq(Float("-0.834310366631110"))
+
+    assert LambertW(-1).is_real is False  # issue 5215
+    assert LambertW(2, evaluate=False).is_real
+    p = Symbol('p', positive=True)
+    assert LambertW(p, evaluate=False).is_real
+    assert LambertW(p - 1, evaluate=False).is_real is None
+    assert LambertW(-p - 2/S.Exp1, evaluate=False).is_real is False
+    assert LambertW(S.Half, -1, evaluate=False).is_real is False
+    assert LambertW(Rational(-1, 10), -1, evaluate=False).is_real
+    assert LambertW(-10, -1, evaluate=False).is_real is False
+    assert LambertW(-2, 2, evaluate=False).is_real is False
+
+    assert LambertW(0, evaluate=False).is_algebraic
+    na = Symbol('na', nonzero=True, algebraic=True)
+    assert LambertW(na).is_algebraic is False
+    assert LambertW(p).is_zero is False
+    n = Symbol('n', negative=True)
+    assert LambertW(n).is_zero is False
+
+
+def test_issue_5673():
+    e = LambertW(-1)
+    assert e.is_comparable is False
+    assert e.is_positive is not True
+    e2 = 1 - 1/(1 - exp(-1000))
+    assert e2.is_positive is not True
+    e3 = -2 + exp(exp(LambertW(log(2)))*LambertW(log(2)))
+    assert e3.is_nonzero is not True
+
+
+def test_log_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: log(x).fdiff(2))
+
+
+def test_log_taylor_term():
+    x = symbols('x')
+    assert log(x).taylor_term(0, x) == x
+    assert log(x).taylor_term(1, x) == -x**2/2
+    assert log(x).taylor_term(4, x) == x**5/5
+    assert log(x).taylor_term(-1, x) is S.Zero
+
+
+def test_exp_expand_NC():
+    A, B, C = symbols('A,B,C', commutative=False)
+
+    assert exp(A + B).expand() == exp(A + B)
+    assert exp(A + B + C).expand() == exp(A + B + C)
+    assert exp(x + y).expand() == exp(x)*exp(y)
+    assert exp(x + y + z).expand() == exp(x)*exp(y)*exp(z)
+
+
+@_both_exp_pow
+def test_as_numer_denom():
+    n = symbols('n', negative=True)
+    assert exp(x).as_numer_denom() == (exp(x), 1)
+    assert exp(-x).as_numer_denom() == (1, exp(x))
+    assert exp(-2*x).as_numer_denom() == (1, exp(2*x))
+    assert exp(-2).as_numer_denom() == (1, exp(2))
+    assert exp(n).as_numer_denom() == (1, exp(-n))
+    assert exp(-n).as_numer_denom() == (exp(-n), 1)
+    assert exp(-I*x).as_numer_denom() == (1, exp(I*x))
+    assert exp(-I*n).as_numer_denom() == (1, exp(I*n))
+    assert exp(-n).as_numer_denom() == (exp(-n), 1)
+    # Check noncommutativity
+    a = symbols('a', commutative=False)
+    assert exp(-a).as_numer_denom() == (exp(-a), 1)
+
+
+@_both_exp_pow
+def test_polar():
+    x, y = symbols('x y', polar=True)
+
+    assert abs(exp_polar(I*4)) == 1
+    assert abs(exp_polar(0)) == 1
+    assert abs(exp_polar(2 + 3*I)) == exp(2)
+    assert exp_polar(I*10).n() == exp_polar(I*10)
+
+    assert log(exp_polar(z)) == z
+    assert log(x*y).expand() == log(x) + log(y)
+    assert log(x**z).expand() == z*log(x)
+
+    assert exp_polar(3).exp == 3
+
+    # Compare exp(1.0*pi*I).
+    assert (exp_polar(1.0*pi*I).n(n=5)).as_real_imag()[1] >= 0
+
+    assert exp_polar(0).is_rational is True  # issue 8008
+
+
+def test_exp_summation():
+    w = symbols("w")
+    m, n, i, j = symbols("m n i j")
+    expr = exp(Sum(w*i, (i, 0, n), (j, 0, m)))
+    assert expr.expand() == Product(exp(w*i), (i, 0, n), (j, 0, m))
+
+
+def test_log_product():
+    from sympy.abc import n, m
+
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    z = symbols('z', real=True)
+    w = symbols('w')
+
+    expr = log(Product(x**i, (i, 1, n)))
+    assert simplify(expr) == expr
+    assert expr.expand() == Sum(i*log(x), (i, 1, n))
+    expr = log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))
+    assert simplify(expr) == expr
+    assert expr.expand() == Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+    expr = log(Product(-2, (n, 0, 4)))
+    assert simplify(expr) == expr
+    assert expr.expand() == expr
+    assert expr.expand(force=True) == Sum(log(-2), (n, 0, 4))
+
+    expr = log(Product(exp(z*i), (i, 0, n)))
+    assert expr.expand() == Sum(z*i, (i, 0, n))
+
+    expr = log(Product(exp(w*i), (i, 0, n)))
+    assert expr.expand() == expr
+    assert expr.expand(force=True) == Sum(w*i, (i, 0, n))
+
+    expr = log(Product(i**2*abs(j), (i, 1, n), (j, 1, m)))
+    assert expr.expand() == Sum(2*log(i) + log(j), (i, 1, n), (j, 1, m))
+
+
+@XFAIL
+def test_log_product_simplify_to_sum():
+    from sympy.abc import n, m
+    i, j = symbols('i,j', positive=True, integer=True)
+    x, y = symbols('x,y', positive=True)
+    assert simplify(log(Product(x**i, (i, 1, n)))) == Sum(i*log(x), (i, 1, n))
+    assert simplify(log(Product(x**i*y**j, (i, 1, n), (j, 1, m)))) == \
+            Sum(i*log(x) + j*log(y), (i, 1, n), (j, 1, m))
+
+
+def test_issue_8866():
+    assert simplify(log(x, 10, evaluate=False)) == simplify(log(x, 10))
+    assert expand_log(log(x, 10, evaluate=False)) == expand_log(log(x, 10))
+
+    y = Symbol('y', positive=True)
+    l1 = log(exp(y), exp(10))
+    b1 = log(exp(y), exp(5))
+    l2 = log(exp(y), exp(10), evaluate=False)
+    b2 = log(exp(y), exp(5), evaluate=False)
+    assert simplify(log(l1, b1)) == simplify(log(l2, b2))
+    assert expand_log(log(l1, b1)) == expand_log(log(l2, b2))
+
+
+def test_log_expand_factor():
+    assert (log(18)/log(3) - 2).expand(factor=True) == log(2)/log(3)
+    assert (log(12)/log(2)).expand(factor=True) == log(3)/log(2) + 2
+    assert (log(15)/log(3)).expand(factor=True) == 1 + log(5)/log(3)
+    assert (log(2)/(-log(12) + log(24))).expand(factor=True) == 1
+
+    assert expand_log(log(12), factor=True) == log(3) + 2*log(2)
+    assert expand_log(log(21)/log(7), factor=False) == log(3)/log(7) + 1
+    assert expand_log(log(45)/log(5) + log(20), factor=False) == \
+        1 + 2*log(3)/log(5) + log(20)
+    assert expand_log(log(45)/log(5) + log(26), factor=True) == \
+        log(2) + log(13) + (log(5) + 2*log(3))/log(5)
+
+
+def test_issue_9116():
+    n = Symbol('n', positive=True, integer=True)
+    assert log(n).is_nonnegative is True
+
+
+def test_issue_18473():
+    assert exp(x*log(cos(1/x))).as_leading_term(x) == S.NaN
+    assert exp(x*log(tan(1/x))).as_leading_term(x) == S.NaN
+    assert log(cos(1/x)).as_leading_term(x) == S.NaN
+    assert log(tan(1/x)).as_leading_term(x) == S.NaN
+    assert log(cos(1/x) + 2).as_leading_term(x) == AccumBounds(0, log(3))
+    assert exp(x*log(cos(1/x) + 2)).as_leading_term(x) == 1
+    assert log(cos(1/x) - 2).as_leading_term(x) == S.NaN
+    assert exp(x*log(cos(1/x) - 2)).as_leading_term(x) == S.NaN
+    assert log(cos(1/x) + 1).as_leading_term(x) == AccumBounds(-oo, log(2))
+    assert exp(x*log(cos(1/x) + 1)).as_leading_term(x) == AccumBounds(0, 1)
+    assert log(sin(1/x)**2).as_leading_term(x) == AccumBounds(-oo, 0)
+    assert exp(x*log(sin(1/x)**2)).as_leading_term(x) == AccumBounds(0, 1)
+    assert log(tan(1/x)**2).as_leading_term(x) == AccumBounds(-oo, oo)
+    assert exp(2*x*(log(tan(1/x)**2))).as_leading_term(x) == AccumBounds(0, oo)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_hyperbolic.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_hyperbolic.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ad9f1d51598b9d605b0472e254c5a710d4ed4f5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_hyperbolic.py
@@ -0,0 +1,1553 @@
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.function import (expand_mul, expand_trig)
+from sympy.core.numbers import (E, I, Integer, Rational, nan, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acosh, acoth, acsch, asech, asinh, atanh, cosh, coth, csch, sech, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, asin, cos, cot, sec, sin, tan)
+from sympy.series.order import O
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError, PoleError
+from sympy.testing.pytest import raises
+
+
+def test_sinh():
+    x, y = symbols('x,y')
+
+    k = Symbol('k', integer=True)
+
+    assert sinh(nan) is nan
+    assert sinh(zoo) is nan
+
+    assert sinh(oo) is oo
+    assert sinh(-oo) is -oo
+
+    assert sinh(0) == 0
+
+    assert unchanged(sinh, 1)
+    assert sinh(-1) == -sinh(1)
+
+    assert unchanged(sinh, x)
+    assert sinh(-x) == -sinh(x)
+
+    assert unchanged(sinh, pi)
+    assert sinh(-pi) == -sinh(pi)
+
+    assert unchanged(sinh, 2**1024 * E)
+    assert sinh(-2**1024 * E) == -sinh(2**1024 * E)
+
+    assert sinh(pi*I) == 0
+    assert sinh(-pi*I) == 0
+    assert sinh(2*pi*I) == 0
+    assert sinh(-2*pi*I) == 0
+    assert sinh(-3*10**73*pi*I) == 0
+    assert sinh(7*10**103*pi*I) == 0
+
+    assert sinh(pi*I/2) == I
+    assert sinh(-pi*I/2) == -I
+    assert sinh(pi*I*Rational(5, 2)) == I
+    assert sinh(pi*I*Rational(7, 2)) == -I
+
+    assert sinh(pi*I/3) == S.Half*sqrt(3)*I
+    assert sinh(pi*I*Rational(-2, 3)) == Rational(-1, 2)*sqrt(3)*I
+
+    assert sinh(pi*I/4) == S.Half*sqrt(2)*I
+    assert sinh(-pi*I/4) == Rational(-1, 2)*sqrt(2)*I
+    assert sinh(pi*I*Rational(17, 4)) == S.Half*sqrt(2)*I
+    assert sinh(pi*I*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)*I
+
+    assert sinh(pi*I/6) == S.Half*I
+    assert sinh(-pi*I/6) == Rational(-1, 2)*I
+    assert sinh(pi*I*Rational(7, 6)) == Rational(-1, 2)*I
+    assert sinh(pi*I*Rational(-5, 6)) == Rational(-1, 2)*I
+
+    assert sinh(pi*I/105) == sin(pi/105)*I
+    assert sinh(-pi*I/105) == -sin(pi/105)*I
+
+    assert unchanged(sinh, 2 + 3*I)
+
+    assert sinh(x*I) == sin(x)*I
+
+    assert sinh(k*pi*I) == 0
+    assert sinh(17*k*pi*I) == 0
+
+    assert sinh(k*pi*I/2) == sin(k*pi/2)*I
+
+    assert sinh(x).as_real_imag(deep=False) == (cos(im(x))*sinh(re(x)),
+                sin(im(x))*cosh(re(x)))
+    x = Symbol('x', extended_real=True)
+    assert sinh(x).as_real_imag(deep=False) == (sinh(x), 0)
+
+    x = Symbol('x', real=True)
+    assert sinh(I*x).is_finite is True
+    assert sinh(x).is_real is True
+    assert sinh(I).is_real is False
+    p = Symbol('p', positive=True)
+    assert sinh(p).is_zero is False
+    assert sinh(0, evaluate=False).is_zero is True
+    assert sinh(2*pi*I, evaluate=False).is_zero is True
+
+
+def test_sinh_series():
+    x = Symbol('x')
+    assert sinh(x).series(x, 0, 10) == \
+        x + x**3/6 + x**5/120 + x**7/5040 + x**9/362880 + O(x**10)
+
+
+def test_sinh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: sinh(x).fdiff(2))
+
+
+def test_cosh():
+    x, y = symbols('x,y')
+
+    k = Symbol('k', integer=True)
+
+    assert cosh(nan) is nan
+    assert cosh(zoo) is nan
+
+    assert cosh(oo) is oo
+    assert cosh(-oo) is oo
+
+    assert cosh(0) == 1
+
+    assert unchanged(cosh, 1)
+    assert cosh(-1) == cosh(1)
+
+    assert unchanged(cosh, x)
+    assert cosh(-x) == cosh(x)
+
+    assert cosh(pi*I) == cos(pi)
+    assert cosh(-pi*I) == cos(pi)
+
+    assert unchanged(cosh, 2**1024 * E)
+    assert cosh(-2**1024 * E) == cosh(2**1024 * E)
+
+    assert cosh(pi*I/2) == 0
+    assert cosh(-pi*I/2) == 0
+    assert cosh((-3*10**73 + 1)*pi*I/2) == 0
+    assert cosh((7*10**103 + 1)*pi*I/2) == 0
+
+    assert cosh(pi*I) == -1
+    assert cosh(-pi*I) == -1
+    assert cosh(5*pi*I) == -1
+    assert cosh(8*pi*I) == 1
+
+    assert cosh(pi*I/3) == S.Half
+    assert cosh(pi*I*Rational(-2, 3)) == Rational(-1, 2)
+
+    assert cosh(pi*I/4) == S.Half*sqrt(2)
+    assert cosh(-pi*I/4) == S.Half*sqrt(2)
+    assert cosh(pi*I*Rational(11, 4)) == Rational(-1, 2)*sqrt(2)
+    assert cosh(pi*I*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)
+
+    assert cosh(pi*I/6) == S.Half*sqrt(3)
+    assert cosh(-pi*I/6) == S.Half*sqrt(3)
+    assert cosh(pi*I*Rational(7, 6)) == Rational(-1, 2)*sqrt(3)
+    assert cosh(pi*I*Rational(-5, 6)) == Rational(-1, 2)*sqrt(3)
+
+    assert cosh(pi*I/105) == cos(pi/105)
+    assert cosh(-pi*I/105) == cos(pi/105)
+
+    assert unchanged(cosh, 2 + 3*I)
+
+    assert cosh(x*I) == cos(x)
+
+    assert cosh(k*pi*I) == cos(k*pi)
+    assert cosh(17*k*pi*I) == cos(17*k*pi)
+
+    assert unchanged(cosh, k*pi)
+
+    assert cosh(x).as_real_imag(deep=False) == (cos(im(x))*cosh(re(x)),
+                sin(im(x))*sinh(re(x)))
+    x = Symbol('x', extended_real=True)
+    assert cosh(x).as_real_imag(deep=False) == (cosh(x), 0)
+
+    x = Symbol('x', real=True)
+    assert cosh(I*x).is_finite is True
+    assert cosh(I*x).is_real is True
+    assert cosh(I*2 + 1).is_real is False
+    assert cosh(5*I*S.Pi/2, evaluate=False).is_zero is True
+    assert cosh(x).is_zero is False
+
+
+def test_cosh_series():
+    x = Symbol('x')
+    assert cosh(x).series(x, 0, 10) == \
+        1 + x**2/2 + x**4/24 + x**6/720 + x**8/40320 + O(x**10)
+
+
+def test_cosh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: cosh(x).fdiff(2))
+
+
+def test_tanh():
+    x, y = symbols('x,y')
+
+    k = Symbol('k', integer=True)
+
+    assert tanh(nan) is nan
+    assert tanh(zoo) is nan
+
+    assert tanh(oo) == 1
+    assert tanh(-oo) == -1
+
+    assert tanh(0) == 0
+
+    assert unchanged(tanh, 1)
+    assert tanh(-1) == -tanh(1)
+
+    assert unchanged(tanh, x)
+    assert tanh(-x) == -tanh(x)
+
+    assert unchanged(tanh, pi)
+    assert tanh(-pi) == -tanh(pi)
+
+    assert unchanged(tanh, 2**1024 * E)
+    assert tanh(-2**1024 * E) == -tanh(2**1024 * E)
+
+    assert tanh(pi*I) == 0
+    assert tanh(-pi*I) == 0
+    assert tanh(2*pi*I) == 0
+    assert tanh(-2*pi*I) == 0
+    assert tanh(-3*10**73*pi*I) == 0
+    assert tanh(7*10**103*pi*I) == 0
+
+    assert tanh(pi*I/2) is zoo
+    assert tanh(-pi*I/2) is zoo
+    assert tanh(pi*I*Rational(5, 2)) is zoo
+    assert tanh(pi*I*Rational(7, 2)) is zoo
+
+    assert tanh(pi*I/3) == sqrt(3)*I
+    assert tanh(pi*I*Rational(-2, 3)) == sqrt(3)*I
+
+    assert tanh(pi*I/4) == I
+    assert tanh(-pi*I/4) == -I
+    assert tanh(pi*I*Rational(17, 4)) == I
+    assert tanh(pi*I*Rational(-3, 4)) == I
+
+    assert tanh(pi*I/6) == I/sqrt(3)
+    assert tanh(-pi*I/6) == -I/sqrt(3)
+    assert tanh(pi*I*Rational(7, 6)) == I/sqrt(3)
+    assert tanh(pi*I*Rational(-5, 6)) == I/sqrt(3)
+
+    assert tanh(pi*I/105) == tan(pi/105)*I
+    assert tanh(-pi*I/105) == -tan(pi/105)*I
+
+    assert unchanged(tanh, 2 + 3*I)
+
+    assert tanh(x*I) == tan(x)*I
+
+    assert tanh(k*pi*I) == 0
+    assert tanh(17*k*pi*I) == 0
+
+    assert tanh(k*pi*I/2) == tan(k*pi/2)*I
+
+    assert tanh(x).as_real_imag(deep=False) == (sinh(re(x))*cosh(re(x))/(cos(im(x))**2
+                                + sinh(re(x))**2),
+                                sin(im(x))*cos(im(x))/(cos(im(x))**2 + sinh(re(x))**2))
+    x = Symbol('x', extended_real=True)
+    assert tanh(x).as_real_imag(deep=False) == (tanh(x), 0)
+    assert tanh(I*pi/3 + 1).is_real is False
+    assert tanh(x).is_real is True
+    assert tanh(I*pi*x/2).is_real is None
+
+
+def test_tanh_series():
+    x = Symbol('x')
+    assert tanh(x).series(x, 0, 10) == \
+        x - x**3/3 + 2*x**5/15 - 17*x**7/315 + 62*x**9/2835 + O(x**10)
+
+
+def test_tanh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: tanh(x).fdiff(2))
+
+
+def test_coth():
+    x, y = symbols('x,y')
+
+    k = Symbol('k', integer=True)
+
+    assert coth(nan) is nan
+    assert coth(zoo) is nan
+
+    assert coth(oo) == 1
+    assert coth(-oo) == -1
+
+    assert coth(0) is zoo
+    assert unchanged(coth, 1)
+    assert coth(-1) == -coth(1)
+
+    assert unchanged(coth, x)
+    assert coth(-x) == -coth(x)
+
+    assert coth(pi*I) == -I*cot(pi)
+    assert coth(-pi*I) == cot(pi)*I
+
+    assert unchanged(coth, 2**1024 * E)
+    assert coth(-2**1024 * E) == -coth(2**1024 * E)
+
+    assert coth(pi*I) == -I*cot(pi)
+    assert coth(-pi*I) == I*cot(pi)
+    assert coth(2*pi*I) == -I*cot(2*pi)
+    assert coth(-2*pi*I) == I*cot(2*pi)
+    assert coth(-3*10**73*pi*I) == I*cot(3*10**73*pi)
+    assert coth(7*10**103*pi*I) == -I*cot(7*10**103*pi)
+
+    assert coth(pi*I/2) == 0
+    assert coth(-pi*I/2) == 0
+    assert coth(pi*I*Rational(5, 2)) == 0
+    assert coth(pi*I*Rational(7, 2)) == 0
+
+    assert coth(pi*I/3) == -I/sqrt(3)
+    assert coth(pi*I*Rational(-2, 3)) == -I/sqrt(3)
+
+    assert coth(pi*I/4) == -I
+    assert coth(-pi*I/4) == I
+    assert coth(pi*I*Rational(17, 4)) == -I
+    assert coth(pi*I*Rational(-3, 4)) == -I
+
+    assert coth(pi*I/6) == -sqrt(3)*I
+    assert coth(-pi*I/6) == sqrt(3)*I
+    assert coth(pi*I*Rational(7, 6)) == -sqrt(3)*I
+    assert coth(pi*I*Rational(-5, 6)) == -sqrt(3)*I
+
+    assert coth(pi*I/105) == -cot(pi/105)*I
+    assert coth(-pi*I/105) == cot(pi/105)*I
+
+    assert unchanged(coth, 2 + 3*I)
+
+    assert coth(x*I) == -cot(x)*I
+
+    assert coth(k*pi*I) == -cot(k*pi)*I
+    assert coth(17*k*pi*I) == -cot(17*k*pi)*I
+
+    assert coth(k*pi*I) == -cot(k*pi)*I
+
+    assert coth(log(tan(2))) == coth(log(-tan(2)))
+    assert coth(1 + I*pi/2) == tanh(1)
+
+    assert coth(x).as_real_imag(deep=False) == (sinh(re(x))*cosh(re(x))/(sin(im(x))**2
+                                + sinh(re(x))**2),
+                                -sin(im(x))*cos(im(x))/(sin(im(x))**2 + sinh(re(x))**2))
+    x = Symbol('x', extended_real=True)
+    assert coth(x).as_real_imag(deep=False) == (coth(x), 0)
+
+    assert expand_trig(coth(2*x)) == (coth(x)**2 + 1)/(2*coth(x))
+    assert expand_trig(coth(3*x)) == (coth(x)**3 + 3*coth(x))/(1 + 3*coth(x)**2)
+
+    assert expand_trig(coth(x + y)) == (1 + coth(x)*coth(y))/(coth(x) + coth(y))
+
+
+def test_coth_series():
+    x = Symbol('x')
+    assert coth(x).series(x, 0, 8) == \
+        1/x + x/3 - x**3/45 + 2*x**5/945 - x**7/4725 + O(x**8)
+
+
+def test_coth_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: coth(x).fdiff(2))
+
+
+def test_csch():
+    x, y = symbols('x,y')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', positive=True)
+
+    assert csch(nan) is nan
+    assert csch(zoo) is nan
+
+    assert csch(oo) == 0
+    assert csch(-oo) == 0
+
+    assert csch(0) is zoo
+
+    assert csch(-1) == -csch(1)
+
+    assert csch(-x) == -csch(x)
+    assert csch(-pi) == -csch(pi)
+    assert csch(-2**1024 * E) == -csch(2**1024 * E)
+
+    assert csch(pi*I) is zoo
+    assert csch(-pi*I) is zoo
+    assert csch(2*pi*I) is zoo
+    assert csch(-2*pi*I) is zoo
+    assert csch(-3*10**73*pi*I) is zoo
+    assert csch(7*10**103*pi*I) is zoo
+
+    assert csch(pi*I/2) == -I
+    assert csch(-pi*I/2) == I
+    assert csch(pi*I*Rational(5, 2)) == -I
+    assert csch(pi*I*Rational(7, 2)) == I
+
+    assert csch(pi*I/3) == -2/sqrt(3)*I
+    assert csch(pi*I*Rational(-2, 3)) == 2/sqrt(3)*I
+
+    assert csch(pi*I/4) == -sqrt(2)*I
+    assert csch(-pi*I/4) == sqrt(2)*I
+    assert csch(pi*I*Rational(7, 4)) == sqrt(2)*I
+    assert csch(pi*I*Rational(-3, 4)) == sqrt(2)*I
+
+    assert csch(pi*I/6) == -2*I
+    assert csch(-pi*I/6) == 2*I
+    assert csch(pi*I*Rational(7, 6)) == 2*I
+    assert csch(pi*I*Rational(-7, 6)) == -2*I
+    assert csch(pi*I*Rational(-5, 6)) == 2*I
+
+    assert csch(pi*I/105) == -1/sin(pi/105)*I
+    assert csch(-pi*I/105) == 1/sin(pi/105)*I
+
+    assert csch(x*I) == -1/sin(x)*I
+
+    assert csch(k*pi*I) is zoo
+    assert csch(17*k*pi*I) is zoo
+
+    assert csch(k*pi*I/2) == -1/sin(k*pi/2)*I
+
+    assert csch(n).is_real is True
+
+    assert expand_trig(csch(x + y)) == 1/(sinh(x)*cosh(y) + cosh(x)*sinh(y))
+
+
+def test_csch_series():
+    x = Symbol('x')
+    assert csch(x).series(x, 0, 10) == \
+       1/ x - x/6 + 7*x**3/360 - 31*x**5/15120 + 127*x**7/604800 \
+          - 73*x**9/3421440 + O(x**10)
+
+
+def test_csch_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: csch(x).fdiff(2))
+
+
+def test_sech():
+    x, y = symbols('x, y')
+
+    k = Symbol('k', integer=True)
+    n = Symbol('n', positive=True)
+
+    assert sech(nan) is nan
+    assert sech(zoo) is nan
+
+    assert sech(oo) == 0
+    assert sech(-oo) == 0
+
+    assert sech(0) == 1
+
+    assert sech(-1) == sech(1)
+    assert sech(-x) == sech(x)
+
+    assert sech(pi*I) == sec(pi)
+
+    assert sech(-pi*I) == sec(pi)
+    assert sech(-2**1024 * E) == sech(2**1024 * E)
+
+    assert sech(pi*I/2) is zoo
+    assert sech(-pi*I/2) is zoo
+    assert sech((-3*10**73 + 1)*pi*I/2) is zoo
+    assert sech((7*10**103 + 1)*pi*I/2) is zoo
+
+    assert sech(pi*I) == -1
+    assert sech(-pi*I) == -1
+    assert sech(5*pi*I) == -1
+    assert sech(8*pi*I) == 1
+
+    assert sech(pi*I/3) == 2
+    assert sech(pi*I*Rational(-2, 3)) == -2
+
+    assert sech(pi*I/4) == sqrt(2)
+    assert sech(-pi*I/4) == sqrt(2)
+    assert sech(pi*I*Rational(5, 4)) == -sqrt(2)
+    assert sech(pi*I*Rational(-5, 4)) == -sqrt(2)
+
+    assert sech(pi*I/6) == 2/sqrt(3)
+    assert sech(-pi*I/6) == 2/sqrt(3)
+    assert sech(pi*I*Rational(7, 6)) == -2/sqrt(3)
+    assert sech(pi*I*Rational(-5, 6)) == -2/sqrt(3)
+
+    assert sech(pi*I/105) == 1/cos(pi/105)
+    assert sech(-pi*I/105) == 1/cos(pi/105)
+
+    assert sech(x*I) == 1/cos(x)
+
+    assert sech(k*pi*I) == 1/cos(k*pi)
+    assert sech(17*k*pi*I) == 1/cos(17*k*pi)
+
+    assert sech(n).is_real is True
+
+    assert expand_trig(sech(x + y)) == 1/(cosh(x)*cosh(y) + sinh(x)*sinh(y))
+
+
+def test_sech_series():
+    x = Symbol('x')
+    assert sech(x).series(x, 0, 10) == \
+        1 - x**2/2 + 5*x**4/24 - 61*x**6/720 + 277*x**8/8064 + O(x**10)
+
+
+def test_sech_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: sech(x).fdiff(2))
+
+
+def test_asinh():
+    x, y = symbols('x,y')
+    assert unchanged(asinh, x)
+    assert asinh(-x) == -asinh(x)
+
+    # at specific points
+    assert asinh(nan) is nan
+    assert asinh( 0) == 0
+    assert asinh(+1) == log(sqrt(2) + 1)
+
+    assert asinh(-1) == log(sqrt(2) - 1)
+    assert asinh(I) == pi*I/2
+    assert asinh(-I) == -pi*I/2
+    assert asinh(I/2) == pi*I/6
+    assert asinh(-I/2) == -pi*I/6
+
+    # at infinites
+    assert asinh(oo) is oo
+    assert asinh(-oo) is -oo
+
+    assert asinh(I*oo) is oo
+    assert asinh(-I *oo) is -oo
+
+    assert asinh(zoo) is zoo
+
+    # properties
+    assert asinh(I *(sqrt(3) - 1)/(2**Rational(3, 2))) == pi*I/12
+    assert asinh(-I *(sqrt(3) - 1)/(2**Rational(3, 2))) == -pi*I/12
+
+    assert asinh(I*(sqrt(5) - 1)/4) == pi*I/10
+    assert asinh(-I*(sqrt(5) - 1)/4) == -pi*I/10
+
+    assert asinh(I*(sqrt(5) + 1)/4) == pi*I*Rational(3, 10)
+    assert asinh(-I*(sqrt(5) + 1)/4) == pi*I*Rational(-3, 10)
+
+    # reality
+    assert asinh(S(2)).is_real is True
+    assert asinh(S(2)).is_finite is True
+    assert asinh(S(-2)).is_real is True
+    assert asinh(S(oo)).is_extended_real is True
+    assert asinh(-S(oo)).is_real is False
+    assert (asinh(2) - oo) == -oo
+    assert asinh(symbols('y', real=True)).is_real is True
+
+    # Symmetry
+    assert asinh(Rational(-1, 2)) == -asinh(S.Half)
+
+    # inverse composition
+    assert unchanged(asinh, sinh(Symbol('v1')))
+
+    assert asinh(sinh(0, evaluate=False)) == 0
+    assert asinh(sinh(-3, evaluate=False)) == -3
+    assert asinh(sinh(2, evaluate=False)) == 2
+    assert asinh(sinh(I, evaluate=False)) == I
+    assert asinh(sinh(-I, evaluate=False)) == -I
+    assert asinh(sinh(5*I, evaluate=False)) == -2*I*pi + 5*I
+    assert asinh(sinh(15 + 11*I)) == 15 - 4*I*pi + 11*I
+    assert asinh(sinh(-73 + 97*I)) == 73 - 97*I + 31*I*pi
+    assert asinh(sinh(-7 - 23*I)) == 7 - 7*I*pi + 23*I
+    assert asinh(sinh(13 - 3*I)) == -13 - I*pi + 3*I
+    p = Symbol('p', positive=True)
+    assert asinh(p).is_zero is False
+    assert asinh(sinh(0, evaluate=False), evaluate=False).is_zero is True
+
+
+def test_asinh_rewrite():
+    x = Symbol('x')
+    assert asinh(x).rewrite(log) == log(x + sqrt(x**2 + 1))
+    assert asinh(x).rewrite(atanh) == atanh(x/sqrt(1 + x**2))
+    assert asinh(x).rewrite(asin) == -I*asin(I*x, evaluate=False)
+    assert asinh(x*(1 + I)).rewrite(asin) == -I*asin(I*x*(1+I))
+    assert asinh(x).rewrite(acos) == I*acos(I*x, evaluate=False) - I*pi/2
+
+
+def test_asinh_leading_term():
+    x = Symbol('x')
+    assert asinh(x).as_leading_term(x, cdir=1) == x
+    # Tests concerning branch points
+    assert asinh(x + I).as_leading_term(x, cdir=1) == I*pi/2
+    assert asinh(x - I).as_leading_term(x, cdir=1) == -I*pi/2
+    assert asinh(1/x).as_leading_term(x, cdir=1) == -log(x) + log(2)
+    assert asinh(1/x).as_leading_term(x, cdir=-1) == log(x) - log(2) - I*pi
+    # Tests concerning points lying on branch cuts
+    assert asinh(x + 2*I).as_leading_term(x, cdir=1) == I*asin(2)
+    assert asinh(x + 2*I).as_leading_term(x, cdir=-1) == -I*asin(2) + I*pi
+    assert asinh(x - 2*I).as_leading_term(x, cdir=1) == -I*pi + I*asin(2)
+    assert asinh(x - 2*I).as_leading_term(x, cdir=-1) == -I*asin(2)
+    # Tests concerning re(ndir) == 0
+    assert asinh(2*I + I*x - x**2).as_leading_term(x, cdir=1) == log(2 - sqrt(3)) + I*pi/2
+    assert asinh(2*I + I*x - x**2).as_leading_term(x, cdir=-1) == log(2 - sqrt(3)) + I*pi/2
+
+
+def test_asinh_series():
+    x = Symbol('x')
+    assert asinh(x).series(x, 0, 8) == \
+        x - x**3/6 + 3*x**5/40 - 5*x**7/112 + O(x**8)
+    t5 = asinh(x).taylor_term(5, x)
+    assert t5 == 3*x**5/40
+    assert asinh(x).taylor_term(7, x, t5, 0) == -5*x**7/112
+
+
+def test_asinh_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert asinh(x + I)._eval_nseries(x, 4, None) == I*pi/2 - \
+    sqrt(2)*sqrt(I)*I*sqrt(x) + sqrt(2)*sqrt(I)*x**(S(3)/2)/12 + 3*sqrt(2)*sqrt(I)*I*x**(S(5)/2)/160 - \
+    5*sqrt(2)*sqrt(I)*x**(S(7)/2)/896 + O(x**4)
+    assert asinh(x - I)._eval_nseries(x, 4, None) == -I*pi/2 + \
+    sqrt(2)*I*sqrt(x)*sqrt(-I) + sqrt(2)*x**(S(3)/2)*sqrt(-I)/12 - \
+    3*sqrt(2)*I*x**(S(5)/2)*sqrt(-I)/160 - 5*sqrt(2)*x**(S(7)/2)*sqrt(-I)/896 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert asinh(x + 2*I)._eval_nseries(x, 4, None, cdir=1) == I*asin(2) - \
+    sqrt(3)*I*x/3 + sqrt(3)*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert asinh(x + 2*I)._eval_nseries(x, 4, None, cdir=-1) == I*pi - I*asin(2) + \
+    sqrt(3)*I*x/3 - sqrt(3)*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asinh(x - 2*I)._eval_nseries(x, 4, None, cdir=1) == I*asin(2) - I*pi + \
+    sqrt(3)*I*x/3 + sqrt(3)*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asinh(x - 2*I)._eval_nseries(x, 4, None, cdir=-1) == -I*asin(2) - \
+    sqrt(3)*I*x/3 - sqrt(3)*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    # Tests concerning re(ndir) == 0
+    assert asinh(2*I + I*x - x**2)._eval_nseries(x, 4, None) == I*pi/2 + log(2 - sqrt(3)) + \
+    x*(-3 + 2*sqrt(3))/(-6 + 3*sqrt(3)) + x**2*(12 - 36*I + sqrt(3)*(-7 + 21*I))/(-63 + \
+    36*sqrt(3)) + x**3*(-168 + sqrt(3)*(97 - 388*I) + 672*I)/(-1746 + 1008*sqrt(3)) + O(x**4)
+
+
+def test_asinh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: asinh(x).fdiff(2))
+
+
+def test_acosh():
+    x = Symbol('x')
+
+    assert unchanged(acosh, -x)
+
+    #at specific points
+    assert acosh(1) == 0
+    assert acosh(-1) == pi*I
+    assert acosh(0) == I*pi/2
+    assert acosh(S.Half) == I*pi/3
+    assert acosh(Rational(-1, 2)) == pi*I*Rational(2, 3)
+    assert acosh(nan) is nan
+
+    # at infinites
+    assert acosh(oo) is oo
+    assert acosh(-oo) is oo
+
+    assert acosh(I*oo) == oo + I*pi/2
+    assert acosh(-I*oo) == oo - I*pi/2
+
+    assert acosh(zoo) is zoo
+
+    assert acosh(I) == log(I*(1 + sqrt(2)))
+    assert acosh(-I) == log(-I*(1 + sqrt(2)))
+    assert acosh((sqrt(3) - 1)/(2*sqrt(2))) == pi*I*Rational(5, 12)
+    assert acosh(-(sqrt(3) - 1)/(2*sqrt(2))) == pi*I*Rational(7, 12)
+    assert acosh(sqrt(2)/2) == I*pi/4
+    assert acosh(-sqrt(2)/2) == I*pi*Rational(3, 4)
+    assert acosh(sqrt(3)/2) == I*pi/6
+    assert acosh(-sqrt(3)/2) == I*pi*Rational(5, 6)
+    assert acosh(sqrt(2 + sqrt(2))/2) == I*pi/8
+    assert acosh(-sqrt(2 + sqrt(2))/2) == I*pi*Rational(7, 8)
+    assert acosh(sqrt(2 - sqrt(2))/2) == I*pi*Rational(3, 8)
+    assert acosh(-sqrt(2 - sqrt(2))/2) == I*pi*Rational(5, 8)
+    assert acosh((1 + sqrt(3))/(2*sqrt(2))) == I*pi/12
+    assert acosh(-(1 + sqrt(3))/(2*sqrt(2))) == I*pi*Rational(11, 12)
+    assert acosh((sqrt(5) + 1)/4) == I*pi/5
+    assert acosh(-(sqrt(5) + 1)/4) == I*pi*Rational(4, 5)
+
+    assert str(acosh(5*I).n(6)) == '2.31244 + 1.5708*I'
+    assert str(acosh(-5*I).n(6)) == '2.31244 - 1.5708*I'
+
+    # inverse composition
+    assert unchanged(acosh, Symbol('v1'))
+
+    assert acosh(cosh(-3, evaluate=False)) == 3
+    assert acosh(cosh(3, evaluate=False)) == 3
+    assert acosh(cosh(0, evaluate=False)) == 0
+    assert acosh(cosh(I, evaluate=False)) == I
+    assert acosh(cosh(-I, evaluate=False)) == I
+    assert acosh(cosh(7*I, evaluate=False)) == -2*I*pi + 7*I
+    assert acosh(cosh(1 + I)) == 1 + I
+    assert acosh(cosh(3 - 3*I)) == 3 - 3*I
+    assert acosh(cosh(-3 + 2*I)) == 3 - 2*I
+    assert acosh(cosh(-5 - 17*I)) == 5 - 6*I*pi + 17*I
+    assert acosh(cosh(-21 + 11*I)) == 21 - 11*I + 4*I*pi
+    assert acosh(cosh(cosh(1) + I)) == cosh(1) + I
+    assert acosh(1, evaluate=False).is_zero is True
+
+    # Reality
+    assert acosh(S(2)).is_real is True
+    assert acosh(S(2)).is_extended_real is True
+    assert acosh(oo).is_extended_real is True
+    assert acosh(S(2)).is_finite is True
+    assert acosh(S(1) / 5).is_real is False
+    assert (acosh(2) - oo) == -oo
+    assert acosh(symbols('y', real=True)).is_real is None
+
+
+def test_acosh_rewrite():
+    x = Symbol('x')
+    assert acosh(x).rewrite(log) == log(x + sqrt(x - 1)*sqrt(x + 1))
+    assert acosh(x).rewrite(asin) == sqrt(x - 1)*(-asin(x) + pi/2)/sqrt(1 - x)
+    assert acosh(x).rewrite(asinh) == sqrt(x - 1)*(I*asinh(I*x, evaluate=False) + pi/2)/sqrt(1 - x)
+    assert acosh(x).rewrite(atanh) == \
+        (sqrt(x - 1)*sqrt(x + 1)*atanh(sqrt(x**2 - 1)/x)/sqrt(x**2 - 1) +
+         pi*sqrt(x - 1)*(-x*sqrt(x**(-2)) + 1)/(2*sqrt(1 - x)))
+    x = Symbol('x', positive=True)
+    assert acosh(x).rewrite(atanh) == \
+        sqrt(x - 1)*sqrt(x + 1)*atanh(sqrt(x**2 - 1)/x)/sqrt(x**2 - 1)
+
+
+def test_acosh_leading_term():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert acosh(x).as_leading_term(x) == I*pi/2
+    assert acosh(x + 1).as_leading_term(x) == sqrt(2)*sqrt(x)
+    assert acosh(x - 1).as_leading_term(x) == I*pi
+    assert acosh(1/x).as_leading_term(x, cdir=1) == -log(x) + log(2)
+    assert acosh(1/x).as_leading_term(x, cdir=-1) == -log(x) + log(2) + 2*I*pi
+    # Tests concerning points lying on branch cuts
+    assert acosh(I*x - 2).as_leading_term(x, cdir=1) == acosh(-2)
+    assert acosh(-I*x - 2).as_leading_term(x, cdir=1) == -2*I*pi + acosh(-2)
+    assert acosh(x**2 - I*x + S(1)/3).as_leading_term(x, cdir=1) == -acosh(S(1)/3)
+    assert acosh(x**2 - I*x + S(1)/3).as_leading_term(x, cdir=-1) == acosh(S(1)/3)
+    assert acosh(1/(I*x - 3)).as_leading_term(x, cdir=1) == -acosh(-S(1)/3)
+    assert acosh(1/(I*x - 3)).as_leading_term(x, cdir=-1) == acosh(-S(1)/3)
+    # Tests concerning im(ndir) == 0
+    assert acosh(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == log(sqrt(3) + 2) - I*pi
+    assert acosh(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == log(sqrt(3) + 2) - I*pi
+
+
+def test_acosh_series():
+    x = Symbol('x')
+    assert acosh(x).series(x, 0, 8) == \
+        -I*x + pi*I/2 - I*x**3/6 - 3*I*x**5/40 - 5*I*x**7/112 + O(x**8)
+    t5 = acosh(x).taylor_term(5, x)
+    assert t5 == - 3*I*x**5/40
+    assert acosh(x).taylor_term(7, x, t5, 0) == - 5*I*x**7/112
+
+
+def test_acosh_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert acosh(x + 1)._eval_nseries(x, 4, None) == sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/12 + 3*sqrt(2)*x**(S(5)/2)/160 - 5*sqrt(2)*x**(S(7)/2)/896 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert acosh(x - 1)._eval_nseries(x, 4, None) == I*pi - \
+    sqrt(2)*I*sqrt(x) - sqrt(2)*I*x**(S(3)/2)/12 - 3*sqrt(2)*I*x**(S(5)/2)/160 - \
+    5*sqrt(2)*I*x**(S(7)/2)/896 + O(x**4)
+    assert acosh(I*x - 2)._eval_nseries(x, 4, None, cdir=1) == acosh(-2) - \
+    sqrt(3)*I*x/3 + sqrt(3)*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert acosh(-I*x - 2)._eval_nseries(x, 4, None, cdir=1) == acosh(-2) - \
+    2*I*pi + sqrt(3)*I*x/3 + sqrt(3)*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert acosh(1/(I*x - 3))._eval_nseries(x, 4, None, cdir=1) == -acosh(-S(1)/3) + \
+    sqrt(2)*x/12 + 17*sqrt(2)*I*x**2/576 - 443*sqrt(2)*x**3/41472 + O(x**4)
+    assert acosh(1/(I*x - 3))._eval_nseries(x, 4, None, cdir=-1) == acosh(-S(1)/3) - \
+    sqrt(2)*x/12 - 17*sqrt(2)*I*x**2/576 + 443*sqrt(2)*x**3/41472 + O(x**4)
+    # Tests concerning im(ndir) == 0
+    assert acosh(-I*x**2 + x - 2)._eval_nseries(x, 4, None) == -I*pi + log(sqrt(3) + 2) + \
+    x*(-2*sqrt(3) - 3)/(3*sqrt(3) + 6) + x**2*(-12 + 36*I + sqrt(3)*(-7 + 21*I))/(36*sqrt(3) + \
+    63) + x**3*(-168 + 672*I + sqrt(3)*(-97 + 388*I))/(1008*sqrt(3) + 1746) + O(x**4)
+
+
+def test_acosh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: acosh(x).fdiff(2))
+
+
+def test_asech():
+    x = Symbol('x')
+
+    assert unchanged(asech, -x)
+
+    # values at fixed points
+    assert asech(1) == 0
+    assert asech(-1) == pi*I
+    assert asech(0) is oo
+    assert asech(2) == I*pi/3
+    assert asech(-2) == 2*I*pi / 3
+    assert asech(nan) is nan
+
+    # at infinites
+    assert asech(oo) == I*pi/2
+    assert asech(-oo) == I*pi/2
+    assert asech(zoo) == I*AccumBounds(-pi/2, pi/2)
+
+    assert asech(I) == log(1 + sqrt(2)) - I*pi/2
+    assert asech(-I) == log(1 + sqrt(2)) + I*pi/2
+    assert asech(sqrt(2) - sqrt(6)) == 11*I*pi / 12
+    assert asech(sqrt(2 - 2/sqrt(5))) == I*pi / 10
+    assert asech(-sqrt(2 - 2/sqrt(5))) == 9*I*pi / 10
+    assert asech(2 / sqrt(2 + sqrt(2))) == I*pi / 8
+    assert asech(-2 / sqrt(2 + sqrt(2))) == 7*I*pi / 8
+    assert asech(sqrt(5) - 1) == I*pi / 5
+    assert asech(1 - sqrt(5)) == 4*I*pi / 5
+    assert asech(-sqrt(2*(2 + sqrt(2)))) == 5*I*pi / 8
+
+    # properties
+    # asech(x) == acosh(1/x)
+    assert asech(sqrt(2)) == acosh(1/sqrt(2))
+    assert asech(2/sqrt(3)) == acosh(sqrt(3)/2)
+    assert asech(2/sqrt(2 + sqrt(2))) == acosh(sqrt(2 + sqrt(2))/2)
+    assert asech(2) == acosh(S.Half)
+
+    # reality
+    assert asech(S(2)).is_real is False
+    assert asech(-S(1) / 3).is_real is False
+    assert asech(S(2) / 3).is_finite is True
+    assert asech(S(0)).is_real is False
+    assert asech(S(0)).is_extended_real is True
+    assert asech(symbols('y', real=True)).is_real is None
+
+    # asech(x) == I*acos(1/x)
+    # (Note: the exact formula is asech(x) == +/- I*acos(1/x))
+    assert asech(-sqrt(2)) == I*acos(-1/sqrt(2))
+    assert asech(-2/sqrt(3)) == I*acos(-sqrt(3)/2)
+    assert asech(-S(2)) == I*acos(Rational(-1, 2))
+    assert asech(-2/sqrt(2)) == I*acos(-sqrt(2)/2)
+
+    # sech(asech(x)) / x == 1
+    assert expand_mul(sech(asech(sqrt(6) - sqrt(2))) / (sqrt(6) - sqrt(2))) == 1
+    assert expand_mul(sech(asech(sqrt(6) + sqrt(2))) / (sqrt(6) + sqrt(2))) == 1
+    assert (sech(asech(sqrt(2 + 2/sqrt(5)))) / (sqrt(2 + 2/sqrt(5)))).simplify() == 1
+    assert (sech(asech(-sqrt(2 + 2/sqrt(5)))) / (-sqrt(2 + 2/sqrt(5)))).simplify() == 1
+    assert (sech(asech(sqrt(2*(2 + sqrt(2))))) / (sqrt(2*(2 + sqrt(2))))).simplify() == 1
+    assert expand_mul(sech(asech(1 + sqrt(5))) / (1 + sqrt(5))) == 1
+    assert expand_mul(sech(asech(-1 - sqrt(5))) / (-1 - sqrt(5))) == 1
+    assert expand_mul(sech(asech(-sqrt(6) - sqrt(2))) / (-sqrt(6) - sqrt(2))) == 1
+
+    # numerical evaluation
+    assert str(asech(5*I).n(6)) == '0.19869 - 1.5708*I'
+    assert str(asech(-5*I).n(6)) == '0.19869 + 1.5708*I'
+
+
+def test_asech_leading_term():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert asech(x).as_leading_term(x, cdir=1) == -log(x) + log(2)
+    assert asech(x).as_leading_term(x, cdir=-1) == -log(x) + log(2) + 2*I*pi
+    assert asech(x + 1).as_leading_term(x, cdir=1) == sqrt(2)*I*sqrt(x)
+    assert asech(1/x).as_leading_term(x, cdir=1) == I*pi/2
+    # Tests concerning points lying on branch cuts
+    assert asech(x - 1).as_leading_term(x, cdir=1) == I*pi
+    assert asech(I*x + 3).as_leading_term(x, cdir=1) == -asech(3)
+    assert asech(-I*x + 3).as_leading_term(x, cdir=1) == asech(3)
+    assert asech(I*x - 3).as_leading_term(x, cdir=1) == -asech(-3)
+    assert asech(-I*x - 3).as_leading_term(x, cdir=1) == asech(-3)
+    assert asech(I*x - S(1)/3).as_leading_term(x, cdir=1) == -2*I*pi + asech(-S(1)/3)
+    assert asech(I*x - S(1)/3).as_leading_term(x, cdir=-1) == asech(-S(1)/3)
+    # Tests concerning im(ndir) == 0
+    assert asech(-I*x**2 + x - 3).as_leading_term(x, cdir=1) == log(-S(1)/3 + 2*sqrt(2)*I/3)
+    assert asech(-I*x**2 + x - 3).as_leading_term(x, cdir=-1) == log(-S(1)/3 + 2*sqrt(2)*I/3)
+
+
+def test_asech_series():
+    x = Symbol('x')
+    assert asech(x).series(x, 0, 9, cdir=1) == log(2) - log(x) - x**2/4 - 3*x**4/32 \
+    - 5*x**6/96 - 35*x**8/1024 + O(x**9)
+    assert asech(x).series(x, 0, 9, cdir=-1) == I*pi + log(2) - log(-x) - x**2/4 - \
+    3*x**4/32 - 5*x**6/96 - 35*x**8/1024 + O(x**9)
+    t6 = asech(x).taylor_term(6, x)
+    assert t6 == -5*x**6/96
+    assert asech(x).taylor_term(8, x, t6, 0) == -35*x**8/1024
+
+
+def test_asech_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert asech(x + 1)._eval_nseries(x, 4, None) == sqrt(2)*sqrt(-x) + 5*sqrt(2)*(-x)**(S(3)/2)/12 + \
+    43*sqrt(2)*(-x)**(S(5)/2)/160 + 177*sqrt(2)*(-x)**(S(7)/2)/896 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert asech(x - 1)._eval_nseries(x, 4, None) == I*pi + sqrt(2)*sqrt(x) + \
+    5*sqrt(2)*x**(S(3)/2)/12 + 43*sqrt(2)*x**(S(5)/2)/160 + 177*sqrt(2)*x**(S(7)/2)/896 + O(x**4)
+    assert asech(I*x + 3)._eval_nseries(x, 4, None) == -asech(3) + sqrt(2)*x/12 - \
+    17*sqrt(2)*I*x**2/576 - 443*sqrt(2)*x**3/41472 + O(x**4)
+    assert asech(-I*x + 3)._eval_nseries(x, 4, None) == asech(3) + sqrt(2)*x/12 + \
+    17*sqrt(2)*I*x**2/576 - 443*sqrt(2)*x**3/41472 + O(x**4)
+    assert asech(I*x - 3)._eval_nseries(x, 4, None) == -asech(-3) - sqrt(2)*x/12 - \
+    17*sqrt(2)*I*x**2/576 + 443*sqrt(2)*x**3/41472 + O(x**4)
+    assert asech(-I*x - 3)._eval_nseries(x, 4, None) == asech(-3) - sqrt(2)*x/12 + \
+    17*sqrt(2)*I*x**2/576 + 443*sqrt(2)*x**3/41472 + O(x**4)
+    # Tests concerning im(ndir) == 0
+    assert asech(-I*x**2 + x - 2)._eval_nseries(x, 3, None) == 2*I*pi/3 + \
+    x*(-sqrt(3) + 3*I)/(6*sqrt(3) + 6*I) + x**2*(36 + sqrt(3)*(7 - 12*I) + 21*I)/(72*sqrt(3) - \
+    72*I) + O(x**3)
+
+
+def test_asech_rewrite():
+    x = Symbol('x')
+    assert asech(x).rewrite(log) == log(1/x + sqrt(1/x - 1) * sqrt(1/x + 1))
+    assert asech(x).rewrite(acosh) == acosh(1/x)
+    assert asech(x).rewrite(asinh) == sqrt(-1 + 1/x)*(I*asinh(I/x, evaluate=False) + pi/2)/sqrt(1 - 1/x)
+    assert asech(x).rewrite(atanh) == \
+        sqrt(x + 1)*sqrt(1/(x + 1))*atanh(sqrt(1 - x**2)) + I*pi*(-sqrt(x)*sqrt(1/x) + 1 - I*sqrt(x**2)/(2*sqrt(-x**2)) - I*sqrt(-x)/(2*sqrt(x)))
+
+
+def test_asech_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: asech(x).fdiff(2))
+
+
+def test_acsch():
+    x = Symbol('x')
+
+    assert unchanged(acsch, x)
+    assert acsch(-x) == -acsch(x)
+
+    # values at fixed points
+    assert acsch(1) == log(1 + sqrt(2))
+    assert acsch(-1) == - log(1 + sqrt(2))
+    assert acsch(0) is zoo
+    assert acsch(2) == log((1+sqrt(5))/2)
+    assert acsch(-2) == - log((1+sqrt(5))/2)
+
+    assert acsch(I) == - I*pi/2
+    assert acsch(-I) == I*pi/2
+    assert acsch(-I*(sqrt(6) + sqrt(2))) == I*pi / 12
+    assert acsch(I*(sqrt(2) + sqrt(6))) == -I*pi / 12
+    assert acsch(-I*(1 + sqrt(5))) == I*pi / 10
+    assert acsch(I*(1 + sqrt(5))) == -I*pi / 10
+    assert acsch(-I*2 / sqrt(2 - sqrt(2))) == I*pi / 8
+    assert acsch(I*2 / sqrt(2 - sqrt(2))) == -I*pi / 8
+    assert acsch(-I*2) == I*pi / 6
+    assert acsch(I*2) == -I*pi / 6
+    assert acsch(-I*sqrt(2 + 2/sqrt(5))) == I*pi / 5
+    assert acsch(I*sqrt(2 + 2/sqrt(5))) == -I*pi / 5
+    assert acsch(-I*sqrt(2)) == I*pi / 4
+    assert acsch(I*sqrt(2)) == -I*pi / 4
+    assert acsch(-I*(sqrt(5)-1)) == 3*I*pi / 10
+    assert acsch(I*(sqrt(5)-1)) == -3*I*pi / 10
+    assert acsch(-I*2 / sqrt(3)) == I*pi / 3
+    assert acsch(I*2 / sqrt(3)) == -I*pi / 3
+    assert acsch(-I*2 / sqrt(2 + sqrt(2))) == 3*I*pi / 8
+    assert acsch(I*2 / sqrt(2 + sqrt(2))) == -3*I*pi / 8
+    assert acsch(-I*sqrt(2 - 2/sqrt(5))) == 2*I*pi / 5
+    assert acsch(I*sqrt(2 - 2/sqrt(5))) == -2*I*pi / 5
+    assert acsch(-I*(sqrt(6) - sqrt(2))) == 5*I*pi / 12
+    assert acsch(I*(sqrt(6) - sqrt(2))) == -5*I*pi / 12
+    assert acsch(nan) is nan
+
+    # properties
+    # acsch(x) == asinh(1/x)
+    assert acsch(-I*sqrt(2)) == asinh(I/sqrt(2))
+    assert acsch(-I*2 / sqrt(3)) == asinh(I*sqrt(3) / 2)
+
+    # reality
+    assert acsch(S(2)).is_real is True
+    assert acsch(S(2)).is_finite is True
+    assert acsch(S(-2)).is_real is True
+    assert acsch(S(oo)).is_extended_real is True
+    assert acsch(-S(oo)).is_real is True
+    assert (acsch(2) - oo) == -oo
+    assert acsch(symbols('y', extended_real=True)).is_extended_real is True
+
+    # acsch(x) == -I*asin(I/x)
+    assert acsch(-I*sqrt(2)) == -I*asin(-1/sqrt(2))
+    assert acsch(-I*2 / sqrt(3)) == -I*asin(-sqrt(3)/2)
+
+    # csch(acsch(x)) / x == 1
+    assert expand_mul(csch(acsch(-I*(sqrt(6) + sqrt(2)))) / (-I*(sqrt(6) + sqrt(2)))) == 1
+    assert expand_mul(csch(acsch(I*(1 + sqrt(5)))) / (I*(1 + sqrt(5)))) == 1
+    assert (csch(acsch(I*sqrt(2 - 2/sqrt(5)))) / (I*sqrt(2 - 2/sqrt(5)))).simplify() == 1
+    assert (csch(acsch(-I*sqrt(2 - 2/sqrt(5)))) / (-I*sqrt(2 - 2/sqrt(5)))).simplify() == 1
+
+    # numerical evaluation
+    assert str(acsch(5*I+1).n(6)) == '0.0391819 - 0.193363*I'
+    assert str(acsch(-5*I+1).n(6)) == '0.0391819 + 0.193363*I'
+
+
+def test_acsch_infinities():
+    assert acsch(oo) == 0
+    assert acsch(-oo) == 0
+    assert acsch(zoo) == 0
+
+
+def test_acsch_leading_term():
+    x = Symbol('x')
+    assert acsch(1/x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert acsch(x + I).as_leading_term(x) == -I*pi/2
+    assert acsch(x - I).as_leading_term(x) == I*pi/2
+    # Tests concerning points lying on branch cuts
+    assert acsch(x).as_leading_term(x, cdir=1) == -log(x) + log(2)
+    assert acsch(x).as_leading_term(x, cdir=-1) == log(x) - log(2) - I*pi
+    assert acsch(x + I/2).as_leading_term(x, cdir=1) == -I*pi - acsch(I/2)
+    assert acsch(x + I/2).as_leading_term(x, cdir=-1) == acsch(I/2)
+    assert acsch(x - I/2).as_leading_term(x, cdir=1) == -acsch(I/2)
+    assert acsch(x - I/2).as_leading_term(x, cdir=-1) == acsch(I/2) + I*pi
+    # Tests concerning re(ndir) == 0
+    assert acsch(I/2 + I*x - x**2).as_leading_term(x, cdir=1) == log(2 - sqrt(3)) - I*pi/2
+    assert acsch(I/2 + I*x - x**2).as_leading_term(x, cdir=-1) == log(2 - sqrt(3)) - I*pi/2
+
+
+def test_acsch_series():
+    x = Symbol('x')
+    assert acsch(x).series(x, 0, 9) == log(2) - log(x) + x**2/4 - 3*x**4/32 \
+    + 5*x**6/96 - 35*x**8/1024 + O(x**9)
+    t4 = acsch(x).taylor_term(4, x)
+    assert t4 == -3*x**4/32
+    assert acsch(x).taylor_term(6, x, t4, 0) == 5*x**6/96
+
+
+def test_acsch_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert acsch(x + I)._eval_nseries(x, 4, None) == -I*pi/2 + \
+    sqrt(2)*I*sqrt(x)*sqrt(-I) - 5*x**(S(3)/2)*(1 - I)/12 - \
+    43*sqrt(2)*I*x**(S(5)/2)*sqrt(-I)/160 + 177*x**(S(7)/2)*(1 - I)/896 + O(x**4)
+    assert acsch(x - I)._eval_nseries(x, 4, None) == I*pi/2 - \
+    sqrt(2)*sqrt(I)*I*sqrt(x) - 5*x**(S(3)/2)*(1 + I)/12 + \
+    43*sqrt(2)*sqrt(I)*I*x**(S(5)/2)/160 + 177*x**(S(7)/2)*(1 + I)/896 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert acsch(x + I/2)._eval_nseries(x, 4, None, cdir=1) == -acsch(I/2) - \
+    I*pi + 4*sqrt(3)*I*x/3 - 8*sqrt(3)*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsch(x + I/2)._eval_nseries(x, 4, None, cdir=-1) == acsch(I/2) - \
+    4*sqrt(3)*I*x/3 + 8*sqrt(3)*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsch(x - I/2)._eval_nseries(x, 4, None, cdir=1) == -acsch(I/2) - \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsch(x - I/2)._eval_nseries(x, 4, None, cdir=-1) == I*pi + \
+    acsch(I/2) + 4*sqrt(3)*I*x/3 + 8*sqrt(3)*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    # Tests concerning re(ndir) == 0
+    assert acsch(I/2 + I*x - x**2)._eval_nseries(x, 4, None) == -I*pi/2 + \
+    log(2 - sqrt(3)) + x*(12 - 8*sqrt(3))/(-6 + 3*sqrt(3)) + x**2*(-96 + \
+    sqrt(3)*(56 - 84*I) + 144*I)/(-63 + 36*sqrt(3)) + x**3*(2688 - 2688*I + \
+    sqrt(3)*(-1552 + 1552*I))/(-873 + 504*sqrt(3)) + O(x**4)
+
+
+def test_acsch_rewrite():
+    x = Symbol('x')
+    assert acsch(x).rewrite(log) == log(1/x + sqrt(1/x**2 + 1))
+    assert acsch(x).rewrite(asinh) == asinh(1/x)
+    assert acsch(x).rewrite(atanh) == (sqrt(-x**2)*(-sqrt(-(x**2 + 1)**2)
+                                                    *atanh(sqrt(x**2 + 1))/(x**2 + 1)
+                                                    + pi/2)/x)
+
+
+def test_acsch_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: acsch(x).fdiff(2))
+
+
+def test_atanh():
+    x = Symbol('x')
+
+    # at specific points
+    assert atanh(0) == 0
+    assert atanh(I) == I*pi/4
+    assert atanh(-I) == -I*pi/4
+    assert atanh(1) is oo
+    assert atanh(-1) is -oo
+    assert atanh(nan) is nan
+
+    # at infinites
+    assert atanh(oo) == -I*pi/2
+    assert atanh(-oo) == I*pi/2
+
+    assert atanh(I*oo) == I*pi/2
+    assert atanh(-I*oo) == -I*pi/2
+
+    assert atanh(zoo) == I*AccumBounds(-pi/2, pi/2)
+
+    # properties
+    assert atanh(-x) == -atanh(x)
+
+    # reality
+    assert atanh(S(2)).is_real is False
+    assert atanh(S(-1)/5).is_real is True
+    assert atanh(symbols('y', extended_real=True)).is_real is None
+    assert atanh(S(1)).is_real is False
+    assert atanh(S(1)).is_extended_real is True
+    assert atanh(S(-1)).is_real is False
+
+    # special values
+    assert atanh(I/sqrt(3)) == I*pi/6
+    assert atanh(-I/sqrt(3)) == -I*pi/6
+    assert atanh(I*sqrt(3)) == I*pi/3
+    assert atanh(-I*sqrt(3)) == -I*pi/3
+    assert atanh(I*(1 + sqrt(2))) == pi*I*Rational(3, 8)
+    assert atanh(I*(sqrt(2) - 1)) == pi*I/8
+    assert atanh(I*(1 - sqrt(2))) == -pi*I/8
+    assert atanh(-I*(1 + sqrt(2))) == pi*I*Rational(-3, 8)
+    assert atanh(I*sqrt(5 + 2*sqrt(5))) == I*pi*Rational(2, 5)
+    assert atanh(-I*sqrt(5 + 2*sqrt(5))) == I*pi*Rational(-2, 5)
+    assert atanh(I*(2 - sqrt(3))) == pi*I/12
+    assert atanh(I*(sqrt(3) - 2)) == -pi*I/12
+    assert atanh(oo) == -I*pi/2
+
+    # Symmetry
+    assert atanh(Rational(-1, 2)) == -atanh(S.Half)
+
+    # inverse composition
+    assert unchanged(atanh, tanh(Symbol('v1')))
+
+    assert atanh(tanh(-5, evaluate=False)) == -5
+    assert atanh(tanh(0, evaluate=False)) == 0
+    assert atanh(tanh(7, evaluate=False)) == 7
+    assert atanh(tanh(I, evaluate=False)) == I
+    assert atanh(tanh(-I, evaluate=False)) == -I
+    assert atanh(tanh(-11*I, evaluate=False)) == -11*I + 4*I*pi
+    assert atanh(tanh(3 + I)) == 3 + I
+    assert atanh(tanh(4 + 5*I)) == 4 - 2*I*pi + 5*I
+    assert atanh(tanh(pi/2)) == pi/2
+    assert atanh(tanh(pi)) == pi
+    assert atanh(tanh(-3 + 7*I)) == -3 - 2*I*pi + 7*I
+    assert atanh(tanh(9 - I*2/3)) == 9 - I*2/3
+    assert atanh(tanh(-32 - 123*I)) == -32 - 123*I + 39*I*pi
+
+
+def test_atanh_rewrite():
+    x = Symbol('x')
+    assert atanh(x).rewrite(log) == (log(1 + x) - log(1 - x)) / 2
+    assert atanh(x).rewrite(asinh) == \
+        pi*x/(2*sqrt(-x**2)) - sqrt(-x)*sqrt(1 - x**2)*sqrt(1/(x**2 - 1))*asinh(sqrt(1/(x**2 - 1)))/sqrt(x)
+
+
+def test_atanh_leading_term():
+    x = Symbol('x')
+    assert atanh(x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert atanh(x + 1).as_leading_term(x, cdir=1) == -log(x)/2 + log(2)/2 - I*pi/2
+    assert atanh(x + 1).as_leading_term(x, cdir=-1) == -log(x)/2 + log(2)/2 + I*pi/2
+    assert atanh(x - 1).as_leading_term(x, cdir=1) == log(x)/2 - log(2)/2
+    assert atanh(x - 1).as_leading_term(x, cdir=-1) == log(x)/2 - log(2)/2
+    assert atanh(1/x).as_leading_term(x, cdir=1) == -I*pi/2
+    assert atanh(1/x).as_leading_term(x, cdir=-1) == I*pi/2
+    # Tests concerning points lying on branch cuts
+    assert atanh(I*x + 2).as_leading_term(x, cdir=1) == atanh(2) + I*pi
+    assert atanh(-I*x + 2).as_leading_term(x, cdir=1) == atanh(2)
+    assert atanh(I*x - 2).as_leading_term(x, cdir=1) == -atanh(2)
+    assert atanh(-I*x - 2).as_leading_term(x, cdir=1) == -I*pi - atanh(2)
+    # Tests concerning im(ndir) == 0
+    assert atanh(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == -log(3)/2 - I*pi/2
+    assert atanh(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == -log(3)/2 - I*pi/2
+
+
+def test_atanh_series():
+    x = Symbol('x')
+    assert atanh(x).series(x, 0, 10) == \
+        x + x**3/3 + x**5/5 + x**7/7 + x**9/9 + O(x**10)
+
+
+def test_atanh_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert atanh(x + 1)._eval_nseries(x, 4, None, cdir=1) == -I*pi/2 + log(2)/2 - \
+    log(x)/2 + x/4 - x**2/16 + x**3/48 + O(x**4)
+    assert atanh(x + 1)._eval_nseries(x, 4, None, cdir=-1) == I*pi/2 + log(2)/2 - \
+    log(x)/2 + x/4 - x**2/16 + x**3/48 + O(x**4)
+    assert atanh(x - 1)._eval_nseries(x, 4, None, cdir=1) == -log(2)/2 + log(x)/2 + \
+    x/4 + x**2/16 + x**3/48 + O(x**4)
+    assert atanh(x - 1)._eval_nseries(x, 4, None, cdir=-1) == -log(2)/2 + log(x)/2 + \
+    x/4 + x**2/16 + x**3/48 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert atanh(I*x + 2)._eval_nseries(x, 4, None, cdir=1) == I*pi + atanh(2) - \
+    I*x/3 - 2*x**2/9 + 13*I*x**3/81 + O(x**4)
+    assert atanh(I*x + 2)._eval_nseries(x, 4, None, cdir=-1) == atanh(2) - I*x/3 - \
+    2*x**2/9 + 13*I*x**3/81 + O(x**4)
+    assert atanh(I*x - 2)._eval_nseries(x, 4, None, cdir=1) == -atanh(2) - I*x/3 + \
+    2*x**2/9 + 13*I*x**3/81 + O(x**4)
+    assert atanh(I*x - 2)._eval_nseries(x, 4, None, cdir=-1) == -atanh(2) - I*pi - \
+    I*x/3 + 2*x**2/9 + 13*I*x**3/81 + O(x**4)
+    # Tests concerning im(ndir) == 0
+    assert atanh(-I*x**2 + x - 2)._eval_nseries(x, 4, None) == -I*pi/2 - log(3)/2 - x/3 + \
+    x**2*(-S(1)/4 + I/2) + x**2*(S(1)/36 - I/6) + x**3*(-S(1)/6 + I/2) + x**3*(S(1)/162 - I/18) + O(x**4)
+
+
+def test_atanh_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: atanh(x).fdiff(2))
+
+
+def test_acoth():
+    x = Symbol('x')
+
+    #at specific points
+    assert acoth(0) == I*pi/2
+    assert acoth(I) == -I*pi/4
+    assert acoth(-I) == I*pi/4
+    assert acoth(1) is oo
+    assert acoth(-1) is -oo
+    assert acoth(nan) is nan
+
+    # at infinites
+    assert acoth(oo) == 0
+    assert acoth(-oo) == 0
+    assert acoth(I*oo) == 0
+    assert acoth(-I*oo) == 0
+    assert acoth(zoo) == 0
+
+    #properties
+    assert acoth(-x) == -acoth(x)
+
+    assert acoth(I/sqrt(3)) == -I*pi/3
+    assert acoth(-I/sqrt(3)) == I*pi/3
+    assert acoth(I*sqrt(3)) == -I*pi/6
+    assert acoth(-I*sqrt(3)) == I*pi/6
+    assert acoth(I*(1 + sqrt(2))) == -pi*I/8
+    assert acoth(-I*(sqrt(2) + 1)) == pi*I/8
+    assert acoth(I*(1 - sqrt(2))) == pi*I*Rational(3, 8)
+    assert acoth(I*(sqrt(2) - 1)) == pi*I*Rational(-3, 8)
+    assert acoth(I*sqrt(5 + 2*sqrt(5))) == -I*pi/10
+    assert acoth(-I*sqrt(5 + 2*sqrt(5))) == I*pi/10
+    assert acoth(I*(2 + sqrt(3))) == -pi*I/12
+    assert acoth(-I*(2 + sqrt(3))) == pi*I/12
+    assert acoth(I*(2 - sqrt(3))) == pi*I*Rational(-5, 12)
+    assert acoth(I*(sqrt(3) - 2)) == pi*I*Rational(5, 12)
+
+    # reality
+    assert acoth(S(2)).is_real is True
+    assert acoth(S(2)).is_finite is True
+    assert acoth(S(2)).is_extended_real is True
+    assert acoth(S(-2)).is_real is True
+    assert acoth(S(1)).is_real is False
+    assert acoth(S(1)).is_extended_real is True
+    assert acoth(S(-1)).is_real is False
+    assert acoth(symbols('y', real=True)).is_real is None
+
+    # Symmetry
+    assert acoth(Rational(-1, 2)) == -acoth(S.Half)
+
+
+def test_acoth_rewrite():
+    x = Symbol('x')
+    assert acoth(x).rewrite(log) == (log(1 + 1/x) - log(1 - 1/x)) / 2
+    assert acoth(x).rewrite(atanh) == atanh(1/x)
+    assert acoth(x).rewrite(asinh) == \
+        x*sqrt(x**(-2))*asinh(sqrt(1/(x**2 - 1))) + I*pi*(sqrt((x - 1)/x)*sqrt(x/(x - 1)) - sqrt(x/(x + 1))*sqrt(1 + 1/x))/2
+
+
+def test_acoth_leading_term():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert acoth(x + 1).as_leading_term(x, cdir=1) == -log(x)/2 + log(2)/2
+    assert acoth(x + 1).as_leading_term(x, cdir=-1) == -log(x)/2 + log(2)/2
+    assert acoth(x - 1).as_leading_term(x, cdir=1) == log(x)/2 - log(2)/2 + I*pi/2
+    assert acoth(x - 1).as_leading_term(x, cdir=-1) == log(x)/2 - log(2)/2 - I*pi/2
+    # Tests concerning points lying on branch cuts
+    assert acoth(x).as_leading_term(x, cdir=-1) == I*pi/2
+    assert acoth(x).as_leading_term(x, cdir=1) == -I*pi/2
+    assert acoth(I*x + 1/2).as_leading_term(x, cdir=1) == acoth(1/2)
+    assert acoth(-I*x + 1/2).as_leading_term(x, cdir=1) == acoth(1/2) + I*pi
+    assert acoth(I*x - 1/2).as_leading_term(x, cdir=1) == -I*pi - acoth(1/2)
+    assert acoth(-I*x - 1/2).as_leading_term(x, cdir=1) == -acoth(1/2)
+    # Tests concerning im(ndir) == 0
+    assert acoth(-I*x**2 - x - S(1)/2).as_leading_term(x, cdir=1) == -log(3)/2 + I*pi/2
+    assert acoth(-I*x**2 - x - S(1)/2).as_leading_term(x, cdir=-1) == -log(3)/2 + I*pi/2
+
+
+def test_acoth_series():
+    x = Symbol('x')
+    assert acoth(x).series(x, 0, 10) == \
+        -I*pi/2 + x + x**3/3 + x**5/5 + x**7/7 + x**9/9 + O(x**10)
+
+
+def test_acoth_nseries():
+    x = Symbol('x')
+    # Tests concerning branch points
+    assert acoth(x + 1)._eval_nseries(x, 4, None) == log(2)/2 - log(x)/2 + x/4 - \
+    x**2/16 + x**3/48 + O(x**4)
+    assert acoth(x - 1)._eval_nseries(x, 4, None, cdir=1) == I*pi/2 - log(2)/2 + \
+    log(x)/2 + x/4 + x**2/16 + x**3/48 + O(x**4)
+    assert acoth(x - 1)._eval_nseries(x, 4, None, cdir=-1) == -I*pi/2 - log(2)/2 + \
+    log(x)/2 + x/4 + x**2/16 + x**3/48 + O(x**4)
+    # Tests concerning points lying on branch cuts
+    assert acoth(I*x + S(1)/2)._eval_nseries(x, 4, None, cdir=1) == acoth(S(1)/2) + \
+    4*I*x/3 - 8*x**2/9 - 112*I*x**3/81 + O(x**4)
+    assert acoth(I*x + S(1)/2)._eval_nseries(x, 4, None, cdir=-1) == I*pi + \
+    acoth(S(1)/2) + 4*I*x/3 - 8*x**2/9 - 112*I*x**3/81 + O(x**4)
+    assert acoth(I*x - S(1)/2)._eval_nseries(x, 4, None, cdir=1) == -acoth(S(1)/2) - \
+    I*pi + 4*I*x/3 + 8*x**2/9 - 112*I*x**3/81 + O(x**4)
+    assert acoth(I*x - S(1)/2)._eval_nseries(x, 4, None, cdir=-1) == -acoth(S(1)/2) + \
+    4*I*x/3 + 8*x**2/9 - 112*I*x**3/81 + O(x**4)
+    # Tests concerning im(ndir) == 0
+    assert acoth(-I*x**2 - x - S(1)/2)._eval_nseries(x, 4, None) == I*pi/2 - log(3)/2 - \
+    4*x/3 + x**2*(-S(8)/9 + 2*I/3) - 2*I*x**2 + x**3*(S(104)/81 - 16*I/9) - 8*x**3/3 + O(x**4)
+
+
+def test_acoth_fdiff():
+    x = Symbol('x')
+    raises(ArgumentIndexError, lambda: acoth(x).fdiff(2))
+
+
+def test_inverses():
+    x = Symbol('x')
+    assert sinh(x).inverse() == asinh
+    raises(AttributeError, lambda: cosh(x).inverse())
+    assert tanh(x).inverse() == atanh
+    assert coth(x).inverse() == acoth
+    assert asinh(x).inverse() == sinh
+    assert acosh(x).inverse() == cosh
+    assert atanh(x).inverse() == tanh
+    assert acoth(x).inverse() == coth
+    assert asech(x).inverse() == sech
+    assert acsch(x).inverse() == csch
+
+
+def test_leading_term():
+    x = Symbol('x')
+    assert cosh(x).as_leading_term(x) == 1
+    assert coth(x).as_leading_term(x) == 1/x
+    for func in [sinh, tanh]:
+        assert func(x).as_leading_term(x) == x
+    for func in [sinh, cosh, tanh, coth]:
+        for ar in (1/x, S.Half):
+            eq = func(ar)
+            assert eq.as_leading_term(x) == eq
+    for func in [csch, sech]:
+        eq = func(S.Half)
+        assert eq.as_leading_term(x) == eq
+
+
+def test_complex():
+    a, b = symbols('a,b', real=True)
+    z = a + b*I
+    for func in [sinh, cosh, tanh, coth, sech, csch]:
+        assert func(z).conjugate() == func(a - b*I)
+    for deep in [True, False]:
+        assert sinh(z).expand(
+            complex=True, deep=deep) == sinh(a)*cos(b) + I*cosh(a)*sin(b)
+        assert cosh(z).expand(
+            complex=True, deep=deep) == cosh(a)*cos(b) + I*sinh(a)*sin(b)
+        assert tanh(z).expand(complex=True, deep=deep) == sinh(a)*cosh(
+            a)/(cos(b)**2 + sinh(a)**2) + I*sin(b)*cos(b)/(cos(b)**2 + sinh(a)**2)
+        assert coth(z).expand(complex=True, deep=deep) == sinh(a)*cosh(
+            a)/(sin(b)**2 + sinh(a)**2) - I*sin(b)*cos(b)/(sin(b)**2 + sinh(a)**2)
+        assert csch(z).expand(complex=True, deep=deep) == cos(b) * sinh(a) / (sin(b)**2\
+            *cosh(a)**2 + cos(b)**2 * sinh(a)**2) - I*sin(b) * cosh(a) / (sin(b)**2\
+            *cosh(a)**2 + cos(b)**2 * sinh(a)**2)
+        assert sech(z).expand(complex=True, deep=deep) == cos(b) * cosh(a) / (sin(b)**2\
+            *sinh(a)**2 + cos(b)**2 * cosh(a)**2) - I*sin(b) * sinh(a) / (sin(b)**2\
+            *sinh(a)**2 + cos(b)**2 * cosh(a)**2)
+
+
+def test_complex_2899():
+    a, b = symbols('a,b', real=True)
+    for deep in [True, False]:
+        for func in [sinh, cosh, tanh, coth]:
+            assert func(a).expand(complex=True, deep=deep) == func(a)
+
+
+def test_simplifications():
+    x = Symbol('x')
+    assert sinh(asinh(x)) == x
+    assert sinh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1)
+    assert sinh(atanh(x)) == x/sqrt(1 - x**2)
+    assert sinh(acoth(x)) == 1/(sqrt(x - 1) * sqrt(x + 1))
+
+    assert cosh(asinh(x)) == sqrt(1 + x**2)
+    assert cosh(acosh(x)) == x
+    assert cosh(atanh(x)) == 1/sqrt(1 - x**2)
+    assert cosh(acoth(x)) == x/(sqrt(x - 1) * sqrt(x + 1))
+
+    assert tanh(asinh(x)) == x/sqrt(1 + x**2)
+    assert tanh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) / x
+    assert tanh(atanh(x)) == x
+    assert tanh(acoth(x)) == 1/x
+
+    assert coth(asinh(x)) == sqrt(1 + x**2)/x
+    assert coth(acosh(x)) == x/(sqrt(x - 1) * sqrt(x + 1))
+    assert coth(atanh(x)) == 1/x
+    assert coth(acoth(x)) == x
+
+    assert csch(asinh(x)) == 1/x
+    assert csch(acosh(x)) == 1/(sqrt(x - 1) * sqrt(x + 1))
+    assert csch(atanh(x)) == sqrt(1 - x**2)/x
+    assert csch(acoth(x)) == sqrt(x - 1) * sqrt(x + 1)
+
+    assert sech(asinh(x)) == 1/sqrt(1 + x**2)
+    assert sech(acosh(x)) == 1/x
+    assert sech(atanh(x)) == sqrt(1 - x**2)
+    assert sech(acoth(x)) == sqrt(x - 1) * sqrt(x + 1)/x
+
+
+def test_issue_4136():
+    assert cosh(asinh(Integer(3)/2)) == sqrt(Integer(13)/4)
+
+
+def test_sinh_rewrite():
+    x = Symbol('x')
+    assert sinh(x).rewrite(exp) == (exp(x) - exp(-x))/2 \
+        == sinh(x).rewrite('tractable')
+    assert sinh(x).rewrite(cosh) == -I*cosh(x + I*pi/2)
+    tanh_half = tanh(S.Half*x)
+    assert sinh(x).rewrite(tanh) == 2*tanh_half/(1 - tanh_half**2)
+    coth_half = coth(S.Half*x)
+    assert sinh(x).rewrite(coth) == 2*coth_half/(coth_half**2 - 1)
+
+
+def test_cosh_rewrite():
+    x = Symbol('x')
+    assert cosh(x).rewrite(exp) == (exp(x) + exp(-x))/2 \
+        == cosh(x).rewrite('tractable')
+    assert cosh(x).rewrite(sinh) == -I*sinh(x + I*pi/2, evaluate=False)
+    tanh_half = tanh(S.Half*x)**2
+    assert cosh(x).rewrite(tanh) == (1 + tanh_half)/(1 - tanh_half)
+    coth_half = coth(S.Half*x)**2
+    assert cosh(x).rewrite(coth) == (coth_half + 1)/(coth_half - 1)
+
+
+def test_tanh_rewrite():
+    x = Symbol('x')
+    assert tanh(x).rewrite(exp) == (exp(x) - exp(-x))/(exp(x) + exp(-x)) \
+        == tanh(x).rewrite('tractable')
+    assert tanh(x).rewrite(sinh) == I*sinh(x)/sinh(I*pi/2 - x, evaluate=False)
+    assert tanh(x).rewrite(cosh) == I*cosh(I*pi/2 - x, evaluate=False)/cosh(x)
+    assert tanh(x).rewrite(coth) == 1/coth(x)
+
+
+def test_coth_rewrite():
+    x = Symbol('x')
+    assert coth(x).rewrite(exp) == (exp(x) + exp(-x))/(exp(x) - exp(-x)) \
+        == coth(x).rewrite('tractable')
+    assert coth(x).rewrite(sinh) == -I*sinh(I*pi/2 - x, evaluate=False)/sinh(x)
+    assert coth(x).rewrite(cosh) == -I*cosh(x)/cosh(I*pi/2 - x, evaluate=False)
+    assert coth(x).rewrite(tanh) == 1/tanh(x)
+
+
+def test_csch_rewrite():
+    x = Symbol('x')
+    assert csch(x).rewrite(exp) == 1 / (exp(x)/2 - exp(-x)/2) \
+        == csch(x).rewrite('tractable')
+    assert csch(x).rewrite(cosh) == I/cosh(x + I*pi/2, evaluate=False)
+    tanh_half = tanh(S.Half*x)
+    assert csch(x).rewrite(tanh) == (1 - tanh_half**2)/(2*tanh_half)
+    coth_half = coth(S.Half*x)
+    assert csch(x).rewrite(coth) == (coth_half**2 - 1)/(2*coth_half)
+
+
+def test_sech_rewrite():
+    x = Symbol('x')
+    assert sech(x).rewrite(exp) == 1 / (exp(x)/2 + exp(-x)/2) \
+        == sech(x).rewrite('tractable')
+    assert sech(x).rewrite(sinh) == I/sinh(x + I*pi/2, evaluate=False)
+    tanh_half = tanh(S.Half*x)**2
+    assert sech(x).rewrite(tanh) == (1 - tanh_half)/(1 + tanh_half)
+    coth_half = coth(S.Half*x)**2
+    assert sech(x).rewrite(coth) == (coth_half - 1)/(coth_half + 1)
+
+
+def test_derivs():
+    x = Symbol('x')
+    assert coth(x).diff(x) == -sinh(x)**(-2)
+    assert sinh(x).diff(x) == cosh(x)
+    assert cosh(x).diff(x) == sinh(x)
+    assert tanh(x).diff(x) == -tanh(x)**2 + 1
+    assert csch(x).diff(x) == -coth(x)*csch(x)
+    assert sech(x).diff(x) == -tanh(x)*sech(x)
+    assert acoth(x).diff(x) == 1/(-x**2 + 1)
+    assert asinh(x).diff(x) == 1/sqrt(x**2 + 1)
+    assert acosh(x).diff(x) == 1/(sqrt(x - 1)*sqrt(x + 1))
+    assert acosh(x).diff(x) == acosh(x).rewrite(log).diff(x).together()
+    assert atanh(x).diff(x) == 1/(-x**2 + 1)
+    assert asech(x).diff(x) == -1/(x*sqrt(1 - x**2))
+    assert acsch(x).diff(x) == -1/(x**2*sqrt(1 + x**(-2)))
+
+
+def test_sinh_expansion():
+    x, y = symbols('x,y')
+    assert sinh(x+y).expand(trig=True) == sinh(x)*cosh(y) + cosh(x)*sinh(y)
+    assert sinh(2*x).expand(trig=True) == 2*sinh(x)*cosh(x)
+    assert sinh(3*x).expand(trig=True).expand() == \
+        sinh(x)**3 + 3*sinh(x)*cosh(x)**2
+
+
+def test_cosh_expansion():
+    x, y = symbols('x,y')
+    assert cosh(x+y).expand(trig=True) == cosh(x)*cosh(y) + sinh(x)*sinh(y)
+    assert cosh(2*x).expand(trig=True) == cosh(x)**2 + sinh(x)**2
+    assert cosh(3*x).expand(trig=True).expand() == \
+        3*sinh(x)**2*cosh(x) + cosh(x)**3
+
+def test_cosh_positive():
+    # See issue 11721
+    # cosh(x) is positive for real values of x
+    k = symbols('k', real=True)
+    n = symbols('n', integer=True)
+
+    assert cosh(k, evaluate=False).is_positive is True
+    assert cosh(k + 2*n*pi*I, evaluate=False).is_positive is True
+    assert cosh(I*pi/4, evaluate=False).is_positive is True
+    assert cosh(3*I*pi/4, evaluate=False).is_positive is False
+
+def test_cosh_nonnegative():
+    k = symbols('k', real=True)
+    n = symbols('n', integer=True)
+
+    assert cosh(k, evaluate=False).is_nonnegative is True
+    assert cosh(k + 2*n*pi*I, evaluate=False).is_nonnegative is True
+    assert cosh(I*pi/4, evaluate=False).is_nonnegative is True
+    assert cosh(3*I*pi/4, evaluate=False).is_nonnegative is False
+    assert cosh(S.Zero, evaluate=False).is_nonnegative is True
+
+def test_real_assumptions():
+    z = Symbol('z', real=False)
+    assert sinh(z).is_real is None
+    assert cosh(z).is_real is None
+    assert tanh(z).is_real is None
+    assert sech(z).is_real is None
+    assert csch(z).is_real is None
+    assert coth(z).is_real is None
+
+def test_sign_assumptions():
+    p = Symbol('p', positive=True)
+    n = Symbol('n', negative=True)
+    assert sinh(n).is_negative is True
+    assert sinh(p).is_positive is True
+    assert cosh(n).is_positive is True
+    assert cosh(p).is_positive is True
+    assert tanh(n).is_negative is True
+    assert tanh(p).is_positive is True
+    assert csch(n).is_negative is True
+    assert csch(p).is_positive is True
+    assert sech(n).is_positive is True
+    assert sech(p).is_positive is True
+    assert coth(n).is_negative is True
+    assert coth(p).is_positive is True
+
+
+def test_issue_25847():
+    x = Symbol('x')
+
+    #atanh
+    assert atanh(sin(x)/x).as_leading_term(x) == atanh(sin(x)/x)
+    raises(PoleError, lambda: atanh(exp(1/x)).as_leading_term(x))
+
+    #asinh
+    assert asinh(sin(x)/x).as_leading_term(x) == log(1 + sqrt(2))
+    raises(PoleError, lambda: asinh(exp(1/x)).as_leading_term(x))
+
+    #acosh
+    assert acosh(sin(x)/x).as_leading_term(x) == 0
+    raises(PoleError, lambda: acosh(exp(1/x)).as_leading_term(x))
+
+    #acoth
+    assert acoth(sin(x)/x).as_leading_term(x) == acoth(sin(x)/x)
+    raises(PoleError, lambda: acoth(exp(1/x)).as_leading_term(x))
+
+    #asech
+    assert asech(sinh(x)/x).as_leading_term(x) == 0
+    raises(PoleError, lambda: asech(exp(1/x)).as_leading_term(x))
+
+    #acsch
+    assert acsch(sin(x)/x).as_leading_term(x) == log(1 + sqrt(2))
+    raises(PoleError, lambda: acsch(exp(1/x)).as_leading_term(x))
+
+
+def test_issue_25175():
+    x = Symbol('x')
+    g1 = 2*acosh(1 + 2*x/3) - acosh(S(5)/3 - S(8)/3/(x + 4))
+    g2 = 2*log(sqrt((x + 4)/3)*(sqrt(x + 3)+sqrt(x))**2/(2*sqrt(x + 3) + sqrt(x)))
+    assert (g1 - g2).series(x) == O(x**6)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_integers.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_integers.py
new file mode 100644
index 0000000000000000000000000000000000000000..a48ad2ac24c4a857d57b2f24e3308ac90078a9b1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_integers.py
@@ -0,0 +1,688 @@
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.numbers import (E, Float, I, Rational, Integer, nan, oo, pi, zoo)
+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, log)
+from sympy.functions.elementary.integers import (ceiling, floor, frac)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos, tan, asin
+from sympy.polys.rootoftools import RootOf, CRootOf
+from sympy import Integers
+from sympy.sets.sets import Interval
+from sympy.sets.fancysets import ImageSet
+from sympy.core.function import Lambda
+
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import XFAIL, raises
+
+x = Symbol('x')
+i = Symbol('i', imaginary=True)
+y = Symbol('y', real=True)
+k, n = symbols('k,n', integer=True)
+b = Symbol('b', real=True, noninteger=True)
+m = Symbol('m', positive=True)
+
+
+def test_floor():
+
+    assert floor(nan) is nan
+
+    assert floor(oo) is oo
+    assert floor(-oo) is -oo
+    assert floor(zoo) is zoo
+
+    assert floor(0) == 0
+
+    assert floor(1) == 1
+    assert floor(-1) == -1
+
+    assert floor(I*log(asin(5)/abs(asin(5)))) == 0
+    assert floor(-I*log(asin(7)/abs(asin(7)))) == -2
+
+    assert floor(E) == 2
+    assert floor(-E) == -3
+
+    assert floor(2*E) == 5
+    assert floor(-2*E) == -6
+
+    assert floor(pi) == 3
+    assert floor(-pi) == -4
+
+    assert floor(S.Half) == 0
+    assert floor(Rational(-1, 2)) == -1
+
+    assert floor(Rational(7, 3)) == 2
+    assert floor(Rational(-7, 3)) == -3
+    assert floor(-Rational(7, 3)) == -3
+
+    assert floor(Float(17.0)) == 17
+    assert floor(-Float(17.0)) == -17
+
+    assert floor(Float(7.69)) == 7
+    assert floor(-Float(7.69)) == -8
+
+    assert floor(1/(m+1)) == S.Zero
+    assert floor((m+2)/(m+1)) == S.One
+    assert floor(-1/(m+1)) == S.NegativeOne
+    assert floor((m+2)/(-m-1)) == Integer(-2)
+
+    assert floor(I) == I
+    assert floor(-I) == -I
+    e = floor(i)
+    assert e.func is floor and e.args[0] == i
+
+    assert floor(oo*I) == oo*I
+    assert floor(-oo*I) == -oo*I
+    assert floor(exp(I*pi/4)*oo) == exp(I*pi/4)*oo
+
+    assert floor(2*I) == 2*I
+    assert floor(-2*I) == -2*I
+
+    assert floor(I/2) == 0
+    assert floor(-I/2) == -I
+
+    assert floor(E + 17) == 19
+    assert floor(pi + 2) == 5
+
+    assert floor(E + pi) == 5
+    assert floor(I + pi) == 3 + I
+
+    assert floor(floor(pi)) == 3
+    assert floor(floor(y)) == floor(y)
+    assert floor(floor(x)) == floor(x)
+
+    assert unchanged(floor, x)
+    assert unchanged(floor, 2*x)
+    assert unchanged(floor, k*x)
+
+    assert floor(k) == k
+    assert floor(2*k) == 2*k
+    assert floor(k*n) == k*n
+
+    assert unchanged(floor, k/2)
+
+    assert unchanged(floor, x + y)
+
+    assert floor(x + 3) == floor(x) + 3
+    assert floor(x + k) == floor(x) + k
+
+    assert floor(y + 3) == floor(y) + 3
+    assert floor(y + k) == floor(y) + k
+
+    assert floor(3 + I*y + pi) == 6 + floor(y)*I
+
+    assert floor(k + n) == k + n
+
+    assert unchanged(floor, x*I)
+    assert floor(k*I) == k*I
+
+    assert floor(Rational(23, 10) - E*I) == 2 - 3*I
+
+    assert floor(sin(1)) == 0
+    assert floor(sin(-1)) == -1
+
+    assert floor(exp(2)) == 7
+
+    assert floor(log(8)/log(2)) != 2
+    assert int(floor(log(8)/log(2)).evalf(chop=True)) == 3
+
+    assert floor(factorial(50)/exp(1)) == \
+        11188719610782480504630258070757734324011354208865721592720336800
+
+    assert (floor(y) < y).is_Relational
+    assert (floor(y) <= y) == True
+    assert (floor(y) > y) == False
+    assert (floor(y) >= y).is_Relational
+    assert (floor(x) <= x).is_Relational  # x could be non-real
+    assert (floor(x) > x).is_Relational
+    assert (floor(x) <= y).is_Relational  # arg is not same as rhs
+    assert (floor(x) > y).is_Relational
+    assert (floor(y) <= oo) == True
+    assert (floor(y) < oo) == True
+    assert (floor(y) >= -oo) == True
+    assert (floor(y) > -oo) == True
+    assert (floor(b) < b) == True
+    assert (floor(b) <= b) == True
+    assert (floor(b) > b) == False
+    assert (floor(b) >= b) == False
+
+    assert floor(y).rewrite(frac) == y - frac(y)
+    assert floor(y).rewrite(ceiling) == -ceiling(-y)
+    assert floor(y).rewrite(frac).subs(y, -pi) == floor(-pi)
+    assert floor(y).rewrite(frac).subs(y, E) == floor(E)
+    assert floor(y).rewrite(ceiling).subs(y, E) == -ceiling(-E)
+    assert floor(y).rewrite(ceiling).subs(y, -pi) == -ceiling(pi)
+
+    assert Eq(floor(y), y - frac(y))
+    assert Eq(floor(y), -ceiling(-y))
+
+    neg = Symbol('neg', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    pos = Symbol('pos', positive=True)
+    np = Symbol('np', nonpositive=True)
+
+    assert (floor(neg) < 0) == True
+    assert (floor(neg) <= 0) == True
+    assert (floor(neg) > 0) == False
+    assert (floor(neg) >= 0) == False
+    assert (floor(neg) <= -1) == True
+    assert (floor(neg) >= -3) == (neg >= -3)
+    assert (floor(neg) < 5) == (neg < 5)
+
+    assert (floor(nn) < 0) == False
+    assert (floor(nn) >= 0) == True
+
+    assert (floor(pos) < 0) == False
+    assert (floor(pos) <= 0) == (pos < 1)
+    assert (floor(pos) > 0) == (pos >= 1)
+    assert (floor(pos) >= 0) == True
+    assert (floor(pos) >= 3) == (pos >= 3)
+
+    assert (floor(np) <= 0) == True
+    assert (floor(np) > 0) == False
+
+    assert floor(neg).is_negative == True
+    assert floor(neg).is_nonnegative == False
+    assert floor(nn).is_negative == False
+    assert floor(nn).is_nonnegative == True
+    assert floor(pos).is_negative == False
+    assert floor(pos).is_nonnegative == True
+    assert floor(np).is_negative is None
+    assert floor(np).is_nonnegative is None
+
+    assert (floor(7, evaluate=False) >= 7) == True
+    assert (floor(7, evaluate=False) > 7) == False
+    assert (floor(7, evaluate=False) <= 7) == True
+    assert (floor(7, evaluate=False) < 7) == False
+
+    assert (floor(7, evaluate=False) >= 6) == True
+    assert (floor(7, evaluate=False) > 6) == True
+    assert (floor(7, evaluate=False) <= 6) == False
+    assert (floor(7, evaluate=False) < 6) == False
+
+    assert (floor(7, evaluate=False) >= 8) == False
+    assert (floor(7, evaluate=False) > 8) == False
+    assert (floor(7, evaluate=False) <= 8) == True
+    assert (floor(7, evaluate=False) < 8) == True
+
+    assert (floor(x) <= 5.5) == Le(floor(x), 5.5, evaluate=False)
+    assert (floor(x) >= -3.2) == Ge(floor(x), -3.2, evaluate=False)
+    assert (floor(x) < 2.9) == Lt(floor(x), 2.9, evaluate=False)
+    assert (floor(x) > -1.7) == Gt(floor(x), -1.7, evaluate=False)
+
+    assert (floor(y) <= 5.5) == (y < 6)
+    assert (floor(y) >= -3.2) == (y >= -3)
+    assert (floor(y) < 2.9) == (y < 3)
+    assert (floor(y) > -1.7) == (y >= -1)
+
+    assert (floor(y) <= n) == (y < n + 1)
+    assert (floor(y) >= n) == (y >= n)
+    assert (floor(y) < n) == (y < n)
+    assert (floor(y) > n) == (y >= n + 1)
+
+    assert floor(RootOf(x**3 - 27*x, 2)) == 5
+
+
+def test_ceiling():
+
+    assert ceiling(nan) is nan
+
+    assert ceiling(oo) is oo
+    assert ceiling(-oo) is -oo
+    assert ceiling(zoo) is zoo
+
+    assert ceiling(0) == 0
+
+    assert ceiling(1) == 1
+    assert ceiling(-1) == -1
+
+    assert ceiling(I*log(asin(5)/abs(asin(5)))) == 1
+    assert ceiling(-I*log(asin(7)/abs(asin(7)))) == -1
+
+    assert ceiling(E) == 3
+    assert ceiling(-E) == -2
+
+    assert ceiling(2*E) == 6
+    assert ceiling(-2*E) == -5
+
+    assert ceiling(pi) == 4
+    assert ceiling(-pi) == -3
+
+    assert ceiling(S.Half) == 1
+    assert ceiling(Rational(-1, 2)) == 0
+
+    assert ceiling(Rational(7, 3)) == 3
+    assert ceiling(-Rational(7, 3)) == -2
+
+    assert ceiling(Float(17.0)) == 17
+    assert ceiling(-Float(17.0)) == -17
+
+    assert ceiling(Float(7.69)) == 8
+    assert ceiling(-Float(7.69)) == -7
+
+    assert ceiling(1/(m+1)) == S.One
+    assert ceiling((m+2)/(m+1)) == Integer(2)
+    assert ceiling(-1/(m+1)) == S.Zero
+    assert ceiling((m+2)/(-m-1)) == S.NegativeOne
+
+    assert ceiling(I) == I
+    assert ceiling(-I) == -I
+    e = ceiling(i)
+    assert e.func is ceiling and e.args[0] == i
+
+    assert ceiling(oo*I) == oo*I
+    assert ceiling(-oo*I) == -oo*I
+    assert ceiling(exp(I*pi/4)*oo) == exp(I*pi/4)*oo
+
+    assert ceiling(2*I) == 2*I
+    assert ceiling(-2*I) == -2*I
+
+    assert ceiling(I/2) == I
+    assert ceiling(-I/2) == 0
+
+    assert ceiling(E + 17) == 20
+    assert ceiling(pi + 2) == 6
+
+    assert ceiling(E + pi) == 6
+    assert ceiling(I + pi) == I + 4
+
+    assert ceiling(ceiling(pi)) == 4
+    assert ceiling(ceiling(y)) == ceiling(y)
+    assert ceiling(ceiling(x)) == ceiling(x)
+
+    assert unchanged(ceiling, x)
+    assert unchanged(ceiling, 2*x)
+    assert unchanged(ceiling, k*x)
+
+    assert ceiling(k) == k
+    assert ceiling(2*k) == 2*k
+    assert ceiling(k*n) == k*n
+
+    assert unchanged(ceiling, k/2)
+
+    assert unchanged(ceiling, x + y)
+
+    assert ceiling(x + 3) == ceiling(x) + 3
+    assert ceiling(x + 3.0) == ceiling(x) + 3
+    assert ceiling(x + 3.0*I) == ceiling(x) + 3*I
+    assert ceiling(x + k) == ceiling(x) + k
+
+    assert ceiling(y + 3) == ceiling(y) + 3
+    assert ceiling(y + k) == ceiling(y) + k
+
+    assert ceiling(3 + pi + y*I) == 7 + ceiling(y)*I
+
+    assert ceiling(k + n) == k + n
+
+    assert unchanged(ceiling, x*I)
+    assert ceiling(k*I) == k*I
+
+    assert ceiling(Rational(23, 10) - E*I) == 3 - 2*I
+
+    assert ceiling(sin(1)) == 1
+    assert ceiling(sin(-1)) == 0
+
+    assert ceiling(exp(2)) == 8
+
+    assert ceiling(-log(8)/log(2)) != -2
+    assert int(ceiling(-log(8)/log(2)).evalf(chop=True)) == -3
+
+    assert ceiling(factorial(50)/exp(1)) == \
+        11188719610782480504630258070757734324011354208865721592720336801
+
+    assert (ceiling(y) >= y) == True
+    assert (ceiling(y) > y).is_Relational
+    assert (ceiling(y) < y) == False
+    assert (ceiling(y) <= y).is_Relational
+    assert (ceiling(x) >= x).is_Relational  # x could be non-real
+    assert (ceiling(x) < x).is_Relational
+    assert (ceiling(x) >= y).is_Relational  # arg is not same as rhs
+    assert (ceiling(x) < y).is_Relational
+    assert (ceiling(y) >= -oo) == True
+    assert (ceiling(y) > -oo) == True
+    assert (ceiling(y) <= oo) == True
+    assert (ceiling(y) < oo) == True
+    assert (ceiling(b) < b) == False
+    assert (ceiling(b) <= b) == False
+    assert (ceiling(b) > b) == True
+    assert (ceiling(b) >= b) == True
+
+    assert ceiling(y).rewrite(floor) == -floor(-y)
+    assert ceiling(y).rewrite(frac) == y + frac(-y)
+    assert ceiling(y).rewrite(floor).subs(y, -pi) == -floor(pi)
+    assert ceiling(y).rewrite(floor).subs(y, E) == -floor(-E)
+    assert ceiling(y).rewrite(frac).subs(y, pi) == ceiling(pi)
+    assert ceiling(y).rewrite(frac).subs(y, -E) == ceiling(-E)
+
+    assert Eq(ceiling(y), y + frac(-y))
+    assert Eq(ceiling(y), -floor(-y))
+
+    neg = Symbol('neg', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    pos = Symbol('pos', positive=True)
+    np = Symbol('np', nonpositive=True)
+
+    assert (ceiling(neg) <= 0) == True
+    assert (ceiling(neg) < 0) == (neg <= -1)
+    assert (ceiling(neg) > 0) == False
+    assert (ceiling(neg) >= 0) == (neg > -1)
+    assert (ceiling(neg) > -3) == (neg > -3)
+    assert (ceiling(neg) <= 10) == (neg <= 10)
+
+    assert (ceiling(nn) < 0) == False
+    assert (ceiling(nn) >= 0) == True
+
+    assert (ceiling(pos) < 0) == False
+    assert (ceiling(pos) <= 0) == False
+    assert (ceiling(pos) > 0) == True
+    assert (ceiling(pos) >= 0) == True
+    assert (ceiling(pos) >= 1) == True
+    assert (ceiling(pos) > 5) == (pos > 5)
+
+    assert (ceiling(np) <= 0) == True
+    assert (ceiling(np) > 0) == False
+
+    assert ceiling(neg).is_positive == False
+    assert ceiling(neg).is_nonpositive == True
+    assert ceiling(nn).is_positive is None
+    assert ceiling(nn).is_nonpositive is None
+    assert ceiling(pos).is_positive == True
+    assert ceiling(pos).is_nonpositive == False
+    assert ceiling(np).is_positive == False
+    assert ceiling(np).is_nonpositive == True
+
+    assert (ceiling(7, evaluate=False) >= 7) == True
+    assert (ceiling(7, evaluate=False) > 7) == False
+    assert (ceiling(7, evaluate=False) <= 7) == True
+    assert (ceiling(7, evaluate=False) < 7) == False
+
+    assert (ceiling(7, evaluate=False) >= 6) == True
+    assert (ceiling(7, evaluate=False) > 6) == True
+    assert (ceiling(7, evaluate=False) <= 6) == False
+    assert (ceiling(7, evaluate=False) < 6) == False
+
+    assert (ceiling(7, evaluate=False) >= 8) == False
+    assert (ceiling(7, evaluate=False) > 8) == False
+    assert (ceiling(7, evaluate=False) <= 8) == True
+    assert (ceiling(7, evaluate=False) < 8) == True
+
+    assert (ceiling(x) <= 5.5) == Le(ceiling(x), 5.5, evaluate=False)
+    assert (ceiling(x) >= -3.2) == Ge(ceiling(x), -3.2, evaluate=False)
+    assert (ceiling(x) < 2.9) == Lt(ceiling(x), 2.9, evaluate=False)
+    assert (ceiling(x) > -1.7) == Gt(ceiling(x), -1.7, evaluate=False)
+
+    assert (ceiling(y) <= 5.5) == (y <= 5)
+    assert (ceiling(y) >= -3.2) == (y > -4)
+    assert (ceiling(y) < 2.9) == (y <= 2)
+    assert (ceiling(y) > -1.7) == (y > -2)
+
+    assert (ceiling(y) <= n) == (y <= n)
+    assert (ceiling(y) >= n) == (y > n - 1)
+    assert (ceiling(y) < n) == (y <= n - 1)
+    assert (ceiling(y) > n) == (y > n)
+
+    assert ceiling(RootOf(x**3 - 27*x, 2)) == 6
+    s = ImageSet(Lambda(n, n + (CRootOf(x**5 - x**2 + 1, 0))), Integers)
+    f = CRootOf(x**5 - x**2 + 1, 0)
+    s = ImageSet(Lambda(n, n + f), Integers)
+    assert s.intersect(Interval(-10, 10)) == {i + f for i in range(-9, 11)}
+
+
+def test_frac():
+    assert isinstance(frac(x), frac)
+    assert frac(oo) == AccumBounds(0, 1)
+    assert frac(-oo) == AccumBounds(0, 1)
+    assert frac(zoo) is nan
+
+    assert frac(n) == 0
+    assert frac(nan) is nan
+    assert frac(Rational(4, 3)) == Rational(1, 3)
+    assert frac(-Rational(4, 3)) == Rational(2, 3)
+    assert frac(Rational(-4, 3)) == Rational(2, 3)
+
+    r = Symbol('r', real=True)
+    assert frac(I*r) == I*frac(r)
+    assert frac(1 + I*r) == I*frac(r)
+    assert frac(0.5 + I*r) == 0.5 + I*frac(r)
+    assert frac(n + I*r) == I*frac(r)
+    assert frac(n + I*k) == 0
+    assert unchanged(frac, x + I*x)
+    assert frac(x + I*n) == frac(x)
+
+    assert frac(x).rewrite(floor) == x - floor(x)
+    assert frac(x).rewrite(ceiling) == x + ceiling(-x)
+    assert frac(y).rewrite(floor).subs(y, pi) == frac(pi)
+    assert frac(y).rewrite(floor).subs(y, -E) == frac(-E)
+    assert frac(y).rewrite(ceiling).subs(y, -pi) == frac(-pi)
+    assert frac(y).rewrite(ceiling).subs(y, E) == frac(E)
+
+    assert Eq(frac(y), y - floor(y))
+    assert Eq(frac(y), y + ceiling(-y))
+
+    r = Symbol('r', real=True)
+    p_i = Symbol('p_i', integer=True, positive=True)
+    n_i = Symbol('p_i', integer=True, negative=True)
+    np_i = Symbol('np_i', integer=True, nonpositive=True)
+    nn_i = Symbol('nn_i', integer=True, nonnegative=True)
+    p_r = Symbol('p_r', positive=True)
+    n_r = Symbol('n_r', negative=True)
+    np_r = Symbol('np_r', real=True, nonpositive=True)
+    nn_r = Symbol('nn_r', real=True, nonnegative=True)
+
+    # Real frac argument, integer rhs
+    assert frac(r) <= p_i
+    assert not frac(r) <= n_i
+    assert (frac(r) <= np_i).has(Le)
+    assert (frac(r) <= nn_i).has(Le)
+    assert frac(r) < p_i
+    assert not frac(r) < n_i
+    assert not frac(r) < np_i
+    assert (frac(r) < nn_i).has(Lt)
+    assert not frac(r) >= p_i
+    assert frac(r) >= n_i
+    assert frac(r) >= np_i
+    assert (frac(r) >= nn_i).has(Ge)
+    assert not frac(r) > p_i
+    assert frac(r) > n_i
+    assert (frac(r) > np_i).has(Gt)
+    assert (frac(r) > nn_i).has(Gt)
+
+    assert not Eq(frac(r), p_i)
+    assert not Eq(frac(r), n_i)
+    assert Eq(frac(r), np_i).has(Eq)
+    assert Eq(frac(r), nn_i).has(Eq)
+
+    assert Ne(frac(r), p_i)
+    assert Ne(frac(r), n_i)
+    assert Ne(frac(r), np_i).has(Ne)
+    assert Ne(frac(r), nn_i).has(Ne)
+
+
+    # Real frac argument, real rhs
+    assert (frac(r) <= p_r).has(Le)
+    assert not frac(r) <= n_r
+    assert (frac(r) <= np_r).has(Le)
+    assert (frac(r) <= nn_r).has(Le)
+    assert (frac(r) < p_r).has(Lt)
+    assert not frac(r) < n_r
+    assert not frac(r) < np_r
+    assert (frac(r) < nn_r).has(Lt)
+    assert (frac(r) >= p_r).has(Ge)
+    assert frac(r) >= n_r
+    assert frac(r) >= np_r
+    assert (frac(r) >= nn_r).has(Ge)
+    assert (frac(r) > p_r).has(Gt)
+    assert frac(r) > n_r
+    assert (frac(r) > np_r).has(Gt)
+    assert (frac(r) > nn_r).has(Gt)
+
+    assert not Eq(frac(r), n_r)
+    assert Eq(frac(r), p_r).has(Eq)
+    assert Eq(frac(r), np_r).has(Eq)
+    assert Eq(frac(r), nn_r).has(Eq)
+
+    assert Ne(frac(r), p_r).has(Ne)
+    assert Ne(frac(r), n_r)
+    assert Ne(frac(r), np_r).has(Ne)
+    assert Ne(frac(r), nn_r).has(Ne)
+
+    # Real frac argument, +/- oo rhs
+    assert frac(r) < oo
+    assert frac(r) <= oo
+    assert not frac(r) > oo
+    assert not frac(r) >= oo
+
+    assert not frac(r) < -oo
+    assert not frac(r) <= -oo
+    assert frac(r) > -oo
+    assert frac(r) >= -oo
+
+    assert frac(r) < 1
+    assert frac(r) <= 1
+    assert not frac(r) > 1
+    assert not frac(r) >= 1
+
+    assert not frac(r) < 0
+    assert (frac(r) <= 0).has(Le)
+    assert (frac(r) > 0).has(Gt)
+    assert frac(r) >= 0
+
+    # Some test for numbers
+    assert frac(r) <= sqrt(2)
+    assert (frac(r) <= sqrt(3) - sqrt(2)).has(Le)
+    assert not frac(r) <= sqrt(2) - sqrt(3)
+    assert not frac(r) >= sqrt(2)
+    assert (frac(r) >= sqrt(3) - sqrt(2)).has(Ge)
+    assert frac(r) >= sqrt(2) - sqrt(3)
+
+    assert not Eq(frac(r), sqrt(2))
+    assert Eq(frac(r), sqrt(3) - sqrt(2)).has(Eq)
+    assert not Eq(frac(r), sqrt(2) - sqrt(3))
+    assert Ne(frac(r), sqrt(2))
+    assert Ne(frac(r), sqrt(3) - sqrt(2)).has(Ne)
+    assert Ne(frac(r), sqrt(2) - sqrt(3))
+
+    assert frac(p_i, evaluate=False).is_zero
+    assert frac(p_i, evaluate=False).is_finite
+    assert frac(p_i, evaluate=False).is_integer
+    assert frac(p_i, evaluate=False).is_real
+    assert frac(r).is_finite
+    assert frac(r).is_real
+    assert frac(r).is_zero is None
+    assert frac(r).is_integer is None
+
+    assert frac(oo).is_finite
+    assert frac(oo).is_real
+
+
+def test_series():
+    x, y = symbols('x,y')
+    assert floor(x).nseries(x, y, 100) == floor(y)
+    assert ceiling(x).nseries(x, y, 100) == ceiling(y)
+    assert floor(x).nseries(x, pi, 100) == 3
+    assert ceiling(x).nseries(x, pi, 100) == 4
+    assert floor(x).nseries(x, 0, 100) == 0
+    assert ceiling(x).nseries(x, 0, 100) == 1
+    assert floor(-x).nseries(x, 0, 100) == -1
+    assert ceiling(-x).nseries(x, 0, 100) == 0
+
+
+def test_issue_14355():
+    # This test checks the leading term and series for the floor and ceil
+    # function when arg0 evaluates to S.NaN.
+    assert floor((x**3 + x)/(x**2 - x)).as_leading_term(x, cdir = 1) == -2
+    assert floor((x**3 + x)/(x**2 - x)).as_leading_term(x, cdir = -1) == -1
+    assert floor((cos(x) - 1)/x).as_leading_term(x, cdir = 1) == -1
+    assert floor((cos(x) - 1)/x).as_leading_term(x, cdir = -1) == 0
+    assert floor(sin(x)/x).as_leading_term(x, cdir = 1) == 0
+    assert floor(sin(x)/x).as_leading_term(x, cdir = -1) == 0
+    assert floor(-tan(x)/x).as_leading_term(x, cdir = 1) == -2
+    assert floor(-tan(x)/x).as_leading_term(x, cdir = -1) == -2
+    assert floor(sin(x)/x/3).as_leading_term(x, cdir = 1) == 0
+    assert floor(sin(x)/x/3).as_leading_term(x, cdir = -1) == 0
+    assert ceiling((x**3 + x)/(x**2 - x)).as_leading_term(x, cdir = 1) == -1
+    assert ceiling((x**3 + x)/(x**2 - x)).as_leading_term(x, cdir = -1) == 0
+    assert ceiling((cos(x) - 1)/x).as_leading_term(x, cdir = 1) == 0
+    assert ceiling((cos(x) - 1)/x).as_leading_term(x, cdir = -1) == 1
+    assert ceiling(sin(x)/x).as_leading_term(x, cdir = 1) == 1
+    assert ceiling(sin(x)/x).as_leading_term(x, cdir = -1) == 1
+    assert ceiling(-tan(x)/x).as_leading_term(x, cdir = 1) == -1
+    assert ceiling(-tan(x)/x).as_leading_term(x, cdir = 1) == -1
+    assert ceiling(sin(x)/x/3).as_leading_term(x, cdir = 1) == 1
+    assert ceiling(sin(x)/x/3).as_leading_term(x, cdir = -1) == 1
+    # test for series
+    assert floor(sin(x)/x).series(x, 0, 100, cdir = 1) == 0
+    assert floor(sin(x)/x).series(x, 0, 100, cdir = 1) == 0
+    assert floor((x**3 + x)/(x**2 - x)).series(x, 0, 100, cdir = 1) == -2
+    assert floor((x**3 + x)/(x**2 - x)).series(x, 0, 100, cdir = -1) == -1
+    assert ceiling(sin(x)/x).series(x, 0, 100, cdir = 1) == 1
+    assert ceiling(sin(x)/x).series(x, 0, 100, cdir = -1) == 1
+    assert ceiling((x**3 + x)/(x**2 - x)).series(x, 0, 100, cdir = 1) == -1
+    assert ceiling((x**3 + x)/(x**2 - x)).series(x, 0, 100, cdir = -1) == 0
+
+
+def test_frac_leading_term():
+    assert frac(x).as_leading_term(x) == x
+    assert frac(x).as_leading_term(x, cdir = 1) == x
+    assert frac(x).as_leading_term(x, cdir = -1) == 1
+    assert frac(x + S.Half).as_leading_term(x, cdir = 1) == S.Half
+    assert frac(x + S.Half).as_leading_term(x, cdir = -1) == S.Half
+    assert frac(-2*x + 1).as_leading_term(x, cdir = 1) == S.One
+    assert frac(-2*x + 1).as_leading_term(x, cdir = -1) == -2*x
+    assert frac(sin(x) + 5).as_leading_term(x, cdir = 1) == x
+    assert frac(sin(x) + 5).as_leading_term(x, cdir = -1) == S.One
+    assert frac(sin(x**2) + 5).as_leading_term(x, cdir = 1) == x**2
+    assert frac(sin(x**2) + 5).as_leading_term(x, cdir = -1) == x**2
+
+
+@XFAIL
+def test_issue_4149():
+    assert floor(3 + pi*I + y*I) == 3 + floor(pi + y)*I
+    assert floor(3*I + pi*I + y*I) == floor(3 + pi + y)*I
+    assert floor(3 + E + pi*I + y*I) == 5 + floor(pi + y)*I
+
+
+def test_issue_21651():
+    k = Symbol('k', positive=True, integer=True)
+    exp = 2*2**(-k)
+    assert isinstance(floor(exp), floor)
+
+
+def test_issue_11207():
+    assert floor(floor(x)) == floor(x)
+    assert floor(ceiling(x)) == ceiling(x)
+    assert ceiling(floor(x)) == floor(x)
+    assert ceiling(ceiling(x)) == ceiling(x)
+
+
+def test_nested_floor_ceiling():
+    assert floor(-floor(ceiling(x**3)/y)) == -floor(ceiling(x**3)/y)
+    assert ceiling(-floor(ceiling(x**3)/y)) == -floor(ceiling(x**3)/y)
+    assert floor(ceiling(-floor(x**Rational(7, 2)/y))) == -floor(x**Rational(7, 2)/y)
+    assert -ceiling(-ceiling(floor(x)/y)) == ceiling(floor(x)/y)
+
+def test_issue_18689():
+    assert floor(floor(floor(x)) + 3) == floor(x) + 3
+    assert ceiling(ceiling(ceiling(x)) + 1) == ceiling(x) + 1
+    assert ceiling(ceiling(floor(x)) + 3) == floor(x) + 3
+
+def test_issue_18421():
+    assert floor(float(0)) is S.Zero
+    assert ceiling(float(0)) is S.Zero
+
+def test_issue_25230():
+    a = Symbol('a', real = True)
+    b = Symbol('b', positive = True)
+    c = Symbol('c', negative = True)
+    raises(NotImplementedError, lambda: floor(x/a).as_leading_term(x, cdir = 1))
+    raises(NotImplementedError, lambda: ceiling(x/a).as_leading_term(x, cdir = 1))
+    assert floor(x/b).as_leading_term(x, cdir = 1) == 0
+    assert floor(x/b).as_leading_term(x, cdir = -1) == -1
+    assert floor(x/c).as_leading_term(x, cdir = 1) == -1
+    assert floor(x/c).as_leading_term(x, cdir = -1) == 0
+    assert ceiling(x/b).as_leading_term(x, cdir = 1) == 1
+    assert ceiling(x/b).as_leading_term(x, cdir = -1) == 0
+    assert ceiling(x/c).as_leading_term(x, cdir = 1) == 0
+    assert ceiling(x/c).as_leading_term(x, cdir = -1) == 1
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_interface.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_interface.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ae2f78b50bea24c64079066076971e315660d69
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_interface.py
@@ -0,0 +1,82 @@
+# This test file tests the SymPy function interface, that people use to create
+# their own new functions. It should be as easy as possible.
+#
+# We test that it works with both Function and DefinedFunction. New code should
+# use DefinedFunction because it has better type inference. Old code still
+# using Function should continue to work though.
+from sympy.core.function import Function, DefinedFunction
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.series.limits import limit
+from sympy.abc import x
+
+
+def test_function_series1():
+    """Create our new "sin" function."""
+
+    for F in [Function, DefinedFunction]:
+
+        class my_function(F):
+
+            def fdiff(self, argindex=1):
+                return cos(self.args[0])
+
+            @classmethod
+            def eval(cls, arg):
+                arg = sympify(arg)
+                if arg == 0:
+                    return sympify(0)
+
+        #Test that the taylor series is correct
+        assert my_function(x).series(x, 0, 10) == sin(x).series(x, 0, 10)
+        assert limit(my_function(x)/x, x, 0) == 1
+
+
+def test_function_series2():
+    """Create our new "cos" function."""
+
+    for F in [Function, DefinedFunction]:
+
+        class my_function2(F):
+
+            def fdiff(self, argindex=1):
+                return -sin(self.args[0])
+
+            @classmethod
+            def eval(cls, arg):
+                arg = sympify(arg)
+                if arg == 0:
+                    return sympify(1)
+
+        #Test that the taylor series is correct
+        assert my_function2(x).series(x, 0, 10) == cos(x).series(x, 0, 10)
+
+
+def test_function_series3():
+    """
+    Test our easy "tanh" function.
+
+    This test tests two things:
+      * that the Function interface works as expected and it's easy to use
+      * that the general algorithm for the series expansion works even when the
+        derivative is defined recursively in terms of the original function,
+        since tanh(x).diff(x) == 1-tanh(x)**2
+    """
+
+    for F in [Function, DefinedFunction]:
+
+        class mytanh(F):
+
+            def fdiff(self, argindex=1):
+                return 1 - mytanh(self.args[0])**2
+
+            @classmethod
+            def eval(cls, arg):
+                arg = sympify(arg)
+                if arg == 0:
+                    return sympify(0)
+
+        e = tanh(x)
+        f = mytanh(x)
+        assert e.series(x, 0, 6) == f.series(x, 0, 6)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_miscellaneous.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_miscellaneous.py
new file mode 100644
index 0000000000000000000000000000000000000000..374c4fb50eaae54a9884015c124c245385e1761e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_miscellaneous.py
@@ -0,0 +1,504 @@
+import itertools as it
+
+from sympy.core.expr import unchanged
+from sympy.core.function import Function
+from sympy.core.numbers import I, oo, Rational
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.external import import_module
+from sympy.functions.elementary.exponential import log
+from sympy.functions.elementary.integers import floor, ceiling
+from sympy.functions.elementary.miscellaneous import (sqrt, cbrt, root, Min,
+                                                      Max, real_root, Rem)
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.delta_functions import Heaviside
+
+from sympy.utilities.lambdify import lambdify
+from sympy.testing.pytest import raises, skip, ignore_warnings
+
+def test_Min():
+    from sympy.abc import x, y, z
+    n = Symbol('n', negative=True)
+    n_ = Symbol('n_', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    nn_ = Symbol('nn_', nonnegative=True)
+    p = Symbol('p', positive=True)
+    p_ = Symbol('p_', positive=True)
+    np = Symbol('np', nonpositive=True)
+    np_ = Symbol('np_', nonpositive=True)
+    r = Symbol('r', real=True)
+
+    assert Min(5, 4) == 4
+    assert Min(-oo, -oo) is -oo
+    assert Min(-oo, n) is -oo
+    assert Min(n, -oo) is -oo
+    assert Min(-oo, np) is -oo
+    assert Min(np, -oo) is -oo
+    assert Min(-oo, 0) is -oo
+    assert Min(0, -oo) is -oo
+    assert Min(-oo, nn) is -oo
+    assert Min(nn, -oo) is -oo
+    assert Min(-oo, p) is -oo
+    assert Min(p, -oo) is -oo
+    assert Min(-oo, oo) is -oo
+    assert Min(oo, -oo) is -oo
+    assert Min(n, n) == n
+    assert unchanged(Min, n, np)
+    assert Min(np, n) == Min(n, np)
+    assert Min(n, 0) == n
+    assert Min(0, n) == n
+    assert Min(n, nn) == n
+    assert Min(nn, n) == n
+    assert Min(n, p) == n
+    assert Min(p, n) == n
+    assert Min(n, oo) == n
+    assert Min(oo, n) == n
+    assert Min(np, np) == np
+    assert Min(np, 0) == np
+    assert Min(0, np) == np
+    assert Min(np, nn) == np
+    assert Min(nn, np) == np
+    assert Min(np, p) == np
+    assert Min(p, np) == np
+    assert Min(np, oo) == np
+    assert Min(oo, np) == np
+    assert Min(0, 0) == 0
+    assert Min(0, nn) == 0
+    assert Min(nn, 0) == 0
+    assert Min(0, p) == 0
+    assert Min(p, 0) == 0
+    assert Min(0, oo) == 0
+    assert Min(oo, 0) == 0
+    assert Min(nn, nn) == nn
+    assert unchanged(Min, nn, p)
+    assert Min(p, nn) == Min(nn, p)
+    assert Min(nn, oo) == nn
+    assert Min(oo, nn) == nn
+    assert Min(p, p) == p
+    assert Min(p, oo) == p
+    assert Min(oo, p) == p
+    assert Min(oo, oo) is oo
+
+    assert Min(n, n_).func is Min
+    assert Min(nn, nn_).func is Min
+    assert Min(np, np_).func is Min
+    assert Min(p, p_).func is Min
+
+    # lists
+    assert Min() is S.Infinity
+    assert Min(x) == x
+    assert Min(x, y) == Min(y, x)
+    assert Min(x, y, z) == Min(z, y, x)
+    assert Min(x, Min(y, z)) == Min(z, y, x)
+    assert Min(x, Max(y, -oo)) == Min(x, y)
+    assert Min(p, oo, n, p, p, p_) == n
+    assert Min(p_, n_, p) == n_
+    assert Min(n, oo, -7, p, p, 2) == Min(n, -7)
+    assert Min(2, x, p, n, oo, n_, p, 2, -2, -2) == Min(-2, x, n, n_)
+    assert Min(0, x, 1, y) == Min(0, x, y)
+    assert Min(1000, 100, -100, x, p, n) == Min(n, x, -100)
+    assert unchanged(Min, sin(x), cos(x))
+    assert Min(sin(x), cos(x)) == Min(cos(x), sin(x))
+    assert Min(cos(x), sin(x)).subs(x, 1) == cos(1)
+    assert Min(cos(x), sin(x)).subs(x, S.Half) == sin(S.Half)
+    raises(ValueError, lambda: Min(cos(x), sin(x)).subs(x, I))
+    raises(ValueError, lambda: Min(I))
+    raises(ValueError, lambda: Min(I, x))
+    raises(ValueError, lambda: Min(S.ComplexInfinity, x))
+
+    assert Min(1, x).diff(x) == Heaviside(1 - x)
+    assert Min(x, 1).diff(x) == Heaviside(1 - x)
+    assert Min(0, -x, 1 - 2*x).diff(x) == -Heaviside(x + Min(0, -2*x + 1)) \
+        - 2*Heaviside(2*x + Min(0, -x) - 1)
+
+    # issue 7619
+    f = Function('f')
+    assert Min(1, 2*Min(f(1), 2))  # doesn't fail
+
+    # issue 7233
+    e = Min(0, x)
+    assert e.n().args == (0, x)
+
+    # issue 8643
+    m = Min(n, p_, n_, r)
+    assert m.is_positive is False
+    assert m.is_nonnegative is False
+    assert m.is_negative is True
+
+    m = Min(p, p_)
+    assert m.is_positive is True
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Min(p, nn_, p_)
+    assert m.is_positive is None
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Min(nn, p, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is None
+    assert m.is_negative is None
+
+
+def test_Max():
+    from sympy.abc import x, y, z
+    n = Symbol('n', negative=True)
+    n_ = Symbol('n_', negative=True)
+    nn = Symbol('nn', nonnegative=True)
+    p = Symbol('p', positive=True)
+    p_ = Symbol('p_', positive=True)
+    r = Symbol('r', real=True)
+
+    assert Max(5, 4) == 5
+
+    # lists
+
+    assert Max() is S.NegativeInfinity
+    assert Max(x) == x
+    assert Max(x, y) == Max(y, x)
+    assert Max(x, y, z) == Max(z, y, x)
+    assert Max(x, Max(y, z)) == Max(z, y, x)
+    assert Max(x, Min(y, oo)) == Max(x, y)
+    assert Max(n, -oo, n_, p, 2) == Max(p, 2)
+    assert Max(n, -oo, n_, p) == p
+    assert Max(2, x, p, n, -oo, S.NegativeInfinity, n_, p, 2) == Max(2, x, p)
+    assert Max(0, x, 1, y) == Max(1, x, y)
+    assert Max(r, r + 1, r - 1) == 1 + r
+    assert Max(1000, 100, -100, x, p, n) == Max(p, x, 1000)
+    assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
+    assert Max(cos(x), sin(x)).subs(x, 1) == sin(1)
+    assert Max(cos(x), sin(x)).subs(x, S.Half) == cos(S.Half)
+    raises(ValueError, lambda: Max(cos(x), sin(x)).subs(x, I))
+    raises(ValueError, lambda: Max(I))
+    raises(ValueError, lambda: Max(I, x))
+    raises(ValueError, lambda: Max(S.ComplexInfinity, 1))
+    assert Max(n, -oo, n_,  p, 2) == Max(p, 2)
+    assert Max(n, -oo, n_,  p, 1000) == Max(p, 1000)
+
+    assert Max(1, x).diff(x) == Heaviside(x - 1)
+    assert Max(x, 1).diff(x) == Heaviside(x - 1)
+    assert Max(x**2, 1 + x, 1).diff(x) == \
+        2*x*Heaviside(x**2 - Max(1, x + 1)) \
+        + Heaviside(x - Max(1, x**2) + 1)
+
+    e = Max(0, x)
+    assert e.n().args == (0, x)
+
+    # issue 8643
+    m = Max(p, p_, n, r)
+    assert m.is_positive is True
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+    m = Max(n, n_)
+    assert m.is_positive is False
+    assert m.is_nonnegative is False
+    assert m.is_negative is True
+
+    m = Max(n, n_, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is None
+    assert m.is_negative is None
+
+    m = Max(n, nn, r)
+    assert m.is_positive is None
+    assert m.is_nonnegative is True
+    assert m.is_negative is False
+
+
+def test_minmax_assumptions():
+    r = Symbol('r', real=True)
+    a = Symbol('a', real=True, algebraic=True)
+    t = Symbol('t', real=True, transcendental=True)
+    q = Symbol('q', rational=True)
+    p = Symbol('p', irrational=True)
+    n = Symbol('n', rational=True, integer=False)
+    i = Symbol('i', integer=True)
+    o = Symbol('o', odd=True)
+    e = Symbol('e', even=True)
+    k = Symbol('k', prime=True)
+    reals = [r, a, t, q, p, n, i, o, e, k]
+
+    for ext in (Max, Min):
+        for x, y in it.product(reals, repeat=2):
+
+            # Must be real
+            assert ext(x, y).is_real
+
+            # Algebraic?
+            if x.is_algebraic and y.is_algebraic:
+                assert ext(x, y).is_algebraic
+            elif x.is_transcendental and y.is_transcendental:
+                assert ext(x, y).is_transcendental
+            else:
+                assert ext(x, y).is_algebraic is None
+
+            # Rational?
+            if x.is_rational and y.is_rational:
+                assert ext(x, y).is_rational
+            elif x.is_irrational and y.is_irrational:
+                assert ext(x, y).is_irrational
+            else:
+                assert ext(x, y).is_rational is None
+
+            # Integer?
+            if x.is_integer and y.is_integer:
+                assert ext(x, y).is_integer
+            elif x.is_noninteger and y.is_noninteger:
+                assert ext(x, y).is_noninteger
+            else:
+                assert ext(x, y).is_integer is None
+
+            # Odd?
+            if x.is_odd and y.is_odd:
+                assert ext(x, y).is_odd
+            elif x.is_odd is False and y.is_odd is False:
+                assert ext(x, y).is_odd is False
+            else:
+                assert ext(x, y).is_odd is None
+
+            # Even?
+            if x.is_even and y.is_even:
+                assert ext(x, y).is_even
+            elif x.is_even is False and y.is_even is False:
+                assert ext(x, y).is_even is False
+            else:
+                assert ext(x, y).is_even is None
+
+            # Prime?
+            if x.is_prime and y.is_prime:
+                assert ext(x, y).is_prime
+            elif x.is_prime is False and y.is_prime is False:
+                assert ext(x, y).is_prime is False
+            else:
+                assert ext(x, y).is_prime is None
+
+
+def test_issue_8413():
+    x = Symbol('x', real=True)
+    # we can't evaluate in general because non-reals are not
+    # comparable: Min(floor(3.2 + I), 3.2 + I) -> ValueError
+    assert Min(floor(x), x) == floor(x)
+    assert Min(ceiling(x), x) == x
+    assert Max(floor(x), x) == x
+    assert Max(ceiling(x), x) == ceiling(x)
+
+
+def test_root():
+    from sympy.abc import x
+    n = Symbol('n', integer=True)
+    k = Symbol('k', integer=True)
+
+    assert root(2, 2) == sqrt(2)
+    assert root(2, 1) == 2
+    assert root(2, 3) == 2**Rational(1, 3)
+    assert root(2, 3) == cbrt(2)
+    assert root(2, -5) == 2**Rational(4, 5)/2
+
+    assert root(-2, 1) == -2
+
+    assert root(-2, 2) == sqrt(2)*I
+    assert root(-2, 1) == -2
+
+    assert root(x, 2) == sqrt(x)
+    assert root(x, 1) == x
+    assert root(x, 3) == x**Rational(1, 3)
+    assert root(x, 3) == cbrt(x)
+    assert root(x, -5) == x**Rational(-1, 5)
+
+    assert root(x, n) == x**(1/n)
+    assert root(x, -n) == x**(-1/n)
+
+    assert root(x, n, k) == (-1)**(2*k/n)*x**(1/n)
+
+
+def test_real_root():
+    assert real_root(-8, 3) == -2
+    assert real_root(-16, 4) == root(-16, 4)
+    r = root(-7, 4)
+    assert real_root(r) == r
+    r1 = root(-1, 3)
+    r2 = r1**2
+    r3 = root(-1, 4)
+    assert real_root(r1 + r2 + r3) == -1 + r2 + r3
+    assert real_root(root(-2, 3)) == -root(2, 3)
+    assert real_root(-8., 3) == -2.0
+    x = Symbol('x')
+    n = Symbol('n')
+    g = real_root(x, n)
+    assert g.subs({"x": -8, "n": 3}) == -2
+    assert g.subs({"x": 8, "n": 3}) == 2
+    # give principle root if there is no real root -- if this is not desired
+    # then maybe a Root class is needed to raise an error instead
+    assert g.subs({"x": I, "n": 3}) == cbrt(I)
+    assert g.subs({"x": -8, "n": 2}) == sqrt(-8)
+    assert g.subs({"x": I, "n": 2}) == sqrt(I)
+
+
+def test_issue_11463():
+    numpy = import_module('numpy')
+    if not numpy:
+        skip("numpy not installed.")
+    x = Symbol('x')
+    f = lambdify(x, real_root((log(x/(x-2))), 3), 'numpy')
+    # numpy.select evaluates all options before considering conditions,
+    # so it raises a warning about root of negative number which does
+    # not affect the outcome. This warning is suppressed here
+    with ignore_warnings(RuntimeWarning):
+        assert f(numpy.array(-1)) < -1
+
+
+def test_rewrite_MaxMin_as_Heaviside():
+    from sympy.abc import x
+    assert Max(0, x).rewrite(Heaviside) == x*Heaviside(x)
+    assert Max(3, x).rewrite(Heaviside) == x*Heaviside(x - 3) + \
+        3*Heaviside(-x + 3)
+    assert Max(0, x+2, 2*x).rewrite(Heaviside) == \
+        2*x*Heaviside(2*x)*Heaviside(x - 2) + \
+        (x + 2)*Heaviside(-x + 2)*Heaviside(x + 2)
+
+    assert Min(0, x).rewrite(Heaviside) == x*Heaviside(-x)
+    assert Min(3, x).rewrite(Heaviside) == x*Heaviside(-x + 3) + \
+        3*Heaviside(x - 3)
+    assert Min(x, -x, -2).rewrite(Heaviside) == \
+        x*Heaviside(-2*x)*Heaviside(-x - 2) - \
+        x*Heaviside(2*x)*Heaviside(x - 2) \
+        - 2*Heaviside(-x + 2)*Heaviside(x + 2)
+
+
+def test_rewrite_MaxMin_as_Piecewise():
+    from sympy.core.symbol import symbols
+    from sympy.functions.elementary.piecewise import Piecewise
+    x, y, z, a, b = symbols('x y z a b', real=True)
+    vx, vy, va = symbols('vx vy va')
+    assert Max(a, b).rewrite(Piecewise) == Piecewise((a, a >= b), (b, True))
+    assert Max(x, y, z).rewrite(Piecewise) == Piecewise((x, (x >= y) & (x >= z)), (y, y >= z), (z, True))
+    assert Max(x, y, a, b).rewrite(Piecewise) == Piecewise((a, (a >= b) & (a >= x) & (a >= y)),
+        (b, (b >= x) & (b >= y)), (x, x >= y), (y, True))
+    assert Min(a, b).rewrite(Piecewise) == Piecewise((a, a <= b), (b, True))
+    assert Min(x, y, z).rewrite(Piecewise) == Piecewise((x, (x <= y) & (x <= z)), (y, y <= z), (z, True))
+    assert Min(x,  y, a, b).rewrite(Piecewise) ==  Piecewise((a, (a <= b) & (a <= x) & (a <= y)),
+        (b, (b <= x) & (b <= y)), (x, x <= y), (y, True))
+
+    # Piecewise rewriting of Min/Max does also takes place for not explicitly real arguments
+    assert Max(vx, vy).rewrite(Piecewise) == Piecewise((vx, vx >= vy), (vy, True))
+    assert Min(va, vx, vy).rewrite(Piecewise) == Piecewise((va, (va <= vx) & (va <= vy)), (vx, vx <= vy), (vy, True))
+
+
+def test_issue_11099():
+    from sympy.abc import x, y
+    # some fixed value tests
+    fixed_test_data = {x: -2, y: 3}
+    assert Min(x, y).evalf(subs=fixed_test_data) == \
+        Min(x, y).subs(fixed_test_data).evalf()
+    assert Max(x, y).evalf(subs=fixed_test_data) == \
+        Max(x, y).subs(fixed_test_data).evalf()
+    # randomly generate some test data
+    from sympy.core.random import randint
+    for i in range(20):
+        random_test_data = {x: randint(-100, 100), y: randint(-100, 100)}
+        assert Min(x, y).evalf(subs=random_test_data) == \
+            Min(x, y).subs(random_test_data).evalf()
+        assert Max(x, y).evalf(subs=random_test_data) == \
+            Max(x, y).subs(random_test_data).evalf()
+
+
+def test_issue_12638():
+    from sympy.abc import a, b, c
+    assert Min(a, b, c, Max(a, b)) == Min(a, b, c)
+    assert Min(a, b, Max(a, b, c)) == Min(a, b)
+    assert Min(a, b, Max(a, c)) == Min(a, b)
+
+def test_issue_21399():
+    from sympy.abc import a, b, c
+    assert Max(Min(a, b), Min(a, b, c)) == Min(a, b)
+
+
+def test_instantiation_evaluation():
+    from sympy.abc import v, w, x, y, z
+    assert Min(1, Max(2, x)) == 1
+    assert Max(3, Min(2, x)) == 3
+    assert Min(Max(x, y), Max(x, z)) == Max(x, Min(y, z))
+    assert set(Min(Max(w, x), Max(y, z)).args) == {
+        Max(w, x), Max(y, z)}
+    assert Min(Max(x, y), Max(x, z), w) == Min(
+        w, Max(x, Min(y, z)))
+    A, B = Min, Max
+    for i in range(2):
+        assert A(x, B(x, y)) == x
+        assert A(x, B(y, A(x, w, z))) == A(x, B(y, A(w, z)))
+        A, B = B, A
+    assert Min(w, Max(x, y), Max(v, x, z)) == Min(
+        w, Max(x, Min(y, Max(v, z))))
+
+def test_rewrite_as_Abs():
+    from itertools import permutations
+    from sympy.functions.elementary.complexes import Abs
+    from sympy.abc import x, y, z, w
+    def test(e):
+        free = e.free_symbols
+        a = e.rewrite(Abs)
+        assert not a.has(Min, Max)
+        for i in permutations(range(len(free))):
+            reps = dict(zip(free, i))
+            assert a.xreplace(reps) == e.xreplace(reps)
+    test(Min(x, y))
+    test(Max(x, y))
+    test(Min(x, y, z))
+    test(Min(Max(w, x), Max(y, z)))
+
+def test_issue_14000():
+    assert isinstance(sqrt(4, evaluate=False), Pow) == True
+    assert isinstance(cbrt(3.5, evaluate=False), Pow) == True
+    assert isinstance(root(16, 4, evaluate=False), Pow) == True
+
+    assert sqrt(4, evaluate=False) == Pow(4, S.Half, evaluate=False)
+    assert cbrt(3.5, evaluate=False) == Pow(3.5, Rational(1, 3), evaluate=False)
+    assert root(4, 2, evaluate=False) == Pow(4, S.Half, evaluate=False)
+
+    assert root(16, 4, 2, evaluate=False).has(Pow) == True
+    assert real_root(-8, 3, evaluate=False).has(Pow) == True
+
+def test_issue_6899():
+    from sympy.core.function import Lambda
+    x = Symbol('x')
+    eqn = Lambda(x, x)
+    assert eqn.func(*eqn.args) == eqn
+
+def test_Rem():
+    from sympy.abc import x, y
+    assert Rem(5, 3) == 2
+    assert Rem(-5, 3) == -2
+    assert Rem(5, -3) == 2
+    assert Rem(-5, -3) == -2
+    assert Rem(x**3, y) == Rem(x**3, y)
+    assert Rem(Rem(-5, 3) + 3, 3) == 1
+
+
+def test_minmax_no_evaluate():
+    from sympy import evaluate
+    p = Symbol('p', positive=True)
+
+    assert Max(1, 3) == 3
+    assert Max(1, 3).args == ()
+    assert Max(0, p) == p
+    assert Max(0, p).args == ()
+    assert Min(0, p) == 0
+    assert Min(0, p).args == ()
+
+    assert Max(1, 3, evaluate=False) != 3
+    assert Max(1, 3, evaluate=False).args == (1, 3)
+    assert Max(0, p, evaluate=False) != p
+    assert Max(0, p, evaluate=False).args == (0, p)
+    assert Min(0, p, evaluate=False) != 0
+    assert Min(0, p, evaluate=False).args == (0, p)
+
+    with evaluate(False):
+        assert Max(1, 3) != 3
+        assert Max(1, 3).args == (1, 3)
+        assert Max(0, p) != p
+        assert Max(0, p).args == (0, p)
+        assert Min(0, p) != 0
+        assert Min(0, p).args == (0, p)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_piecewise.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_piecewise.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d0728095578b49480a1334857a1c237012d2534
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_piecewise.py
@@ -0,0 +1,1639 @@
+from sympy.concrete.summations import Sum
+from sympy.core.add import Add
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.expr import unchanged
+from sympy.core.function import (Function, diff, expand)
+from sympy.core.mul import Mul
+from sympy.core.mod import Mod
+from sympy.core.numbers import (Float, I, Rational, oo, pi, zoo)
+from sympy.core.relational import (Eq, Ge, Gt, 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.complexes import (Abs, adjoint, arg, conjugate, im, re, transpose)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import (Max, Min, sqrt)
+from sympy.functions.elementary.piecewise import (Piecewise,
+    piecewise_fold, piecewise_exclusive, Undefined, ExprCondPair)
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.tensor_functions import KroneckerDelta
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.logic.boolalg import (And, ITE, Not, Or)
+from sympy.matrices.expressions.matexpr import MatrixSymbol
+from sympy.printing import srepr
+from sympy.sets.contains import Contains
+from sympy.sets.sets import Interval
+from sympy.solvers.solvers import solve
+from sympy.testing.pytest import raises, slow
+from sympy.utilities.lambdify import lambdify
+
+a, b, c, d, x, y = symbols('a:d, x, y')
+z = symbols('z', nonzero=True)
+
+
+def test_piecewise1():
+
+    # Test canonicalization
+    assert Piecewise((x, x < 1.)).has(1.0)  # doesn't get changed to x < 1
+    assert unchanged(Piecewise, ExprCondPair(x, x < 1), ExprCondPair(0, True))
+    assert Piecewise((x, x < 1), (0, True)) == Piecewise(ExprCondPair(x, x < 1),
+                                                         ExprCondPair(0, True))
+    assert Piecewise((x, x < 1), (0, True), (1, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (0, False), (-1, 1 > 2)) == \
+        Piecewise((x, x < 1))
+    assert Piecewise((x, x < 1), (0, x < 1), (0, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (0, x < 2), (0, True)) == \
+        Piecewise((x, x < 1), (0, True))
+    assert Piecewise((x, x < 1), (x, x < 2), (0, True)) == \
+        Piecewise((x, Or(x < 1, x < 2)), (0, True))
+    assert Piecewise((x, x < 1), (x, x < 2), (x, True)) == x
+    assert Piecewise((x, True)) == x
+    # Explicitly constructed empty Piecewise not accepted
+    raises(TypeError, lambda: Piecewise())
+    # False condition is never retained
+    assert Piecewise((2*x, x < 0), (x, False)) == \
+        Piecewise((2*x, x < 0), (x, False), evaluate=False) == \
+        Piecewise((2*x, x < 0))
+    assert Piecewise((x, False)) == Undefined
+    raises(TypeError, lambda: Piecewise(x))
+    assert Piecewise((x, 1)) == x  # 1 and 0 are accepted as True/False
+    raises(TypeError, lambda: Piecewise((x, 2)))
+    raises(TypeError, lambda: Piecewise((x, x**2)))
+    raises(TypeError, lambda: Piecewise(([1], True)))
+    assert Piecewise(((1, 2), True)) == Tuple(1, 2)
+    cond = (Piecewise((1, x < 0), (2, True)) < y)
+    assert Piecewise((1, cond)
+        ) == Piecewise((1, ITE(x < 0, y > 1, y > 2)))
+
+    assert Piecewise((1, x > 0), (2, And(x <= 0, x > -1))
+        ) == Piecewise((1, x > 0), (2, x > -1))
+    assert Piecewise((1, x <= 0), (2, (x < 0) & (x > -1))
+        ) == Piecewise((1, x <= 0))
+
+    # test for supporting Contains in Piecewise
+    pwise = Piecewise(
+        (1, And(x <= 6, x > 1, Contains(x, S.Integers))),
+        (0, True))
+    assert pwise.subs(x, pi) == 0
+    assert pwise.subs(x, 2) == 1
+    assert pwise.subs(x, 7) == 0
+
+    # Test subs
+    p = Piecewise((-1, x < -1), (x**2, x < 0), (log(x), x >= 0))
+    p_x2 = Piecewise((-1, x**2 < -1), (x**4, x**2 < 0), (log(x**2), x**2 >= 0))
+    assert p.subs(x, x**2) == p_x2
+    assert p.subs(x, -5) == -1
+    assert p.subs(x, -1) == 1
+    assert p.subs(x, 1) == log(1)
+
+    # More subs tests
+    p2 = Piecewise((1, x < pi), (-1, x < 2*pi), (0, x > 2*pi))
+    p3 = Piecewise((1, Eq(x, 0)), (1/x, True))
+    p4 = Piecewise((1, Eq(x, 0)), (2, 1/x>2))
+    assert p2.subs(x, 2) == 1
+    assert p2.subs(x, 4) == -1
+    assert p2.subs(x, 10) == 0
+    assert p3.subs(x, 0.0) == 1
+    assert p4.subs(x, 0.0) == 1
+
+
+    f, g, h = symbols('f,g,h', cls=Function)
+    pf = Piecewise((f(x), x < -1), (f(x) + h(x) + 2, x <= 1))
+    pg = Piecewise((g(x), x < -1), (g(x) + h(x) + 2, x <= 1))
+    assert pg.subs(g, f) == pf
+
+    assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 0) == 1
+    assert Piecewise((1, Eq(x, 0)), (0, True)).subs(x, 1) == 0
+    assert Piecewise((1, Eq(x, y)), (0, True)).subs(x, y) == 1
+    assert Piecewise((1, Eq(x, z)), (0, True)).subs(x, z) == 1
+    assert Piecewise((1, Eq(exp(x), cos(z))), (0, True)).subs(x, z) == \
+        Piecewise((1, Eq(exp(z), cos(z))), (0, True))
+
+    p5 = Piecewise( (0, Eq(cos(x) + y, 0)), (1, True))
+    assert p5.subs(y, 0) == Piecewise( (0, Eq(cos(x), 0)), (1, True))
+
+    assert Piecewise((-1, y < 1), (0, x < 0), (1, Eq(x, 0)), (2, True)
+        ).subs(x, 1) == Piecewise((-1, y < 1), (2, True))
+    assert Piecewise((1, Eq(x**2, -1)), (2, x < 0)).subs(x, I) == 1
+
+    p6 = Piecewise((x, x > 0))
+    n = symbols('n', negative=True)
+    assert p6.subs(x, n) == Undefined
+
+    # Test evalf
+    assert p.evalf() == Piecewise((-1.0, x < -1), (x**2, x < 0), (log(x), True))
+    assert p.evalf(subs={x: -2}) == -1.0
+    assert p.evalf(subs={x: -1}) == 1.0
+    assert p.evalf(subs={x: 1}) == log(1)
+    assert p6.evalf(subs={x: -5}) == Undefined
+
+    # Test doit
+    f_int = Piecewise((Integral(x, (x, 0, 1)), x < 1))
+    assert f_int.doit() == Piecewise( (S.Half, x < 1) )
+
+    # Test differentiation
+    f = x
+    fp = x*p
+    dp = Piecewise((0, x < -1), (2*x, x < 0), (1/x, x >= 0))
+    fp_dx = x*dp + p
+    assert diff(p, x) == dp
+    assert diff(f*p, x) == fp_dx
+
+    # Test simple arithmetic
+    assert x*p == fp
+    assert x*p + p == p + x*p
+    assert p + f == f + p
+    assert p + dp == dp + p
+    assert p - dp == -(dp - p)
+
+    # Test power
+    dp2 = Piecewise((0, x < -1), (4*x**2, x < 0), (1/x**2, x >= 0))
+    assert dp**2 == dp2
+
+    # Test _eval_interval
+    f1 = x*y + 2
+    f2 = x*y**2 + 3
+    peval = Piecewise((f1, x < 0), (f2, x > 0))
+    peval_interval = f1.subs(
+        x, 0) - f1.subs(x, -1) + f2.subs(x, 1) - f2.subs(x, 0)
+    assert peval._eval_interval(x, 0, 0) == 0
+    assert peval._eval_interval(x, -1, 1) == peval_interval
+    peval2 = Piecewise((f1, x < 0), (f2, True))
+    assert peval2._eval_interval(x, 0, 0) == 0
+    assert peval2._eval_interval(x, 1, -1) == -peval_interval
+    assert peval2._eval_interval(x, -1, -2) == f1.subs(x, -2) - f1.subs(x, -1)
+    assert peval2._eval_interval(x, -1, 1) == peval_interval
+    assert peval2._eval_interval(x, None, 0) == peval2.subs(x, 0)
+    assert peval2._eval_interval(x, -1, None) == -peval2.subs(x, -1)
+
+    # Test integration
+    assert p.integrate() == Piecewise(
+        (-x, x < -1),
+        (x**3/3 + Rational(4, 3), x < 0),
+        (x*log(x) - x + Rational(4, 3), True))
+    p = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
+    assert integrate(p, (x, -2, 2)) == Rational(5, 6)
+    assert integrate(p, (x, 2, -2)) == Rational(-5, 6)
+    p = Piecewise((0, x < 0), (1, x < 1), (0, x < 2), (1, x < 3), (0, True))
+    assert integrate(p, (x, -oo, oo)) == 2
+    p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
+    assert integrate(p, (x, -2, 2)) == Undefined
+
+    # Test commutativity
+    assert isinstance(p, Piecewise) and p.is_commutative is True
+
+
+def test_piecewise_free_symbols():
+    f = Piecewise((x, a < 0), (y, True))
+    assert f.free_symbols == {x, y, a}
+
+
+def test_piecewise_integrate1():
+    x, y = symbols('x y', real=True)
+
+    f = Piecewise(((x - 2)**2, x >= 0), (1, True))
+    assert integrate(f, (x, -2, 2)) == Rational(14, 3)
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, True))
+    assert integrate(g, (x, -2, 2)) == Rational(14, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(43, 6)
+
+    assert g == Piecewise(((x - 5)**5, x >= 4), (f, x < 4))
+
+    g = Piecewise(((x - 5)**5, 2 <= x), (f, x < 2))
+    assert integrate(g, (x, -2, 2)) == Rational(14, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(-701, 6)
+
+    assert g == Piecewise(((x - 5)**5, 2 <= x), (f, True))
+
+    g = Piecewise(((x - 5)**5, 2 <= x), (2*f, True))
+    assert integrate(g, (x, -2, 2)) == Rational(28, 3)
+    assert integrate(g, (x, -2, 5)) == Rational(-673, 6)
+
+
+def test_piecewise_integrate1b():
+    g = Piecewise((1, x > 0), (0, Eq(x, 0)), (-1, x < 0))
+    assert integrate(g, (x, -1, 1)) == 0
+
+    g = Piecewise((1, x - y < 0), (0, True))
+    assert integrate(g, (y, -oo, 0)) == -Min(0, x)
+    assert g.subs(x, -3).integrate((y, -oo, 0)) == 3
+    assert integrate(g, (y, 0, -oo)) == Min(0, x)
+    assert integrate(g, (y, 0, oo)) == -Max(0, x) + oo
+    assert integrate(g, (y, -oo, 42)) == -Min(42, x) + 42
+    assert integrate(g, (y, -oo, oo)) == -x + oo
+
+    g = Piecewise((0, x < 0), (x, x <= 1), (1, True))
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+    for yy in (-1, S.Half, 2):
+        assert g.integrate((x, yy, 1)) == gy1.subs(y, yy)
+        assert g.integrate((x, 1, yy)) == g1y.subs(y, yy)
+    assert gy1 == Piecewise(
+        (-Min(1, Max(0, y))**2/2 + S.Half, y < 1),
+        (-y + 1, True))
+    assert g1y == Piecewise(
+        (Min(1, Max(0, y))**2/2 - S.Half, y < 1),
+        (y - 1, True))
+
+
+@slow
+def test_piecewise_integrate1ca():
+    y = symbols('y', real=True)
+    g = Piecewise(
+        (1 - x, Interval(0, 1).contains(x)),
+        (1 + x, Interval(-1, 0).contains(x)),
+        (0, True)
+        )
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+
+    assert g.integrate((x, -2, 1)) == gy1.subs(y, -2)
+    assert g.integrate((x, 1, -2)) == g1y.subs(y, -2)
+    assert g.integrate((x, 0, 1)) == gy1.subs(y, 0)
+    assert g.integrate((x, 1, 0)) == g1y.subs(y, 0)
+    assert g.integrate((x, 2, 1)) == gy1.subs(y, 2)
+    assert g.integrate((x, 1, 2)) == g1y.subs(y, 2)
+    assert piecewise_fold(gy1.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (1, y <= -1),
+            (-y**2/2 - y + S.Half, y <= 0),
+            (y**2/2 - y + S.Half, y < 1),
+            (0, True))
+    assert piecewise_fold(g1y.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (-1, y <= -1),
+            (y**2/2 + y - S.Half, y <= 0),
+            (-y**2/2 + y - S.Half, y < 1),
+            (0, True))
+    assert gy1 == Piecewise(
+        (
+            -Min(1, Max(-1, y))**2/2 - Min(1, Max(-1, y)) +
+            Min(1, Max(0, y))**2 + S.Half, y < 1),
+        (0, True)
+        )
+    assert g1y == Piecewise(
+        (
+            Min(1, Max(-1, y))**2/2 + Min(1, Max(-1, y)) -
+            Min(1, Max(0, y))**2 - S.Half, y < 1),
+        (0, True))
+
+
+@slow
+def test_piecewise_integrate1cb():
+    y = symbols('y', real=True)
+    g = Piecewise(
+        (0, Or(x <= -1, x >= 1)),
+        (1 - x, x > 0),
+        (1 + x, True)
+        )
+    gy1 = g.integrate((x, y, 1))
+    g1y = g.integrate((x, 1, y))
+
+    assert g.integrate((x, -2, 1)) == gy1.subs(y, -2)
+    assert g.integrate((x, 1, -2)) == g1y.subs(y, -2)
+    assert g.integrate((x, 0, 1)) == gy1.subs(y, 0)
+    assert g.integrate((x, 1, 0)) == g1y.subs(y, 0)
+    assert g.integrate((x, 2, 1)) == gy1.subs(y, 2)
+    assert g.integrate((x, 1, 2)) == g1y.subs(y, 2)
+
+    assert piecewise_fold(gy1.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (1, y <= -1),
+            (-y**2/2 - y + S.Half, y <= 0),
+            (y**2/2 - y + S.Half, y < 1),
+            (0, True))
+    assert piecewise_fold(g1y.rewrite(Piecewise)
+        ).simplify() == Piecewise(
+            (-1, y <= -1),
+            (y**2/2 + y - S.Half, y <= 0),
+            (-y**2/2 + y - S.Half, y < 1),
+            (0, True))
+
+    # g1y and gy1 should simplify if the condition that y < 1
+    # is applied, e.g. Min(1, Max(-1, y)) --> Max(-1, y)
+    assert gy1 == Piecewise(
+        (
+            -Min(1, Max(-1, y))**2/2 - Min(1, Max(-1, y)) +
+            Min(1, Max(0, y))**2 + S.Half, y < 1),
+        (0, True)
+        )
+    assert g1y == Piecewise(
+        (
+            Min(1, Max(-1, y))**2/2 + Min(1, Max(-1, y)) -
+            Min(1, Max(0, y))**2 - S.Half, y < 1),
+        (0, True))
+
+
+def test_piecewise_integrate2():
+    from itertools import permutations
+    lim = Tuple(x, c, d)
+    p = Piecewise((1, x < a), (2, x > b), (3, True))
+    q = p.integrate(lim)
+    assert q == Piecewise(
+        (-c + 2*d - 2*Min(d, Max(a, c)) + Min(d, Max(a, b, c)), c < d),
+        (-2*c + d + 2*Min(c, Max(a, d)) - Min(c, Max(a, b, d)), True))
+    for v in permutations((1, 2, 3, 4)):
+        r = dict(zip((a, b, c, d), v))
+        assert p.subs(r).integrate(lim.subs(r)) == q.subs(r)
+
+
+def test_meijer_bypass():
+    # totally bypass meijerg machinery when dealing
+    # with Piecewise in integrate
+    assert Piecewise((1, x < 4), (0, True)).integrate((x, oo, 1)) == -3
+
+
+def test_piecewise_integrate3_inequality_conditions():
+    from sympy.utilities.iterables import cartes
+    lim = (x, 0, 5)
+    # set below includes two pts below range, 2 pts in range,
+    # 2 pts above range, and the boundaries
+    N = (-2, -1, 0, 1, 2, 5, 6, 7)
+
+    p = Piecewise((1, x > a), (2, x > b), (0, True))
+    ans = p.integrate(lim)
+    for i, j in cartes(N, repeat=2):
+        reps = dict(zip((a, b), (i, j)))
+        assert ans.subs(reps) == p.subs(reps).integrate(lim)
+    assert ans.subs(a, 4).subs(b, 1) == 0 + 2*3 + 1
+
+    p = Piecewise((1, x > a), (2, x < b), (0, True))
+    ans = p.integrate(lim)
+    for i, j in cartes(N, repeat=2):
+        reps = dict(zip((a, b), (i, j)))
+        assert ans.subs(reps) == p.subs(reps).integrate(lim)
+
+    # delete old tests that involved c1 and c2 since those
+    # reduce to the above except that a value of 0 was used
+    # for two expressions whereas the above uses 3 different
+    # values
+
+
+@slow
+def test_piecewise_integrate4_symbolic_conditions():
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    p0 = Piecewise((0, Or(x < a, x > b)), (1, True))
+    p1 = Piecewise((0, x < a), (0, x > b), (1, True))
+    p2 = Piecewise((0, x > b), (0, x < a), (1, True))
+    p3 = Piecewise((0, x < a), (1, x < b), (0, True))
+    p4 = Piecewise((0, x > b), (1, x > a), (0, True))
+    p5 = Piecewise((1, And(a < x, x < b)), (0, True))
+
+    # check values of a=1, b=3 (and reversed) with values
+    # of y of 0, 1, 2, 3, 4
+    lim = Tuple(x, -oo, y)
+    for p in (p0, p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a: 3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+    lim = Tuple(x, y, oo)
+    for p in (p0, p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a:3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+
+    ans = Piecewise(
+        (0, x <= Min(a, b)),
+        (x - Min(a, b), x <= b),
+        (b - Min(a, b), True))
+    for i in (p0, p1, p2, p4):
+        assert i.integrate(x) == ans
+    assert p3.integrate(x) == Piecewise(
+        (0, x < a),
+        (-a + x, x <= Max(a, b)),
+        (-a + Max(a, b), True))
+    assert p5.integrate(x) == Piecewise(
+        (0, x <= a),
+        (-a + x, x <= Max(a, b)),
+        (-a + Max(a, b), True))
+
+    p1 = Piecewise((0, x < a), (S.Half, x > b), (1, True))
+    p2 = Piecewise((S.Half, x > b), (0, x < a), (1, True))
+    p3 = Piecewise((0, x < a), (1, x < b), (S.Half, True))
+    p4 = Piecewise((S.Half, x > b), (1, x > a), (0, True))
+    p5 = Piecewise((1, And(a < x, x < b)), (S.Half, x > b), (0, True))
+
+    # check values of a=1, b=3 (and reversed) with values
+    # of y of 0, 1, 2, 3, 4
+    lim = Tuple(x, -oo, y)
+    for p in (p1, p2, p3, p4, p5):
+        ans = p.integrate(lim)
+        for i in range(5):
+            reps = {a:1, b:3, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+            reps = {a: 3, b:1, y:i}
+            assert ans.subs(reps) == p.subs(reps).integrate(lim.subs(reps))
+
+
+def test_piecewise_integrate5_independent_conditions():
+    p = Piecewise((0, Eq(y, 0)), (x*y, True))
+    assert integrate(p, (x, 1, 3)) == Piecewise((0, Eq(y, 0)), (4*y, True))
+
+
+def test_issue_22917():
+    p = (Piecewise((0, ITE((x - y > 1) | (2 * x - 2 * y > 1), False,
+                           ITE(x - y > 1, 2 * y - 2 < -1, 2 * x - 2 * y > 1))),
+                   (Piecewise((0, ITE(x - y > 1, True, 2 * x - 2 * y > 1)),
+                              (2 * Piecewise((0, x - y > 1), (y, True)), True)), True))
+         + 2 * Piecewise((1, ITE((x - y > 1) | (2 * x - 2 * y > 1), False,
+                                 ITE(x - y > 1, 2 * y - 2 < -1, 2 * x - 2 * y > 1))),
+                         (Piecewise((1, ITE(x - y > 1, True, 2 * x - 2 * y > 1)),
+                                    (2 * Piecewise((1, x - y > 1), (x, True)), True)), True)))
+    assert piecewise_fold(p) == Piecewise((2, (x - y > S.Half) | (x - y > 1)),
+                                          (2*y + 4, x - y > 1),
+                                          (4*x + 2*y, True))
+    assert piecewise_fold(p > 1).rewrite(ITE) == ITE((x - y > S.Half) | (x - y > 1), True,
+                                                     ITE(x - y > 1, 2*y + 4 > 1, 4*x + 2*y > 1))
+
+
+def test_piecewise_simplify():
+    p = Piecewise(((x**2 + 1)/x**2, Eq(x*(1 + x) - x**2, 0)),
+                  ((-1)**x*(-1), True))
+    assert p.simplify() == \
+        Piecewise((zoo, Eq(x, 0)), ((-1)**(x + 1), True))
+    # simplify when there are Eq in conditions
+    assert Piecewise(
+        (a, And(Eq(a, 0), Eq(a + b, 0))), (1, True)).simplify(
+        ) == Piecewise(
+        (0, And(Eq(a, 0), Eq(b, 0))), (1, True))
+    assert Piecewise((2*x*factorial(a)/(factorial(y)*factorial(-y + a)),
+        Eq(y, 0) & Eq(-y + a, 0)), (2*factorial(a)/(factorial(y)*factorial(-y
+        + a)), Eq(y, 0) & Eq(-y + a, 1)), (0, True)).simplify(
+        ) == Piecewise(
+            (2*x, And(Eq(a, 0), Eq(y, 0))),
+            (2, And(Eq(a, 1), Eq(y, 0))),
+            (0, True))
+    args = (2, And(Eq(x, 2), Ge(y, 0))), (x, True)
+    assert Piecewise(*args).simplify() == Piecewise(*args)
+    args = (1, Eq(x, 0)), (sin(x)/x, True)
+    assert Piecewise(*args).simplify() == Piecewise(*args)
+    assert Piecewise((2 + y, And(Eq(x, 2), Eq(y, 0))), (x, True)
+        ).simplify() == x
+    # check that x or f(x) are recognized as being Symbol-like for lhs
+    args = Tuple((1, Eq(x, 0)), (sin(x) + 1 + x, True))
+    ans = x + sin(x) + 1
+    f = Function('f')
+    assert Piecewise(*args).simplify() == ans
+    assert Piecewise(*args.subs(x, f(x))).simplify() == ans.subs(x, f(x))
+
+    # issue 18634
+    d = Symbol("d", integer=True)
+    n = Symbol("n", integer=True)
+    t = Symbol("t", positive=True)
+    expr = Piecewise((-d + 2*n, Eq(1/t, 1)), (t**(1 - 4*n)*t**(4*n - 1)*(-d + 2*n), True))
+    assert expr.simplify() == -d + 2*n
+
+    # issue 22747
+    p = Piecewise((0, (t < -2) & (t < -1) & (t < 0)), ((t/2 + 1)*(t +
+        1)*(t + 2), (t < -1) & (t < 0)), ((S.Half - t/2)*(1 - t)*(t + 1),
+        (t < -2) & (t < -1) & (t < 1)), ((t + 1)*(-t*(t/2 + 1) + (S.Half
+        - t/2)*(1 - t)), (t < -2) & (t < -1) & (t < 0) & (t < 1)), ((t +
+        1)*((S.Half - t/2)*(1 - t) + (t/2 + 1)*(t + 2)), (t < -1) & (t <
+        1)), ((t + 1)*(-t*(t/2 + 1) + (S.Half - t/2)*(1 - t)), (t < -1) &
+        (t < 0) & (t < 1)), (0, (t < -2) & (t < -1)), ((t/2 + 1)*(t +
+        1)*(t + 2), t < -1), ((t + 1)*(-t*(t/2 + 1) + (S.Half - t/2)*(t +
+        1)), (t < 0) & ((t < -2) | (t < 0))), ((S.Half - t/2)*(1 - t)*(t
+        + 1), (t < 1) & ((t < -2) | (t < 1))), (0, True)) + Piecewise((0,
+        (t < -1) & (t < 0) & (t < 1)), ((1 - t)*(t/2 + S.Half)*(t + 1),
+        (t < 0) & (t < 1)), ((1 - t)*(1 - t/2)*(2 - t), (t < -1) & (t <
+        0) & (t < 2)), ((1 - t)*((1 - t)*(t/2 + S.Half) + (1 - t/2)*(2 -
+        t)), (t < -1) & (t < 0) & (t < 1) & (t < 2)), ((1 - t)*((1 -
+        t/2)*(2 - t) + (t/2 + S.Half)*(t + 1)), (t < 0) & (t < 2)), ((1 -
+        t)*((1 - t)*(t/2 + S.Half) + (1 - t/2)*(2 - t)), (t < 0) & (t <
+        1) & (t < 2)), (0, (t < -1) & (t < 0)), ((1 - t)*(t/2 +
+        S.Half)*(t + 1), t < 0), ((1 - t)*(t*(1 - t/2) + (1 - t)*(t/2 +
+        S.Half)), (t < 1) & ((t < -1) | (t < 1))), ((1 - t)*(1 - t/2)*(2
+        - t), (t < 2) & ((t < -1) | (t < 2))), (0, True))
+    assert p.simplify() == Piecewise(
+        (0, t < -2), ((t + 1)*(t + 2)**2/2, t < -1), (-3*t**3/2
+        - 5*t**2/2 + 1, t < 0), (3*t**3/2 - 5*t**2/2 + 1, t < 1), ((1 -
+        t)*(t - 2)**2/2, t < 2), (0, True))
+
+    # coverage
+    nan = Undefined
+    assert Piecewise((1, x > 3), (2, x < 2), (3, x > 1)).simplify(
+        )  == Piecewise((1, x > 3), (2, x < 2), (3, True))
+    assert Piecewise((1, x < 2), (2, x < 1), (3, True)).simplify(
+        ) == Piecewise((1, x < 2), (3, True))
+    assert Piecewise((1, x > 2)).simplify() == Piecewise((1, x > 2),
+        (nan, True))
+    assert Piecewise((1, (x >= 2) & (x < oo))
+        ).simplify() == Piecewise((1, (x >= 2) & (x < oo)), (nan, True))
+    assert Piecewise((1, x < 2), (2, (x > 1) & (x < 3)), (3, True)
+        ). simplify() == Piecewise((1, x < 2), (2, x < 3), (3, True))
+    assert Piecewise((1, x < 2), (2, (x <= 3) & (x > 1)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, x <= 3), (3, True))
+    assert Piecewise((1, x < 2), (2, (x > 2) & (x < 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, (x > 2) & (x < 3)),
+        (3, True))
+    assert Piecewise((1, x < 2), (2, (x >= 1) & (x <= 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 2), (2, x <= 3), (3, True))
+    assert Piecewise((1, x < 1), (2, (x >= 2) & (x <= 3)), (3, True)
+        ).simplify() == Piecewise((1, x < 1), (2, (x >= 2) & (x <= 3)),
+        (3, True))
+    # https://github.com/sympy/sympy/issues/25603
+    assert Piecewise((log(x), (x <= 5) & (x > 3)), (x, True)
+        ).simplify() == Piecewise((log(x), (x <= 5) & (x > 3)), (x, True))
+
+    assert Piecewise((1, (x >= 1) & (x < 3)), (2, (x > 2) & (x < 4))
+        ).simplify() == Piecewise((1, (x >= 1) & (x < 3)), (
+        2, (x >= 3) & (x < 4)), (nan, True))
+    assert Piecewise((1, (x >= 1) & (x <= 3)), (2, (x > 2) & (x < 4))
+        ).simplify() == Piecewise((1, (x >= 1) & (x <= 3)), (
+        2, (x > 3) & (x < 4)), (nan, True))
+
+    # involves a symbolic range so cset.inf fails
+    L = Symbol('L', nonnegative=True)
+    p = Piecewise((nan, x <= 0), (0, (x >= 0) & (L > x) & (L - x <= 0)),
+        (x - L/2, (L > x) & (L - x <= 0)),
+        (L/2 - x, (x >= 0) & (L > x)),
+        (0, L > x), (nan, True))
+    assert p.simplify() == Piecewise(
+        (nan, x <= 0), (L/2 - x, L > x), (nan, True))
+    assert p.subs(L, y).simplify() == Piecewise(
+        (nan, x <= 0), (-x + y/2, x < Max(0, y)), (0, x < y), (nan, True))
+
+
+def test_piecewise_solve():
+    abs2 = Piecewise((-x, x <= 0), (x, x > 0))
+    f = abs2.subs(x, x - 2)
+    assert solve(f, x) == [2]
+    assert solve(f - 1, x) == [1, 3]
+
+    f = Piecewise(((x - 2)**2, x >= 0), (1, True))
+    assert solve(f, x) == [2]
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, True))
+    assert solve(g, x) == [2, 5]
+
+    g = Piecewise(((x - 5)**5, x >= 4), (f, x < 4))
+    assert solve(g, x) == [2, 5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, x < 2))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, True))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2), (f, True), (10, False))
+    assert solve(g, x) == [5]
+
+    g = Piecewise(((x - 5)**5, x >= 2),
+                  (-x + 2, x - 2 <= 0), (x - 2, x - 2 > 0))
+    assert solve(g, x) == [5]
+
+    # if no symbol is given the piecewise detection must still work
+    assert solve(Piecewise((x - 2, x > 2), (2 - x, True)) - 3) == [-1, 5]
+
+    f = Piecewise(((x - 2)**2, x >= 0), (0, True))
+    raises(NotImplementedError, lambda: solve(f, x))
+
+    def nona(ans):
+        return list(filter(lambda x: x is not S.NaN, ans))
+    p = Piecewise((x**2 - 4, x < y), (x - 2, True))
+    ans = solve(p, x)
+    assert nona([i.subs(y, -2) for i in ans]) == [2]
+    assert nona([i.subs(y, 2) for i in ans]) == [-2, 2]
+    assert nona([i.subs(y, 3) for i in ans]) == [-2, 2]
+    assert ans == [
+        Piecewise((-2, y > -2), (S.NaN, True)),
+        Piecewise((2, y <= 2), (S.NaN, True)),
+        Piecewise((2, y > 2), (S.NaN, True))]
+
+    # issue 6060
+    absxm3 = Piecewise(
+        (x - 3, 0 <= x - 3),
+        (3 - x, 0 > x - 3)
+    )
+    assert solve(absxm3 - y, x) == [
+        Piecewise((-y + 3, -y < 0), (S.NaN, True)),
+        Piecewise((y + 3, y >= 0), (S.NaN, True))]
+    p = Symbol('p', positive=True)
+    assert solve(absxm3 - p, x) == [-p + 3, p + 3]
+
+    # issue 6989
+    f = Function('f')
+    assert solve(Eq(-f(x), Piecewise((1, x > 0), (0, True))), f(x)) == \
+        [Piecewise((-1, x > 0), (0, True))]
+
+    # issue 8587
+    f = Piecewise((2*x**2, And(0 < x, x < 1)), (2, True))
+    assert solve(f - 1) == [1/sqrt(2)]
+
+
+def test_piecewise_fold():
+    p = Piecewise((x, x < 1), (1, 1 <= x))
+
+    assert piecewise_fold(x*p) == Piecewise((x**2, x < 1), (x, 1 <= x))
+    assert piecewise_fold(p + p) == Piecewise((2*x, x < 1), (2, 1 <= x))
+    assert piecewise_fold(Piecewise((1, x < 0), (2, True))
+                          + Piecewise((10, x < 0), (-10, True))) == \
+        Piecewise((11, x < 0), (-8, True))
+
+    p1 = Piecewise((0, x < 0), (x, x <= 1), (0, True))
+    p2 = Piecewise((0, x < 0), (1 - x, x <= 1), (0, True))
+
+    p = 4*p1 + 2*p2
+    assert integrate(
+        piecewise_fold(p), (x, -oo, oo)) == integrate(2*x + 2, (x, 0, 1))
+
+    assert piecewise_fold(
+        Piecewise((1, y <= 0), (-Piecewise((2, y >= 0)), True)
+        )) == Piecewise((1, y <= 0), (-2, y >= 0))
+
+    assert piecewise_fold(Piecewise((x, ITE(x > 0, y < 1, y > 1)))
+        ) == Piecewise((x, ((x <= 0) | (y < 1)) & ((x > 0) | (y > 1))))
+
+    a, b = (Piecewise((2, Eq(x, 0)), (0, True)),
+        Piecewise((x, Eq(-x + y, 0)), (1, Eq(-x + y, 1)), (0, True)))
+    assert piecewise_fold(Mul(a, b, evaluate=False)
+        ) == piecewise_fold(Mul(b, a, evaluate=False))
+
+
+def test_piecewise_fold_piecewise_in_cond():
+    p1 = Piecewise((cos(x), x < 0), (0, True))
+    p2 = Piecewise((0, Eq(p1, 0)), (p1 / Abs(p1), True))
+    assert p2.subs(x, -pi/2) == 0
+    assert p2.subs(x, 1) == 0
+    assert p2.subs(x, -pi/4) == 1
+    p4 = Piecewise((0, Eq(p1, 0)), (1,True))
+    ans = piecewise_fold(p4)
+    for i in range(-1, 1):
+        assert ans.subs(x, i) == p4.subs(x, i)
+
+    r1 = 1 < Piecewise((1, x < 1), (3, True))
+    ans = piecewise_fold(r1)
+    for i in range(2):
+        assert ans.subs(x, i) == r1.subs(x, i)
+
+    p5 = Piecewise((1, x < 0), (3, True))
+    p6 = Piecewise((1, x < 1), (3, True))
+    p7 = Piecewise((1, p5 < p6), (0, True))
+    ans = piecewise_fold(p7)
+    for i in range(-1, 2):
+        assert ans.subs(x, i) == p7.subs(x, i)
+
+
+def test_piecewise_fold_piecewise_in_cond_2():
+    p1 = Piecewise((cos(x), x < 0), (0, True))
+    p2 = Piecewise((0, Eq(p1, 0)), (1 / p1, True))
+    p3 = Piecewise(
+        (0, (x >= 0) | Eq(cos(x), 0)),
+        (1/cos(x), x < 0),
+        (zoo, True))  # redundant b/c all x are already covered
+    assert(piecewise_fold(p2) == p3)
+
+
+def test_piecewise_fold_expand():
+    p1 = Piecewise((1, Interval(0, 1, False, True).contains(x)), (0, True))
+
+    p2 = piecewise_fold(expand((1 - x)*p1))
+    cond = ((x >= 0) & (x < 1))
+    assert piecewise_fold(expand((1 - x)*p1), evaluate=False
+        ) == Piecewise((1 - x, cond), (-x, cond), (1, cond), (0, True), evaluate=False)
+    assert piecewise_fold(expand((1 - x)*p1), evaluate=None
+        ) == Piecewise((1 - x, cond), (0, True))
+    assert p2 == Piecewise((1 - x, cond), (0, True))
+    assert p2 == expand(piecewise_fold((1 - x)*p1))
+
+
+def test_piecewise_duplicate():
+    p = Piecewise((x, x < -10), (x**2, x <= -1), (x, 1 < x))
+    assert p == Piecewise(*p.args)
+
+
+def test_doit():
+    p1 = Piecewise((x, x < 1), (x**2, -1 <= x), (x, 3 < x))
+    p2 = Piecewise((x, x < 1), (Integral(2 * x), -1 <= x), (x, 3 < x))
+    assert p2.doit() == p1
+    assert p2.doit(deep=False) == p2
+    # issue 17165
+    p1 = Sum(y**x, (x, -1, oo)).doit()
+    assert p1.doit() == p1
+
+
+def test_piecewise_interval():
+    p1 = Piecewise((x, Interval(0, 1).contains(x)), (0, True))
+    assert p1.subs(x, -0.5) == 0
+    assert p1.subs(x, 0.5) == 0.5
+    assert p1.diff(x) == Piecewise((1, Interval(0, 1).contains(x)), (0, True))
+    assert integrate(p1, x) == Piecewise(
+        (0, x <= 0),
+        (x**2/2, x <= 1),
+        (S.Half, True))
+
+
+def test_piecewise_exclusive():
+    p = Piecewise((0, x < 0), (S.Half, x <= 0), (1, True))
+    assert piecewise_exclusive(p) == Piecewise((0, x < 0), (S.Half, Eq(x, 0)),
+                                               (1, x > 0), evaluate=False)
+    assert piecewise_exclusive(p + 2) == Piecewise((0, x < 0), (S.Half, Eq(x, 0)),
+                                               (1, x > 0), evaluate=False) + 2
+    assert piecewise_exclusive(Piecewise((1, y <= 0),
+                                         (-Piecewise((2, y >= 0)), True))) == \
+        Piecewise((1, y <= 0),
+                  (-Piecewise((2, y >= 0),
+                              (S.NaN, y < 0), evaluate=False), y > 0), evaluate=False)
+    assert piecewise_exclusive(Piecewise((1, x > y))) == Piecewise((1, x > y),
+                                                                  (S.NaN, x <= y),
+                                                                  evaluate=False)
+    assert piecewise_exclusive(Piecewise((1, x > y)),
+                               skip_nan=True) == Piecewise((1, x > y))
+
+    xr, yr = symbols('xr, yr', real=True)
+
+    p1 = Piecewise((1, xr < 0), (2, True), evaluate=False)
+    p1x = Piecewise((1, xr < 0), (2, xr >= 0), evaluate=False)
+
+    p2 = Piecewise((p1, yr < 0), (3, True), evaluate=False)
+    p2x = Piecewise((p1, yr < 0), (3, yr >= 0), evaluate=False)
+    p2xx = Piecewise((p1x, yr < 0), (3, yr >= 0), evaluate=False)
+
+    assert piecewise_exclusive(p2) == p2xx
+    assert piecewise_exclusive(p2, deep=False) == p2x
+
+
+def test_piecewise_collapse():
+    assert Piecewise((x, True)) == x
+    a = x < 1
+    assert Piecewise((x, a), (x + 1, a)) == Piecewise((x, a))
+    assert Piecewise((x, a), (x + 1, a.reversed)) == Piecewise((x, a))
+    b = x < 5
+    def canonical(i):
+        if isinstance(i, Piecewise):
+            return Piecewise(*i.args)
+        return i
+    for args in [
+        ((1, a), (Piecewise((2, a), (3, b)), b)),
+        ((1, a), (Piecewise((2, a), (3, b.reversed)), b)),
+        ((1, a), (Piecewise((2, a), (3, b)), b), (4, True)),
+        ((1, a), (Piecewise((2, a), (3, b), (4, True)), b)),
+        ((1, a), (Piecewise((2, a), (3, b), (4, True)), b), (5, True))]:
+        for i in (0, 2, 10):
+            assert canonical(
+                Piecewise(*args, evaluate=False).subs(x, i)
+                ) == canonical(Piecewise(*args).subs(x, i))
+    r1, r2, r3, r4 = symbols('r1:5')
+    a = x < r1
+    b = x < r2
+    c = x < r3
+    d = x < r4
+    assert Piecewise((1, a), (Piecewise(
+        (2, a), (3, b), (4, c)), b), (5, c)
+        ) == Piecewise((1, a), (3, b), (5, c))
+    assert Piecewise((1, a), (Piecewise(
+        (2, a), (3, b), (4, c), (6, True)), c), (5, d)
+        ) == Piecewise((1, a), (Piecewise(
+        (3, b), (4, c)), c), (5, d))
+    assert Piecewise((1, Or(a, d)), (Piecewise(
+        (2, d), (3, b), (4, c)), b), (5, c)
+        ) == Piecewise((1, Or(a, d)), (Piecewise(
+        (2, d), (3, b)), b), (5, c))
+    assert Piecewise((1, c), (2, ~c), (3, S.true)
+        ) == Piecewise((1, c), (2, S.true))
+    assert Piecewise((1, c), (2, And(~c, b)), (3,True)
+        ) == Piecewise((1, c), (2, b), (3, True))
+    assert Piecewise((1, c), (2, Or(~c, b)), (3,True)
+        ).subs(dict(zip((r1, r2, r3, r4, x), (1, 2, 3, 4, 3.5))))  == 2
+    assert Piecewise((1, c), (2, ~c)) == Piecewise((1, c), (2, True))
+
+
+def test_piecewise_lambdify():
+    p = Piecewise(
+        (x**2, x < 0),
+        (x, Interval(0, 1, False, True).contains(x)),
+        (2 - x, x >= 1),
+        (0, True)
+    )
+
+    f = lambdify(x, p)
+    assert f(-2.0) == 4.0
+    assert f(0.0) == 0.0
+    assert f(0.5) == 0.5
+    assert f(2.0) == 0.0
+
+
+def test_piecewise_series():
+    from sympy.series.order import O
+    p1 = Piecewise((sin(x), x < 0), (cos(x), x > 0))
+    p2 = Piecewise((x + O(x**2), x < 0), (1 + O(x**2), x > 0))
+    assert p1.nseries(x, n=2) == p2
+
+
+def test_piecewise_as_leading_term():
+    p1 = Piecewise((1/x, x > 1), (0, True))
+    p2 = Piecewise((x, x > 1), (0, True))
+    p3 = Piecewise((1/x, x > 1), (x, True))
+    p4 = Piecewise((x, x > 1), (1/x, True))
+    p5 = Piecewise((1/x, x > 1), (x, True))
+    p6 = Piecewise((1/x, x < 1), (x, True))
+    p7 = Piecewise((x, x < 1), (1/x, True))
+    p8 = Piecewise((x, x > 1), (1/x, True))
+    assert p1.as_leading_term(x) == 0
+    assert p2.as_leading_term(x) == 0
+    assert p3.as_leading_term(x) == x
+    assert p4.as_leading_term(x) == 1/x
+    assert p5.as_leading_term(x) == x
+    assert p6.as_leading_term(x) == 1/x
+    assert p7.as_leading_term(x) == x
+    assert p8.as_leading_term(x) == 1/x
+
+
+def test_piecewise_complex():
+    p1 = Piecewise((2, x < 0), (1, 0 <= x))
+    p2 = Piecewise((2*I, x < 0), (I, 0 <= x))
+    p3 = Piecewise((I*x, x > 1), (1 + I, True))
+    p4 = Piecewise((-I*conjugate(x), x > 1), (1 - I, True))
+
+    assert conjugate(p1) == p1
+    assert conjugate(p2) == piecewise_fold(-p2)
+    assert conjugate(p3) == p4
+
+    assert p1.is_imaginary is False
+    assert p1.is_real is True
+    assert p2.is_imaginary is True
+    assert p2.is_real is False
+    assert p3.is_imaginary is None
+    assert p3.is_real is None
+
+    assert p1.as_real_imag() == (p1, 0)
+    assert p2.as_real_imag() == (0, -I*p2)
+
+
+def test_conjugate_transpose():
+    A, B = symbols("A B", commutative=False)
+    p = Piecewise((A*B**2, x > 0), (A**2*B, True))
+    assert p.adjoint() == \
+        Piecewise((adjoint(A*B**2), x > 0), (adjoint(A**2*B), True))
+    assert p.conjugate() == \
+        Piecewise((conjugate(A*B**2), x > 0), (conjugate(A**2*B), True))
+    assert p.transpose() == \
+        Piecewise((transpose(A*B**2), x > 0), (transpose(A**2*B), True))
+
+
+def test_piecewise_evaluate():
+    assert Piecewise((x, True)) == x
+    assert Piecewise((x, True), evaluate=True) == x
+    assert Piecewise((1, Eq(1, x))).args == ((1, Eq(x, 1)),)
+    assert Piecewise((1, Eq(1, x)), evaluate=False).args == (
+        (1, Eq(1, x)),)
+    # like the additive and multiplicative identities that
+    # cannot be kept in Add/Mul, we also do not keep a single True
+    p = Piecewise((x, True), evaluate=False)
+    assert p == x
+
+
+def test_as_expr_set_pairs():
+    assert Piecewise((x, x > 0), (-x, x <= 0)).as_expr_set_pairs() == \
+        [(x, Interval(0, oo, True, True)), (-x, Interval(-oo, 0))]
+
+    assert Piecewise(((x - 2)**2, x >= 0), (0, True)).as_expr_set_pairs() == \
+        [((x - 2)**2, Interval(0, oo)), (0, Interval(-oo, 0, True, True))]
+
+
+def test_S_srepr_is_identity():
+    p = Piecewise((10, Eq(x, 0)), (12, True))
+    q = S(srepr(p))
+    assert p == q
+
+
+def test_issue_12587():
+    # sort holes into intervals
+    p = Piecewise((1, x > 4), (2, Not((x <= 3) & (x > -1))), (3, True))
+    assert p.integrate((x, -5, 5)) == 23
+    p = Piecewise((1, x > 1), (2, x < y), (3, True))
+    lim = x, -3, 3
+    ans = p.integrate(lim)
+    for i in range(-1, 3):
+        assert ans.subs(y, i) == p.subs(y, i).integrate(lim)
+
+
+def test_issue_11045():
+    assert integrate(1/(x*sqrt(x**2 - 1)), (x, 1, 2)) == pi/3
+
+    # handle And with Or arguments
+    assert Piecewise((1, And(Or(x < 1, x > 3), x < 2)), (0, True)
+        ).integrate((x, 0, 3)) == 1
+
+    # hidden false
+    assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)
+        ).integrate((x, 0, 3)) == 5
+    # targetcond is Eq
+    assert Piecewise((1, x > 1), (2, Eq(1, x)), (3, True)
+        ).integrate((x, 0, 4)) == 6
+    # And has Relational needing to be solved
+    assert Piecewise((1, And(2*x > x + 1, x < 2)), (0, True)
+        ).integrate((x, 0, 3)) == 1
+    # Or has Relational needing to be solved
+    assert Piecewise((1, Or(2*x > x + 2, x < 1)), (0, True)
+        ).integrate((x, 0, 3)) == 2
+    # ignore hidden false (handled in canonicalization)
+    assert Piecewise((1, x > 1), (2, x > x + 1), (3, True)
+        ).integrate((x, 0, 3)) == 5
+    # watch for hidden True Piecewise
+    assert Piecewise((2, Eq(1 - x, x*(1/x - 1))), (0, True)
+        ).integrate((x, 0, 3)) == 6
+
+    # overlapping conditions of targetcond are recognized and ignored;
+    # the condition x > 3 will be pre-empted by the first condition
+    assert Piecewise((1, Or(x < 1, x > 2)), (2, x > 3), (3, True)
+        ).integrate((x, 0, 4)) == 6
+
+    # convert Ne to Or
+    assert Piecewise((1, Ne(x, 0)), (2, True)
+        ).integrate((x, -1, 1)) == 2
+
+    # no default but well defined
+    assert Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4))
+        ).integrate((x, 1, 4)) == 5
+
+    p = Piecewise((x, (x > 1) & (x < 3)), (1, (x < 4)))
+    nan = Undefined
+    i = p.integrate((x, 1, y))
+    assert i == Piecewise(
+        (y - 1, y < 1),
+        (Min(3, y)**2/2 - Min(3, y) + Min(4, y) - S.Half,
+            y <= Min(4, y)),
+        (nan, True))
+    assert p.integrate((x, 1, -1)) == i.subs(y, -1)
+    assert p.integrate((x, 1, 4)) == 5
+    assert p.integrate((x, 1, 5)) is nan
+
+    # handle Not
+    p = Piecewise((1, x > 1), (2, Not(And(x > 1, x< 3))), (3, True))
+    assert p.integrate((x, 0, 3)) == 4
+
+    # handle updating of int_expr when there is overlap
+    p = Piecewise(
+        (1, And(5 > x, x > 1)),
+        (2, Or(x < 3, x > 7)),
+        (4, x < 8))
+    assert p.integrate((x, 0, 10)) == 20
+
+    # And with Eq arg handling
+    assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1))
+        ).integrate((x, 0, 3)) is S.NaN
+    assert Piecewise((1, x < 1), (2, And(Eq(x, 3), x > 1)), (3, True)
+        ).integrate((x, 0, 3)) == 7
+    assert Piecewise((1, x < 0), (2, And(Eq(x, 3), x < 1)), (3, True)
+        ).integrate((x, -1, 1)) == 4
+    # middle condition doesn't matter: it's a zero width interval
+    assert Piecewise((1, x < 1), (2, Eq(x, 3) & (y < x)), (3, True)
+        ).integrate((x, 0, 3)) == 7
+
+
+def test_holes():
+    nan = Undefined
+    assert Piecewise((1, x < 2)).integrate(x) == Piecewise(
+        (x, x < 2), (nan, True))
+    assert Piecewise((1, And(x > 1, x < 2))).integrate(x) == Piecewise(
+        (nan, x < 1), (x, x < 2), (nan, True))
+    assert Piecewise((1, And(x > 1, x < 2))).integrate((x, 0, 3)) is nan
+    assert Piecewise((1, And(x > 0, x < 4))).integrate((x, 1, 3)) == 2
+
+    # this also tests that the integrate method is used on non-Piecwise
+    # arguments in _eval_integral
+    A, B = symbols("A B")
+    a, b = symbols('a b', real=True)
+    assert Piecewise((A, And(x < 0, a < 1)), (B, Or(x < 1, a > 2))
+        ).integrate(x) == Piecewise(
+        (B*x, (a > 2)),
+        (Piecewise((A*x, x < 0), (B*x, x < 1), (nan, True)), a < 1),
+        (Piecewise((B*x, x < 1), (nan, True)), True))
+
+
+def test_issue_11922():
+    def f(x):
+        return Piecewise((0, x < -1), (1 - x**2, x < 1), (0, True))
+    autocorr = lambda k: (
+        f(x) * f(x + k)).integrate((x, -1, 1))
+    assert autocorr(1.9) > 0
+    k = symbols('k')
+    good_autocorr = lambda k: (
+        (1 - x**2) * f(x + k)).integrate((x, -1, 1))
+    a = good_autocorr(k)
+    assert a.subs(k, 3) == 0
+    k = symbols('k', positive=True)
+    a = good_autocorr(k)
+    assert a.subs(k, 3) == 0
+    assert Piecewise((0, x < 1), (10, (x >= 1))
+        ).integrate() == Piecewise((0, x < 1), (10*x - 10, True))
+
+
+def test_issue_5227():
+    f = 0.0032513612725229*Piecewise((0, x < -80.8461538461539),
+        (-0.0160799238820171*x + 1.33215984776403, x < 2),
+        (Piecewise((0.3, x > 123), (0.7, True)) +
+        Piecewise((0.4, x > 2), (0.6, True)), x <=
+        123), (-0.00817409766454352*x + 2.10541401273885, x <
+        380.571428571429), (0, True))
+    i = integrate(f, (x, -oo, oo))
+    assert i == Integral(f, (x, -oo, oo)).doit()
+    assert str(i) == '1.00195081676351'
+    assert Piecewise((1, x - y < 0), (0, True)
+        ).integrate(y) == Piecewise((0, y <= x), (-x + y, True))
+
+
+def test_issue_10137():
+    a = Symbol('a', real=True)
+    b = Symbol('b', real=True)
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    p0 = Piecewise((0, Or(x < a, x > b)), (1, True))
+    p1 = Piecewise((0, Or(a > x, b < x)), (1, True))
+    assert integrate(p0, (x, y, oo)) == integrate(p1, (x, y, oo))
+    p3 = Piecewise((1, And(0 < x, x < a)), (0, True))
+    p4 = Piecewise((1, And(a > x, x > 0)), (0, True))
+    ip3 = integrate(p3, x)
+    assert ip3 == Piecewise(
+        (0, x <= 0),
+        (x, x <= Max(0, a)),
+        (Max(0, a), True))
+    ip4 = integrate(p4, x)
+    assert ip4 == ip3
+    assert p3.integrate((x, 2, 4)) == Min(4, Max(2, a)) - 2
+    assert p4.integrate((x, 2, 4)) == Min(4, Max(2, a)) - 2
+
+
+def test_stackoverflow_43852159():
+    f = lambda x: Piecewise((1, (x >= -1) & (x <= 1)), (0, True))
+    Conv = lambda x: integrate(f(x - y)*f(y), (y, -oo, +oo))
+    cx = Conv(x)
+    assert cx.subs(x, -1.5) == cx.subs(x, 1.5)
+    assert cx.subs(x, 3) == 0
+    assert piecewise_fold(f(x - y)*f(y)) == Piecewise(
+        (1, (y >= -1) & (y <= 1) & (x - y >= -1) & (x - y <= 1)),
+        (0, True))
+
+
+def test_issue_12557():
+    '''
+    # 3200 seconds to compute the fourier part of issue
+    import sympy as sym
+    x,y,z,t = sym.symbols('x y z t')
+    k = sym.symbols("k", integer=True)
+    fourier = sym.fourier_series(sym.cos(k*x)*sym.sqrt(x**2),
+                                 (x, -sym.pi, sym.pi))
+    assert fourier == FourierSeries(
+    sqrt(x**2)*cos(k*x), (x, -pi, pi), (Piecewise((pi**2,
+    Eq(k, 0)), (2*(-1)**k/k**2 - 2/k**2, True))/(2*pi),
+    SeqFormula(Piecewise((pi**2, (Eq(_n, 0) & Eq(k, 0)) | (Eq(_n, 0) &
+    Eq(_n, k) & Eq(k, 0)) | (Eq(_n, 0) & Eq(k, 0) & Eq(_n, -k)) | (Eq(_n,
+    0) & Eq(_n, k) & Eq(k, 0) & Eq(_n, -k))), (pi**2/2, Eq(_n, k) | Eq(_n,
+    -k) | (Eq(_n, 0) & Eq(_n, k)) | (Eq(_n, k) & Eq(k, 0)) | (Eq(_n, 0) &
+    Eq(_n, -k)) | (Eq(_n, k) & Eq(_n, -k)) | (Eq(k, 0) & Eq(_n, -k)) |
+    (Eq(_n, 0) & Eq(_n, k) & Eq(_n, -k)) | (Eq(_n, k) & Eq(k, 0) & Eq(_n,
+    -k))), ((-1)**k*pi**2*_n**3*sin(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi**2*_n**3*sin(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2
+    - pi*k**4) + (-1)**k*pi*_n**2*cos(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi*_n**2*cos(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) - (-1)**k*pi**2*_n*k**2*sin(pi*_n)/(pi*_n**4 -
+    2*pi*_n**2*k**2 + pi*k**4) +
+    (-1)**k*pi**2*_n*k**2*sin(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) + (-1)**k*pi*k**2*cos(pi*_n)/(pi*_n**4 - 2*pi*_n**2*k**2 +
+    pi*k**4) - (-1)**k*pi*k**2*cos(pi*_n)/(-pi*_n**4 + 2*pi*_n**2*k**2 -
+    pi*k**4) - (2*_n**2 + 2*k**2)/(_n**4 - 2*_n**2*k**2 + k**4),
+    True))*cos(_n*x)/pi, (_n, 1, oo)), SeqFormula(0, (_k, 1, oo))))
+    '''
+    x = symbols("x", real=True)
+    k = symbols('k', integer=True, finite=True)
+    abs2 = lambda x: Piecewise((-x, x <= 0), (x, x > 0))
+    assert integrate(abs2(x), (x, -pi, pi)) == pi**2
+    func = cos(k*x)*sqrt(x**2)
+    assert integrate(func, (x, -pi, pi)) == Piecewise(
+        (2*(-1)**k/k**2 - 2/k**2, Ne(k, 0)), (pi**2, True))
+
+def test_issue_6900():
+    from itertools import permutations
+    t0, t1, T, t = symbols('t0, t1 T t')
+    f = Piecewise((0, t < t0), (x, And(t0 <= t, t < t1)), (0, t >= t1))
+    g = f.integrate(t)
+    assert g == Piecewise(
+        (0, t <= t0),
+        (t*x - t0*x, t <= Max(t0, t1)),
+        (-t0*x + x*Max(t0, t1), True))
+    for i in permutations(range(2)):
+        reps = dict(zip((t0,t1), i))
+        for tt in range(-1,3):
+            assert (g.xreplace(reps).subs(t,tt) ==
+                f.xreplace(reps).integrate(t).subs(t,tt))
+    lim = Tuple(t, t0, T)
+    g = f.integrate(lim)
+    ans = Piecewise(
+        (-t0*x + x*Min(T, Max(t0, t1)), T > t0),
+        (0, True))
+    for i in permutations(range(3)):
+        reps = dict(zip((t0,t1,T), i))
+        tru = f.xreplace(reps).integrate(lim.xreplace(reps))
+        assert tru == ans.xreplace(reps)
+    assert g == ans
+
+
+def test_issue_10122():
+    assert solve(abs(x) + abs(x - 1) - 1 > 0, x
+        ) == Or(And(-oo < x, x < S.Zero), And(S.One < x, x < oo))
+
+
+def test_issue_4313():
+    u = Piecewise((0, x <= 0), (1, x >= a), (x/a, True))
+    e = (u - u.subs(x, y))**2/(x - y)**2
+    M = Max(0, a)
+    assert integrate(e,  x).expand() == Piecewise(
+        (Piecewise(
+            (0, x <= 0),
+            (-y**2/(a**2*x - a**2*y) + x/a**2 - 2*y*log(-y)/a**2 +
+                2*y*log(x - y)/a**2 - y/a**2, x <= M),
+            (-y**2/(-a**2*y + a**2*M) + 1/(-y + M) -
+                1/(x - y) - 2*y*log(-y)/a**2 + 2*y*log(-y +
+                M)/a**2 - y/a**2 + M/a**2, True)),
+        ((a <= y) & (y <= 0)) | ((y <= 0) & (y > -oo))),
+        (Piecewise(
+            (-1/(x - y), x <= 0),
+            (-a**2/(a**2*x - a**2*y) + 2*a*y/(a**2*x - a**2*y) -
+                y**2/(a**2*x - a**2*y) + 2*log(-y)/a - 2*log(x - y)/a +
+                2/a + x/a**2 - 2*y*log(-y)/a**2 + 2*y*log(x - y)/a**2 -
+                y/a**2, x <= M),
+            (-a**2/(-a**2*y + a**2*M) + 2*a*y/(-a**2*y +
+                a**2*M) - y**2/(-a**2*y + a**2*M) +
+                2*log(-y)/a - 2*log(-y + M)/a + 2/a -
+                2*y*log(-y)/a**2 + 2*y*log(-y + M)/a**2 -
+                y/a**2 + M/a**2, True)),
+        a <= y),
+        (Piecewise(
+            (-y**2/(a**2*x - a**2*y), x <= 0),
+            (x/a**2 + y/a**2, x <= M),
+            (a**2/(-a**2*y + a**2*M) -
+                a**2/(a**2*x - a**2*y) - 2*a*y/(-a**2*y + a**2*M) +
+                2*a*y/(a**2*x - a**2*y) + y**2/(-a**2*y + a**2*M) -
+                y**2/(a**2*x - a**2*y) + y/a**2 + M/a**2, True)),
+        True))
+
+
+def test__intervals():
+    assert Piecewise((x + 2, Eq(x, 3)))._intervals(x) == (True, [])
+    assert Piecewise(
+        (1, x > x + 1),
+        (Piecewise((1, x < x + 1)), 2*x < 2*x + 1),
+        (1, True))._intervals(x) == (True, [(-oo, oo, 1, 1)])
+    assert Piecewise((1, Ne(x, I)), (0, True))._intervals(x) == (True,
+        [(-oo, oo, 1, 0)])
+    assert Piecewise((-cos(x), sin(x) >= 0), (cos(x), True)
+        )._intervals(x) == (True,
+        [(0, pi, -cos(x), 0), (-oo, oo, cos(x), 1)])
+    # the following tests that duplicates are removed and that non-Eq
+    # generated zero-width intervals are removed
+    assert Piecewise((1, Abs(x**(-2)) > 1), (0, True)
+        )._intervals(x) == (True,
+        [(-1, 0, 1, 0), (0, 1, 1, 0), (-oo, oo, 0, 1)])
+
+
+def test_containment():
+    a, b, c, d, e = [1, 2, 3, 4, 5]
+    p = (Piecewise((d, x > 1), (e, True))*
+        Piecewise((a, Abs(x - 1) < 1), (b, Abs(x - 2) < 2), (c, True)))
+    assert p.integrate(x).diff(x) == Piecewise(
+        (c*e, x <= 0),
+        (a*e, x <= 1),
+        (a*d, x < 2),  # this is what we want to get right
+        (b*d, x < 4),
+        (c*d, True))
+
+
+def test_piecewise_with_DiracDelta():
+    d1 = DiracDelta(x - 1)
+    assert integrate(d1, (x, -oo, oo)) == 1
+    assert integrate(d1, (x, 0, 2)) == 1
+    assert Piecewise((d1, Eq(x, 2)), (0, True)).integrate(x) == 0
+    assert Piecewise((d1, x < 2), (0, True)).integrate(x) == Piecewise(
+        (Heaviside(x - 1), x < 2), (1, True))
+    # TODO raise error if function is discontinuous at limit of
+    # integration, e.g. integrate(d1, (x, -2, 1)) or Piecewise(
+    # (d1, Eq(x, 1)
+
+
+def test_issue_10258():
+    assert Piecewise((0, x < 1), (1, True)).is_zero is None
+    assert Piecewise((-1, x < 1), (1, True)).is_zero is False
+    a = Symbol('a', zero=True)
+    assert Piecewise((0, x < 1), (a, True)).is_zero
+    assert Piecewise((1, x < 1), (a, x < 3)).is_zero is None
+    a = Symbol('a')
+    assert Piecewise((0, x < 1), (a, True)).is_zero is None
+    assert Piecewise((0, x < 1), (1, True)).is_nonzero is None
+    assert Piecewise((1, x < 1), (2, True)).is_nonzero
+    assert Piecewise((0, x < 1), (oo, True)).is_finite is None
+    assert Piecewise((0, x < 1), (1, True)).is_finite
+    b = Basic()
+    assert Piecewise((b, x < 1)).is_finite is None
+
+    # 10258
+    c = Piecewise((1, x < 0), (2, True)) < 3
+    assert c != True
+    assert piecewise_fold(c) == True
+
+
+def test_issue_10087():
+    a, b = Piecewise((x, x > 1), (2, True)), Piecewise((x, x > 3), (3, True))
+    m = a*b
+    f = piecewise_fold(m)
+    for i in (0, 2, 4):
+        assert m.subs(x, i) == f.subs(x, i)
+    m = a + b
+    f = piecewise_fold(m)
+    for i in (0, 2, 4):
+        assert m.subs(x, i) == f.subs(x, i)
+
+
+def test_issue_8919():
+    c = symbols('c:5')
+    x = symbols("x")
+    f1 = Piecewise((c[1], x < 1), (c[2], True))
+    f2 = Piecewise((c[3], x < Rational(1, 3)), (c[4], True))
+    assert integrate(f1*f2, (x, 0, 2)
+        ) == c[1]*c[3]/3 + 2*c[1]*c[4]/3 + c[2]*c[4]
+    f1 = Piecewise((0, x < 1), (2, True))
+    f2 = Piecewise((3, x < 2), (0, True))
+    assert integrate(f1*f2, (x, 0, 3)) == 6
+
+    y = symbols("y", positive=True)
+    a, b, c, x, z = symbols("a,b,c,x,z", real=True)
+    I = Integral(Piecewise(
+        (0, (x >= y) | (x < 0) | (b > c)),
+        (a, True)), (x, 0, z))
+    ans = I.doit()
+    assert ans == Piecewise((0, b > c), (a*Min(y, z) - a*Min(0, z), True))
+    for cond in (True, False):
+        for yy in range(1, 3):
+            for zz in range(-yy, 0, yy):
+                reps = [(b > c, cond), (y, yy), (z, zz)]
+                assert ans.subs(reps) == I.subs(reps).doit()
+
+
+def test_unevaluated_integrals():
+    f = Function('f')
+    p = Piecewise((1, Eq(f(x) - 1, 0)), (2, x - 10 < 0), (0, True))
+    assert p.integrate(x) == Integral(p, x)
+    assert p.integrate((x, 0, 5)) == Integral(p, (x, 0, 5))
+    # test it by replacing f(x) with x%2 which will not
+    # affect the answer: the integrand is essentially 2 over
+    # the domain of integration
+    assert Integral(p, (x, 0, 5)).subs(f(x), x%2).n() == 10.0
+
+    # this is a test of using _solve_inequality when
+    # solve_univariate_inequality fails
+    assert p.integrate(y) == Piecewise(
+        (y, Eq(f(x), 1) | ((x < 10) & Eq(f(x), 1))),
+        (2*y, (x > -oo) & (x < 10)), (0, True))
+
+
+def test_conditions_as_alternate_booleans():
+    a, b, c = symbols('a:c')
+    assert Piecewise((x, Piecewise((y < 1, x > 0), (y > 1, True)))
+        ) == Piecewise((x, ITE(x > 0, y < 1, y > 1)))
+
+
+def test_Piecewise_rewrite_as_ITE():
+    a, b, c, d = symbols('a:d')
+
+    def _ITE(*args):
+        return Piecewise(*args).rewrite(ITE)
+
+    assert _ITE((a, x < 1), (b, x >= 1)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, x < oo)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, Or(y < 1, x < oo)), (c, y > 0)
+               ) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, True)) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (b, x < 2), (c, True)
+               ) == ITE(x < 1, a, ITE(x < 2, b, c))
+    assert _ITE((a, x < 1), (b, y < 2), (c, True)
+               ) == ITE(x < 1, a, ITE(y < 2, b, c))
+    assert _ITE((a, x < 1), (b, x < oo), (c, y < 1)
+               ) == ITE(x < 1, a, b)
+    assert _ITE((a, x < 1), (c, y < 1), (b, x < oo), (d, True)
+               ) == ITE(x < 1, a, ITE(y < 1, c, b))
+    assert _ITE((a, x < 0), (b, Or(x < oo, y < 1))
+               ) == ITE(x < 0, a, b)
+    raises(TypeError, lambda: _ITE((x + 1, x < 1), (x, True)))
+    # if `a` in the following were replaced with y then the coverage
+    # is complete but something other than as_set would need to be
+    # used to detect this
+    raises(NotImplementedError, lambda: _ITE((x, x < y), (y, x >= a)))
+    raises(ValueError, lambda: _ITE((a, x < 2), (b, x > 3)))
+
+
+def test_Piecewise_replace_relational_27538():
+    x, y = symbols('x, y')
+    p1 = Piecewise(
+        (0, Eq(x, True)),
+        (1, True),
+    )
+    p2 = p1.xreplace({x: y < 1})
+    assert p2.subs(y, 0) == 0
+    assert p2.subs(y, 1) == 1
+
+
+def test_issue_14052():
+    assert integrate(abs(sin(x)), (x, 0, 2*pi)) == 4
+
+
+def test_issue_14240():
+    assert piecewise_fold(
+        Piecewise((1, a), (2, b), (4, True)) +
+        Piecewise((8, a), (16, True))
+        ) == Piecewise((9, a), (18, b), (20, True))
+    assert piecewise_fold(
+        Piecewise((2, a), (3, b), (5, True)) *
+        Piecewise((7, a), (11, True))
+        ) == Piecewise((14, a), (33, b), (55, True))
+    # these will hang if naive folding is used
+    assert piecewise_fold(Add(*[
+        Piecewise((i, a), (0, True)) for i in range(40)])
+        ) == Piecewise((780, a), (0, True))
+    assert piecewise_fold(Mul(*[
+        Piecewise((i, a), (0, True)) for i in range(1, 41)])
+        ) == Piecewise((factorial(40), a), (0, True))
+
+
+def test_issue_14787():
+    x = Symbol('x')
+    f = Piecewise((x, x < 1), ((S(58) / 7), True))
+    assert str(f.evalf()) == "Piecewise((x, x < 1), (8.28571428571429, True))"
+
+def test_issue_21481():
+    b, e = symbols('b e')
+    C = Piecewise(
+        (2,
+        ((b > 1) & (e > 0)) |
+        ((b > 0) & (b < 1) & (e < 0)) |
+        ((e >= 2) & (b < -1) & Eq(Mod(e, 2), 0)) |
+        ((e <= -2) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 0))),
+        (S.Half,
+        ((b > 1) & (e < 0)) |
+        ((b > 0) & (e > 0) & (b < 1)) |
+        ((e <= -2) & (b < -1) & Eq(Mod(e, 2), 0)) |
+        ((e >= 2) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 0))),
+        (-S.Half,
+        Eq(Mod(e, 2), 1) &
+        (((e <= -1) & (b < -1)) | ((e >= 1) & (b > -1) & (b < 0)))),
+        (-2,
+        ((e >= 1) & (b < -1) & Eq(Mod(e, 2), 1)) |
+        ((e <= -1) & (b > -1) & (b < 0) & Eq(Mod(e, 2), 1)))
+    )
+    A = Piecewise(
+        (1, Eq(b, 1) | Eq(e, 0) | (Eq(b, -1) & Eq(Mod(e, 2), 0))),
+        (0, Eq(b, 0) & (e > 0)),
+        (-1, Eq(b, -1) & Eq(Mod(e, 2), 1)),
+        (C, Eq(im(b), 0) & Eq(im(e), 0))
+    )
+
+    B = piecewise_fold(A)
+    sa = A.simplify()
+    sb = B.simplify()
+    v = (-2, -1, -S.Half, 0, S.Half, 1, 2)
+    for i in v:
+        for j in v:
+            r = {b:i, e:j}
+            ok = [k.xreplace(r) for k in (A, B, sa, sb)]
+            assert len(set(ok)) == 1
+
+
+def test_issue_8458():
+    x, y = symbols('x y')
+    # Original issue
+    p1 = Piecewise((0, Eq(x, 0)), (sin(x), True))
+    assert p1.simplify() == sin(x)
+    # Slightly larger variant
+    p2 = Piecewise((x, Eq(x, 0)), (4*x + (y-2)**4, Eq(x, 0) & Eq(x+y, 2)), (sin(x), True))
+    assert p2.simplify() == sin(x)
+    # Test for problem highlighted during review
+    p3 = Piecewise((x+1, Eq(x, -1)), (4*x + (y-2)**4, Eq(x, 0) & Eq(x+y, 2)), (sin(x), True))
+    assert p3.simplify() == Piecewise((0, Eq(x, -1)), (sin(x), True))
+
+
+def test_issue_16417():
+    z = Symbol('z')
+    assert unchanged(Piecewise, (1, Or(Eq(im(z), 0), Gt(re(z), 0))), (2, True))
+
+    x = Symbol('x')
+    assert unchanged(Piecewise, (S.Pi, re(x) < 0),
+                 (0, Or(re(x) > 0, Ne(im(x), 0))),
+                 (S.NaN, True))
+    r = Symbol('r', real=True)
+    p = Piecewise((S.Pi, re(r) < 0),
+                 (0, Or(re(r) > 0, Ne(im(r), 0))),
+                 (S.NaN, True))
+    assert p == Piecewise((S.Pi, r < 0),
+                 (0, r > 0),
+                 (S.NaN, True), evaluate=False)
+    # Does not work since imaginary != 0...
+    #i = Symbol('i', imaginary=True)
+    #p = Piecewise((S.Pi, re(i) < 0),
+    #              (0, Or(re(i) > 0, Ne(im(i), 0))),
+    #              (S.NaN, True))
+    #assert p == Piecewise((0, Ne(im(i), 0)),
+    #                      (S.NaN, True), evaluate=False)
+    i = I*r
+    p = Piecewise((S.Pi, re(i) < 0),
+                  (0, Or(re(i) > 0, Ne(im(i), 0))),
+                  (S.NaN, True))
+    assert p == Piecewise((0, Ne(im(i), 0)),
+                          (S.NaN, True), evaluate=False)
+    assert p == Piecewise((0, Ne(r, 0)),
+                          (S.NaN, True), evaluate=False)
+
+
+def test_eval_rewrite_as_KroneckerDelta():
+    x, y, z, n, t, m = symbols('x y z n t m')
+    K = KroneckerDelta
+    f = lambda p: expand(p.rewrite(K))
+
+    p1 = Piecewise((0, Eq(x, y)), (1, True))
+    assert f(p1) == 1 - K(x, y)
+
+    p2 = Piecewise((x, Eq(y,0)), (z, Eq(t,0)), (n, True))
+    assert f(p2) == n*K(0, t)*K(0, y) - n*K(0, t) - n*K(0, y) + n + \
+           x*K(0, y) - z*K(0, t)*K(0, y) + z*K(0, t)
+
+    p3 = Piecewise((1, Ne(x, y)), (0, True))
+    assert f(p3) == 1 - K(x, y)
+
+    p4 = Piecewise((1, Eq(x, 3)), (4, True), (5, True))
+    assert f(p4) == 4 - 3*K(3, x)
+
+    p5 = Piecewise((3, Ne(x, 2)), (4, Eq(y, 2)), (5, True))
+    assert f(p5) == -K(2, x)*K(2, y) + 2*K(2, x) + 3
+
+    p6 = Piecewise((0, Ne(x, 1) & Ne(y, 4)), (1, True))
+    assert f(p6) == -K(1, x)*K(4, y) + K(1, x) + K(4, y)
+
+    p7 = Piecewise((2, Eq(y, 3) & Ne(x, 2)), (1, True))
+    assert f(p7) == -K(2, x)*K(3, y) + K(3, y) + 1
+
+    p8 = Piecewise((4, Eq(x, 3) & Ne(y, 2)), (1, True))
+    assert f(p8) == -3*K(2, y)*K(3, x) + 3*K(3, x) + 1
+
+    p9 = Piecewise((6, Eq(x, 4) & Eq(y, 1)), (1, True))
+    assert f(p9) == 5 * K(1, y) * K(4, x) + 1
+
+    p10 = Piecewise((4, Ne(x, -4) | Ne(y, 1)), (1, True))
+    assert f(p10) == -3 * K(-4, x) * K(1, y) + 4
+
+    p11 = Piecewise((1, Eq(y, 2) | Ne(x, -3)), (2, True))
+    assert f(p11) == -K(-3, x)*K(2, y) + K(-3, x) + 1
+
+    p12 = Piecewise((-1, Eq(x, 1) | Ne(y, 3)), (1, True))
+    assert f(p12) == -2*K(1, x)*K(3, y) + 2*K(3, y) - 1
+
+    p13 = Piecewise((3, Eq(x, 2) | Eq(y, 4)), (1, True))
+    assert f(p13) == -2*K(2, x)*K(4, y) + 2*K(2, x) + 2*K(4, y) + 1
+
+    p14 = Piecewise((1, Ne(x, 0) | Ne(y, 1)), (3, True))
+    assert f(p14) == 2 * K(0, x) * K(1, y) + 1
+
+    p15 = Piecewise((2, Eq(x, 3) | Ne(y, 2)), (3, Eq(x, 4) & Eq(y, 5)), (1, True))
+    assert f(p15) == -2*K(2, y)*K(3, x)*K(4, x)*K(5, y) + K(2, y)*K(3, x) + \
+           2*K(2, y)*K(4, x)*K(5, y) - K(2, y) + 2
+
+    p16 = Piecewise((0, Ne(m, n)), (1, True))*Piecewise((0, Ne(n, t)), (1, True))\
+          *Piecewise((0, Ne(n, x)), (1, True)) - Piecewise((0, Ne(t, x)), (1, True))
+    assert f(p16) == K(m, n)*K(n, t)*K(n, x) - K(t, x)
+
+    p17 = Piecewise((0, Ne(t, x) & (Ne(m, n) | Ne(n, t) | Ne(n, x))),
+                    (1, Ne(t, x)), (-1, Ne(m, n) | Ne(n, t) | Ne(n, x)), (0, True))
+    assert f(p17) == K(m, n)*K(n, t)*K(n, x) - K(t, x)
+
+    p18 = Piecewise((-4, Eq(y, 1) | (Eq(x, -5) & Eq(x, z))), (4, True))
+    assert f(p18) == 8*K(-5, x)*K(1, y)*K(x, z) - 8*K(-5, x)*K(x, z) - 8*K(1, y) + 4
+
+    p19 = Piecewise((0, x > 2), (1, True))
+    assert f(p19) == p19
+
+    p20 = Piecewise((0, And(x < 2, x > -5)), (1, True))
+    assert f(p20) == p20
+
+    p21 = Piecewise((0, Or(x > 1, x < 0)), (1, True))
+    assert f(p21) == p21
+
+    p22 = Piecewise((0, ~((Eq(y, -1) | Ne(x, 0)) & (Ne(x, 1) | Ne(y, -1)))), (1, True))
+    assert f(p22) == K(-1, y)*K(0, x) - K(-1, y)*K(1, x) - K(0, x) + 1
+
+
+@slow
+def test_identical_conds_issue():
+    from sympy.stats import Uniform, density
+    u1 = Uniform('u1', 0, 1)
+    u2 = Uniform('u2', 0, 1)
+    # Result is quite big, so not really important here (and should ideally be
+    # simpler). Should not give an exception though.
+    density(u1 + u2)
+
+
+def test_issue_7370():
+    f = Piecewise((1, x <= 2400))
+    v = integrate(f, (x, 0, Float("252.4", 30)))
+    assert str(v) == '252.400000000000000000000000000'
+
+
+def test_issue_14933():
+    x = Symbol('x')
+    y = Symbol('y')
+
+    inp = MatrixSymbol('inp', 1, 1)
+    rep_dict = {y: inp[0, 0], x: inp[0, 0]}
+
+    p = Piecewise((1, ITE(y > 0, x < 0, True)))
+    assert p.xreplace(rep_dict) == Piecewise((1, ITE(inp[0, 0] > 0, inp[0, 0] < 0, True)))
+
+
+def test_issue_16715():
+    raises(NotImplementedError, lambda: Piecewise((x, x<0), (0, y>1)).as_expr_set_pairs())
+
+
+def test_issue_20360():
+    t, tau = symbols("t tau", real=True)
+    n = symbols("n", integer=True)
+    lam = pi * (n - S.Half)
+    eq = integrate(exp(lam * tau), (tau, 0, t))
+    assert eq.simplify() == (2*exp(pi*t*(2*n - 1)/2) - 2)/(pi*(2*n - 1))
+
+
+def test_piecewise_eval():
+    # XXX these tests might need modification if this
+    # simplification is moved out of eval and into
+    # boolalg or Piecewise simplification functions
+    f = lambda x: x.args[0].cond
+    # unsimplified
+    assert f(Piecewise((x, (x > -oo) & (x < 3)))
+        ) == ((x > -oo) & (x < 3))
+    assert f(Piecewise((x, (x > -oo) & (x < oo)))
+        ) == ((x > -oo) & (x < oo))
+    assert f(Piecewise((x, (x > -3) & (x < 3)))
+        ) == ((x > -3) & (x < 3))
+    assert f(Piecewise((x, (x > -3) & (x < oo)))
+        ) == ((x > -3) & (x < oo))
+    assert f(Piecewise((x, (x <= 3) & (x > -oo)))
+        ) == ((x <= 3) & (x > -oo))
+    assert f(Piecewise((x, (x <= 3) & (x > -3)))
+        ) == ((x <= 3) & (x > -3))
+    assert f(Piecewise((x, (x >= -3) & (x < 3)))
+        ) == ((x >= -3) & (x < 3))
+    assert f(Piecewise((x, (x >= -3) & (x < oo)))
+        ) == ((x >= -3) & (x < oo))
+    assert f(Piecewise((x, (x >= -3) & (x <= 3)))
+        ) == ((x >= -3) & (x <= 3))
+    # could simplify by keeping only the first
+    # arg of result
+    assert f(Piecewise((x, (x <= oo) & (x > -oo)))
+        ) == (x > -oo) & (x <= oo)
+    assert f(Piecewise((x, (x <= oo) & (x > -3)))
+        ) == (x > -3) & (x <= oo)
+    assert f(Piecewise((x, (x >= -oo) & (x < 3)))
+        ) == (x < 3) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x < oo)))
+        ) == (x < oo) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x <= 3)))
+        ) == (x <= 3) & (x >= -oo)
+    assert f(Piecewise((x, (x >= -oo) & (x <= oo)))
+        ) == (x <= oo) & (x >= -oo)  # but cannot be True unless x is real
+    assert f(Piecewise((x, (x >= -3) & (x <= oo)))
+        ) == (x >= -3) & (x <= oo)
+    assert f(Piecewise((x, (Abs(arg(a)) <= 1) | (Abs(arg(a)) < 1)))
+        ) == (Abs(arg(a)) <= 1) | (Abs(arg(a)) < 1)
+
+
+def test_issue_22533():
+    x = Symbol('x', real=True)
+    f = Piecewise((-1 / x, x <= 0), (1 / x, True))
+    assert integrate(f, x) == Piecewise((-log(x), x <= 0), (log(x), True))
+
+
+def test_issue_24072():
+    assert Piecewise((1, x > 1), (2, x <= 1), (3, x <= 1)
+        ) == Piecewise((1, x > 1), (2, True))
+
+
+def test_piecewise__eval_is_meromorphic():
+    """ Issue 24127: Tests eval_is_meromorphic auxiliary method """
+    x = symbols('x', real=True)
+    f = Piecewise((1, x < 0), (sqrt(1 - x), True))
+    assert f.is_meromorphic(x, I) is None
+    assert f.is_meromorphic(x, -1) == True
+    assert f.is_meromorphic(x, 0) == None
+    assert f.is_meromorphic(x, 1) == False
+    assert f.is_meromorphic(x, 2) == True
+    assert f.is_meromorphic(x, Symbol('a')) == None
+    assert f.is_meromorphic(x, Symbol('a', real=True)) == None
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_trigonometric.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_trigonometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..815f424093aac72ee3a078d8ce62e5c195a625dc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/tests/test_trigonometric.py
@@ -0,0 +1,2236 @@
+from sympy.calculus.accumulationbounds import AccumBounds
+from sympy.core.add import Add
+from sympy.core.function import (Lambda, diff)
+from sympy.core.mod import Mod
+from sympy.core.mul import Mul
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (arg, conjugate, im, re)
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.hyperbolic import (acoth, asinh, atanh, cosh, coth, sinh, tanh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, acot, acsc, asec, asin, atan, atan2,
+                                                      cos, cot, csc, sec, sin, sinc, tan)
+from sympy.functions.special.bessel import (besselj, jn)
+from sympy.functions.special.delta_functions import Heaviside
+from sympy.matrices.dense import Matrix
+from sympy.polys.polytools import (cancel, gcd)
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.sets.fancysets import ImageSet
+from sympy.sets.sets import (FiniteSet, Interval)
+from sympy.simplify.simplify import simplify
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError, PoleError
+from sympy.core.relational import Ne, Eq
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.sets.setexpr import SetExpr
+from sympy.testing.pytest import XFAIL, slow, raises
+
+
+x, y, z = symbols('x y z')
+r = Symbol('r', real=True)
+k, m = symbols('k m', integer=True)
+p = Symbol('p', positive=True)
+n = Symbol('n', negative=True)
+np = Symbol('p', nonpositive=True)
+nn = Symbol('n', nonnegative=True)
+nz = Symbol('nz', nonzero=True)
+ep = Symbol('ep', extended_positive=True)
+en = Symbol('en', extended_negative=True)
+enp = Symbol('ep', extended_nonpositive=True)
+enn = Symbol('en', extended_nonnegative=True)
+enz = Symbol('enz', extended_nonzero=True)
+a = Symbol('a', algebraic=True)
+na = Symbol('na', nonzero=True, algebraic=True)
+
+
+def test_sin():
+    x, y = symbols('x y')
+    z = symbols('z', imaginary=True)
+
+    assert sin.nargs == FiniteSet(1)
+    assert sin(nan) is nan
+    assert sin(zoo) is nan
+
+    assert sin(oo) == AccumBounds(-1, 1)
+    assert sin(oo) - sin(oo) == AccumBounds(-2, 2)
+    assert sin(oo*I) == oo*I
+    assert sin(-oo*I) == -oo*I
+    assert 0*sin(oo) is S.Zero
+    assert 0/sin(oo) is S.Zero
+    assert 0 + sin(oo) == AccumBounds(-1, 1)
+    assert 5 + sin(oo) == AccumBounds(4, 6)
+
+    assert sin(0) == 0
+
+    assert sin(z*I) == I*sinh(z)
+    assert sin(asin(x)) == x
+    assert sin(atan(x)) == x / sqrt(1 + x**2)
+    assert sin(acos(x)) == sqrt(1 - x**2)
+    assert sin(acot(x)) == 1 / (sqrt(1 + 1 / x**2) * x)
+    assert sin(acsc(x)) == 1 / x
+    assert sin(asec(x)) == sqrt(1 - 1 / x**2)
+    assert sin(atan2(y, x)) == y / sqrt(x**2 + y**2)
+
+    assert sin(pi*I) == sinh(pi)*I
+    assert sin(-pi*I) == -sinh(pi)*I
+    assert sin(-2*I) == -sinh(2)*I
+
+    assert sin(pi) == 0
+    assert sin(-pi) == 0
+    assert sin(2*pi) == 0
+    assert sin(-2*pi) == 0
+    assert sin(-3*10**73*pi) == 0
+    assert sin(7*10**103*pi) == 0
+
+    assert sin(pi/2) == 1
+    assert sin(-pi/2) == -1
+    assert sin(pi*Rational(5, 2)) == 1
+    assert sin(pi*Rational(7, 2)) == -1
+
+    ne = symbols('ne', integer=True, even=False)
+    e = symbols('e', even=True)
+    assert sin(pi*ne/2) == (-1)**(ne/2 - S.Half)
+    assert sin(pi*k/2).func == sin
+    assert sin(pi*e/2) == 0
+    assert sin(pi*k) == 0
+    assert sin(pi*k).subs(k, 3) == sin(pi*k/2).subs(k, 6)  # issue 8298
+
+    assert sin(pi/3) == S.Half*sqrt(3)
+    assert sin(pi*Rational(-2, 3)) == Rational(-1, 2)*sqrt(3)
+
+    assert sin(pi/4) == S.Half*sqrt(2)
+    assert sin(-pi/4) == Rational(-1, 2)*sqrt(2)
+    assert sin(pi*Rational(17, 4)) == S.Half*sqrt(2)
+    assert sin(pi*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)
+
+    assert sin(pi/6) == S.Half
+    assert sin(-pi/6) == Rational(-1, 2)
+    assert sin(pi*Rational(7, 6)) == Rational(-1, 2)
+    assert sin(pi*Rational(-5, 6)) == Rational(-1, 2)
+
+    assert sin(pi*Rational(1, 5)) == sqrt((5 - sqrt(5)) / 8)
+    assert sin(pi*Rational(2, 5)) == sqrt((5 + sqrt(5)) / 8)
+    assert sin(pi*Rational(3, 5)) == sin(pi*Rational(2, 5))
+    assert sin(pi*Rational(4, 5)) == sin(pi*Rational(1, 5))
+    assert sin(pi*Rational(6, 5)) == -sin(pi*Rational(1, 5))
+    assert sin(pi*Rational(8, 5)) == -sin(pi*Rational(2, 5))
+
+    assert sin(pi*Rational(-1273, 5)) == -sin(pi*Rational(2, 5))
+
+    assert sin(pi/8) == sqrt((2 - sqrt(2))/4)
+
+    assert sin(pi/10) == Rational(-1, 4) + sqrt(5)/4
+
+    assert sin(pi/12) == -sqrt(2)/4 + sqrt(6)/4
+    assert sin(pi*Rational(5, 12)) == sqrt(2)/4 + sqrt(6)/4
+    assert sin(pi*Rational(-7, 12)) == -sqrt(2)/4 - sqrt(6)/4
+    assert sin(pi*Rational(-11, 12)) == sqrt(2)/4 - sqrt(6)/4
+
+    assert sin(pi*Rational(104, 105)) == sin(pi/105)
+    assert sin(pi*Rational(106, 105)) == -sin(pi/105)
+
+    assert sin(pi*Rational(-104, 105)) == -sin(pi/105)
+    assert sin(pi*Rational(-106, 105)) == sin(pi/105)
+
+    assert sin(x*I) == sinh(x)*I
+
+    assert sin(k*pi) == 0
+    assert sin(17*k*pi) == 0
+    assert sin(2*k*pi + 4) == sin(4)
+    assert sin(2*k*pi + m*pi + 1) == (-1)**(m + 2*k)*sin(1)
+
+    assert sin(k*pi*I) == sinh(k*pi)*I
+
+    assert sin(r).is_real is True
+
+    assert sin(0, evaluate=False).is_algebraic
+    assert sin(a).is_algebraic is None
+    assert sin(na).is_algebraic is False
+    q = Symbol('q', rational=True)
+    assert sin(pi*q).is_algebraic
+    qn = Symbol('qn', rational=True, nonzero=True)
+    assert sin(qn).is_rational is False
+    assert sin(q).is_rational is None  # issue 8653
+
+    assert isinstance(sin( re(x) - im(y)), sin) is True
+    assert isinstance(sin(-re(x) + im(y)), sin) is False
+
+    assert sin(SetExpr(Interval(0, 1))) == SetExpr(ImageSet(Lambda(x, sin(x)),
+                       Interval(0, 1)))
+
+    for d in list(range(1, 22)) + [60, 85]:
+        for n in range(d*2 + 1):
+            x = n*pi/d
+            e = abs( float(sin(x)) - sin(float(x)) )
+            assert e < 1e-12
+
+    assert sin(0, evaluate=False).is_zero is True
+    assert sin(k*pi, evaluate=False).is_zero is True
+
+    assert sin(Add(1, -1, evaluate=False), evaluate=False).is_zero is True
+
+
+def test_sin_cos():
+    for d in [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 24, 30, 40, 60, 120]:  # list is not exhaustive...
+        for n in range(-2*d, d*2):
+            x = n*pi/d
+            assert sin(x + pi/2) == cos(x), "fails for %d*pi/%d" % (n, d)
+            assert sin(x - pi/2) == -cos(x), "fails for %d*pi/%d" % (n, d)
+            assert sin(x) == cos(x - pi/2), "fails for %d*pi/%d" % (n, d)
+            assert -sin(x) == cos(x + pi/2), "fails for %d*pi/%d" % (n, d)
+
+
+def test_sin_series():
+    assert sin(x).series(x, 0, 9) == \
+        x - x**3/6 + x**5/120 - x**7/5040 + O(x**9)
+
+
+def test_sin_rewrite():
+    assert sin(x).rewrite(exp) == -I*(exp(I*x) - exp(-I*x))/2
+    assert sin(x).rewrite(tan) == 2*tan(x/2)/(1 + tan(x/2)**2)
+    assert sin(x).rewrite(cot) == \
+        Piecewise((0, Eq(im(x), 0) & Eq(Mod(x, pi), 0)),
+                  (2*cot(x/2)/(cot(x/2)**2 + 1), True))
+    assert sin(sinh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert sin(cosh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert sin(tanh(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert sin(coth(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, coth(3)).n()
+    assert sin(sin(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sin(3)).n()
+    assert sin(cos(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cos(3)).n()
+    assert sin(tan(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tan(3)).n()
+    assert sin(cot(x)).rewrite(
+        exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cot(3)).n()
+    assert sin(log(x)).rewrite(Pow) == I*x**-I / 2 - I*x**I /2
+    assert sin(x).rewrite(csc) == 1/csc(x)
+    assert sin(x).rewrite(cos) == cos(x - pi / 2, evaluate=False)
+    assert sin(x).rewrite(sec) == 1 / sec(x - pi / 2, evaluate=False)
+    assert sin(cos(x)).rewrite(Pow) == sin(cos(x))
+    assert sin(x).rewrite(besselj) == sqrt(pi*x/2)*besselj(S.Half, x)
+    assert sin(x).rewrite(besselj).subs(x, 0) == sin(0)
+
+
+def _test_extrig(f, i, e):
+    from sympy.core.function import expand_trig
+    assert unchanged(f, i)
+    assert expand_trig(f(i)) == f(i)
+    # testing directly instead of with .expand(trig=True)
+    # because the other expansions undo the unevaluated Mul
+    assert expand_trig(f(Mul(i, 1, evaluate=False))) == e
+    assert abs(f(i) - e).n() < 1e-10
+
+
+def test_sin_expansion():
+    # Note: these formulas are not unique.  The ones here come from the
+    # Chebyshev formulas.
+    assert sin(x + y).expand(trig=True) == sin(x)*cos(y) + cos(x)*sin(y)
+    assert sin(x - y).expand(trig=True) == sin(x)*cos(y) - cos(x)*sin(y)
+    assert sin(y - x).expand(trig=True) == cos(x)*sin(y) - sin(x)*cos(y)
+    assert sin(2*x).expand(trig=True) == 2*sin(x)*cos(x)
+    assert sin(3*x).expand(trig=True) == -4*sin(x)**3 + 3*sin(x)
+    assert sin(4*x).expand(trig=True) == -8*sin(x)**3*cos(x) + 4*sin(x)*cos(x)
+    assert sin(2*pi/17).expand(trig=True) == sin(2*pi/17, evaluate=False)
+    assert sin(x+pi/17).expand(trig=True) == sin(pi/17)*cos(x) + cos(pi/17)*sin(x)
+    _test_extrig(sin, 2, 2*sin(1)*cos(1))
+    _test_extrig(sin, 3, -4*sin(1)**3 + 3*sin(1))
+
+
+def test_sin_AccumBounds():
+    assert sin(AccumBounds(-oo, oo)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, oo)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(-oo, 0)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, 2*S.Pi)) == AccumBounds(-1, 1)
+    assert sin(AccumBounds(0, S.Pi*Rational(3, 4))) == AccumBounds(0, 1)
+    assert sin(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(7, 4))) == AccumBounds(-1, sin(S.Pi*Rational(3, 4)))
+    assert sin(AccumBounds(S.Pi/4, S.Pi/3)) == AccumBounds(sin(S.Pi/4), sin(S.Pi/3))
+    assert sin(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(5, 6))) == AccumBounds(sin(S.Pi*Rational(5, 6)), sin(S.Pi*Rational(3, 4)))
+
+
+def test_sin_fdiff():
+    assert sin(x).fdiff() == cos(x)
+    raises(ArgumentIndexError, lambda: sin(x).fdiff(2))
+
+
+def test_trig_symmetry():
+    assert sin(-x) == -sin(x)
+    assert cos(-x) == cos(x)
+    assert tan(-x) == -tan(x)
+    assert cot(-x) == -cot(x)
+    assert sin(x + pi) == -sin(x)
+    assert sin(x + 2*pi) == sin(x)
+    assert sin(x + 3*pi) == -sin(x)
+    assert sin(x + 4*pi) == sin(x)
+    assert sin(x - 5*pi) == -sin(x)
+    assert cos(x + pi) == -cos(x)
+    assert cos(x + 2*pi) == cos(x)
+    assert cos(x + 3*pi) == -cos(x)
+    assert cos(x + 4*pi) == cos(x)
+    assert cos(x - 5*pi) == -cos(x)
+    assert tan(x + pi) == tan(x)
+    assert tan(x - 3*pi) == tan(x)
+    assert cot(x + pi) == cot(x)
+    assert cot(x - 3*pi) == cot(x)
+    assert sin(pi/2 - x) == cos(x)
+    assert sin(pi*Rational(3, 2) - x) == -cos(x)
+    assert sin(pi*Rational(5, 2) - x) == cos(x)
+    assert cos(pi/2 - x) == sin(x)
+    assert cos(pi*Rational(3, 2) - x) == -sin(x)
+    assert cos(pi*Rational(5, 2) - x) == sin(x)
+    assert tan(pi/2 - x) == cot(x)
+    assert tan(pi*Rational(3, 2) - x) == cot(x)
+    assert tan(pi*Rational(5, 2) - x) == cot(x)
+    assert cot(pi/2 - x) == tan(x)
+    assert cot(pi*Rational(3, 2) - x) == tan(x)
+    assert cot(pi*Rational(5, 2) - x) == tan(x)
+    assert sin(pi/2 + x) == cos(x)
+    assert cos(pi/2 + x) == -sin(x)
+    assert tan(pi/2 + x) == -cot(x)
+    assert cot(pi/2 + x) == -tan(x)
+
+
+def test_cos():
+    x, y = symbols('x y')
+
+    assert cos.nargs == FiniteSet(1)
+    assert cos(nan) is nan
+
+    assert cos(oo) == AccumBounds(-1, 1)
+    assert cos(oo) - cos(oo) == AccumBounds(-2, 2)
+    assert cos(oo*I) is oo
+    assert cos(-oo*I) is oo
+    assert cos(zoo) is nan
+
+    assert cos(0) == 1
+
+    assert cos(acos(x)) == x
+    assert cos(atan(x)) == 1 / sqrt(1 + x**2)
+    assert cos(asin(x)) == sqrt(1 - x**2)
+    assert cos(acot(x)) == 1 / sqrt(1 + 1 / x**2)
+    assert cos(acsc(x)) == sqrt(1 - 1 / x**2)
+    assert cos(asec(x)) == 1 / x
+    assert cos(atan2(y, x)) == x / sqrt(x**2 + y**2)
+
+    assert cos(pi*I) == cosh(pi)
+    assert cos(-pi*I) == cosh(pi)
+    assert cos(-2*I) == cosh(2)
+
+    assert cos(pi/2) == 0
+    assert cos(-pi/2) == 0
+    assert cos(pi/2) == 0
+    assert cos(-pi/2) == 0
+    assert cos((-3*10**73 + 1)*pi/2) == 0
+    assert cos((7*10**103 + 1)*pi/2) == 0
+
+    n = symbols('n', integer=True, even=False)
+    e = symbols('e', even=True)
+    assert cos(pi*n/2) == 0
+    assert cos(pi*e/2) == (-1)**(e/2)
+
+    assert cos(pi) == -1
+    assert cos(-pi) == -1
+    assert cos(2*pi) == 1
+    assert cos(5*pi) == -1
+    assert cos(8*pi) == 1
+
+    assert cos(pi/3) == S.Half
+    assert cos(pi*Rational(-2, 3)) == Rational(-1, 2)
+
+    assert cos(pi/4) == S.Half*sqrt(2)
+    assert cos(-pi/4) == S.Half*sqrt(2)
+    assert cos(pi*Rational(11, 4)) == Rational(-1, 2)*sqrt(2)
+    assert cos(pi*Rational(-3, 4)) == Rational(-1, 2)*sqrt(2)
+
+    assert cos(pi/6) == S.Half*sqrt(3)
+    assert cos(-pi/6) == S.Half*sqrt(3)
+    assert cos(pi*Rational(7, 6)) == Rational(-1, 2)*sqrt(3)
+    assert cos(pi*Rational(-5, 6)) == Rational(-1, 2)*sqrt(3)
+
+    assert cos(pi*Rational(1, 5)) == (sqrt(5) + 1)/4
+    assert cos(pi*Rational(2, 5)) == (sqrt(5) - 1)/4
+    assert cos(pi*Rational(3, 5)) == -cos(pi*Rational(2, 5))
+    assert cos(pi*Rational(4, 5)) == -cos(pi*Rational(1, 5))
+    assert cos(pi*Rational(6, 5)) == -cos(pi*Rational(1, 5))
+    assert cos(pi*Rational(8, 5)) == cos(pi*Rational(2, 5))
+
+    assert cos(pi*Rational(-1273, 5)) == -cos(pi*Rational(2, 5))
+
+    assert cos(pi/8) == sqrt((2 + sqrt(2))/4)
+
+    assert cos(pi/12) == sqrt(2)/4 + sqrt(6)/4
+    assert cos(pi*Rational(5, 12)) == -sqrt(2)/4 + sqrt(6)/4
+    assert cos(pi*Rational(7, 12)) == sqrt(2)/4 - sqrt(6)/4
+    assert cos(pi*Rational(11, 12)) == -sqrt(2)/4 - sqrt(6)/4
+
+    assert cos(pi*Rational(104, 105)) == -cos(pi/105)
+    assert cos(pi*Rational(106, 105)) == -cos(pi/105)
+
+    assert cos(pi*Rational(-104, 105)) == -cos(pi/105)
+    assert cos(pi*Rational(-106, 105)) == -cos(pi/105)
+
+    assert cos(x*I) == cosh(x)
+    assert cos(k*pi*I) == cosh(k*pi)
+
+    assert cos(r).is_real is True
+
+    assert cos(0, evaluate=False).is_algebraic
+    assert cos(a).is_algebraic is None
+    assert cos(na).is_algebraic is False
+    q = Symbol('q', rational=True)
+    assert cos(pi*q).is_algebraic
+    assert cos(pi*Rational(2, 7)).is_algebraic
+
+    assert cos(k*pi) == (-1)**k
+    assert cos(2*k*pi) == 1
+    assert cos(0, evaluate=False).is_zero is False
+    assert cos(Rational(1, 2)).is_zero is False
+    # The following test will return None as the result, but really it should
+    # be True even if it is not always possible to resolve an assumptions query.
+    assert cos(asin(-1, evaluate=False), evaluate=False).is_zero is None
+    for d in list(range(1, 22)) + [60, 85]:
+        for n in range(2*d + 1):
+            x = n*pi/d
+            e = abs( float(cos(x)) - cos(float(x)) )
+            assert e < 1e-12
+
+
+def test_issue_6190():
+    c = Float('123456789012345678901234567890.25', '')
+    for cls in [sin, cos, tan, cot]:
+        assert cls(c*pi) == cls(pi/4)
+        assert cls(4.125*pi) == cls(pi/8)
+        assert cls(4.7*pi) == cls((4.7 % 2)*pi)
+
+
+def test_cos_series():
+    assert cos(x).series(x, 0, 9) == \
+        1 - x**2/2 + x**4/24 - x**6/720 + x**8/40320 + O(x**9)
+
+
+def test_cos_rewrite():
+    assert cos(x).rewrite(exp) == exp(I*x)/2 + exp(-I*x)/2
+    assert cos(x).rewrite(tan) == (1 - tan(x/2)**2)/(1 + tan(x/2)**2)
+    assert cos(x).rewrite(cot) == \
+        Piecewise((1, Eq(im(x), 0) & Eq(Mod(x, 2*pi), 0)),
+                  ((cot(x/2)**2 - 1)/(cot(x/2)**2 + 1), True))
+    assert cos(sinh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert cos(cosh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert cos(tanh(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert cos(coth(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, coth(3)).n()
+    assert cos(sin(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sin(3)).n()
+    assert cos(cos(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cos(3)).n()
+    assert cos(tan(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tan(3)).n()
+    assert cos(cot(x)).rewrite(
+        exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cot(3)).n()
+    assert cos(log(x)).rewrite(Pow) == x**I/2 + x**-I/2
+    assert cos(x).rewrite(sec) == 1/sec(x)
+    assert cos(x).rewrite(sin) == sin(x + pi/2, evaluate=False)
+    assert cos(x).rewrite(csc) == 1/csc(-x + pi/2, evaluate=False)
+    assert cos(sin(x)).rewrite(Pow) == cos(sin(x))
+    assert cos(x).rewrite(besselj) == Piecewise(
+                (sqrt(pi*x/2)*besselj(-S.Half, x), Ne(x, 0)),
+                (1, True)
+            )
+    assert cos(x).rewrite(besselj).subs(x, 0) == cos(0)
+
+
+def test_cos_expansion():
+    assert cos(x + y).expand(trig=True) == cos(x)*cos(y) - sin(x)*sin(y)
+    assert cos(x - y).expand(trig=True) == cos(x)*cos(y) + sin(x)*sin(y)
+    assert cos(y - x).expand(trig=True) == cos(x)*cos(y) + sin(x)*sin(y)
+    assert cos(2*x).expand(trig=True) == 2*cos(x)**2 - 1
+    assert cos(3*x).expand(trig=True) == 4*cos(x)**3 - 3*cos(x)
+    assert cos(4*x).expand(trig=True) == 8*cos(x)**4 - 8*cos(x)**2 + 1
+    assert cos(2*pi/17).expand(trig=True) == cos(2*pi/17, evaluate=False)
+    assert cos(x+pi/17).expand(trig=True) == cos(pi/17)*cos(x) - sin(pi/17)*sin(x)
+    _test_extrig(cos, 2, 2*cos(1)**2 - 1)
+    _test_extrig(cos, 3, 4*cos(1)**3 - 3*cos(1))
+
+
+def test_cos_AccumBounds():
+    assert cos(AccumBounds(-oo, oo)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(0, oo)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(-oo, 0)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(0, 2*S.Pi)) == AccumBounds(-1, 1)
+    assert cos(AccumBounds(-S.Pi/3, S.Pi/4)) == AccumBounds(cos(-S.Pi/3), 1)
+    assert cos(AccumBounds(S.Pi*Rational(3, 4), S.Pi*Rational(5, 4))) == AccumBounds(-1, cos(S.Pi*Rational(3, 4)))
+    assert cos(AccumBounds(S.Pi*Rational(5, 4), S.Pi*Rational(4, 3))) == AccumBounds(cos(S.Pi*Rational(5, 4)), cos(S.Pi*Rational(4, 3)))
+    assert cos(AccumBounds(S.Pi/4, S.Pi/3)) == AccumBounds(cos(S.Pi/3), cos(S.Pi/4))
+
+
+def test_cos_fdiff():
+    assert cos(x).fdiff() == -sin(x)
+    raises(ArgumentIndexError, lambda: cos(x).fdiff(2))
+
+
+def test_tan():
+    assert tan(nan) is nan
+
+    assert tan(zoo) is nan
+    assert tan(oo) == AccumBounds(-oo, oo)
+    assert tan(oo) - tan(oo) == AccumBounds(-oo, oo)
+    assert tan.nargs == FiniteSet(1)
+    assert tan(oo*I) == I
+    assert tan(-oo*I) == -I
+
+    assert tan(0) == 0
+
+    assert tan(atan(x)) == x
+    assert tan(asin(x)) == x / sqrt(1 - x**2)
+    assert tan(acos(x)) == sqrt(1 - x**2) / x
+    assert tan(acot(x)) == 1 / x
+    assert tan(acsc(x)) == 1 / (sqrt(1 - 1 / x**2) * x)
+    assert tan(asec(x)) == sqrt(1 - 1 / x**2) * x
+    assert tan(atan2(y, x)) == y/x
+
+    assert tan(pi*I) == tanh(pi)*I
+    assert tan(-pi*I) == -tanh(pi)*I
+    assert tan(-2*I) == -tanh(2)*I
+
+    assert tan(pi) == 0
+    assert tan(-pi) == 0
+    assert tan(2*pi) == 0
+    assert tan(-2*pi) == 0
+    assert tan(-3*10**73*pi) == 0
+
+    assert tan(pi/2) is zoo
+    assert tan(pi*Rational(3, 2)) is zoo
+
+    assert tan(pi/3) == sqrt(3)
+    assert tan(pi*Rational(-2, 3)) == sqrt(3)
+
+    assert tan(pi/4) is S.One
+    assert tan(-pi/4) is S.NegativeOne
+    assert tan(pi*Rational(17, 4)) is S.One
+    assert tan(pi*Rational(-3, 4)) is S.One
+
+    assert tan(pi/5) == sqrt(5 - 2*sqrt(5))
+    assert tan(pi*Rational(2, 5)) == sqrt(5 + 2*sqrt(5))
+    assert tan(pi*Rational(18, 5)) == -sqrt(5 + 2*sqrt(5))
+    assert tan(pi*Rational(-16, 5)) == -sqrt(5 - 2*sqrt(5))
+
+    assert tan(pi/6) == 1/sqrt(3)
+    assert tan(-pi/6) == -1/sqrt(3)
+    assert tan(pi*Rational(7, 6)) == 1/sqrt(3)
+    assert tan(pi*Rational(-5, 6)) == 1/sqrt(3)
+
+    assert tan(pi/8) == -1 + sqrt(2)
+    assert tan(pi*Rational(3, 8)) == 1 + sqrt(2)  # issue 15959
+    assert tan(pi*Rational(5, 8)) == -1 - sqrt(2)
+    assert tan(pi*Rational(7, 8)) == 1 - sqrt(2)
+
+    assert tan(pi/10) == sqrt(1 - 2*sqrt(5)/5)
+    assert tan(pi*Rational(3, 10)) == sqrt(1 + 2*sqrt(5)/5)
+    assert tan(pi*Rational(17, 10)) == -sqrt(1 + 2*sqrt(5)/5)
+    assert tan(pi*Rational(-31, 10)) == -sqrt(1 - 2*sqrt(5)/5)
+
+    assert tan(pi/12) == -sqrt(3) + 2
+    assert tan(pi*Rational(5, 12)) == sqrt(3) + 2
+    assert tan(pi*Rational(7, 12)) == -sqrt(3) - 2
+    assert tan(pi*Rational(11, 12)) == sqrt(3) - 2
+
+    assert tan(pi/24).radsimp() == -2 - sqrt(3) + sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(5, 24)).radsimp() == -2 + sqrt(3) - sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(7, 24)).radsimp() == 2 - sqrt(3) - sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(11, 24)).radsimp() == 2 + sqrt(3) + sqrt(2) + sqrt(6)
+    assert tan(pi*Rational(13, 24)).radsimp() == -2 - sqrt(3) - sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(17, 24)).radsimp() == -2 + sqrt(3) + sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(19, 24)).radsimp() == 2 - sqrt(3) + sqrt(2) - sqrt(6)
+    assert tan(pi*Rational(23, 24)).radsimp() == 2 + sqrt(3) - sqrt(2) - sqrt(6)
+
+    assert tan(x*I) == tanh(x)*I
+
+    assert tan(k*pi) == 0
+    assert tan(17*k*pi) == 0
+
+    assert tan(k*pi*I) == tanh(k*pi)*I
+
+    assert tan(r).is_real is None
+    assert tan(r).is_extended_real is True
+
+    assert tan(0, evaluate=False).is_algebraic
+    assert tan(a).is_algebraic is None
+    assert tan(na).is_algebraic is False
+
+    assert tan(pi*Rational(10, 7)) == tan(pi*Rational(3, 7))
+    assert tan(pi*Rational(11, 7)) == -tan(pi*Rational(3, 7))
+    assert tan(pi*Rational(-11, 7)) == tan(pi*Rational(3, 7))
+
+    assert tan(pi*Rational(15, 14)) == tan(pi/14)
+    assert tan(pi*Rational(-15, 14)) == -tan(pi/14)
+
+    assert tan(r).is_finite is None
+    assert tan(I*r).is_finite is True
+
+    # https://github.com/sympy/sympy/issues/21177
+    f = tan(pi*(x + S(3)/2))/(3*x)
+    assert f.as_leading_term(x) == -1/(3*pi*x**2)
+
+
+def test_tan_series():
+    assert tan(x).series(x, 0, 9) == \
+        x + x**3/3 + 2*x**5/15 + 17*x**7/315 + O(x**9)
+
+
+def test_tan_rewrite():
+    neg_exp, pos_exp = exp(-x*I), exp(x*I)
+    assert tan(x).rewrite(exp) == I*(neg_exp - pos_exp)/(neg_exp + pos_exp)
+    assert tan(x).rewrite(sin) == 2*sin(x)**2/sin(2*x)
+    assert tan(x).rewrite(cos) == cos(x - S.Pi/2, evaluate=False)/cos(x)
+    assert tan(x).rewrite(cot) == 1/cot(x)
+    assert tan(sinh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sinh(3)).n()
+    assert tan(cosh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cosh(3)).n()
+    assert tan(tanh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tanh(3)).n()
+    assert tan(coth(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, coth(3)).n()
+    assert tan(sin(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sin(3)).n()
+    assert tan(cos(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cos(3)).n()
+    assert tan(tan(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tan(3)).n()
+    assert tan(cot(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cot(3)).n()
+    assert tan(log(x)).rewrite(Pow) == I*(x**-I - x**I)/(x**-I + x**I)
+    assert tan(x).rewrite(sec) == sec(x)/sec(x - pi/2, evaluate=False)
+    assert tan(x).rewrite(csc) == csc(-x + pi/2, evaluate=False)/csc(x)
+    assert tan(sin(x)).rewrite(Pow) == tan(sin(x))
+    assert tan(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == sqrt(sqrt(5)/8 +
+               Rational(5, 8))/(Rational(-1, 4) + sqrt(5)/4)
+    assert tan(x).rewrite(besselj) == besselj(S.Half, x)/besselj(-S.Half, x)
+    assert tan(x).rewrite(besselj).subs(x, 0) == tan(0)
+
+
+@slow
+def test_tan_rewrite_slow():
+    assert 0 == (cos(pi/34)*tan(pi/34) - sin(pi/34)).rewrite(pow)
+    assert 0 == (cos(pi/17)*tan(pi/17) - sin(pi/17)).rewrite(pow)
+    assert tan(pi/19).rewrite(pow) == tan(pi/19)
+    assert tan(pi*Rational(8, 19)).rewrite(sqrt) == tan(pi*Rational(8, 19))
+    assert tan(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == sqrt(sqrt(5)/8 +
+               Rational(5, 8))/(Rational(-1, 4) + sqrt(5)/4)
+
+
+def test_tan_subs():
+    assert tan(x).subs(tan(x), y) == y
+    assert tan(x).subs(x, y) == tan(y)
+    assert tan(x).subs(x, S.Pi/2) is zoo
+    assert tan(x).subs(x, S.Pi*Rational(3, 2)) is zoo
+
+
+def test_tan_expansion():
+    assert tan(x + y).expand(trig=True) == ((tan(x) + tan(y))/(1 - tan(x)*tan(y))).expand()
+    assert tan(x - y).expand(trig=True) == ((tan(x) - tan(y))/(1 + tan(x)*tan(y))).expand()
+    assert tan(x + y + z).expand(trig=True) == (
+        (tan(x) + tan(y) + tan(z) - tan(x)*tan(y)*tan(z))/
+        (1 - tan(x)*tan(y) - tan(x)*tan(z) - tan(y)*tan(z))).expand()
+    assert 0 == tan(2*x).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 7))])*24 - 7
+    assert 0 == tan(3*x).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 5))])*55 - 37
+    assert 0 == tan(4*x - pi/4).expand(trig=True).rewrite(tan).subs([(tan(x), Rational(1, 5))])*239 - 1
+    _test_extrig(tan, 2, 2*tan(1)/(1 - tan(1)**2))
+    _test_extrig(tan, 3, (-tan(1)**3 + 3*tan(1))/(1 - 3*tan(1)**2))
+
+
+def test_tan_AccumBounds():
+    assert tan(AccumBounds(-oo, oo)) == AccumBounds(-oo, oo)
+    assert tan(AccumBounds(S.Pi/3, S.Pi*Rational(2, 3))) == AccumBounds(-oo, oo)
+    assert tan(AccumBounds(S.Pi/6, S.Pi/3)) == AccumBounds(tan(S.Pi/6), tan(S.Pi/3))
+
+
+def test_tan_fdiff():
+    assert tan(x).fdiff() == tan(x)**2 + 1
+    raises(ArgumentIndexError, lambda: tan(x).fdiff(2))
+
+
+def test_cot():
+    assert cot(nan) is nan
+
+    assert cot.nargs == FiniteSet(1)
+    assert cot(oo*I) == -I
+    assert cot(-oo*I) == I
+    assert cot(zoo) is nan
+
+    assert cot(0) is zoo
+    assert cot(2*pi) is zoo
+
+    assert cot(acot(x)) == x
+    assert cot(atan(x)) == 1 / x
+    assert cot(asin(x)) == sqrt(1 - x**2) / x
+    assert cot(acos(x)) == x / sqrt(1 - x**2)
+    assert cot(acsc(x)) == sqrt(1 - 1 / x**2) * x
+    assert cot(asec(x)) == 1 / (sqrt(1 - 1 / x**2) * x)
+    assert cot(atan2(y, x)) == x/y
+
+    assert cot(pi*I) == -coth(pi)*I
+    assert cot(-pi*I) == coth(pi)*I
+    assert cot(-2*I) == coth(2)*I
+
+    assert cot(pi) == cot(2*pi) == cot(3*pi)
+    assert cot(-pi) == cot(-2*pi) == cot(-3*pi)
+
+    assert cot(pi/2) == 0
+    assert cot(-pi/2) == 0
+    assert cot(pi*Rational(5, 2)) == 0
+    assert cot(pi*Rational(7, 2)) == 0
+
+    assert cot(pi/3) == 1/sqrt(3)
+    assert cot(pi*Rational(-2, 3)) == 1/sqrt(3)
+
+    assert cot(pi/4) is S.One
+    assert cot(-pi/4) is S.NegativeOne
+    assert cot(pi*Rational(17, 4)) is S.One
+    assert cot(pi*Rational(-3, 4)) is S.One
+
+    assert cot(pi/6) == sqrt(3)
+    assert cot(-pi/6) == -sqrt(3)
+    assert cot(pi*Rational(7, 6)) == sqrt(3)
+    assert cot(pi*Rational(-5, 6)) == sqrt(3)
+
+    assert cot(pi/8) == 1 + sqrt(2)
+    assert cot(pi*Rational(3, 8)) == -1 + sqrt(2)
+    assert cot(pi*Rational(5, 8)) == 1 - sqrt(2)
+    assert cot(pi*Rational(7, 8)) == -1 - sqrt(2)
+
+    assert cot(pi/12) == sqrt(3) + 2
+    assert cot(pi*Rational(5, 12)) == -sqrt(3) + 2
+    assert cot(pi*Rational(7, 12)) == sqrt(3) - 2
+    assert cot(pi*Rational(11, 12)) == -sqrt(3) - 2
+
+    assert cot(pi/24).radsimp() == sqrt(2) + sqrt(3) + 2 + sqrt(6)
+    assert cot(pi*Rational(5, 24)).radsimp() == -sqrt(2) - sqrt(3) + 2 + sqrt(6)
+    assert cot(pi*Rational(7, 24)).radsimp() == -sqrt(2) + sqrt(3) - 2 + sqrt(6)
+    assert cot(pi*Rational(11, 24)).radsimp() == sqrt(2) - sqrt(3) - 2 + sqrt(6)
+    assert cot(pi*Rational(13, 24)).radsimp() == -sqrt(2) + sqrt(3) + 2 - sqrt(6)
+    assert cot(pi*Rational(17, 24)).radsimp() == sqrt(2) - sqrt(3) + 2 - sqrt(6)
+    assert cot(pi*Rational(19, 24)).radsimp() == sqrt(2) + sqrt(3) - 2 - sqrt(6)
+    assert cot(pi*Rational(23, 24)).radsimp() == -sqrt(2) - sqrt(3) - 2 - sqrt(6)
+
+    assert cot(x*I) == -coth(x)*I
+    assert cot(k*pi*I) == -coth(k*pi)*I
+
+    assert cot(r).is_real is None
+    assert cot(r).is_extended_real is True
+
+    assert cot(a).is_algebraic is None
+    assert cot(na).is_algebraic is False
+
+    assert cot(pi*Rational(10, 7)) == cot(pi*Rational(3, 7))
+    assert cot(pi*Rational(11, 7)) == -cot(pi*Rational(3, 7))
+    assert cot(pi*Rational(-11, 7)) == cot(pi*Rational(3, 7))
+
+    assert cot(pi*Rational(39, 34)) == cot(pi*Rational(5, 34))
+    assert cot(pi*Rational(-41, 34)) == -cot(pi*Rational(7, 34))
+
+    assert cot(x).is_finite is None
+    assert cot(r).is_finite is None
+    i = Symbol('i', imaginary=True)
+    assert cot(i).is_finite is True
+
+    assert cot(x).subs(x, 3*pi) is zoo
+
+    # https://github.com/sympy/sympy/issues/21177
+    f = cot(pi*(x + 4))/(3*x)
+    assert f.as_leading_term(x) == 1/(3*pi*x**2)
+
+
+def test_tan_cot_sin_cos_evalf():
+    assert abs((tan(pi*Rational(8, 15))*cos(pi*Rational(8, 15))/sin(pi*Rational(8, 15)) - 1).evalf()) < 1e-14
+    assert abs((cot(pi*Rational(4, 15))*sin(pi*Rational(4, 15))/cos(pi*Rational(4, 15)) - 1).evalf()) < 1e-14
+
+@XFAIL
+def test_tan_cot_sin_cos_ratsimp():
+    assert 1 == (tan(pi*Rational(8, 15))*cos(pi*Rational(8, 15))/sin(pi*Rational(8, 15))).ratsimp()
+    assert 1 == (cot(pi*Rational(4, 15))*sin(pi*Rational(4, 15))/cos(pi*Rational(4, 15))).ratsimp()
+
+
+def test_cot_series():
+    assert cot(x).series(x, 0, 9) == \
+        1/x - x/3 - x**3/45 - 2*x**5/945 - x**7/4725 + O(x**9)
+    # issue 6210
+    assert cot(x**4 + x**5).series(x, 0, 1) == \
+        x**(-4) - 1/x**3 + x**(-2) - 1/x + 1 + O(x)
+    assert cot(pi*(1-x)).series(x, 0, 3) == -1/(pi*x) + pi*x/3 + O(x**3)
+    assert cot(x).taylor_term(0, x) == 1/x
+    assert cot(x).taylor_term(2, x) is S.Zero
+    assert cot(x).taylor_term(3, x) == -x**3/45
+
+
+def test_cot_rewrite():
+    neg_exp, pos_exp = exp(-x*I), exp(x*I)
+    assert cot(x).rewrite(exp) == I*(pos_exp + neg_exp)/(pos_exp - neg_exp)
+    assert cot(x).rewrite(sin) == sin(2*x)/(2*(sin(x)**2))
+    assert cot(x).rewrite(cos) == cos(x)/cos(x - pi/2, evaluate=False)
+    assert cot(x).rewrite(tan) == 1/tan(x)
+    def check(func):
+        z = cot(func(x)).rewrite(exp) - cot(x).rewrite(exp).subs(x, func(x))
+        assert z.rewrite(exp).expand() == 0
+    check(sinh)
+    check(cosh)
+    check(tanh)
+    check(coth)
+    check(sin)
+    check(cos)
+    check(tan)
+    assert cot(log(x)).rewrite(Pow) == -I*(x**-I + x**I)/(x**-I - x**I)
+    assert cot(x).rewrite(sec) == sec(x - pi / 2, evaluate=False) / sec(x)
+    assert cot(x).rewrite(csc) == csc(x) / csc(- x + pi / 2, evaluate=False)
+    assert cot(sin(x)).rewrite(Pow) == cot(sin(x))
+    assert cot(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == (Rational(-1, 4) + sqrt(5)/4)/\
+                                                        sqrt(sqrt(5)/8 + Rational(5, 8))
+    assert cot(x).rewrite(besselj) == besselj(-S.Half, x)/besselj(S.Half, x)
+    assert cot(x).rewrite(besselj).subs(x, 0) == cot(0)
+
+
+@slow
+def test_cot_rewrite_slow():
+    assert cot(pi*Rational(4, 34)).rewrite(pow).ratsimp() == \
+        (cos(pi*Rational(4, 34))/sin(pi*Rational(4, 34))).rewrite(pow).ratsimp()
+    assert cot(pi*Rational(4, 17)).rewrite(pow) == \
+        (cos(pi*Rational(4, 17))/sin(pi*Rational(4, 17))).rewrite(pow)
+    assert cot(pi/19).rewrite(pow) == cot(pi/19)
+    assert cot(pi/19).rewrite(sqrt) == cot(pi/19)
+    assert cot(pi*Rational(2, 5), evaluate=False).rewrite(sqrt) == \
+        (Rational(-1, 4) + sqrt(5)/4) / sqrt(sqrt(5)/8 + Rational(5, 8))
+
+
+def test_cot_subs():
+    assert cot(x).subs(cot(x), y) == y
+    assert cot(x).subs(x, y) == cot(y)
+    assert cot(x).subs(x, 0) is zoo
+    assert cot(x).subs(x, S.Pi) is zoo
+
+
+def test_cot_expansion():
+    assert cot(x + y).expand(trig=True).together() == (
+        (cot(x)*cot(y) - 1)/(cot(x) + cot(y)))
+    assert cot(x - y).expand(trig=True).together() == (
+        cot(x)*cot(-y) - 1)/(cot(x) + cot(-y))
+    assert cot(x + y + z).expand(trig=True).together() == (
+        (cot(x)*cot(y)*cot(z) - cot(x) - cot(y) - cot(z))/
+        (-1 + cot(x)*cot(y) + cot(x)*cot(z) + cot(y)*cot(z)))
+    assert cot(3*x).expand(trig=True).together() == (
+        (cot(x)**2 - 3)*cot(x)/(3*cot(x)**2 - 1))
+    assert cot(2*x).expand(trig=True) == cot(x)/2 - 1/(2*cot(x))
+    assert cot(3*x).expand(trig=True).together() == (
+        cot(x)**2 - 3)*cot(x)/(3*cot(x)**2 - 1)
+    assert cot(4*x - pi/4).expand(trig=True).cancel() == (
+        -tan(x)**4 + 4*tan(x)**3 + 6*tan(x)**2 - 4*tan(x) - 1
+        )/(tan(x)**4 + 4*tan(x)**3 - 6*tan(x)**2 - 4*tan(x) + 1)
+    _test_extrig(cot, 2, (-1 + cot(1)**2)/(2*cot(1)))
+    _test_extrig(cot, 3, (-3*cot(1) + cot(1)**3)/(-1 + 3*cot(1)**2))
+
+
+def test_cot_AccumBounds():
+    assert cot(AccumBounds(-oo, oo)) == AccumBounds(-oo, oo)
+    assert cot(AccumBounds(-S.Pi/3, S.Pi/3)) == AccumBounds(-oo, oo)
+    assert cot(AccumBounds(S.Pi/6, S.Pi/3)) == AccumBounds(cot(S.Pi/3), cot(S.Pi/6))
+
+
+def test_cot_fdiff():
+    assert cot(x).fdiff() == -cot(x)**2 - 1
+    raises(ArgumentIndexError, lambda: cot(x).fdiff(2))
+
+
+def test_sinc():
+    assert isinstance(sinc(x), sinc)
+
+    s = Symbol('s', zero=True)
+    assert sinc(s) is S.One
+    assert sinc(S.Infinity) is S.Zero
+    assert sinc(S.NegativeInfinity) is S.Zero
+    assert sinc(S.NaN) is S.NaN
+    assert sinc(S.ComplexInfinity) is S.NaN
+
+    n = Symbol('n', integer=True, nonzero=True)
+    assert sinc(n*pi) is S.Zero
+    assert sinc(-n*pi) is S.Zero
+    assert sinc(pi/2) == 2 / pi
+    assert sinc(-pi/2) == 2 / pi
+    assert sinc(pi*Rational(5, 2)) == 2 / (5*pi)
+    assert sinc(pi*Rational(7, 2)) == -2 / (7*pi)
+
+    assert sinc(-x) == sinc(x)
+
+    assert sinc(x).diff(x) == cos(x)/x - sin(x)/x**2
+    assert sinc(x).diff(x) == (sin(x)/x).diff(x)
+    assert sinc(x).diff(x, x) == (-sin(x) - 2*cos(x)/x + 2*sin(x)/x**2)/x
+    assert sinc(x).diff(x, x) == (sin(x)/x).diff(x, x)
+    assert limit(sinc(x).diff(x), x, 0) == 0
+    assert limit(sinc(x).diff(x, x), x, 0) == -S(1)/3
+
+    # https://github.com/sympy/sympy/issues/11402
+    #
+    # assert sinc(x).diff(x) == Piecewise(((x*cos(x) - sin(x)) / x**2, Ne(x, 0)), (0, True))
+    #
+    # assert sinc(x).diff(x).equals(sinc(x).rewrite(sin).diff(x))
+    #
+    # assert sinc(x).diff(x).subs(x, 0) is S.Zero
+
+    assert sinc(x).series() == 1 - x**2/6 + x**4/120 + O(x**6)
+
+    assert sinc(x).rewrite(jn) == jn(0, x)
+    assert sinc(x).rewrite(sin) == Piecewise((sin(x)/x, Ne(x, 0)), (1, True))
+    assert sinc(pi, evaluate=False).is_zero is True
+    assert sinc(0, evaluate=False).is_zero is False
+    assert sinc(n*pi, evaluate=False).is_zero is True
+    assert sinc(x).is_zero is None
+    xr = Symbol('xr', real=True, nonzero=True)
+    assert sinc(x).is_real is None
+    assert sinc(xr).is_real is True
+    assert sinc(I*xr).is_real is True
+    assert sinc(I*100).is_real is True
+    assert sinc(x).is_finite is None
+    assert sinc(xr).is_finite is True
+
+
+def test_asin():
+    assert asin(nan) is nan
+
+    assert asin.nargs == FiniteSet(1)
+    assert asin(oo) == -I*oo
+    assert asin(-oo) == I*oo
+    assert asin(zoo) is zoo
+
+    # Note: asin(-x) = - asin(x)
+    assert asin(0) == 0
+    assert asin(1) == pi/2
+    assert asin(-1) == -pi/2
+    assert asin(sqrt(3)/2) == pi/3
+    assert asin(-sqrt(3)/2) == -pi/3
+    assert asin(sqrt(2)/2) == pi/4
+    assert asin(-sqrt(2)/2) == -pi/4
+    assert asin(sqrt((5 - sqrt(5))/8)) == pi/5
+    assert asin(-sqrt((5 - sqrt(5))/8)) == -pi/5
+    assert asin(S.Half) == pi/6
+    assert asin(Rational(-1, 2)) == -pi/6
+    assert asin((sqrt(2 - sqrt(2)))/2) == pi/8
+    assert asin(-(sqrt(2 - sqrt(2)))/2) == -pi/8
+    assert asin((sqrt(5) - 1)/4) == pi/10
+    assert asin(-(sqrt(5) - 1)/4) == -pi/10
+    assert asin((sqrt(3) - 1)/sqrt(2**3)) == pi/12
+    assert asin(-(sqrt(3) - 1)/sqrt(2**3)) == -pi/12
+
+    # check round-trip for exact values:
+    for d in [5, 6, 8, 10, 12]:
+        for n in range(-(d//2), d//2 + 1):
+            if gcd(n, d) == 1:
+                assert asin(sin(n*pi/d)) == n*pi/d
+
+    assert asin(x).diff(x) == 1/sqrt(1 - x**2)
+
+    assert asin(0.2, evaluate=False).is_real is True
+    assert asin(-2).is_real is False
+    assert asin(r).is_real is None
+
+    assert asin(-2*I) == -I*asinh(2)
+
+    assert asin(Rational(1, 7), evaluate=False).is_positive is True
+    assert asin(Rational(-1, 7), evaluate=False).is_positive is False
+    assert asin(p).is_positive is None
+    assert asin(sin(Rational(7, 2))) == Rational(-7, 2) + pi
+    assert asin(sin(Rational(-7, 4))) == Rational(7, 4) - pi
+    assert unchanged(asin, cos(x))
+
+
+def test_asin_series():
+    assert asin(x).series(x, 0, 9) == \
+        x + x**3/6 + 3*x**5/40 + 5*x**7/112 + O(x**9)
+    t5 = asin(x).taylor_term(5, x)
+    assert t5 == 3*x**5/40
+    assert asin(x).taylor_term(7, x, t5, 0) == 5*x**7/112
+
+
+def test_asin_leading_term():
+    assert asin(x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert asin(x + 1).as_leading_term(x) == pi/2
+    assert asin(x - 1).as_leading_term(x) == -pi/2
+    assert asin(1/x).as_leading_term(x, cdir=1) == I*log(x) + pi/2 - I*log(2)
+    assert asin(1/x).as_leading_term(x, cdir=-1) == -I*log(x) - 3*pi/2 + I*log(2)
+    # Tests concerning points lying on branch cuts
+    assert asin(I*x + 2).as_leading_term(x, cdir=1) == pi - asin(2)
+    assert asin(-I*x + 2).as_leading_term(x, cdir=1) == asin(2)
+    assert asin(I*x - 2).as_leading_term(x, cdir=1) == -asin(2)
+    assert asin(-I*x - 2).as_leading_term(x, cdir=1) == -pi + asin(2)
+    # Tests concerning im(ndir) == 0
+    assert asin(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == -pi/2 + I*log(2 - sqrt(3))
+    assert asin(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(2 - sqrt(3))
+
+
+def test_asin_rewrite():
+    assert asin(x).rewrite(log) == -I*log(I*x + sqrt(1 - x**2))
+    assert asin(x).rewrite(atan) == 2*atan(x/(1 + sqrt(1 - x**2)))
+    assert asin(x).rewrite(acos) == S.Pi/2 - acos(x)
+    assert asin(x).rewrite(acot) == 2*acot((sqrt(-x**2 + 1) + 1)/x)
+    assert asin(x).rewrite(asec) == -asec(1/x) + pi/2
+    assert asin(x).rewrite(acsc) == acsc(1/x)
+
+
+def test_asin_fdiff():
+    assert asin(x).fdiff() == 1/sqrt(1 - x**2)
+    raises(ArgumentIndexError, lambda: asin(x).fdiff(2))
+
+
+def test_acos():
+    assert acos(nan) is nan
+    assert acos(zoo) is zoo
+
+    assert acos.nargs == FiniteSet(1)
+    assert acos(oo) == I*oo
+    assert acos(-oo) == -I*oo
+
+    # Note: acos(-x) = pi - acos(x)
+    assert acos(0) == pi/2
+    assert acos(S.Half) == pi/3
+    assert acos(Rational(-1, 2)) == pi*Rational(2, 3)
+    assert acos(1) == 0
+    assert acos(-1) == pi
+    assert acos(sqrt(2)/2) == pi/4
+    assert acos(-sqrt(2)/2) == pi*Rational(3, 4)
+
+    # check round-trip for exact values:
+    for d in range(5, 13):
+        for num in range(d):
+            if gcd(num, d) == 1:
+                assert acos(cos(num*pi/d)) == num*pi/d
+                assert acos(-cos(num*pi/d)) == pi - num*pi/d
+                assert acos(sin(num*pi/d)) == pi/2 - asin(sin(num*pi/d))
+                assert acos(-sin(num*pi/d)) == pi/2 - asin(-sin(num*pi/d))
+
+    assert acos(2*I) == pi/2 - asin(2*I)
+
+    assert acos(x).diff(x) == -1/sqrt(1 - x**2)
+
+    assert acos(0.2).is_real is True
+    assert acos(-2).is_real is False
+    assert acos(r).is_real is None
+
+    assert acos(Rational(1, 7), evaluate=False).is_positive is True
+    assert acos(Rational(-1, 7), evaluate=False).is_positive is True
+    assert acos(Rational(3, 2), evaluate=False).is_positive is False
+    assert acos(p).is_positive is None
+
+    assert acos(2 + p).conjugate() != acos(10 + p)
+    assert acos(-3 + n).conjugate() != acos(-3 + n)
+    assert acos(Rational(1, 3)).conjugate() == acos(Rational(1, 3))
+    assert acos(Rational(-1, 3)).conjugate() == acos(Rational(-1, 3))
+    assert acos(p + n*I).conjugate() == acos(p - n*I)
+    assert acos(z).conjugate() != acos(conjugate(z))
+
+
+def test_acos_leading_term():
+    assert acos(x).as_leading_term(x) == pi/2
+    # Tests concerning branch points
+    assert acos(x + 1).as_leading_term(x) == sqrt(2)*sqrt(-x)
+    assert acos(x - 1).as_leading_term(x) == pi
+    assert acos(1/x).as_leading_term(x, cdir=1) == -I*log(x) + I*log(2)
+    assert acos(1/x).as_leading_term(x, cdir=-1) == I*log(x) + 2*pi - I*log(2)
+    # Tests concerning points lying on branch cuts
+    assert acos(I*x + 2).as_leading_term(x, cdir=1) == -acos(2)
+    assert acos(-I*x + 2).as_leading_term(x, cdir=1) == acos(2)
+    assert acos(I*x - 2).as_leading_term(x, cdir=1) == acos(-2)
+    assert acos(-I*x - 2).as_leading_term(x, cdir=1) == 2*pi - acos(-2)
+    # Tests concerning im(ndir) == 0
+    assert acos(-I*x**2 + x - 2).as_leading_term(x, cdir=1) == pi + I*log(sqrt(3) + 2)
+    assert acos(-I*x**2 + x - 2).as_leading_term(x, cdir=-1) == pi + I*log(sqrt(3) + 2)
+
+
+def test_acos_series():
+    assert acos(x).series(x, 0, 8) == \
+        pi/2 - x - x**3/6 - 3*x**5/40 - 5*x**7/112 + O(x**8)
+    assert acos(x).series(x, 0, 8) == pi/2 - asin(x).series(x, 0, 8)
+    t5 = acos(x).taylor_term(5, x)
+    assert t5 == -3*x**5/40
+    assert acos(x).taylor_term(7, x, t5, 0) == -5*x**7/112
+    assert acos(x).taylor_term(0, x) == pi/2
+    assert acos(x).taylor_term(2, x) is S.Zero
+
+
+def test_acos_rewrite():
+    assert acos(x).rewrite(log) == pi/2 + I*log(I*x + sqrt(1 - x**2))
+    assert acos(x).rewrite(atan) == pi*(-x*sqrt(x**(-2)) + 1)/2 + atan(sqrt(1 - x**2)/x)
+    assert acos(0).rewrite(atan) == S.Pi/2
+    assert acos(0.5).rewrite(atan) == acos(0.5).rewrite(log)
+    assert acos(x).rewrite(asin) == S.Pi/2 - asin(x)
+    assert acos(x).rewrite(acot) == -2*acot((sqrt(-x**2 + 1) + 1)/x) + pi/2
+    assert acos(x).rewrite(asec) == asec(1/x)
+    assert acos(x).rewrite(acsc) == -acsc(1/x) + pi/2
+
+
+def test_acos_fdiff():
+    assert acos(x).fdiff() == -1/sqrt(1 - x**2)
+    raises(ArgumentIndexError, lambda: acos(x).fdiff(2))
+
+
+def test_atan():
+    assert atan(nan) is nan
+
+    assert atan.nargs == FiniteSet(1)
+    assert atan(oo) == pi/2
+    assert atan(-oo) == -pi/2
+    assert atan(zoo) == AccumBounds(-pi/2, pi/2)
+
+    assert atan(0) == 0
+    assert atan(1) == pi/4
+    assert atan(sqrt(3)) == pi/3
+    assert atan(-(1 + sqrt(2))) == pi*Rational(-3, 8)
+    assert atan(sqrt(5 - 2 * sqrt(5))) == pi/5
+    assert atan(-sqrt(1 - 2 * sqrt(5)/ 5)) == -pi/10
+    assert atan(sqrt(1 + 2 * sqrt(5) / 5)) == pi*Rational(3, 10)
+    assert atan(-2 + sqrt(3)) == -pi/12
+    assert atan(2 + sqrt(3)) == pi*Rational(5, 12)
+    assert atan(-2 - sqrt(3)) == pi*Rational(-5, 12)
+
+    # check round-trip for exact values:
+    for d in [5, 6, 8, 10, 12]:
+        for num in range(-(d//2), d//2 + 1):
+            if gcd(num, d) == 1:
+                assert atan(tan(num*pi/d)) == num*pi/d
+
+    assert atan(oo) == pi/2
+    assert atan(x).diff(x) == 1/(1 + x**2)
+
+    assert atan(r).is_real is True
+
+    assert atan(-2*I) == -I*atanh(2)
+    assert unchanged(atan, cot(x))
+    assert atan(cot(Rational(1, 4))) == Rational(-1, 4) + pi/2
+    assert acot(Rational(1, 4)).is_rational is False
+
+    for s in (x, p, n, np, nn, nz, ep, en, enp, enn, enz):
+        if s.is_real or s.is_extended_real is None:
+            assert s.is_nonzero is atan(s).is_nonzero
+            assert s.is_positive is atan(s).is_positive
+            assert s.is_negative is atan(s).is_negative
+            assert s.is_nonpositive is atan(s).is_nonpositive
+            assert s.is_nonnegative is atan(s).is_nonnegative
+        else:
+            assert s.is_extended_nonzero is atan(s).is_nonzero
+            assert s.is_extended_positive is atan(s).is_positive
+            assert s.is_extended_negative is atan(s).is_negative
+            assert s.is_extended_nonpositive is atan(s).is_nonpositive
+            assert s.is_extended_nonnegative is atan(s).is_nonnegative
+        assert s.is_extended_nonzero is atan(s).is_extended_nonzero
+        assert s.is_extended_positive is atan(s).is_extended_positive
+        assert s.is_extended_negative is atan(s).is_extended_negative
+        assert s.is_extended_nonpositive is atan(s).is_extended_nonpositive
+        assert s.is_extended_nonnegative is atan(s).is_extended_nonnegative
+
+
+def test_atan_rewrite():
+    assert atan(x).rewrite(log) == I*(log(1 - I*x)-log(1 + I*x))/2
+    assert atan(x).rewrite(asin) == (-asin(1/sqrt(x**2 + 1)) + pi/2)*sqrt(x**2)/x
+    assert atan(x).rewrite(acos) == sqrt(x**2)*acos(1/sqrt(x**2 + 1))/x
+    assert atan(x).rewrite(acot) == acot(1/x)
+    assert atan(x).rewrite(asec) == sqrt(x**2)*asec(sqrt(x**2 + 1))/x
+    assert atan(x).rewrite(acsc) == (-acsc(sqrt(x**2 + 1)) + pi/2)*sqrt(x**2)/x
+
+    assert atan(-5*I).evalf() == atan(x).rewrite(log).evalf(subs={x:-5*I})
+    assert atan(5*I).evalf() == atan(x).rewrite(log).evalf(subs={x:5*I})
+
+
+def test_atan_fdiff():
+    assert atan(x).fdiff() == 1/(x**2 + 1)
+    raises(ArgumentIndexError, lambda: atan(x).fdiff(2))
+
+
+def test_atan_leading_term():
+    assert atan(x).as_leading_term(x) == x
+    assert atan(1/x).as_leading_term(x, cdir=1) == pi/2
+    assert atan(1/x).as_leading_term(x, cdir=-1) == -pi/2
+    # Tests concerning branch points
+    assert atan(x + I).as_leading_term(x, cdir=1) == -I*log(x)/2 + pi/4 + I*log(2)/2
+    assert atan(x + I).as_leading_term(x, cdir=-1) == -I*log(x)/2 - 3*pi/4 + I*log(2)/2
+    assert atan(x - I).as_leading_term(x, cdir=1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert atan(x - I).as_leading_term(x, cdir=-1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    # Tests concerning points lying on branch cuts
+    assert atan(x + 2*I).as_leading_term(x, cdir=1) == I*atanh(2)
+    assert atan(x + 2*I).as_leading_term(x, cdir=-1) == -pi + I*atanh(2)
+    assert atan(x - 2*I).as_leading_term(x, cdir=1) == pi - I*atanh(2)
+    assert atan(x - 2*I).as_leading_term(x, cdir=-1) == -I*atanh(2)
+    # Tests concerning re(ndir) == 0
+    assert atan(2*I - I*x - x**2).as_leading_term(x, cdir=1) == -pi/2 + I*log(3)/2
+    assert atan(2*I - I*x - x**2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(3)/2
+
+
+def test_atan2():
+    assert atan2.nargs == FiniteSet(2)
+    assert atan2(0, 0) is S.NaN
+    assert atan2(0, 1) == 0
+    assert atan2(1, 1) == pi/4
+    assert atan2(1, 0) == pi/2
+    assert atan2(1, -1) == pi*Rational(3, 4)
+    assert atan2(0, -1) == pi
+    assert atan2(-1, -1) == pi*Rational(-3, 4)
+    assert atan2(-1, 0) == -pi/2
+    assert atan2(-1, 1) == -pi/4
+    i = symbols('i', imaginary=True)
+    r = symbols('r', real=True)
+    eq = atan2(r, i)
+    ans = -I*log((i + I*r)/sqrt(i**2 + r**2))
+    reps = ((r, 2), (i, I))
+    assert eq.subs(reps) == ans.subs(reps)
+
+    x = Symbol('x', negative=True)
+    y = Symbol('y', negative=True)
+    assert atan2(y, x) == atan(y/x) - pi
+    y = Symbol('y', nonnegative=True)
+    assert atan2(y, x) == atan(y/x) + pi
+    y = Symbol('y')
+    assert atan2(y, x) == atan2(y, x, evaluate=False)
+
+    u = Symbol("u", positive=True)
+    assert atan2(0, u) == 0
+    u = Symbol("u", negative=True)
+    assert atan2(0, u) == pi
+
+    assert atan2(y, oo) ==  0
+    assert atan2(y, -oo)==  2*pi*Heaviside(re(y), S.Half) - pi
+
+    assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2))
+    assert atan2(0, 0) is S.NaN
+
+    ex = atan2(y, x) - arg(x + I*y)
+    assert ex.subs({x:2, y:3}).rewrite(arg) == 0
+    assert ex.subs({x:2, y:3*I}).rewrite(arg) == -pi - I*log(sqrt(5)*I/5)
+    assert ex.subs({x:2*I, y:3}).rewrite(arg) == -pi/2 - I*log(sqrt(5)*I)
+    assert ex.subs({x:2*I, y:3*I}).rewrite(arg) == -pi + atan(Rational(2, 3)) + atan(Rational(3, 2))
+    i = symbols('i', imaginary=True)
+    r = symbols('r', real=True)
+    e = atan2(i, r)
+    rewrite = e.rewrite(arg)
+    reps = {i: I, r: -2}
+    assert rewrite == -I*log(abs(I*i + r)/sqrt(abs(i**2 + r**2))) + arg((I*i + r)/sqrt(i**2 + r**2))
+    assert (e - rewrite).subs(reps).equals(0)
+
+    assert atan2(0, x).rewrite(atan) == Piecewise((pi, re(x) < 0),
+                                            (0, Ne(x, 0)),
+                                            (nan, True))
+    assert atan2(0, r).rewrite(atan) == Piecewise((pi, r < 0), (0, Ne(r, 0)), (S.NaN, True))
+    assert atan2(0, i),rewrite(atan) == 0
+    assert atan2(0, r + i).rewrite(atan) == Piecewise((pi, r < 0), (0, True))
+
+    assert atan2(y, x).rewrite(atan) == Piecewise(
+            (2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)),
+            (pi, re(x) < 0),
+            (0, (re(x) > 0) | Ne(im(x), 0)),
+            (nan, True))
+    assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y))
+
+    assert diff(atan2(y, x), x) == -y/(x**2 + y**2)
+    assert diff(atan2(y, x), y) == x/(x**2 + y**2)
+
+    assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2)
+    assert simplify(diff(atan2(y, x).rewrite(log), y)) ==  x/(x**2 + y**2)
+
+    assert str(atan2(1, 2).evalf(5)) == '0.46365'
+    raises(ArgumentIndexError, lambda: atan2(x, y).fdiff(3))
+
+def test_issue_17461():
+    class A(Symbol):
+        is_extended_real = True
+
+        def _eval_evalf(self, prec):
+            return Float(5.0)
+
+    x = A('X')
+    y = A('Y')
+    assert abs(atan2(x, y).evalf() - 0.785398163397448) <= 1e-10
+
+def test_acot():
+    assert acot(nan) is nan
+
+    assert acot.nargs == FiniteSet(1)
+    assert acot(-oo) == 0
+    assert acot(oo) == 0
+    assert acot(zoo) == 0
+    assert acot(1) == pi/4
+    assert acot(0) == pi/2
+    assert acot(sqrt(3)/3) == pi/3
+    assert acot(1/sqrt(3)) == pi/3
+    assert acot(-1/sqrt(3)) == -pi/3
+    assert acot(x).diff(x) == -1/(1 + x**2)
+
+    assert acot(r).is_extended_real is True
+
+    assert acot(I*pi) == -I*acoth(pi)
+    assert acot(-2*I) == I*acoth(2)
+    assert acot(x).is_positive is None
+    assert acot(n).is_positive is False
+    assert acot(p).is_positive is True
+    assert acot(I).is_positive is False
+    assert acot(Rational(1, 4)).is_rational is False
+    assert unchanged(acot, cot(x))
+    assert unchanged(acot, tan(x))
+    assert acot(cot(Rational(1, 4))) == Rational(1, 4)
+    assert acot(tan(Rational(-1, 4))) == Rational(1, 4) - pi/2
+
+
+def test_acot_rewrite():
+    assert acot(x).rewrite(log) == I*(log(1 - I/x)-log(1 + I/x))/2
+    assert acot(x).rewrite(asin) == x*(-asin(sqrt(-x**2)/sqrt(-x**2 - 1)) + pi/2)*sqrt(x**(-2))
+    assert acot(x).rewrite(acos) == x*sqrt(x**(-2))*acos(sqrt(-x**2)/sqrt(-x**2 - 1))
+    assert acot(x).rewrite(atan) == atan(1/x)
+    assert acot(x).rewrite(asec) == x*sqrt(x**(-2))*asec(sqrt((x**2 + 1)/x**2))
+    assert acot(x).rewrite(acsc) == x*(-acsc(sqrt((x**2 + 1)/x**2)) + pi/2)*sqrt(x**(-2))
+
+    assert acot(-I/5).evalf() == acot(x).rewrite(log).evalf(subs={x:-I/5})
+    assert acot(I/5).evalf() == acot(x).rewrite(log).evalf(subs={x:I/5})
+
+
+def test_acot_fdiff():
+    assert acot(x).fdiff() == -1/(x**2 + 1)
+    raises(ArgumentIndexError, lambda: acot(x).fdiff(2))
+
+def test_acot_leading_term():
+    assert acot(1/x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert acot(x + I).as_leading_term(x, cdir=1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert acot(x + I).as_leading_term(x, cdir=-1) == I*log(x)/2 + pi/4 - I*log(2)/2
+    assert acot(x - I).as_leading_term(x, cdir=1) == -I*log(x)/2 + pi/4 + I*log(2)/2
+    assert acot(x - I).as_leading_term(x, cdir=-1) == -I*log(x)/2 - 3*pi/4 + I*log(2)/2
+    # Tests concerning points lying on branch cuts
+    assert acot(x).as_leading_term(x, cdir=1) == pi/2
+    assert acot(x).as_leading_term(x, cdir=-1) == -pi/2
+    assert acot(x + I/2).as_leading_term(x, cdir=1) == pi - I*acoth(S(1)/2)
+    assert acot(x + I/2).as_leading_term(x, cdir=-1) == -I*acoth(S(1)/2)
+    assert acot(x - I/2).as_leading_term(x, cdir=1) == I*acoth(S(1)/2)
+    assert acot(x - I/2).as_leading_term(x, cdir=-1) == -pi + I*acoth(S(1)/2)
+    # Tests concerning re(ndir) == 0
+    assert acot(I/2 - I*x - x**2).as_leading_term(x, cdir=1) == -pi/2 - I*log(3)/2
+    assert acot(I/2 - I*x - x**2).as_leading_term(x, cdir=-1) == -pi/2 - I*log(3)/2
+
+
+def test_attributes():
+    assert sin(x).args == (x,)
+
+
+def test_sincos_rewrite():
+    assert sin(pi/2 - x) == cos(x)
+    assert sin(pi - x) == sin(x)
+    assert cos(pi/2 - x) == sin(x)
+    assert cos(pi - x) == -cos(x)
+
+
+def _check_even_rewrite(func, arg):
+    """Checks that the expr has been rewritten using f(-x) -> f(x)
+    arg : -x
+    """
+    return func(arg).args[0] == -arg
+
+
+def _check_odd_rewrite(func, arg):
+    """Checks that the expr has been rewritten using f(-x) -> -f(x)
+    arg : -x
+    """
+    return func(arg).func.is_Mul
+
+
+def _check_no_rewrite(func, arg):
+    """Checks that the expr is not rewritten"""
+    return func(arg).args[0] == arg
+
+
+def test_evenodd_rewrite():
+    a = cos(2)  # negative
+    b = sin(1)  # positive
+    even = [cos]
+    odd = [sin, tan, cot, asin, atan, acot]
+    with_minus = [-1, -2**1024 * E, -pi/105, -x*y, -x - y]
+    for func in even:
+        for expr in with_minus:
+            assert _check_even_rewrite(func, expr)
+        assert _check_no_rewrite(func, a*b)
+        assert func(
+            x - y) == func(y - x)  # it doesn't matter which form is canonical
+    for func in odd:
+        for expr in with_minus:
+            assert _check_odd_rewrite(func, expr)
+        assert _check_no_rewrite(func, a*b)
+        assert func(
+            x - y) == -func(y - x)  # it doesn't matter which form is canonical
+
+
+def test_as_leading_term_issue_5272():
+    assert sin(x).as_leading_term(x) == x
+    assert cos(x).as_leading_term(x) == 1
+    assert tan(x).as_leading_term(x) == x
+    assert cot(x).as_leading_term(x) == 1/x
+
+
+def test_leading_terms():
+    assert sin(1/x).as_leading_term(x) == AccumBounds(-1, 1)
+    assert sin(S.Half).as_leading_term(x) == sin(S.Half)
+    assert cos(1/x).as_leading_term(x) == AccumBounds(-1, 1)
+    assert cos(S.Half).as_leading_term(x) == cos(S.Half)
+    assert sec(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert csc(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert tan(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+    assert cot(1/x).as_leading_term(x) == AccumBounds(S.NegativeInfinity, S.Infinity)
+
+    # https://github.com/sympy/sympy/issues/21038
+    f = sin(pi*(x + 4))/(3*x)
+    assert f.as_leading_term(x) == pi/3
+
+
+def test_atan2_expansion():
+    assert cancel(atan2(x**2, x + 1).diff(x) - atan(x**2/(x + 1)).diff(x)) == 0
+    assert cancel(atan(y/x).series(y, 0, 5) - atan2(y, x).series(y, 0, 5)
+                  + atan2(0, x) - atan(0)) == O(y**5)
+    assert cancel(atan(y/x).series(x, 1, 4) - atan2(y, x).series(x, 1, 4)
+                  + atan2(y, 1) - atan(y)) == O((x - 1)**4, (x, 1))
+    assert cancel(atan((y + x)/x).series(x, 1, 3) - atan2(y + x, x).series(x, 1, 3)
+                  + atan2(1 + y, 1) - atan(1 + y)) == O((x - 1)**3, (x, 1))
+    assert Matrix([atan2(y, x)]).jacobian([y, x]) == \
+        Matrix([[x/(y**2 + x**2), -y/(y**2 + x**2)]])
+
+
+def test_aseries():
+    def t(n, v, d, e):
+        assert abs(
+            n(1/v).evalf() - n(1/x).series(x, dir=d).removeO().subs(x, v)) < e
+    t(atan, 0.1, '+', 1e-5)
+    t(atan, -0.1, '-', 1e-5)
+    t(acot, 0.1, '+', 1e-5)
+    t(acot, -0.1, '-', 1e-5)
+
+
+def test_issue_4420():
+    i = Symbol('i', integer=True)
+    e = Symbol('e', even=True)
+    o = Symbol('o', odd=True)
+
+    # unknown parity for variable
+    assert cos(4*i*pi) == 1
+    assert sin(4*i*pi) == 0
+    assert tan(4*i*pi) == 0
+    assert cot(4*i*pi) is zoo
+
+    assert cos(3*i*pi) == cos(pi*i)  # +/-1
+    assert sin(3*i*pi) == 0
+    assert tan(3*i*pi) == 0
+    assert cot(3*i*pi) is zoo
+
+    assert cos(4.0*i*pi) == 1
+    assert sin(4.0*i*pi) == 0
+    assert tan(4.0*i*pi) == 0
+    assert cot(4.0*i*pi) is zoo
+
+    assert cos(3.0*i*pi) == cos(pi*i)  # +/-1
+    assert sin(3.0*i*pi) == 0
+    assert tan(3.0*i*pi) == 0
+    assert cot(3.0*i*pi) is zoo
+
+    assert cos(4.5*i*pi) == cos(0.5*pi*i)
+    assert sin(4.5*i*pi) == sin(0.5*pi*i)
+    assert tan(4.5*i*pi) == tan(0.5*pi*i)
+    assert cot(4.5*i*pi) == cot(0.5*pi*i)
+
+    # parity of variable is known
+    assert cos(4*e*pi) == 1
+    assert sin(4*e*pi) == 0
+    assert tan(4*e*pi) == 0
+    assert cot(4*e*pi) is zoo
+
+    assert cos(3*e*pi) == 1
+    assert sin(3*e*pi) == 0
+    assert tan(3*e*pi) == 0
+    assert cot(3*e*pi) is zoo
+
+    assert cos(4.0*e*pi) == 1
+    assert sin(4.0*e*pi) == 0
+    assert tan(4.0*e*pi) == 0
+    assert cot(4.0*e*pi) is zoo
+
+    assert cos(3.0*e*pi) == 1
+    assert sin(3.0*e*pi) == 0
+    assert tan(3.0*e*pi) == 0
+    assert cot(3.0*e*pi) is zoo
+
+    assert cos(4.5*e*pi) == cos(0.5*pi*e)
+    assert sin(4.5*e*pi) == sin(0.5*pi*e)
+    assert tan(4.5*e*pi) == tan(0.5*pi*e)
+    assert cot(4.5*e*pi) == cot(0.5*pi*e)
+
+    assert cos(4*o*pi) == 1
+    assert sin(4*o*pi) == 0
+    assert tan(4*o*pi) == 0
+    assert cot(4*o*pi) is zoo
+
+    assert cos(3*o*pi) == -1
+    assert sin(3*o*pi) == 0
+    assert tan(3*o*pi) == 0
+    assert cot(3*o*pi) is zoo
+
+    assert cos(4.0*o*pi) == 1
+    assert sin(4.0*o*pi) == 0
+    assert tan(4.0*o*pi) == 0
+    assert cot(4.0*o*pi) is zoo
+
+    assert cos(3.0*o*pi) == -1
+    assert sin(3.0*o*pi) == 0
+    assert tan(3.0*o*pi) == 0
+    assert cot(3.0*o*pi) is zoo
+
+    assert cos(4.5*o*pi) == cos(0.5*pi*o)
+    assert sin(4.5*o*pi) == sin(0.5*pi*o)
+    assert tan(4.5*o*pi) == tan(0.5*pi*o)
+    assert cot(4.5*o*pi) == cot(0.5*pi*o)
+
+    # x could be imaginary
+    assert cos(4*x*pi) == cos(4*pi*x)
+    assert sin(4*x*pi) == sin(4*pi*x)
+    assert tan(4*x*pi) == tan(4*pi*x)
+    assert cot(4*x*pi) == cot(4*pi*x)
+
+    assert cos(3*x*pi) == cos(3*pi*x)
+    assert sin(3*x*pi) == sin(3*pi*x)
+    assert tan(3*x*pi) == tan(3*pi*x)
+    assert cot(3*x*pi) == cot(3*pi*x)
+
+    assert cos(4.0*x*pi) == cos(4.0*pi*x)
+    assert sin(4.0*x*pi) == sin(4.0*pi*x)
+    assert tan(4.0*x*pi) == tan(4.0*pi*x)
+    assert cot(4.0*x*pi) == cot(4.0*pi*x)
+
+    assert cos(3.0*x*pi) == cos(3.0*pi*x)
+    assert sin(3.0*x*pi) == sin(3.0*pi*x)
+    assert tan(3.0*x*pi) == tan(3.0*pi*x)
+    assert cot(3.0*x*pi) == cot(3.0*pi*x)
+
+    assert cos(4.5*x*pi) == cos(4.5*pi*x)
+    assert sin(4.5*x*pi) == sin(4.5*pi*x)
+    assert tan(4.5*x*pi) == tan(4.5*pi*x)
+    assert cot(4.5*x*pi) == cot(4.5*pi*x)
+
+
+def test_inverses():
+    raises(AttributeError, lambda: sin(x).inverse())
+    raises(AttributeError, lambda: cos(x).inverse())
+    assert tan(x).inverse() == atan
+    assert cot(x).inverse() == acot
+    raises(AttributeError, lambda: csc(x).inverse())
+    raises(AttributeError, lambda: sec(x).inverse())
+    assert asin(x).inverse() == sin
+    assert acos(x).inverse() == cos
+    assert atan(x).inverse() == tan
+    assert acot(x).inverse() == cot
+
+
+def test_real_imag():
+    a, b = symbols('a b', real=True)
+    z = a + b*I
+    for deep in [True, False]:
+        assert sin(
+            z).as_real_imag(deep=deep) == (sin(a)*cosh(b), cos(a)*sinh(b))
+        assert cos(
+            z).as_real_imag(deep=deep) == (cos(a)*cosh(b), -sin(a)*sinh(b))
+        assert tan(z).as_real_imag(deep=deep) == (sin(2*a)/(cos(2*a) +
+            cosh(2*b)), sinh(2*b)/(cos(2*a) + cosh(2*b)))
+        assert cot(z).as_real_imag(deep=deep) == (-sin(2*a)/(cos(2*a) -
+            cosh(2*b)), sinh(2*b)/(cos(2*a) - cosh(2*b)))
+        assert sin(a).as_real_imag(deep=deep) == (sin(a), 0)
+        assert cos(a).as_real_imag(deep=deep) == (cos(a), 0)
+        assert tan(a).as_real_imag(deep=deep) == (tan(a), 0)
+        assert cot(a).as_real_imag(deep=deep) == (cot(a), 0)
+
+
+@slow
+def test_sincos_rewrite_sqrt():
+    # equivalent to testing rewrite(pow)
+    for p in [1, 3, 5, 17]:
+        for t in [1, 8]:
+            n = t*p
+            # The vertices `exp(i*pi/n)` of a regular `n`-gon can
+            # be expressed by means of nested square roots if and
+            # only if `n` is a product of Fermat primes, `p`, and
+            # powers of 2, `t'. The code aims to check all vertices
+            # not belonging to an `m`-gon for `m < n`(`gcd(i, n) == 1`).
+            # For large `n` this makes the test too slow, therefore
+            # the vertices are limited to those of index `i < 10`.
+            for i in range(1, min((n + 1)//2 + 1, 10)):
+                if 1 == gcd(i, n):
+                    x = i*pi/n
+                    s1 = sin(x).rewrite(sqrt)
+                    c1 = cos(x).rewrite(sqrt)
+                    assert not s1.has(cos, sin), "fails for %d*pi/%d" % (i, n)
+                    assert not c1.has(cos, sin), "fails for %d*pi/%d" % (i, n)
+                    assert 1e-3 > abs(sin(x.evalf(5)) - s1.evalf(2)), "fails for %d*pi/%d" % (i, n)
+                    assert 1e-3 > abs(cos(x.evalf(5)) - c1.evalf(2)), "fails for %d*pi/%d" % (i, n)
+    assert cos(pi/14).rewrite(sqrt) == sqrt(cos(pi/7)/2 + S.Half)
+    assert cos(pi*Rational(-15, 2)/11, evaluate=False).rewrite(
+        sqrt) == -sqrt(-cos(pi*Rational(4, 11))/2 + S.Half)
+    assert cos(Mul(2, pi, S.Half, evaluate=False), evaluate=False).rewrite(
+        sqrt) == -1
+    e = cos(pi/3/17)  # don't use pi/15 since that is caught at instantiation
+    a = (
+        -3*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17) + 17)/64 -
+        3*sqrt(34)*sqrt(sqrt(17) + 17)/128 - sqrt(sqrt(17) +
+        17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) + 17)
+        + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 - sqrt(-sqrt(17)
+        + 17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/128 - Rational(1, 32) +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 +
+        3*sqrt(2)*sqrt(sqrt(17) + 17)/128 + sqrt(34)*sqrt(-sqrt(17) + 17)/128
+        + 13*sqrt(2)*sqrt(-sqrt(17) + 17)/128 + sqrt(17)*sqrt(-sqrt(17) +
+        17)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) + 17)
+        + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/128 + 5*sqrt(17)/32
+        + sqrt(3)*sqrt(-sqrt(2)*sqrt(sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/8 -
+        5*sqrt(2)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 -
+        3*sqrt(2)*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/32
+        + sqrt(34)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/64 +
+        sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 + Rational(15, 32))/2 +
+        S.Half + sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 + sqrt(2)*sqrt(-sqrt(17) +
+        17)/32 + sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) -
+        sqrt(2)*sqrt(-sqrt(17) + 17) + sqrt(34)*sqrt(-sqrt(17) + 17) +
+        6*sqrt(17) + 34)/32 + Rational(15, 32))*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) -
+        sqrt(2)*sqrt(-sqrt(17) + 17) + sqrt(34)*sqrt(-sqrt(17) + 17) +
+        6*sqrt(17) + 34)/32 + sqrt(34)*sqrt(-sqrt(17) + 17)*sqrt(sqrt(17)/32 +
+        sqrt(2)*sqrt(-sqrt(17) + 17)/32 +
+        sqrt(2)*sqrt(-8*sqrt(2)*sqrt(sqrt(17) + 17) - sqrt(2)*sqrt(-sqrt(17) +
+        17) + sqrt(34)*sqrt(-sqrt(17) + 17) + 6*sqrt(17) + 34)/32 +
+        Rational(15, 32))/32)/2)
+    assert e.rewrite(sqrt) == a
+    assert e.n() == a.n()
+    # coverage of fermatCoords: multiplicity > 1; the following could be
+    # different but that portion of the code should be tested in some way
+    assert cos(pi/9/17).rewrite(sqrt) == \
+        sin(pi/9)*sin(pi*Rational(2, 17)) + cos(pi/9)*cos(pi*Rational(2, 17))
+
+
+@slow
+def test_sincos_rewrite_sqrt_257():
+    assert cos(pi/257).rewrite(sqrt).evalf(64) == cos(pi/257).evalf(64)
+
+
+@slow
+def test_tancot_rewrite_sqrt():
+    # equivalent to testing rewrite(pow)
+    for p in [1, 3, 5, 17]:
+        for t in [1, 8]:
+            n = t*p
+            for i in range(1, min((n + 1)//2 + 1, 10)):
+                if 1 == gcd(i, n):
+                    x = i*pi/n
+                    if  2*i != n and 3*i != 2*n:
+                        t1 = tan(x).rewrite(sqrt)
+                        assert not t1.has(cot, tan), "fails for %d*pi/%d" % (i, n)
+                        assert 1e-3 > abs( tan(x.evalf(7)) - t1.evalf(4) ), "fails for %d*pi/%d" % (i, n)
+                    if  i != 0 and i != n:
+                        c1 = cot(x).rewrite(sqrt)
+                        assert not c1.has(cot, tan), "fails for %d*pi/%d" % (i, n)
+                        assert 1e-3 > abs( cot(x.evalf(7)) - c1.evalf(4) ), "fails for %d*pi/%d" % (i, n)
+
+
+def test_sec():
+    x = symbols('x', real=True)
+    z = symbols('z')
+
+    assert sec.nargs == FiniteSet(1)
+
+    assert sec(zoo) is nan
+    assert sec(0) == 1
+    assert sec(pi) == -1
+    assert sec(pi/2) is zoo
+    assert sec(-pi/2) is zoo
+    assert sec(pi/6) == 2*sqrt(3)/3
+    assert sec(pi/3) == 2
+    assert sec(pi*Rational(5, 2)) is zoo
+    assert sec(pi*Rational(9, 7)) == -sec(pi*Rational(2, 7))
+    assert sec(pi*Rational(3, 4)) == -sqrt(2)  # issue 8421
+    assert sec(I) == 1/cosh(1)
+    assert sec(x*I) == 1/cosh(x)
+    assert sec(-x) == sec(x)
+
+    assert sec(asec(x)) == x
+
+    assert sec(z).conjugate() == sec(conjugate(z))
+
+    assert (sec(z).as_real_imag() ==
+    (cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
+                             cos(re(z))**2*cosh(im(z))**2),
+     sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
+                             cos(re(z))**2*cosh(im(z))**2)))
+
+    assert sec(x).expand(trig=True) == 1/cos(x)
+    assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1)
+
+    assert sec(x).is_extended_real == True
+    assert sec(z).is_real == None
+
+    assert sec(a).is_algebraic is None
+    assert sec(na).is_algebraic is False
+
+    assert sec(x).as_leading_term() == sec(x)
+
+    assert sec(0, evaluate=False).is_finite == True
+    assert sec(x).is_finite == None
+    assert sec(pi/2, evaluate=False).is_finite == False
+
+    assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6)
+
+    # https://github.com/sympy/sympy/issues/7166
+    assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6)
+
+    # https://github.com/sympy/sympy/issues/7167
+    assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
+            1/sqrt(x - pi*Rational(3, 2)) + (x - pi*Rational(3, 2))**Rational(3, 2)/12 +
+            (x - pi*Rational(3, 2))**Rational(7, 2)/160 + O((x - pi*Rational(3, 2))**4, (x, pi*Rational(3, 2))))
+
+    assert sec(x).diff(x) == tan(x)*sec(x)
+
+    # Taylor Term checks
+    assert sec(z).taylor_term(4, z) == 5*z**4/24
+    assert sec(z).taylor_term(6, z) == 61*z**6/720
+    assert sec(z).taylor_term(5, z) == 0
+
+
+def test_sec_rewrite():
+    assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2)
+    assert sec(x).rewrite(cos) == 1/cos(x)
+    assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1)
+    assert sec(x).rewrite(pow) == sec(x)
+    assert sec(x).rewrite(sqrt) == sec(x)
+    assert sec(z).rewrite(cot) == (cot(z/2)**2 + 1)/(cot(z/2)**2 - 1)
+    assert sec(x).rewrite(sin) == 1 / sin(x + pi / 2, evaluate=False)
+    assert sec(x).rewrite(tan) == (tan(x / 2)**2 + 1) / (-tan(x / 2)**2 + 1)
+    assert sec(x).rewrite(csc) == csc(-x + pi/2, evaluate=False)
+    assert sec(x).rewrite(besselj) == Piecewise(
+                (sqrt(2)/(sqrt(pi*x)*besselj(-S.Half, x)), Ne(x, 0)),
+                (1, True)
+            )
+    assert sec(x).rewrite(besselj).subs(x, 0) == sec(0)
+
+
+def test_sec_fdiff():
+    assert sec(x).fdiff() == tan(x)*sec(x)
+    raises(ArgumentIndexError, lambda: sec(x).fdiff(2))
+
+
+def test_csc():
+    x = symbols('x', real=True)
+    z = symbols('z')
+
+    # https://github.com/sympy/sympy/issues/6707
+    cosecant = csc('x')
+    alternate = 1/sin('x')
+    assert cosecant.equals(alternate) == True
+    assert alternate.equals(cosecant) == True
+
+    assert csc.nargs == FiniteSet(1)
+
+    assert csc(0) is zoo
+    assert csc(pi) is zoo
+    assert csc(zoo) is nan
+
+    assert csc(pi/2) == 1
+    assert csc(-pi/2) == -1
+    assert csc(pi/6) == 2
+    assert csc(pi/3) == 2*sqrt(3)/3
+    assert csc(pi*Rational(5, 2)) == 1
+    assert csc(pi*Rational(9, 7)) == -csc(pi*Rational(2, 7))
+    assert csc(pi*Rational(3, 4)) == sqrt(2)  # issue 8421
+    assert csc(I) == -I/sinh(1)
+    assert csc(x*I) == -I/sinh(x)
+    assert csc(-x) == -csc(x)
+
+    assert csc(acsc(x)) == x
+
+    assert csc(z).conjugate() == csc(conjugate(z))
+
+    assert (csc(z).as_real_imag() ==
+            (sin(re(z))*cosh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
+                                     cos(re(z))**2*sinh(im(z))**2),
+             -cos(re(z))*sinh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
+                          cos(re(z))**2*sinh(im(z))**2)))
+
+    assert csc(x).expand(trig=True) == 1/sin(x)
+    assert csc(2*x).expand(trig=True) == 1/(2*sin(x)*cos(x))
+
+    assert csc(x).is_extended_real == True
+    assert csc(z).is_real == None
+
+    assert csc(a).is_algebraic is None
+    assert csc(na).is_algebraic is False
+
+    assert csc(x).as_leading_term() == csc(x)
+
+    assert csc(0, evaluate=False).is_finite == False
+    assert csc(x).is_finite == None
+    assert csc(pi/2, evaluate=False).is_finite == True
+
+    assert series(csc(x), x, x0=pi/2, n=6) == \
+        1 + (x - pi/2)**2/2 + 5*(x - pi/2)**4/24 + O((x - pi/2)**6, (x, pi/2))
+    assert series(csc(x), x, x0=0, n=6) == \
+            1/x + x/6 + 7*x**3/360 + 31*x**5/15120 + O(x**6)
+
+    assert csc(x).diff(x) == -cot(x)*csc(x)
+
+    assert csc(x).taylor_term(2, x) == 0
+    assert csc(x).taylor_term(3, x) == 7*x**3/360
+    assert csc(x).taylor_term(5, x) == 31*x**5/15120
+    raises(ArgumentIndexError, lambda: csc(x).fdiff(2))
+
+
+def test_asec():
+    z = Symbol('z', zero=True)
+    assert asec(z) is zoo
+    assert asec(nan) is nan
+    assert asec(1) == 0
+    assert asec(-1) == pi
+    assert asec(oo) == pi/2
+    assert asec(-oo) == pi/2
+    assert asec(zoo) == pi/2
+
+    assert asec(sec(pi*Rational(13, 4))) == pi*Rational(3, 4)
+    assert asec(1 + sqrt(5)) == pi*Rational(2, 5)
+    assert asec(2/sqrt(3)) == pi/6
+    assert asec(sqrt(4 - 2*sqrt(2))) == pi/8
+    assert asec(-sqrt(4 + 2*sqrt(2))) == pi*Rational(5, 8)
+    assert asec(sqrt(2 + 2*sqrt(5)/5)) == pi*Rational(3, 10)
+    assert asec(-sqrt(2 + 2*sqrt(5)/5)) == pi*Rational(7, 10)
+    assert asec(sqrt(2) - sqrt(6)) == pi*Rational(11, 12)
+
+    for d in [3, 4, 6]:
+        for num in range(d):
+            if gcd(num, d) == 1:
+                assert asec(sec(num*pi/d)) == num*pi/d
+                assert asec(-sec(num*pi/d)) == pi - num*pi/d
+                assert asec(csc(num*pi/d)) == pi/2 - acsc(csc(num*pi/d))
+                assert asec(-csc(num*pi/d)) == pi/2 - acsc(-csc(num*pi/d))
+
+    assert asec(x).diff(x) == 1/(x**2*sqrt(1 - 1/x**2))
+
+    assert asec(x).rewrite(log) == I*log(sqrt(1 - 1/x**2) + I/x) + pi/2
+    assert asec(x).rewrite(asin) == -asin(1/x) + pi/2
+    assert asec(x).rewrite(acos) == acos(1/x)
+    assert asec(x).rewrite(atan) == \
+        pi*(1 - sqrt(x**2)/x)/2 + sqrt(x**2)*atan(sqrt(x**2 - 1))/x
+    assert asec(x).rewrite(acot) == \
+        pi*(1 - sqrt(x**2)/x)/2 + sqrt(x**2)*acot(1/sqrt(x**2 - 1))/x
+    assert asec(x).rewrite(acsc) == -acsc(x) + pi/2
+    raises(ArgumentIndexError, lambda: asec(x).fdiff(2))
+
+
+def test_asec_is_real():
+    assert asec(S.Half).is_real is False
+    n = Symbol('n', positive=True, integer=True)
+    assert asec(n).is_extended_real is True
+    assert asec(x).is_real is None
+    assert asec(r).is_real is None
+    t = Symbol('t', real=False, finite=True)
+    assert asec(t).is_real is False
+
+
+def test_asec_leading_term():
+    assert asec(1/x).as_leading_term(x) == pi/2
+    # Tests concerning branch points
+    assert asec(x + 1).as_leading_term(x) == sqrt(2)*sqrt(x)
+    assert asec(x - 1).as_leading_term(x) == pi
+    # Tests concerning points lying on branch cuts
+    assert asec(x).as_leading_term(x, cdir=1) == -I*log(x) + I*log(2)
+    assert asec(x).as_leading_term(x, cdir=-1) == I*log(x) + 2*pi - I*log(2)
+    assert asec(I*x + 1/2).as_leading_term(x, cdir=1) == asec(1/2)
+    assert asec(-I*x + 1/2).as_leading_term(x, cdir=1) == -asec(1/2)
+    assert asec(I*x - 1/2).as_leading_term(x, cdir=1) == 2*pi - asec(-1/2)
+    assert asec(-I*x - 1/2).as_leading_term(x, cdir=1) == asec(-1/2)
+    # Tests concerning im(ndir) == 0
+    assert asec(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=1) == pi + I*log(2 - sqrt(3))
+    assert asec(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=-1) == pi + I*log(2 - sqrt(3))
+
+
+def test_asec_series():
+    assert asec(x).series(x, 0, 9) == \
+        I*log(2) - I*log(x) - I*x**2/4 - 3*I*x**4/32 \
+        - 5*I*x**6/96 - 35*I*x**8/1024 + O(x**9)
+    t4 = asec(x).taylor_term(4, x)
+    assert t4 == -3*I*x**4/32
+    assert asec(x).taylor_term(6, x, t4, 0) == -5*I*x**6/96
+
+
+def test_acsc():
+    assert acsc(nan) is nan
+    assert acsc(1) == pi/2
+    assert acsc(-1) == -pi/2
+    assert acsc(oo) == 0
+    assert acsc(-oo) == 0
+    assert acsc(zoo) == 0
+    assert acsc(0) is zoo
+
+    assert acsc(csc(3)) == -3 + pi
+    assert acsc(csc(4)) == -4 + pi
+    assert acsc(csc(6)) == 6 - 2*pi
+    assert unchanged(acsc, csc(x))
+    assert unchanged(acsc, sec(x))
+
+    assert acsc(2/sqrt(3)) == pi/3
+    assert acsc(csc(pi*Rational(13, 4))) == -pi/4
+    assert acsc(sqrt(2 + 2*sqrt(5)/5)) == pi/5
+    assert acsc(-sqrt(2 + 2*sqrt(5)/5)) == -pi/5
+    assert acsc(-2) == -pi/6
+    assert acsc(-sqrt(4 + 2*sqrt(2))) == -pi/8
+    assert acsc(sqrt(4 - 2*sqrt(2))) == pi*Rational(3, 8)
+    assert acsc(1 + sqrt(5)) == pi/10
+    assert acsc(sqrt(2) - sqrt(6)) == pi*Rational(-5, 12)
+
+    assert acsc(x).diff(x) == -1/(x**2*sqrt(1 - 1/x**2))
+
+    assert acsc(x).rewrite(log) == -I*log(sqrt(1 - 1/x**2) + I/x)
+    assert acsc(x).rewrite(asin) == asin(1/x)
+    assert acsc(x).rewrite(acos) == -acos(1/x) + pi/2
+    assert acsc(x).rewrite(atan) == \
+        (-atan(sqrt(x**2 - 1)) + pi/2)*sqrt(x**2)/x
+    assert acsc(x).rewrite(acot) == (-acot(1/sqrt(x**2 - 1)) + pi/2)*sqrt(x**2)/x
+    assert acsc(x).rewrite(asec) == -asec(x) + pi/2
+    raises(ArgumentIndexError, lambda: acsc(x).fdiff(2))
+
+
+def test_csc_rewrite():
+    assert csc(x).rewrite(pow) == csc(x)
+    assert csc(x).rewrite(sqrt) == csc(x)
+
+    assert csc(x).rewrite(exp) == 2*I/(exp(I*x) - exp(-I*x))
+    assert csc(x).rewrite(sin) == 1/sin(x)
+    assert csc(x).rewrite(tan) == (tan(x/2)**2 + 1)/(2*tan(x/2))
+    assert csc(x).rewrite(cot) == (cot(x/2)**2 + 1)/(2*cot(x/2))
+    assert csc(x).rewrite(cos) == 1/cos(x - pi/2, evaluate=False)
+    assert csc(x).rewrite(sec) == sec(-x + pi/2, evaluate=False)
+
+    # issue 17349
+    assert csc(1 - exp(-besselj(I, I))).rewrite(cos) == \
+           -1/cos(-pi/2 - 1 + cos(I*besselj(I, I)) +
+                  I*cos(-pi/2 + I*besselj(I, I), evaluate=False), evaluate=False)
+    assert csc(x).rewrite(besselj) == sqrt(2)/(sqrt(pi*x)*besselj(S.Half, x))
+    assert csc(x).rewrite(besselj).subs(x, 0) == csc(0)
+
+
+def test_acsc_leading_term():
+    assert acsc(1/x).as_leading_term(x) == x
+    # Tests concerning branch points
+    assert acsc(x + 1).as_leading_term(x) == pi/2
+    assert acsc(x - 1).as_leading_term(x) == -pi/2
+    # Tests concerning points lying on branch cuts
+    assert acsc(x).as_leading_term(x, cdir=1) == I*log(x) + pi/2 - I*log(2)
+    assert acsc(x).as_leading_term(x, cdir=-1) == -I*log(x) - 3*pi/2 + I*log(2)
+    assert acsc(I*x + 1/2).as_leading_term(x, cdir=1) == acsc(1/2)
+    assert acsc(-I*x + 1/2).as_leading_term(x, cdir=1) == pi - acsc(1/2)
+    assert acsc(I*x - 1/2).as_leading_term(x, cdir=1) == -pi - acsc(-1/2)
+    assert acsc(-I*x - 1/2).as_leading_term(x, cdir=1) == -acsc(1/2)
+    # Tests concerning im(ndir) == 0
+    assert acsc(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=1) == -pi/2 + I*log(sqrt(3) + 2)
+    assert acsc(-I*x**2 + x - S(1)/2).as_leading_term(x, cdir=-1) == -pi/2 + I*log(sqrt(3) + 2)
+
+
+def test_acsc_series():
+    assert acsc(x).series(x, 0, 9) == \
+        -I*log(2) + pi/2 + I*log(x) + I*x**2/4 \
+        + 3*I*x**4/32 + 5*I*x**6/96 + 35*I*x**8/1024 + O(x**9)
+    t6 = acsc(x).taylor_term(6, x)
+    assert t6 == 5*I*x**6/96
+    assert acsc(x).taylor_term(8, x, t6, 0) == 35*I*x**8/1024
+
+
+def test_asin_nseries():
+    assert asin(x + 2)._eval_nseries(x, 4, None, I) == -asin(2) + pi + \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x + 2)._eval_nseries(x, 4, None, -I) == asin(2) - \
+    sqrt(3)*I*x/3 + sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x - 2)._eval_nseries(x, 4, None, I) == -asin(2) - \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert asin(x - 2)._eval_nseries(x, 4, None, -I) == asin(2) - pi + \
+    sqrt(3)*I*x/3 + sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    # testing nseries for asin at branch points
+    assert asin(1 + x)._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/12 - 3*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert asin(-1 + x)._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/12 + 3*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert asin(exp(x))._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/6 - sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+    assert asin(-exp(x))._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/6 + sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+
+
+def test_acos_nseries():
+    assert acos(x + 2)._eval_nseries(x, 4, None, I) == -acos(2) - sqrt(3)*I*x/3 + \
+    sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x + 2)._eval_nseries(x, 4, None, -I) == acos(2) + sqrt(3)*I*x/3 - \
+    sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x - 2)._eval_nseries(x, 4, None, I) == acos(-2) + sqrt(3)*I*x/3 + \
+    sqrt(3)*I*x**2/9 + sqrt(3)*I*x**3/18 + O(x**4)
+    assert acos(x - 2)._eval_nseries(x, 4, None, -I) == -acos(-2) + 2*pi - \
+    sqrt(3)*I*x/3 - sqrt(3)*I*x**2/9 - sqrt(3)*I*x**3/18 + O(x**4)
+    # testing nseries for acos at branch points
+    assert acos(1 + x)._eval_nseries(x, 3, None) == sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/12 + 3*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert acos(-1 + x)._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/12 - 3*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert acos(exp(x))._eval_nseries(x, 3, None) == sqrt(2)*sqrt(-x) - \
+    sqrt(2)*(-x)**(S(3)/2)/6 + sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+    assert acos(-exp(x))._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(-x) + \
+    sqrt(2)*(-x)**(S(3)/2)/6 - sqrt(2)*(-x)**(S(5)/2)/120 + O(x**3)
+
+
+def test_atan_nseries():
+    assert atan(x + 2*I)._eval_nseries(x, 4, None, 1) == I*atanh(2) - x/3 - \
+    2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x + 2*I)._eval_nseries(x, 4, None, -1) == I*atanh(2) - pi - \
+    x/3 - 2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x - 2*I)._eval_nseries(x, 4, None, 1) == -I*atanh(2) + pi - \
+    x/3 + 2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(x - 2*I)._eval_nseries(x, 4, None, -1) == -I*atanh(2) - x/3 + \
+    2*I*x**2/9 + 13*x**3/81 + O(x**4)
+    assert atan(1/x)._eval_nseries(x, 2, None, 1) == pi/2 - x + O(x**2)
+    assert atan(1/x)._eval_nseries(x, 2, None, -1) == -pi/2 - x + O(x**2)
+    # testing nseries for atan at branch points
+    assert atan(x + I)._eval_nseries(x, 4, None) == I*log(2)/2 + pi/4 - \
+    I*log(x)/2 + x/4 + I*x**2/16 - x**3/48 + O(x**4)
+    assert atan(x - I)._eval_nseries(x, 4, None) == -I*log(2)/2 + pi/4 + \
+    I*log(x)/2 + x/4 - I*x**2/16 - x**3/48 + O(x**4)
+
+
+def test_acot_nseries():
+    assert acot(x + S(1)/2*I)._eval_nseries(x, 4, None, 1) == -I*acoth(S(1)/2) + \
+    pi - 4*x/3 + 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x + S(1)/2*I)._eval_nseries(x, 4, None, -1) == -I*acoth(S(1)/2) - \
+    4*x/3 + 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x - S(1)/2*I)._eval_nseries(x, 4, None, 1) == I*acoth(S(1)/2) - \
+    4*x/3 - 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x - S(1)/2*I)._eval_nseries(x, 4, None, -1) == I*acoth(S(1)/2) - \
+    pi - 4*x/3 - 8*I*x**2/9 + 112*x**3/81 + O(x**4)
+    assert acot(x)._eval_nseries(x, 2, None, 1) == pi/2 - x + O(x**2)
+    assert acot(x)._eval_nseries(x, 2, None, -1) == -pi/2 - x + O(x**2)
+    # testing nseries for acot at branch points
+    assert acot(x + I)._eval_nseries(x, 4, None) == -I*log(2)/2 + pi/4 + \
+    I*log(x)/2 - x/4 - I*x**2/16 + x**3/48 + O(x**4)
+    assert acot(x - I)._eval_nseries(x, 4, None) == I*log(2)/2 + pi/4 - \
+    I*log(x)/2 - x/4 + I*x**2/16 + x**3/48 + O(x**4)
+
+
+def test_asec_nseries():
+    assert asec(x + S(1)/2)._eval_nseries(x, 4, None, I) == asec(S(1)/2) - \
+    4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x + S(1)/2)._eval_nseries(x, 4, None, -I) == -asec(S(1)/2) + \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x - S(1)/2)._eval_nseries(x, 4, None, I) == -asec(-S(1)/2) + \
+    2*pi + 4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert asec(x - S(1)/2)._eval_nseries(x, 4, None, -I) == asec(-S(1)/2) - \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    # testing nseries for asec at branch points
+    assert asec(1 + x)._eval_nseries(x, 3, None) == sqrt(2)*sqrt(x) - \
+    5*sqrt(2)*x**(S(3)/2)/12 + 43*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert asec(-1 + x)._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(-x) + \
+    5*sqrt(2)*(-x)**(S(3)/2)/12 - 43*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert asec(exp(x))._eval_nseries(x, 3, None) == sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/6 + sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+    assert asec(-exp(x))._eval_nseries(x, 3, None) == pi - sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/6 - sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+
+
+def test_acsc_nseries():
+    assert acsc(x + S(1)/2)._eval_nseries(x, 4, None, I) == acsc(S(1)/2) + \
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x + S(1)/2)._eval_nseries(x, 4, None, -I) == -acsc(S(1)/2) + \
+    pi - 4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x - S(1)/2)._eval_nseries(x, 4, None, I) == acsc(S(1)/2) - pi -\
+    4*sqrt(3)*I*x/3 - 8*sqrt(3)*I*x**2/9 - 16*sqrt(3)*I*x**3/9 + O(x**4)
+    assert acsc(x - S(1)/2)._eval_nseries(x, 4, None, -I) == -acsc(S(1)/2) + \
+    4*sqrt(3)*I*x/3 + 8*sqrt(3)*I*x**2/9 + 16*sqrt(3)*I*x**3/9 + O(x**4)
+    # testing nseries for acsc at branch points
+    assert acsc(1 + x)._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(x) + \
+    5*sqrt(2)*x**(S(3)/2)/12 - 43*sqrt(2)*x**(S(5)/2)/160 + O(x**3)
+    assert acsc(-1 + x)._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(-x) - \
+    5*sqrt(2)*(-x)**(S(3)/2)/12 + 43*sqrt(2)*(-x)**(S(5)/2)/160 + O(x**3)
+    assert acsc(exp(x))._eval_nseries(x, 3, None) == pi/2 - sqrt(2)*sqrt(x) + \
+    sqrt(2)*x**(S(3)/2)/6 - sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+    assert acsc(-exp(x))._eval_nseries(x, 3, None) == -pi/2 + sqrt(2)*sqrt(x) - \
+    sqrt(2)*x**(S(3)/2)/6 + sqrt(2)*x**(S(5)/2)/120 + O(x**3)
+
+
+def test_issue_8653():
+    n = Symbol('n', integer=True)
+    assert sin(n).is_irrational is None
+    assert cos(n).is_irrational is None
+    assert tan(n).is_irrational is None
+
+
+def test_issue_9157():
+    n = Symbol('n', integer=True, positive=True)
+    assert atan(n - 1).is_nonnegative is True
+
+
+def test_trig_period():
+    x, y = symbols('x, y')
+
+    assert sin(x).period() == 2*pi
+    assert cos(x).period() == 2*pi
+    assert tan(x).period() == pi
+    assert cot(x).period() == pi
+    assert sec(x).period() == 2*pi
+    assert csc(x).period() == 2*pi
+    assert sin(2*x).period() == pi
+    assert cot(4*x - 6).period() == pi/4
+    assert cos((-3)*x).period() == pi*Rational(2, 3)
+    assert cos(x*y).period(x) == 2*pi/abs(y)
+    assert sin(3*x*y + 2*pi).period(y) == 2*pi/abs(3*x)
+    assert tan(3*x).period(y) is S.Zero
+    raises(NotImplementedError, lambda: sin(x**2).period(x))
+
+
+def test_issue_7171():
+    assert sin(x).rewrite(sqrt) == sin(x)
+    assert sin(x).rewrite(pow) == sin(x)
+
+
+def test_issue_11864():
+    w, k = symbols('w, k', real=True)
+    F = Piecewise((1, Eq(2*pi*k, 0)), (sin(pi*k)/(pi*k), True))
+    soln = Piecewise((1, Eq(2*pi*k, 0)), (sinc(pi*k), True))
+    assert F.rewrite(sinc) == soln
+
+def test_real_assumptions():
+    z = Symbol('z', real=False, finite=True)
+    assert sin(z).is_real is None
+    assert cos(z).is_real is None
+    assert tan(z).is_real is False
+    assert sec(z).is_real is None
+    assert csc(z).is_real is None
+    assert cot(z).is_real is False
+    assert asin(p).is_real is None
+    assert asin(n).is_real is None
+    assert asec(p).is_real is None
+    assert asec(n).is_real is None
+    assert acos(p).is_real is None
+    assert acos(n).is_real is None
+    assert acsc(p).is_real is None
+    assert acsc(n).is_real is None
+    assert atan(p).is_positive is True
+    assert atan(n).is_negative is True
+    assert acot(p).is_positive is True
+    assert acot(n).is_negative is True
+
+def test_issue_14320():
+    assert asin(sin(2)) == -2 + pi and (-pi/2 <= -2 + pi <= pi/2) and sin(2) == sin(-2 + pi)
+    assert asin(cos(2)) == -2 + pi/2 and (-pi/2 <= -2 + pi/2 <= pi/2) and cos(2) == sin(-2 + pi/2)
+    assert acos(sin(2)) == -pi/2 + 2 and (0 <= -pi/2 + 2 <= pi) and sin(2) == cos(-pi/2 + 2)
+    assert acos(cos(20)) == -6*pi + 20 and (0 <= -6*pi + 20 <= pi) and cos(20) == cos(-6*pi + 20)
+    assert acos(cos(30)) == -30 + 10*pi and (0 <= -30 + 10*pi <= pi) and cos(30) == cos(-30 + 10*pi)
+
+    assert atan(tan(17)) == -5*pi + 17 and (-pi/2 < -5*pi + 17 < pi/2) and tan(17) == tan(-5*pi + 17)
+    assert atan(tan(15)) == -5*pi + 15 and (-pi/2 < -5*pi + 15 < pi/2) and tan(15) == tan(-5*pi + 15)
+    assert atan(cot(12)) == -12 + pi*Rational(7, 2) and (-pi/2 < -12 + pi*Rational(7, 2) < pi/2) and cot(12) == tan(-12 + pi*Rational(7, 2))
+    assert acot(cot(15)) == -5*pi + 15 and (-pi/2 < -5*pi + 15 <= pi/2) and cot(15) == cot(-5*pi + 15)
+    assert acot(tan(19)) == -19 + pi*Rational(13, 2) and (-pi/2 < -19 + pi*Rational(13, 2) <= pi/2) and tan(19) == cot(-19 + pi*Rational(13, 2))
+
+    assert asec(sec(11)) == -11 + 4*pi and (0 <= -11 + 4*pi <= pi) and cos(11) == cos(-11 + 4*pi)
+    assert asec(csc(13)) == -13 + pi*Rational(9, 2) and (0 <= -13 + pi*Rational(9, 2) <= pi) and sin(13) == cos(-13 + pi*Rational(9, 2))
+    assert acsc(csc(14)) == -4*pi + 14 and (-pi/2 <= -4*pi + 14 <= pi/2) and sin(14) == sin(-4*pi + 14)
+    assert acsc(sec(10)) == pi*Rational(-7, 2) + 10 and (-pi/2 <= pi*Rational(-7, 2) + 10 <= pi/2) and cos(10) == sin(pi*Rational(-7, 2) + 10)
+
+def test_issue_14543():
+    assert sec(2*pi + 11) == sec(11)
+    assert sec(2*pi - 11) == sec(11)
+    assert sec(pi + 11) == -sec(11)
+    assert sec(pi - 11) == -sec(11)
+
+    assert csc(2*pi + 17) == csc(17)
+    assert csc(2*pi - 17) == -csc(17)
+    assert csc(pi + 17) == -csc(17)
+    assert csc(pi - 17) == csc(17)
+
+    x = Symbol('x')
+    assert csc(pi/2 + x) == sec(x)
+    assert csc(pi/2 - x) == sec(x)
+    assert csc(pi*Rational(3, 2) + x) == -sec(x)
+    assert csc(pi*Rational(3, 2) - x) == -sec(x)
+
+    assert sec(pi/2 - x) == csc(x)
+    assert sec(pi/2 + x) == -csc(x)
+    assert sec(pi*Rational(3, 2) + x) == csc(x)
+    assert sec(pi*Rational(3, 2) - x) == -csc(x)
+
+
+def test_as_real_imag():
+    # This is for https://github.com/sympy/sympy/issues/17142
+    # If it start failing again in irrelevant builds or in the master
+    # please open up the issue again.
+    expr = atan(I/(I + I*tan(1)))
+    assert expr.as_real_imag() == (expr, 0)
+
+
+def test_issue_18746():
+    e3 = cos(S.Pi*(x/4 + 1/4))
+    assert e3.period() == 8
+
+
+def test_issue_25833():
+    assert limit(atan(x**2), x, oo) == pi/2
+    assert limit(atan(x**2 - 1), x, oo) == pi/2
+    assert limit(atan(log(2**x)/log(2*x)), x, oo) == pi/2
+
+
+def test_issue_25847():
+    #atan
+    assert atan(sin(x)/x).as_leading_term(x) == pi/4
+    raises(PoleError, lambda: atan(exp(1/x)).as_leading_term(x))
+
+    #asin
+    assert asin(sin(x)/x).as_leading_term(x) == pi/2
+    raises(PoleError, lambda: asin(exp(1/x)).as_leading_term(x))
+
+    #acos
+    assert acos(sin(x)/x).as_leading_term(x) == 0
+    raises(PoleError, lambda: acos(exp(1/x)).as_leading_term(x))
+
+    #acot
+    assert acot(sin(x)/x).as_leading_term(x) == pi/4
+    raises(PoleError, lambda: acot(exp(1/x)).as_leading_term(x))
+
+    #asec
+    assert asec(sin(x)/x).as_leading_term(x) == 0
+    raises(PoleError, lambda: asec(exp(1/x)).as_leading_term(x))
+
+    #acsc
+    assert acsc(sin(x)/x).as_leading_term(x) == pi/2
+    raises(PoleError, lambda: acsc(exp(1/x)).as_leading_term(x))
+
+def test_issue_23843():
+    #atan
+    assert atan(x + I).series(x, oo) == -16/(5*x**5) - 2*I/x**4 + 4/(3*x**3) + I/x**2 - 1/x + pi/2 + O(x**(-6), (x, oo))
+    assert atan(x + I).series(x, -oo) == -16/(5*x**5) - 2*I/x**4 + 4/(3*x**3) + I/x**2 - 1/x - pi/2 + O(x**(-6), (x, -oo))
+    assert atan(x - I).series(x, oo) == -16/(5*x**5) + 2*I/x**4 + 4/(3*x**3) - I/x**2 - 1/x + pi/2 + O(x**(-6), (x, oo))
+    assert atan(x - I).series(x, -oo) == -16/(5*x**5) + 2*I/x**4 + 4/(3*x**3) - I/x**2 - 1/x - pi/2 + O(x**(-6), (x, -oo))
+
+    #acot
+    assert acot(x + I).series(x, oo) == 16/(5*x**5) + 2*I/x**4 - 4/(3*x**3) - I/x**2 + 1/x + O(x**(-6), (x, oo))
+    assert acot(x + I).series(x, -oo) == 16/(5*x**5) + 2*I/x**4 - 4/(3*x**3) - I/x**2 + 1/x + O(x**(-6), (x, -oo))
+    assert acot(x - I).series(x, oo) == 16/(5*x**5) - 2*I/x**4 - 4/(3*x**3) + I/x**2 + 1/x + O(x**(-6), (x, oo))
+    assert acot(x - I).series(x, -oo) == 16/(5*x**5) - 2*I/x**4 - 4/(3*x**3) + I/x**2 + 1/x + O(x**(-6), (x, -oo))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/elementary/trigonometric.py b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/trigonometric.py
new file mode 100644
index 0000000000000000000000000000000000000000..24e5db81f17a215f5b344291f0e9bf4752e5317d
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/elementary/trigonometric.py
@@ -0,0 +1,3627 @@
+from __future__ import annotations
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError, PoleError, expand_mul
+from sympy.core.logic import fuzzy_not, fuzzy_or, FuzzyBool, fuzzy_and
+from sympy.core.mod import Mod
+from sympy.core.numbers import Rational, pi, Integer, Float, equal_valued
+from sympy.core.relational import Ne, Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol, Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial, RisingFactorial
+from sympy.functions.combinatorial.numbers import bernoulli, euler
+from sympy.functions.elementary.complexes import arg as arg_f, im, re
+from sympy.functions.elementary.exponential import log, exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt, Min, Max
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary._trigonometric_special import (
+    cos_table, ipartfrac, fermat_coords)
+from sympy.logic.boolalg import And
+from sympy.ntheory import factorint
+from sympy.polys.specialpolys import symmetric_poly
+from sympy.utilities.iterables import numbered_symbols
+
+
+###############################################################################
+########################## UTILITIES ##########################################
+###############################################################################
+
+
+def _imaginary_unit_as_coefficient(arg):
+    """ Helper to extract symbolic coefficient for imaginary unit """
+    if isinstance(arg, Float):
+        return None
+    else:
+        return arg.as_coefficient(S.ImaginaryUnit)
+
+###############################################################################
+########################## TRIGONOMETRIC FUNCTIONS ############################
+###############################################################################
+
+
+class TrigonometricFunction(DefinedFunction):
+    """Base class for trigonometric functions. """
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if s.args[0].is_rational and fuzzy_not(s.args[0].is_zero):
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_algebraic(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if fuzzy_not(self.args[0].is_zero) and self.args[0].is_algebraic:
+                return False
+            pi_coeff = _pi_coeff(self.args[0])
+            if pi_coeff is not None and pi_coeff.is_rational:
+                return True
+        else:
+            return s.is_algebraic
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*S.ImaginaryUnit
+
+    def _as_real_imag(self, deep=True, **hints):
+        if self.args[0].is_extended_real:
+            if deep:
+                hints['complex'] = False
+                return (self.args[0].expand(deep, **hints), S.Zero)
+            else:
+                return (self.args[0], S.Zero)
+        if deep:
+            re, im = self.args[0].expand(deep, **hints).as_real_imag()
+        else:
+            re, im = self.args[0].as_real_imag()
+        return (re, im)
+
+    def _period(self, general_period, symbol=None):
+        f = expand_mul(self.args[0])
+        if symbol is None:
+            symbol = tuple(f.free_symbols)[0]
+
+        if not f.has(symbol):
+            return S.Zero
+
+        if f == symbol:
+            return general_period
+
+        if symbol in f.free_symbols:
+            if f.is_Mul:
+                g, h = f.as_independent(symbol)
+                if h == symbol:
+                    return general_period/abs(g)
+
+            if f.is_Add:
+                a, h = f.as_independent(symbol)
+                g, h = h.as_independent(symbol, as_Add=False)
+                if h == symbol:
+                    return general_period/abs(g)
+
+        raise NotImplementedError("Use the periodicity function instead.")
+
+
+@cacheit
+def _table2():
+    # If nested sqrt's are worse than un-evaluation
+    # you can require q to be in (1, 2, 3, 4, 6, 12)
+    # q <= 12, q=15, q=20, q=24, q=30, q=40, q=60, q=120 return
+    # expressions with 2 or fewer sqrt nestings.
+    return {
+        12: (3, 4),
+        20: (4, 5),
+        30: (5, 6),
+        15: (6, 10),
+        24: (6, 8),
+        40: (8, 10),
+        60: (20, 30),
+        120: (40, 60)
+    }
+
+
+def _peeloff_pi(arg):
+    r"""
+    Split ARG into two parts, a "rest" and a multiple of $\pi$.
+    This assumes ARG to be an Add.
+    The multiple of $\pi$ returned in the second position is always a Rational.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.trigonometric import _peeloff_pi
+    >>> from sympy import pi
+    >>> from sympy.abc import x, y
+    >>> _peeloff_pi(x + pi/2)
+    (x, 1/2)
+    >>> _peeloff_pi(x + 2*pi/3 + pi*y)
+    (x + pi*y + pi/6, 1/2)
+
+    """
+    pi_coeff = S.Zero
+    rest_terms = []
+    for a in Add.make_args(arg):
+        K = a.coeff(pi)
+        if K and K.is_rational:
+            pi_coeff += K
+        else:
+            rest_terms.append(a)
+
+    if pi_coeff is S.Zero:
+        return arg, S.Zero
+
+    m1 = (pi_coeff % S.Half)
+    m2 = pi_coeff - m1
+    if m2.is_integer or ((2*m2).is_integer and m2.is_even is False):
+        return Add(*(rest_terms + [m1*pi])), m2
+    return arg, S.Zero
+
+
+def _pi_coeff(arg: Expr, cycles: int = 1) -> Expr | None:
+    r"""
+    When arg is a Number times $\pi$ (e.g. $3\pi/2$) then return the Number
+    normalized to be in the range $[0, 2]$, else `None`.
+
+    When an even multiple of $\pi$ is encountered, if it is multiplying
+    something with known parity then the multiple is returned as 0 otherwise
+    as 2.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.elementary.trigonometric import _pi_coeff
+    >>> from sympy import pi, Dummy
+    >>> from sympy.abc import x
+    >>> _pi_coeff(3*x*pi)
+    3*x
+    >>> _pi_coeff(11*pi/7)
+    11/7
+    >>> _pi_coeff(-11*pi/7)
+    3/7
+    >>> _pi_coeff(4*pi)
+    0
+    >>> _pi_coeff(5*pi)
+    1
+    >>> _pi_coeff(5.0*pi)
+    1
+    >>> _pi_coeff(5.5*pi)
+    3/2
+    >>> _pi_coeff(2 + pi)
+
+    >>> _pi_coeff(2*Dummy(integer=True)*pi)
+    2
+    >>> _pi_coeff(2*Dummy(even=True)*pi)
+    0
+
+    """
+    if arg is pi:
+        return S.One
+    elif not arg:
+        return S.Zero
+    elif arg.is_Mul:
+        cx = arg.coeff(pi)
+        if cx:
+            c, x = cx.as_coeff_Mul()  # pi is not included as coeff
+            if c.is_Float:
+                # recast exact binary fractions to Rationals
+                f = abs(c) % 1
+                if f != 0:
+                    p = -int(round(log(f, 2).evalf()))
+                    m = 2**p
+                    cm = c*m
+                    i = int(cm)
+                    if equal_valued(i, cm):
+                        c = Rational(i, m)
+                        cx = c*x
+                else:
+                    c = Rational(int(c))
+                    cx = c*x
+            if x.is_integer:
+                c2 = c % 2
+                if c2 == 1:
+                    return x
+                elif not c2:
+                    if x.is_even is not None:  # known parity
+                        return S.Zero
+                    return Integer(2)
+                else:
+                    return c2*x
+            return cx
+    elif arg.is_zero:
+        return S.Zero
+    return None
+
+
+class sin(TrigonometricFunction):
+    r"""
+    The sine function.
+
+    Returns the sine of x (measured in radians).
+
+    Explanation
+    ===========
+
+    This function will evaluate automatically in the
+    case $x/\pi$ is some rational number [4]_.  For example,
+    if $x$ is a multiple of $\pi$, $\pi/2$, $\pi/3$, $\pi/4$, and $\pi/6$.
+
+    Examples
+    ========
+
+    >>> from sympy import sin, pi
+    >>> from sympy.abc import x
+    >>> sin(x**2).diff(x)
+    2*x*cos(x**2)
+    >>> sin(1).diff(x)
+    0
+    >>> sin(pi)
+    0
+    >>> sin(pi/2)
+    1
+    >>> sin(pi/6)
+    1/2
+    >>> sin(pi/12)
+    -sqrt(2)/4 + sqrt(6)/4
+
+
+    See Also
+    ========
+
+    csc, cos, sec, tan, cot
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Sin
+    .. [4] https://mathworld.wolfram.com/TrigonometryAngles.html
+
+    """
+
+    def period(self, symbol=None):
+        return self._period(2*pi, symbol)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return cos(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.sets.setexpr import SetExpr
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.Zero
+            elif arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(-1, 1)
+
+        if arg is S.ComplexInfinity:
+            return S.NaN
+
+        if isinstance(arg, AccumBounds):
+            from sympy.sets.sets import FiniteSet
+            min, max = arg.min, arg.max
+            d = floor(min/(2*pi))
+            if min is not S.NegativeInfinity:
+                min = min - d*2*pi
+            if max is not S.Infinity:
+                max = max - d*2*pi
+            if AccumBounds(min, max).intersection(FiniteSet(pi/2, pi*Rational(5, 2))) \
+                    is not S.EmptySet and \
+                    AccumBounds(min, max).intersection(FiniteSet(pi*Rational(3, 2),
+                        pi*Rational(7, 2))) is not S.EmptySet:
+                return AccumBounds(-1, 1)
+            elif AccumBounds(min, max).intersection(FiniteSet(pi/2, pi*Rational(5, 2))) \
+                    is not S.EmptySet:
+                return AccumBounds(Min(sin(min), sin(max)), 1)
+            elif AccumBounds(min, max).intersection(FiniteSet(pi*Rational(3, 2), pi*Rational(8, 2))) \
+                        is not S.EmptySet:
+                return AccumBounds(-1, Max(sin(min), sin(max)))
+            else:
+                return AccumBounds(Min(sin(min), sin(max)),
+                                Max(sin(min), sin(max)))
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import sinh
+            return S.ImaginaryUnit*sinh(i_coeff)
+
+        pi_coeff = _pi_coeff(arg)
+        if pi_coeff is not None:
+            if pi_coeff.is_integer:
+                return S.Zero
+
+            if (2*pi_coeff).is_integer:
+                # is_even-case handled above as then pi_coeff.is_integer,
+                # so check if known to be not even
+                if pi_coeff.is_even is False:
+                    return S.NegativeOne**(pi_coeff - S.Half)
+
+            if not pi_coeff.is_Rational:
+                narg = pi_coeff*pi
+                if narg != arg:
+                    return cls(narg)
+                return None
+
+            # https://github.com/sympy/sympy/issues/6048
+            # transform a sine to a cosine, to avoid redundant code
+            if pi_coeff.is_Rational:
+                x = pi_coeff % 2
+                if x > 1:
+                    return -cls((x % 1)*pi)
+                if 2*x > 1:
+                    return cls((1 - x)*pi)
+                narg = ((pi_coeff + Rational(3, 2)) % 2)*pi
+                result = cos(narg)
+                if not isinstance(result, cos):
+                    return result
+                if pi_coeff*pi != arg:
+                    return cls(pi_coeff*pi)
+                return None
+
+        if arg.is_Add:
+            x, m = _peeloff_pi(arg)
+            if m:
+                m = m*pi
+                return sin(m)*cos(x) + cos(m)*sin(x)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, asin):
+            return arg.args[0]
+
+        if isinstance(arg, atan):
+            x = arg.args[0]
+            return x/sqrt(1 + x**2)
+
+        if isinstance(arg, atan2):
+            y, x = arg.args
+            return y/sqrt(x**2 + y**2)
+
+        if isinstance(arg, acos):
+            x = arg.args[0]
+            return sqrt(1 - x**2)
+
+        if isinstance(arg, acot):
+            x = arg.args[0]
+            return 1/(sqrt(1 + 1/x**2)*x)
+
+        if isinstance(arg, acsc):
+            x = arg.args[0]
+            return 1/x
+
+        if isinstance(arg, asec):
+            x = arg.args[0]
+            return sqrt(1 - 1/x**2)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return -p*x**2/(n*(n - 1))
+            else:
+                return S.NegativeOne**(n//2)*x**n/factorial(n)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        if logx is not None:
+            arg = arg.subs(log(x), logx)
+        if arg.subs(x, 0).has(S.NaN, S.ComplexInfinity):
+            raise PoleError("Cannot expand %s around 0" % (self))
+        return super()._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+        I = S.ImaginaryUnit
+        if isinstance(arg, (TrigonometricFunction, HyperbolicFunction)):
+            arg = arg.func(arg.args[0]).rewrite(exp)
+        return (exp(arg*I) - exp(-arg*I))/(2*I)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if isinstance(arg, log):
+            I = S.ImaginaryUnit
+            x = arg.args[0]
+            return I*x**-I/2 - I*x**I /2
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return cos(arg - pi/2, evaluate=False)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        tan_half = tan(S.Half*arg)
+        return 2*tan_half/(1 + tan_half**2)
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return sin(arg)*cos(arg)/cos(arg)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        cot_half = cot(S.Half*arg)
+        return Piecewise((0, And(Eq(im(arg), 0), Eq(Mod(arg, pi), 0))),
+                         (2*cot_half/(1 + cot_half**2), True))
+
+    def _eval_rewrite_as_pow(self, arg, **kwargs):
+        return self.rewrite(cos, **kwargs).rewrite(pow, **kwargs)
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        return self.rewrite(cos, **kwargs).rewrite(sqrt, **kwargs)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return 1/csc(arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1/sec(arg - pi/2, evaluate=False)
+
+    def _eval_rewrite_as_sinc(self, arg, **kwargs):
+        return arg*sinc(arg)
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return sqrt(pi*arg/2)*besselj(S.Half, arg)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.hyperbolic import cosh, sinh
+        re, im = self._as_real_imag(deep=deep, **hints)
+        return (sin(re)*cosh(im), cos(re)*sinh(im))
+
+    def _eval_expand_trig(self, **hints):
+        from sympy.functions.special.polynomials import chebyshevt, chebyshevu
+        arg = self.args[0]
+        x = None
+        if arg.is_Add:  # TODO, implement more if deep stuff here
+            # TODO: Do this more efficiently for more than two terms
+            x, y = arg.as_two_terms()
+            sx = sin(x, evaluate=False)._eval_expand_trig()
+            sy = sin(y, evaluate=False)._eval_expand_trig()
+            cx = cos(x, evaluate=False)._eval_expand_trig()
+            cy = cos(y, evaluate=False)._eval_expand_trig()
+            return sx*cy + sy*cx
+        elif arg.is_Mul:
+            n, x = arg.as_coeff_Mul(rational=True)
+            if n.is_Integer:  # n will be positive because of .eval
+                # canonicalization
+
+                # See https://mathworld.wolfram.com/Multiple-AngleFormulas.html
+                if n.is_odd:
+                    return S.NegativeOne**((n - 1)/2)*chebyshevt(n, sin(x))
+                else:
+                    return expand_mul(S.NegativeOne**(n/2 - 1)*cos(x)*
+                                      chebyshevu(n - 1, sin(x)), deep=False)
+        return sin(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = x0/pi
+        if n.is_integer:
+            lt = (arg - n*pi).as_leading_term(x)
+            return (S.NegativeOne**n)*lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in [S.Infinity, S.NegativeInfinity]:
+            return AccumBounds(-1, 1)
+        return self.func(x0) if x0.is_finite else self
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        if arg.is_extended_real:
+            return True
+
+    def _eval_is_zero(self):
+        rest, pi_mult = _peeloff_pi(self.args[0])
+        if rest.is_zero:
+            return pi_mult.is_integer
+
+    def _eval_is_complex(self):
+        if self.args[0].is_extended_real \
+                or self.args[0].is_complex:
+            return True
+
+
+class cos(TrigonometricFunction):
+    """
+    The cosine function.
+
+    Returns the cosine of x (measured in radians).
+
+    Explanation
+    ===========
+
+    See :func:`sin` for notes about automatic evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import cos, pi
+    >>> from sympy.abc import x
+    >>> cos(x**2).diff(x)
+    -2*x*sin(x**2)
+    >>> cos(1).diff(x)
+    0
+    >>> cos(pi)
+    -1
+    >>> cos(pi/2)
+    0
+    >>> cos(2*pi/3)
+    -1/2
+    >>> cos(pi/12)
+    sqrt(2)/4 + sqrt(6)/4
+
+    See Also
+    ========
+
+    sin, csc, sec, tan, cot
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Cos
+
+    """
+
+    def period(self, symbol=None):
+        return self._period(2*pi, symbol)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -sin(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.functions.special.polynomials import chebyshevt
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.sets.setexpr import SetExpr
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.One
+            elif arg in (S.Infinity, S.NegativeInfinity):
+                # In this case it is better to return AccumBounds(-1, 1)
+                # rather than returning S.NaN, since AccumBounds(-1, 1)
+                # preserves the information that sin(oo) is between
+                # -1 and 1, where S.NaN does not do that.
+                return AccumBounds(-1, 1)
+
+        if arg is S.ComplexInfinity:
+            return S.NaN
+
+        if isinstance(arg, AccumBounds):
+            return sin(arg + pi/2)
+        elif isinstance(arg, SetExpr):
+            return arg._eval_func(cls)
+
+        if arg.is_extended_real and arg.is_finite is False:
+            return AccumBounds(-1, 1)
+
+        if arg.could_extract_minus_sign():
+            return cls(-arg)
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import cosh
+            return cosh(i_coeff)
+
+        pi_coeff = _pi_coeff(arg)
+        if pi_coeff is not None:
+            if pi_coeff.is_integer:
+                return (S.NegativeOne)**pi_coeff
+
+            if (2*pi_coeff).is_integer:
+                # is_even-case handled above as then pi_coeff.is_integer,
+                # so check if known to be not even
+                if pi_coeff.is_even is False:
+                    return S.Zero
+
+            if not pi_coeff.is_Rational:
+                narg = pi_coeff*pi
+                if narg != arg:
+                    return cls(narg)
+                return None
+
+            # cosine formula #####################
+            # https://github.com/sympy/sympy/issues/6048
+            # explicit calculations are performed for
+            # cos(k pi/n) for n = 8,10,12,15,20,24,30,40,60,120
+            # Some other exact values like cos(k pi/240) can be
+            # calculated using a partial-fraction decomposition
+            # by calling cos( X ).rewrite(sqrt)
+            if pi_coeff.is_Rational:
+                q = pi_coeff.q
+                p = pi_coeff.p % (2*q)
+                if p > q:
+                    narg = (pi_coeff - 1)*pi
+                    return -cls(narg)
+                if 2*p > q:
+                    narg = (1 - pi_coeff)*pi
+                    return -cls(narg)
+
+                # If nested sqrt's are worse than un-evaluation
+                # you can require q to be in (1, 2, 3, 4, 6, 12)
+                # q <= 12, q=15, q=20, q=24, q=30, q=40, q=60, q=120 return
+                # expressions with 2 or fewer sqrt nestings.
+                table2 = _table2()
+                if q in table2:
+                    a, b = table2[q]
+                    a, b = p*pi/a, p*pi/b
+                    nvala, nvalb = cls(a), cls(b)
+                    if None in (nvala, nvalb):
+                        return None
+                    return nvala*nvalb + cls(pi/2 - a)*cls(pi/2 - b)
+
+                if q > 12:
+                    return None
+
+                cst_table_some = {
+                    3: S.Half,
+                    5: (sqrt(5) + 1) / 4,
+                }
+                if q in cst_table_some:
+                    cts = cst_table_some[pi_coeff.q]
+                    return chebyshevt(pi_coeff.p, cts).expand()
+
+                if 0 == q % 2:
+                    narg = (pi_coeff*2)*pi
+                    nval = cls(narg)
+                    if None == nval:
+                        return None
+                    x = (2*pi_coeff + 1)/2
+                    sign_cos = (-1)**((-1 if x < 0 else 1)*int(abs(x)))
+                    return sign_cos*sqrt( (1 + nval)/2 )
+            return None
+
+        if arg.is_Add:
+            x, m = _peeloff_pi(arg)
+            if m:
+                m = m*pi
+                return cos(m)*cos(x) - sin(m)*sin(x)
+
+        if arg.is_zero:
+            return S.One
+
+        if isinstance(arg, acos):
+            return arg.args[0]
+
+        if isinstance(arg, atan):
+            x = arg.args[0]
+            return 1/sqrt(1 + x**2)
+
+        if isinstance(arg, atan2):
+            y, x = arg.args
+            return x/sqrt(x**2 + y**2)
+
+        if isinstance(arg, asin):
+            x = arg.args[0]
+            return sqrt(1 - x ** 2)
+
+        if isinstance(arg, acot):
+            x = arg.args[0]
+            return 1/sqrt(1 + 1/x**2)
+
+        if isinstance(arg, acsc):
+            x = arg.args[0]
+            return sqrt(1 - 1/x**2)
+
+        if isinstance(arg, asec):
+            x = arg.args[0]
+            return 1/x
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            if len(previous_terms) > 2:
+                p = previous_terms[-2]
+                return -p*x**2/(n*(n - 1))
+            else:
+                return S.NegativeOne**(n//2)*x**n/factorial(n)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        arg = self.args[0]
+        if logx is not None:
+            arg = arg.subs(log(x), logx)
+        if arg.subs(x, 0).has(S.NaN, S.ComplexInfinity):
+            raise PoleError("Cannot expand %s around 0" % (self))
+        return super()._eval_nseries(x, n=n, logx=logx, cdir=cdir)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        I = S.ImaginaryUnit
+        from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+        if isinstance(arg, (TrigonometricFunction, HyperbolicFunction)):
+            arg = arg.func(arg.args[0]).rewrite(exp, **kwargs)
+        return (exp(arg*I) + exp(-arg*I))/2
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if isinstance(arg, log):
+            I = S.ImaginaryUnit
+            x = arg.args[0]
+            return x**I/2 + x**-I/2
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return sin(arg + pi/2, evaluate=False)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        tan_half = tan(S.Half*arg)**2
+        return (1 - tan_half)/(1 + tan_half)
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return sin(arg)*cos(arg)/sin(arg)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        cot_half = cot(S.Half*arg)**2
+        return Piecewise((1, And(Eq(im(arg), 0), Eq(Mod(arg, 2*pi), 0))),
+                         ((cot_half - 1)/(cot_half + 1), True))
+
+    def _eval_rewrite_as_pow(self, arg, **kwargs):
+        return self._eval_rewrite_as_sqrt(arg, **kwargs)
+
+    def _eval_rewrite_as_sqrt(self, arg: Expr, **kwargs):
+        from sympy.functions.special.polynomials import chebyshevt
+
+        pi_coeff = _pi_coeff(arg)
+        if pi_coeff is None:
+            return None
+
+        if isinstance(pi_coeff, Integer):
+            return None
+
+        if not isinstance(pi_coeff, Rational):
+            return None
+
+        cst_table_some = cos_table()
+
+        if pi_coeff.q in cst_table_some:
+            rv = chebyshevt(pi_coeff.p, cst_table_some[pi_coeff.q]())
+            if pi_coeff.q < 257:
+                rv = rv.expand()
+            return rv
+
+        if not pi_coeff.q % 2:  # recursively remove factors of 2
+            pico2 = pi_coeff * 2
+            nval = cos(pico2 * pi).rewrite(sqrt, **kwargs)
+            x = (pico2 + 1) / 2
+            sign_cos = -1 if int(x) % 2 else 1
+            return sign_cos * sqrt((1 + nval) / 2)
+
+        FC = fermat_coords(pi_coeff.q)
+        if FC:
+            denoms = FC
+        else:
+            denoms = [b**e for b, e in factorint(pi_coeff.q).items()]
+
+        apart = ipartfrac(*denoms)
+        decomp = (pi_coeff.p * Rational(n, d) for n, d in zip(apart, denoms))
+        X = [(x[1], x[0]*pi) for x in zip(decomp, numbered_symbols('z'))]
+        pcls = cos(sum(x[0] for x in X))._eval_expand_trig().subs(X)
+
+        if not FC or len(FC) == 1:
+            return pcls
+        return pcls.rewrite(sqrt, **kwargs)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return 1/sec(arg)
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return 1/sec(arg).rewrite(csc, **kwargs)
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return Piecewise(
+                (sqrt(pi*arg/2)*besselj(-S.Half, arg), Ne(arg, 0)),
+                (1, True)
+            )
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        from sympy.functions.elementary.hyperbolic import cosh, sinh
+        re, im = self._as_real_imag(deep=deep, **hints)
+        return (cos(re)*cosh(im), -sin(re)*sinh(im))
+
+    def _eval_expand_trig(self, **hints):
+        from sympy.functions.special.polynomials import chebyshevt
+        arg = self.args[0]
+        x = None
+        if arg.is_Add:  # TODO: Do this more efficiently for more than two terms
+            x, y = arg.as_two_terms()
+            sx = sin(x, evaluate=False)._eval_expand_trig()
+            sy = sin(y, evaluate=False)._eval_expand_trig()
+            cx = cos(x, evaluate=False)._eval_expand_trig()
+            cy = cos(y, evaluate=False)._eval_expand_trig()
+            return cx*cy - sx*sy
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer:
+                return chebyshevt(coeff, cos(terms))
+        return cos(arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = (x0 + pi/2)/pi
+        if n.is_integer:
+            lt = (arg - n*pi + pi/2).as_leading_term(x)
+            return (S.NegativeOne**n)*lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in [S.Infinity, S.NegativeInfinity]:
+            return AccumBounds(-1, 1)
+        return self.func(x0) if x0.is_finite else self
+
+    def _eval_is_extended_real(self):
+        if self.args[0].is_extended_real:
+            return True
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+
+        if arg.is_extended_real:
+            return True
+
+    def _eval_is_complex(self):
+        if self.args[0].is_extended_real \
+            or self.args[0].is_complex:
+            return True
+
+    def _eval_is_zero(self):
+        rest, pi_mult = _peeloff_pi(self.args[0])
+        if rest.is_zero and pi_mult:
+            return (pi_mult - S.Half).is_integer
+
+
+class tan(TrigonometricFunction):
+    """
+    The tangent function.
+
+    Returns the tangent of x (measured in radians).
+
+    Explanation
+    ===========
+
+    See :class:`sin` for notes about automatic evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import tan, pi
+    >>> from sympy.abc import x
+    >>> tan(x**2).diff(x)
+    2*x*(tan(x**2)**2 + 1)
+    >>> tan(1).diff(x)
+    0
+    >>> tan(pi/8).expand()
+    -1 + sqrt(2)
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, cot
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Tan
+
+    """
+
+    def period(self, symbol=None):
+        return self._period(pi, symbol)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return S.One + self**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return atan
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg.is_zero:
+                return S.Zero
+            elif arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(S.NegativeInfinity, S.Infinity)
+
+        if arg is S.ComplexInfinity:
+            return S.NaN
+
+        if isinstance(arg, AccumBounds):
+            min, max = arg.min, arg.max
+            d = floor(min/pi)
+            if min is not S.NegativeInfinity:
+                min = min - d*pi
+            if max is not S.Infinity:
+                max = max - d*pi
+            from sympy.sets.sets import FiniteSet
+            if AccumBounds(min, max).intersection(FiniteSet(pi/2, pi*Rational(3, 2))):
+                return AccumBounds(S.NegativeInfinity, S.Infinity)
+            else:
+                return AccumBounds(tan(min), tan(max))
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import tanh
+            return S.ImaginaryUnit*tanh(i_coeff)
+
+        pi_coeff = _pi_coeff(arg, 2)
+        if pi_coeff is not None:
+            if pi_coeff.is_integer:
+                return S.Zero
+
+            if not pi_coeff.is_Rational:
+                narg = pi_coeff*pi
+                if narg != arg:
+                    return cls(narg)
+                return None
+
+            if pi_coeff.is_Rational:
+                q = pi_coeff.q
+                p = pi_coeff.p % q
+                # ensure simplified results are returned for n*pi/5, n*pi/10
+                table10 = {
+                    1: sqrt(1 - 2*sqrt(5)/5),
+                    2: sqrt(5 - 2*sqrt(5)),
+                    3: sqrt(1 + 2*sqrt(5)/5),
+                    4: sqrt(5 + 2*sqrt(5))
+                    }
+                if q in (5, 10):
+                    n = 10*p/q
+                    if n > 5:
+                        n = 10 - n
+                        return -table10[n]
+                    else:
+                        return table10[n]
+                if not pi_coeff.q % 2:
+                    narg = pi_coeff*pi*2
+                    cresult, sresult = cos(narg), cos(narg - pi/2)
+                    if not isinstance(cresult, cos) \
+                            and not isinstance(sresult, cos):
+                        if sresult == 0:
+                            return S.ComplexInfinity
+                        return 1/sresult - cresult/sresult
+
+                table2 = _table2()
+                if q in table2:
+                    a, b = table2[q]
+                    nvala, nvalb = cls(p*pi/a), cls(p*pi/b)
+                    if None in (nvala, nvalb):
+                        return None
+                    return (nvala - nvalb)/(1 + nvala*nvalb)
+                narg = ((pi_coeff + S.Half) % 1 - S.Half)*pi
+                # see cos() to specify which expressions should  be
+                # expanded automatically in terms of radicals
+                cresult, sresult = cos(narg), cos(narg - pi/2)
+                if not isinstance(cresult, cos) \
+                        and not isinstance(sresult, cos):
+                    if cresult == 0:
+                        return S.ComplexInfinity
+                    return (sresult/cresult)
+                if narg != arg:
+                    return cls(narg)
+
+        if arg.is_Add:
+            x, m = _peeloff_pi(arg)
+            if m:
+                tanm = tan(m*pi)
+                if tanm is S.ComplexInfinity:
+                    return -cot(x)
+                else: # tanm == 0
+                    return tan(x)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, atan):
+            return arg.args[0]
+
+        if isinstance(arg, atan2):
+            y, x = arg.args
+            return y/x
+
+        if isinstance(arg, asin):
+            x = arg.args[0]
+            return x/sqrt(1 - x**2)
+
+        if isinstance(arg, acos):
+            x = arg.args[0]
+            return sqrt(1 - x**2)/x
+
+        if isinstance(arg, acot):
+            x = arg.args[0]
+            return 1/x
+
+        if isinstance(arg, acsc):
+            x = arg.args[0]
+            return 1/(sqrt(1 - 1/x**2)*x)
+
+        if isinstance(arg, asec):
+            x = arg.args[0]
+            return sqrt(1 - 1/x**2)*x
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            a, b = ((n - 1)//2), 2**(n + 1)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return S.NegativeOne**a*b*(b - 1)*B/F*x**n
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        i = self.args[0].limit(x, 0)*2/pi
+        if i and i.is_Integer:
+            return self.rewrite(cos)._eval_nseries(x, n=n, logx=logx)
+        return super()._eval_nseries(x, n=n, logx=logx)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if isinstance(arg, log):
+            I = S.ImaginaryUnit
+            x = arg.args[0]
+            return I*(x**-I - x**I)/(x**-I + x**I)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        re, im = self._as_real_imag(deep=deep, **hints)
+        if im:
+            from sympy.functions.elementary.hyperbolic import cosh, sinh
+            denom = cos(2*re) + cosh(2*im)
+            return (sin(2*re)/denom, sinh(2*im)/denom)
+        else:
+            return (self.func(re), S.Zero)
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        x = None
+        if arg.is_Add:
+            n = len(arg.args)
+            TX = []
+            for x in arg.args:
+                tx = tan(x, evaluate=False)._eval_expand_trig()
+                TX.append(tx)
+
+            Yg = numbered_symbols('Y')
+            Y = [ next(Yg) for i in range(n) ]
+
+            p = [0, 0]
+            for i in range(n + 1):
+                p[1 - i % 2] += symmetric_poly(i, Y)*(-1)**((i % 4)//2)
+            return (p[0]/p[1]).subs(list(zip(Y, TX)))
+
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer and coeff > 1:
+                I = S.ImaginaryUnit
+                z = Symbol('dummy', real=True)
+                P = ((1 + I*z)**coeff).expand()
+                return (im(P)/re(P)).subs([(z, tan(terms))])
+        return tan(arg)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        I = S.ImaginaryUnit
+        from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+        if isinstance(arg, (TrigonometricFunction, HyperbolicFunction)):
+            arg = arg.func(arg.args[0]).rewrite(exp)
+        neg_exp, pos_exp = exp(-arg*I), exp(arg*I)
+        return I*(neg_exp - pos_exp)/(neg_exp + pos_exp)
+
+    def _eval_rewrite_as_sin(self, x, **kwargs):
+        return 2*sin(x)**2/sin(2*x)
+
+    def _eval_rewrite_as_cos(self, x, **kwargs):
+        return cos(x - pi/2, evaluate=False)/cos(x)
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return sin(arg)/cos(arg)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        return 1/cot(arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        sin_in_sec_form = sin(arg).rewrite(sec, **kwargs)
+        cos_in_sec_form = cos(arg).rewrite(sec, **kwargs)
+        return sin_in_sec_form/cos_in_sec_form
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        sin_in_csc_form = sin(arg).rewrite(csc, **kwargs)
+        cos_in_csc_form = cos(arg).rewrite(csc, **kwargs)
+        return sin_in_csc_form/cos_in_csc_form
+
+    def _eval_rewrite_as_pow(self, arg, **kwargs):
+        y = self.rewrite(cos, **kwargs).rewrite(pow, **kwargs)
+        if y.has(cos):
+            return None
+        return y
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        y = self.rewrite(cos, **kwargs).rewrite(sqrt, **kwargs)
+        if y.has(cos):
+            return None
+        return y
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return besselj(S.Half, arg)/besselj(-S.Half, arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.functions.elementary.complexes import re
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = 2*x0/pi
+        if n.is_integer:
+            lt = (arg - n*pi/2).as_leading_term(x)
+            return lt if n.is_even else -1/lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in (S.Infinity, S.NegativeInfinity):
+            return AccumBounds(S.NegativeInfinity, S.Infinity)
+        return self.func(x0) if x0.is_finite else self
+
+    def _eval_is_extended_real(self):
+        # FIXME: currently tan(pi/2) return zoo
+        return self.args[0].is_extended_real
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real and (arg/pi - S.Half).is_integer is False:
+            return True
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+
+        if arg.is_real and (arg/pi - S.Half).is_integer is False:
+            return True
+
+        if arg.is_imaginary:
+            return True
+
+    def _eval_is_zero(self):
+        rest, pi_mult = _peeloff_pi(self.args[0])
+        if rest.is_zero:
+            return pi_mult.is_integer
+
+    def _eval_is_complex(self):
+        arg = self.args[0]
+
+        if arg.is_real and (arg/pi - S.Half).is_integer is False:
+            return True
+
+
+class cot(TrigonometricFunction):
+    """
+    The cotangent function.
+
+    Returns the cotangent of x (measured in radians).
+
+    Explanation
+    ===========
+
+    See :class:`sin` for notes about automatic evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import cot, pi
+    >>> from sympy.abc import x
+    >>> cot(x**2).diff(x)
+    2*x*(-cot(x**2)**2 - 1)
+    >>> cot(1).diff(x)
+    0
+    >>> cot(pi/12)
+    sqrt(3) + 2
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Cot
+
+    """
+
+    def period(self, symbol=None):
+        return self._period(pi, symbol)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return S.NegativeOne - self**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return acot
+
+    @classmethod
+    def eval(cls, arg):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            if arg.is_zero:
+                return S.ComplexInfinity
+            elif arg in (S.Infinity, S.NegativeInfinity):
+                return AccumBounds(S.NegativeInfinity, S.Infinity)
+
+        if arg is S.ComplexInfinity:
+            return S.NaN
+
+        if isinstance(arg, AccumBounds):
+            return -tan(arg + pi/2)
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import coth
+            return -S.ImaginaryUnit*coth(i_coeff)
+
+        pi_coeff = _pi_coeff(arg, 2)
+        if pi_coeff is not None:
+            if pi_coeff.is_integer:
+                return S.ComplexInfinity
+
+            if not pi_coeff.is_Rational:
+                narg = pi_coeff*pi
+                if narg != arg:
+                    return cls(narg)
+                return None
+
+            if pi_coeff.is_Rational:
+                if pi_coeff.q in (5, 10):
+                    return tan(pi/2 - arg)
+                if pi_coeff.q > 2 and not pi_coeff.q % 2:
+                    narg = pi_coeff*pi*2
+                    cresult, sresult = cos(narg), cos(narg - pi/2)
+                    if not isinstance(cresult, cos) \
+                            and not isinstance(sresult, cos):
+                        return 1/sresult + cresult/sresult
+                q = pi_coeff.q
+                p = pi_coeff.p % q
+                table2 = _table2()
+                if q in table2:
+                    a, b = table2[q]
+                    nvala, nvalb = cls(p*pi/a), cls(p*pi/b)
+                    if None in (nvala, nvalb):
+                        return None
+                    return (1 + nvala*nvalb)/(nvalb - nvala)
+                narg = (((pi_coeff + S.Half) % 1) - S.Half)*pi
+                # see cos() to specify which expressions should be
+                # expanded automatically in terms of radicals
+                cresult, sresult = cos(narg), cos(narg - pi/2)
+                if not isinstance(cresult, cos) \
+                        and not isinstance(sresult, cos):
+                    if sresult == 0:
+                        return S.ComplexInfinity
+                    return cresult/sresult
+                if narg != arg:
+                    return cls(narg)
+
+        if arg.is_Add:
+            x, m = _peeloff_pi(arg)
+            if m:
+                cotm = cot(m*pi)
+                if cotm is S.ComplexInfinity:
+                    return cot(x)
+                else: # cotm == 0
+                    return -tan(x)
+
+        if arg.is_zero:
+            return S.ComplexInfinity
+
+        if isinstance(arg, acot):
+            return arg.args[0]
+
+        if isinstance(arg, atan):
+            x = arg.args[0]
+            return 1/x
+
+        if isinstance(arg, atan2):
+            y, x = arg.args
+            return x/y
+
+        if isinstance(arg, asin):
+            x = arg.args[0]
+            return sqrt(1 - x**2)/x
+
+        if isinstance(arg, acos):
+            x = arg.args[0]
+            return x/sqrt(1 - x**2)
+
+        if isinstance(arg, acsc):
+            x = arg.args[0]
+            return sqrt(1 - 1/x**2)*x
+
+        if isinstance(arg, asec):
+            x = arg.args[0]
+            return 1/(sqrt(1 - 1/x**2)*x)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return 1/sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+
+            B = bernoulli(n + 1)
+            F = factorial(n + 1)
+
+            return S.NegativeOne**((n + 1)//2)*2**(n + 1)*B/F*x**n
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        i = self.args[0].limit(x, 0)/pi
+        if i and i.is_Integer:
+            return self.rewrite(cos)._eval_nseries(x, n=n, logx=logx)
+        return self.rewrite(tan)._eval_nseries(x, n=n, logx=logx)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        re, im = self._as_real_imag(deep=deep, **hints)
+        if im:
+            from sympy.functions.elementary.hyperbolic import cosh, sinh
+            denom = cos(2*re) - cosh(2*im)
+            return (-sin(2*re)/denom, sinh(2*im)/denom)
+        else:
+            return (self.func(re), S.Zero)
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        from sympy.functions.elementary.hyperbolic import HyperbolicFunction
+        I = S.ImaginaryUnit
+        if isinstance(arg, (TrigonometricFunction, HyperbolicFunction)):
+            arg = arg.func(arg.args[0]).rewrite(exp, **kwargs)
+        neg_exp, pos_exp = exp(-arg*I), exp(arg*I)
+        return I*(pos_exp + neg_exp)/(pos_exp - neg_exp)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        if isinstance(arg, log):
+            I = S.ImaginaryUnit
+            x = arg.args[0]
+            return -I*(x**-I + x**I)/(x**-I - x**I)
+
+    def _eval_rewrite_as_sin(self, x, **kwargs):
+        return sin(2*x)/(2*(sin(x)**2))
+
+    def _eval_rewrite_as_cos(self, x, **kwargs):
+        return cos(x)/cos(x - pi/2, evaluate=False)
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return cos(arg)/sin(arg)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return 1/tan(arg)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        cos_in_sec_form = cos(arg).rewrite(sec, **kwargs)
+        sin_in_sec_form = sin(arg).rewrite(sec, **kwargs)
+        return cos_in_sec_form/sin_in_sec_form
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        cos_in_csc_form = cos(arg).rewrite(csc, **kwargs)
+        sin_in_csc_form = sin(arg).rewrite(csc, **kwargs)
+        return cos_in_csc_form/sin_in_csc_form
+
+    def _eval_rewrite_as_pow(self, arg, **kwargs):
+        y = self.rewrite(cos, **kwargs).rewrite(pow, **kwargs)
+        if y.has(cos):
+            return None
+        return y
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        y = self.rewrite(cos, **kwargs).rewrite(sqrt, **kwargs)
+        if y.has(cos):
+            return None
+        return y
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return besselj(-S.Half, arg)/besselj(S.Half, arg)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.functions.elementary.complexes import re
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = 2*x0/pi
+        if n.is_integer:
+            lt = (arg - n*pi/2).as_leading_term(x)
+            return 1/lt if n.is_even else -lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in (S.Infinity, S.NegativeInfinity):
+            return AccumBounds(S.NegativeInfinity, S.Infinity)
+        return self.func(x0) if x0.is_finite else self
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_expand_trig(self, **hints):
+        arg = self.args[0]
+        x = None
+        if arg.is_Add:
+            n = len(arg.args)
+            CX = []
+            for x in arg.args:
+                cx = cot(x, evaluate=False)._eval_expand_trig()
+                CX.append(cx)
+
+            Yg = numbered_symbols('Y')
+            Y = [ next(Yg) for i in range(n) ]
+
+            p = [0, 0]
+            for i in range(n, -1, -1):
+                p[(n - i) % 2] += symmetric_poly(i, Y)*(-1)**(((n - i) % 4)//2)
+            return (p[0]/p[1]).subs(list(zip(Y, CX)))
+        elif arg.is_Mul:
+            coeff, terms = arg.as_coeff_Mul(rational=True)
+            if coeff.is_Integer and coeff > 1:
+                I = S.ImaginaryUnit
+                z = Symbol('dummy', real=True)
+                P = ((z + I)**coeff).expand()
+                return (re(P)/im(P)).subs([(z, cot(terms))])
+        return cot(arg)  # XXX sec and csc return 1/cos and 1/sin
+
+    def _eval_is_finite(self):
+        arg = self.args[0]
+        if arg.is_real and (arg/pi).is_integer is False:
+            return True
+        if arg.is_imaginary:
+            return True
+
+    def _eval_is_real(self):
+        arg = self.args[0]
+        if arg.is_real and (arg/pi).is_integer is False:
+            return True
+
+    def _eval_is_complex(self):
+        arg = self.args[0]
+        if arg.is_real and (arg/pi).is_integer is False:
+            return True
+
+    def _eval_is_zero(self):
+        rest, pimult = _peeloff_pi(self.args[0])
+        if pimult and rest.is_zero:
+            return (pimult - S.Half).is_integer
+
+    def _eval_subs(self, old, new):
+        arg = self.args[0]
+        argnew = arg.subs(old, new)
+        if arg != argnew and (argnew/pi).is_integer:
+            return S.ComplexInfinity
+        return cot(argnew)
+
+
+class ReciprocalTrigonometricFunction(TrigonometricFunction):
+    """Base class for reciprocal functions of trigonometric functions. """
+
+    _reciprocal_of = None       # mandatory, to be defined in subclass
+    _singularities = (S.ComplexInfinity,)
+
+    # _is_even and _is_odd are used for correct evaluation of csc(-x), sec(-x)
+    # TODO refactor into TrigonometricFunction common parts of
+    # trigonometric functions eval() like even/odd, func(x+2*k*pi), etc.
+
+    # optional, to be defined in subclasses:
+    _is_even: FuzzyBool = None
+    _is_odd: FuzzyBool = None
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.could_extract_minus_sign():
+            if cls._is_even:
+                return cls(-arg)
+            if cls._is_odd:
+                return -cls(-arg)
+
+        pi_coeff = _pi_coeff(arg)
+        if (pi_coeff is not None
+            and not (2*pi_coeff).is_integer
+            and pi_coeff.is_Rational):
+                q = pi_coeff.q
+                p = pi_coeff.p % (2*q)
+                if p > q:
+                    narg = (pi_coeff - 1)*pi
+                    return -cls(narg)
+                if 2*p > q:
+                    narg = (1 - pi_coeff)*pi
+                    if cls._is_odd:
+                        return cls(narg)
+                    elif cls._is_even:
+                        return -cls(narg)
+
+        if hasattr(arg, 'inverse') and arg.inverse() == cls:
+            return arg.args[0]
+
+        t = cls._reciprocal_of.eval(arg)
+        if t is None:
+            return t
+        elif any(isinstance(i, cos) for i in (t, -t)):
+            return (1/t).rewrite(sec)
+        elif any(isinstance(i, sin) for i in (t, -t)):
+            return (1/t).rewrite(csc)
+        else:
+            return 1/t
+
+    def _call_reciprocal(self, method_name, *args, **kwargs):
+        # Calls method_name on _reciprocal_of
+        o = self._reciprocal_of(self.args[0])
+        return getattr(o, method_name)(*args, **kwargs)
+
+    def _calculate_reciprocal(self, method_name, *args, **kwargs):
+        # If calling method_name on _reciprocal_of returns a value != None
+        # then return the reciprocal of that value
+        t = self._call_reciprocal(method_name, *args, **kwargs)
+        return 1/t if t is not None else t
+
+    def _rewrite_reciprocal(self, method_name, arg):
+        # Special handling for rewrite functions. If reciprocal rewrite returns
+        # unmodified expression, then return None
+        t = self._call_reciprocal(method_name, arg)
+        if t is not None and t != self._reciprocal_of(arg):
+            return 1/t
+
+    def _period(self, symbol):
+        f = expand_mul(self.args[0])
+        return self._reciprocal_of(f).period(symbol)
+
+    def fdiff(self, argindex=1):
+        return -self._calculate_reciprocal("fdiff", argindex)/self**2
+
+    def _eval_rewrite_as_exp(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_exp", arg)
+
+    def _eval_rewrite_as_Pow(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_Pow", arg)
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_sin", arg)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_cos", arg)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_tan", arg)
+
+    def _eval_rewrite_as_pow(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_pow", arg)
+
+    def _eval_rewrite_as_sqrt(self, arg, **kwargs):
+        return self._rewrite_reciprocal("_eval_rewrite_as_sqrt", arg)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def as_real_imag(self, deep=True, **hints):
+        return (1/self._reciprocal_of(self.args[0])).as_real_imag(deep,
+                                                                  **hints)
+
+    def _eval_expand_trig(self, **hints):
+        return self._calculate_reciprocal("_eval_expand_trig", **hints)
+
+    def _eval_is_extended_real(self):
+        return self._reciprocal_of(self.args[0])._eval_is_extended_real()
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        return (1/self._reciprocal_of(self.args[0]))._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_finite(self):
+        return (1/self._reciprocal_of(self.args[0])).is_finite
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        return (1/self._reciprocal_of(self.args[0]))._eval_nseries(x, n, logx)
+
+
+class sec(ReciprocalTrigonometricFunction):
+    """
+    The secant function.
+
+    Returns the secant of x (measured in radians).
+
+    Explanation
+    ===========
+
+    See :class:`sin` for notes about automatic evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import sec
+    >>> from sympy.abc import x
+    >>> sec(x**2).diff(x)
+    2*x*tan(x**2)*sec(x**2)
+    >>> sec(1).diff(x)
+    0
+
+    See Also
+    ========
+
+    sin, csc, cos, tan, cot
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Sec
+
+    """
+
+    _reciprocal_of = cos
+    _is_even = True
+
+    def period(self, symbol=None):
+        return self._period(symbol)
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        cot_half_sq = cot(arg/2)**2
+        return (cot_half_sq + 1)/(cot_half_sq - 1)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return (1/cos(arg))
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return sin(arg)/(cos(arg)*sin(arg))
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return (1/cos(arg).rewrite(sin, **kwargs))
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return (1/cos(arg).rewrite(tan, **kwargs))
+
+    def _eval_rewrite_as_csc(self, arg, **kwargs):
+        return csc(pi/2 - arg, evaluate=False)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return tan(self.args[0])*sec(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return Piecewise(
+                (1/(sqrt(pi*arg)/(sqrt(2))*besselj(-S.Half, arg)), Ne(arg, 0)),
+                (1, True)
+            )
+
+    def _eval_is_complex(self):
+        arg = self.args[0]
+
+        if arg.is_complex and (arg/pi - S.Half).is_integer is False:
+            return True
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        # Reference Formula:
+        # https://functions.wolfram.com/ElementaryFunctions/Sec/06/01/02/01/
+        if n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = n//2
+            return S.NegativeOne**k*euler(2*k)/factorial(2*k)*x**(2*k)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.functions.elementary.complexes import re
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = (x0 + pi/2)/pi
+        if n.is_integer:
+            lt = (arg - n*pi + pi/2).as_leading_term(x)
+            return (S.NegativeOne**n)/lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in (S.Infinity, S.NegativeInfinity):
+            return AccumBounds(S.NegativeInfinity, S.Infinity)
+        return self.func(x0) if x0.is_finite else self
+
+
+class csc(ReciprocalTrigonometricFunction):
+    """
+    The cosecant function.
+
+    Returns the cosecant of x (measured in radians).
+
+    Explanation
+    ===========
+
+    See :func:`sin` for notes about automatic evaluation.
+
+    Examples
+    ========
+
+    >>> from sympy import csc
+    >>> from sympy.abc import x
+    >>> csc(x**2).diff(x)
+    -2*x*cot(x**2)*csc(x**2)
+    >>> csc(1).diff(x)
+    0
+
+    See Also
+    ========
+
+    sin, cos, sec, tan, cot
+    asin, acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.14
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/Csc
+
+    """
+
+    _reciprocal_of = sin
+    _is_odd = True
+
+    def period(self, symbol=None):
+        return self._period(symbol)
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return (1/sin(arg))
+
+    def _eval_rewrite_as_sincos(self, arg, **kwargs):
+        return cos(arg)/(sin(arg)*cos(arg))
+
+    def _eval_rewrite_as_cot(self, arg, **kwargs):
+        cot_half = cot(arg/2)
+        return (1 + cot_half**2)/(2*cot_half)
+
+    def _eval_rewrite_as_cos(self, arg, **kwargs):
+        return 1/sin(arg).rewrite(cos, **kwargs)
+
+    def _eval_rewrite_as_sec(self, arg, **kwargs):
+        return sec(pi/2 - arg, evaluate=False)
+
+    def _eval_rewrite_as_tan(self, arg, **kwargs):
+        return (1/sin(arg).rewrite(tan, **kwargs))
+
+    def _eval_rewrite_as_besselj(self, arg, **kwargs):
+        from sympy.functions.special.bessel import besselj
+        return sqrt(2/pi)*(1/(sqrt(arg)*besselj(S.Half, arg)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -cot(self.args[0])*csc(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_complex(self):
+        arg = self.args[0]
+        if arg.is_real and (arg/pi).is_integer is False:
+            return True
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return 1/sympify(x)
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = n//2 + 1
+            return (S.NegativeOne**(k - 1)*2*(2**(2*k - 1) - 1)*
+                    bernoulli(2*k)*x**(2*k - 1)/factorial(2*k))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.calculus.accumulationbounds import AccumBounds
+        from sympy.functions.elementary.complexes import re
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        n = x0/pi
+        if n.is_integer:
+            lt = (arg - n*pi).as_leading_term(x)
+            return (S.NegativeOne**n)/lt
+        if x0 is S.ComplexInfinity:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if x0 in (S.Infinity, S.NegativeInfinity):
+            return AccumBounds(S.NegativeInfinity, S.Infinity)
+        return self.func(x0) if x0.is_finite else self
+
+
+class sinc(DefinedFunction):
+    r"""
+    Represents an unnormalized sinc function:
+
+    .. math::
+
+        \operatorname{sinc}(x) =
+        \begin{cases}
+          \frac{\sin x}{x} & \qquad x \neq 0 \\
+          1 & \qquad x = 0
+        \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy import sinc, oo, jn
+    >>> from sympy.abc import x
+    >>> sinc(x)
+    sinc(x)
+
+    * Automated Evaluation
+
+    >>> sinc(0)
+    1
+    >>> sinc(oo)
+    0
+
+    * Differentiation
+
+    >>> sinc(x).diff()
+    cos(x)/x - sin(x)/x**2
+
+    * Series Expansion
+
+    >>> sinc(x).series()
+    1 - x**2/6 + x**4/120 + O(x**6)
+
+    * As zero'th order spherical Bessel Function
+
+    >>> sinc(x).rewrite(jn)
+    jn(0, x)
+
+    See also
+    ========
+
+    sin
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Sinc_function
+
+    """
+    _singularities = (S.ComplexInfinity,)
+
+    def fdiff(self, argindex=1):
+        x = self.args[0]
+        if argindex == 1:
+            # We would like to return the Piecewise here, but Piecewise.diff
+            # currently can't handle removable singularities, meaning things
+            # like sinc(x).diff(x, 2) give the wrong answer at x = 0. See
+            # https://github.com/sympy/sympy/issues/11402.
+            #
+            # return Piecewise(((x*cos(x) - sin(x))/x**2, Ne(x, S.Zero)), (S.Zero, S.true))
+            return cos(x)/x - sin(x)/x**2
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_zero:
+            return S.One
+        if arg.is_Number:
+            if arg in [S.Infinity, S.NegativeInfinity]:
+                return S.Zero
+            elif arg is S.NaN:
+                return S.NaN
+
+        if arg is S.ComplexInfinity:
+            return S.NaN
+
+        if arg.could_extract_minus_sign():
+            return cls(-arg)
+
+        pi_coeff = _pi_coeff(arg)
+        if pi_coeff is not None:
+            if pi_coeff.is_integer:
+                if fuzzy_not(arg.is_zero):
+                    return S.Zero
+            elif (2*pi_coeff).is_integer:
+                return S.NegativeOne**(pi_coeff - S.Half)/arg
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x = self.args[0]
+        return (sin(x)/x)._eval_nseries(x, n, logx)
+
+    def _eval_rewrite_as_jn(self, arg, **kwargs):
+        from sympy.functions.special.bessel import jn
+        return jn(0, arg)
+
+    def _eval_rewrite_as_sin(self, arg, **kwargs):
+        return Piecewise((sin(arg)/arg, Ne(arg, S.Zero)), (S.One, S.true))
+
+    def _eval_is_zero(self):
+        if self.args[0].is_infinite:
+            return True
+        rest, pi_mult = _peeloff_pi(self.args[0])
+        if rest.is_zero:
+            return fuzzy_and([pi_mult.is_integer, pi_mult.is_nonzero])
+        if rest.is_Number and pi_mult.is_integer:
+            return False
+
+    def _eval_is_real(self):
+        if self.args[0].is_extended_real or self.args[0].is_imaginary:
+            return True
+
+    _eval_is_finite = _eval_is_real
+
+
+###############################################################################
+########################### TRIGONOMETRIC INVERSES ############################
+###############################################################################
+
+
+class InverseTrigonometricFunction(DefinedFunction):
+    """Base class for inverse trigonometric functions."""
+    _singularities: tuple[Expr, ...] = (S.One, S.NegativeOne, S.Zero, S.ComplexInfinity)
+
+    @staticmethod
+    @cacheit
+    def _asin_table():
+        # Only keys with could_extract_minus_sign() == False
+        # are actually needed.
+        return {
+            sqrt(3)/2: pi/3,
+            sqrt(2)/2: pi/4,
+            1/sqrt(2): pi/4,
+            sqrt((5 - sqrt(5))/8): pi/5,
+            sqrt(2)*sqrt(5 - sqrt(5))/4: pi/5,
+            sqrt((5 + sqrt(5))/8): pi*Rational(2, 5),
+            sqrt(2)*sqrt(5 + sqrt(5))/4: pi*Rational(2, 5),
+            S.Half: pi/6,
+            sqrt(2 - sqrt(2))/2: pi/8,
+            sqrt(S.Half - sqrt(2)/4): pi/8,
+            sqrt(2 + sqrt(2))/2: pi*Rational(3, 8),
+            sqrt(S.Half + sqrt(2)/4): pi*Rational(3, 8),
+            (sqrt(5) - 1)/4: pi/10,
+            (1 - sqrt(5))/4: -pi/10,
+            (sqrt(5) + 1)/4: pi*Rational(3, 10),
+            sqrt(6)/4 - sqrt(2)/4: pi/12,
+            -sqrt(6)/4 + sqrt(2)/4: -pi/12,
+            (sqrt(3) - 1)/sqrt(8): pi/12,
+            (1 - sqrt(3))/sqrt(8): -pi/12,
+            sqrt(6)/4 + sqrt(2)/4: pi*Rational(5, 12),
+            (1 + sqrt(3))/sqrt(8): pi*Rational(5, 12)
+        }
+
+
+    @staticmethod
+    @cacheit
+    def _atan_table():
+        # Only keys with could_extract_minus_sign() == False
+        # are actually needed.
+        return {
+            sqrt(3)/3: pi/6,
+            1/sqrt(3): pi/6,
+            sqrt(3): pi/3,
+            sqrt(2) - 1: pi/8,
+            1 - sqrt(2): -pi/8,
+            1 + sqrt(2): pi*Rational(3, 8),
+            sqrt(5 - 2*sqrt(5)): pi/5,
+            sqrt(5 + 2*sqrt(5)): pi*Rational(2, 5),
+            sqrt(1 - 2*sqrt(5)/5): pi/10,
+            sqrt(1 + 2*sqrt(5)/5): pi*Rational(3, 10),
+            2 - sqrt(3): pi/12,
+            -2 + sqrt(3): -pi/12,
+            2 + sqrt(3): pi*Rational(5, 12)
+        }
+
+    @staticmethod
+    @cacheit
+    def _acsc_table():
+        # Keys for which could_extract_minus_sign()
+        # will obviously return True are omitted.
+        return {
+            2*sqrt(3)/3: pi/3,
+            sqrt(2): pi/4,
+            sqrt(2 + 2*sqrt(5)/5): pi/5,
+            1/sqrt(Rational(5, 8) - sqrt(5)/8): pi/5,
+            sqrt(2 - 2*sqrt(5)/5): pi*Rational(2, 5),
+            1/sqrt(Rational(5, 8) + sqrt(5)/8): pi*Rational(2, 5),
+            2: pi/6,
+            sqrt(4 + 2*sqrt(2)): pi/8,
+            2/sqrt(2 - sqrt(2)): pi/8,
+            sqrt(4 - 2*sqrt(2)): pi*Rational(3, 8),
+            2/sqrt(2 + sqrt(2)): pi*Rational(3, 8),
+            1 + sqrt(5): pi/10,
+            sqrt(5) - 1: pi*Rational(3, 10),
+            -(sqrt(5) - 1): pi*Rational(-3, 10),
+            sqrt(6) + sqrt(2): pi/12,
+            sqrt(6) - sqrt(2): pi*Rational(5, 12),
+            -(sqrt(6) - sqrt(2)): pi*Rational(-5, 12)
+        }
+
+
+class asin(InverseTrigonometricFunction):
+    r"""
+    The inverse sine function.
+
+    Returns the arcsine of x in radians.
+
+    Explanation
+    ===========
+
+    ``asin(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, 0, 1, -1\}$ and for some instances when the
+    result is a rational multiple of $\pi$ (see the ``eval`` class method).
+
+    A purely imaginary argument will lead to an asinh expression.
+
+    Examples
+    ========
+
+    >>> from sympy import asin, oo
+    >>> asin(1)
+    pi/2
+    >>> asin(-1)
+    -pi/2
+    >>> asin(-oo)
+    oo*I
+    >>> asin(oo)
+    -oo*I
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    acsc, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.23
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcSin
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/sqrt(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if s.args[0].is_rational:
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_positive(self):
+        return self._eval_is_extended_real() and self.args[0].is_positive
+
+    def _eval_is_negative(self):
+        return self._eval_is_extended_real() and self.args[0].is_negative
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.NegativeInfinity*S.ImaginaryUnit
+            elif arg is S.NegativeInfinity:
+                return S.Infinity*S.ImaginaryUnit
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return pi/2
+            elif arg is S.NegativeOne:
+                return -pi/2
+
+        if arg is S.ComplexInfinity:
+            return S.ComplexInfinity
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        if arg.is_number:
+            asin_table = cls._asin_table()
+            if arg in asin_table:
+                return asin_table[arg]
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import asinh
+            return S.ImaginaryUnit*asinh(i_coeff)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, sin):
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang %= 2*pi # restrict to [0,2*pi)
+                if ang > pi: # restrict to (-pi,pi]
+                    ang = pi - ang
+
+                # restrict to [-pi/2,pi/2]
+                if ang > pi/2:
+                    ang = pi - ang
+                if ang < -pi/2:
+                    ang = -pi - ang
+
+                return ang
+
+        if isinstance(arg, cos): # acos(x) + asin(x) = pi/2
+            ang = arg.args[0]
+            if ang.is_comparable:
+                return pi/2 - acos(arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return p*(n - 2)**2/(n*(n - 1))*x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return R/F*x**n/n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        # Handling points lying on branch cuts (-oo, -1) U (1, oo)
+        if (1 - x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_negative:
+                    return -pi - self.func(x0)
+            elif im(ndir).is_positive:
+                if x0.is_positive:
+                    return pi - self.func(x0)
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asin
+        from sympy.series.order import O
+        arg0 = self.args[0].subs(x, 0)
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = asin(S.One - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = asin(S.NegativeOne + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else -pi/2 + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+        # Handling points lying on branch cuts (-oo, -1) U (1, oo)
+        if (1 - arg0**2).is_negative:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_negative:
+                    return -pi - res
+            elif im(ndir).is_positive:
+                if arg0.is_positive:
+                    return pi - res
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_acos(self, x, **kwargs):
+        return pi/2 - acos(x)
+
+    def _eval_rewrite_as_atan(self, x, **kwargs):
+        return 2*atan(x/(1 + sqrt(1 - x**2)))
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return -S.ImaginaryUnit*log(S.ImaginaryUnit*x + sqrt(1 - x**2))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_acot(self, arg, **kwargs):
+        return 2*acot((1 + sqrt(1 - arg**2))/arg)
+
+    def _eval_rewrite_as_asec(self, arg, **kwargs):
+        return pi/2 - asec(1/arg)
+
+    def _eval_rewrite_as_acsc(self, arg, **kwargs):
+        return acsc(1/arg)
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        return x.is_extended_real and (1 - abs(x)).is_nonnegative
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sin
+
+
+class acos(InverseTrigonometricFunction):
+    r"""
+    The inverse cosine function.
+
+    Explanation
+    ===========
+
+    Returns the arc cosine of x (measured in radians).
+
+    ``acos(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, 0, 1, -1\}$ and for some instances when
+    the result is a rational multiple of $\pi$ (see the eval class method).
+
+    ``acos(zoo)`` evaluates to ``zoo``
+    (see note in :class:`sympy.functions.elementary.trigonometric.asec`)
+
+    A purely imaginary argument will be rewritten to asinh.
+
+    Examples
+    ========
+
+    >>> from sympy import acos, oo
+    >>> acos(1)
+    0
+    >>> acos(0)
+    pi/2
+    >>> acos(oo)
+    oo*I
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acsc, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.23
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcCos
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/sqrt(1 - self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if s.args[0].is_rational:
+                return False
+        else:
+            return s.is_rational
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity*S.ImaginaryUnit
+            elif arg is S.NegativeInfinity:
+                return S.NegativeInfinity*S.ImaginaryUnit
+            elif arg.is_zero:
+                return pi/2
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi
+
+        if arg is S.ComplexInfinity:
+            return S.ComplexInfinity
+
+        if arg.is_number:
+            asin_table = cls._asin_table()
+            if arg in asin_table:
+                return pi/2 - asin_table[arg]
+            elif -arg in asin_table:
+                return pi/2 + asin_table[-arg]
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            return pi/2 - asin(arg)
+
+        if arg.is_Mul and len(arg.args) == 2 and arg.args[0] == -1:
+            narg = arg.args[1]
+            minus = True
+        else:
+            narg = arg
+            minus = False
+
+        if isinstance(narg, cos):
+            # acos(cos(x)) = x or acos(-cos(x)) = pi - x
+            ang = narg.args[0]
+            if ang.is_comparable:
+                if minus:
+                    ang = pi - ang
+                ang %= 2*pi # restrict to [0,2*pi)
+                if ang > pi: # restrict to [0,pi]
+                    ang = 2*pi - ang
+                return ang
+
+        if isinstance(narg, sin): # acos(x) + asin(x) = pi/2
+            ang = narg.args[0]
+            if ang.is_comparable:
+                if minus:
+                    return pi/2 + asin(narg)
+                return pi/2 - asin(narg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return pi/2
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) >= 2 and n > 2:
+                p = previous_terms[-2]
+                return p*(n - 2)**2/(n*(n - 1))*x**2
+            else:
+                k = (n - 1) // 2
+                R = RisingFactorial(S.Half, k)
+                F = factorial(k)
+                return -R/F*x**n/n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        # Handling branch points
+        if x0 == 1:
+            return sqrt(2)*sqrt((S.One - arg).as_leading_term(x))
+        if x0 in (-S.One, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-oo, -1) U (1, oo)
+        if (1 - x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_negative:
+                    return 2*pi - self.func(x0)
+            elif im(ndir).is_positive:
+                if x0.is_positive:
+                    return -self.func(x0)
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        return x.is_extended_real and (1 - abs(x)).is_nonnegative
+
+    def _eval_is_nonnegative(self):
+        return self._eval_is_extended_real()
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acos
+        from sympy.series.order import O
+        arg0 = self.args[0].subs(x, 0)
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = acos(S.One - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = acos(S.NegativeOne + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.One + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            if not g.is_meromorphic(x, 0):   # cannot be expanded
+                return O(1) if n == 0 else pi + O(sqrt(x))
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+        # Handling points lying on branch cuts (-oo, -1) U (1, oo)
+        if (1 - arg0**2).is_negative:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_negative:
+                    return 2*pi - res
+            elif im(ndir).is_positive:
+                if arg0.is_positive:
+                    return -res
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return pi/2 + S.ImaginaryUnit*\
+            log(S.ImaginaryUnit*x + sqrt(1 - x**2))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asin(self, x, **kwargs):
+        return pi/2 - asin(x)
+
+    def _eval_rewrite_as_atan(self, x, **kwargs):
+        return atan(sqrt(1 - x**2)/x) + (pi/2)*(1 - x*sqrt(1/x**2))
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return cos
+
+    def _eval_rewrite_as_acot(self, arg, **kwargs):
+        return pi/2 - 2*acot((1 + sqrt(1 - arg**2))/arg)
+
+    def _eval_rewrite_as_asec(self, arg, **kwargs):
+        return asec(1/arg)
+
+    def _eval_rewrite_as_acsc(self, arg, **kwargs):
+        return pi/2 - acsc(1/arg)
+
+    def _eval_conjugate(self):
+        z = self.args[0]
+        r = self.func(self.args[0].conjugate())
+        if z.is_extended_real is False:
+            return r
+        elif z.is_extended_real and (z + 1).is_nonnegative and (z - 1).is_nonpositive:
+            return r
+
+
+class atan(InverseTrigonometricFunction):
+    r"""
+    The inverse tangent function.
+
+    Returns the arc tangent of x (measured in radians).
+
+    Explanation
+    ===========
+
+    ``atan(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, 0, 1, -1\}$ and for some instances when the
+    result is a rational multiple of $\pi$ (see the eval class method).
+
+    Examples
+    ========
+
+    >>> from sympy import atan, oo
+    >>> atan(0)
+    0
+    >>> atan(1)
+    pi/4
+    >>> atan(oo)
+    pi/2
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acsc, acos, asec, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.23
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcTan
+
+    """
+
+    args: tuple[Expr]
+
+    _singularities = (S.ImaginaryUnit, -S.ImaginaryUnit)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(1 + self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if s.args[0].is_rational:
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_positive(self):
+        return self.args[0].is_extended_positive
+
+    def _eval_is_nonnegative(self):
+        return self.args[0].is_extended_nonnegative
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_is_real(self):
+        return self.args[0].is_extended_real
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return pi/2
+            elif arg is S.NegativeInfinity:
+                return -pi/2
+            elif arg.is_zero:
+                return S.Zero
+            elif arg is S.One:
+                return pi/4
+            elif arg is S.NegativeOne:
+                return -pi/4
+
+        if arg is S.ComplexInfinity:
+            from sympy.calculus.accumulationbounds import AccumBounds
+            return AccumBounds(-pi/2, pi/2)
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        if arg.is_number:
+            atan_table = cls._atan_table()
+            if arg in atan_table:
+                return atan_table[arg]
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import atanh
+            return S.ImaginaryUnit*atanh(i_coeff)
+
+        if arg.is_zero:
+            return S.Zero
+
+        if isinstance(arg, tan):
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang %= pi # restrict to [0,pi)
+                if ang > pi/2: # restrict to [-pi/2,pi/2]
+                    ang -= pi
+
+                return ang
+
+        if isinstance(arg, cot): # atan(x) + acot(x) = pi/2
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang = pi/2 - acot(arg)
+                if ang > pi/2: # restrict to [-pi/2,pi/2]
+                    ang -= pi
+                return ang
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return S.NegativeOne**((n - 1)//2)*x**n/n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        if x0.is_zero:
+            return arg.as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.ImaginaryUnit, S.ImaginaryUnit, S.ComplexInfinity):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + x0**2).is_negative:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_negative:
+                if im(x0).is_positive:
+                    return self.func(x0) - pi
+            elif re(ndir).is_positive:
+                if im(x0).is_negative:
+                    return self.func(x0) + pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # atan
+        arg0 = self.args[0].subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.ImaginaryUnit, S.NegativeOne*S.ImaginaryUnit):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        ndir = self.args[0].dir(x, cdir if cdir else 1)
+        if arg0 is S.ComplexInfinity:
+            if re(ndir) > 0:
+                return res - pi
+            return res
+        # Handling points lying on branch cuts (-I*oo, -I) U (I, I*oo)
+        if (1 + arg0**2).is_negative:
+            if re(ndir).is_negative:
+                if im(arg0).is_positive:
+                    return res - pi
+            elif re(ndir).is_positive:
+                if im(arg0).is_negative:
+                    return res + pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return S.ImaginaryUnit/2*(log(S.One - S.ImaginaryUnit*x)
+            - log(S.One + S.ImaginaryUnit*x))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_aseries(self, n, args0, x, logx):
+        if args0[0] in [S.Infinity, S.NegativeInfinity]:
+            return (pi/2 - atan(1/self.args[0]))._eval_nseries(x, n, logx)
+        else:
+            return super()._eval_aseries(n, args0, x, logx)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return tan
+
+    def _eval_rewrite_as_asin(self, arg, **kwargs):
+        return sqrt(arg**2)/arg*(pi/2 - asin(1/sqrt(1 + arg**2)))
+
+    def _eval_rewrite_as_acos(self, arg, **kwargs):
+        return sqrt(arg**2)/arg*acos(1/sqrt(1 + arg**2))
+
+    def _eval_rewrite_as_acot(self, arg, **kwargs):
+        return acot(1/arg)
+
+    def _eval_rewrite_as_asec(self, arg, **kwargs):
+        return sqrt(arg**2)/arg*asec(sqrt(1 + arg**2))
+
+    def _eval_rewrite_as_acsc(self, arg, **kwargs):
+        return sqrt(arg**2)/arg*(pi/2 - acsc(sqrt(1 + arg**2)))
+
+
+class acot(InverseTrigonometricFunction):
+    r"""
+    The inverse cotangent function.
+
+    Returns the arc cotangent of x (measured in radians).
+
+    Explanation
+    ===========
+
+    ``acot(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, \tilde{\infty}, 0, 1, -1\}$
+    and for some instances when the result is a rational multiple of $\pi$
+    (see the eval class method).
+
+    A purely imaginary argument will lead to an ``acoth`` expression.
+
+    ``acot(x)`` has a branch cut along $(-i, i)$, hence it is discontinuous
+    at 0. Its range for real $x$ is $(-\frac{\pi}{2}, \frac{\pi}{2}]$.
+
+    Examples
+    ========
+
+    >>> from sympy import acot, sqrt
+    >>> acot(0)
+    pi/2
+    >>> acot(1)
+    pi/4
+    >>> acot(sqrt(3) - 2)
+    -5*pi/12
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acsc, acos, asec, atan, atan2
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/4.23
+    .. [2] https://functions.wolfram.com/ElementaryFunctions/ArcCot
+
+    """
+    _singularities = (S.ImaginaryUnit, -S.ImaginaryUnit)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/(1 + self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_rational(self):
+        s = self.func(*self.args)
+        if s.func == self.func:
+            if s.args[0].is_rational:
+                return False
+        else:
+            return s.is_rational
+
+    def _eval_is_positive(self):
+        return self.args[0].is_nonnegative
+
+    def _eval_is_negative(self):
+        return self.args[0].is_negative
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return pi/ 2
+            elif arg is S.One:
+                return pi/4
+            elif arg is S.NegativeOne:
+                return -pi/4
+
+        if arg is S.ComplexInfinity:
+            return S.Zero
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        if arg.is_number:
+            atan_table = cls._atan_table()
+            if arg in atan_table:
+                ang = pi/2 - atan_table[arg]
+                if ang > pi/2: # restrict to (-pi/2,pi/2]
+                    ang -= pi
+                return ang
+
+        i_coeff = _imaginary_unit_as_coefficient(arg)
+        if i_coeff is not None:
+            from sympy.functions.elementary.hyperbolic import acoth
+            return -S.ImaginaryUnit*acoth(i_coeff)
+
+        if arg.is_zero:
+            return pi*S.Half
+
+        if isinstance(arg, cot):
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang %= pi # restrict to [0,pi)
+                if ang > pi/2: # restrict to (-pi/2,pi/2]
+                    ang -= pi
+                return ang
+
+        if isinstance(arg, tan): # atan(x) + acot(x) = pi/2
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang = pi/2 - atan(arg)
+                if ang > pi/2: # restrict to (-pi/2,pi/2]
+                    ang -= pi
+                return ang
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return pi/2  # FIX THIS
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            return S.NegativeOne**((n + 1)//2)*x**n/n
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling branch points
+        if x0 in (-S.ImaginaryUnit, S.ImaginaryUnit, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        # Handling points lying on branch cuts [-I, I]
+        if x0.is_imaginary and (1 + x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if re(ndir).is_positive:
+                if im(x0).is_positive:
+                    return self.func(x0) + pi
+            elif re(ndir).is_negative:
+                if im(x0).is_negative:
+                    return self.func(x0) - pi
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acot
+        arg0 = self.args[0].subs(x, 0)
+
+        # Handling branch points
+        if arg0 in (S.ImaginaryUnit, S.NegativeOne*S.ImaginaryUnit):
+            return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+        ndir = self.args[0].dir(x, cdir if cdir else 1)
+        if arg0.is_zero:
+            if re(ndir) < 0:
+                return res - pi
+            return res
+        # Handling points lying on branch cuts [-I, I]
+        if arg0.is_imaginary and (1 + arg0**2).is_positive:
+            if re(ndir).is_positive:
+                if im(arg0).is_positive:
+                    return res + pi
+            elif re(ndir).is_negative:
+                if im(arg0).is_negative:
+                    return res - pi
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_aseries(self, n, args0, x, logx):
+        if args0[0] in [S.Infinity, S.NegativeInfinity]:
+            return atan(1/self.args[0])._eval_nseries(x, n, logx)
+        else:
+            return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_log(self, x, **kwargs):
+        return S.ImaginaryUnit/2*(log(1 - S.ImaginaryUnit/x)
+            - log(1 + S.ImaginaryUnit/x))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return cot
+
+    def _eval_rewrite_as_asin(self, arg, **kwargs):
+        return (arg*sqrt(1/arg**2)*
+                (pi/2 - asin(sqrt(-arg**2)/sqrt(-arg**2 - 1))))
+
+    def _eval_rewrite_as_acos(self, arg, **kwargs):
+        return arg*sqrt(1/arg**2)*acos(sqrt(-arg**2)/sqrt(-arg**2 - 1))
+
+    def _eval_rewrite_as_atan(self, arg, **kwargs):
+        return atan(1/arg)
+
+    def _eval_rewrite_as_asec(self, arg, **kwargs):
+        return arg*sqrt(1/arg**2)*asec(sqrt((1 + arg**2)/arg**2))
+
+    def _eval_rewrite_as_acsc(self, arg, **kwargs):
+        return arg*sqrt(1/arg**2)*(pi/2 - acsc(sqrt((1 + arg**2)/arg**2)))
+
+
+class asec(InverseTrigonometricFunction):
+    r"""
+    The inverse secant function.
+
+    Returns the arc secant of x (measured in radians).
+
+    Explanation
+    ===========
+
+    ``asec(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, 0, 1, -1\}$ and for some instances when the
+    result is a rational multiple of $\pi$ (see the eval class method).
+
+    ``asec(x)`` has branch cut in the interval $[-1, 1]$. For complex arguments,
+    it can be defined [4]_ as
+
+    .. math::
+        \operatorname{sec^{-1}}(z) = -i\frac{\log\left(\sqrt{1 - z^2} + 1\right)}{z}
+
+    At ``x = 0``, for positive branch cut, the limit evaluates to ``zoo``. For
+    negative branch cut, the limit
+
+    .. math::
+        \lim_{z \to 0}-i\frac{\log\left(-\sqrt{1 - z^2} + 1\right)}{z}
+
+    simplifies to :math:`-i\log\left(z/2 + O\left(z^3\right)\right)` which
+    ultimately evaluates to ``zoo``.
+
+    As ``acos(x) = asec(1/x)``, a similar argument can be given for
+    ``acos(x)``.
+
+    Examples
+    ========
+
+    >>> from sympy import asec, oo
+    >>> asec(1)
+    0
+    >>> asec(-1)
+    pi
+    >>> asec(0)
+    zoo
+    >>> asec(-oo)
+    pi/2
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acsc, acos, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.23
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcSec
+    .. [4] https://reference.wolfram.com/language/ref/ArcSec.html
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_zero:
+            return S.ComplexInfinity
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.One:
+                return S.Zero
+            elif arg is S.NegativeOne:
+                return pi
+        if arg in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+            return pi/2
+
+        if arg.is_number:
+            acsc_table = cls._acsc_table()
+            if arg in acsc_table:
+                return pi/2 - acsc_table[arg]
+            elif -arg in acsc_table:
+                return pi/2 + acsc_table[-arg]
+
+        if arg.is_infinite:
+            return pi/2
+
+        if arg.is_Mul and len(arg.args) == 2 and arg.args[0] == -1:
+            narg = arg.args[1]
+            minus = True
+        else:
+            narg = arg
+            minus = False
+
+        if isinstance(narg, sec):
+            # asec(sec(x)) = x or asec(-sec(x)) = pi - x
+            ang = narg.args[0]
+            if ang.is_comparable:
+                if minus:
+                    ang = pi - ang
+                ang %= 2*pi # restrict to [0,2*pi)
+                if ang > pi: # restrict to [0,pi]
+                    ang = 2*pi - ang
+                return ang
+
+        if isinstance(narg, csc): # asec(x) + acsc(x) = pi/2
+            ang = narg.args[0]
+            if ang.is_comparable:
+                if minus:
+                    pi/2 + acsc(narg)
+                return pi/2 - acsc(narg)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 1/(self.args[0]**2*sqrt(1 - 1/self.args[0]**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return sec
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return S.ImaginaryUnit*log(2 / x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) *  n
+                F = factorial(k) * n // 2 * n // 2
+                return -S.ImaginaryUnit * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        # Handling branch points
+        if x0 == 1:
+            return sqrt(2)*sqrt((arg - S.One).as_leading_term(x))
+        if x0 in (-S.One, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        # Handling points lying on branch cuts (-1, 1)
+        if x0.is_real and (1 - x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_positive:
+                    return -self.func(x0)
+            elif im(ndir).is_positive:
+                if x0.is_negative:
+                    return 2*pi - self.func(x0)
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # asec
+        from sympy.series.order import O
+        arg0 = self.args[0].subs(x, 0)
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = asec(S.One + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.NegativeOne + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = asec(S.NegativeOne - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.NegativeOne - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+        # Handling points lying on branch cuts (-1, 1)
+        if arg0.is_real and (1 - arg0**2).is_positive:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_positive:
+                    return -res
+            elif im(ndir).is_positive:
+                if arg0.is_negative:
+                    return 2*pi - res
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_is_extended_real(self):
+        x = self.args[0]
+        if x.is_extended_real is False:
+            return False
+        return fuzzy_or(((x - 1).is_nonnegative, (-x - 1).is_nonnegative))
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return pi/2 + S.ImaginaryUnit*log(S.ImaginaryUnit/arg + sqrt(1 - 1/arg**2))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asin(self, arg, **kwargs):
+        return pi/2 - asin(1/arg)
+
+    def _eval_rewrite_as_acos(self, arg, **kwargs):
+        return acos(1/arg)
+
+    def _eval_rewrite_as_atan(self, x, **kwargs):
+        sx2x = sqrt(x**2)/x
+        return pi/2*(1 - sx2x) + sx2x*atan(sqrt(x**2 - 1))
+
+    def _eval_rewrite_as_acot(self, x, **kwargs):
+        sx2x = sqrt(x**2)/x
+        return pi/2*(1 - sx2x) + sx2x*acot(1/sqrt(x**2 - 1))
+
+    def _eval_rewrite_as_acsc(self, arg, **kwargs):
+        return pi/2 - acsc(arg)
+
+
+class acsc(InverseTrigonometricFunction):
+    r"""
+    The inverse cosecant function.
+
+    Returns the arc cosecant of x (measured in radians).
+
+    Explanation
+    ===========
+
+    ``acsc(x)`` will evaluate automatically in the cases
+    $x \in \{\infty, -\infty, 0, 1, -1\}$` and for some instances when the
+    result is a rational multiple of $\pi$ (see the ``eval`` class method).
+
+    Examples
+    ========
+
+    >>> from sympy import acsc, oo
+    >>> acsc(1)
+    pi/2
+    >>> acsc(-1)
+    -pi/2
+    >>> acsc(oo)
+    0
+    >>> acsc(-oo) == acsc(oo)
+    True
+    >>> acsc(0)
+    zoo
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acos, asec, atan, acot, atan2
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://dlmf.nist.gov/4.23
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcCsc
+
+    """
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_zero:
+            return S.ComplexInfinity
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.One:
+                return pi/2
+            elif arg is S.NegativeOne:
+                return -pi/2
+        if arg in [S.Infinity, S.NegativeInfinity, S.ComplexInfinity]:
+            return S.Zero
+
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+        if arg.is_infinite:
+            return S.Zero
+
+        if arg.is_number:
+            acsc_table = cls._acsc_table()
+            if arg in acsc_table:
+                return acsc_table[arg]
+
+        if isinstance(arg, csc):
+            ang = arg.args[0]
+            if ang.is_comparable:
+                ang %= 2*pi # restrict to [0,2*pi)
+                if ang > pi: # restrict to (-pi,pi]
+                    ang = pi - ang
+
+                # restrict to [-pi/2,pi/2]
+                if ang > pi/2:
+                    ang = pi - ang
+                if ang < -pi/2:
+                    ang = -pi - ang
+
+                return ang
+
+        if isinstance(arg, sec): # asec(x) + acsc(x) = pi/2
+            ang = arg.args[0]
+            if ang.is_comparable:
+                return pi/2 - asec(arg)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -1/(self.args[0]**2*sqrt(1 - 1/self.args[0]**2))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+        """
+        return csc
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return pi/2 - S.ImaginaryUnit*log(2) + S.ImaginaryUnit*log(x)
+        elif n < 0 or n % 2 == 1:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 2 and n > 2:
+                p = previous_terms[-2]
+                return p * ((n - 1)*(n-2)) * x**2/(4 * (n//2)**2)
+            else:
+                k = n // 2
+                R = RisingFactorial(S.Half, k) *  n
+                F = factorial(k) * n // 2 * n // 2
+                return S.ImaginaryUnit * R / F * x**n / 4
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0).cancel()
+        if x0 is S.NaN:
+            return self.func(arg.as_leading_term(x))
+        # Handling branch points
+        if x0 in (-S.One, S.One, S.Zero):
+            return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        if x0 is S.ComplexInfinity:
+            return (1/arg).as_leading_term(x)
+        # Handling points lying on branch cuts (-1, 1)
+        if x0.is_real and (1 - x0**2).is_positive:
+            ndir = arg.dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if x0.is_positive:
+                    return pi - self.func(x0)
+            elif im(ndir).is_positive:
+                if x0.is_negative:
+                    return -pi - self.func(x0)
+            else:
+                return self.rewrite(log)._eval_as_leading_term(x, logx=logx, cdir=cdir).expand()
+        return self.func(x0)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):  # acsc
+        from sympy.series.order import O
+        arg0 = self.args[0].subs(x, 0)
+        # Handling branch points
+        if arg0 is S.One:
+            t = Dummy('t', positive=True)
+            ser = acsc(S.One + t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.NegativeOne + self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        if arg0 is S.NegativeOne:
+            t = Dummy('t', positive=True)
+            ser = acsc(S.NegativeOne - t**2).rewrite(log).nseries(t, 0, 2*n)
+            arg1 = S.NegativeOne - self.args[0]
+            f = arg1.as_leading_term(x)
+            g = (arg1 - f)/ f
+            res1 = sqrt(S.One + g)._eval_nseries(x, n=n, logx=logx)
+            res = (res1.removeO()*sqrt(f)).expand()
+            return ser.removeO().subs(t, res).expand().powsimp() + O(x**n, x)
+
+        res = super()._eval_nseries(x, n=n, logx=logx)
+        if arg0 is S.ComplexInfinity:
+            return res
+        # Handling points lying on branch cuts (-1, 1)
+        if arg0.is_real and (1 - arg0**2).is_positive:
+            ndir = self.args[0].dir(x, cdir if cdir else 1)
+            if im(ndir).is_negative:
+                if arg0.is_positive:
+                    return pi - res
+            elif im(ndir).is_positive:
+                if arg0.is_negative:
+                    return -pi - res
+            else:
+                return self.rewrite(log)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return res
+
+    def _eval_rewrite_as_log(self, arg, **kwargs):
+        return -S.ImaginaryUnit*log(S.ImaginaryUnit/arg + sqrt(1 - 1/arg**2))
+
+    _eval_rewrite_as_tractable = _eval_rewrite_as_log
+
+    def _eval_rewrite_as_asin(self, arg, **kwargs):
+        return asin(1/arg)
+
+    def _eval_rewrite_as_acos(self, arg, **kwargs):
+        return pi/2 - acos(1/arg)
+
+    def _eval_rewrite_as_atan(self, x, **kwargs):
+        return sqrt(x**2)/x*(pi/2 - atan(sqrt(x**2 - 1)))
+
+    def _eval_rewrite_as_acot(self, arg, **kwargs):
+        return sqrt(arg**2)/arg*(pi/2 - acot(1/sqrt(arg**2 - 1)))
+
+    def _eval_rewrite_as_asec(self, arg, **kwargs):
+        return pi/2 - asec(arg)
+
+
+class atan2(InverseTrigonometricFunction):
+    r"""
+    The function ``atan2(y, x)`` computes `\operatorname{atan}(y/x)` taking
+    two arguments `y` and `x`.  Signs of both `y` and `x` are considered to
+    determine the appropriate quadrant of `\operatorname{atan}(y/x)`.
+    The range is `(-\pi, \pi]`. The complete definition reads as follows:
+
+    .. math::
+
+        \operatorname{atan2}(y, x) =
+        \begin{cases}
+          \arctan\left(\frac y x\right) & \qquad x > 0 \\
+          \arctan\left(\frac y x\right) + \pi& \qquad y \ge 0, x < 0 \\
+          \arctan\left(\frac y x\right) - \pi& \qquad y < 0, x < 0 \\
+          +\frac{\pi}{2} & \qquad y > 0, x = 0 \\
+          -\frac{\pi}{2} & \qquad y < 0, x = 0 \\
+          \text{undefined} & \qquad y = 0, x = 0
+        \end{cases}
+
+    Attention: Note the role reversal of both arguments. The `y`-coordinate
+    is the first argument and the `x`-coordinate the second.
+
+    If either `x` or `y` is complex:
+
+    .. math::
+
+        \operatorname{atan2}(y, x) =
+            -i\log\left(\frac{x + iy}{\sqrt{x^2 + y^2}}\right)
+
+    Examples
+    ========
+
+    Going counter-clock wise around the origin we find the
+    following angles:
+
+    >>> from sympy import atan2
+    >>> atan2(0, 1)
+    0
+    >>> atan2(1, 1)
+    pi/4
+    >>> atan2(1, 0)
+    pi/2
+    >>> atan2(1, -1)
+    3*pi/4
+    >>> atan2(0, -1)
+    pi
+    >>> atan2(-1, -1)
+    -3*pi/4
+    >>> atan2(-1, 0)
+    -pi/2
+    >>> atan2(-1, 1)
+    -pi/4
+
+    which are all correct. Compare this to the results of the ordinary
+    `\operatorname{atan}` function for the point `(x, y) = (-1, 1)`
+
+    >>> from sympy import atan, S
+    >>> atan(S(1)/-1)
+    -pi/4
+    >>> atan2(1, -1)
+    3*pi/4
+
+    where only the `\operatorname{atan2}` function returns what we expect.
+    We can differentiate the function with respect to both arguments:
+
+    >>> from sympy import diff
+    >>> from sympy.abc import x, y
+    >>> diff(atan2(y, x), x)
+    -y/(x**2 + y**2)
+
+    >>> diff(atan2(y, x), y)
+    x/(x**2 + y**2)
+
+    We can express the `\operatorname{atan2}` function in terms of
+    complex logarithms:
+
+    >>> from sympy import log
+    >>> atan2(y, x).rewrite(log)
+    -I*log((x + I*y)/sqrt(x**2 + y**2))
+
+    and in terms of `\operatorname(atan)`:
+
+    >>> from sympy import atan
+    >>> atan2(y, x).rewrite(atan)
+    Piecewise((2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)), (pi, re(x) < 0), (0, Ne(x, 0)), (nan, True))
+
+    but note that this form is undefined on the negative real axis.
+
+    See Also
+    ========
+
+    sin, csc, cos, sec, tan, cot
+    asin, acsc, acos, asec, atan, acot
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Inverse_trigonometric_functions
+    .. [2] https://en.wikipedia.org/wiki/Atan2
+    .. [3] https://functions.wolfram.com/ElementaryFunctions/ArcTan2
+
+    """
+
+    @classmethod
+    def eval(cls, y, x):
+        from sympy.functions.special.delta_functions import Heaviside
+        if x is S.NegativeInfinity:
+            if y.is_zero:
+                # Special case y = 0 because we define Heaviside(0) = 1/2
+                return pi
+            return 2*pi*(Heaviside(re(y))) - pi
+        elif x is S.Infinity:
+            return S.Zero
+        elif x.is_imaginary and y.is_imaginary and x.is_number and y.is_number:
+            x = im(x)
+            y = im(y)
+
+        if x.is_extended_real and y.is_extended_real:
+            if x.is_positive:
+                return atan(y/x)
+            elif x.is_negative:
+                if y.is_negative:
+                    return atan(y/x) - pi
+                elif y.is_nonnegative:
+                    return atan(y/x) + pi
+            elif x.is_zero:
+                if y.is_positive:
+                    return pi/2
+                elif y.is_negative:
+                    return -pi/2
+                elif y.is_zero:
+                    return S.NaN
+        if y.is_zero:
+            if x.is_extended_nonzero:
+                return pi*(S.One - Heaviside(x))
+            if x.is_number:
+                return Piecewise((pi, re(x) < 0),
+                                 (0, Ne(x, 0)),
+                                 (S.NaN, True))
+        if x.is_number and y.is_number:
+            return -S.ImaginaryUnit*log(
+                (x + S.ImaginaryUnit*y)/sqrt(x**2 + y**2))
+
+    def _eval_rewrite_as_log(self, y, x, **kwargs):
+        return -S.ImaginaryUnit*log((x + S.ImaginaryUnit*y)/sqrt(x**2 + y**2))
+
+    def _eval_rewrite_as_atan(self, y, x, **kwargs):
+        return Piecewise((2*atan(y/(x + sqrt(x**2 + y**2))), Ne(y, 0)),
+                         (pi, re(x) < 0),
+                         (0, Ne(x, 0)),
+                         (S.NaN, True))
+
+    def _eval_rewrite_as_arg(self, y, x, **kwargs):
+        if x.is_extended_real and y.is_extended_real:
+            return arg_f(x + y*S.ImaginaryUnit)
+        n = x + S.ImaginaryUnit*y
+        d = x**2 + y**2
+        return arg_f(n/sqrt(d)) - S.ImaginaryUnit*log(abs(n)/sqrt(abs(d)))
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real and self.args[1].is_extended_real
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate(), self.args[1].conjugate())
+
+    def fdiff(self, argindex):
+        y, x = self.args
+        if argindex == 1:
+            # Diff wrt y
+            return x/(x**2 + y**2)
+        elif argindex == 2:
+            # Diff wrt x
+            return -y/(x**2 + y**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        y, x = self.args
+        if x.is_extended_real and y.is_extended_real:
+            return super()._eval_evalf(prec)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ab52ace36a8dfbe73179dbf4419a54f7fa1af5fa
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/__init__.py
@@ -0,0 +1 @@
+# Stub __init__.py for the sympy.functions.special package
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77421d9a54710dcb4a381b7c3808fd6ab3fc6283
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bessel.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bessel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1737c245c354eca53df5b99f27b110217046f0bc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bessel.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63700b829896bd43432447f6328e24b5bc9fb6cb3846176380a2e42c15023f87
+size 100552
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/beta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/beta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9016727c4f8de9ad49aa0a6b11d8792b9120538d
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/beta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bsplines.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bsplines.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f39548661c91964b8c938cd61259ec2f721e8d5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/bsplines.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/delta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/delta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2d320934e8202edffbd107827c7ffd92a50f65c8
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/delta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/elliptic_integrals.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/elliptic_integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb68f0f384ac554913f169962588c0cb6ae14941
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/elliptic_integrals.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..162c82b5935dd4ebe503ecb4e52a523971550a21
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/error_functions.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3d9bf22d4f5d45912200504b2637d8a5e5c194c3c2d5c3218b8e6664830ec8ae
+size 121137
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/gamma_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/gamma_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..024b3036a82e5733396db5b8c7acc2a601ff315e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/gamma_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/hyper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/hyper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..31512b4cc6872af0000b9a05e56bcadc44c0a102
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/hyper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/mathieu_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/mathieu_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5abcbb845bed00a65e1e4c74d90456d551437766
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/mathieu_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/polynomials.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/polynomials.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f29933e9913dcdd7df53d238e935f8d59f47627b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/polynomials.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/singularity_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/singularity_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bef049d5f1daede05047ebb8d3bf62f08c62f4bf
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/singularity_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/spherical_harmonics.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/spherical_harmonics.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e063f5df3763e03fdbd167b43d36c753c318512
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/spherical_harmonics.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/tensor_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/tensor_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ecf2cfbf253dec1d13d5e704defd7e10691168b1
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/tensor_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/zeta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/zeta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af65b2c50b491b85c4437a004779472f9c0d51a9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/__pycache__/zeta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e069df76164e099bfc30dd3d809cdb33137791e5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/bench_special.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/bench_special.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ee6190e01ac4a2df72a9717a39baa6b8044194f3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/__pycache__/bench_special.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/bench_special.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/bench_special.py
new file mode 100644
index 0000000000000000000000000000000000000000..25d7280c2cf31dcbff08065a78847ed03e0ebb05
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/benchmarks/bench_special.py
@@ -0,0 +1,8 @@
+from sympy.core.symbol import symbols
+from sympy.functions.special.spherical_harmonics import Ynm
+
+x, y = symbols('x,y')
+
+
+def timeit_Ynm_xy():
+    Ynm(1, 1, x, y)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/bessel.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/bessel.py
new file mode 100644
index 0000000000000000000000000000000000000000..a24e7dc442d2a5a9bf7047113fd81b36c6b6ba36
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/bessel.py
@@ -0,0 +1,2208 @@
+from functools import wraps
+
+from sympy.core import S
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError, _mexpand
+from sympy.core.logic import fuzzy_or, fuzzy_not
+from sympy.core.numbers import Rational, pi, I
+from sympy.core.power import Pow
+from sympy.core.symbol import Dummy, uniquely_named_symbol, Wild
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial, RisingFactorial
+from sympy.functions.elementary.trigonometric import sin, cos, csc, cot
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.miscellaneous import cbrt, sqrt, root
+from sympy.functions.elementary.complexes import (Abs, re, im, polar_lift, unpolarify)
+from sympy.functions.special.gamma_functions import gamma, digamma, uppergamma
+from sympy.functions.special.hyper import hyper
+from sympy.polys.orthopolys import spherical_bessel_fn
+
+from mpmath import mp, workprec
+
+# TODO
+# o Scorer functions G1 and G2
+# o Asymptotic expansions
+#   These are possible, e.g. for fixed order, but since the bessel type
+#   functions are oscillatory they are not actually tractable at
+#   infinity, so this is not particularly useful right now.
+# o Nicer series expansions.
+# o More rewriting.
+# o Add solvers to ode.py (or rather add solvers for the hypergeometric equation).
+
+
+class BesselBase(DefinedFunction):
+    """
+    Abstract base class for Bessel-type functions.
+
+    This class is meant to reduce code duplication.
+    All Bessel-type functions can 1) be differentiated, with the derivatives
+    expressed in terms of similar functions, and 2) be rewritten in terms
+    of other Bessel-type functions.
+
+    Here, Bessel-type functions are assumed to have one complex parameter.
+
+    To use this base class, define class attributes ``_a`` and ``_b`` such that
+    ``2*F_n' = -_a*F_{n+1} + b*F_{n-1}``.
+
+    """
+
+    @property
+    def order(self):
+        """ The order of the Bessel-type function. """
+        return self.args[0]
+
+    @property
+    def argument(self):
+        """ The argument of the Bessel-type function. """
+        return self.args[1]
+
+    @classmethod
+    def eval(cls, nu, z):
+        return
+
+    def fdiff(self, argindex=2):
+        if argindex != 2:
+            raise ArgumentIndexError(self, argindex)
+        return (self._b/2 * self.__class__(self.order - 1, self.argument) -
+                self._a/2 * self.__class__(self.order + 1, self.argument))
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return self.__class__(self.order.conjugate(), z.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        nu, z = self.order, self.argument
+
+        if nu.has(x):
+            return False
+        if not z._eval_is_meromorphic(x, a):
+            return None
+        z0 = z.subs(x, a)
+        if nu.is_integer:
+            if isinstance(self, (besselj, besseli, hn1, hn2, jn, yn)) or not nu.is_zero:
+                return fuzzy_not(z0.is_infinite)
+        return fuzzy_not(fuzzy_or([z0.is_zero, z0.is_infinite]))
+
+    def _eval_expand_func(self, **hints):
+        nu, z, f = self.order, self.argument, self.__class__
+        if nu.is_real:
+            if (nu - 1).is_positive:
+                return (-self._a*self._b*f(nu - 2, z)._eval_expand_func() +
+                        2*self._a*(nu - 1)*f(nu - 1, z)._eval_expand_func()/z)
+            elif (nu + 1).is_negative:
+                return (2*self._b*(nu + 1)*f(nu + 1, z)._eval_expand_func()/z -
+                        self._a*self._b*f(nu + 2, z)._eval_expand_func())
+        return self
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.simplify import besselsimp
+        return besselsimp(self)
+
+
+class besselj(BesselBase):
+    r"""
+    Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    The Bessel $J$ function of order $\nu$ is defined to be the function
+    satisfying Bessel's differential equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+        + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 - \nu^2) w = 0,
+
+    with Laurent expansion
+
+    .. math ::
+        J_\nu(z) = z^\nu \left(\frac{1}{\Gamma(\nu + 1) 2^\nu} + O(z^2) \right),
+
+    if $\nu$ is not a negative integer. If $\nu=-n \in \mathbb{Z}_{<0}$
+    *is* a negative integer, then the definition is
+
+    .. math ::
+        J_{-n}(z) = (-1)^n J_n(z).
+
+    Examples
+    ========
+
+    Create a Bessel function object:
+
+    >>> from sympy import besselj, jn
+    >>> from sympy.abc import z, n
+    >>> b = besselj(n, z)
+
+    Differentiate it:
+
+    >>> b.diff(z)
+    besselj(n - 1, z)/2 - besselj(n + 1, z)/2
+
+    Rewrite in terms of spherical Bessel functions:
+
+    >>> b.rewrite(jn)
+    sqrt(2)*sqrt(z)*jn(n - 1/2, z)/sqrt(pi)
+
+    Access the parameter and argument:
+
+    >>> b.order
+    n
+    >>> b.argument
+    z
+
+    See Also
+    ========
+
+    bessely, besseli, besselk
+
+    References
+    ==========
+
+    .. [1] Abramowitz, Milton; Stegun, Irene A., eds. (1965), "Chapter 9",
+           Handbook of Mathematical Functions with Formulas, Graphs, and
+           Mathematical Tables
+    .. [2] Luke, Y. L. (1969), The Special Functions and Their
+           Approximations, Volume 1
+    .. [3] https://en.wikipedia.org/wiki/Bessel_function
+    .. [4] https://functions.wolfram.com/Bessel-TypeFunctions/BesselJ/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif (nu.is_integer and nu.is_zero is False) or re(nu).is_positive:
+                return S.Zero
+            elif re(nu).is_negative and not (nu.is_integer is True):
+                return S.ComplexInfinity
+            elif nu.is_imaginary:
+                return S.NaN
+        if z in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+
+        if z.could_extract_minus_sign():
+            return (z)**nu*(-z)**(-nu)*besselj(nu, -z)
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return S.NegativeOne**(-nu)*besselj(-nu, z)
+            newz = z.extract_multiplicatively(I)
+            if newz:  # NOTE we don't want to change the function if z==0
+                return I**(nu)*besseli(nu, newz)
+
+        # branch handling:
+        if nu.is_integer:
+            newz = unpolarify(z)
+            if newz != z:
+                return besselj(nu, newz)
+        else:
+            newz, n = z.extract_branch_factor()
+            if n != 0:
+                return exp(2*n*pi*nu*I)*besselj(nu, newz)
+        nnu = unpolarify(nu)
+        if nu != nnu:
+            return besselj(nnu, z)
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        return exp(I*pi*nu/2)*besseli(nu, polar_lift(-I)*z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return csc(pi*nu)*bessely(-nu, z) - cot(pi*nu)*bessely(nu, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return sqrt(2*z/pi)*jn(nu - S.Half, self.argument)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            return arg**nu/(2**nu*gamma(nu + 1))
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 364 for more information on
+                # asymptotic approximation of besselj function.
+                return sqrt(2)*cos(z - pi*(2*nu + 1)/4)/sqrt(pi*z)
+            return self
+
+        return super(besselj, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_extended_real:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselJ/06/01/04/01/01/0003/
+        # for more information on nseries expansion of besselj function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive:
+            newn = ceiling(n/exp)
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            term = r**nu/gamma(nu + 1)
+            s = [term]
+            for k in range(1, (newn + 1)//2):
+                term *= -t/(k*(nu + k))
+                term = (_mexpand(term) + o).removeO()
+                s.append(term)
+            return Add(*s) + o
+
+        return super(besselj, self)._eval_nseries(x, n, logx, cdir)
+
+
+class bessely(BesselBase):
+    r"""
+    Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    The Bessel $Y$ function of order $\nu$ is defined as
+
+    .. math ::
+        Y_\nu(z) = \lim_{\mu \to \nu} \frac{J_\mu(z) \cos(\pi \mu)
+                                            - J_{-\mu}(z)}{\sin(\pi \mu)},
+
+    where $J_\mu(z)$ is the Bessel function of the first kind.
+
+    It is a solution to Bessel's equation, and linearly independent from
+    $J_\nu$.
+
+    Examples
+    ========
+
+    >>> from sympy import bessely, yn
+    >>> from sympy.abc import z, n
+    >>> b = bessely(n, z)
+    >>> b.diff(z)
+    bessely(n - 1, z)/2 - bessely(n + 1, z)/2
+    >>> b.rewrite(yn)
+    sqrt(2)*sqrt(z)*yn(n - 1/2, z)/sqrt(pi)
+
+    See Also
+    ========
+
+    besselj, besseli, besselk
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselY/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.NegativeInfinity
+            elif re(nu).is_zero is False:
+                return S.ComplexInfinity
+            elif re(nu).is_zero:
+                return S.NaN
+        if z in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        if z == I*S.Infinity:
+            return exp(I*pi*(nu + 1)/2) * S.Infinity
+        if z == I*S.NegativeInfinity:
+            return exp(-I*pi*(nu + 1)/2) * S.Infinity
+
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return S.NegativeOne**(-nu)*bessely(-nu, z)
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return csc(pi*nu)*(cos(pi*nu)*besselj(nu, z) - besselj(-nu, z))
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(besseli)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        return sqrt(2*z/pi) * yn(nu - S.Half, self.argument)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            term_one = ((2/pi)*log(z/2)*besselj(nu, z))
+            term_two = -(z/2)**(-nu)*factorial(nu - 1)/pi if (nu).is_positive else S.Zero
+            term_three = -(z/2)**nu/(pi*factorial(nu))*(digamma(nu + 1) - S.EulerGamma)
+            arg = Add(*[term_one, term_two, term_three]).as_leading_term(x, logx=logx)
+            return arg
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 364 for more information on
+                # asymptotic approximation of bessely function.
+                return sqrt(2)*(-sin(pi*nu/2 - z + pi/4) + 3*cos(pi*nu/2 - z + pi/4)/(8*z))*sqrt(1/z)/sqrt(pi)
+            return self
+
+        return super(bessely, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_positive:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselY/06/01/04/01/02/0008/
+        # for more information on nseries expansion of bessely function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive and nu.is_integer:
+            newn = ceiling(n/exp)
+            bn = besselj(nu, z)
+            a = ((2/pi)*log(z/2)*bn)._eval_nseries(x, n, logx, cdir)
+
+            b, c = [], []
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            if nu > S.Zero:
+                term = r**(-nu)*factorial(nu - 1)/pi
+                b.append(term)
+                for k in range(1, nu):
+                    denom = (nu - k)*k
+                    if denom == S.Zero:
+                        term *= t/k
+                    else:
+                        term *= t/denom
+                    term = (_mexpand(term) + o).removeO()
+                    b.append(term)
+
+            p = r**nu/(pi*factorial(nu))
+            term = p*(digamma(nu + 1) - S.EulerGamma)
+            c.append(term)
+            for k in range(1, (newn + 1)//2):
+                p *= -t/(k*(k + nu))
+                p = (_mexpand(p) + o).removeO()
+                term = p*(digamma(k + nu + 1) + digamma(k + 1))
+                c.append(term)
+            return a - Add(*b) - Add(*c) # Order term comes from a
+
+        return super(bessely, self)._eval_nseries(x, n, logx, cdir)
+
+
+class besseli(BesselBase):
+    r"""
+    Modified Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    The Bessel $I$ function is a solution to the modified Bessel equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+        + z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 + \nu^2)^2 w = 0.
+
+    It can be defined as
+
+    .. math ::
+        I_\nu(z) = i^{-\nu} J_\nu(iz),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind.
+
+    Examples
+    ========
+
+    >>> from sympy import besseli
+    >>> from sympy.abc import z, n
+    >>> besseli(n, z).diff(z)
+    besseli(n - 1, z)/2 + besseli(n + 1, z)/2
+
+    See Also
+    ========
+
+    besselj, bessely, besselk
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselI/
+
+    """
+
+    _a = -S.One
+    _b = S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif (nu.is_integer and nu.is_zero is False) or re(nu).is_positive:
+                return S.Zero
+            elif re(nu).is_negative and not (nu.is_integer is True):
+                return S.ComplexInfinity
+            elif nu.is_imaginary:
+                return S.NaN
+        if im(z) in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        if z is S.Infinity:
+            return S.Infinity
+        if z is S.NegativeInfinity:
+            return (-1)**nu*S.Infinity
+
+        if z.could_extract_minus_sign():
+            return (z)**nu*(-z)**(-nu)*besseli(nu, -z)
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return besseli(-nu, z)
+            newz = z.extract_multiplicatively(I)
+            if newz:  # NOTE we don't want to change the function if z==0
+                return I**(-nu)*besselj(nu, -newz)
+
+        # branch handling:
+        if nu.is_integer:
+            newz = unpolarify(z)
+            if newz != z:
+                return besseli(nu, newz)
+        else:
+            newz, n = z.extract_branch_factor()
+            if n != 0:
+                return exp(2*n*pi*nu*I)*besseli(nu, newz)
+        nnu = unpolarify(nu)
+        if nu != nnu:
+            return besseli(nnu, z)
+
+    def _eval_rewrite_as_tractable(self, nu, z, limitvar=None, **kwargs):
+        if z.is_extended_real:
+            return exp(z)*_besseli(nu, z)
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return exp(-I*pi*nu/2)*besselj(nu, polar_lift(I)*z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(bessely)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return self._eval_rewrite_as_besselj(*self.args).rewrite(jn)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_extended_real:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        c, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            return arg**nu/(2**nu*gamma(nu + 1))
+        elif e.is_negative:
+            cdir = 1 if cdir == 0 else cdir
+            sign = c*cdir**e
+            if not sign.is_negative:
+                # Refer Abramowitz and Stegun 1965, p. 377 for more information on
+                # asymptotic approximation of besseli function.
+                return exp(z)/sqrt(2*pi*z)
+            return self
+
+        return super(besseli, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # Refer https://functions.wolfram.com/Bessel-TypeFunctions/BesselI/06/01/04/01/01/0003/
+        # for more information on nseries expansion of besseli function.
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        if exp.is_positive:
+            newn = ceiling(n/exp)
+            o = Order(x**n, x)
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return o
+            t = (_mexpand(r**2) + o).removeO()
+
+            term = r**nu/gamma(nu + 1)
+            s = [term]
+            for k in range(1, (newn + 1)//2):
+                term *= t/(k*(nu + k))
+                term = (_mexpand(term) + o).removeO()
+                s.append(term)
+            return Add(*s) + o
+
+        return super(besseli, self)._eval_nseries(x, n, logx, cdir)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            s = [(RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(Rational(2*nu + 1, 2), k))/\
+            ((2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k)) for k in range(n)] + [Order(1/z**(Rational(2*n + 1, 2)), x)]
+            return exp(z)/sqrt(2*pi) * (Add(*s))
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class besselk(BesselBase):
+    r"""
+    Modified Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    The Bessel $K$ function of order $\nu$ is defined as
+
+    .. math ::
+        K_\nu(z) = \lim_{\mu \to \nu} \frac{\pi}{2}
+                   \frac{I_{-\mu}(z) -I_\mu(z)}{\sin(\pi \mu)},
+
+    where $I_\mu(z)$ is the modified Bessel function of the first kind.
+
+    It is a solution of the modified Bessel equation, and linearly independent
+    from $Y_\nu$.
+
+    Examples
+    ========
+
+    >>> from sympy import besselk
+    >>> from sympy.abc import z, n
+    >>> besselk(n, z).diff(z)
+    -besselk(n - 1, z)/2 - besselk(n + 1, z)/2
+
+    See Also
+    ========
+
+    besselj, besseli, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/
+
+    """
+
+    _a = S.One
+    _b = -S.One
+
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.Infinity
+            elif re(nu).is_zero is False:
+                return S.ComplexInfinity
+            elif re(nu).is_zero:
+                return S.NaN
+        if z in (S.Infinity, I*S.Infinity, I*S.NegativeInfinity):
+            return S.Zero
+
+        if nu.is_integer:
+            if nu.could_extract_minus_sign():
+                return besselk(-nu, z)
+
+    def _eval_rewrite_as_besseli(self, nu, z, **kwargs):
+        if nu.is_integer is False:
+            return pi*csc(pi*nu)*(besseli(-nu, z) - besseli(nu, z))/2
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        ai = self._eval_rewrite_as_besseli(*self.args)
+        if ai:
+            return ai.rewrite(besselj)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        aj = self._eval_rewrite_as_besselj(*self.args)
+        if aj:
+            return aj.rewrite(bessely)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        ay = self._eval_rewrite_as_bessely(*self.args)
+        if ay:
+            return ay.rewrite(yn)
+
+    def _eval_is_extended_real(self):
+        nu, z = self.args
+        if nu.is_integer and z.is_positive:
+            return True
+
+    def _eval_rewrite_as_tractable(self, nu, z, limitvar=None, **kwargs):
+        if z.is_extended_real:
+            return exp(-z)*_besselk(nu, z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        nu, z = self.args
+        try:
+            arg = z.as_leading_term(x)
+        except NotImplementedError:
+            return self
+        _, e = arg.as_coeff_exponent(x)
+
+        if e.is_positive:
+            if nu.is_zero:
+                # Equation 9.6.8 of Abramowitz and Stegun (10th ed, 1972).
+                term = -log(z) - S.EulerGamma + log(2)
+            elif nu.is_nonzero:
+                # Equation 9.6.9 of Abramowitz and Stegun (10th ed, 1972).
+                term = gamma(Abs(nu))*(z/2)**(-Abs(nu))/2
+            else:
+                raise NotImplementedError(f"Cannot proceed without knowing if {nu} is zero or not.")
+
+            return term.as_leading_term(x, logx=logx)
+        elif e.is_negative:
+            # Equation 9.7.2 of Abramowitz and Stegun (10th ed, 1972).
+            return sqrt(pi)*exp(-arg)/sqrt(2*arg)
+        else:
+            return self.func(nu, arg)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        try:
+            _, exp = z.leadterm(x)
+        except (ValueError, NotImplementedError):
+            return self
+
+        # In case of powers less than 1, number of terms need to be computed
+        # separately to avoid repeated callings of _eval_nseries with wrong n
+        if exp.is_positive:
+            r = (z/2)._eval_nseries(x, n, logx, cdir).removeO()
+            if r is S.Zero:
+                return Order(z**(-nu) + z**nu, x)
+
+            o = Order(x**n, x)
+            if nu.is_integer:
+                # Reference: https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/06/01/04/01/02/0008/ (only for integer order)
+                newn = ceiling(n/exp)
+                bn = besseli(nu, z)
+                a = ((-1)**(nu - 1)*log(z/2)*bn)._eval_nseries(x, n, logx, cdir)
+
+                b, c = [], []
+                t = _mexpand(r**2)
+
+                if nu > S.Zero:
+                    term = r**(-nu)*factorial(nu - 1)/2
+                    b.append(term)
+                    for k in range(1, nu):
+                        term *= t/((k - nu)*k)
+                        term = (_mexpand(term) + o).removeO()
+                        b.append(term)
+
+                p = r**nu*(-1)**nu/(2*factorial(nu))
+                term = p*(digamma(nu + 1) - S.EulerGamma)
+                c.append(term)
+                for k in range(1, (newn + 1)//2):
+                    p *= t/(k*(k + nu))
+                    p = (_mexpand(p) + o).removeO()
+                    term = p*(digamma(k + nu + 1) + digamma(k + 1))
+                    c.append(term)
+                return a + Add(*b) + Add(*c) + o
+            elif nu.is_noninteger:
+                # Reference: https://functions.wolfram.com/Bessel-TypeFunctions/BesselK/06/01/04/01/01/0003/
+                # (only for non-integer order).
+                # While the expression in the reference above seems correct
+                # for non-real order as well, it would need some manipulation
+                # (not implemented) to be written as a power series in x with
+                # real exponents [e.g. Dunster 1990. "Bessel functions
+                # of purely imaginary order, with an application to second-order
+                # linear differential equations having a large parameter".
+                # SIAM J. Math. Anal. Vol 21, No. 4, pp 995-1018.].
+                newn_a = ceiling((n+nu)/exp)
+                newn_b = ceiling((n-nu)/exp)
+
+                a, b = [], []
+                for k in range((newn_a+1)//2):
+                    term = gamma(nu)*r**(2*k-nu)/(2*RisingFactorial(1-nu, k)*factorial(k))
+                    a.append(_mexpand(term))
+                for k in range((newn_b+1)//2):
+                    term = gamma(-nu)*r**(2*k+nu)/(2*RisingFactorial(nu+1, k)*factorial(k))
+                    b.append(_mexpand(term))
+                return Add(*a) + Add(*b) + o
+            else:
+                raise NotImplementedError("besselk expansion is only implemented for real order")
+
+        return super(besselk, self)._eval_nseries(x, n, logx, cdir)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            s = [(RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(Rational(2*nu + 1, 2), k))/\
+            ((-2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k)) for k in range(n)] +[Order(1/z**(Rational(2*n + 1, 2)), x)]
+            return (exp(-z)*sqrt(pi/2))*Add(*s)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class hankel1(BesselBase):
+    r"""
+    Hankel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math ::
+        H_\nu^{(1)} = J_\nu(z) + iY_\nu(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind, and
+    $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    It is a solution to Bessel's equation.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel1
+    >>> from sympy.abc import z, n
+    >>> hankel1(n, z).diff(z)
+    hankel1(n - 1, z)/2 - hankel1(n + 1, z)/2
+
+    See Also
+    ========
+
+    hankel2, besselj, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/HankelH1/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return hankel2(self.order.conjugate(), z.conjugate())
+
+
+class hankel2(BesselBase):
+    r"""
+    Hankel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math ::
+        H_\nu^{(2)} = J_\nu(z) - iY_\nu(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind, and
+    $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    It is a solution to Bessel's equation, and linearly independent from
+    $H_\nu^{(1)}$.
+
+    Examples
+    ========
+
+    >>> from sympy import hankel2
+    >>> from sympy.abc import z, n
+    >>> hankel2(n, z).diff(z)
+    hankel2(n - 1, z)/2 - hankel2(n + 1, z)/2
+
+    See Also
+    ========
+
+    hankel1, besselj, bessely
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/Bessel-TypeFunctions/HankelH2/
+
+    """
+
+    _a = S.One
+    _b = S.One
+
+    def _eval_conjugate(self):
+        z = self.argument
+        if z.is_extended_negative is False:
+            return hankel1(self.order.conjugate(), z.conjugate())
+
+
+def assume_integer_order(fn):
+    @wraps(fn)
+    def g(self, nu, z):
+        if nu.is_integer:
+            return fn(self, nu, z)
+    return g
+
+
+class SphericalBesselBase(BesselBase):
+    """
+    Base class for spherical Bessel functions.
+
+    These are thin wrappers around ordinary Bessel functions,
+    since spherical Bessel functions differ from the ordinary
+    ones just by a slight change in order.
+
+    To use this class, define the ``_eval_evalf()`` and ``_expand()`` methods.
+
+    """
+
+    def _expand(self, **hints):
+        """ Expand self into a polynomial. Nu is guaranteed to be Integer. """
+        raise NotImplementedError('expansion')
+
+    def _eval_expand_func(self, **hints):
+        if self.order.is_Integer:
+            return self._expand(**hints)
+        return self
+
+    def fdiff(self, argindex=2):
+        if argindex != 2:
+            raise ArgumentIndexError(self, argindex)
+        return self.__class__(self.order - 1, self.argument) - \
+            self * (self.order + 1)/self.argument
+
+
+def _jn(n, z):
+    return (spherical_bessel_fn(n, z)*sin(z) +
+            S.NegativeOne**(n + 1)*spherical_bessel_fn(-n - 1, z)*cos(z))
+
+
+def _yn(n, z):
+    # (-1)**(n + 1) * _jn(-n - 1, z)
+    return (S.NegativeOne**(n + 1) * spherical_bessel_fn(-n - 1, z)*sin(z) -
+            spherical_bessel_fn(n, z)*cos(z))
+
+
+class jn(SphericalBesselBase):
+    r"""
+    Spherical Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is a solution to the spherical Bessel equation
+
+    .. math ::
+        z^2 \frac{\mathrm{d}^2 w}{\mathrm{d}z^2}
+          + 2z \frac{\mathrm{d}w}{\mathrm{d}z} + (z^2 - \nu(\nu + 1)) w = 0.
+
+    It can be defined as
+
+    .. math ::
+        j_\nu(z) = \sqrt{\frac{\pi}{2z}} J_{\nu + \frac{1}{2}}(z),
+
+    where $J_\nu(z)$ is the Bessel function of the first kind.
+
+    The spherical Bessel functions of integral order are
+    calculated using the formula:
+
+    .. math:: j_n(z) = f_n(z) \sin{z} + (-1)^{n+1} f_{-n-1}(z) \cos{z},
+
+    where the coefficients $f_n(z)$ are available as
+    :func:`sympy.polys.orthopolys.spherical_bessel_fn`.
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, jn, sin, cos, expand_func, besselj, bessely
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(jn(0, z)))
+    sin(z)/z
+    >>> expand_func(jn(1, z)) == sin(z)/z**2 - cos(z)/z
+    True
+    >>> expand_func(jn(3, z))
+    (-6/z**2 + 15/z**4)*sin(z) + (1/z - 15/z**3)*cos(z)
+    >>> jn(nu, z).rewrite(besselj)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(nu + 1/2, z)/2
+    >>> jn(nu, z).rewrite(bessely)
+    (-1)**nu*sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(-nu - 1/2, z)/2
+    >>> jn(2, 5.2+0.3j).evalf(20)
+    0.099419756723640344491 - 0.054525080242173562897*I
+
+    See Also
+    ========
+
+    besselj, bessely, besselk, yn
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+    @classmethod
+    def eval(cls, nu, z):
+        if z.is_zero:
+            if nu.is_zero:
+                return S.One
+            elif nu.is_integer:
+                if nu.is_positive:
+                    return S.Zero
+                else:
+                    return S.ComplexInfinity
+        if z in (S.NegativeInfinity, S.Infinity):
+            return S.Zero
+
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z)) * besselj(nu + S.Half, z)
+
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        return S.NegativeOne**nu * sqrt(pi/(2*z)) * bessely(-nu - S.Half, z)
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu) * yn(-nu - 1, z)
+
+    def _expand(self, **hints):
+        return _jn(self.order, self.argument)
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(besselj)._eval_evalf(prec)
+
+
+class yn(SphericalBesselBase):
+    r"""
+    Spherical Bessel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is another solution to the spherical Bessel equation, and
+    linearly independent from $j_n$. It can be defined as
+
+    .. math ::
+        y_\nu(z) = \sqrt{\frac{\pi}{2z}} Y_{\nu + \frac{1}{2}}(z),
+
+    where $Y_\nu(z)$ is the Bessel function of the second kind.
+
+    For integral orders $n$, $y_n$ is calculated using the formula:
+
+    .. math:: y_n(z) = (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, yn, sin, cos, expand_func, besselj, bessely
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(yn(0, z)))
+    -cos(z)/z
+    >>> expand_func(yn(1, z)) == -cos(z)/z**2-sin(z)/z
+    True
+    >>> yn(nu, z).rewrite(besselj)
+    (-1)**(nu + 1)*sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(-nu - 1/2, z)/2
+    >>> yn(nu, z).rewrite(bessely)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(nu + 1/2, z)/2
+    >>> yn(2, 5.2+0.3j).evalf(20)
+    0.18525034196069722536 + 0.014895573969924817587*I
+
+    See Also
+    ========
+
+    besselj, bessely, besselk, jn
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+    @assume_integer_order
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu+1) * sqrt(pi/(2*z)) * besselj(-nu - S.Half, z)
+
+    @assume_integer_order
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z)) * bessely(nu + S.Half, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        return S.NegativeOne**(nu + 1) * jn(-nu - 1, z)
+
+    def _expand(self, **hints):
+        return _yn(self.order, self.argument)
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(bessely)._eval_evalf(prec)
+
+
+class SphericalHankelBase(SphericalBesselBase):
+
+    @assume_integer_order
+    def _eval_rewrite_as_besselj(self, nu, z, **kwargs):
+        # jn +- I*yn
+        # jn as beeselj: sqrt(pi/(2*z)) * besselj(nu + S.Half, z)
+        # yn as besselj: (-1)**(nu+1) * sqrt(pi/(2*z)) * besselj(-nu - S.Half, z)
+        hks = self._hankel_kind_sign
+        return sqrt(pi/(2*z))*(besselj(nu + S.Half, z) +
+                               hks*I*S.NegativeOne**(nu+1)*besselj(-nu - S.Half, z))
+
+    @assume_integer_order
+    def _eval_rewrite_as_bessely(self, nu, z, **kwargs):
+        # jn +- I*yn
+        # jn as bessely: (-1)**nu * sqrt(pi/(2*z)) * bessely(-nu - S.Half, z)
+        # yn as bessely: sqrt(pi/(2*z)) * bessely(nu + S.Half, z)
+        hks = self._hankel_kind_sign
+        return sqrt(pi/(2*z))*(S.NegativeOne**nu*bessely(-nu - S.Half, z) +
+                               hks*I*bessely(nu + S.Half, z))
+
+    def _eval_rewrite_as_yn(self, nu, z, **kwargs):
+        hks = self._hankel_kind_sign
+        return jn(nu, z).rewrite(yn) + hks*I*yn(nu, z)
+
+    def _eval_rewrite_as_jn(self, nu, z, **kwargs):
+        hks = self._hankel_kind_sign
+        return jn(nu, z) + hks*I*yn(nu, z).rewrite(jn)
+
+    def _eval_expand_func(self, **hints):
+        if self.order.is_Integer:
+            return self._expand(**hints)
+        else:
+            nu = self.order
+            z = self.argument
+            hks = self._hankel_kind_sign
+            return jn(nu, z) + hks*I*yn(nu, z)
+
+    def _expand(self, **hints):
+        n = self.order
+        z = self.argument
+        hks = self._hankel_kind_sign
+
+        # fully expanded version
+        # return ((fn(n, z) * sin(z) +
+        #          (-1)**(n + 1) * fn(-n - 1, z) * cos(z)) +  # jn
+        #         (hks * I * (-1)**(n + 1) *
+        #          (fn(-n - 1, z) * hk * I * sin(z) +
+        #           (-1)**(-n) * fn(n, z) * I * cos(z)))  # +-I*yn
+        #         )
+
+        return (_jn(n, z) + hks*I*_yn(n, z)).expand()
+
+    def _eval_evalf(self, prec):
+        if self.order.is_Integer:
+            return self.rewrite(besselj)._eval_evalf(prec)
+
+
+class hn1(SphericalHankelBase):
+    r"""
+    Spherical Hankel function of the first kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: h_\nu^(1)(z) = j_\nu(z) + i y_\nu(z),
+
+    where $j_\nu(z)$ and $y_\nu(z)$ are the spherical
+    Bessel function of the first and second kinds.
+
+    For integral orders $n$, $h_n^(1)$ is calculated using the formula:
+
+    .. math:: h_n^(1)(z) = j_{n}(z) + i (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, hn1, hankel1, expand_func, yn, jn
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(hn1(nu, z)))
+    jn(nu, z) + I*yn(nu, z)
+    >>> print(expand_func(hn1(0, z)))
+    sin(z)/z - I*cos(z)/z
+    >>> print(expand_func(hn1(1, z)))
+    -I*sin(z)/z - cos(z)/z + sin(z)/z**2 - I*cos(z)/z**2
+    >>> hn1(nu, z).rewrite(jn)
+    (-1)**(nu + 1)*I*jn(-nu - 1, z) + jn(nu, z)
+    >>> hn1(nu, z).rewrite(yn)
+    (-1)**nu*yn(-nu - 1, z) + I*yn(nu, z)
+    >>> hn1(nu, z).rewrite(hankel1)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*hankel1(nu, z)/2
+
+    See Also
+    ========
+
+    hn2, jn, yn, hankel1, hankel2
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+
+    _hankel_kind_sign = S.One
+
+    @assume_integer_order
+    def _eval_rewrite_as_hankel1(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z))*hankel1(nu, z)
+
+
+class hn2(SphericalHankelBase):
+    r"""
+    Spherical Hankel function of the second kind.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: h_\nu^(2)(z) = j_\nu(z) - i y_\nu(z),
+
+    where $j_\nu(z)$ and $y_\nu(z)$ are the spherical
+    Bessel function of the first and second kinds.
+
+    For integral orders $n$, $h_n^(2)$ is calculated using the formula:
+
+    .. math:: h_n^(2)(z) = j_{n} - i (-1)^{n+1} j_{-n-1}(z)
+
+    Examples
+    ========
+
+    >>> from sympy import Symbol, hn2, hankel2, expand_func, jn, yn
+    >>> z = Symbol("z")
+    >>> nu = Symbol("nu", integer=True)
+    >>> print(expand_func(hn2(nu, z)))
+    jn(nu, z) - I*yn(nu, z)
+    >>> print(expand_func(hn2(0, z)))
+    sin(z)/z + I*cos(z)/z
+    >>> print(expand_func(hn2(1, z)))
+    I*sin(z)/z - cos(z)/z + sin(z)/z**2 + I*cos(z)/z**2
+    >>> hn2(nu, z).rewrite(hankel2)
+    sqrt(2)*sqrt(pi)*sqrt(1/z)*hankel2(nu, z)/2
+    >>> hn2(nu, z).rewrite(jn)
+    -(-1)**(nu + 1)*I*jn(-nu - 1, z) + jn(nu, z)
+    >>> hn2(nu, z).rewrite(yn)
+    (-1)**nu*yn(-nu - 1, z) - I*yn(nu, z)
+
+    See Also
+    ========
+
+    hn1, jn, yn, hankel1, hankel2
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/10.47
+
+    """
+
+    _hankel_kind_sign = -S.One
+
+    @assume_integer_order
+    def _eval_rewrite_as_hankel2(self, nu, z, **kwargs):
+        return sqrt(pi/(2*z))*hankel2(nu, z)
+
+
+def jn_zeros(n, k, method="sympy", dps=15):
+    """
+    Zeros of the spherical Bessel function of the first kind.
+
+    Explanation
+    ===========
+
+    This returns an array of zeros of $jn$ up to the $k$-th zero.
+
+    * method = "sympy": uses `mpmath.besseljzero
+      `_
+    * method = "scipy": uses the
+      `SciPy's sph_jn `_
+      and
+      `newton `_
+      to find all
+      roots, which is faster than computing the zeros using a general
+      numerical solver, but it requires SciPy and only works with low
+      precision floating point numbers. (The function used with
+      method="sympy" is a recent addition to mpmath; before that a general
+      solver was used.)
+
+    Examples
+    ========
+
+    >>> from sympy import jn_zeros
+    >>> jn_zeros(2, 4, dps=5)
+    [5.7635, 9.095, 12.323, 15.515]
+
+    See Also
+    ========
+
+    jn, yn, besselj, besselk, bessely
+
+    Parameters
+    ==========
+
+    n : integer
+        order of Bessel function
+
+    k : integer
+        number of zeros to return
+
+
+    """
+    from math import pi as math_pi
+
+    if method == "sympy":
+        from mpmath import besseljzero
+        from mpmath.libmp.libmpf import dps_to_prec
+        prec = dps_to_prec(dps)
+        return [Expr._from_mpmath(besseljzero(S(n + 0.5)._to_mpmath(prec),
+                                              int(l)), prec)
+                for l in range(1, k + 1)]
+    elif method == "scipy":
+        from scipy.optimize import newton
+        try:
+            from scipy.special import spherical_jn
+            f = lambda x: spherical_jn(n, x)
+        except ImportError:
+            from scipy.special import sph_jn
+            f = lambda x: sph_jn(n, x)[0][-1]
+    else:
+        raise NotImplementedError("Unknown method.")
+
+    def solver(f, x):
+        if method == "scipy":
+            root = newton(f, x)
+        else:
+            raise NotImplementedError("Unknown method.")
+        return root
+
+    # we need to approximate the position of the first root:
+    root = n + math_pi
+    # determine the first root exactly:
+    root = solver(f, root)
+    roots = [root]
+    for i in range(k - 1):
+        # estimate the position of the next root using the last root + pi:
+        root = solver(f, root + math_pi)
+        roots.append(root)
+    return roots
+
+
+class AiryBase(DefinedFunction):
+    """
+    Abstract base class for Airy functions.
+
+    This class is meant to reduce code duplication.
+
+    """
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def as_real_imag(self, deep=True, **hints):
+        z = self.args[0]
+        zc = z.conjugate()
+        f = self.func
+        u = (f(z)+f(zc))/2
+        v = I*(f(zc)-f(z))/2
+        return u, v
+
+    def _eval_expand_complex(self, deep=True, **hints):
+        re_part, im_part = self.as_real_imag(deep=deep, **hints)
+        return re_part + im_part*I
+
+
+class airyai(AiryBase):
+    r"""
+    The Airy function $\operatorname{Ai}$ of the first kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Ai}(z)$ is defined to be the function
+    satisfying Airy's differential equation
+
+    .. math::
+        \frac{\mathrm{d}^2 w(z)}{\mathrm{d}z^2} - z w(z) = 0.
+
+    Equivalently, for real $z$
+
+    .. math::
+        \operatorname{Ai}(z) := \frac{1}{\pi}
+        \int_0^\infty \cos\left(\frac{t^3}{3} + z t\right) \mathrm{d}t.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airyai
+    >>> from sympy.abc import z
+
+    >>> airyai(z)
+    airyai(z)
+
+    Several special values are known:
+
+    >>> airyai(0)
+    3**(1/3)/(3*gamma(2/3))
+    >>> from sympy import oo
+    >>> airyai(oo)
+    0
+    >>> airyai(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airyai(z))
+    airyai(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airyai(z), z)
+    airyaiprime(z)
+    >>> diff(airyai(z), z, 2)
+    z*airyai(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airyai(z), z, 0, 3)
+    3**(5/6)*gamma(1/3)/(6*pi) - 3**(1/6)*z*gamma(2/3)/(2*pi) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airyai(-2).evalf(50)
+    0.22740742820168557599192443603787379946077222541710
+
+    Rewrite $\operatorname{Ai}(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airyai(z).rewrite(hyper)
+    -3**(2/3)*z*hyper((), (4/3,), z**3/9)/(3*gamma(1/3)) + 3**(1/3)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3))
+
+    See Also
+    ========
+
+    airybi: Airy function of the second kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.One / (3**Rational(2, 3) * gamma(Rational(2, 3)))
+        if arg.is_zero:
+            return S.One / (3**Rational(2, 3) * gamma(Rational(2, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return airyaiprime(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return ((cbrt(3)*x)**(-n)*(cbrt(3)*x)**(n + 1)*sin(pi*(n*Rational(2, 3) + Rational(4, 3)))*factorial(n) *
+                        gamma(n/3 + Rational(2, 3))/(sin(pi*(n*Rational(2, 3) + Rational(2, 3)))*factorial(n + 1)*gamma(n/3 + Rational(1, 3))) * p)
+            else:
+                return (S.One/(3**Rational(2, 3)*pi) * gamma((n+S.One)/S(3)) * sin(Rational(2, 3)*pi*(n+S.One)) /
+                        factorial(n) * (cbrt(3)*x)**n)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return ot*sqrt(-z) * (besselj(-ot, tt*a) + besselj(ot, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return ot*sqrt(z) * (besseli(-ot, tt*a) - besseli(ot, tt*a))
+        else:
+            return ot*(Pow(a, ot)*besseli(-ot, tt*a) - z*Pow(a, -ot)*besseli(ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = S.One / (3**Rational(2, 3)*gamma(Rational(2, 3)))
+        pf2 = z / (root(3, 3)*gamma(Rational(1, 3)))
+        return pf1 * hyper([], [Rational(2, 3)], z**3/9) - pf2 * hyper([], [Rational(4, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is given by 03.05.16.0001.01
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryAi/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d * z**n)**m / (d**m * z**(m*n))
+                    newarg = c * d**m * z**(m*n)
+                    return S.Half * ((pf + S.One)*airyai(newarg) - (pf - S.One)/sqrt(3)*airybi(newarg))
+
+
+class airybi(AiryBase):
+    r"""
+    The Airy function $\operatorname{Bi}$ of the second kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Bi}(z)$ is defined to be the function
+    satisfying Airy's differential equation
+
+    .. math::
+        \frac{\mathrm{d}^2 w(z)}{\mathrm{d}z^2} - z w(z) = 0.
+
+    Equivalently, for real $z$
+
+    .. math::
+        \operatorname{Bi}(z) := \frac{1}{\pi}
+                 \int_0^\infty
+                   \exp\left(-\frac{t^3}{3} + z t\right)
+                   + \sin\left(\frac{t^3}{3} + z t\right) \mathrm{d}t.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airybi
+    >>> from sympy.abc import z
+
+    >>> airybi(z)
+    airybi(z)
+
+    Several special values are known:
+
+    >>> airybi(0)
+    3**(5/6)/(3*gamma(2/3))
+    >>> from sympy import oo
+    >>> airybi(oo)
+    oo
+    >>> airybi(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airybi(z))
+    airybi(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airybi(z), z)
+    airybiprime(z)
+    >>> diff(airybi(z), z, 2)
+    z*airybi(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airybi(z), z, 0, 3)
+    3**(1/3)*gamma(1/3)/(2*pi) + 3**(2/3)*z*gamma(2/3)/(2*pi) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airybi(-2).evalf(50)
+    -0.41230258795639848808323405461146104203453483447240
+
+    Rewrite $\operatorname{Bi}(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airybi(z).rewrite(hyper)
+    3**(1/6)*z*hyper((), (4/3,), z**3/9)/gamma(1/3) + 3**(5/6)*hyper((), (2/3,), z**3/9)/(3*gamma(2/3))
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.One / (3**Rational(1, 6) * gamma(Rational(2, 3)))
+
+        if arg.is_zero:
+            return S.One / (3**Rational(1, 6) * gamma(Rational(2, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return airybiprime(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (cbrt(3)*x * Abs(sin(Rational(2, 3)*pi*(n + S.One))) * factorial((n - S.One)/S(3)) /
+                        ((n + S.One) * Abs(cos(Rational(2, 3)*pi*(n + S.Half))) * factorial((n - 2)/S(3))) * p)
+            else:
+                return (S.One/(root(3, 6)*pi) * gamma((n + S.One)/S(3)) * Abs(sin(Rational(2, 3)*pi*(n + S.One))) /
+                        factorial(n) * (cbrt(3)*x)**n)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return sqrt(-z/3) * (besselj(-ot, tt*a) - besselj(ot, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return sqrt(z)/sqrt(3) * (besseli(-ot, tt*a) + besseli(ot, tt*a))
+        else:
+            b = Pow(a, ot)
+            c = Pow(a, -ot)
+            return sqrt(ot)*(b*besseli(-ot, tt*a) + z*c*besseli(ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = S.One / (root(3, 6)*gamma(Rational(2, 3)))
+        pf2 = z*root(3, 6) / gamma(Rational(1, 3))
+        return pf1 * hyper([], [Rational(2, 3)], z**3/9) + pf2 * hyper([], [Rational(4, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is given by 03.06.16.0001.01
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryBi/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d * z**n)**m / (d**m * z**(m*n))
+                    newarg = c * d**m * z**(m*n)
+                    return S.Half * (sqrt(3)*(S.One - pf)*airyai(newarg) + (S.One + pf)*airybi(newarg))
+
+
+class airyaiprime(AiryBase):
+    r"""
+    The derivative $\operatorname{Ai}^\prime$ of the Airy function of the first
+    kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Ai}^\prime(z)$ is defined to be the
+    function
+
+    .. math::
+        \operatorname{Ai}^\prime(z) := \frac{\mathrm{d} \operatorname{Ai}(z)}{\mathrm{d} z}.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airyaiprime
+    >>> from sympy.abc import z
+
+    >>> airyaiprime(z)
+    airyaiprime(z)
+
+    Several special values are known:
+
+    >>> airyaiprime(0)
+    -3**(2/3)/(3*gamma(1/3))
+    >>> from sympy import oo
+    >>> airyaiprime(oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airyaiprime(z))
+    airyaiprime(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airyaiprime(z), z)
+    z*airyai(z)
+    >>> diff(airyaiprime(z), z, 2)
+    z*airyaiprime(z) + airyai(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airyaiprime(z), z, 0, 3)
+    -3**(2/3)/(3*gamma(1/3)) + 3**(1/3)*z**2/(6*gamma(2/3)) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airyaiprime(-2).evalf(50)
+    0.61825902074169104140626429133247528291577794512415
+
+    Rewrite $\operatorname{Ai}^\prime(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airyaiprime(z).rewrite(hyper)
+    3**(1/3)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) - 3**(2/3)*hyper((), (1/3,), z**3/9)/(3*gamma(1/3))
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airybi: Airy function of the second kind.
+    airybiprime: Derivative of the Airy function of the second kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+
+        if arg.is_zero:
+            return S.NegativeOne / (3**Rational(1, 3) * gamma(Rational(1, 3)))
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.args[0]*airyai(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        z = self.args[0]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.airyai(z, derivative=1)
+        return Expr._from_mpmath(res, prec)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        tt = Rational(2, 3)
+        a = Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return z/3 * (besselj(-tt, tt*a) - besselj(tt, tt*a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = tt * Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return z/3 * (besseli(tt, a) - besseli(-tt, a))
+        else:
+            a = Pow(z, Rational(3, 2))
+            b = Pow(a, tt)
+            c = Pow(a, -tt)
+            return ot * (z**2*c*besseli(tt, tt*a) - b*besseli(-ot, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = z**2 / (2*3**Rational(2, 3)*gamma(Rational(2, 3)))
+        pf2 = 1 / (root(3, 3)*gamma(Rational(1, 3)))
+        return pf1 * hyper([], [Rational(5, 3)], z**3/9) - pf2 * hyper([], [Rational(1, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is in principle
+                # given by 03.07.16.0001.01 but note
+                # that there is an error in this formula.
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryAiPrime/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d**m * z**(n*m)) / (d * z**n)**m
+                    newarg = c * d**m * z**(n*m)
+                    return S.Half * ((pf + S.One)*airyaiprime(newarg) + (pf - S.One)/sqrt(3)*airybiprime(newarg))
+
+
+class airybiprime(AiryBase):
+    r"""
+    The derivative $\operatorname{Bi}^\prime$ of the Airy function of the first
+    kind.
+
+    Explanation
+    ===========
+
+    The Airy function $\operatorname{Bi}^\prime(z)$ is defined to be the
+    function
+
+    .. math::
+        \operatorname{Bi}^\prime(z) := \frac{\mathrm{d} \operatorname{Bi}(z)}{\mathrm{d} z}.
+
+    Examples
+    ========
+
+    Create an Airy function object:
+
+    >>> from sympy import airybiprime
+    >>> from sympy.abc import z
+
+    >>> airybiprime(z)
+    airybiprime(z)
+
+    Several special values are known:
+
+    >>> airybiprime(0)
+    3**(1/6)/gamma(1/3)
+    >>> from sympy import oo
+    >>> airybiprime(oo)
+    oo
+    >>> airybiprime(-oo)
+    0
+
+    The Airy function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(airybiprime(z))
+    airybiprime(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(airybiprime(z), z)
+    z*airybi(z)
+    >>> diff(airybiprime(z), z, 2)
+    z*airybiprime(z) + airybi(z)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(airybiprime(z), z, 0, 3)
+    3**(1/6)/gamma(1/3) + 3**(5/6)*z**2/(6*gamma(2/3)) + O(z**3)
+
+    We can numerically evaluate the Airy function to arbitrary precision
+    on the whole complex plane:
+
+    >>> airybiprime(-2).evalf(50)
+    0.27879516692116952268509756941098324140300059345163
+
+    Rewrite $\operatorname{Bi}^\prime(z)$ in terms of hypergeometric functions:
+
+    >>> from sympy import hyper
+    >>> airybiprime(z).rewrite(hyper)
+    3**(5/6)*z**2*hyper((), (5/3,), z**3/9)/(6*gamma(2/3)) + 3**(1/6)*hyper((), (1/3,), z**3/9)/gamma(1/3)
+
+    See Also
+    ========
+
+    airyai: Airy function of the first kind.
+    airybi: Airy function of the second kind.
+    airyaiprime: Derivative of the Airy function of the first kind.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Airy_function
+    .. [2] https://dlmf.nist.gov/9
+    .. [3] https://encyclopediaofmath.org/wiki/Airy_functions
+    .. [4] https://mathworld.wolfram.com/AiryFunctions.html
+
+    """
+
+    nargs = 1
+    unbranched = True
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Infinity
+            elif arg is S.NegativeInfinity:
+                return S.Zero
+            elif arg.is_zero:
+                return 3**Rational(1, 6) / gamma(Rational(1, 3))
+
+        if arg.is_zero:
+            return 3**Rational(1, 6) / gamma(Rational(1, 3))
+
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.args[0]*airybi(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        z = self.args[0]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.airybi(z, derivative=1)
+        return Expr._from_mpmath(res, prec)
+
+    def _eval_rewrite_as_besselj(self, z, **kwargs):
+        tt = Rational(2, 3)
+        a = tt * Pow(-z, Rational(3, 2))
+        if re(z).is_negative:
+            return -z/sqrt(3) * (besselj(-tt, a) + besselj(tt, a))
+
+    def _eval_rewrite_as_besseli(self, z, **kwargs):
+        ot = Rational(1, 3)
+        tt = Rational(2, 3)
+        a = tt * Pow(z, Rational(3, 2))
+        if re(z).is_positive:
+            return z/sqrt(3) * (besseli(-tt, a) + besseli(tt, a))
+        else:
+            a = Pow(z, Rational(3, 2))
+            b = Pow(a, tt)
+            c = Pow(a, -tt)
+            return sqrt(ot) * (b*besseli(-tt, tt*a) + z**2*c*besseli(tt, tt*a))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        pf1 = z**2 / (2*root(3, 6)*gamma(Rational(2, 3)))
+        pf2 = root(3, 6) / gamma(Rational(1, 3))
+        return pf1 * hyper([], [Rational(5, 3)], z**3/9) + pf2 * hyper([], [Rational(1, 3)], z**3/9)
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        symbs = arg.free_symbols
+
+        if len(symbs) == 1:
+            z = symbs.pop()
+            c = Wild("c", exclude=[z])
+            d = Wild("d", exclude=[z])
+            m = Wild("m", exclude=[z])
+            n = Wild("n", exclude=[z])
+            M = arg.match(c*(d*z**n)**m)
+            if M is not None:
+                m = M[m]
+                # The transformation is in principle
+                # given by 03.08.16.0001.01 but note
+                # that there is an error in this formula.
+                # https://functions.wolfram.com/Bessel-TypeFunctions/AiryBiPrime/16/01/01/0001/
+                if (3*m).is_integer:
+                    c = M[c]
+                    d = M[d]
+                    n = M[n]
+                    pf = (d**m * z**(n*m)) / (d * z**n)**m
+                    newarg = c * d**m * z**(n*m)
+                    return S.Half * (sqrt(3)*(pf - S.One)*airyaiprime(newarg) + (pf + S.One)*airybiprime(newarg))
+
+
+class marcumq(DefinedFunction):
+    r"""
+    The Marcum Q-function.
+
+    Explanation
+    ===========
+
+    The Marcum Q-function is defined by the meromorphic continuation of
+
+    .. math::
+        Q_m(a, b) = a^{- m + 1} \int_{b}^{\infty} x^{m} e^{- \frac{a^{2}}{2} - \frac{x^{2}}{2}} I_{m - 1}\left(a x\right)\, dx
+
+    Examples
+    ========
+
+    >>> from sympy import marcumq
+    >>> from sympy.abc import m, a, b
+    >>> marcumq(m, a, b)
+    marcumq(m, a, b)
+
+    Special values:
+
+    >>> marcumq(m, 0, b)
+    uppergamma(m, b**2/2)/gamma(m)
+    >>> marcumq(0, 0, 0)
+    0
+    >>> marcumq(0, a, 0)
+    1 - exp(-a**2/2)
+    >>> marcumq(1, a, a)
+    1/2 + exp(-a**2)*besseli(0, a**2)/2
+    >>> marcumq(2, a, a)
+    1/2 + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2)
+
+    Differentiation with respect to $a$ and $b$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(marcumq(m, a, b), a)
+    a*(-marcumq(m, a, b) + marcumq(m + 1, a, b))
+    >>> diff(marcumq(m, a, b), b)
+    -a**(1 - m)*b**m*exp(-a**2/2 - b**2/2)*besseli(m - 1, a*b)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Marcum_Q-function
+    .. [2] https://mathworld.wolfram.com/MarcumQ-Function.html
+
+    """
+
+    @classmethod
+    def eval(cls, m, a, b):
+        if a is S.Zero:
+            if m is S.Zero and b is S.Zero:
+                return S.Zero
+            return uppergamma(m, b**2 * S.Half) / gamma(m)
+
+        if m is S.Zero and b is S.Zero:
+            return 1 - 1 / exp(a**2 * S.Half)
+
+        if a == b:
+            if m is S.One:
+                return (1 + exp(-a**2) * besseli(0, a**2))*S.Half
+            if m == 2:
+                return S.Half + S.Half * exp(-a**2) * besseli(0, a**2) + exp(-a**2) * besseli(1, a**2)
+
+        if a.is_zero:
+            if m.is_zero and b.is_zero:
+                return S.Zero
+            return uppergamma(m, b**2*S.Half) / gamma(m)
+
+        if m.is_zero and b.is_zero:
+            return 1 - 1 / exp(a**2*S.Half)
+
+    def fdiff(self, argindex=2):
+        m, a, b = self.args
+        if argindex == 2:
+            return a * (-marcumq(m, a, b) + marcumq(1+m, a, b))
+        elif argindex == 3:
+            return (-b**m / a**(m-1)) * exp(-(a**2 + b**2)/2) * besseli(m-1, a*b)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Integral(self, m, a, b, **kwargs):
+        from sympy.integrals.integrals import Integral
+        x = kwargs.get('x', Dummy(uniquely_named_symbol('x').name))
+        return a ** (1 - m) * \
+               Integral(x**m * exp(-(x**2 + a**2)/2) * besseli(m-1, a*x), [x, b, S.Infinity])
+
+    def _eval_rewrite_as_Sum(self, m, a, b, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = kwargs.get('k', Dummy('k'))
+        return exp(-(a**2 + b**2) / 2) * Sum((a/b)**k * besseli(k, a*b), [k, 1-m, S.Infinity])
+
+    def _eval_rewrite_as_besseli(self, m, a, b, **kwargs):
+        if a == b:
+            if m == 1:
+                return (1 + exp(-a**2) * besseli(0, a**2)) / 2
+            if m.is_Integer and m >= 2:
+                s = sum(besseli(i, a**2) for i in range(1, m))
+                return S.Half + exp(-a**2) * besseli(0, a**2) / 2 + exp(-a**2) * s
+
+    def _eval_is_zero(self):
+        if all(arg.is_zero for arg in self.args):
+            return True
+
+class _besseli(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{besseli}(nu, z)$
+    function tractable for the Gruntz algorithm.
+
+    """
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            l = [((RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(
+                    Rational(2*nu + 1, 2), k))/((2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k))) for k in range(n)]
+            return sqrt(pi/(2))*(Add(*l)) + Order(1/z**(Rational(2*n + 1, 2)), x)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_intractable(self, nu, z, **kwargs):
+        return exp(-z)*besseli(nu, z)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+
+class _besselk(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{besselk}(nu, z)$
+    function tractable for the Gruntz algorithm.
+
+    """
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.functions.combinatorial.factorials import RisingFactorial
+        from sympy.series.order import Order
+        point = args0[1]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            nu, z = self.args
+            l = [((RisingFactorial(Rational(2*nu - 1, 2), k)*RisingFactorial(
+                    Rational(2*nu + 1, 2), k))/((-2)**(k)*z**(Rational(2*k + 1, 2))*factorial(k))) for k in range(n)]
+            return sqrt(pi/(2))*(Add(*l)) + Order(1/z**(Rational(2*n + 1, 2)), x)
+
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_intractable(self,nu, z, **kwargs):
+        return exp(z)*besselk(nu, z)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/beta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/beta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..337ae6c71fe5a38cc0fcd819e9d489ebbbd1946b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/beta_functions.py
@@ -0,0 +1,389 @@
+from sympy.core import S
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.symbol import Dummy, uniquely_named_symbol
+from sympy.functions.special.gamma_functions import gamma, digamma
+from sympy.functions.combinatorial.numbers import catalan
+from sympy.functions.elementary.complexes import conjugate
+
+# See mpmath #569 and SymPy #20569
+def betainc_mpmath_fix(a, b, x1, x2, reg=0):
+    from mpmath import betainc, mpf
+    if x1 == x2:
+        return mpf(0)
+    else:
+        return betainc(a, b, x1, x2, reg)
+
+###############################################################################
+############################ COMPLETE BETA  FUNCTION ##########################
+###############################################################################
+
+class beta(DefinedFunction):
+    r"""
+    The beta integral is called the Eulerian integral of the first kind by
+    Legendre:
+
+    .. math::
+        \mathrm{B}(x,y)  \int^{1}_{0} t^{x-1} (1-t)^{y-1} \mathrm{d}t.
+
+    Explanation
+    ===========
+
+    The Beta function or Euler's first integral is closely associated
+    with the gamma function. The Beta function is often used in probability
+    theory and mathematical statistics. It satisfies properties like:
+
+    .. math::
+        \mathrm{B}(a,1) = \frac{1}{a} \\
+        \mathrm{B}(a,b) = \mathrm{B}(b,a)  \\
+        \mathrm{B}(a,b) = \frac{\Gamma(a) \Gamma(b)}{\Gamma(a+b)}
+
+    Therefore for integral values of $a$ and $b$:
+
+    .. math::
+        \mathrm{B} = \frac{(a-1)! (b-1)!}{(a+b-1)!}
+
+    A special case of the Beta function when `x = y` is the
+    Central Beta function. It satisfies properties like:
+
+    .. math::
+        \mathrm{B}(x) = 2^{1 - 2x}\mathrm{B}(x, \frac{1}{2})
+        \mathrm{B}(x) = 2^{1 - 2x} cos(\pi x) \mathrm{B}(\frac{1}{2} - x, x)
+        \mathrm{B}(x) = \int_{0}^{1} \frac{t^x}{(1 + t)^{2x}} dt
+        \mathrm{B}(x) = \frac{2}{x} \prod_{n = 1}^{\infty} \frac{n(n + 2x)}{(n + x)^2}
+
+    Examples
+    ========
+
+    >>> from sympy import I, pi
+    >>> from sympy.abc import x, y
+
+    The Beta function obeys the mirror symmetry:
+
+    >>> from sympy import beta, conjugate
+    >>> conjugate(beta(x, y))
+    beta(conjugate(x), conjugate(y))
+
+    Differentiation with respect to both $x$ and $y$ is supported:
+
+    >>> from sympy import beta, diff
+    >>> diff(beta(x, y), x)
+    (polygamma(0, x) - polygamma(0, x + y))*beta(x, y)
+
+    >>> diff(beta(x, y), y)
+    (polygamma(0, y) - polygamma(0, x + y))*beta(x, y)
+
+    >>> diff(beta(x), x)
+    2*(polygamma(0, x) - polygamma(0, 2*x))*beta(x, x)
+
+    We can numerically evaluate the Beta function to
+    arbitrary precision for any complex numbers x and y:
+
+    >>> from sympy import beta
+    >>> beta(pi).evalf(40)
+    0.02671848900111377452242355235388489324562
+
+    >>> beta(1 + I).evalf(20)
+    -0.2112723729365330143 - 0.7655283165378005676*I
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    uppergamma: Upper incomplete gamma function.
+    lowergamma: Lower incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function
+    .. [2] https://mathworld.wolfram.com/BetaFunction.html
+    .. [3] https://dlmf.nist.gov/5.12
+
+    """
+    unbranched = True
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            # Diff wrt x
+            return beta(x, y)*(digamma(x) - digamma(x + y))
+        elif argindex == 2:
+            # Diff wrt y
+            return beta(x, y)*(digamma(y) - digamma(x + y))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y=None):
+        if y is None:
+            return beta(x, x)
+        if x.is_Number and y.is_Number:
+            return beta(x, y, evaluate=False).doit()
+
+    def doit(self, **hints):
+        x = xold = self.args[0]
+        # Deal with unevaluated single argument beta
+        single_argument = len(self.args) == 1
+        y = yold = self.args[0] if single_argument else self.args[1]
+        if hints.get('deep', True):
+            x = x.doit(**hints)
+            y = y.doit(**hints)
+        if y.is_zero or x.is_zero:
+            return S.ComplexInfinity
+        if y is S.One:
+            return 1/x
+        if x is S.One:
+            return 1/y
+        if y == x + 1:
+            return 1/(x*y*catalan(x))
+        s = x + y
+        if (s.is_integer and s.is_negative and x.is_integer is False and
+            y.is_integer is False):
+            return S.Zero
+        if x == xold and y == yold and not single_argument:
+            return self
+        return beta(x, y)
+
+    def _eval_expand_func(self, **hints):
+        x, y = self.args
+        return gamma(x)*gamma(y) / gamma(x + y)
+
+    def _eval_is_real(self):
+        return self.args[0].is_real and self.args[1].is_real
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate(), self.args[1].conjugate())
+
+    def _eval_rewrite_as_gamma(self, x, y, piecewise=True, **kwargs):
+        return self._eval_expand_func(**kwargs)
+
+    def _eval_rewrite_as_Integral(self, x, y, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [x, y]).name)
+        return Integral(t**(x - 1)*(1 - t)**(y - 1), (t, 0, 1))
+
+###############################################################################
+########################## INCOMPLETE BETA FUNCTION ###########################
+###############################################################################
+
+class betainc(DefinedFunction):
+    r"""
+    The Generalized Incomplete Beta function is defined as
+
+    .. math::
+        \mathrm{B}_{(x_1, x_2)}(a, b) = \int_{x_1}^{x_2} t^{a - 1} (1 - t)^{b - 1} dt
+
+    The Incomplete Beta function is a special case
+    of the Generalized Incomplete Beta function :
+
+    .. math:: \mathrm{B}_z (a, b) = \mathrm{B}_{(0, z)}(a, b)
+
+    The Incomplete Beta function satisfies :
+
+    .. math:: \mathrm{B}_z (a, b) = (-1)^a \mathrm{B}_{\frac{z}{z - 1}} (a, 1 - a - b)
+
+    The Beta function is a special case of the Incomplete Beta function :
+
+    .. math:: \mathrm{B}(a, b) = \mathrm{B}_{1}(a, b)
+
+    Examples
+    ========
+
+    >>> from sympy import betainc, symbols, conjugate
+    >>> a, b, x, x1, x2 = symbols('a b x x1 x2')
+
+    The Generalized Incomplete Beta function is given by:
+
+    >>> betainc(a, b, x1, x2)
+    betainc(a, b, x1, x2)
+
+    The Incomplete Beta function can be obtained as follows:
+
+    >>> betainc(a, b, 0, x)
+    betainc(a, b, 0, x)
+
+    The Incomplete Beta function obeys the mirror symmetry:
+
+    >>> conjugate(betainc(a, b, x1, x2))
+    betainc(conjugate(a), conjugate(b), conjugate(x1), conjugate(x2))
+
+    We can numerically evaluate the Incomplete Beta function to
+    arbitrary precision for any complex numbers a, b, x1 and x2:
+
+    >>> from sympy import betainc, I
+    >>> betainc(2, 3, 4, 5).evalf(10)
+    56.08333333
+    >>> betainc(0.75, 1 - 4*I, 0, 2 + 3*I).evalf(25)
+    0.2241657956955709603655887 + 0.3619619242700451992411724*I
+
+    The Generalized Incomplete Beta function can be expressed
+    in terms of the Generalized Hypergeometric function.
+
+    >>> from sympy import hyper
+    >>> betainc(a, b, x1, x2).rewrite(hyper)
+    (-x1**a*hyper((a, 1 - b), (a + 1,), x1) + x2**a*hyper((a, 1 - b), (a + 1,), x2))/a
+
+    See Also
+    ========
+
+    beta: Beta function
+    hyper: Generalized Hypergeometric function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function
+    .. [2] https://dlmf.nist.gov/8.17
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Beta4/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/BetaRegularized4/02/
+
+    """
+    nargs = 4
+    unbranched = True
+
+    def fdiff(self, argindex):
+        a, b, x1, x2 = self.args
+        if argindex == 3:
+            # Diff wrt x1
+            return -(1 - x1)**(b - 1)*x1**(a - 1)
+        elif argindex == 4:
+            # Diff wrt x2
+            return (1 - x2)**(b - 1)*x2**(a - 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_mpmath(self):
+        return betainc_mpmath_fix, self.args
+
+    def _eval_is_real(self):
+        if all(arg.is_real for arg in self.args):
+            return True
+
+    def _eval_conjugate(self):
+        return self.func(*map(conjugate, self.args))
+
+    def _eval_rewrite_as_Integral(self, a, b, x1, x2, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [a, b, x1, x2]).name)
+        return Integral(t**(a - 1)*(1 - t)**(b - 1), (t, x1, x2))
+
+    def _eval_rewrite_as_hyper(self, a, b, x1, x2, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        return (x2**a * hyper((a, 1 - b), (a + 1,), x2) - x1**a * hyper((a, 1 - b), (a + 1,), x1)) / a
+
+###############################################################################
+#################### REGULARIZED INCOMPLETE BETA FUNCTION #####################
+###############################################################################
+
+class betainc_regularized(DefinedFunction):
+    r"""
+    The Generalized Regularized Incomplete Beta function is given by
+
+    .. math::
+        \mathrm{I}_{(x_1, x_2)}(a, b) = \frac{\mathrm{B}_{(x_1, x_2)}(a, b)}{\mathrm{B}(a, b)}
+
+    The Regularized Incomplete Beta function is a special case
+    of the Generalized Regularized Incomplete Beta function :
+
+    .. math:: \mathrm{I}_z (a, b) = \mathrm{I}_{(0, z)}(a, b)
+
+    The Regularized Incomplete Beta function is the cumulative distribution
+    function of the beta distribution.
+
+    Examples
+    ========
+
+    >>> from sympy import betainc_regularized, symbols, conjugate
+    >>> a, b, x, x1, x2 = symbols('a b x x1 x2')
+
+    The Generalized Regularized Incomplete Beta
+    function is given by:
+
+    >>> betainc_regularized(a, b, x1, x2)
+    betainc_regularized(a, b, x1, x2)
+
+    The Regularized Incomplete Beta function
+    can be obtained as follows:
+
+    >>> betainc_regularized(a, b, 0, x)
+    betainc_regularized(a, b, 0, x)
+
+    The Regularized Incomplete Beta function
+    obeys the mirror symmetry:
+
+    >>> conjugate(betainc_regularized(a, b, x1, x2))
+    betainc_regularized(conjugate(a), conjugate(b), conjugate(x1), conjugate(x2))
+
+    We can numerically evaluate the Regularized Incomplete Beta function
+    to arbitrary precision for any complex numbers a, b, x1 and x2:
+
+    >>> from sympy import betainc_regularized, pi, E
+    >>> betainc_regularized(1, 2, 0, 0.25).evalf(10)
+    0.4375000000
+    >>> betainc_regularized(pi, E, 0, 1).evalf(5)
+    1.00000
+
+    The Generalized Regularized Incomplete Beta function can be
+    expressed in terms of the Generalized Hypergeometric function.
+
+    >>> from sympy import hyper
+    >>> betainc_regularized(a, b, x1, x2).rewrite(hyper)
+    (-x1**a*hyper((a, 1 - b), (a + 1,), x1) + x2**a*hyper((a, 1 - b), (a + 1,), x2))/(a*beta(a, b))
+
+    See Also
+    ========
+
+    beta: Beta function
+    hyper: Generalized Hypergeometric function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Beta_function#Incomplete_beta_function
+    .. [2] https://dlmf.nist.gov/8.17
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Beta4/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/BetaRegularized4/02/
+
+    """
+    nargs = 4
+    unbranched = True
+
+    def __new__(cls, a, b, x1, x2):
+        return super().__new__(cls, a, b, x1, x2)
+
+    def _eval_mpmath(self):
+        return betainc_mpmath_fix, (*self.args, S(1))
+
+    def fdiff(self, argindex):
+        a, b, x1, x2 = self.args
+        if argindex == 3:
+            # Diff wrt x1
+            return -(1 - x1)**(b - 1)*x1**(a - 1) / beta(a, b)
+        elif argindex == 4:
+            # Diff wrt x2
+            return (1 - x2)**(b - 1)*x2**(a - 1) / beta(a, b)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_real(self):
+        if all(arg.is_real for arg in self.args):
+            return True
+
+    def _eval_conjugate(self):
+        return self.func(*map(conjugate, self.args))
+
+    def _eval_rewrite_as_Integral(self, a, b, x1, x2, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [a, b, x1, x2]).name)
+        integrand = t**(a - 1)*(1 - t)**(b - 1)
+        expr = Integral(integrand, (t, x1, x2))
+        return expr / Integral(integrand, (t, 0, 1))
+
+    def _eval_rewrite_as_hyper(self, a, b, x1, x2, **kwargs):
+        from sympy.functions.special.hyper import hyper
+        expr = (x2**a * hyper((a, 1 - b), (a + 1,), x2) - x1**a * hyper((a, 1 - b), (a + 1,), x1)) / a
+        return expr / beta(a, b)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/bsplines.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/bsplines.py
new file mode 100644
index 0000000000000000000000000000000000000000..50c9141e841288aa02457c466fc6573f9a20d09f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/bsplines.py
@@ -0,0 +1,348 @@
+from sympy.core import S, sympify
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions import Piecewise, piecewise_fold
+from sympy.logic.boolalg import And
+from sympy.sets.sets import Interval
+
+from functools import lru_cache
+
+
+def _ivl(cond, x):
+    """return the interval corresponding to the condition
+
+    Conditions in spline's Piecewise give the range over
+    which an expression is valid like (lo <= x) & (x <= hi).
+    This function returns (lo, hi).
+    """
+    if isinstance(cond, And) and len(cond.args) == 2:
+        a, b = cond.args
+        if a.lts == x:
+            a, b = b, a
+        return a.lts, b.gts
+    raise TypeError('unexpected cond type: %s' % cond)
+
+
+def _add_splines(c, b1, d, b2, x):
+    """Construct c*b1 + d*b2."""
+
+    if S.Zero in (b1, c):
+        rv = piecewise_fold(d * b2)
+    elif S.Zero in (b2, d):
+        rv = piecewise_fold(c * b1)
+    else:
+        new_args = []
+        # Just combining the Piecewise without any fancy optimization
+        p1 = piecewise_fold(c * b1)
+        p2 = piecewise_fold(d * b2)
+
+        # Search all Piecewise arguments except (0, True)
+        p2args = list(p2.args[:-1])
+
+        # This merging algorithm assumes the conditions in
+        # p1 and p2 are sorted
+        for arg in p1.args[:-1]:
+            expr = arg.expr
+            cond = arg.cond
+
+            lower = _ivl(cond, x)[0]
+
+            # Check p2 for matching conditions that can be merged
+            for i, arg2 in enumerate(p2args):
+                expr2 = arg2.expr
+                cond2 = arg2.cond
+
+                lower_2, upper_2 = _ivl(cond2, x)
+                if cond2 == cond:
+                    # Conditions match, join expressions
+                    expr += expr2
+                    # Remove matching element
+                    del p2args[i]
+                    # No need to check the rest
+                    break
+                elif lower_2 < lower and upper_2 <= lower:
+                    # Check if arg2 condition smaller than arg1,
+                    # add to new_args by itself (no match expected
+                    # in p1)
+                    new_args.append(arg2)
+                    del p2args[i]
+                    break
+
+            # Checked all, add expr and cond
+            new_args.append((expr, cond))
+
+        # Add remaining items from p2args
+        new_args.extend(p2args)
+
+        # Add final (0, True)
+        new_args.append((0, True))
+
+        rv = Piecewise(*new_args, evaluate=False)
+
+    return rv.expand()
+
+
+@lru_cache(maxsize=128)
+def bspline_basis(d, knots, n, x):
+    """
+    The $n$-th B-spline at $x$ of degree $d$ with knots.
+
+    Explanation
+    ===========
+
+    B-Splines are piecewise polynomials of degree $d$. They are defined on a
+    set of knots, which is a sequence of integers or floats.
+
+    Examples
+    ========
+
+    The 0th degree splines have a value of 1 on a single interval:
+
+        >>> from sympy import bspline_basis
+        >>> from sympy.abc import x
+        >>> d = 0
+        >>> knots = tuple(range(5))
+        >>> bspline_basis(d, knots, 0, x)
+        Piecewise((1, (x >= 0) & (x <= 1)), (0, True))
+
+    For a given ``(d, knots)`` there are ``len(knots)-d-1`` B-splines
+    defined, that are indexed by ``n`` (starting at 0).
+
+    Here is an example of a cubic B-spline:
+
+        >>> bspline_basis(3, tuple(range(5)), 0, x)
+        Piecewise((x**3/6, (x >= 0) & (x <= 1)),
+                  (-x**3/2 + 2*x**2 - 2*x + 2/3,
+                  (x >= 1) & (x <= 2)),
+                  (x**3/2 - 4*x**2 + 10*x - 22/3,
+                  (x >= 2) & (x <= 3)),
+                  (-x**3/6 + 2*x**2 - 8*x + 32/3,
+                  (x >= 3) & (x <= 4)),
+                  (0, True))
+
+    By repeating knot points, you can introduce discontinuities in the
+    B-splines and their derivatives:
+
+        >>> d = 1
+        >>> knots = (0, 0, 2, 3, 4)
+        >>> bspline_basis(d, knots, 0, x)
+        Piecewise((1 - x/2, (x >= 0) & (x <= 2)), (0, True))
+
+    It is quite time consuming to construct and evaluate B-splines. If
+    you need to evaluate a B-spline many times, it is best to lambdify them
+    first:
+
+        >>> from sympy import lambdify
+        >>> d = 3
+        >>> knots = tuple(range(10))
+        >>> b0 = bspline_basis(d, knots, 0, x)
+        >>> f = lambdify(x, b0)
+        >>> y = f(0.5)
+
+    Parameters
+    ==========
+
+    d : integer
+        degree of bspline
+
+    knots : list of integer values
+        list of knots points of bspline
+
+    n : integer
+        $n$-th B-spline
+
+    x : symbol
+
+    See Also
+    ========
+
+    bspline_basis_set
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/B-spline
+
+    """
+    # make sure x has no assumptions so conditions don't evaluate
+    xvar = x
+    x = Dummy()
+
+    knots = tuple(sympify(k) for k in knots)
+    d = int(d)
+    n = int(n)
+    n_knots = len(knots)
+    n_intervals = n_knots - 1
+    if n + d + 1 > n_intervals:
+        raise ValueError("n + d + 1 must not exceed len(knots) - 1")
+    if d == 0:
+        result = Piecewise(
+            (S.One, Interval(knots[n], knots[n + 1]).contains(x)), (0, True)
+        )
+    elif d > 0:
+        denom = knots[n + d + 1] - knots[n + 1]
+        if denom != S.Zero:
+            B = (knots[n + d + 1] - x) / denom
+            b2 = bspline_basis(d - 1, knots, n + 1, x)
+        else:
+            b2 = B = S.Zero
+
+        denom = knots[n + d] - knots[n]
+        if denom != S.Zero:
+            A = (x - knots[n]) / denom
+            b1 = bspline_basis(d - 1, knots, n, x)
+        else:
+            b1 = A = S.Zero
+
+        result = _add_splines(A, b1, B, b2, x)
+    else:
+        raise ValueError("degree must be non-negative: %r" % n)
+
+    # return result with user-given x
+    return result.xreplace({x: xvar})
+
+
+def bspline_basis_set(d, knots, x):
+    """
+    Return the ``len(knots)-d-1`` B-splines at *x* of degree *d*
+    with *knots*.
+
+    Explanation
+    ===========
+
+    This function returns a list of piecewise polynomials that are the
+    ``len(knots)-d-1`` B-splines of degree *d* for the given knots.
+    This function calls ``bspline_basis(d, knots, n, x)`` for different
+    values of *n*.
+
+    Examples
+    ========
+
+    >>> from sympy import bspline_basis_set
+    >>> from sympy.abc import x
+    >>> d = 2
+    >>> knots = range(5)
+    >>> splines = bspline_basis_set(d, knots, x)
+    >>> splines
+    [Piecewise((x**2/2, (x >= 0) & (x <= 1)),
+               (-x**2 + 3*x - 3/2, (x >= 1) & (x <= 2)),
+               (x**2/2 - 3*x + 9/2, (x >= 2) & (x <= 3)),
+               (0, True)),
+    Piecewise((x**2/2 - x + 1/2, (x >= 1) & (x <= 2)),
+              (-x**2 + 5*x - 11/2, (x >= 2) & (x <= 3)),
+              (x**2/2 - 4*x + 8, (x >= 3) & (x <= 4)),
+              (0, True))]
+
+    Parameters
+    ==========
+
+    d : integer
+        degree of bspline
+
+    knots : list of integers
+        list of knots points of bspline
+
+    x : symbol
+
+    See Also
+    ========
+
+    bspline_basis
+
+    """
+    n_splines = len(knots) - d - 1
+    return [bspline_basis(d, tuple(knots), i, x) for i in range(n_splines)]
+
+
+def interpolating_spline(d, x, X, Y):
+    """
+    Return spline of degree *d*, passing through the given *X*
+    and *Y* values.
+
+    Explanation
+    ===========
+
+    This function returns a piecewise function such that each part is
+    a polynomial of degree not greater than *d*. The value of *d*
+    must be 1 or greater and the values of *X* must be strictly
+    increasing.
+
+    Examples
+    ========
+
+    >>> from sympy import interpolating_spline
+    >>> from sympy.abc import x
+    >>> interpolating_spline(1, x, [1, 2, 4, 7], [3, 6, 5, 7])
+    Piecewise((3*x, (x >= 1) & (x <= 2)),
+            (7 - x/2, (x >= 2) & (x <= 4)),
+            (2*x/3 + 7/3, (x >= 4) & (x <= 7)))
+    >>> interpolating_spline(3, x, [-2, 0, 1, 3, 4], [4, 2, 1, 1, 3])
+    Piecewise((7*x**3/117 + 7*x**2/117 - 131*x/117 + 2, (x >= -2) & (x <= 1)),
+            (10*x**3/117 - 2*x**2/117 - 122*x/117 + 77/39, (x >= 1) & (x <= 4)))
+
+    Parameters
+    ==========
+
+    d : integer
+        Degree of Bspline strictly greater than equal to one
+
+    x : symbol
+
+    X : list of strictly increasing real values
+        list of X coordinates through which the spline passes
+
+    Y : list of real values
+        list of corresponding Y coordinates through which the spline passes
+
+    See Also
+    ========
+
+    bspline_basis_set, interpolating_poly
+
+    """
+    from sympy.solvers.solveset import linsolve
+    from sympy.matrices.dense import Matrix
+
+    # Input sanitization
+    d = sympify(d)
+    if not (d.is_Integer and d.is_positive):
+        raise ValueError("Spline degree must be a positive integer, not %s." % d)
+    if len(X) != len(Y):
+        raise ValueError("Number of X and Y coordinates must be the same.")
+    if len(X) < d + 1:
+        raise ValueError("Degree must be less than the number of control points.")
+    if not all(a < b for a, b in zip(X, X[1:])):
+        raise ValueError("The x-coordinates must be strictly increasing.")
+    X = [sympify(i) for i in X]
+
+    # Evaluating knots value
+    if d.is_odd:
+        j = (d + 1) // 2
+        interior_knots = X[j:-j]
+    else:
+        j = d // 2
+        interior_knots = [
+            (a + b)/2 for a, b in zip(X[j : -j - 1], X[j + 1 : -j])
+        ]
+
+    knots = [X[0]] * (d + 1) + list(interior_knots) + [X[-1]] * (d + 1)
+
+    basis = bspline_basis_set(d, knots, x)
+
+    A = [[b.subs(x, v) for b in basis] for v in X]
+
+    coeff = linsolve((Matrix(A), Matrix(Y)), symbols("c0:{}".format(len(X)), cls=Dummy))
+    coeff = list(coeff)[0]
+    intervals = {c for b in basis for (e, c) in b.args if c != True}
+
+    # Sorting the intervals
+    #  ival contains the end-points of each interval
+    intervals = sorted(intervals, key=lambda c: _ivl(c, x))
+
+    basis_dicts = [{c: e for (e, c) in b.args} for b in basis]
+    spline = []
+    for i in intervals:
+        piece = sum(
+            [c * d.get(i, S.Zero) for (c, d) in zip(coeff, basis_dicts)], S.Zero
+        )
+        spline.append((piece, i))
+    return Piecewise(*spline)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/delta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/delta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..698d8c0c3ba5e68c2f084e83e7a9ec070ce83307
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/delta_functions.py
@@ -0,0 +1,664 @@
+from sympy.core import S, diff
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Eq, Ne
+from sympy.functions.elementary.complexes import im, sign
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.polys.polyerrors import PolynomialError
+from sympy.polys.polyroots import roots
+from sympy.utilities.misc import filldedent
+
+
+###############################################################################
+################################ DELTA FUNCTION ###############################
+###############################################################################
+
+
+class DiracDelta(DefinedFunction):
+    r"""
+    The DiracDelta function and its derivatives.
+
+    Explanation
+    ===========
+
+    DiracDelta is not an ordinary function. It can be rigorously defined either
+    as a distribution or as a measure.
+
+    DiracDelta only makes sense in definite integrals, and in particular,
+    integrals of the form ``Integral(f(x)*DiracDelta(x - x0), (x, a, b))``,
+    where it equals ``f(x0)`` if ``a <= x0 <= b`` and ``0`` otherwise. Formally,
+    DiracDelta acts in some ways like a function that is ``0`` everywhere except
+    at ``0``, but in many ways it also does not. It can often be useful to treat
+    DiracDelta in formal ways, building up and manipulating expressions with
+    delta functions (which may eventually be integrated), but care must be taken
+    to not treat it as a real function. SymPy's ``oo`` is similar. It only
+    truly makes sense formally in certain contexts (such as integration limits),
+    but SymPy allows its use everywhere, and it tries to be consistent with
+    operations on it (like ``1/oo``), but it is easy to get into trouble and get
+    wrong results if ``oo`` is treated too much like a number. Similarly, if
+    DiracDelta is treated too much like a function, it is easy to get wrong or
+    nonsensical results.
+
+    DiracDelta function has the following properties:
+
+    1) $\frac{d}{d x} \theta(x) = \delta(x)$
+    2) $\int_{-\infty}^\infty \delta(x - a)f(x)\, dx = f(a)$ and $\int_{a-
+       \epsilon}^{a+\epsilon} \delta(x - a)f(x)\, dx = f(a)$
+    3) $\delta(x) = 0$ for all $x \neq 0$
+    4) $\delta(g(x)) = \sum_i \frac{\delta(x - x_i)}{\|g'(x_i)\|}$ where $x_i$
+       are the roots of $g$
+    5) $\delta(-x) = \delta(x)$
+
+    Derivatives of ``k``-th order of DiracDelta have the following properties:
+
+    6) $\delta(x, k) = 0$ for all $x \neq 0$
+    7) $\delta(-x, k) = -\delta(x, k)$ for odd $k$
+    8) $\delta(-x, k) = \delta(x, k)$ for even $k$
+
+    Examples
+    ========
+
+    >>> from sympy import DiracDelta, diff, pi
+    >>> from sympy.abc import x, y
+
+    >>> DiracDelta(x)
+    DiracDelta(x)
+    >>> DiracDelta(1)
+    0
+    >>> DiracDelta(-1)
+    0
+    >>> DiracDelta(pi)
+    0
+    >>> DiracDelta(x - 4).subs(x, 4)
+    DiracDelta(0)
+    >>> diff(DiracDelta(x))
+    DiracDelta(x, 1)
+    >>> diff(DiracDelta(x - 1), x, 2)
+    DiracDelta(x - 1, 2)
+    >>> diff(DiracDelta(x**2 - 1), x, 2)
+    2*(2*x**2*DiracDelta(x**2 - 1, 2) + DiracDelta(x**2 - 1, 1))
+    >>> DiracDelta(3*x).is_simple(x)
+    True
+    >>> DiracDelta(x**2).is_simple(x)
+    False
+    >>> DiracDelta((x**2 - 1)*y).expand(diracdelta=True, wrt=x)
+    DiracDelta(x - 1)/(2*Abs(y)) + DiracDelta(x + 1)/(2*Abs(y))
+
+    See Also
+    ========
+
+    Heaviside
+    sympy.simplify.simplify.simplify, is_simple
+    sympy.functions.special.tensor_functions.KroneckerDelta
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/DeltaFunction.html
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a DiracDelta Function.
+
+        Explanation
+        ===========
+
+        The difference between ``diff()`` and ``fdiff()`` is: ``diff()`` is the
+        user-level function and ``fdiff()`` is an object method. ``fdiff()`` is
+        a convenience method available in the ``Function`` class. It returns
+        the derivative of the function without considering the chain rule.
+        ``diff(function, x)`` calls ``Function._eval_derivative`` which in turn
+        calls ``fdiff()`` internally to compute the derivative of the function.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, diff
+        >>> from sympy.abc import x
+
+        >>> DiracDelta(x).fdiff()
+        DiracDelta(x, 1)
+
+        >>> DiracDelta(x, 1).fdiff()
+        DiracDelta(x, 2)
+
+        >>> DiracDelta(x**2 - 1).fdiff()
+        DiracDelta(x**2 - 1, 1)
+
+        >>> diff(DiracDelta(x, 1)).fdiff()
+        DiracDelta(x, 3)
+
+        Parameters
+        ==========
+
+        argindex : integer
+            degree of derivative
+
+        """
+        if argindex == 1:
+            #I didn't know if there is a better way to handle default arguments
+            k = 0
+            if len(self.args) > 1:
+                k = self.args[1]
+            return self.func(self.args[0], k + 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg, k=S.Zero):
+        """
+        Returns a simplified form or a value of DiracDelta depending on the
+        argument passed by the DiracDelta object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the ``DiracDelta``
+        class is about to be instantiated and it returns either some simplified
+        instance or the unevaluated instance depending on the argument passed.
+        In other words, ``eval()`` method is not needed to be called explicitly,
+        it is being called and evaluated once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, S
+        >>> from sympy.abc import x
+
+        >>> DiracDelta(x)
+        DiracDelta(x)
+
+        >>> DiracDelta(-x, 1)
+        -DiracDelta(x, 1)
+
+        >>> DiracDelta(1)
+        0
+
+        >>> DiracDelta(5, 1)
+        0
+
+        >>> DiracDelta(0)
+        DiracDelta(0)
+
+        >>> DiracDelta(-1)
+        0
+
+        >>> DiracDelta(S.NaN)
+        nan
+
+        >>> DiracDelta(x - 100).subs(x, 5)
+        0
+
+        >>> DiracDelta(x - 100).subs(x, 100)
+        DiracDelta(0)
+
+        Parameters
+        ==========
+
+        k : integer
+            order of derivative
+
+        arg : argument passed to DiracDelta
+
+        """
+        if not k.is_Integer or k.is_negative:
+            raise ValueError("Error: the second argument of DiracDelta must be \
+            a non-negative integer, %s given instead." % (k,))
+        if arg is S.NaN:
+            return S.NaN
+        if arg.is_nonzero:
+            return S.Zero
+        if fuzzy_not(im(arg).is_zero):
+            raise ValueError(filldedent('''
+                Function defined only for Real Values.
+                Complex part: %s  found in %s .''' % (
+                repr(im(arg)), repr(arg))))
+        c, nc = arg.args_cnc()
+        if c and c[0] is S.NegativeOne:
+            # keep this fast and simple instead of using
+            # could_extract_minus_sign
+            if k.is_odd:
+                return -cls(-arg, k)
+            elif k.is_even:
+                return cls(-arg, k) if k else cls(-arg)
+        elif k.is_zero:
+            return cls(arg, evaluate=False)
+
+    def _eval_expand_diracdelta(self, **hints):
+        """
+        Compute a simplified representation of the function using
+        property number 4. Pass ``wrt`` as a hint to expand the expression
+        with respect to a particular variable.
+
+        Explanation
+        ===========
+
+        ``wrt`` is:
+
+        - a variable with respect to which a DiracDelta expression will
+        get expanded.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta
+        >>> from sympy.abc import x, y
+
+        >>> DiracDelta(x*y).expand(diracdelta=True, wrt=x)
+        DiracDelta(x)/Abs(y)
+        >>> DiracDelta(x*y).expand(diracdelta=True, wrt=y)
+        DiracDelta(y)/Abs(x)
+
+        >>> DiracDelta(x**2 + x - 2).expand(diracdelta=True, wrt=x)
+        DiracDelta(x - 1)/3 + DiracDelta(x + 2)/3
+
+        See Also
+        ========
+
+        is_simple, Diracdelta
+
+        """
+        wrt = hints.get('wrt', None)
+        if wrt is None:
+            free = self.free_symbols
+            if len(free) == 1:
+                wrt = free.pop()
+            else:
+                raise TypeError(filldedent('''
+            When there is more than 1 free symbol or variable in the expression,
+            the 'wrt' keyword is required as a hint to expand when using the
+            DiracDelta hint.'''))
+
+        if not self.args[0].has(wrt) or (len(self.args) > 1 and self.args[1] != 0 ):
+            return self
+        try:
+            argroots = roots(self.args[0], wrt)
+            result = 0
+            valid = True
+            darg = abs(diff(self.args[0], wrt))
+            for r, m in argroots.items():
+                if r.is_real is not False and m == 1:
+                    result += self.func(wrt - r)/darg.subs(wrt, r)
+                else:
+                    # don't handle non-real and if m != 1 then
+                    # a polynomial will have a zero in the derivative (darg)
+                    # at r
+                    valid = False
+                    break
+            if valid:
+                return result
+        except PolynomialError:
+            pass
+        return self
+
+    def is_simple(self, x):
+        """
+        Tells whether the argument(args[0]) of DiracDelta is a linear
+        expression in *x*.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, cos
+        >>> from sympy.abc import x, y
+
+        >>> DiracDelta(x*y).is_simple(x)
+        True
+        >>> DiracDelta(x*y).is_simple(y)
+        True
+
+        >>> DiracDelta(x**2 + x - 2).is_simple(x)
+        False
+
+        >>> DiracDelta(cos(x)).is_simple(x)
+        False
+
+        Parameters
+        ==========
+
+        x : can be a symbol
+
+        See Also
+        ========
+
+        sympy.simplify.simplify.simplify, DiracDelta
+
+        """
+        p = self.args[0].as_poly(x)
+        if p:
+            return p.degree() == 1
+        return False
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        """
+        Represents DiracDelta in a piecewise form.
+
+        Examples
+        ========
+
+        >>> from sympy import DiracDelta, Piecewise, Symbol
+        >>> x = Symbol('x')
+
+        >>> DiracDelta(x).rewrite(Piecewise)
+        Piecewise((DiracDelta(0), Eq(x, 0)), (0, True))
+
+        >>> DiracDelta(x - 5).rewrite(Piecewise)
+        Piecewise((DiracDelta(0), Eq(x, 5)), (0, True))
+
+        >>> DiracDelta(x**2 - 5).rewrite(Piecewise)
+           Piecewise((DiracDelta(0), Eq(x**2, 5)), (0, True))
+
+        >>> DiracDelta(x - 5, 4).rewrite(Piecewise)
+        DiracDelta(x - 5, 4)
+
+        """
+        if len(args) == 1:
+            return Piecewise((DiracDelta(0), Eq(args[0], 0)), (0, True))
+
+    def _eval_rewrite_as_SingularityFunction(self, *args, **kwargs):
+        """
+        Returns the DiracDelta expression written in the form of Singularity
+        Functions.
+
+        """
+        from sympy.solvers import solve
+        from sympy.functions.special.singularity_functions import SingularityFunction
+        if self == DiracDelta(0):
+            return SingularityFunction(0, 0, -1)
+        if self == DiracDelta(0, 1):
+            return SingularityFunction(0, 0, -2)
+        free = self.free_symbols
+        if len(free) == 1:
+            x = (free.pop())
+            if len(args) == 1:
+                return SingularityFunction(x, solve(args[0], x)[0], -1)
+            return SingularityFunction(x, solve(args[0], x)[0], -args[1] - 1)
+        else:
+            # I don't know how to handle the case for DiracDelta expressions
+            # having arguments with more than one variable.
+            raise TypeError(filldedent('''
+                rewrite(SingularityFunction) does not support
+                arguments with more that one variable.'''))
+
+
+###############################################################################
+############################## HEAVISIDE FUNCTION #############################
+###############################################################################
+
+
+class Heaviside(DefinedFunction):
+    r"""
+    Heaviside step function.
+
+    Explanation
+    ===========
+
+    The Heaviside step function has the following properties:
+
+    1) $\frac{d}{d x} \theta(x) = \delta(x)$
+    2) $\theta(x) = \begin{cases} 0 & \text{for}\: x < 0 \\ \frac{1}{2} &
+       \text{for}\: x = 0 \\1 & \text{for}\: x > 0 \end{cases}$
+    3) $\frac{d}{d x} \max(x, 0) = \theta(x)$
+
+    Heaviside(x) is printed as $\theta(x)$ with the SymPy LaTeX printer.
+
+    The value at 0 is set differently in different fields. SymPy uses 1/2,
+    which is a convention from electronics and signal processing, and is
+    consistent with solving improper integrals by Fourier transform and
+    convolution.
+
+    To specify a different value of Heaviside at ``x=0``, a second argument
+    can be given. Using ``Heaviside(x, nan)`` gives an expression that will
+    evaluate to nan for x=0.
+
+    .. versionchanged:: 1.9 ``Heaviside(0)`` now returns 1/2 (before: undefined)
+
+    Examples
+    ========
+
+    >>> from sympy import Heaviside, nan
+    >>> from sympy.abc import x
+    >>> Heaviside(9)
+    1
+    >>> Heaviside(-9)
+    0
+    >>> Heaviside(0)
+    1/2
+    >>> Heaviside(0, nan)
+    nan
+    >>> (Heaviside(x) + 1).replace(Heaviside(x), Heaviside(x, 1))
+    Heaviside(x, 1) + 1
+
+    See Also
+    ========
+
+    DiracDelta
+
+    References
+    ==========
+
+    .. [1] https://mathworld.wolfram.com/HeavisideStepFunction.html
+    .. [2] https://dlmf.nist.gov/1.16#iv
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a Heaviside Function.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, diff
+        >>> from sympy.abc import x
+
+        >>> Heaviside(x).fdiff()
+        DiracDelta(x)
+
+        >>> Heaviside(x**2 - 1).fdiff()
+        DiracDelta(x**2 - 1)
+
+        >>> diff(Heaviside(x)).fdiff()
+        DiracDelta(x, 1)
+
+        Parameters
+        ==========
+
+        argindex : integer
+            order of derivative
+
+        """
+        if argindex == 1:
+            return DiracDelta(self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def __new__(cls, arg, H0=S.Half, **options):
+        if isinstance(H0, Heaviside) and len(H0.args) == 1:
+            H0 = S.Half
+        return super(cls, cls).__new__(cls, arg, H0, **options)
+
+    @property
+    def pargs(self):
+        """Args without default S.Half"""
+        args = self.args
+        if args[1] is S.Half:
+            args = args[:1]
+        return args
+
+    @classmethod
+    def eval(cls, arg, H0=S.Half):
+        """
+        Returns a simplified form or a value of Heaviside depending on the
+        argument passed by the Heaviside object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the ``Heaviside``
+        class is about to be instantiated and it returns either some simplified
+        instance or the unevaluated instance depending on the argument passed.
+        In other words, ``eval()`` method is not needed to be called explicitly,
+        it is being called and evaluated once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, S
+        >>> from sympy.abc import x
+
+        >>> Heaviside(x)
+        Heaviside(x)
+
+        >>> Heaviside(19)
+        1
+
+        >>> Heaviside(0)
+        1/2
+
+        >>> Heaviside(0, 1)
+        1
+
+        >>> Heaviside(-5)
+        0
+
+        >>> Heaviside(S.NaN)
+        nan
+
+        >>> Heaviside(x - 100).subs(x, 5)
+        0
+
+        >>> Heaviside(x - 100).subs(x, 105)
+        1
+
+        Parameters
+        ==========
+
+        arg : argument passed by Heaviside object
+
+        H0 : value of Heaviside(0)
+
+        """
+        if arg.is_extended_negative:
+            return S.Zero
+        elif arg.is_extended_positive:
+            return S.One
+        elif arg.is_zero:
+            return H0
+        elif arg is S.NaN:
+            return S.NaN
+        elif fuzzy_not(im(arg).is_zero):
+            raise ValueError("Function defined only for Real Values. Complex part: %s  found in %s ." % (repr(im(arg)), repr(arg)) )
+
+    def _eval_rewrite_as_Piecewise(self, arg, H0=None, **kwargs):
+        """
+        Represents Heaviside in a Piecewise form.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, Piecewise, Symbol, nan
+        >>> x = Symbol('x')
+
+        >>> Heaviside(x).rewrite(Piecewise)
+        Piecewise((0, x < 0), (1/2, Eq(x, 0)), (1, True))
+
+        >>> Heaviside(x,nan).rewrite(Piecewise)
+        Piecewise((0, x < 0), (nan, Eq(x, 0)), (1, True))
+
+        >>> Heaviside(x - 5).rewrite(Piecewise)
+        Piecewise((0, x < 5), (1/2, Eq(x, 5)), (1, True))
+
+        >>> Heaviside(x**2 - 1).rewrite(Piecewise)
+        Piecewise((0, x**2 < 1), (1/2, Eq(x**2, 1)), (1, True))
+
+        """
+        if H0 == 0:
+            return Piecewise((0, arg <= 0), (1, True))
+        if H0 == 1:
+            return Piecewise((0, arg < 0), (1, True))
+        return Piecewise((0, arg < 0), (H0, Eq(arg, 0)), (1, True))
+
+    def _eval_rewrite_as_sign(self, arg, H0=S.Half, **kwargs):
+        """
+        Represents the Heaviside function in the form of sign function.
+
+        Explanation
+        ===========
+
+        The value of Heaviside(0) must be 1/2 for rewriting as sign to be
+        strictly equivalent. For easier usage, we also allow this rewriting
+        when Heaviside(0) is undefined.
+
+        Examples
+        ========
+
+        >>> from sympy import Heaviside, Symbol, sign, nan
+        >>> x = Symbol('x', real=True)
+        >>> y = Symbol('y')
+
+        >>> Heaviside(x).rewrite(sign)
+        sign(x)/2 + 1/2
+
+        >>> Heaviside(x, 0).rewrite(sign)
+        Piecewise((sign(x)/2 + 1/2, Ne(x, 0)), (0, True))
+
+        >>> Heaviside(x, nan).rewrite(sign)
+        Piecewise((sign(x)/2 + 1/2, Ne(x, 0)), (nan, True))
+
+        >>> Heaviside(x - 2).rewrite(sign)
+        sign(x - 2)/2 + 1/2
+
+        >>> Heaviside(x**2 - 2*x + 1).rewrite(sign)
+        sign(x**2 - 2*x + 1)/2 + 1/2
+
+        >>> Heaviside(y).rewrite(sign)
+        Heaviside(y)
+
+        >>> Heaviside(y**2 - 2*y + 1).rewrite(sign)
+        Heaviside(y**2 - 2*y + 1)
+
+        See Also
+        ========
+
+        sign
+
+        """
+        if arg.is_extended_real:
+            pw1 = Piecewise(
+                ((sign(arg) + 1)/2, Ne(arg, 0)),
+                (Heaviside(0, H0=H0), True))
+            pw2 = Piecewise(
+                ((sign(arg) + 1)/2, Eq(Heaviside(0, H0=H0), S.Half)),
+                (pw1, True))
+            return pw2
+
+    def _eval_rewrite_as_SingularityFunction(self, args, H0=S.Half, **kwargs):
+        """
+        Returns the Heaviside expression written in the form of Singularity
+        Functions.
+
+        """
+        from sympy.solvers import solve
+        from sympy.functions.special.singularity_functions import SingularityFunction
+        if self == Heaviside(0):
+            return SingularityFunction(0, 0, 0)
+        free = self.free_symbols
+        if len(free) == 1:
+            x = (free.pop())
+            return SingularityFunction(x, solve(args, x)[0], 0)
+            # TODO
+            # ((x - 5)**3*Heaviside(x - 5)).rewrite(SingularityFunction) should output
+            # SingularityFunction(x, 5, 0) instead of (x - 5)**3*SingularityFunction(x, 5, 0)
+        else:
+            # I don't know how to handle the case for Heaviside expressions
+            # having arguments with more than one variable.
+            raise TypeError(filldedent('''
+                rewrite(SingularityFunction) does not
+                support arguments with more that one variable.'''))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/elliptic_integrals.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/elliptic_integrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..a94e343c0106891db44668ae05c33e84ecd05d0b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/elliptic_integrals.py
@@ -0,0 +1,445 @@
+""" Elliptic Integrals. """
+
+from sympy.core import S, pi, I, Rational
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.symbol import Dummy,uniquely_named_symbol
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, tan
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper, meijerg
+
+class elliptic_k(DefinedFunction):
+    r"""
+    The complete elliptic integral of the first kind, defined by
+
+    .. math:: K(m) = F\left(\tfrac{\pi}{2}\middle| m\right)
+
+    where $F\left(z\middle| m\right)$ is the Legendre incomplete
+    elliptic integral of the first kind.
+
+    Explanation
+    ===========
+
+    The function $K(m)$ is a single-valued function on the complex
+    plane with branch cut along the interval $(1, \infty)$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_k, I
+    >>> from sympy.abc import m
+    >>> elliptic_k(0)
+    pi/2
+    >>> elliptic_k(1.0 + I)
+    1.50923695405127 + 0.625146415202697*I
+    >>> elliptic_k(m).series(n=3)
+    pi/2 + pi*m/8 + 9*pi*m**2/128 + O(m**3)
+
+    See Also
+    ========
+
+    elliptic_f
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticK
+
+    """
+
+    @classmethod
+    def eval(cls, m):
+        if m.is_zero:
+            return pi*S.Half
+        elif m is S.Half:
+            return 8*pi**Rational(3, 2)/gamma(Rational(-1, 4))**2
+        elif m is S.One:
+            return S.ComplexInfinity
+        elif m is S.NegativeOne:
+            return gamma(Rational(1, 4))**2/(4*sqrt(2*pi))
+        elif m in (S.Infinity, S.NegativeInfinity, I*S.Infinity,
+                   I*S.NegativeInfinity, S.ComplexInfinity):
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        m = self.args[0]
+        return (elliptic_e(m) - (1 - m)*elliptic_k(m))/(2*m*(1 - m))
+
+    def _eval_conjugate(self):
+        m = self.args[0]
+        if (m.is_real and (m - 1).is_positive) is False:
+            return self.func(m.conjugate())
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.simplify import hyperexpand
+        return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
+
+    def _eval_rewrite_as_hyper(self, m, **kwargs):
+        return pi*S.Half*hyper((S.Half, S.Half), (S.One,), m)
+
+    def _eval_rewrite_as_meijerg(self, m, **kwargs):
+        return meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -m)/2
+
+    def _eval_is_zero(self):
+        m = self.args[0]
+        if m.is_infinite:
+            return True
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        m = self.args[0]
+        return Integral(1/sqrt(1 - m*sin(t)**2), (t, 0, pi/2))
+
+
+class elliptic_f(DefinedFunction):
+    r"""
+    The Legendre incomplete elliptic integral of the first
+    kind, defined by
+
+    .. math:: F\left(z\middle| m\right) =
+              \int_0^z \frac{dt}{\sqrt{1 - m \sin^2 t}}
+
+    Explanation
+    ===========
+
+    This function reduces to a complete elliptic integral of
+    the first kind, $K(m)$, when $z = \pi/2$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_f, I
+    >>> from sympy.abc import z, m
+    >>> elliptic_f(z, m).series(z)
+    z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
+    >>> elliptic_f(3.0 + I/2, 1.0 + I)
+    2.909449841483 + 1.74720545502474*I
+
+    See Also
+    ========
+
+    elliptic_k
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticF
+
+    """
+
+    @classmethod
+    def eval(cls, z, m):
+        if z.is_zero:
+            return S.Zero
+        if m.is_zero:
+            return z
+        k = 2*z/pi
+        if k.is_integer:
+            return k*elliptic_k(m)
+        elif m in (S.Infinity, S.NegativeInfinity):
+            return S.Zero
+        elif z.could_extract_minus_sign():
+            return -elliptic_f(-z, m)
+
+    def fdiff(self, argindex=1):
+        z, m = self.args
+        fm = sqrt(1 - m*sin(z)**2)
+        if argindex == 1:
+            return 1/fm
+        elif argindex == 2:
+            return (elliptic_e(z, m)/(2*m*(1 - m)) - elliptic_f(z, m)/(2*m) -
+                    sin(2*z)/(4*(1 - m)*fm))
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        z, m = self.args
+        if (m.is_real and (m - 1).is_positive) is False:
+            return self.func(z.conjugate(), m.conjugate())
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        z, m = self.args[0], self.args[1]
+        return Integral(1/(sqrt(1 - m*sin(t)**2)), (t, 0, z))
+
+    def _eval_is_zero(self):
+        z, m = self.args
+        if z.is_zero:
+            return True
+        if m.is_extended_real and m.is_infinite:
+            return True
+
+
+class elliptic_e(DefinedFunction):
+    r"""
+    Called with two arguments $z$ and $m$, evaluates the
+    incomplete elliptic integral of the second kind, defined by
+
+    .. math:: E\left(z\middle| m\right) = \int_0^z \sqrt{1 - m \sin^2 t} dt
+
+    Called with a single argument $m$, evaluates the Legendre complete
+    elliptic integral of the second kind
+
+    .. math:: E(m) = E\left(\tfrac{\pi}{2}\middle| m\right)
+
+    Explanation
+    ===========
+
+    The function $E(m)$ is a single-valued function on the complex
+    plane with branch cut along the interval $(1, \infty)$.
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_e, I
+    >>> from sympy.abc import z, m
+    >>> elliptic_e(z, m).series(z)
+    z + z**5*(-m**2/40 + m/30) - m*z**3/6 + O(z**6)
+    >>> elliptic_e(m).series(n=4)
+    pi/2 - pi*m/8 - 3*pi*m**2/128 - 5*pi*m**3/512 + O(m**4)
+    >>> elliptic_e(1 + I, 2 - I/2).n()
+    1.55203744279187 + 0.290764986058437*I
+    >>> elliptic_e(0)
+    pi/2
+    >>> elliptic_e(2.0 - I)
+    0.991052601328069 + 0.81879421395609*I
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticE2
+    .. [3] https://functions.wolfram.com/EllipticIntegrals/EllipticE
+
+    """
+
+    @classmethod
+    def eval(cls, m, z=None):
+        if z is not None:
+            z, m = m, z
+            k = 2*z/pi
+            if m.is_zero:
+                return z
+            if z.is_zero:
+                return S.Zero
+            elif k.is_integer:
+                return k*elliptic_e(m)
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.ComplexInfinity
+            elif z.could_extract_minus_sign():
+                return -elliptic_e(-z, m)
+        else:
+            if m.is_zero:
+                return pi/2
+            elif m is S.One:
+                return S.One
+            elif m is S.Infinity:
+                return I*S.Infinity
+            elif m is S.NegativeInfinity:
+                return S.Infinity
+            elif m is S.ComplexInfinity:
+                return S.ComplexInfinity
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 2:
+            z, m = self.args
+            if argindex == 1:
+                return sqrt(1 - m*sin(z)**2)
+            elif argindex == 2:
+                return (elliptic_e(z, m) - elliptic_f(z, m))/(2*m)
+        else:
+            m = self.args[0]
+            if argindex == 1:
+                return (elliptic_e(m) - elliptic_k(m))/(2*m)
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        if len(self.args) == 2:
+            z, m = self.args
+            if (m.is_real and (m - 1).is_positive) is False:
+                return self.func(z.conjugate(), m.conjugate())
+        else:
+            m = self.args[0]
+            if (m.is_real and (m - 1).is_positive) is False:
+                return self.func(m.conjugate())
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.simplify import hyperexpand
+        if len(self.args) == 1:
+            return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
+        return super()._eval_nseries(x, n=n, logx=logx)
+
+    def _eval_rewrite_as_hyper(self, *args, **kwargs):
+        if len(args) == 1:
+            m = args[0]
+            return (pi/2)*hyper((Rational(-1, 2), S.Half), (S.One,), m)
+
+    def _eval_rewrite_as_meijerg(self, *args, **kwargs):
+        if len(args) == 1:
+            m = args[0]
+            return -meijerg(((S.Half, Rational(3, 2)), []), \
+                            ((S.Zero,), (S.Zero,)), -m)/4
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        z, m = (pi/2, self.args[0]) if len(self.args) == 1 else self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(sqrt(1 - m*sin(t)**2), (t, 0, z))
+
+
+class elliptic_pi(DefinedFunction):
+    r"""
+    Called with three arguments $n$, $z$ and $m$, evaluates the
+    Legendre incomplete elliptic integral of the third kind, defined by
+
+    .. math:: \Pi\left(n; z\middle| m\right) = \int_0^z \frac{dt}
+              {\left(1 - n \sin^2 t\right) \sqrt{1 - m \sin^2 t}}
+
+    Called with two arguments $n$ and $m$, evaluates the complete
+    elliptic integral of the third kind:
+
+    .. math:: \Pi\left(n\middle| m\right) =
+              \Pi\left(n; \tfrac{\pi}{2}\middle| m\right)
+
+    Explanation
+    ===========
+
+    Note that our notation defines the incomplete elliptic integral
+    in terms of the parameter $m$ instead of the elliptic modulus
+    (eccentricity) $k$.
+    In this case, the parameter $m$ is defined as $m=k^2$.
+
+    Examples
+    ========
+
+    >>> from sympy import elliptic_pi, I
+    >>> from sympy.abc import z, n, m
+    >>> elliptic_pi(n, z, m).series(z, n=4)
+    z + z**3*(m/6 + n/3) + O(z**4)
+    >>> elliptic_pi(0.5 + I, 1.0 - I, 1.2)
+    2.50232379629182 - 0.760939574180767*I
+    >>> elliptic_pi(0, 0)
+    pi/2
+    >>> elliptic_pi(1.0 - I/3, 2.0 + I)
+    3.29136443417283 + 0.32555634906645*I
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Elliptic_integrals
+    .. [2] https://functions.wolfram.com/EllipticIntegrals/EllipticPi3
+    .. [3] https://functions.wolfram.com/EllipticIntegrals/EllipticPi
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, z=None):
+        if z is not None:
+            z, m = m, z
+            if n.is_zero:
+                return elliptic_f(z, m)
+            elif n is S.One:
+                return (elliptic_f(z, m) +
+                        (sqrt(1 - m*sin(z)**2)*tan(z) -
+                         elliptic_e(z, m))/(1 - m))
+            k = 2*z/pi
+            if k.is_integer:
+                return k*elliptic_pi(n, m)
+            elif m.is_zero:
+                return atanh(sqrt(n - 1)*tan(z))/sqrt(n - 1)
+            elif n == m:
+                return (elliptic_f(z, n) - elliptic_pi(1, z, n) +
+                        tan(z)/sqrt(1 - n*sin(z)**2))
+            elif n in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif z.could_extract_minus_sign():
+                return -elliptic_pi(n, -z, m)
+            if n.is_zero:
+                return elliptic_f(z, m)
+            if m.is_extended_real and m.is_infinite or \
+                    n.is_extended_real and n.is_infinite:
+                return S.Zero
+        else:
+            if n.is_zero:
+                return elliptic_k(m)
+            elif n is S.One:
+                return S.ComplexInfinity
+            elif m.is_zero:
+                return pi/(2*sqrt(1 - n))
+            elif m == S.One:
+                return S.NegativeInfinity/sign(n - 1)
+            elif n == m:
+                return elliptic_e(n)/(1 - n)
+            elif n in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            elif m in (S.Infinity, S.NegativeInfinity):
+                return S.Zero
+            if n.is_zero:
+                return elliptic_k(m)
+            if m.is_extended_real and m.is_infinite or \
+                    n.is_extended_real and n.is_infinite:
+                return S.Zero
+
+    def _eval_conjugate(self):
+        if len(self.args) == 3:
+            n, z, m = self.args
+            if (n.is_real and (n - 1).is_positive) is False and \
+               (m.is_real and (m - 1).is_positive) is False:
+                return self.func(n.conjugate(), z.conjugate(), m.conjugate())
+        else:
+            n, m = self.args
+            return self.func(n.conjugate(), m.conjugate())
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 3:
+            n, z, m = self.args
+            fm, fn = sqrt(1 - m*sin(z)**2), 1 - n*sin(z)**2
+            if argindex == 1:
+                return (elliptic_e(z, m) + (m - n)*elliptic_f(z, m)/n +
+                        (n**2 - m)*elliptic_pi(n, z, m)/n -
+                        n*fm*sin(2*z)/(2*fn))/(2*(m - n)*(n - 1))
+            elif argindex == 2:
+                return 1/(fm*fn)
+            elif argindex == 3:
+                return (elliptic_e(z, m)/(m - 1) +
+                        elliptic_pi(n, z, m) -
+                        m*sin(2*z)/(2*(m - 1)*fm))/(2*(n - m))
+        else:
+            n, m = self.args
+            if argindex == 1:
+                return (elliptic_e(m) + (m - n)*elliptic_k(m)/n +
+                        (n**2 - m)*elliptic_pi(n, m)/n)/(2*(m - n)*(n - 1))
+            elif argindex == 2:
+                return (elliptic_e(m)/(m - 1) + elliptic_pi(n, m))/(2*(n - m))
+        raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        if len(self.args) == 2:
+            n, m, z = self.args[0], self.args[1], pi/2
+        else:
+            n, z, m = self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(1/((1 - n*sin(t)**2)*sqrt(1 - m*sin(t)**2)), (t, 0, z))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/error_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/error_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..a778127d8b80583a892285fadbb8230f72de39f9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/error_functions.py
@@ -0,0 +1,2801 @@
+""" This module contains various functions that are special cases
+    of incomplete gamma functions. It should probably be renamed. """
+
+from sympy.core import EulerGamma # Must be imported from core, not core.numbers
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.function import DefinedFunction, ArgumentIndexError, expand_mul
+from sympy.core.logic import fuzzy_or
+from sympy.core.numbers import I, pi, Rational, Integer
+from sympy.core.relational import is_eq
+from sympy.core.power import Pow
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.factorials import factorial, factorial2, RisingFactorial
+from sympy.functions.elementary.complexes import  polar_lift, re, unpolarify
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt, root
+from sympy.functions.elementary.exponential import exp, log, exp_polar
+from sympy.functions.elementary.hyperbolic import cosh, sinh
+from sympy.functions.elementary.trigonometric import cos, sin, sinc
+from sympy.functions.special.hyper import hyper, meijerg
+
+# TODO series expansions
+# TODO see the "Note:" in Ei
+
+# Helper function
+def real_to_real_as_real_imag(self, deep=True, **hints):
+    if self.args[0].is_extended_real:
+        if deep:
+            hints['complex'] = False
+            return (self.expand(deep, **hints), S.Zero)
+        else:
+            return (self, S.Zero)
+    if deep:
+        x, y = self.args[0].expand(deep, **hints).as_real_imag()
+    else:
+        x, y = self.args[0].as_real_imag()
+    re = (self.func(x + I*y) + self.func(x - I*y))/2
+    im = (self.func(x + I*y) - self.func(x - I*y))/(2*I)
+    return (re, im)
+
+
+###############################################################################
+################################ ERROR FUNCTION ###############################
+###############################################################################
+
+
+class erf(DefinedFunction):
+    r"""
+    The Gauss error function.
+
+    Explanation
+    ===========
+
+    This function is defined as:
+
+    .. math ::
+        \mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{-t^2} \mathrm{d}t.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erf
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erf(0)
+    0
+    >>> erf(oo)
+    1
+    >>> erf(-oo)
+    -1
+    >>> erf(I*oo)
+    oo*I
+    >>> erf(-I*oo)
+    -oo*I
+
+    In general one can pull out factors of -1 and $I$ from the argument:
+
+    >>> erf(-z)
+    -erf(z)
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erf(z))
+    erf(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf(z), z)
+    2*exp(-z**2)/sqrt(pi)
+
+    We can numerically evaluate the error function to arbitrary precision
+    on the whole complex plane:
+
+    >>> erf(4).evalf(30)
+    0.999999984582742099719981147840
+
+    >>> erf(-4*I).evalf(30)
+    -1296959.73071763923152794095062*I
+
+    See Also
+    ========
+
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/Erf.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Erf
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 2*exp(-self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfinv
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.One
+            elif arg is S.NegativeInfinity:
+                return S.NegativeOne
+            elif arg.is_zero:
+                return S.Zero
+
+        if isinstance(arg, erfinv):
+            return arg.args[0]
+
+        if isinstance(arg, erfcinv):
+            return S.One - arg.args[0]
+
+        if arg.is_zero:
+            return S.Zero
+
+        # Only happens with unevaluated erf2inv
+        if isinstance(arg, erf2inv) and arg.args[0].is_zero:
+            return arg.args[1]
+
+        # Try to pull out factors of I
+        t = arg.extract_multiplicatively(I)
+        if t in (S.Infinity, S.NegativeInfinity):
+            return arg
+
+        # Try to pull out factors of -1
+        if arg.could_extract_minus_sign():
+            return -cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return -previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return 2*S.NegativeOne**k * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        if self.args[0].is_extended_real is True:
+            return True
+        # There are cases where erf(z) becomes a real number
+        # even if z is a complex number
+
+    def _eval_is_imaginary(self):
+        if self.args[0].is_imaginary is True:
+            return True
+
+    def _eval_is_finite(self):
+        z = self.args[0]
+        return fuzzy_or([z.is_finite, z.is_extended_real])
+
+    def _eval_is_zero(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_zero
+
+    def _eval_is_positive(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_extended_positive
+
+    def _eval_is_negative(self):
+        if self.args[0].is_extended_real is True:
+            return self.args[0].is_extended_negative
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return sqrt(z**2)/z*(S.One - uppergamma(S.Half, z**2)/sqrt(pi))
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], -z**2)
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return sqrt(z**2)/z - z*expint(S.Half, z**2)/sqrt(pi)
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        from sympy.series.limits import limit
+        if limitvar:
+            lim = limit(z, limitvar, S.Infinity)
+            if lim is S.NegativeInfinity:
+                return S.NegativeOne + _erfs(-z)*exp(-z**2)
+        return S.One - _erfs(z)*exp(-z**2)
+
+    def _eval_rewrite_as_erfc(self, z, **kwargs):
+        return S.One - erfc(z)
+
+    def _eval_rewrite_as_erfi(self, z, **kwargs):
+        return -I*erfi(I*z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if cdir == -1 else '+')
+        if x in arg.free_symbols and arg0.is_zero:
+            return 2*arg/sqrt(pi)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in [S.Infinity, S.NegativeInfinity]:
+            z = self.args[0]
+
+            try:
+                _, ex = z.leadterm(x)
+            except (ValueError, NotImplementedError):
+                return self
+
+            ex = -ex # as x->1/x for aseries
+            if ex.is_positive:
+                newn = ceiling(n/ex)
+                s = [S.NegativeOne**k * factorial2(2*k - 1) / (z**(2*k + 1) * 2**k)
+                     for k in range(newn)] + [Order(1/z**newn, x)]
+                return S.One - (exp(-z**2)/sqrt(pi)) * Add(*s)
+
+        return super(erf, self)._eval_aseries(n, args0, x, logx)
+
+    as_real_imag = real_to_real_as_real_imag
+
+
+class erfc(DefinedFunction):
+    r"""
+    Complementary Error Function.
+
+    Explanation
+    ===========
+
+    The function is defined as:
+
+    .. math ::
+        \mathrm{erfc}(x) = \frac{2}{\sqrt{\pi}} \int_x^\infty e^{-t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erfc
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erfc(0)
+    1
+    >>> erfc(oo)
+    0
+    >>> erfc(-oo)
+    2
+    >>> erfc(I*oo)
+    -oo*I
+    >>> erfc(-I*oo)
+    oo*I
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erfc(z))
+    erfc(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfc(z), z)
+    -2*exp(-z**2)/sqrt(pi)
+
+    It also follows
+
+    >>> erfc(-z)
+    2 - erfc(z)
+
+    We can numerically evaluate the complementary error function to arbitrary
+    precision on the whole complex plane:
+
+    >>> erfc(4).evalf(30)
+    0.0000000154172579002800188521596734869
+
+    >>> erfc(4*I).evalf(30)
+    1.0 - 1296959.73071763923152794095062*I
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/Erfc.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Erfc
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return -2*exp(-self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfcinv
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is S.Infinity:
+                return S.Zero
+            elif arg.is_zero:
+                return S.One
+
+        if isinstance(arg, erfinv):
+            return S.One - arg.args[0]
+
+        if isinstance(arg, erfcinv):
+            return arg.args[0]
+
+        if arg.is_zero:
+            return S.One
+
+        # Try to pull out factors of I
+        t = arg.extract_multiplicatively(I)
+        if t in (S.Infinity, S.NegativeInfinity):
+            return -arg
+
+        # Try to pull out factors of -1
+        if arg.could_extract_minus_sign():
+            return 2 - cls(-arg)
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n == 0:
+            return S.One
+        elif n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return -previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return -2*S.NegativeOne**k * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        if self.args[0].is_extended_real is True:
+            return True
+        if self.args[0].is_imaginary is True:
+            return False
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(erf).rewrite("tractable", deep=True, limitvar=limitvar)
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return S.One - erf(z)
+
+    def _eval_rewrite_as_erfi(self, z, **kwargs):
+        return S.One + I*erfi(I*z)
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One - I)*z/sqrt(pi)
+        return S.One - (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One-I)*z/sqrt(pi)
+        return S.One - (S.One + I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return S.One - z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return S.One - 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], -z**2)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return S.One - sqrt(z**2)/z*(S.One - uppergamma(S.Half, z**2)/sqrt(pi))
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return S.One - sqrt(z**2)/z + z*expint(S.Half, z**2)/sqrt(pi)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if cdir == -1 else '+')
+        if arg0.is_zero:
+            return S.One
+        else:
+            return self.func(arg0)
+
+    as_real_imag = real_to_real_as_real_imag
+
+    def _eval_aseries(self, n, args0, x, logx):
+        return S.One - erf(*self.args)._eval_aseries(n, args0, x, logx)
+
+
+class erfi(DefinedFunction):
+    r"""
+    Imaginary error function.
+
+    Explanation
+    ===========
+
+    The function erfi is defined as:
+
+    .. math ::
+        \mathrm{erfi}(x) = \frac{2}{\sqrt{\pi}} \int_0^x e^{t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, erfi
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> erfi(0)
+    0
+    >>> erfi(oo)
+    oo
+    >>> erfi(-oo)
+    -oo
+    >>> erfi(I*oo)
+    I
+    >>> erfi(-I*oo)
+    -I
+
+    In general one can pull out factors of -1 and $I$ from the argument:
+
+    >>> erfi(-z)
+    -erfi(z)
+
+    >>> from sympy import conjugate
+    >>> conjugate(erfi(z))
+    erfi(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfi(z), z)
+    2*exp(z**2)/sqrt(pi)
+
+    We can numerically evaluate the imaginary error function to arbitrary
+    precision on the whole complex plane:
+
+    >>> erfi(2).evalf(30)
+    18.5648024145755525987042919132
+
+    >>> erfi(-2*I).evalf(30)
+    -0.995322265018952734162069256367*I
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function
+    .. [2] https://mathworld.wolfram.com/Erfi.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/Erfi
+
+    """
+
+    unbranched = True
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return 2*exp(self.args[0]**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_Number:
+            if z is S.NaN:
+                return S.NaN
+            elif z.is_zero:
+                return S.Zero
+            elif z is S.Infinity:
+                return S.Infinity
+
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(-z)
+
+        # Try to pull out factors of I
+        nz = z.extract_multiplicatively(I)
+        if nz is not None:
+            if nz is S.Infinity:
+                return I
+            if isinstance(nz, erfinv):
+                return I*nz.args[0]
+            if isinstance(nz, erfcinv):
+                return I*(S.One - nz.args[0])
+            # Only happens with unevaluated erf2inv
+            if isinstance(nz, erf2inv) and nz.args[0].is_zero:
+                return I*nz.args[1]
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0 or n % 2 == 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            k = floor((n - 1)/S(2))
+            if len(previous_terms) > 2:
+                return previous_terms[-2] * x**2 * (n - 2)/(n*k)
+            else:
+                return 2 * x**n/(n*factorial(k)*sqrt(pi))
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(erf).rewrite("tractable", deep=True, limitvar=limitvar)
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return -I*erf(I*z)
+
+    def _eval_rewrite_as_erfc(self, z, **kwargs):
+        return I*erfc(I*z) - I
+
+    def _eval_rewrite_as_fresnels(self, z, **kwargs):
+        arg = (S.One + I)*z/sqrt(pi)
+        return (S.One - I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_fresnelc(self, z, **kwargs):
+        arg = (S.One + I)*z/sqrt(pi)
+        return (S.One - I)*(fresnelc(arg) - I*fresnels(arg))
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return z/sqrt(pi)*meijerg([S.Half], [], [0], [Rational(-1, 2)], -z**2)
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return 2*z/sqrt(pi)*hyper([S.Half], [3*S.Half], z**2)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return sqrt(-z**2)/z*(uppergamma(S.Half, -z**2)/sqrt(pi) - S.One)
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return sqrt(-z**2)/z - z*expint(S.Half, -z**2)/sqrt(pi)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    as_real_imag = real_to_real_as_real_imag
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if x in arg.free_symbols and arg0.is_zero:
+            return 2*arg/sqrt(pi)
+        elif arg0.is_finite:
+            return self.func(arg0)
+        return self.func(arg)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point is S.Infinity:
+            z = self.args[0]
+            s = [factorial2(2*k - 1) / (2**k * z**(2*k + 1))
+                    for k in range(n)] + [Order(1/z**n, x)]
+            return -I + (exp(z**2)/sqrt(pi)) * Add(*s)
+
+        return super(erfi, self)._eval_aseries(n, args0, x, logx)
+
+
+class erf2(DefinedFunction):
+    r"""
+    Two-argument error function.
+
+    Explanation
+    ===========
+
+    This function is defined as:
+
+    .. math ::
+        \mathrm{erf2}(x, y) = \frac{2}{\sqrt{\pi}} \int_x^y e^{-t^2} \mathrm{d}t
+
+    Examples
+    ========
+
+    >>> from sympy import oo, erf2
+    >>> from sympy.abc import x, y
+
+    Several special values are known:
+
+    >>> erf2(0, 0)
+    0
+    >>> erf2(x, x)
+    0
+    >>> erf2(x, oo)
+    1 - erf(x)
+    >>> erf2(x, -oo)
+    -erf(x) - 1
+    >>> erf2(oo, y)
+    erf(y) - 1
+    >>> erf2(-oo, y)
+    erf(y) + 1
+
+    In general one can pull out factors of -1:
+
+    >>> erf2(-x, -y)
+    -erf2(x, y)
+
+    The error function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(erf2(x, y))
+    erf2(conjugate(x), conjugate(y))
+
+    Differentiation with respect to $x$, $y$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf2(x, y), x)
+    -2*exp(-x**2)/sqrt(pi)
+    >>> diff(erf2(x, y), y)
+    2*exp(-y**2)/sqrt(pi)
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/Erf2/
+
+    """
+
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            return -2*exp(-x**2)/sqrt(pi)
+        elif argindex == 2:
+            return 2*exp(-y**2)/sqrt(pi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y):
+        chk = (S.Infinity, S.NegativeInfinity, S.Zero)
+        if x is S.NaN or y is S.NaN:
+            return S.NaN
+        elif x == y:
+            return S.Zero
+        elif x in chk or y in chk:
+            return erf(y) - erf(x)
+
+        if isinstance(y, erf2inv) and y.args[0] == x:
+            return y.args[1]
+
+        if x.is_zero or y.is_zero or x.is_extended_real and x.is_infinite or \
+                y.is_extended_real and y.is_infinite:
+            return erf(y) - erf(x)
+
+        #Try to pull out -1 factor
+        sign_x = x.could_extract_minus_sign()
+        sign_y = y.could_extract_minus_sign()
+        if (sign_x and sign_y):
+            return -cls(-x, -y)
+        elif (sign_x or sign_y):
+            return erf(y)-erf(x)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate(), self.args[1].conjugate())
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real and self.args[1].is_extended_real
+
+    def _eval_rewrite_as_erf(self, x, y, **kwargs):
+        return erf(y) - erf(x)
+
+    def _eval_rewrite_as_erfc(self, x, y, **kwargs):
+        return erfc(x) - erfc(y)
+
+    def _eval_rewrite_as_erfi(self, x, y, **kwargs):
+        return I*(erfi(I*x)-erfi(I*y))
+
+    def _eval_rewrite_as_fresnels(self, x, y, **kwargs):
+        return erf(y).rewrite(fresnels) - erf(x).rewrite(fresnels)
+
+    def _eval_rewrite_as_fresnelc(self, x, y, **kwargs):
+        return erf(y).rewrite(fresnelc) - erf(x).rewrite(fresnelc)
+
+    def _eval_rewrite_as_meijerg(self, x, y, **kwargs):
+        return erf(y).rewrite(meijerg) - erf(x).rewrite(meijerg)
+
+    def _eval_rewrite_as_hyper(self, x, y, **kwargs):
+        return erf(y).rewrite(hyper) - erf(x).rewrite(hyper)
+
+    def _eval_rewrite_as_uppergamma(self, x, y, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return (sqrt(y**2)/y*(S.One - uppergamma(S.Half, y**2)/sqrt(pi)) -
+            sqrt(x**2)/x*(S.One - uppergamma(S.Half, x**2)/sqrt(pi)))
+
+    def _eval_rewrite_as_expint(self, x, y, **kwargs):
+        return erf(y).rewrite(expint) - erf(x).rewrite(expint)
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(erf)
+
+    def _eval_is_zero(self):
+        return is_eq(*self.args)
+
+class erfinv(DefinedFunction):
+    r"""
+    Inverse Error Function. The erfinv function is defined as:
+
+    .. math ::
+        \mathrm{erf}(x) = y \quad \Rightarrow \quad \mathrm{erfinv}(y) = x
+
+    Examples
+    ========
+
+    >>> from sympy import erfinv
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> erfinv(0)
+    0
+    >>> erfinv(1)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfinv(x), x)
+    sqrt(pi)*exp(erfinv(x)**2)/2
+
+    We can numerically evaluate the inverse error function to arbitrary
+    precision on [-1, 1]:
+
+    >>> erfinv(0.2).evalf(30)
+    0.179143454621291692285822705344
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfcinv: Inverse Complementary error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function#Inverse_functions
+    .. [2] https://functions.wolfram.com/GammaBetaErf/InverseErf/
+
+    """
+
+
+    def fdiff(self, argindex =1):
+        if argindex == 1:
+            return sqrt(pi)*exp(self.func(self.args[0])**2)*S.Half
+        else :
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erf
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.NaN:
+            return S.NaN
+        elif z is S.NegativeOne:
+            return S.NegativeInfinity
+        elif z.is_zero:
+            return S.Zero
+        elif z is S.One:
+            return S.Infinity
+
+        if isinstance(z, erf) and z.args[0].is_extended_real:
+            return z.args[0]
+
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1
+        nz = z.extract_multiplicatively(-1)
+        if nz is not None and (isinstance(nz, erf) and (nz.args[0]).is_extended_real):
+            return -nz.args[0]
+
+    def _eval_rewrite_as_erfcinv(self, z, **kwargs):
+        return erfcinv(1-z)
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+
+class erfcinv (DefinedFunction):
+    r"""
+    Inverse Complementary Error Function. The erfcinv function is defined as:
+
+    .. math ::
+        \mathrm{erfc}(x) = y \quad \Rightarrow \quad \mathrm{erfcinv}(y) = x
+
+    Examples
+    ========
+
+    >>> from sympy import erfcinv
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> erfcinv(1)
+    0
+    >>> erfcinv(0)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erfcinv(x), x)
+    -sqrt(pi)*exp(erfcinv(x)**2)/2
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erf2inv: Inverse two-argument error function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Error_function#Inverse_functions
+    .. [2] https://functions.wolfram.com/GammaBetaErf/InverseErfc/
+
+    """
+
+
+    def fdiff(self, argindex =1):
+        if argindex == 1:
+            return -sqrt(pi)*exp(self.func(self.args[0])**2)*S.Half
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def inverse(self, argindex=1):
+        """
+        Returns the inverse of this function.
+
+        """
+        return erfc
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.NaN:
+            return S.NaN
+        elif z.is_zero:
+            return S.Infinity
+        elif z is S.One:
+            return S.Zero
+        elif z == 2:
+            return S.NegativeInfinity
+
+        if z.is_zero:
+            return S.Infinity
+
+    def _eval_rewrite_as_erfinv(self, z, **kwargs):
+        return erfinv(1-z)
+
+    def _eval_is_zero(self):
+        return (self.args[0] - 1).is_zero
+
+    def _eval_is_infinite(self):
+        z = self.args[0]
+        return fuzzy_or([z.is_zero, is_eq(z, Integer(2))])
+
+
+class erf2inv(DefinedFunction):
+    r"""
+    Two-argument Inverse error function. The erf2inv function is defined as:
+
+    .. math ::
+        \mathrm{erf2}(x, w) = y \quad \Rightarrow \quad \mathrm{erf2inv}(x, y) = w
+
+    Examples
+    ========
+
+    >>> from sympy import erf2inv, oo
+    >>> from sympy.abc import x, y
+
+    Several special values are known:
+
+    >>> erf2inv(0, 0)
+    0
+    >>> erf2inv(1, 0)
+    1
+    >>> erf2inv(0, 1)
+    oo
+    >>> erf2inv(0, y)
+    erfinv(y)
+    >>> erf2inv(oo, y)
+    erfcinv(-y)
+
+    Differentiation with respect to $x$ and $y$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(erf2inv(x, y), x)
+    exp(-x**2 + erf2inv(x, y)**2)
+    >>> diff(erf2inv(x, y), y)
+    sqrt(pi)*exp(erf2inv(x, y)**2)/2
+
+    See Also
+    ========
+
+    erf: Gaussian error function.
+    erfc: Complementary error function.
+    erfi: Imaginary error function.
+    erf2: Two-argument error function.
+    erfinv: Inverse error function.
+    erfcinv: Inverse complementary error function.
+
+    References
+    ==========
+
+    .. [1] https://functions.wolfram.com/GammaBetaErf/InverseErf2/
+
+    """
+
+
+    def fdiff(self, argindex):
+        x, y = self.args
+        if argindex == 1:
+            return exp(self.func(x,y)**2-x**2)
+        elif argindex == 2:
+            return sqrt(pi)*S.Half*exp(self.func(x,y)**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, y):
+        if x is S.NaN or y is S.NaN:
+            return S.NaN
+        elif x.is_zero and y.is_zero:
+            return S.Zero
+        elif x.is_zero and y is S.One:
+            return S.Infinity
+        elif x is S.One and y.is_zero:
+            return S.One
+        elif x.is_zero:
+            return erfinv(y)
+        elif x is S.Infinity:
+            return erfcinv(-y)
+        elif y.is_zero:
+            return x
+        elif y is S.Infinity:
+            return erfinv(x)
+
+        if x.is_zero:
+            if y.is_zero:
+                return S.Zero
+            else:
+                return erfinv(y)
+        if y.is_zero:
+            return x
+
+    def _eval_is_zero(self):
+        x, y = self.args
+        if x.is_zero and y.is_zero:
+            return True
+
+###############################################################################
+#################### EXPONENTIAL INTEGRALS ####################################
+###############################################################################
+
+class Ei(DefinedFunction):
+    r"""
+    The classical exponential integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{Ei}(x) = \sum_{n=1}^\infty \frac{x^n}{n\, n!}
+                                     + \log(x) + \gamma,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    If $x$ is a polar number, this defines an analytic function on the
+    Riemann surface of the logarithm. Otherwise this defines an analytic
+    function in the cut plane $\mathbb{C} \setminus (-\infty, 0]$.
+
+    **Background**
+
+    The name exponential integral comes from the following statement:
+
+    .. math:: \operatorname{Ei}(x) = \int_{-\infty}^x \frac{e^t}{t} \mathrm{d}t
+
+    If the integral is interpreted as a Cauchy principal value, this statement
+    holds for $x > 0$ and $\operatorname{Ei}(x)$ as defined above.
+
+    Examples
+    ========
+
+    >>> from sympy import Ei, polar_lift, exp_polar, I, pi
+    >>> from sympy.abc import x
+
+    >>> Ei(-1)
+    Ei(-1)
+
+    This yields a real value:
+
+    >>> Ei(-1).n(chop=True)
+    -0.219383934395520
+
+    On the other hand the analytic continuation is not real:
+
+    >>> Ei(polar_lift(-1)).n(chop=True)
+    -0.21938393439552 + 3.14159265358979*I
+
+    The exponential integral has a logarithmic branch point at the origin:
+
+    >>> Ei(x*exp_polar(2*I*pi))
+    Ei(x) + 2*I*pi
+
+    Differentiation is supported:
+
+    >>> Ei(x).diff(x)
+    exp(x)/x
+
+    The exponential integral is related to many other special functions.
+    For example:
+
+    >>> from sympy import expint, Shi
+    >>> Ei(x).rewrite(expint)
+    -expint(1, x*exp_polar(I*pi)) - I*pi
+    >>> Ei(x).rewrite(Shi)
+    Chi(x) + Shi(x)
+
+    See Also
+    ========
+
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    uppergamma: Upper incomplete gamma function.
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/6.6
+    .. [2] https://en.wikipedia.org/wiki/Exponential_integral
+    .. [3] Abramowitz & Stegun, section 5: https://web.archive.org/web/20201128173312/http://people.math.sfu.ca/~cbm/aands/page_228.htm
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_zero:
+            return S.NegativeInfinity
+        elif z is S.Infinity:
+            return S.Infinity
+        elif z is S.NegativeInfinity:
+            return S.Zero
+
+        if z.is_zero:
+            return S.NegativeInfinity
+
+        nz, n = z.extract_branch_factor()
+        if n:
+            return Ei(nz) + 2*I*pi*n
+
+    def fdiff(self, argindex=1):
+        arg = unpolarify(self.args[0])
+        if argindex == 1:
+            return exp(arg)/arg
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        if (self.args[0]/polar_lift(-1)).is_positive:
+            return super()._eval_evalf(prec) + (I*pi)._eval_evalf(prec)
+        return super()._eval_evalf(prec)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        # XXX this does not currently work usefully because uppergamma
+        #     immediately turns into expint
+        return -uppergamma(0, polar_lift(-1)*z) - I*pi
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -expint(1, polar_lift(-1)*z) - I*pi
+
+    def _eval_rewrite_as_li(self, z, **kwargs):
+        if isinstance(z, log):
+            return li(z.args[0])
+        # TODO:
+        # Actually it only holds that:
+        #  Ei(z) = li(exp(z))
+        # for -pi < imag(z) <= pi
+        return li(exp(z))
+
+    def _eval_rewrite_as_Si(self, z, **kwargs):
+        if z.is_negative:
+            return Shi(z) + Chi(z) - I*pi
+        else:
+            return Shi(z) + Chi(z)
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Si
+    _eval_rewrite_as_Shi = _eval_rewrite_as_Si
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return exp(z) * _eis(z)
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(S.Exp1**t/t, (t, S.NegativeInfinity, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy import re
+        x0 = self.args[0].limit(x, 0)
+        arg = self.args[0].as_leading_term(x, cdir=cdir)
+        cdir = arg.dir(x, cdir)
+        if x0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma - (
+                I*pi if re(cdir).is_negative else S.Zero)
+        return super()._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_Si(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in (S.Infinity, S.NegativeInfinity):
+            z = self.args[0]
+            s = [factorial(k) / (z)**k for k in range(n)] + \
+                    [Order(1/z**n, x)]
+            return (exp(z)/z) * Add(*s)
+
+        return super(Ei, self)._eval_aseries(n, args0, x, logx)
+
+
+class expint(DefinedFunction):
+    r"""
+    Generalized exponential integral.
+
+    Explanation
+    ===========
+
+    This function is defined as
+
+    .. math:: \operatorname{E}_\nu(z) = z^{\nu - 1} \Gamma(1 - \nu, z),
+
+    where $\Gamma(1 - \nu, z)$ is the upper incomplete gamma function
+    (``uppergamma``).
+
+    Hence for $z$ with positive real part we have
+
+    .. math:: \operatorname{E}_\nu(z)
+              =   \int_1^\infty \frac{e^{-zt}}{t^\nu} \mathrm{d}t,
+
+    which explains the name.
+
+    The representation as an incomplete gamma function provides an analytic
+    continuation for $\operatorname{E}_\nu(z)$. If $\nu$ is a
+    non-positive integer, the exponential integral is thus an unbranched
+    function of $z$, otherwise there is a branch point at the origin.
+    Refer to the incomplete gamma function documentation for details of the
+    branching behavior.
+
+    Examples
+    ========
+
+    >>> from sympy import expint, S
+    >>> from sympy.abc import nu, z
+
+    Differentiation is supported. Differentiation with respect to $z$ further
+    explains the name: for integral orders, the exponential integral is an
+    iterated integral of the exponential function.
+
+    >>> expint(nu, z).diff(z)
+    -expint(nu - 1, z)
+
+    Differentiation with respect to $\nu$ has no classical expression:
+
+    >>> expint(nu, z).diff(nu)
+    -z**(nu - 1)*meijerg(((), (1, 1)), ((0, 0, 1 - nu), ()), z)
+
+    At non-postive integer orders, the exponential integral reduces to the
+    exponential function:
+
+    >>> expint(0, z)
+    exp(-z)/z
+    >>> expint(-1, z)
+    exp(-z)/z + exp(-z)/z**2
+
+    At half-integers it reduces to error functions:
+
+    >>> expint(S(1)/2, z)
+    sqrt(pi)*erfc(sqrt(z))/sqrt(z)
+
+    At positive integer orders it can be rewritten in terms of exponentials
+    and ``expint(1, z)``. Use ``expand_func()`` to do this:
+
+    >>> from sympy import expand_func
+    >>> expand_func(expint(5, z))
+    z**4*expint(1, z)/24 + (-z**3 + z**2 - 2*z + 6)*exp(-z)/24
+
+    The generalised exponential integral is essentially equivalent to the
+    incomplete gamma function:
+
+    >>> from sympy import uppergamma
+    >>> expint(nu, z).rewrite(uppergamma)
+    z**(nu - 1)*uppergamma(1 - nu, z)
+
+    As such it is branched at the origin:
+
+    >>> from sympy import exp_polar, pi, I
+    >>> expint(4, z*exp_polar(2*pi*I))
+    I*pi*z**3/3 + expint(4, z)
+    >>> expint(nu, z*exp_polar(2*pi*I))
+    z**(nu - 1)*(exp(2*I*pi*nu) - 1)*gamma(1 - nu) + expint(nu, z)
+
+    See Also
+    ========
+
+    Ei: Another related function called exponential integral.
+    E1: The classical case, returns expint(1, z).
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    uppergamma
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/8.19
+    .. [2] https://functions.wolfram.com/GammaBetaErf/ExpIntegralE/
+    .. [3] https://en.wikipedia.org/wiki/Exponential_integral
+
+    """
+
+
+    @classmethod
+    def eval(cls, nu, z):
+        from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+        nu2 = unpolarify(nu)
+        if nu != nu2:
+            return expint(nu2, z)
+        if nu.is_Integer and nu <= 0 or (not nu.is_Integer and (2*nu).is_Integer):
+            return unpolarify(expand_mul(z**(nu - 1)*uppergamma(1 - nu, z)))
+
+        # Extract branching information. This can be deduced from what is
+        # explained in lowergamma.eval().
+        z, n = z.extract_branch_factor()
+        if n is S.Zero:
+            return
+        if nu.is_integer:
+            if not nu > 0:
+                return
+            return expint(nu, z) \
+                - 2*pi*I*n*S.NegativeOne**(nu - 1)/factorial(nu - 1)*unpolarify(z)**(nu - 1)
+        else:
+            return (exp(2*I*pi*nu*n) - 1)*z**(nu - 1)*gamma(1 - nu) + expint(nu, z)
+
+    def fdiff(self, argindex):
+        nu, z = self.args
+        if argindex == 1:
+            return -z**(nu - 1)*meijerg([], [1, 1], [0, 0, 1 - nu], [], z)
+        elif argindex == 2:
+            return -expint(nu - 1, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_uppergamma(self, nu, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return z**(nu - 1)*uppergamma(1 - nu, z)
+
+    def _eval_rewrite_as_Ei(self, nu, z, **kwargs):
+        if nu == 1:
+            return -Ei(z*exp_polar(-I*pi)) - I*pi
+        elif nu.is_Integer and nu > 1:
+            # DLMF, 8.19.7
+            x = -unpolarify(z)
+            return x**(nu - 1)/factorial(nu - 1)*E1(z).rewrite(Ei) + \
+                exp(x)/factorial(nu - 1) * \
+                Add(*[factorial(nu - k - 2)*x**k for k in range(nu - 1)])
+        else:
+            return self
+
+    def _eval_expand_func(self, **hints):
+        return self.rewrite(Ei).rewrite(expint, **hints)
+
+    def _eval_rewrite_as_Si(self, nu, z, **kwargs):
+        if nu != 1:
+            return self
+        return Shi(z) - Chi(z)
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Si
+    _eval_rewrite_as_Shi = _eval_rewrite_as_Si
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        if not self.args[0].has(x):
+            nu = self.args[0]
+            if nu == 1:
+                f = self._eval_rewrite_as_Si(*self.args)
+                return f._eval_nseries(x, n, logx)
+            elif nu.is_Integer and nu > 1:
+                f = self._eval_rewrite_as_Ei(*self.args)
+                return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[1]
+        nu = self.args[0]
+
+        if point is S.Infinity:
+            z = self.args[1]
+            s = [S.NegativeOne**k * RisingFactorial(nu, k) / z**k for k in range(n)] + [Order(1/z**n, x)]
+            return (exp(-z)/z) * Add(*s)
+
+        return super(expint, self)._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_Integral(self, *args, **kwargs):
+        from sympy.integrals.integrals import Integral
+        n, x = self.args
+        t = Dummy(uniquely_named_symbol('t', args).name)
+        return Integral(t**-n * exp(-t*x), (t, 1, S.Infinity))
+
+
+def E1(z):
+    """
+    Classical case of the generalized exponential integral.
+
+    Explanation
+    ===========
+
+    This is equivalent to ``expint(1, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import E1
+    >>> E1(0)
+    expint(1, 0)
+
+    >>> E1(5)
+    expint(1, 5)
+
+    See Also
+    ========
+
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    """
+    return expint(1, z)
+
+
+class li(DefinedFunction):
+    r"""
+    The classical logarithmic integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{li}(x) = \int_0^x \frac{1}{\log(t)} \mathrm{d}t \,.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, li
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> li(0)
+    0
+    >>> li(1)
+    -oo
+    >>> li(oo)
+    oo
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(li(z), z)
+    1/log(z)
+
+    Defining the ``li`` function via an integral:
+    >>> from sympy import integrate
+    >>> integrate(li(z))
+    z*li(z) - Ei(2*log(z))
+
+    >>> integrate(li(z),z)
+    z*li(z) - Ei(2*log(z))
+
+
+    The logarithmic integral can also be defined in terms of ``Ei``:
+
+    >>> from sympy import Ei
+    >>> li(z).rewrite(Ei)
+    Ei(log(z))
+    >>> diff(li(z).rewrite(Ei), z)
+    1/log(z)
+
+    We can numerically evaluate the logarithmic integral to arbitrary precision
+    on the whole complex plane (except the singular points):
+
+    >>> li(2).evalf(30)
+    1.04516378011749278484458888919
+
+    >>> li(2*I).evalf(30)
+    1.0652795784357498247001125598 + 3.08346052231061726610939702133*I
+
+    We can even compute Soldner's constant by the help of mpmath:
+
+    >>> from mpmath import findroot
+    >>> findroot(li, 2)
+    1.45136923488338
+
+    Further transformations include rewriting ``li`` in terms of
+    the trigonometric integrals ``Si``, ``Ci``, ``Shi`` and ``Chi``:
+
+    >>> from sympy import Si, Ci, Shi, Chi
+    >>> li(z).rewrite(Si)
+    -log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
+    >>> li(z).rewrite(Ci)
+    -log(I*log(z)) - log(1/log(z))/2 + log(log(z))/2 + Ci(I*log(z)) + Shi(log(z))
+    >>> li(z).rewrite(Shi)
+    -log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z))
+    >>> li(z).rewrite(Chi)
+    -log(1/log(z))/2 + log(log(z))/2 + Chi(log(z)) - Shi(log(z))
+
+    See Also
+    ========
+
+    Li: Offset logarithmic integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_integral
+    .. [2] https://mathworld.wolfram.com/LogarithmicIntegral.html
+    .. [3] https://dlmf.nist.gov/6
+    .. [4] https://mathworld.wolfram.com/SoldnersConstant.html
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z.is_zero:
+            return S.Zero
+        elif z is S.One:
+            return S.NegativeInfinity
+        elif z is S.Infinity:
+            return S.Infinity
+        if z.is_zero:
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        arg = self.args[0]
+        if argindex == 1:
+            return S.One / log(arg)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_conjugate(self):
+        z = self.args[0]
+        # Exclude values on the branch cut (-oo, 0)
+        if not z.is_extended_negative:
+            return self.func(z.conjugate())
+
+    def _eval_rewrite_as_Li(self, z, **kwargs):
+        return Li(z) + li(2)
+
+    def _eval_rewrite_as_Ei(self, z, **kwargs):
+        return Ei(log(z))
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return (-uppergamma(0, -log(z)) +
+                S.Half*(log(log(z)) - log(S.One/log(z))) - log(-log(z)))
+
+    def _eval_rewrite_as_Si(self, z, **kwargs):
+        return (Ci(I*log(z)) - I*Si(I*log(z)) -
+                S.Half*(log(S.One/log(z)) - log(log(z))) - log(I*log(z)))
+
+    _eval_rewrite_as_Ci = _eval_rewrite_as_Si
+
+    def _eval_rewrite_as_Shi(self, z, **kwargs):
+        return (Chi(log(z)) - Shi(log(z)) - S.Half*(log(S.One/log(z)) - log(log(z))))
+
+    _eval_rewrite_as_Chi = _eval_rewrite_as_Shi
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return (log(z)*hyper((1, 1), (2, 2), log(z)) +
+                S.Half*(log(log(z)) - log(S.One/log(z))) + EulerGamma)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (-log(-log(z)) - S.Half*(log(S.One/log(z)) - log(log(z)))
+                - meijerg(((), (1,)), ((0, 0), ()), -log(z)))
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return z * _eis(log(z))
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        z = self.args[0]
+        s = [(log(z))**k / (factorial(k) * k) for k in range(1, n)]
+        return EulerGamma + log(log(z)) + Add(*s)
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+class Li(DefinedFunction):
+    r"""
+    The offset logarithmic integral.
+
+    Explanation
+    ===========
+
+    For use in SymPy, this function is defined as
+
+    .. math:: \operatorname{Li}(x) = \operatorname{li}(x) - \operatorname{li}(2)
+
+    Examples
+    ========
+
+    >>> from sympy import Li
+    >>> from sympy.abc import z
+
+    The following special value is known:
+
+    >>> Li(2)
+    0
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(Li(z), z)
+    1/log(z)
+
+    The shifted logarithmic integral can be written in terms of $li(z)$:
+
+    >>> from sympy import li
+    >>> Li(z).rewrite(li)
+    li(z) - li(2)
+
+    We can numerically evaluate the logarithmic integral to arbitrary precision
+    on the whole complex plane (except the singular points):
+
+    >>> Li(2).evalf(30)
+    0
+
+    >>> Li(4).evalf(30)
+    1.92242131492155809316615998938
+
+    See Also
+    ========
+
+    li: Logarithmic integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Logarithmic_integral
+    .. [2] https://mathworld.wolfram.com/LogarithmicIntegral.html
+    .. [3] https://dlmf.nist.gov/6
+
+    """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.Infinity:
+            return S.Infinity
+        elif z == S(2):
+            return S.Zero
+
+    def fdiff(self, argindex=1):
+        arg = self.args[0]
+        if argindex == 1:
+            return S.One / log(arg)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        return self.rewrite(li).evalf(prec)
+
+    def _eval_rewrite_as_li(self, z, **kwargs):
+        return li(z) - li(2)
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return self.rewrite(li).rewrite("tractable", deep=True)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        f = self._eval_rewrite_as_li(*self.args)
+        return f._eval_nseries(x, n, logx)
+
+###############################################################################
+#################### TRIGONOMETRIC INTEGRALS ##################################
+###############################################################################
+
+class TrigonometricIntegral(DefinedFunction):
+    """ Base class for trigonometric integrals. """
+
+
+    @classmethod
+    def eval(cls, z):
+        if z is S.Zero:
+            return cls._atzero
+        elif z is S.Infinity:
+            return cls._atinf()
+        elif z is S.NegativeInfinity:
+            return cls._atneginf()
+
+        if z.is_zero:
+            return cls._atzero
+
+        nz = z.extract_multiplicatively(polar_lift(I))
+        if nz is None and cls._trigfunc(0) == 0:
+            nz = z.extract_multiplicatively(I)
+        if nz is not None:
+            return cls._Ifactor(nz, 1)
+        nz = z.extract_multiplicatively(polar_lift(-I))
+        if nz is not None:
+            return cls._Ifactor(nz, -1)
+
+        nz = z.extract_multiplicatively(polar_lift(-1))
+        if nz is None and cls._trigfunc(0) == 0:
+            nz = z.extract_multiplicatively(-1)
+        if nz is not None:
+            return cls._minusfactor(nz)
+
+        nz, n = z.extract_branch_factor()
+        if n == 0 and nz == z:
+            return
+        return 2*pi*I*n*cls._trigfunc(0) + cls(nz)
+
+    def fdiff(self, argindex=1):
+        arg = unpolarify(self.args[0])
+        if argindex == 1:
+            return self._trigfunc(arg)/arg
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Ei(self, z, **kwargs):
+        return self._eval_rewrite_as_expint(z).rewrite(Ei)
+
+    def _eval_rewrite_as_uppergamma(self, z, **kwargs):
+        from sympy.functions.special.gamma_functions import uppergamma
+        return self._eval_rewrite_as_expint(z).rewrite(uppergamma)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        # NOTE this is fairly inefficient
+        if self.args[0].subs(x, 0) != 0:
+            return super()._eval_nseries(x, n, logx)
+        baseseries = self._trigfunc(x)._eval_nseries(x, n, logx)
+        if self._trigfunc(0) != 0:
+            baseseries -= 1
+        baseseries = baseseries.replace(Pow, lambda t, n: t**n/n, simultaneous=False)
+        if self._trigfunc(0) != 0:
+            baseseries += EulerGamma + log(x)
+        return baseseries.subs(x, self.args[0])._eval_nseries(x, n, logx)
+
+
+class Si(TrigonometricIntegral):
+    r"""
+    Sine integral.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{Si}(z) = \int_0^z \frac{\sin{t}}{t} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import Si
+    >>> from sympy.abc import z
+
+    The sine integral is an antiderivative of $sin(z)/z$:
+
+    >>> Si(z).diff(z)
+    sin(z)/z
+
+    It is unbranched:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Si(z*exp_polar(2*I*pi))
+    Si(z)
+
+    Sine integral behaves much like ordinary sine under multiplication by ``I``:
+
+    >>> Si(I*z)
+    I*Shi(z)
+    >>> Si(-z)
+    -Si(z)
+
+    It can also be expressed in terms of exponential integrals, but beware
+    that the latter is branched:
+
+    >>> from sympy import expint
+    >>> Si(z).rewrite(expint)
+    -I*(-expint(1, z*exp_polar(-I*pi/2))/2 +
+         expint(1, z*exp_polar(I*pi/2))/2) + pi/2
+
+    It can be rewritten in the form of sinc function (by definition):
+
+    >>> from sympy import sinc
+    >>> Si(z).rewrite(sinc)
+    Integral(sinc(_t), (_t, 0, z))
+
+    See Also
+    ========
+
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    sinc: unnormalized sinc function
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = sin
+    _atzero = S.Zero
+
+    @classmethod
+    def _atinf(cls):
+        return pi*S.Half
+
+    @classmethod
+    def _atneginf(cls):
+        return -pi*S.Half
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return -Si(z)
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return I*Shi(z)*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        # XXX should we polarify z?
+        return pi/2 + (E1(polar_lift(I)*z) - E1(polar_lift(-I)*z))/2/I
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(sinc(t), (t, 0, z))
+
+    _eval_rewrite_as_sinc =  _eval_rewrite_as_Integral
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif not arg0.is_infinite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point is S.Infinity:
+            z = self.args[0]
+            p = [S.NegativeOne**k * factorial(2*k) / z**(2*k + 1)
+                    for k in range(n//2 + 1)] + [Order(1/z**n, x)]
+            q = [S.NegativeOne**k * factorial(2*k + 1) / z**(2*(k + 1))
+                    for k in range(n//2)] + [Order(1/z**n, x)]
+            return pi/2 - cos(z)*Add(*p) - sin(z)*Add(*q)
+
+        # All other points are not handled
+        return super(Si, self)._eval_aseries(n, args0, x, logx)
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+
+class Ci(TrigonometricIntegral):
+    r"""
+    Cosine integral.
+
+    Explanation
+    ===========
+
+    This function is defined for positive $x$ by
+
+    .. math:: \operatorname{Ci}(x) = \gamma + \log{x}
+                         + \int_0^x \frac{\cos{t} - 1}{t} \mathrm{d}t
+           = -\int_x^\infty \frac{\cos{t}}{t} \mathrm{d}t,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    We have
+
+    .. math:: \operatorname{Ci}(z) =
+        -\frac{\operatorname{E}_1\left(e^{i\pi/2} z\right)
+               + \operatorname{E}_1\left(e^{-i \pi/2} z\right)}{2}
+
+    which holds for all polar $z$ and thus provides an analytic
+    continuation to the Riemann surface of the logarithm.
+
+    The formula also holds as stated
+    for $z \in \mathbb{C}$ with $\Re(z) > 0$.
+    By lifting to the principal branch, we obtain an analytic function on the
+    cut complex plane.
+
+    Examples
+    ========
+
+    >>> from sympy import Ci
+    >>> from sympy.abc import z
+
+    The cosine integral is a primitive of $\cos(z)/z$:
+
+    >>> Ci(z).diff(z)
+    cos(z)/z
+
+    It has a logarithmic branch point at the origin:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Ci(z*exp_polar(2*I*pi))
+    Ci(z) + 2*I*pi
+
+    The cosine integral behaves somewhat like ordinary $\cos$ under
+    multiplication by $i$:
+
+    >>> from sympy import polar_lift
+    >>> Ci(polar_lift(I)*z)
+    Chi(z) + I*pi/2
+    >>> Ci(polar_lift(-1)*z)
+    Ci(z) + I*pi
+
+    It can also be expressed in terms of exponential integrals:
+
+    >>> from sympy import expint
+    >>> Ci(z).rewrite(expint)
+    -expint(1, z*exp_polar(-I*pi/2))/2 - expint(1, z*exp_polar(I*pi/2))/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Shi: Hyperbolic sine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = cos
+    _atzero = S.ComplexInfinity
+
+    @classmethod
+    def _atinf(cls):
+        return S.Zero
+
+    @classmethod
+    def _atneginf(cls):
+        return I*pi
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return Ci(z) + I*pi
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return Chi(z) + I*pi/2*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -(E1(polar_lift(I)*z) + E1(polar_lift(-I)*z))/2
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return S.EulerGamma + log(z) - Integral((1-cos(t))/t, (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        if point in (S.Infinity, S.NegativeInfinity):
+            z = self.args[0]
+            p = [S.NegativeOne**k * factorial(2*k) / z**(2*k + 1)
+                    for k in range(n//2 + 1)] + [Order(1/z**n, x)]
+            q = [S.NegativeOne**k * factorial(2*k + 1) / z**(2*(k + 1))
+                    for k in range(n//2)] + [Order(1/z**n, x)]
+            result = sin(z)*(Add(*p)) - cos(z)*(Add(*q))
+
+            if point is S.NegativeInfinity:
+                result += I*pi
+            return result
+
+        return super(Ci, self)._eval_aseries(n, args0, x, logx)
+
+class Shi(TrigonometricIntegral):
+    r"""
+    Sinh integral.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{Shi}(z) = \int_0^z \frac{\sinh{t}}{t} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import Shi
+    >>> from sympy.abc import z
+
+    The Sinh integral is a primitive of $\sinh(z)/z$:
+
+    >>> Shi(z).diff(z)
+    sinh(z)/z
+
+    It is unbranched:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Shi(z*exp_polar(2*I*pi))
+    Shi(z)
+
+    The $\sinh$ integral behaves much like ordinary $\sinh$ under
+    multiplication by $i$:
+
+    >>> Shi(I*z)
+    I*Si(z)
+    >>> Shi(-z)
+    -Shi(z)
+
+    It can also be expressed in terms of exponential integrals, but beware
+    that the latter is branched:
+
+    >>> from sympy import expint
+    >>> Shi(z).rewrite(expint)
+    expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Chi: Hyperbolic cosine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = sinh
+    _atzero = S.Zero
+
+    @classmethod
+    def _atinf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _atneginf(cls):
+        return S.NegativeInfinity
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return -Shi(z)
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return I*Si(z)*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        # XXX should we polarify z?
+        return (E1(z) - E1(exp_polar(I*pi)*z))/2 - I*pi/2
+
+    def _eval_is_zero(self):
+        z = self.args[0]
+        if z.is_zero:
+            return True
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif not arg0.is_infinite:
+            return self.func(arg0)
+        else:
+            return self
+
+
+class Chi(TrigonometricIntegral):
+    r"""
+    Cosh integral.
+
+    Explanation
+    ===========
+
+    This function is defined for positive $x$ by
+
+    .. math:: \operatorname{Chi}(x) = \gamma + \log{x}
+                         + \int_0^x \frac{\cosh{t} - 1}{t} \mathrm{d}t,
+
+    where $\gamma$ is the Euler-Mascheroni constant.
+
+    We have
+
+    .. math:: \operatorname{Chi}(z) = \operatorname{Ci}\left(e^{i \pi/2}z\right)
+                         - i\frac{\pi}{2},
+
+    which holds for all polar $z$ and thus provides an analytic
+    continuation to the Riemann surface of the logarithm.
+    By lifting to the principal branch we obtain an analytic function on the
+    cut complex plane.
+
+    Examples
+    ========
+
+    >>> from sympy import Chi
+    >>> from sympy.abc import z
+
+    The $\cosh$ integral is a primitive of $\cosh(z)/z$:
+
+    >>> Chi(z).diff(z)
+    cosh(z)/z
+
+    It has a logarithmic branch point at the origin:
+
+    >>> from sympy import exp_polar, I, pi
+    >>> Chi(z*exp_polar(2*I*pi))
+    Chi(z) + 2*I*pi
+
+    The $\cosh$ integral behaves somewhat like ordinary $\cosh$ under
+    multiplication by $i$:
+
+    >>> from sympy import polar_lift
+    >>> Chi(polar_lift(I)*z)
+    Ci(z) + I*pi/2
+    >>> Chi(polar_lift(-1)*z)
+    Chi(z) + I*pi
+
+    It can also be expressed in terms of exponential integrals:
+
+    >>> from sympy import expint
+    >>> Chi(z).rewrite(expint)
+    -expint(1, z)/2 - expint(1, z*exp_polar(I*pi))/2 - I*pi/2
+
+    See Also
+    ========
+
+    Si: Sine integral.
+    Ci: Cosine integral.
+    Shi: Hyperbolic sine integral.
+    Ei: Exponential integral.
+    expint: Generalised exponential integral.
+    E1: Special case of the generalised exponential integral.
+    li: Logarithmic integral.
+    Li: Offset logarithmic integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigonometric_integral
+
+    """
+
+    _trigfunc = cosh
+    _atzero = S.ComplexInfinity
+
+    @classmethod
+    def _atinf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _atneginf(cls):
+        return S.Infinity
+
+    @classmethod
+    def _minusfactor(cls, z):
+        return Chi(z) + I*pi
+
+    @classmethod
+    def _Ifactor(cls, z, sign):
+        return Ci(z) + I*pi/2*sign
+
+    def _eval_rewrite_as_expint(self, z, **kwargs):
+        return -I*pi/2 - (E1(z) + E1(exp_polar(I*pi)*z))/2
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.NaN:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            c, e = arg.as_coeff_exponent(x)
+            logx = log(x) if logx is None else logx
+            return log(c) + e*logx + EulerGamma
+        elif arg0.is_finite:
+            return self.func(arg0)
+        else:
+            return self
+
+
+###############################################################################
+#################### FRESNEL INTEGRALS ########################################
+###############################################################################
+
+class FresnelIntegral(DefinedFunction):
+    """ Base class for the Fresnel integrals."""
+
+    unbranched = True
+
+    @classmethod
+    def eval(cls, z):
+        # Values at positive infinities signs
+        # if any were extracted automatically
+        if z is S.Infinity:
+            return S.Half
+
+        # Value at zero
+        if z.is_zero:
+            return S.Zero
+
+        # Try to pull out factors of -1 and I
+        prefact = S.One
+        newarg = z
+        changed = False
+
+        nz = newarg.extract_multiplicatively(-1)
+        if nz is not None:
+            prefact = -prefact
+            newarg = nz
+            changed = True
+
+        nz = newarg.extract_multiplicatively(I)
+        if nz is not None:
+            prefact = cls._sign*I*prefact
+            newarg = nz
+            changed = True
+
+        if changed:
+            return prefact*cls(newarg)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self._trigfunc(S.Half*pi*self.args[0]**2)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_is_extended_real(self):
+        return self.args[0].is_extended_real
+
+    _eval_is_finite = _eval_is_extended_real
+
+    def _eval_is_zero(self):
+        return self.args[0].is_zero
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    as_real_imag = real_to_real_as_real_imag
+
+
+class fresnels(FresnelIntegral):
+    r"""
+    Fresnel integral S.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{S}(z) = \int_0^z \sin{\frac{\pi}{2} t^2} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, fresnels
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> fresnels(0)
+    0
+    >>> fresnels(oo)
+    1/2
+    >>> fresnels(-oo)
+    -1/2
+    >>> fresnels(I*oo)
+    -I/2
+    >>> fresnels(-I*oo)
+    I/2
+
+    In general one can pull out factors of -1 and $i$ from the argument:
+
+    >>> fresnels(-z)
+    -fresnels(z)
+    >>> fresnels(I*z)
+    -I*fresnels(z)
+
+    The Fresnel S integral obeys the mirror symmetry
+    $\overline{S(z)} = S(\bar{z})$:
+
+    >>> from sympy import conjugate
+    >>> conjugate(fresnels(z))
+    fresnels(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(fresnels(z), z)
+    sin(pi*z**2/2)
+
+    Defining the Fresnel functions via an integral:
+
+    >>> from sympy import integrate, pi, sin, expand_func
+    >>> integrate(sin(pi*z**2/2), z)
+    3*fresnels(z)*gamma(3/4)/(4*gamma(7/4))
+    >>> expand_func(integrate(sin(pi*z**2/2), z))
+    fresnels(z)
+
+    We can numerically evaluate the Fresnel integral to arbitrary precision
+    on the whole complex plane:
+
+    >>> fresnels(2).evalf(30)
+    0.343415678363698242195300815958
+
+    >>> fresnels(-2*I).evalf(30)
+    0.343415678363698242195300815958*I
+
+    See Also
+    ========
+
+    fresnelc: Fresnel cosine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fresnel_integral
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/FresnelIntegrals.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/FresnelS
+    .. [5] The converging factors for the fresnel integrals
+            by John W. Wrench Jr. and Vicki Alley
+
+    """
+    _trigfunc = sin
+    _sign = -S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (-pi**2*x**4*(4*n - 1)/(8*n*(2*n + 1)*(4*n + 3))) * p
+            else:
+                return x**3 * (-x**4)**n * (S(2)**(-2*n - 1)*pi**(2*n + 1)) / ((4*n + 3)*factorial(2*n + 1))
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return (S.One + I)/4 * (erf((S.One + I)/2*sqrt(pi)*z) - I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return pi*z**3/6 * hyper([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)], -pi**2*z**4/16)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (pi*z**Rational(9, 4) / (sqrt(2)*(z**2)**Rational(3, 4)*(-z)**Rational(3, 4))
+                * meijerg([], [1], [Rational(3, 4)], [Rational(1, 4), 0], -pi**2*z**4/16))
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(sin(pi*t**2/2), (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return pi*arg**3/6
+        elif arg0 in [S.Infinity, S.NegativeInfinity]:
+            s = 1 if arg0 is S.Infinity else -1
+            return s*S.Half + Order(x, x)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo and -oo
+        if point in [S.Infinity, -S.Infinity]:
+            z = self.args[0]
+
+            # expansion of S(x) = S1(x*sqrt(pi/2)), see reference[5] page 1-8
+            # as only real infinities are dealt with, sin and cos are O(1)
+            p = [S.NegativeOne**k * factorial(4*k + 1) /
+                 (2**(2*k + 2) * z**(4*k + 3) * 2**(2*k)*factorial(2*k))
+                 for k in range(0, n) if 4*k + 3 < n]
+            q = [1/(2*z)] + [S.NegativeOne**k * factorial(4*k - 1) /
+                 (2**(2*k + 1) * z**(4*k + 1) * 2**(2*k - 1)*factorial(2*k - 1))
+                 for k in range(1, n) if 4*k + 1 < n]
+
+            p = [-sqrt(2/pi)*t for t in p]
+            q = [-sqrt(2/pi)*t for t in q]
+            s = 1 if point is S.Infinity else -1
+            # The expansion at oo is 1/2 + some odd powers of z
+            # To get the expansion at -oo, replace z by -z and flip the sign
+            # The result -1/2 + the same odd powers of z as before.
+            return s*S.Half + (sin(z**2)*Add(*p) + cos(z**2)*Add(*q)
+                ).subs(x, sqrt(2/pi)*x) + Order(1/z**n, x)
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+class fresnelc(FresnelIntegral):
+    r"""
+    Fresnel integral C.
+
+    Explanation
+    ===========
+
+    This function is defined by
+
+    .. math:: \operatorname{C}(z) = \int_0^z \cos{\frac{\pi}{2} t^2} \mathrm{d}t.
+
+    It is an entire function.
+
+    Examples
+    ========
+
+    >>> from sympy import I, oo, fresnelc
+    >>> from sympy.abc import z
+
+    Several special values are known:
+
+    >>> fresnelc(0)
+    0
+    >>> fresnelc(oo)
+    1/2
+    >>> fresnelc(-oo)
+    -1/2
+    >>> fresnelc(I*oo)
+    I/2
+    >>> fresnelc(-I*oo)
+    -I/2
+
+    In general one can pull out factors of -1 and $i$ from the argument:
+
+    >>> fresnelc(-z)
+    -fresnelc(z)
+    >>> fresnelc(I*z)
+    I*fresnelc(z)
+
+    The Fresnel C integral obeys the mirror symmetry
+    $\overline{C(z)} = C(\bar{z})$:
+
+    >>> from sympy import conjugate
+    >>> conjugate(fresnelc(z))
+    fresnelc(conjugate(z))
+
+    Differentiation with respect to $z$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(fresnelc(z), z)
+    cos(pi*z**2/2)
+
+    Defining the Fresnel functions via an integral:
+
+    >>> from sympy import integrate, pi, cos, expand_func
+    >>> integrate(cos(pi*z**2/2), z)
+    fresnelc(z)*gamma(1/4)/(4*gamma(5/4))
+    >>> expand_func(integrate(cos(pi*z**2/2), z))
+    fresnelc(z)
+
+    We can numerically evaluate the Fresnel integral to arbitrary precision
+    on the whole complex plane:
+
+    >>> fresnelc(2).evalf(30)
+    0.488253406075340754500223503357
+
+    >>> fresnelc(-2*I).evalf(30)
+    -0.488253406075340754500223503357*I
+
+    See Also
+    ========
+
+    fresnels: Fresnel sine integral.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Fresnel_integral
+    .. [2] https://dlmf.nist.gov/7
+    .. [3] https://mathworld.wolfram.com/FresnelIntegrals.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/FresnelC
+    .. [5] The converging factors for the fresnel integrals
+            by John W. Wrench Jr. and Vicki Alley
+
+    """
+    _trigfunc = cos
+    _sign = S.One
+
+    @staticmethod
+    @cacheit
+    def taylor_term(n, x, *previous_terms):
+        if n < 0:
+            return S.Zero
+        else:
+            x = sympify(x)
+            if len(previous_terms) > 1:
+                p = previous_terms[-1]
+                return (-pi**2*x**4*(4*n - 3)/(8*n*(2*n - 1)*(4*n + 1))) * p
+            else:
+                return x * (-x**4)**n * (S(2)**(-2*n)*pi**(2*n)) / ((4*n + 1)*factorial(2*n))
+
+    def _eval_rewrite_as_erf(self, z, **kwargs):
+        return (S.One - I)/4 * (erf((S.One + I)/2*sqrt(pi)*z) + I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    def _eval_rewrite_as_hyper(self, z, **kwargs):
+        return z * hyper([Rational(1, 4)], [S.Half, Rational(5, 4)], -pi**2*z**4/16)
+
+    def _eval_rewrite_as_meijerg(self, z, **kwargs):
+        return (pi*z**Rational(3, 4) / (sqrt(2)*root(z**2, 4)*root(-z, 4))
+                * meijerg([], [1], [Rational(1, 4)], [Rational(3, 4), 0], -pi**2*z**4/16))
+
+    def _eval_rewrite_as_Integral(self, z, **kwargs):
+        from sympy.integrals.integrals import Integral
+        t = Dummy(uniquely_named_symbol('t', [z]).name)
+        return Integral(cos(pi*t**2/2), (t, 0, z))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        arg = self.args[0].as_leading_term(x, logx=logx, cdir=cdir)
+        arg0 = arg.subs(x, 0)
+
+        if arg0 is S.ComplexInfinity:
+            arg0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+        if arg0.is_zero:
+            return arg
+        elif arg0 in [S.Infinity, S.NegativeInfinity]:
+            s = 1 if arg0 is S.Infinity else -1
+            return s*S.Half + Order(x, x)
+        else:
+            return self.func(arg0)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point in [S.Infinity, -S.Infinity]:
+            z = self.args[0]
+
+            # expansion of C(x) = C1(x*sqrt(pi/2)), see reference[5] page 1-8
+            # as only real infinities are dealt with, sin and cos are O(1)
+            p = [S.NegativeOne**k * factorial(4*k + 1) /
+                 (2**(2*k + 2) * z**(4*k + 3) * 2**(2*k)*factorial(2*k))
+                 for k in range(n) if 4*k + 3 < n]
+            q = [1/(2*z)] + [S.NegativeOne**k * factorial(4*k - 1) /
+                 (2**(2*k + 1) * z**(4*k + 1) * 2**(2*k - 1)*factorial(2*k - 1))
+                 for k in range(1, n) if 4*k + 1 < n]
+
+            p = [-sqrt(2/pi)*t for t in p]
+            q = [ sqrt(2/pi)*t for t in q]
+            s = 1 if point is S.Infinity else -1
+            # The expansion at oo is 1/2 + some odd powers of z
+            # To get the expansion at -oo, replace z by -z and flip the sign
+            # The result -1/2 + the same odd powers of z as before.
+            return s*S.Half + (cos(z**2)*Add(*p) + sin(z**2)*Add(*q)
+                ).subs(x, sqrt(2/pi)*x) + Order(1/z**n, x)
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+
+###############################################################################
+#################### HELPER FUNCTIONS #########################################
+###############################################################################
+
+
+class _erfs(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{erf}(z)$ function
+    tractable for the Gruntz algorithm.
+
+    """
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_zero:
+            return S.One
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        point = args0[0]
+
+        # Expansion at oo
+        if point is S.Infinity:
+            z = self.args[0]
+            l = [1/sqrt(pi) * factorial(2*k)*(-S(
+                 4))**(-k)/factorial(k) * (1/z)**(2*k + 1) for k in range(n)]
+            o = Order(1/z**(2*n + 1), x)
+            # It is very inefficient to first add the order and then do the nseries
+            return (Add(*l))._eval_nseries(x, n, logx) + o
+
+        # Expansion at I*oo
+        t = point.extract_multiplicatively(I)
+        if t is S.Infinity:
+            z = self.args[0]
+            # TODO: is the series really correct?
+            l = [1/sqrt(pi) * factorial(2*k)*(-S(
+                 4))**(-k)/factorial(k) * (1/z)**(2*k + 1) for k in range(n)]
+            o = Order(1/z**(2*n + 1), x)
+            # It is very inefficient to first add the order and then do the nseries
+            return (Add(*l))._eval_nseries(x, n, logx) + o
+
+        # All other points are not handled
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return -2/sqrt(pi) + 2*z*_erfs(z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return (S.One - erf(z))*exp(z**2)
+
+
+class _eis(DefinedFunction):
+    """
+    Helper function to make the $\\mathrm{Ei}(z)$ and $\\mathrm{li}(z)$
+    functions tractable for the Gruntz algorithm.
+
+    """
+
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[0] not in (S.Infinity, S.NegativeInfinity):
+            return super()._eval_aseries(n, args0, x, logx)
+
+        z = self.args[0]
+        l = [factorial(k) * (1/z)**(k + 1) for k in range(n)]
+        o = Order(1/z**(n + 1), x)
+        # It is very inefficient to first add the order and then do the nseries
+        return (Add(*l))._eval_nseries(x, n, logx) + o
+
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            z = self.args[0]
+            return S.One / z - _eis(z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return exp(-z)*Ei(z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_as_leading_term(x, logx=logx, cdir=cdir)
+        return super()._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/gamma_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/gamma_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..73a5a1585154c603e9c510b3c61144039e0e5502
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/gamma_functions.py
@@ -0,0 +1,1344 @@
+from math import prod
+
+from sympy.core import Add, S, Dummy, expand_func
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError, PoleError
+from sympy.core.logic import fuzzy_and, fuzzy_not
+from sympy.core.numbers import Rational, pi, oo, I
+from sympy.core.power import Pow
+from sympy.functions.special.zeta_functions import zeta
+from sympy.functions.special.error_functions import erf, erfc, Ei
+from sympy.functions.elementary.complexes import re, unpolarify
+from sympy.functions.elementary.exponential import exp, log
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos, cot
+from sympy.functions.combinatorial.numbers import bernoulli, harmonic
+from sympy.functions.combinatorial.factorials import factorial, rf, RisingFactorial
+from sympy.utilities.misc import as_int
+
+from mpmath import mp, workprec
+from mpmath.libmp.libmpf import prec_to_dps
+
+def intlike(n):
+    try:
+        as_int(n, strict=False)
+        return True
+    except ValueError:
+        return False
+
+###############################################################################
+############################ COMPLETE GAMMA FUNCTION ##########################
+###############################################################################
+
+class gamma(DefinedFunction):
+    r"""
+    The gamma function
+
+    .. math::
+        \Gamma(x) := \int^{\infty}_{0} t^{x-1} e^{-t} \mathrm{d}t.
+
+    Explanation
+    ===========
+
+    The ``gamma`` function implements the function which passes through the
+    values of the factorial function (i.e., $\Gamma(n) = (n - 1)!$ when n is
+    an integer). More generally, $\Gamma(z)$ is defined in the whole complex
+    plane except at the negative integers where there are simple poles.
+
+    Examples
+    ========
+
+    >>> from sympy import S, I, pi, gamma
+    >>> from sympy.abc import x
+
+    Several special values are known:
+
+    >>> gamma(1)
+    1
+    >>> gamma(4)
+    6
+    >>> gamma(S(3)/2)
+    sqrt(pi)/2
+
+    The ``gamma`` function obeys the mirror symmetry:
+
+    >>> from sympy import conjugate
+    >>> conjugate(gamma(x))
+    gamma(conjugate(x))
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(gamma(x), x)
+    gamma(x)*polygamma(0, x)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(gamma(x), x, 0, 3)
+    1/x - EulerGamma + x*(EulerGamma**2/2 + pi**2/12) + x**2*(-EulerGamma*pi**2/12 - zeta(3)/3 - EulerGamma**3/6) + O(x**3)
+
+    We can numerically evaluate the ``gamma`` function to arbitrary precision
+    on the whole complex plane:
+
+    >>> gamma(pi).evalf(40)
+    2.288037795340032417959588909060233922890
+    >>> gamma(1+I).evalf(20)
+    0.49801566811835604271 - 0.15494982830181068512*I
+
+    See Also
+    ========
+
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gamma_function
+    .. [2] https://dlmf.nist.gov/5
+    .. [3] https://mathworld.wolfram.com/GammaFunction.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma/
+
+    """
+
+    unbranched = True
+    _singularities = (S.ComplexInfinity,)
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return self.func(self.args[0])*polygamma(0, self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, arg):
+        if arg.is_Number:
+            if arg is S.NaN:
+                return S.NaN
+            elif arg is oo:
+                return oo
+            elif intlike(arg):
+                if arg.is_positive:
+                    return factorial(arg - 1)
+                else:
+                    return S.ComplexInfinity
+            elif arg.is_Rational:
+                if arg.q == 2:
+                    n = abs(arg.p) // arg.q
+
+                    if arg.is_positive:
+                        k, coeff = n, S.One
+                    else:
+                        n = k = n + 1
+
+                        if n & 1 == 0:
+                            coeff = S.One
+                        else:
+                            coeff = S.NegativeOne
+
+                    coeff *= prod(range(3, 2*k, 2))
+
+                    if arg.is_positive:
+                        return coeff*sqrt(pi) / 2**n
+                    else:
+                        return 2**n*sqrt(pi) / coeff
+
+    def _eval_expand_func(self, **hints):
+        arg = self.args[0]
+        if arg.is_Rational:
+            if abs(arg.p) > arg.q:
+                x = Dummy('x')
+                n = arg.p // arg.q
+                p = arg.p - n*arg.q
+                return self.func(x + n)._eval_expand_func().subs(x, Rational(p, arg.q))
+
+        if arg.is_Add:
+            coeff, tail = arg.as_coeff_add()
+            if coeff and coeff.q != 1:
+                intpart = floor(coeff)
+                tail = (coeff - intpart,) + tail
+                coeff = intpart
+            tail = arg._new_rawargs(*tail, reeval=False)
+            return self.func(tail)*RisingFactorial(tail, coeff)
+
+        return self.func(*self.args)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0].conjugate())
+
+    def _eval_is_real(self):
+        x = self.args[0]
+        if x.is_nonpositive and x.is_integer:
+            return False
+        if intlike(x) and x <= 0:
+            return False
+        if x.is_positive or x.is_noninteger:
+            return True
+
+    def _eval_is_positive(self):
+        x = self.args[0]
+        if x.is_positive:
+            return True
+        elif x.is_noninteger:
+            return floor(x).is_even
+
+    def _eval_rewrite_as_tractable(self, z, limitvar=None, **kwargs):
+        return exp(loggamma(z))
+
+    def _eval_rewrite_as_factorial(self, z, **kwargs):
+        return factorial(z - 1)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if not (x0.is_Integer and x0 <= 0):
+            return super()._eval_nseries(x, n, logx)
+        t = self.args[0] - x0
+        return (self.func(t + 1)/rf(self.args[0], -x0 + 1))._eval_nseries(x, n, logx)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[0]
+        x0 = arg.subs(x, 0)
+
+        if x0.is_integer and x0.is_nonpositive:
+            n = -x0
+            res = S.NegativeOne**n/self.func(n + 1)
+            return res/(arg + n).as_leading_term(x)
+        elif not x0.is_infinite:
+            return self.func(x0)
+        raise PoleError()
+
+
+###############################################################################
+################## LOWER and UPPER INCOMPLETE GAMMA FUNCTIONS #################
+###############################################################################
+
+class lowergamma(DefinedFunction):
+    r"""
+    The lower incomplete gamma function.
+
+    Explanation
+    ===========
+
+    It can be defined as the meromorphic continuation of
+
+    .. math::
+        \gamma(s, x) := \int_0^x t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \Gamma(s, x).
+
+    This can be shown to be the same as
+
+    .. math::
+        \gamma(s, x) = \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),
+
+    where ${}_1F_1$ is the (confluent) hypergeometric function.
+
+    Examples
+    ========
+
+    >>> from sympy import lowergamma, S
+    >>> from sympy.abc import s, x
+    >>> lowergamma(s, x)
+    lowergamma(s, x)
+    >>> lowergamma(3, x)
+    -2*(x**2/2 + x + 1)*exp(-x) + 2
+    >>> lowergamma(-S(1)/2, x)
+    -2*sqrt(pi)*erf(sqrt(x)) - 2*exp(-x)/sqrt(x)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Lower_incomplete_gamma_function
+    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
+           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
+           and Mathematical Tables
+    .. [3] https://dlmf.nist.gov/8
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
+    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/
+
+    """
+
+
+    def fdiff(self, argindex=2):
+        from sympy.functions.special.hyper import meijerg
+        if argindex == 2:
+            a, z = self.args
+            return exp(-unpolarify(z))*z**(a - 1)
+        elif argindex == 1:
+            a, z = self.args
+            return gamma(a)*digamma(a) - log(z)*uppergamma(a, z) \
+                - meijerg([], [1, 1], [0, 0, a], [], z)
+
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, x):
+        # For lack of a better place, we use this one to extract branching
+        # information. The following can be
+        # found in the literature (c/f references given above), albeit scattered:
+        # 1) For fixed x != 0, lowergamma(s, x) is an entire function of s
+        # 2) For fixed positive integers s, lowergamma(s, x) is an entire
+        #    function of x.
+        # 3) For fixed non-positive integers s,
+        #    lowergamma(s, exp(I*2*pi*n)*x) =
+        #              2*pi*I*n*(-1)**(-s)/factorial(-s) + lowergamma(s, x)
+        #    (this follows from lowergamma(s, x).diff(x) = x**(s-1)*exp(-x)).
+        # 4) For fixed non-integral s,
+        #    lowergamma(s, x) = x**s*gamma(s)*lowergamma_unbranched(s, x),
+        #    where lowergamma_unbranched(s, x) is an entire function (in fact
+        #    of both s and x), i.e.
+        #    lowergamma(s, exp(2*I*pi*n)*x) = exp(2*pi*I*n*a)*lowergamma(a, x)
+        if x is S.Zero:
+            return S.Zero
+        nx, n = x.extract_branch_factor()
+        if a.is_integer and a.is_positive:
+            nx = unpolarify(x)
+            if nx != x:
+                return lowergamma(a, nx)
+        elif a.is_integer and a.is_nonpositive:
+            if n != 0:
+                return 2*pi*I*n*S.NegativeOne**(-a)/factorial(-a) + lowergamma(a, nx)
+        elif n != 0:
+            return exp(2*pi*I*n*a)*lowergamma(a, nx)
+
+        # Special values.
+        if a.is_Number:
+            if a is S.One:
+                return S.One - exp(-x)
+            elif a is S.Half:
+                return sqrt(pi)*erf(sqrt(x))
+            elif a.is_Integer or (2*a).is_Integer:
+                b = a - 1
+                if b.is_positive:
+                    if a.is_integer:
+                        return factorial(b) - exp(-x) * factorial(b) * Add(*[x ** k / factorial(k) for k in range(a)])
+                    else:
+                        return gamma(a)*(lowergamma(S.Half, x)/sqrt(pi) - exp(-x)*Add(*[x**(k - S.Half)/gamma(S.Half + k) for k in range(1, a + S.Half)]))
+
+                if not a.is_Integer:
+                    return S.NegativeOne**(S.Half - a)*pi*erf(sqrt(x))/gamma(1 - a) + exp(-x)*Add(*[x**(k + a - 1)*gamma(a)/gamma(a + k) for k in range(1, Rational(3, 2) - a)])
+
+        if x.is_zero:
+            return S.Zero
+
+    def _eval_evalf(self, prec):
+        if all(x.is_number for x in self.args):
+            a = self.args[0]._to_mpmath(prec)
+            z = self.args[1]._to_mpmath(prec)
+            with workprec(prec):
+                res = mp.gammainc(a, 0, z)
+            return Expr._from_mpmath(res, prec)
+        else:
+            return self
+
+    def _eval_conjugate(self):
+        x = self.args[1]
+        if x not in (S.Zero, S.NegativeInfinity):
+            return self.func(self.args[0].conjugate(), x.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        # By https://en.wikipedia.org/wiki/Incomplete_gamma_function#Holomorphic_extension,
+        #    lowergamma(s, z) = z**s*gamma(s)*gammastar(s, z),
+        # where gammastar(s, z) is holomorphic for all s and z.
+        # Hence the singularities of lowergamma are z = 0  (branch
+        # point) and nonpositive integer values of s (poles of gamma(s)).
+        s, z = self.args
+        args_merom = fuzzy_and([z._eval_is_meromorphic(x, a),
+            s._eval_is_meromorphic(x, a)])
+        if not args_merom:
+            return args_merom
+        z0 = z.subs(x, a)
+        if s.is_integer:
+            return fuzzy_and([s.is_positive, z0.is_finite])
+        s0 = s.subs(x, a)
+        return fuzzy_and([s0.is_finite, z0.is_finite, fuzzy_not(z0.is_zero)])
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import O
+        s, z = self.args
+        if args0[0] is oo and not z.has(x):
+            coeff = z**s*exp(-z)
+            sum_expr = sum(z**k/rf(s, k + 1) for k in range(n - 1))
+            o = O(z**s*s**(-n))
+            return coeff*sum_expr + o
+        return super()._eval_aseries(n, args0, x, logx)
+
+    def _eval_rewrite_as_uppergamma(self, s, x, **kwargs):
+        return gamma(s) - uppergamma(s, x)
+
+    def _eval_rewrite_as_expint(self, s, x, **kwargs):
+        from sympy.functions.special.error_functions import expint
+        if s.is_integer and s.is_nonpositive:
+            return self
+        return self.rewrite(uppergamma).rewrite(expint)
+
+    def _eval_is_zero(self):
+        x = self.args[1]
+        if x.is_zero:
+            return True
+
+
+class uppergamma(DefinedFunction):
+    r"""
+    The upper incomplete gamma function.
+
+    Explanation
+    ===========
+
+    It can be defined as the meromorphic continuation of
+
+    .. math::
+        \Gamma(s, x) := \int_x^\infty t^{s-1} e^{-t} \mathrm{d}t = \Gamma(s) - \gamma(s, x).
+
+    where $\gamma(s, x)$ is the lower incomplete gamma function,
+    :class:`lowergamma`. This can be shown to be the same as
+
+    .. math::
+        \Gamma(s, x) = \Gamma(s) - \frac{x^s}{s} {}_1F_1\left({s \atop s+1} \middle| -x\right),
+
+    where ${}_1F_1$ is the (confluent) hypergeometric function.
+
+    The upper incomplete gamma function is also essentially equivalent to the
+    generalized exponential integral:
+
+    .. math::
+        \operatorname{E}_{n}(x) = \int_{1}^{\infty}{\frac{e^{-xt}}{t^n} \, dt} = x^{n-1}\Gamma(1-n,x).
+
+    Examples
+    ========
+
+    >>> from sympy import uppergamma, S
+    >>> from sympy.abc import s, x
+    >>> uppergamma(s, x)
+    uppergamma(s, x)
+    >>> uppergamma(3, x)
+    2*(x**2/2 + x + 1)*exp(-x)
+    >>> uppergamma(-S(1)/2, x)
+    -2*sqrt(pi)*erfc(sqrt(x)) + 2*exp(-x)/sqrt(x)
+    >>> uppergamma(-2, x)
+    expint(3, x)/x**2
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Incomplete_gamma_function#Upper_incomplete_gamma_function
+    .. [2] Abramowitz, Milton; Stegun, Irene A., eds. (1965), Chapter 6,
+           Section 5, Handbook of Mathematical Functions with Formulas, Graphs,
+           and Mathematical Tables
+    .. [3] https://dlmf.nist.gov/8
+    .. [4] https://functions.wolfram.com/GammaBetaErf/Gamma2/
+    .. [5] https://functions.wolfram.com/GammaBetaErf/Gamma3/
+    .. [6] https://en.wikipedia.org/wiki/Exponential_integral#Relation_with_other_functions
+
+    """
+
+
+    def fdiff(self, argindex=2):
+        from sympy.functions.special.hyper import meijerg
+        if argindex == 2:
+            a, z = self.args
+            return -exp(-unpolarify(z))*z**(a - 1)
+        elif argindex == 1:
+            a, z = self.args
+            return uppergamma(a, z)*log(z) + meijerg([], [1, 1], [0, 0, a], [], z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_evalf(self, prec):
+        if all(x.is_number for x in self.args):
+            a = self.args[0]._to_mpmath(prec)
+            z = self.args[1]._to_mpmath(prec)
+            with workprec(prec):
+                res = mp.gammainc(a, z, mp.inf)
+            return Expr._from_mpmath(res, prec)
+        return self
+
+    @classmethod
+    def eval(cls, a, z):
+        from sympy.functions.special.error_functions import expint
+        if z.is_Number:
+            if z is S.NaN:
+                return S.NaN
+            elif z is oo:
+                return S.Zero
+            elif z.is_zero:
+                if re(a).is_positive:
+                    return gamma(a)
+
+        # We extract branching information here. C/f lowergamma.
+        nx, n = z.extract_branch_factor()
+        if a.is_integer and a.is_positive:
+            nx = unpolarify(z)
+            if z != nx:
+                return uppergamma(a, nx)
+        elif a.is_integer and a.is_nonpositive:
+            if n != 0:
+                return -2*pi*I*n*S.NegativeOne**(-a)/factorial(-a) + uppergamma(a, nx)
+        elif n != 0:
+            return gamma(a)*(1 - exp(2*pi*I*n*a)) + exp(2*pi*I*n*a)*uppergamma(a, nx)
+
+        # Special values.
+        if a.is_Number:
+            if a is S.Zero and z.is_positive:
+                return -Ei(-z)
+            elif a is S.One:
+                return exp(-z)
+            elif a is S.Half:
+                return sqrt(pi)*erfc(sqrt(z))
+            elif a.is_Integer or (2*a).is_Integer:
+                b = a - 1
+                if b.is_positive:
+                    if a.is_integer:
+                        return exp(-z) * factorial(b) * Add(*[z**k / factorial(k)
+                                                              for k in range(a)])
+                    else:
+                        return (gamma(a) * erfc(sqrt(z)) +
+                                S.NegativeOne**(a - S(3)/2) * exp(-z) * sqrt(z)
+                                * Add(*[gamma(-S.Half - k) * (-z)**k / gamma(1-a)
+                                        for k in range(a - S.Half)]))
+                elif b.is_Integer:
+                    return expint(-b, z)*unpolarify(z)**(b + 1)
+
+                if not a.is_Integer:
+                    return (S.NegativeOne**(S.Half - a) * pi*erfc(sqrt(z))/gamma(1-a)
+                            - z**a * exp(-z) * Add(*[z**k * gamma(a) / gamma(a+k+1)
+                                                     for k in range(S.Half - a)]))
+
+        if a.is_zero and z.is_positive:
+            return -Ei(-z)
+
+        if z.is_zero and re(a).is_positive:
+            return gamma(a)
+
+    def _eval_conjugate(self):
+        z = self.args[1]
+        if z not in (S.Zero, S.NegativeInfinity):
+            return self.func(self.args[0].conjugate(), z.conjugate())
+
+    def _eval_is_meromorphic(self, x, a):
+        return lowergamma._eval_is_meromorphic(self, x, a)
+
+    def _eval_rewrite_as_lowergamma(self, s, x, **kwargs):
+        return gamma(s) - lowergamma(s, x)
+
+    def _eval_rewrite_as_tractable(self, s, x, **kwargs):
+        return exp(loggamma(s)) - lowergamma(s, x)
+
+    def _eval_rewrite_as_expint(self, s, x, **kwargs):
+        from sympy.functions.special.error_functions import expint
+        return expint(1 - s, x)*x**s
+
+
+###############################################################################
+###################### POLYGAMMA and LOGGAMMA FUNCTIONS #######################
+###############################################################################
+
+class polygamma(DefinedFunction):
+    r"""
+    The function ``polygamma(n, z)`` returns ``log(gamma(z)).diff(n + 1)``.
+
+    Explanation
+    ===========
+
+    It is a meromorphic function on $\mathbb{C}$ and defined as the $(n+1)$-th
+    derivative of the logarithm of the gamma function:
+
+    .. math::
+        \psi^{(n)} (z) := \frac{\mathrm{d}^{n+1}}{\mathrm{d} z^{n+1}} \log\Gamma(z).
+
+    For `n` not a nonnegative integer the generalization by Espinosa and Moll [5]_
+    is used:
+
+    .. math:: \psi(s,z) = \frac{\zeta'(s+1, z) + (\gamma + \psi(-s)) \zeta(s+1, z)}
+        {\Gamma(-s)}
+
+    Examples
+    ========
+
+    Several special values are known:
+
+    >>> from sympy import S, polygamma
+    >>> polygamma(0, 1)
+    -EulerGamma
+    >>> polygamma(0, 1/S(2))
+    -2*log(2) - EulerGamma
+    >>> polygamma(0, 1/S(3))
+    -log(3) - sqrt(3)*pi/6 - EulerGamma - log(sqrt(3))
+    >>> polygamma(0, 1/S(4))
+    -pi/2 - log(4) - log(2) - EulerGamma
+    >>> polygamma(0, 2)
+    1 - EulerGamma
+    >>> polygamma(0, 23)
+    19093197/5173168 - EulerGamma
+
+    >>> from sympy import oo, I
+    >>> polygamma(0, oo)
+    oo
+    >>> polygamma(0, -oo)
+    oo
+    >>> polygamma(0, I*oo)
+    oo
+    >>> polygamma(0, -I*oo)
+    oo
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import Symbol, diff
+    >>> x = Symbol("x")
+    >>> diff(polygamma(0, x), x)
+    polygamma(1, x)
+    >>> diff(polygamma(0, x), x, 2)
+    polygamma(2, x)
+    >>> diff(polygamma(0, x), x, 3)
+    polygamma(3, x)
+    >>> diff(polygamma(1, x), x)
+    polygamma(2, x)
+    >>> diff(polygamma(1, x), x, 2)
+    polygamma(3, x)
+    >>> diff(polygamma(2, x), x)
+    polygamma(3, x)
+    >>> diff(polygamma(2, x), x, 2)
+    polygamma(4, x)
+
+    >>> n = Symbol("n")
+    >>> diff(polygamma(n, x), x)
+    polygamma(n + 1, x)
+    >>> diff(polygamma(n, x), x, 2)
+    polygamma(n + 2, x)
+
+    We can rewrite ``polygamma`` functions in terms of harmonic numbers:
+
+    >>> from sympy import harmonic
+    >>> polygamma(0, x).rewrite(harmonic)
+    harmonic(x - 1) - EulerGamma
+    >>> polygamma(2, x).rewrite(harmonic)
+    2*harmonic(x - 1, 3) - 2*zeta(3)
+    >>> ni = Symbol("n", integer=True)
+    >>> polygamma(ni, x).rewrite(harmonic)
+    (-1)**(n + 1)*(-harmonic(x - 1, n + 1) + zeta(n + 1))*factorial(n)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Polygamma_function
+    .. [2] https://mathworld.wolfram.com/PolygammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma/
+    .. [4] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+    .. [5] O. Espinosa and V. Moll, "A generalized polygamma function",
+           *Integral Transforms and Special Functions* (2004), 101-115.
+
+    """
+
+    @classmethod
+    def eval(cls, n, z):
+        if n is S.NaN or z is S.NaN:
+            return S.NaN
+        elif z is oo:
+            return oo if n.is_zero else S.Zero
+        elif z.is_Integer and z.is_nonpositive:
+            return S.ComplexInfinity
+        elif n is S.NegativeOne:
+            return loggamma(z) - log(2*pi) / 2
+        elif n.is_zero:
+            if z is -oo or z.extract_multiplicatively(I) in (oo, -oo):
+                return oo
+            elif z.is_Integer:
+                return harmonic(z-1) - S.EulerGamma
+            elif z.is_Rational:
+                # TODO n == 1 also can do some rational z
+                p, q = z.as_numer_denom()
+                # only expand for small denominators to avoid creating long expressions
+                if q <= 6:
+                    return expand_func(polygamma(S.Zero, z, evaluate=False))
+        elif n.is_integer and n.is_nonnegative:
+            nz = unpolarify(z)
+            if z != nz:
+                return polygamma(n, nz)
+            if z.is_Integer:
+                return S.NegativeOne**(n+1) * factorial(n) * zeta(n+1, z)
+            elif z is S.Half:
+                return S.NegativeOne**(n+1) * factorial(n) * (2**(n+1)-1) * zeta(n+1)
+
+    def _eval_is_real(self):
+        if self.args[0].is_positive and self.args[1].is_positive:
+            return True
+
+    def _eval_is_complex(self):
+        z = self.args[1]
+        is_negative_integer = fuzzy_and([z.is_negative, z.is_integer])
+        return fuzzy_and([z.is_complex, fuzzy_not(is_negative_integer)])
+
+    def _eval_is_positive(self):
+        n, z = self.args
+        if n.is_positive:
+            if n.is_odd and z.is_real:
+                return True
+            if n.is_even and z.is_positive:
+                return False
+
+    def _eval_is_negative(self):
+        n, z = self.args
+        if n.is_positive:
+            if n.is_even and z.is_positive:
+                return True
+            if n.is_odd and z.is_real:
+                return False
+
+    def _eval_expand_func(self, **hints):
+        n, z = self.args
+
+        if n.is_Integer and n.is_nonnegative:
+            if z.is_Add:
+                coeff = z.args[0]
+                if coeff.is_Integer:
+                    e = -(n + 1)
+                    if coeff > 0:
+                        tail = Add(*[Pow(
+                            z - i, e) for i in range(1, int(coeff) + 1)])
+                    else:
+                        tail = -Add(*[Pow(
+                            z + i, e) for i in range(int(-coeff))])
+                    return polygamma(n, z - coeff) + S.NegativeOne**n*factorial(n)*tail
+
+            elif z.is_Mul:
+                coeff, z = z.as_two_terms()
+                if coeff.is_Integer and coeff.is_positive:
+                    tail = [polygamma(n, z + Rational(
+                        i, coeff)) for i in range(int(coeff))]
+                    if n == 0:
+                        return Add(*tail)/coeff + log(coeff)
+                    else:
+                        return Add(*tail)/coeff**(n + 1)
+                z *= coeff
+
+        if n == 0 and z.is_Rational:
+            p, q = z.as_numer_denom()
+
+            # Reference:
+            #   Values of the polygamma functions at rational arguments, J. Choi, 2007
+            part_1 = -S.EulerGamma - pi * cot(p * pi / q) / 2 - log(q) + Add(
+                *[cos(2 * k * pi * p / q) * log(2 * sin(k * pi / q)) for k in range(1, q)])
+
+            if z > 0:
+                n = floor(z)
+                z0 = z - n
+                return part_1 + Add(*[1 / (z0 + k) for k in range(n)])
+            elif z < 0:
+                n = floor(1 - z)
+                z0 = z + n
+                return part_1 - Add(*[1 / (z0 - 1 - k) for k in range(n)])
+
+        if n == -1:
+            return loggamma(z) - log(2*pi) / 2
+        if n.is_integer is False or n.is_nonnegative is False:
+            s = Dummy("s")
+            dzt = zeta(s, z).diff(s).subs(s, n+1)
+            return (dzt + (S.EulerGamma + digamma(-n)) * zeta(n+1, z)) / gamma(-n)
+
+        return polygamma(n, z)
+
+    def _eval_rewrite_as_zeta(self, n, z, **kwargs):
+        if n.is_integer and n.is_positive:
+            return S.NegativeOne**(n + 1)*factorial(n)*zeta(n + 1, z)
+
+    def _eval_rewrite_as_harmonic(self, n, z, **kwargs):
+        if n.is_integer:
+            if n.is_zero:
+                return harmonic(z - 1) - S.EulerGamma
+            else:
+                return S.NegativeOne**(n+1) * factorial(n) * (zeta(n+1) - harmonic(z-1, n+1))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.series.order import Order
+        n, z = [a.as_leading_term(x) for a in self.args]
+        o = Order(z, x)
+        if n == 0 and o.contains(1/x):
+            logx = log(x) if logx is None else logx
+            return o.getn() * logx
+        else:
+            return self.func(n, z)
+
+    def fdiff(self, argindex=2):
+        if argindex == 2:
+            n, z = self.args[:2]
+            return polygamma(n + 1, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[1] != oo or not \
+                (self.args[0].is_Integer and self.args[0].is_nonnegative):
+            return super()._eval_aseries(n, args0, x, logx)
+        z = self.args[1]
+        N = self.args[0]
+
+        if N == 0:
+            # digamma function series
+            # Abramowitz & Stegun, p. 259, 6.3.18
+            r = log(z) - 1/(2*z)
+            o = None
+            if n < 2:
+                o = Order(1/z, x)
+            else:
+                m = ceiling((n + 1)//2)
+                l = [bernoulli(2*k) / (2*k*z**(2*k)) for k in range(1, m)]
+                r -= Add(*l)
+                o = Order(1/z**n, x)
+            return r._eval_nseries(x, n, logx) + o
+        else:
+            # proper polygamma function
+            # Abramowitz & Stegun, p. 260, 6.4.10
+            # We return terms to order higher than O(x**n) on purpose
+            # -- otherwise we would not be able to return any terms for
+            #    quite a long time!
+            fac = gamma(N)
+            e0 = fac + N*fac/(2*z)
+            m = ceiling((n + 1)//2)
+            for k in range(1, m):
+                fac = fac*(2*k + N - 1)*(2*k + N - 2) / ((2*k)*(2*k - 1))
+                e0 += bernoulli(2*k)*fac/z**(2*k)
+            o = Order(1/z**(2*m), x)
+            if n == 0:
+                o = Order(1/z, x)
+            elif n == 1:
+                o = Order(1/z**2, x)
+            r = e0._eval_nseries(z, n, logx) + o
+            return (-1 * (-1/z)**N * r)._eval_nseries(x, n, logx)
+
+    def _eval_evalf(self, prec):
+        if not all(i.is_number for i in self.args):
+            return
+        s = self.args[0]._to_mpmath(prec+12)
+        z = self.args[1]._to_mpmath(prec+12)
+        if mp.isint(z) and z <= 0:
+            return S.ComplexInfinity
+        with workprec(prec+12):
+            if mp.isint(s) and s >= 0:
+                res = mp.polygamma(s, z)
+            else:
+                zt = mp.zeta(s+1, z)
+                dzt = mp.zeta(s+1, z, 1)
+                res = (dzt + (mp.euler + mp.digamma(-s)) * zt) * mp.rgamma(-s)
+        return Expr._from_mpmath(res, prec)
+
+
+class loggamma(DefinedFunction):
+    r"""
+    The ``loggamma`` function implements the logarithm of the
+    gamma function (i.e., $\log\Gamma(x)$).
+
+    Examples
+    ========
+
+    Several special values are known. For numerical integral
+    arguments we have:
+
+    >>> from sympy import loggamma
+    >>> loggamma(-2)
+    oo
+    >>> loggamma(0)
+    oo
+    >>> loggamma(1)
+    0
+    >>> loggamma(2)
+    0
+    >>> loggamma(3)
+    log(2)
+
+    And for symbolic values:
+
+    >>> from sympy import Symbol
+    >>> n = Symbol("n", integer=True, positive=True)
+    >>> loggamma(n)
+    log(gamma(n))
+    >>> loggamma(-n)
+    oo
+
+    For half-integral values:
+
+    >>> from sympy import S
+    >>> loggamma(S(5)/2)
+    log(3*sqrt(pi)/4)
+    >>> loggamma(n/2)
+    log(2**(1 - n)*sqrt(pi)*gamma(n)/gamma(n/2 + 1/2))
+
+    And general rational arguments:
+
+    >>> from sympy import expand_func
+    >>> L = loggamma(S(16)/3)
+    >>> expand_func(L).doit()
+    -5*log(3) + loggamma(1/3) + log(4) + log(7) + log(10) + log(13)
+    >>> L = loggamma(S(19)/4)
+    >>> expand_func(L).doit()
+    -4*log(4) + loggamma(3/4) + log(3) + log(7) + log(11) + log(15)
+    >>> L = loggamma(S(23)/7)
+    >>> expand_func(L).doit()
+    -3*log(7) + log(2) + loggamma(2/7) + log(9) + log(16)
+
+    The ``loggamma`` function has the following limits towards infinity:
+
+    >>> from sympy import oo
+    >>> loggamma(oo)
+    oo
+    >>> loggamma(-oo)
+    zoo
+
+    The ``loggamma`` function obeys the mirror symmetry
+    if $x \in \mathbb{C} \setminus \{-\infty, 0\}$:
+
+    >>> from sympy.abc import x
+    >>> from sympy import conjugate
+    >>> conjugate(loggamma(x))
+    loggamma(conjugate(x))
+
+    Differentiation with respect to $x$ is supported:
+
+    >>> from sympy import diff
+    >>> diff(loggamma(x), x)
+    polygamma(0, x)
+
+    Series expansion is also supported:
+
+    >>> from sympy import series
+    >>> series(loggamma(x), x, 0, 4).cancel()
+    -log(x) - EulerGamma*x + pi**2*x**2/12 - x**3*zeta(3)/3 + O(x**4)
+
+    We can numerically evaluate the ``loggamma`` function
+    to arbitrary precision on the whole complex plane:
+
+    >>> from sympy import I
+    >>> loggamma(5).evalf(30)
+    3.17805383034794561964694160130
+    >>> loggamma(I).evalf(20)
+    -0.65092319930185633889 - 1.8724366472624298171*I
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    digamma: Digamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gamma_function
+    .. [2] https://dlmf.nist.gov/5
+    .. [3] https://mathworld.wolfram.com/LogGammaFunction.html
+    .. [4] https://functions.wolfram.com/GammaBetaErf/LogGamma/
+
+    """
+    @classmethod
+    def eval(cls, z):
+        if z.is_integer:
+            if z.is_nonpositive:
+                return oo
+            elif z.is_positive:
+                return log(gamma(z))
+        elif z.is_rational:
+            p, q = z.as_numer_denom()
+            # Half-integral values:
+            if p.is_positive and q == 2:
+                return log(sqrt(pi) * 2**(1 - p) * gamma(p) / gamma((p + 1)*S.Half))
+
+        if z is oo:
+            return oo
+        elif abs(z) is oo:
+            return S.ComplexInfinity
+        if z is S.NaN:
+            return S.NaN
+
+    def _eval_expand_func(self, **hints):
+        from sympy.concrete.summations import Sum
+        z = self.args[0]
+
+        if z.is_Rational:
+            p, q = z.as_numer_denom()
+            # General rational arguments (u + p/q)
+            # Split z as n + p/q with p < q
+            n = p // q
+            p = p - n*q
+            if p.is_positive and q.is_positive and p < q:
+                k = Dummy("k")
+                if n.is_positive:
+                    return loggamma(p / q) - n*log(q) + Sum(log((k - 1)*q + p), (k, 1, n))
+                elif n.is_negative:
+                    return loggamma(p / q) - n*log(q) + pi*I*n - Sum(log(k*q - p), (k, 1, -n))
+                elif n.is_zero:
+                    return loggamma(p / q)
+
+        return self
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        x0 = self.args[0].limit(x, 0)
+        if x0.is_zero:
+            f = self._eval_rewrite_as_intractable(*self.args)
+            return f._eval_nseries(x, n, logx)
+        return super()._eval_nseries(x, n, logx)
+
+    def _eval_aseries(self, n, args0, x, logx):
+        from sympy.series.order import Order
+        if args0[0] != oo:
+            return super()._eval_aseries(n, args0, x, logx)
+        z = self.args[0]
+        r = log(z)*(z - S.Half) - z + log(2*pi)/2
+        l = [bernoulli(2*k) / (2*k*(2*k - 1)*z**(2*k - 1)) for k in range(1, n)]
+        o = None
+        if n == 0:
+            o = Order(1, x)
+        else:
+            o = Order(1/z**n, x)
+        # It is very inefficient to first add the order and then do the nseries
+        return (r + Add(*l))._eval_nseries(x, n, logx) + o
+
+    def _eval_rewrite_as_intractable(self, z, **kwargs):
+        return log(gamma(z))
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        if z.is_positive:
+            return True
+        elif z.is_nonpositive:
+            return False
+
+    def _eval_conjugate(self):
+        z = self.args[0]
+        if z not in (S.Zero, S.NegativeInfinity):
+            return self.func(z.conjugate())
+
+    def fdiff(self, argindex=1):
+        if argindex == 1:
+            return polygamma(0, self.args[0])
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+
+class digamma(DefinedFunction):
+    r"""
+    The ``digamma`` function is the first derivative of the ``loggamma``
+    function
+
+    .. math::
+        \psi(x) := \frac{\mathrm{d}}{\mathrm{d} z} \log\Gamma(z)
+                = \frac{\Gamma'(z)}{\Gamma(z) }.
+
+    In this case, ``digamma(z) = polygamma(0, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import digamma
+    >>> digamma(0)
+    zoo
+    >>> from sympy import Symbol
+    >>> z = Symbol('z')
+    >>> digamma(z)
+    polygamma(0, z)
+
+    To retain ``digamma`` as it is:
+
+    >>> digamma(0, evaluate=False)
+    digamma(0)
+    >>> digamma(z, evaluate=False)
+    digamma(z)
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    trigamma: Trigamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Digamma_function
+    .. [2] https://mathworld.wolfram.com/DigammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+
+    """
+    def _eval_evalf(self, prec):
+        z = self.args[0]
+        nprec = prec_to_dps(prec)
+        return polygamma(0, z).evalf(n=nprec)
+
+    def fdiff(self, argindex=1):
+        z = self.args[0]
+        return polygamma(0, z).fdiff()
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        return polygamma(0, z).is_real
+
+    def _eval_is_positive(self):
+        z = self.args[0]
+        return polygamma(0, z).is_positive
+
+    def _eval_is_negative(self):
+        z = self.args[0]
+        return polygamma(0, z).is_negative
+
+    def _eval_aseries(self, n, args0, x, logx):
+        as_polygamma = self.rewrite(polygamma)
+        args0 = [S.Zero,] + args0
+        return as_polygamma._eval_aseries(n, args0, x, logx)
+
+    @classmethod
+    def eval(cls, z):
+        return polygamma(0, z)
+
+    def _eval_expand_func(self, **hints):
+        z = self.args[0]
+        return polygamma(0, z).expand(func=True)
+
+    def _eval_rewrite_as_harmonic(self, z, **kwargs):
+        return harmonic(z - 1) - S.EulerGamma
+
+    def _eval_rewrite_as_polygamma(self, z, **kwargs):
+        return polygamma(0, z)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z = self.args[0]
+        return polygamma(0, z).as_leading_term(x)
+
+
+
+class trigamma(DefinedFunction):
+    r"""
+    The ``trigamma`` function is the second derivative of the ``loggamma``
+    function
+
+    .. math::
+        \psi^{(1)}(z) := \frac{\mathrm{d}^{2}}{\mathrm{d} z^{2}} \log\Gamma(z).
+
+    In this case, ``trigamma(z) = polygamma(1, z)``.
+
+    Examples
+    ========
+
+    >>> from sympy import trigamma
+    >>> trigamma(0)
+    zoo
+    >>> from sympy import Symbol
+    >>> z = Symbol('z')
+    >>> trigamma(z)
+    polygamma(1, z)
+
+    To retain ``trigamma`` as it is:
+
+    >>> trigamma(0, evaluate=False)
+    trigamma(0)
+    >>> trigamma(z, evaluate=False)
+    trigamma(z)
+
+
+    See Also
+    ========
+
+    gamma: Gamma function.
+    lowergamma: Lower incomplete gamma function.
+    uppergamma: Upper incomplete gamma function.
+    polygamma: Polygamma function.
+    loggamma: Log Gamma function.
+    digamma: Digamma function.
+    sympy.functions.special.beta_functions.beta: Euler Beta function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Trigamma_function
+    .. [2] https://mathworld.wolfram.com/TrigammaFunction.html
+    .. [3] https://functions.wolfram.com/GammaBetaErf/PolyGamma2/
+
+    """
+    def _eval_evalf(self, prec):
+        z = self.args[0]
+        nprec = prec_to_dps(prec)
+        return polygamma(1, z).evalf(n=nprec)
+
+    def fdiff(self, argindex=1):
+        z = self.args[0]
+        return polygamma(1, z).fdiff()
+
+    def _eval_is_real(self):
+        z = self.args[0]
+        return polygamma(1, z).is_real
+
+    def _eval_is_positive(self):
+        z = self.args[0]
+        return polygamma(1, z).is_positive
+
+    def _eval_is_negative(self):
+        z = self.args[0]
+        return polygamma(1, z).is_negative
+
+    def _eval_aseries(self, n, args0, x, logx):
+        as_polygamma = self.rewrite(polygamma)
+        args0 = [S.One,] + args0
+        return as_polygamma._eval_aseries(n, args0, x, logx)
+
+    @classmethod
+    def eval(cls, z):
+        return polygamma(1, z)
+
+    def _eval_expand_func(self, **hints):
+        z = self.args[0]
+        return polygamma(1, z).expand(func=True)
+
+    def _eval_rewrite_as_zeta(self, z, **kwargs):
+        return zeta(2, z)
+
+    def _eval_rewrite_as_polygamma(self, z, **kwargs):
+        return polygamma(1, z)
+
+    def _eval_rewrite_as_harmonic(self, z, **kwargs):
+        return -harmonic(z - 1, 2) + pi**2 / 6
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z = self.args[0]
+        return polygamma(1, z).as_leading_term(x)
+
+
+###############################################################################
+##################### COMPLETE MULTIVARIATE GAMMA FUNCTION ####################
+###############################################################################
+
+
+class multigamma(DefinedFunction):
+    r"""
+    The multivariate gamma function is a generalization of the gamma function
+
+    .. math::
+        \Gamma_p(z) = \pi^{p(p-1)/4}\prod_{k=1}^p \Gamma[z + (1 - k)/2].
+
+    In a special case, ``multigamma(x, 1) = gamma(x)``.
+
+    Examples
+    ========
+
+    >>> from sympy import S, multigamma
+    >>> from sympy import Symbol
+    >>> x = Symbol('x')
+    >>> p = Symbol('p', positive=True, integer=True)
+
+    >>> multigamma(x, p)
+    pi**(p*(p - 1)/4)*Product(gamma(-_k/2 + x + 1/2), (_k, 1, p))
+
+    Several special values are known:
+
+    >>> multigamma(1, 1)
+    1
+    >>> multigamma(4, 1)
+    6
+    >>> multigamma(S(3)/2, 1)
+    sqrt(pi)/2
+
+    Writing ``multigamma`` in terms of the ``gamma`` function:
+
+    >>> multigamma(x, 1)
+    gamma(x)
+
+    >>> multigamma(x, 2)
+    sqrt(pi)*gamma(x)*gamma(x - 1/2)
+
+    >>> multigamma(x, 3)
+    pi**(3/2)*gamma(x)*gamma(x - 1)*gamma(x - 1/2)
+
+    Parameters
+    ==========
+
+    p : order or dimension of the multivariate gamma function
+
+    See Also
+    ========
+
+    gamma, lowergamma, uppergamma, polygamma, loggamma, digamma, trigamma,
+    sympy.functions.special.beta_functions.beta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Multivariate_gamma_function
+
+    """
+    unbranched = True
+
+    def fdiff(self, argindex=2):
+        from sympy.concrete.summations import Sum
+        if argindex == 2:
+            x, p = self.args
+            k = Dummy("k")
+            return self.func(x, p)*Sum(polygamma(0, x + (1 - k)/2), (k, 1, p))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, x, p):
+        from sympy.concrete.products import Product
+        if p.is_positive is False or p.is_integer is False:
+            raise ValueError('Order parameter p must be positive integer.')
+        k = Dummy("k")
+        return (pi**(p*(p - 1)/4)*Product(gamma(x + (1 - k)/2),
+                                          (k, 1, p))).doit()
+
+    def _eval_conjugate(self):
+        x, p = self.args
+        return self.func(x.conjugate(), p)
+
+    def _eval_is_real(self):
+        x, p = self.args
+        y = 2*x
+        if y.is_integer and (y <= (p - 1)) is True:
+            return False
+        if intlike(y) and (y <= (p - 1)):
+            return False
+        if y > (p - 1) or y.is_noninteger:
+            return True
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/hyper.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/hyper.py
new file mode 100644
index 0000000000000000000000000000000000000000..3943e140821222a510c609a071b5dbbf08883745
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/hyper.py
@@ -0,0 +1,1185 @@
+"""Hypergeometric and Meijer G-functions"""
+from collections import Counter
+
+from sympy.core import S, Mod
+from sympy.core.add import Add
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, Derivative, ArgumentIndexError
+
+from sympy.core.containers import Tuple
+from sympy.core.mul import Mul
+from sympy.core.numbers import I, pi, oo, zoo
+from sympy.core.parameters import global_parameters
+from sympy.core.relational import Ne
+from sympy.core.sorting import default_sort_key
+from sympy.core.symbol import Dummy
+
+from sympy.external.gmpy import lcm
+from sympy.functions import (sqrt, exp, log, sin, cos, asin, atan,
+        sinh, cosh, asinh, acosh, atanh, acoth)
+from sympy.functions import factorial, RisingFactorial
+from sympy.functions.elementary.complexes import Abs, re, unpolarify
+from sympy.functions.elementary.exponential import exp_polar
+from sympy.functions.elementary.integers import ceiling
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import (And, Or)
+from sympy import ordered
+
+
+class TupleArg(Tuple):
+
+    # This method is only needed because hyper._eval_as_leading_term falls back
+    # (via super()) on using Function._eval_as_leading_term, which in turn
+    # calls as_leading_term on the args of the hyper. Ideally hyper should just
+    # have an _eval_as_leading_term method that handles all cases and this
+    # method should be removed because leading terms of tuples don't make
+    # sense.
+    def as_leading_term(self, *x, logx=None, cdir=0):
+        return TupleArg(*[f.as_leading_term(*x, logx=logx, cdir=cdir) for f in self.args])
+
+    def limit(self, x, xlim, dir='+'):
+        """ Compute limit x->xlim.
+        """
+        from sympy.series.limits import limit
+        return TupleArg(*[limit(f, x, xlim, dir) for f in self.args])
+
+
+# TODO should __new__ accept **options?
+# TODO should constructors should check if parameters are sensible?
+
+
+def _prep_tuple(v):
+    """
+    Turn an iterable argument *v* into a tuple and unpolarify, since both
+    hypergeometric and meijer g-functions are unbranched in their parameters.
+
+    Examples
+    ========
+
+    >>> from sympy.functions.special.hyper import _prep_tuple
+    >>> _prep_tuple([1, 2, 3])
+    (1, 2, 3)
+    >>> _prep_tuple((4, 5))
+    (4, 5)
+    >>> _prep_tuple((7, 8, 9))
+    (7, 8, 9)
+
+    """
+    return TupleArg(*[unpolarify(x) for x in v])
+
+
+class TupleParametersBase(DefinedFunction):
+    """ Base class that takes care of differentiation, when some of
+        the arguments are actually tuples. """
+    # This is not deduced automatically since there are Tuples as arguments.
+    is_commutative = True
+
+    def _eval_derivative(self, s):
+        try:
+            res = 0
+            if self.args[0].has(s) or self.args[1].has(s):
+                for i, p in enumerate(self._diffargs):
+                    m = self._diffargs[i].diff(s)
+                    if m != 0:
+                        res += self.fdiff((1, i))*m
+            return res + self.fdiff(3)*self.args[2].diff(s)
+        except (ArgumentIndexError, NotImplementedError):
+            return Derivative(self, s)
+
+
+class hyper(TupleParametersBase):
+    r"""
+    The generalized hypergeometric function is defined by a series where
+    the ratios of successive terms are a rational function of the summation
+    index. When convergent, it is continued analytically to the largest
+    possible domain.
+
+    Explanation
+    ===========
+
+    The hypergeometric function depends on two vectors of parameters, called
+    the numerator parameters $a_p$, and the denominator parameters
+    $b_q$. It also has an argument $z$. The series definition is
+
+    .. math ::
+        {}_pF_q\left(\begin{matrix} a_1, \cdots, a_p \\ b_1, \cdots, b_q \end{matrix}
+                     \middle| z \right)
+        = \sum_{n=0}^\infty \frac{(a_1)_n \cdots (a_p)_n}{(b_1)_n \cdots (b_q)_n}
+                            \frac{z^n}{n!},
+
+    where $(a)_n = (a)(a+1)\cdots(a+n-1)$ denotes the rising factorial.
+
+    If one of the $b_q$ is a non-positive integer then the series is
+    undefined unless one of the $a_p$ is a larger (i.e., smaller in
+    magnitude) non-positive integer. If none of the $b_q$ is a
+    non-positive integer and one of the $a_p$ is a non-positive
+    integer, then the series reduces to a polynomial. To simplify the
+    following discussion, we assume that none of the $a_p$ or
+    $b_q$ is a non-positive integer. For more details, see the
+    references.
+
+    The series converges for all $z$ if $p \le q$, and thus
+    defines an entire single-valued function in this case. If $p =
+    q+1$ the series converges for $|z| < 1$, and can be continued
+    analytically into a half-plane. If $p > q+1$ the series is
+    divergent for all $z$.
+
+    Please note the hypergeometric function constructor currently does *not*
+    check if the parameters actually yield a well-defined function.
+
+    Examples
+    ========
+
+    The parameters $a_p$ and $b_q$ can be passed as arbitrary
+    iterables, for example:
+
+    >>> from sympy import hyper
+    >>> from sympy.abc import x, n, a
+    >>> h = hyper((1, 2, 3), [3, 4], x); h
+    hyper((1, 2), (4,), x)
+    >>> hyper((3, 1, 2), [3, 4], x, evaluate=False)  # don't remove duplicates
+    hyper((1, 2, 3), (3, 4), x)
+
+    There is also pretty printing (it looks better using Unicode):
+
+    >>> from sympy import pprint
+    >>> pprint(h, use_unicode=False)
+      _
+     |_  /1, 2 |  \
+     |   |     | x|
+    2  1 \  4  |  /
+
+    The parameters must always be iterables, even if they are vectors of
+    length one or zero:
+
+    >>> hyper((1, ), [], x)
+    hyper((1,), (), x)
+
+    But of course they may be variables (but if they depend on $x$ then you
+    should not expect much implemented functionality):
+
+    >>> hyper((n, a), (n**2,), x)
+    hyper((a, n), (n**2,), x)
+
+    The hypergeometric function generalizes many named special functions.
+    The function ``hyperexpand()`` tries to express a hypergeometric function
+    using named special functions. For example:
+
+    >>> from sympy import hyperexpand
+    >>> hyperexpand(hyper([], [], x))
+    exp(x)
+
+    You can also use ``expand_func()``:
+
+    >>> from sympy import expand_func
+    >>> expand_func(x*hyper([1, 1], [2], -x))
+    log(x + 1)
+
+    More examples:
+
+    >>> from sympy import S
+    >>> hyperexpand(hyper([], [S(1)/2], -x**2/4))
+    cos(x)
+    >>> hyperexpand(x*hyper([S(1)/2, S(1)/2], [S(3)/2], x**2))
+    asin(x)
+
+    We can also sometimes ``hyperexpand()`` parametric functions:
+
+    >>> from sympy.abc import a
+    >>> hyperexpand(hyper([-a], [], x))
+    (1 - x)**a
+
+    See Also
+    ========
+
+    sympy.simplify.hyperexpand
+    gamma
+    meijerg
+
+    References
+    ==========
+
+    .. [1] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+           Volume 1
+    .. [2] https://en.wikipedia.org/wiki/Generalized_hypergeometric_function
+
+    """
+
+
+    def __new__(cls, ap, bq, z, **kwargs):
+        # TODO should we check convergence conditions?
+        if kwargs.pop('evaluate', global_parameters.evaluate):
+            ca = Counter(Tuple(*ap))
+            cb = Counter(Tuple(*bq))
+            common = ca & cb
+            arg = ap, bq = [], []
+            for i, c in enumerate((ca, cb)):
+                c -= common
+                for k in ordered(c):
+                    arg[i].extend([k]*c[k])
+        else:
+            ap = list(ordered(ap))
+            bq = list(ordered(bq))
+        return super().__new__(cls, _prep_tuple(ap), _prep_tuple(bq), z, **kwargs)
+
+    @classmethod
+    def eval(cls, ap, bq, z):
+        if len(ap) <= len(bq) or (len(ap) == len(bq) + 1 and (Abs(z) <= 1) == True):
+            nz = unpolarify(z)
+            if z != nz:
+                return hyper(ap, bq, nz)
+
+    def fdiff(self, argindex=3):
+        if argindex != 3:
+            raise ArgumentIndexError(self, argindex)
+        nap = Tuple(*[a + 1 for a in self.ap])
+        nbq = Tuple(*[b + 1 for b in self.bq])
+        fac = Mul(*self.ap)/Mul(*self.bq)
+        return fac*hyper(nap, nbq, self.argument)
+
+    def _eval_expand_func(self, **hints):
+        from sympy.functions.special.gamma_functions import gamma
+        from sympy.simplify.hyperexpand import hyperexpand
+        if len(self.ap) == 2 and len(self.bq) == 1 and self.argument == 1:
+            a, b = self.ap
+            c = self.bq[0]
+            return gamma(c)*gamma(c - a - b)/gamma(c - a)/gamma(c - b)
+        return hyperexpand(self)
+
+    def _eval_rewrite_as_Sum(self, ap, bq, z, **kwargs):
+        from sympy.concrete.summations import Sum
+        n = Dummy("n", integer=True)
+        rfap = [RisingFactorial(a, n) for a in ap]
+        rfbq = [RisingFactorial(b, n) for b in bq]
+        coeff = Mul(*rfap) / Mul(*rfbq)
+        return Piecewise((Sum(coeff * z**n / factorial(n), (n, 0, oo)),
+                         self.convergence_statement), (self, True))
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        arg = self.args[2]
+        x0 = arg.subs(x, 0)
+        if x0 is S.NaN:
+            x0 = arg.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+
+        if x0 is S.Zero:
+            return S.One
+        return super()._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+
+        from sympy.series.order import Order
+
+        arg = self.args[2]
+        x0 = arg.limit(x, 0)
+        ap = self.args[0]
+        bq = self.args[1]
+
+        if not (arg == x and x0 == 0):
+            # It would be better to do something with arg.nseries here, rather
+            # than falling back on Function._eval_nseries. The code below
+            # though is not sufficient if arg is something like x/(x+1).
+            from sympy.simplify.hyperexpand import hyperexpand
+            return hyperexpand(super()._eval_nseries(x, n, logx))
+
+        terms = []
+
+        for i in range(n):
+            num = Mul(*[RisingFactorial(a, i) for a in ap])
+            den = Mul(*[RisingFactorial(b, i) for b in bq])
+            terms.append(((num/den) * (arg**i)) / factorial(i))
+
+        return (Add(*terms) + Order(x**n,x))
+
+    @property
+    def argument(self):
+        """ Argument of the hypergeometric function. """
+        return self.args[2]
+
+    @property
+    def ap(self):
+        """ Numerator parameters of the hypergeometric function. """
+        return Tuple(*self.args[0])
+
+    @property
+    def bq(self):
+        """ Denominator parameters of the hypergeometric function. """
+        return Tuple(*self.args[1])
+
+    @property
+    def _diffargs(self):
+        return self.ap + self.bq
+
+    @property
+    def eta(self):
+        """ A quantity related to the convergence of the series. """
+        return sum(self.ap) - sum(self.bq)
+
+    @property
+    def radius_of_convergence(self):
+        """
+        Compute the radius of convergence of the defining series.
+
+        Explanation
+        ===========
+
+        Note that even if this is not ``oo``, the function may still be
+        evaluated outside of the radius of convergence by analytic
+        continuation. But if this is zero, then the function is not actually
+        defined anywhere else.
+
+        Examples
+        ========
+
+        >>> from sympy import hyper
+        >>> from sympy.abc import z
+        >>> hyper((1, 2), [3], z).radius_of_convergence
+        1
+        >>> hyper((1, 2, 3), [4], z).radius_of_convergence
+        0
+        >>> hyper((1, 2), (3, 4), z).radius_of_convergence
+        oo
+
+        """
+        if any(a.is_integer and (a <= 0) == True for a in self.ap + self.bq):
+            aints = [a for a in self.ap if a.is_Integer and (a <= 0) == True]
+            bints = [a for a in self.bq if a.is_Integer and (a <= 0) == True]
+            if len(aints) < len(bints):
+                return S.Zero
+            popped = False
+            for b in bints:
+                cancelled = False
+                while aints:
+                    a = aints.pop()
+                    if a >= b:
+                        cancelled = True
+                        break
+                    popped = True
+                if not cancelled:
+                    return S.Zero
+            if aints or popped:
+                # There are still non-positive numerator parameters.
+                # This is a polynomial.
+                return oo
+        if len(self.ap) == len(self.bq) + 1:
+            return S.One
+        elif len(self.ap) <= len(self.bq):
+            return oo
+        else:
+            return S.Zero
+
+    @property
+    def convergence_statement(self):
+        """ Return a condition on z under which the series converges. """
+        R = self.radius_of_convergence
+        if R == 0:
+            return False
+        if R == oo:
+            return True
+        # The special functions and their approximations, page 44
+        e = self.eta
+        z = self.argument
+        c1 = And(re(e) < 0, abs(z) <= 1)
+        c2 = And(0 <= re(e), re(e) < 1, abs(z) <= 1, Ne(z, 1))
+        c3 = And(re(e) >= 1, abs(z) < 1)
+        return Or(c1, c2, c3)
+
+    def _eval_simplify(self, **kwargs):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self)
+
+
+class meijerg(TupleParametersBase):
+    r"""
+    The Meijer G-function is defined by a Mellin-Barnes type integral that
+    resembles an inverse Mellin transform. It generalizes the hypergeometric
+    functions.
+
+    Explanation
+    ===========
+
+    The Meijer G-function depends on four sets of parameters. There are
+    "*numerator parameters*"
+    $a_1, \ldots, a_n$ and $a_{n+1}, \ldots, a_p$, and there are
+    "*denominator parameters*"
+    $b_1, \ldots, b_m$ and $b_{m+1}, \ldots, b_q$.
+    Confusingly, it is traditionally denoted as follows (note the position
+    of $m$, $n$, $p$, $q$, and how they relate to the lengths of the four
+    parameter vectors):
+
+    .. math ::
+        G_{p,q}^{m,n} \left(\begin{matrix}a_1, \cdots, a_n & a_{n+1}, \cdots, a_p \\
+                                        b_1, \cdots, b_m & b_{m+1}, \cdots, b_q
+                          \end{matrix} \middle| z \right).
+
+    However, in SymPy the four parameter vectors are always available
+    separately (see examples), so that there is no need to keep track of the
+    decorating sub- and super-scripts on the G symbol.
+
+    The G function is defined as the following integral:
+
+    .. math ::
+         \frac{1}{2 \pi i} \int_L \frac{\prod_{j=1}^m \Gamma(b_j - s)
+         \prod_{j=1}^n \Gamma(1 - a_j + s)}{\prod_{j=m+1}^q \Gamma(1- b_j +s)
+         \prod_{j=n+1}^p \Gamma(a_j - s)} z^s \mathrm{d}s,
+
+    where $\Gamma(z)$ is the gamma function. There are three possible
+    contours which we will not describe in detail here (see the references).
+    If the integral converges along more than one of them, the definitions
+    agree. The contours all separate the poles of $\Gamma(1-a_j+s)$
+    from the poles of $\Gamma(b_k-s)$, so in particular the G function
+    is undefined if $a_j - b_k \in \mathbb{Z}_{>0}$ for some
+    $j \le n$ and $k \le m$.
+
+    The conditions under which one of the contours yields a convergent integral
+    are complicated and we do not state them here, see the references.
+
+    Please note currently the Meijer G-function constructor does *not* check any
+    convergence conditions.
+
+    Examples
+    ========
+
+    You can pass the parameters either as four separate vectors:
+
+    >>> from sympy import meijerg, Tuple, pprint
+    >>> from sympy.abc import x, a
+    >>> pprint(meijerg((1, 2), (a, 4), (5,), [], x), use_unicode=False)
+     __1, 2 /1, 2  4, a |  \
+    /__     |           | x|
+    \_|4, 1 \ 5         |  /
+
+    Or as two nested vectors:
+
+    >>> pprint(meijerg([(1, 2), (3, 4)], ([5], Tuple()), x), use_unicode=False)
+     __1, 2 /1, 2  3, 4 |  \
+    /__     |           | x|
+    \_|4, 1 \ 5         |  /
+
+    As with the hypergeometric function, the parameters may be passed as
+    arbitrary iterables. Vectors of length zero and one also have to be
+    passed as iterables. The parameters need not be constants, but if they
+    depend on the argument then not much implemented functionality should be
+    expected.
+
+    All the subvectors of parameters are available:
+
+    >>> from sympy import pprint
+    >>> g = meijerg([1], [2], [3], [4], x)
+    >>> pprint(g, use_unicode=False)
+     __1, 1 /1  2 |  \
+    /__     |     | x|
+    \_|2, 2 \3  4 |  /
+    >>> g.an
+    (1,)
+    >>> g.ap
+    (1, 2)
+    >>> g.aother
+    (2,)
+    >>> g.bm
+    (3,)
+    >>> g.bq
+    (3, 4)
+    >>> g.bother
+    (4,)
+
+    The Meijer G-function generalizes the hypergeometric functions.
+    In some cases it can be expressed in terms of hypergeometric functions,
+    using Slater's theorem. For example:
+
+    >>> from sympy import hyperexpand
+    >>> from sympy.abc import a, b, c
+    >>> hyperexpand(meijerg([a], [], [c], [b], x), allow_hyper=True)
+    x**c*gamma(-a + c + 1)*hyper((-a + c + 1,),
+                                 (-b + c + 1,), -x)/gamma(-b + c + 1)
+
+    Thus the Meijer G-function also subsumes many named functions as special
+    cases. You can use ``expand_func()`` or ``hyperexpand()`` to (try to)
+    rewrite a Meijer G-function in terms of named special functions. For
+    example:
+
+    >>> from sympy import expand_func, S
+    >>> expand_func(meijerg([[],[]], [[0],[]], -x))
+    exp(x)
+    >>> hyperexpand(meijerg([[],[]], [[S(1)/2],[0]], (x/2)**2))
+    sin(x)/sqrt(pi)
+
+    See Also
+    ========
+
+    hyper
+    sympy.simplify.hyperexpand
+
+    References
+    ==========
+
+    .. [1] Luke, Y. L. (1969), The Special Functions and Their Approximations,
+           Volume 1
+    .. [2] https://en.wikipedia.org/wiki/Meijer_G-function
+
+    """
+
+
+    def __new__(cls, *args, **kwargs):
+        if len(args) == 5:
+            args = [(args[0], args[1]), (args[2], args[3]), args[4]]
+        if len(args) != 3:
+            raise TypeError("args must be either as, as', bs, bs', z or "
+                            "as, bs, z")
+
+        def tr(p):
+            if len(p) != 2:
+                raise TypeError("wrong argument")
+            p = [list(ordered(i)) for i in p]
+            return TupleArg(_prep_tuple(p[0]), _prep_tuple(p[1]))
+
+        arg0, arg1 = tr(args[0]), tr(args[1])
+        if Tuple(arg0, arg1).has(oo, zoo, -oo):
+            raise ValueError("G-function parameters must be finite")
+        if any((a - b).is_Integer and a - b > 0
+               for a in arg0[0] for b in arg1[0]):
+            raise ValueError("no parameter a1, ..., an may differ from "
+                         "any b1, ..., bm by a positive integer")
+
+        # TODO should we check convergence conditions?
+        return super().__new__(cls, arg0, arg1, args[2], **kwargs)
+
+    def fdiff(self, argindex=3):
+        if argindex != 3:
+            return self._diff_wrt_parameter(argindex[1])
+        if len(self.an) >= 1:
+            a = list(self.an)
+            a[0] -= 1
+            G = meijerg(a, self.aother, self.bm, self.bother, self.argument)
+            return 1/self.argument * ((self.an[0] - 1)*self + G)
+        elif len(self.bm) >= 1:
+            b = list(self.bm)
+            b[0] += 1
+            G = meijerg(self.an, self.aother, b, self.bother, self.argument)
+            return 1/self.argument * (self.bm[0]*self - G)
+        else:
+            return S.Zero
+
+    def _diff_wrt_parameter(self, idx):
+        # Differentiation wrt a parameter can only be done in very special
+        # cases. In particular, if we want to differentiate with respect to
+        # `a`, all other gamma factors have to reduce to rational functions.
+        #
+        # Let MT denote mellin transform. Suppose T(-s) is the gamma factor
+        # appearing in the definition of G. Then
+        #
+        #   MT(log(z)G(z)) = d/ds T(s) = d/da T(s) + ...
+        #
+        # Thus d/da G(z) = log(z)G(z) - ...
+        # The ... can be evaluated as a G function under the above conditions,
+        # the formula being most easily derived by using
+        #
+        # d  Gamma(s + n)    Gamma(s + n) / 1    1                1     \
+        # -- ------------ =  ------------ | - + ----  + ... + --------- |
+        # ds Gamma(s)        Gamma(s)     \ s   s + 1         s + n - 1 /
+        #
+        # which follows from the difference equation of the digamma function.
+        # (There is a similar equation for -n instead of +n).
+
+        # We first figure out how to pair the parameters.
+        an = list(self.an)
+        ap = list(self.aother)
+        bm = list(self.bm)
+        bq = list(self.bother)
+        if idx < len(an):
+            an.pop(idx)
+        else:
+            idx -= len(an)
+            if idx < len(ap):
+                ap.pop(idx)
+            else:
+                idx -= len(ap)
+                if idx < len(bm):
+                    bm.pop(idx)
+                else:
+                    bq.pop(idx - len(bm))
+        pairs1 = []
+        pairs2 = []
+        for l1, l2, pairs in [(an, bq, pairs1), (ap, bm, pairs2)]:
+            while l1:
+                x = l1.pop()
+                found = None
+                for i, y in enumerate(l2):
+                    if not Mod((x - y).simplify(), 1):
+                        found = i
+                        break
+                if found is None:
+                    raise NotImplementedError('Derivative not expressible '
+                                              'as G-function?')
+                y = l2[i]
+                l2.pop(i)
+                pairs.append((x, y))
+
+        # Now build the result.
+        res = log(self.argument)*self
+
+        for a, b in pairs1:
+            sign = 1
+            n = a - b
+            base = b
+            if n < 0:
+                sign = -1
+                n = b - a
+                base = a
+            for k in range(n):
+                res -= sign*meijerg(self.an + (base + k + 1,), self.aother,
+                                    self.bm, self.bother + (base + k + 0,),
+                                    self.argument)
+
+        for a, b in pairs2:
+            sign = 1
+            n = b - a
+            base = a
+            if n < 0:
+                sign = -1
+                n = a - b
+                base = b
+            for k in range(n):
+                res -= sign*meijerg(self.an, self.aother + (base + k + 1,),
+                                    self.bm + (base + k + 0,), self.bother,
+                                    self.argument)
+
+        return res
+
+    def get_period(self):
+        """
+        Return a number $P$ such that $G(x*exp(I*P)) == G(x)$.
+
+        Examples
+        ========
+
+        >>> from sympy import meijerg, pi, S
+        >>> from sympy.abc import z
+
+        >>> meijerg([1], [], [], [], z).get_period()
+        2*pi
+        >>> meijerg([pi], [], [], [], z).get_period()
+        oo
+        >>> meijerg([1, 2], [], [], [], z).get_period()
+        oo
+        >>> meijerg([1,1], [2], [1, S(1)/2, S(1)/3], [1], z).get_period()
+        12*pi
+
+        """
+        # This follows from slater's theorem.
+        def compute(l):
+            # first check that no two differ by an integer
+            for i, b in enumerate(l):
+                if not b.is_Rational:
+                    return oo
+                for j in range(i + 1, len(l)):
+                    if not Mod((b - l[j]).simplify(), 1):
+                        return oo
+            return lcm(*(x.q for x in l))
+        beta = compute(self.bm)
+        alpha = compute(self.an)
+        p, q = len(self.ap), len(self.bq)
+        if p == q:
+            if oo in (alpha, beta):
+                return oo
+            return 2*pi*lcm(alpha, beta)
+        elif p < q:
+            return 2*pi*beta
+        else:
+            return 2*pi*alpha
+
+    def _eval_expand_func(self, **hints):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self)
+
+    def _eval_evalf(self, prec):
+        # The default code is insufficient for polar arguments.
+        # mpmath provides an optional argument "r", which evaluates
+        # G(z**(1/r)). I am not sure what its intended use is, but we hijack it
+        # here in the following way: to evaluate at a number z of |argument|
+        # less than (say) n*pi, we put r=1/n, compute z' = root(z, n)
+        # (carefully so as not to loose the branch information), and evaluate
+        # G(z'**(1/r)) = G(z'**n) = G(z).
+        import mpmath
+        znum = self.argument._eval_evalf(prec)
+        if znum.has(exp_polar):
+            znum, branch = znum.as_coeff_mul(exp_polar)
+            if len(branch) != 1:
+                return
+            branch = branch[0].args[0]/I
+        else:
+            branch = S.Zero
+        n = ceiling(abs(branch/pi)) + 1
+        znum = znum**(S.One/n)*exp(I*branch / n)
+
+        # Convert all args to mpf or mpc
+        try:
+            [z, r, ap, bq] = [arg._to_mpmath(prec)
+                    for arg in [znum, 1/n, self.args[0], self.args[1]]]
+        except ValueError:
+            return
+
+        with mpmath.workprec(prec):
+            v = mpmath.meijerg(ap, bq, z, r)
+
+        return Expr._from_mpmath(v, prec)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        from sympy.simplify.hyperexpand import hyperexpand
+        return hyperexpand(self).as_leading_term(x, logx=logx, cdir=cdir)
+
+    def integrand(self, s):
+        """ Get the defining integrand D(s). """
+        from sympy.functions.special.gamma_functions import gamma
+        return self.argument**s \
+            * Mul(*(gamma(b - s) for b in self.bm)) \
+            * Mul(*(gamma(1 - a + s) for a in self.an)) \
+            / Mul(*(gamma(1 - b + s) for b in self.bother)) \
+            / Mul(*(gamma(a - s) for a in self.aother))
+
+    @property
+    def argument(self):
+        """ Argument of the Meijer G-function. """
+        return self.args[2]
+
+    @property
+    def an(self):
+        """ First set of numerator parameters. """
+        return Tuple(*self.args[0][0])
+
+    @property
+    def ap(self):
+        """ Combined numerator parameters. """
+        return Tuple(*(self.args[0][0] + self.args[0][1]))
+
+    @property
+    def aother(self):
+        """ Second set of numerator parameters. """
+        return Tuple(*self.args[0][1])
+
+    @property
+    def bm(self):
+        """ First set of denominator parameters. """
+        return Tuple(*self.args[1][0])
+
+    @property
+    def bq(self):
+        """ Combined denominator parameters. """
+        return Tuple(*(self.args[1][0] + self.args[1][1]))
+
+    @property
+    def bother(self):
+        """ Second set of denominator parameters. """
+        return Tuple(*self.args[1][1])
+
+    @property
+    def _diffargs(self):
+        return self.ap + self.bq
+
+    @property
+    def nu(self):
+        """ A quantity related to the convergence region of the integral,
+            c.f. references. """
+        return sum(self.bq) - sum(self.ap)
+
+    @property
+    def delta(self):
+        """ A quantity related to the convergence region of the integral,
+            c.f. references. """
+        return len(self.bm) + len(self.an) - S(len(self.ap) + len(self.bq))/2
+
+    @property
+    def is_number(self):
+        """ Returns true if expression has numeric data only. """
+        return not self.free_symbols
+
+
+class HyperRep(DefinedFunction):
+    """
+    A base class for "hyper representation functions".
+
+    This is used exclusively in ``hyperexpand()``, but fits more logically here.
+
+    pFq is branched at 1 if p == q+1. For use with slater-expansion, we want
+    define an "analytic continuation" to all polar numbers, which is
+    continuous on circles and on the ray t*exp_polar(I*pi). Moreover, we want
+    a "nice" expression for the various cases.
+
+    This base class contains the core logic, concrete derived classes only
+    supply the actual functions.
+
+    """
+
+
+    @classmethod
+    def eval(cls, *args):
+        newargs = tuple(map(unpolarify, args[:-1])) + args[-1:]
+        if args != newargs:
+            return cls(*newargs)
+
+    @classmethod
+    def _expr_small(cls, x):
+        """ An expression for F(x) which holds for |x| < 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_small_minus(cls, x):
+        """ An expression for F(-x) which holds for |x| < 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_big(cls, x, n):
+        """ An expression for F(exp_polar(2*I*pi*n)*x), |x| > 1. """
+        raise NotImplementedError
+
+    @classmethod
+    def _expr_big_minus(cls, x, n):
+        """ An expression for F(exp_polar(2*I*pi*n + pi*I)*x), |x| > 1. """
+        raise NotImplementedError
+
+    def _eval_rewrite_as_nonrep(self, *args, **kwargs):
+        x, n = self.args[-1].extract_branch_factor(allow_half=True)
+        minus = False
+        newargs = self.args[:-1] + (x,)
+        if not n.is_Integer:
+            minus = True
+            n -= S.Half
+        newerargs = newargs + (n,)
+        if minus:
+            small = self._expr_small_minus(*newargs)
+            big = self._expr_big_minus(*newerargs)
+        else:
+            small = self._expr_small(*newargs)
+            big = self._expr_big(*newerargs)
+
+        if big == small:
+            return small
+        return Piecewise((big, abs(x) > 1), (small, True))
+
+    def _eval_rewrite_as_nonrepsmall(self, *args, **kwargs):
+        x, n = self.args[-1].extract_branch_factor(allow_half=True)
+        args = self.args[:-1] + (x,)
+        if not n.is_Integer:
+            return self._expr_small_minus(*args)
+        return self._expr_small(*args)
+
+
+class HyperRep_power1(HyperRep):
+    """ Return a representative for hyper([-a], [], z) == (1 - z)**a. """
+
+    @classmethod
+    def _expr_small(cls, a, x):
+        return (1 - x)**a
+
+    @classmethod
+    def _expr_small_minus(cls, a, x):
+        return (1 + x)**a
+
+    @classmethod
+    def _expr_big(cls, a, x, n):
+        if a.is_integer:
+            return cls._expr_small(a, x)
+        return (x - 1)**a*exp((2*n - 1)*pi*I*a)
+
+    @classmethod
+    def _expr_big_minus(cls, a, x, n):
+        if a.is_integer:
+            return cls._expr_small_minus(a, x)
+        return (1 + x)**a*exp(2*n*pi*I*a)
+
+
+class HyperRep_power2(HyperRep):
+    """ Return a representative for hyper([a, a - 1/2], [2*a], z). """
+
+    @classmethod
+    def _expr_small(cls, a, x):
+        return 2**(2*a - 1)*(1 + sqrt(1 - x))**(1 - 2*a)
+
+    @classmethod
+    def _expr_small_minus(cls, a, x):
+        return 2**(2*a - 1)*(1 + sqrt(1 + x))**(1 - 2*a)
+
+    @classmethod
+    def _expr_big(cls, a, x, n):
+        sgn = -1
+        if n.is_odd:
+            sgn = 1
+            n -= 1
+        return 2**(2*a - 1)*(1 + sgn*I*sqrt(x - 1))**(1 - 2*a) \
+            *exp(-2*n*pi*I*a)
+
+    @classmethod
+    def _expr_big_minus(cls, a, x, n):
+        sgn = 1
+        if n.is_odd:
+            sgn = -1
+        return sgn*2**(2*a - 1)*(sqrt(1 + x) + sgn)**(1 - 2*a)*exp(-2*pi*I*a*n)
+
+
+class HyperRep_log1(HyperRep):
+    """ Represent -z*hyper([1, 1], [2], z) == log(1 - z). """
+    @classmethod
+    def _expr_small(cls, x):
+        return log(1 - x)
+
+    @classmethod
+    def _expr_small_minus(cls, x):
+        return log(1 + x)
+
+    @classmethod
+    def _expr_big(cls, x, n):
+        return log(x - 1) + (2*n - 1)*pi*I
+
+    @classmethod
+    def _expr_big_minus(cls, x, n):
+        return log(1 + x) + 2*n*pi*I
+
+
+class HyperRep_atanh(HyperRep):
+    """ Represent hyper([1/2, 1], [3/2], z) == atanh(sqrt(z))/sqrt(z). """
+    @classmethod
+    def _expr_small(cls, x):
+        return atanh(sqrt(x))/sqrt(x)
+
+    def _expr_small_minus(cls, x):
+        return atan(sqrt(x))/sqrt(x)
+
+    def _expr_big(cls, x, n):
+        if n.is_even:
+            return (acoth(sqrt(x)) + I*pi/2)/sqrt(x)
+        else:
+            return (acoth(sqrt(x)) - I*pi/2)/sqrt(x)
+
+    def _expr_big_minus(cls, x, n):
+        if n.is_even:
+            return atan(sqrt(x))/sqrt(x)
+        else:
+            return (atan(sqrt(x)) - pi)/sqrt(x)
+
+
+class HyperRep_asin1(HyperRep):
+    """ Represent hyper([1/2, 1/2], [3/2], z) == asin(sqrt(z))/sqrt(z). """
+    @classmethod
+    def _expr_small(cls, z):
+        return asin(sqrt(z))/sqrt(z)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return asinh(sqrt(z))/sqrt(z)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        return S.NegativeOne**n*((S.Half - n)*pi/sqrt(z) + I*acosh(sqrt(z))/sqrt(z))
+
+    @classmethod
+    def _expr_big_minus(cls, z, n):
+        return S.NegativeOne**n*(asinh(sqrt(z))/sqrt(z) + n*pi*I/sqrt(z))
+
+
+class HyperRep_asin2(HyperRep):
+    """ Represent hyper([1, 1], [3/2], z) == asin(sqrt(z))/sqrt(z)/sqrt(1-z). """
+    # TODO this can be nicer
+    @classmethod
+    def _expr_small(cls, z):
+        return HyperRep_asin1._expr_small(z) \
+            /HyperRep_power1._expr_small(S.Half, z)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return HyperRep_asin1._expr_small_minus(z) \
+            /HyperRep_power1._expr_small_minus(S.Half, z)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        return HyperRep_asin1._expr_big(z, n) \
+            /HyperRep_power1._expr_big(S.Half, z, n)
+
+    @classmethod
+    def _expr_big_minus(cls, z, n):
+        return HyperRep_asin1._expr_big_minus(z, n) \
+            /HyperRep_power1._expr_big_minus(S.Half, z, n)
+
+
+class HyperRep_sqrts1(HyperRep):
+    """ Return a representative for hyper([-a, 1/2 - a], [1/2], z). """
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return ((1 - sqrt(z))**(2*a) + (1 + sqrt(z))**(2*a))/2
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return (1 + z)**a*cos(2*a*atan(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        if n.is_even:
+            return ((sqrt(z) + 1)**(2*a)*exp(2*pi*I*n*a) +
+                    (sqrt(z) - 1)**(2*a)*exp(2*pi*I*(n - 1)*a))/2
+        else:
+            n -= 1
+            return ((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n + 1)) +
+                    (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))/2
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        if n.is_even:
+            return (1 + z)**a*exp(2*pi*I*n*a)*cos(2*a*atan(sqrt(z)))
+        else:
+            return (1 + z)**a*exp(2*pi*I*n*a)*cos(2*a*atan(sqrt(z)) - 2*pi*a)
+
+
+class HyperRep_sqrts2(HyperRep):
+    """ Return a representative for
+          sqrt(z)/2*[(1-sqrt(z))**2a - (1 + sqrt(z))**2a]
+          == -2*z/(2*a+1) d/dz hyper([-a - 1/2, -a], [1/2], z)"""
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return sqrt(z)*((1 - sqrt(z))**(2*a) - (1 + sqrt(z))**(2*a))/2
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return sqrt(z)*(1 + z)**a*sin(2*a*atan(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        if n.is_even:
+            return sqrt(z)/2*((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n - 1)) -
+                              (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))
+        else:
+            n -= 1
+            return sqrt(z)/2*((sqrt(z) - 1)**(2*a)*exp(2*pi*I*a*(n + 1)) -
+                              (sqrt(z) + 1)**(2*a)*exp(2*pi*I*a*n))
+
+    def _expr_big_minus(cls, a, z, n):
+        if n.is_even:
+            return (1 + z)**a*exp(2*pi*I*n*a)*sqrt(z)*sin(2*a*atan(sqrt(z)))
+        else:
+            return (1 + z)**a*exp(2*pi*I*n*a)*sqrt(z) \
+                *sin(2*a*atan(sqrt(z)) - 2*pi*a)
+
+
+class HyperRep_log2(HyperRep):
+    """ Represent log(1/2 + sqrt(1 - z)/2) == -z/4*hyper([3/2, 1, 1], [2, 2], z) """
+
+    @classmethod
+    def _expr_small(cls, z):
+        return log(S.Half + sqrt(1 - z)/2)
+
+    @classmethod
+    def _expr_small_minus(cls, z):
+        return log(S.Half + sqrt(1 + z)/2)
+
+    @classmethod
+    def _expr_big(cls, z, n):
+        if n.is_even:
+            return (n - S.Half)*pi*I + log(sqrt(z)/2) + I*asin(1/sqrt(z))
+        else:
+            return (n - S.Half)*pi*I + log(sqrt(z)/2) - I*asin(1/sqrt(z))
+
+    def _expr_big_minus(cls, z, n):
+        if n.is_even:
+            return pi*I*n + log(S.Half + sqrt(1 + z)/2)
+        else:
+            return pi*I*n + log(sqrt(1 + z)/2 - S.Half)
+
+
+class HyperRep_cosasin(HyperRep):
+    """ Represent hyper([a, -a], [1/2], z) == cos(2*a*asin(sqrt(z))). """
+    # Note there are many alternative expressions, e.g. as powers of a sum of
+    # square roots.
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return cos(2*a*asin(sqrt(z)))
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return cosh(2*a*asinh(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        return cosh(2*a*acosh(sqrt(z)) + a*pi*I*(2*n - 1))
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        return cosh(2*a*asinh(sqrt(z)) + 2*a*pi*I*n)
+
+
+class HyperRep_sinasin(HyperRep):
+    """ Represent 2*a*z*hyper([1 - a, 1 + a], [3/2], z)
+        == sqrt(z)/sqrt(1-z)*sin(2*a*asin(sqrt(z))) """
+
+    @classmethod
+    def _expr_small(cls, a, z):
+        return sqrt(z)/sqrt(1 - z)*sin(2*a*asin(sqrt(z)))
+
+    @classmethod
+    def _expr_small_minus(cls, a, z):
+        return -sqrt(z)/sqrt(1 + z)*sinh(2*a*asinh(sqrt(z)))
+
+    @classmethod
+    def _expr_big(cls, a, z, n):
+        return -1/sqrt(1 - 1/z)*sinh(2*a*acosh(sqrt(z)) + a*pi*I*(2*n - 1))
+
+    @classmethod
+    def _expr_big_minus(cls, a, z, n):
+        return -1/sqrt(1 + 1/z)*sinh(2*a*asinh(sqrt(z)) + 2*a*pi*I*n)
+
+class appellf1(DefinedFunction):
+    r"""
+    This is the Appell hypergeometric function of two variables as:
+
+    .. math ::
+        F_1(a,b_1,b_2,c,x,y) = \sum_{m=0}^{\infty} \sum_{n=0}^{\infty}
+        \frac{(a)_{m+n} (b_1)_m (b_2)_n}{(c)_{m+n}}
+        \frac{x^m y^n}{m! n!}.
+
+    Examples
+    ========
+
+    >>> from sympy import appellf1, symbols
+    >>> x, y, a, b1, b2, c = symbols('x y a b1 b2 c')
+    >>> appellf1(2., 1., 6., 4., 5., 6.)
+    0.0063339426292673
+    >>> appellf1(12., 12., 6., 4., 0.5, 0.12)
+    172870711.659936
+    >>> appellf1(40, 2, 6, 4, 15, 60)
+    appellf1(40, 2, 6, 4, 15, 60)
+    >>> appellf1(20., 12., 10., 3., 0.5, 0.12)
+    15605338197184.4
+    >>> appellf1(40, 2, 6, 4, x, y)
+    appellf1(40, 2, 6, 4, x, y)
+    >>> appellf1(a, b1, b2, c, x, y)
+    appellf1(a, b1, b2, c, x, y)
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Appell_series
+    .. [2] https://functions.wolfram.com/HypergeometricFunctions/AppellF1/
+
+    """
+
+    @classmethod
+    def eval(cls, a, b1, b2, c, x, y):
+        if default_sort_key(b1) > default_sort_key(b2):
+            b1, b2 = b2, b1
+            x, y = y, x
+            return cls(a, b1, b2, c, x, y)
+        elif b1 == b2 and default_sort_key(x) > default_sort_key(y):
+            x, y = y, x
+            return cls(a, b1, b2, c, x, y)
+        if x == 0 and y == 0:
+            return S.One
+
+    def fdiff(self, argindex=5):
+        a, b1, b2, c, x, y = self.args
+        if argindex == 5:
+            return (a*b1/c)*appellf1(a + 1, b1 + 1, b2, c + 1, x, y)
+        elif argindex == 6:
+            return (a*b2/c)*appellf1(a + 1, b1, b2 + 1, c + 1, x, y)
+        elif argindex in (1, 2, 3, 4):
+            return Derivative(self, self.args[argindex-1])
+        else:
+            raise ArgumentIndexError(self, argindex)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/mathieu_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/mathieu_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..66bccd8d3e6dd357e1e0b93fb5cb5ad4c5f1367f
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/mathieu_functions.py
@@ -0,0 +1,269 @@
+""" This module contains the Mathieu functions.
+"""
+
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos
+
+
+class MathieuBase(DefinedFunction):
+    """
+    Abstract base class for Mathieu functions.
+
+    This class is meant to reduce code duplication.
+
+    """
+
+    unbranched = True
+
+    def _eval_conjugate(self):
+        a, q, z = self.args
+        return self.func(a.conjugate(), q.conjugate(), z.conjugate())
+
+
+class mathieus(MathieuBase):
+    r"""
+    The Mathieu Sine function $S(a,q,z)$.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieus
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieus(a, q, z)
+    mathieus(a, q, z)
+
+    >>> mathieus(a, 0, z)
+    sin(sqrt(a)*z)
+
+    >>> diff(mathieus(a, q, z), z)
+    mathieusprime(a, q, z)
+
+    See Also
+    ========
+
+    mathieuc: Mathieu cosine function.
+    mathieusprime: Derivative of Mathieu sine function.
+    mathieucprime: Derivative of Mathieu cosine function.
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuS/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return mathieusprime(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return sin(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(a, q, -z)
+
+
+class mathieuc(MathieuBase):
+    r"""
+    The Mathieu Cosine function $C(a,q,z)$.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieuc
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieuc(a, q, z)
+    mathieuc(a, q, z)
+
+    >>> mathieuc(a, 0, z)
+    cos(sqrt(a)*z)
+
+    >>> diff(mathieuc(a, q, z), z)
+    mathieucprime(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieusprime: Derivative of Mathieu sine function
+    mathieucprime: Derivative of Mathieu cosine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuC/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return mathieucprime(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return cos(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return cls(a, q, -z)
+
+
+class mathieusprime(MathieuBase):
+    r"""
+    The derivative $S^{\prime}(a,q,z)$ of the Mathieu Sine function.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Cosine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieusprime
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieusprime(a, q, z)
+    mathieusprime(a, q, z)
+
+    >>> mathieusprime(a, 0, z)
+    sqrt(a)*cos(sqrt(a)*z)
+
+    >>> diff(mathieusprime(a, q, z), z)
+    (-a + 2*q*cos(2*z))*mathieus(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieuc: Mathieu cosine function
+    mathieucprime: Derivative of Mathieu cosine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuSPrime/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return (2*q*cos(2*z) - a)*mathieus(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return sqrt(a)*cos(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return cls(a, q, -z)
+
+
+class mathieucprime(MathieuBase):
+    r"""
+    The derivative $C^{\prime}(a,q,z)$ of the Mathieu Cosine function.
+
+    Explanation
+    ===========
+
+    This function is one solution of the Mathieu differential equation:
+
+    .. math ::
+        y(x)^{\prime\prime} + (a - 2 q \cos(2 x)) y(x) = 0
+
+    The other solution is the Mathieu Sine function.
+
+    Examples
+    ========
+
+    >>> from sympy import diff, mathieucprime
+    >>> from sympy.abc import a, q, z
+
+    >>> mathieucprime(a, q, z)
+    mathieucprime(a, q, z)
+
+    >>> mathieucprime(a, 0, z)
+    -sqrt(a)*sin(sqrt(a)*z)
+
+    >>> diff(mathieucprime(a, q, z), z)
+    (-a + 2*q*cos(2*z))*mathieuc(a, q, z)
+
+    See Also
+    ========
+
+    mathieus: Mathieu sine function
+    mathieuc: Mathieu cosine function
+    mathieusprime: Derivative of Mathieu sine function
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Mathieu_function
+    .. [2] https://dlmf.nist.gov/28
+    .. [3] https://mathworld.wolfram.com/MathieuFunction.html
+    .. [4] https://functions.wolfram.com/MathieuandSpheroidalFunctions/MathieuCPrime/
+
+    """
+
+    def fdiff(self, argindex=1):
+        if argindex == 3:
+            a, q, z = self.args
+            return (2*q*cos(2*z) - a)*mathieuc(a, q, z)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, a, q, z):
+        if q.is_Number and q.is_zero:
+            return -sqrt(a)*sin(sqrt(a)*z)
+        # Try to pull out factors of -1
+        if z.could_extract_minus_sign():
+            return -cls(a, q, -z)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/polynomials.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/polynomials.py
new file mode 100644
index 0000000000000000000000000000000000000000..5816baef600baf957c31a9dddaa5571da86d754a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/polynomials.py
@@ -0,0 +1,1447 @@
+"""
+This module mainly implements special orthogonal polynomials.
+
+See also functions.combinatorial.numbers which contains some
+combinatorial polynomials.
+
+"""
+
+from sympy.core import Rational
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions.combinatorial.factorials import binomial, factorial, RisingFactorial
+from sympy.functions.elementary.complexes import re
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos, sec
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.polys.orthopolys import (chebyshevt_poly, chebyshevu_poly,
+                                    gegenbauer_poly, hermite_poly, hermite_prob_poly,
+                                    jacobi_poly, laguerre_poly, legendre_poly)
+
+_x = Dummy('x')
+
+
+class OrthogonalPolynomial(DefinedFunction):
+    """Base class for orthogonal polynomials.
+    """
+
+    @classmethod
+    def _eval_at_order(cls, n, x):
+        if n.is_integer and n >= 0:
+            return cls._ortho_poly(int(n), _x).subs(_x, x)
+
+    def _eval_conjugate(self):
+        return self.func(self.args[0], self.args[1].conjugate())
+
+#----------------------------------------------------------------------------
+# Jacobi polynomials
+#
+
+
+class jacobi(OrthogonalPolynomial):
+    r"""
+    Jacobi polynomial $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``jacobi(n, alpha, beta, x)`` gives the $n$th Jacobi polynomial
+    in $x$, $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    The Jacobi polynomials are orthogonal on $[-1, 1]$ with respect
+    to the weight $\left(1-x\right)^\alpha \left(1+x\right)^\beta$.
+
+    Examples
+    ========
+
+    >>> from sympy import jacobi, S, conjugate, diff
+    >>> from sympy.abc import a, b, n, x
+
+    >>> jacobi(0, a, b, x)
+    1
+    >>> jacobi(1, a, b, x)
+    a/2 - b/2 + x*(a/2 + b/2 + 1)
+    >>> jacobi(2, a, b, x)
+    a**2/8 - a*b/4 - a/8 + b**2/8 - b/8 + x**2*(a**2/8 + a*b/4 + 7*a/8 + b**2/8 + 7*b/8 + 3/2) + x*(a**2/4 + 3*a/4 - b**2/4 - 3*b/4) - 1/2
+
+    >>> jacobi(n, a, b, x)
+    jacobi(n, a, b, x)
+
+    >>> jacobi(n, a, a, x)
+    RisingFactorial(a + 1, n)*gegenbauer(n,
+        a + 1/2, x)/RisingFactorial(2*a + 1, n)
+
+    >>> jacobi(n, 0, 0, x)
+    legendre(n, x)
+
+    >>> jacobi(n, S(1)/2, S(1)/2, x)
+    RisingFactorial(3/2, n)*chebyshevu(n, x)/factorial(n + 1)
+
+    >>> jacobi(n, -S(1)/2, -S(1)/2, x)
+    RisingFactorial(1/2, n)*chebyshevt(n, x)/factorial(n)
+
+    >>> jacobi(n, a, b, -x)
+    (-1)**n*jacobi(n, b, a, x)
+
+    >>> jacobi(n, a, b, 0)
+    gamma(a + n + 1)*hyper((-n, -b - n), (a + 1,), -1)/(2**n*factorial(n)*gamma(a + 1))
+    >>> jacobi(n, a, b, 1)
+    RisingFactorial(a + 1, n)/factorial(n)
+
+    >>> conjugate(jacobi(n, a, b, x))
+    jacobi(n, conjugate(a), conjugate(b), conjugate(x))
+
+    >>> diff(jacobi(n,a,b,x), x)
+    (a/2 + b/2 + n/2 + 1/2)*jacobi(n - 1, a + 1, b + 1, x)
+
+    See Also
+    ========
+
+    gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly,
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jacobi_polynomials
+    .. [2] https://mathworld.wolfram.com/JacobiPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/JacobiP/
+
+    """
+
+    @classmethod
+    def eval(cls, n, a, b, x):
+        # Simplify to other polynomials
+        # P^{a, a}_n(x)
+        if a == b:
+            if a == Rational(-1, 2):
+                return RisingFactorial(S.Half, n) / factorial(n) * chebyshevt(n, x)
+            elif a.is_zero:
+                return legendre(n, x)
+            elif a == S.Half:
+                return RisingFactorial(3*S.Half, n) / factorial(n + 1) * chebyshevu(n, x)
+            else:
+                return RisingFactorial(a + 1, n) / RisingFactorial(2*a + 1, n) * gegenbauer(n, a + S.Half, x)
+        elif b == -a:
+            # P^{a, -a}_n(x)
+            return gamma(n + a + 1) / gamma(n + 1) * (1 + x)**(a/2) / (1 - x)**(a/2) * assoc_legendre(n, -a, x)
+
+        if not n.is_Number:
+            # Symbolic result P^{a,b}_n(x)
+            # P^{a,b}_n(-x)  --->  (-1)**n * P^{b,a}_n(-x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * jacobi(n, b, a, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return (2**(-n) * gamma(a + n + 1) / (gamma(a + 1) * factorial(n)) *
+                        hyper([-b - n, -n], [a + 1], -1))
+            if x == S.One:
+                return RisingFactorial(a + 1, n) / factorial(n)
+            elif x is S.Infinity:
+                if n.is_positive:
+                    # Make sure a+b+2*n \notin Z
+                    if (a + b + 2*n).is_integer:
+                        raise ValueError("Error. a + b + 2*n should not be an integer.")
+                    return RisingFactorial(a + b + n + 1, n) * S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            return jacobi_poly(n, a, b, x)
+
+    def fdiff(self, argindex=4):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt a
+            n, a, b, x = self.args
+            k = Dummy("k")
+            f1 = 1 / (a + b + n + k + 1)
+            f2 = ((a + b + 2*k + 1) * RisingFactorial(b + k + 1, n - k) /
+                  ((n - k) * RisingFactorial(a + b + k + 1, n - k)))
+            return Sum(f1 * (jacobi(n, a, b, x) + f2*jacobi(k, a, b, x)), (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt b
+            n, a, b, x = self.args
+            k = Dummy("k")
+            f1 = 1 / (a + b + n + k + 1)
+            f2 = (-1)**(n - k) * ((a + b + 2*k + 1) * RisingFactorial(a + k + 1, n - k) /
+                  ((n - k) * RisingFactorial(a + b + k + 1, n - k)))
+            return Sum(f1 * (jacobi(n, a, b, x) + f2*jacobi(k, a, b, x)), (k, 0, n - 1))
+        elif argindex == 4:
+            # Diff wrt x
+            n, a, b, x = self.args
+            return S.Half * (a + b + n + 1) * jacobi(n - 1, a + 1, b + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, a, b, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("Error: n should be a non-negative integer.")
+        k = Dummy("k")
+        kern = (RisingFactorial(-n, k) * RisingFactorial(a + b + n + 1, k) * RisingFactorial(a + k + 1, n - k) /
+                factorial(k) * ((1 - x)/2)**k)
+        return 1 / factorial(n) * Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, a, b, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, a, b, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, a, b, x = self.args
+        return self.func(n, a.conjugate(), b.conjugate(), x.conjugate())
+
+
+def jacobi_normalized(n, a, b, x):
+    r"""
+    Jacobi polynomial $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``jacobi_normalized(n, alpha, beta, x)`` gives the $n$th
+    Jacobi polynomial in $x$, $P_n^{\left(\alpha, \beta\right)}(x)$.
+
+    The Jacobi polynomials are orthogonal on $[-1, 1]$ with respect
+    to the weight $\left(1-x\right)^\alpha \left(1+x\right)^\beta$.
+
+    This functions returns the polynomials normilzed:
+
+    .. math::
+
+        \int_{-1}^{1}
+          P_m^{\left(\alpha, \beta\right)}(x)
+          P_n^{\left(\alpha, \beta\right)}(x)
+          (1-x)^{\alpha} (1+x)^{\beta} \mathrm{d}x
+        = \delta_{m,n}
+
+    Examples
+    ========
+
+    >>> from sympy import jacobi_normalized
+    >>> from sympy.abc import n,a,b,x
+
+    >>> jacobi_normalized(n, a, b, x)
+    jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)/((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1)))
+
+    Parameters
+    ==========
+
+    n : integer degree of polynomial
+
+    a : alpha value
+
+    b : beta value
+
+    x : symbol
+
+    See Also
+    ========
+
+    gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly,
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Jacobi_polynomials
+    .. [2] https://mathworld.wolfram.com/JacobiPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/JacobiP/
+
+    """
+    nfactor = (S(2)**(a + b + 1) * (gamma(n + a + 1) * gamma(n + b + 1))
+               / (2*n + a + b + 1) / (factorial(n) * gamma(n + a + b + 1)))
+
+    return jacobi(n, a, b, x) / sqrt(nfactor)
+
+
+#----------------------------------------------------------------------------
+# Gegenbauer polynomials
+#
+
+
+class gegenbauer(OrthogonalPolynomial):
+    r"""
+    Gegenbauer polynomial $C_n^{\left(\alpha\right)}(x)$.
+
+    Explanation
+    ===========
+
+    ``gegenbauer(n, alpha, x)`` gives the $n$th Gegenbauer polynomial
+    in $x$, $C_n^{\left(\alpha\right)}(x)$.
+
+    The Gegenbauer polynomials are orthogonal on $[-1, 1]$ with
+    respect to the weight $\left(1-x^2\right)^{\alpha-\frac{1}{2}}$.
+
+    Examples
+    ========
+
+    >>> from sympy import gegenbauer, conjugate, diff
+    >>> from sympy.abc import n,a,x
+    >>> gegenbauer(0, a, x)
+    1
+    >>> gegenbauer(1, a, x)
+    2*a*x
+    >>> gegenbauer(2, a, x)
+    -a + x**2*(2*a**2 + 2*a)
+    >>> gegenbauer(3, a, x)
+    x**3*(4*a**3/3 + 4*a**2 + 8*a/3) + x*(-2*a**2 - 2*a)
+
+    >>> gegenbauer(n, a, x)
+    gegenbauer(n, a, x)
+    >>> gegenbauer(n, a, -x)
+    (-1)**n*gegenbauer(n, a, x)
+
+    >>> gegenbauer(n, a, 0)
+    2**n*sqrt(pi)*gamma(a + n/2)/(gamma(a)*gamma(1/2 - n/2)*gamma(n + 1))
+    >>> gegenbauer(n, a, 1)
+    gamma(2*a + n)/(gamma(2*a)*gamma(n + 1))
+
+    >>> conjugate(gegenbauer(n, a, x))
+    gegenbauer(n, conjugate(a), conjugate(x))
+
+    >>> diff(gegenbauer(n, a, x), x)
+    2*a*gegenbauer(n - 1, a + 1, x)
+
+    See Also
+    ========
+
+    jacobi,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Gegenbauer_polynomials
+    .. [2] https://mathworld.wolfram.com/GegenbauerPolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/GegenbauerC3/
+
+    """
+
+    @classmethod
+    def eval(cls, n, a, x):
+        # For negative n the polynomials vanish
+        # See https://functions.wolfram.com/Polynomials/GegenbauerC3/03/01/03/0012/
+        if n.is_negative:
+            return S.Zero
+
+        # Some special values for fixed a
+        if a == S.Half:
+            return legendre(n, x)
+        elif a == S.One:
+            return chebyshevu(n, x)
+        elif a == S.NegativeOne:
+            return S.Zero
+
+        if not n.is_Number:
+            # Handle this before the general sign extraction rule
+            if x == S.NegativeOne:
+                if (re(a) > S.Half) == True:
+                    return S.ComplexInfinity
+                else:
+                    return (cos(S.Pi*(a+n)) * sec(S.Pi*a) * gamma(2*a+n) /
+                                (gamma(2*a) * gamma(n+1)))
+
+            # Symbolic result C^a_n(x)
+            # C^a_n(-x)  --->  (-1)**n * C^a_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * gegenbauer(n, a, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return (2**n * sqrt(S.Pi) * gamma(a + S.Half*n) /
+                        (gamma((1 - n)/2) * gamma(n + 1) * gamma(a)) )
+            if x == S.One:
+                return gamma(2*a + n) / (gamma(2*a) * gamma(n + 1))
+            elif x is S.Infinity:
+                if n.is_positive:
+                    return RisingFactorial(a, n) * S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            return gegenbauer_poly(n, a, x)
+
+    def fdiff(self, argindex=3):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt a
+            n, a, x = self.args
+            k = Dummy("k")
+            factor1 = 2 * (1 + (-1)**(n - k)) * (k + a) / ((k +
+                           n + 2*a) * (n - k))
+            factor2 = 2*(k + 1) / ((k + 2*a) * (2*k + 2*a + 1)) + \
+                2 / (k + n + 2*a)
+            kern = factor1*gegenbauer(k, a, x) + factor2*gegenbauer(n, a, x)
+            return Sum(kern, (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt x
+            n, a, x = self.args
+            return 2*a*gegenbauer(n - 1, a + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, a, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = ((-1)**k * RisingFactorial(a, n - k) * (2*x)**(n - 2*k) /
+                (factorial(k) * factorial(n - 2*k)))
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, a, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, a, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, a, x = self.args
+        return self.func(n, a.conjugate(), x.conjugate())
+
+#----------------------------------------------------------------------------
+# Chebyshev polynomials of first and second kind
+#
+
+
+class chebyshevt(OrthogonalPolynomial):
+    r"""
+    Chebyshev polynomial of the first kind, $T_n(x)$.
+
+    Explanation
+    ===========
+
+    ``chebyshevt(n, x)`` gives the $n$th Chebyshev polynomial (of the first
+    kind) in $x$, $T_n(x)$.
+
+    The Chebyshev polynomials of the first kind are orthogonal on
+    $[-1, 1]$ with respect to the weight $\frac{1}{\sqrt{1-x^2}}$.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevt, diff
+    >>> from sympy.abc import n,x
+    >>> chebyshevt(0, x)
+    1
+    >>> chebyshevt(1, x)
+    x
+    >>> chebyshevt(2, x)
+    2*x**2 - 1
+
+    >>> chebyshevt(n, x)
+    chebyshevt(n, x)
+    >>> chebyshevt(n, -x)
+    (-1)**n*chebyshevt(n, x)
+    >>> chebyshevt(-n, x)
+    chebyshevt(n, x)
+
+    >>> chebyshevt(n, 0)
+    cos(pi*n/2)
+    >>> chebyshevt(n, -1)
+    (-1)**n
+
+    >>> diff(chebyshevt(n, x), x)
+    n*chebyshevu(n - 1, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Chebyshev_polynomial
+    .. [2] https://mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html
+    .. [3] https://mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html
+    .. [4] https://functions.wolfram.com/Polynomials/ChebyshevT/
+    .. [5] https://functions.wolfram.com/Polynomials/ChebyshevU/
+
+    """
+
+    _ortho_poly = staticmethod(chebyshevt_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result T_n(x)
+            # T_n(-x)  --->  (-1)**n * T_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * chebyshevt(n, -x)
+            # T_{-n}(x)  --->  T_n(x)
+            if n.could_extract_minus_sign():
+                return chebyshevt(-n, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return cos(S.Half * S.Pi * n)
+            if x == S.One:
+                return S.One
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                # T_{-n}(x) == T_n(x)
+                return cls._eval_at_order(-n, x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return n * chebyshevu(n - 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = binomial(n, 2*k) * (x**2 - 1)**k * x**(n - 2*k)
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class chebyshevu(OrthogonalPolynomial):
+    r"""
+    Chebyshev polynomial of the second kind, $U_n(x)$.
+
+    Explanation
+    ===========
+
+    ``chebyshevu(n, x)`` gives the $n$th Chebyshev polynomial of the second
+    kind in x, $U_n(x)$.
+
+    The Chebyshev polynomials of the second kind are orthogonal on
+    $[-1, 1]$ with respect to the weight $\sqrt{1-x^2}$.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevu, diff
+    >>> from sympy.abc import n,x
+    >>> chebyshevu(0, x)
+    1
+    >>> chebyshevu(1, x)
+    2*x
+    >>> chebyshevu(2, x)
+    4*x**2 - 1
+
+    >>> chebyshevu(n, x)
+    chebyshevu(n, x)
+    >>> chebyshevu(n, -x)
+    (-1)**n*chebyshevu(n, x)
+    >>> chebyshevu(-n, x)
+    -chebyshevu(n - 2, x)
+
+    >>> chebyshevu(n, 0)
+    cos(pi*n/2)
+    >>> chebyshevu(n, 1)
+    n + 1
+
+    >>> diff(chebyshevu(n, x), x)
+    (-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Chebyshev_polynomial
+    .. [2] https://mathworld.wolfram.com/ChebyshevPolynomialoftheFirstKind.html
+    .. [3] https://mathworld.wolfram.com/ChebyshevPolynomialoftheSecondKind.html
+    .. [4] https://functions.wolfram.com/Polynomials/ChebyshevT/
+    .. [5] https://functions.wolfram.com/Polynomials/ChebyshevU/
+
+    """
+
+    _ortho_poly = staticmethod(chebyshevu_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result U_n(x)
+            # U_n(-x)  --->  (-1)**n * U_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * chebyshevu(n, -x)
+            # U_{-n}(x)  --->  -U_{n-2}(x)
+            if n.could_extract_minus_sign():
+                if n == S.NegativeOne:
+                    # n can not be -1 here
+                    return S.Zero
+                elif not (-n - 2).could_extract_minus_sign():
+                    return -chebyshevu(-n - 2, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return cos(S.Half * S.Pi * n)
+            if x == S.One:
+                return S.One + n
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                # U_{-n}(x)  --->  -U_{n-2}(x)
+                if n == S.NegativeOne:
+                    return S.Zero
+                else:
+                    return -cls._eval_at_order(-n - 2, x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return ((n + 1) * chebyshevt(n + 1, x) - x * chebyshevu(n, x)) / (x**2 - 1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k * factorial(
+            n - k) * (2*x)**(n - 2*k) / (factorial(k) * factorial(n - 2*k))
+        return Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class chebyshevt_root(DefinedFunction):
+    r"""
+    ``chebyshev_root(n, k)`` returns the $k$th root (indexed from zero) of
+    the $n$th Chebyshev polynomial of the first kind; that is, if
+    $0 \le k < n$, ``chebyshevt(n, chebyshevt_root(n, k)) == 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevt, chebyshevt_root
+    >>> chebyshevt_root(3, 2)
+    -sqrt(3)/2
+    >>> chebyshevt(3, chebyshevt_root(3, 2))
+    0
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+    """
+
+    @classmethod
+    def eval(cls, n, k):
+        if not ((0 <= k) and (k < n)):
+            raise ValueError("must have 0 <= k < n, "
+                "got k = %s and n = %s" % (k, n))
+        return cos(S.Pi*(2*k + 1)/(2*n))
+
+
+class chebyshevu_root(DefinedFunction):
+    r"""
+    ``chebyshevu_root(n, k)`` returns the $k$th root (indexed from zero) of the
+    $n$th Chebyshev polynomial of the second kind; that is, if $0 \le k < n$,
+    ``chebyshevu(n, chebyshevu_root(n, k)) == 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import chebyshevu, chebyshevu_root
+    >>> chebyshevu_root(3, 2)
+    -sqrt(2)/2
+    >>> chebyshevu(3, chebyshevu_root(3, 2))
+    0
+
+    See Also
+    ========
+
+    chebyshevt, chebyshevt_root, chebyshevu,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+    """
+
+
+    @classmethod
+    def eval(cls, n, k):
+        if not ((0 <= k) and (k < n)):
+            raise ValueError("must have 0 <= k < n, "
+                "got k = %s and n = %s" % (k, n))
+        return cos(S.Pi*(k + 1)/(n + 1))
+
+#----------------------------------------------------------------------------
+# Legendre polynomials and Associated Legendre polynomials
+#
+
+
+class legendre(OrthogonalPolynomial):
+    r"""
+    ``legendre(n, x)`` gives the $n$th Legendre polynomial of $x$, $P_n(x)$
+
+    Explanation
+    ===========
+
+    The Legendre polynomials are orthogonal on $[-1, 1]$ with respect to
+    the constant weight 1. They satisfy $P_n(1) = 1$ for all $n$; further,
+    $P_n$ is odd for odd $n$ and even for even $n$.
+
+    Examples
+    ========
+
+    >>> from sympy import legendre, diff
+    >>> from sympy.abc import x, n
+    >>> legendre(0, x)
+    1
+    >>> legendre(1, x)
+    x
+    >>> legendre(2, x)
+    3*x**2/2 - 1/2
+    >>> legendre(n, x)
+    legendre(n, x)
+    >>> diff(legendre(n,x), x)
+    n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    assoc_legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Legendre_polynomial
+    .. [2] https://mathworld.wolfram.com/LegendrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LegendreP/
+    .. [4] https://functions.wolfram.com/Polynomials/LegendreP2/
+
+    """
+
+    _ortho_poly = staticmethod(legendre_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result L_n(x)
+            # L_n(-x)  --->  (-1)**n * L_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * legendre(n, -x)
+            # L_{-n}(x)  --->  L_{n-1}(x)
+            if n.could_extract_minus_sign() and not(-n - 1).could_extract_minus_sign():
+                return legendre(-n - S.One, x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return sqrt(S.Pi)/(gamma(S.Half - n/2)*gamma(S.One + n/2))
+            elif x == S.One:
+                return S.One
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial;
+            # L_{-n}(x)  --->  L_{n-1}(x)
+            if n.is_negative:
+                n = -n - S.One
+            return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            # Find better formula, this is unsuitable for x = +/-1
+            # https://www.autodiff.org/ad16/Oral/Buecker_Legendre.pdf says
+            # at x = 1:
+            #    n*(n + 1)/2            , m = 0
+            #    oo                     , m = 1
+            #    -(n-1)*n*(n+1)*(n+2)/4 , m = 2
+            #    0                      , m = 3, 4, ..., n
+            #
+            # at x = -1
+            #    (-1)**(n+1)*n*(n + 1)/2       , m = 0
+            #    (-1)**n*oo                    , m = 1
+            #    (-1)**n*(n-1)*n*(n+1)*(n+2)/4 , m = 2
+            #    0                             , m = 3, 4, ..., n
+            n, x = self.args
+            return n/(x**2 - 1)*(x*legendre(n, x) - legendre(n - 1, x))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k*binomial(n, k)**2*((1 + x)/2)**(n - k)*((1 - x)/2)**k
+        return Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class assoc_legendre(DefinedFunction):
+    r"""
+    ``assoc_legendre(n, m, x)`` gives $P_n^m(x)$, where $n$ and $m$ are
+    the degree and order or an expression which is related to the nth
+    order Legendre polynomial, $P_n(x)$ in the following manner:
+
+    .. math::
+        P_n^m(x) = (-1)^m (1 - x^2)^{\frac{m}{2}}
+                   \frac{\mathrm{d}^m P_n(x)}{\mathrm{d} x^m}
+
+    Explanation
+    ===========
+
+    Associated Legendre polynomials are orthogonal on $[-1, 1]$ with:
+
+    - weight $= 1$            for the same $m$ and different $n$.
+    - weight $= \frac{1}{1-x^2}$   for the same $n$ and different $m$.
+
+    Examples
+    ========
+
+    >>> from sympy import assoc_legendre
+    >>> from sympy.abc import x, m, n
+    >>> assoc_legendre(0,0, x)
+    1
+    >>> assoc_legendre(1,0, x)
+    x
+    >>> assoc_legendre(1,1, x)
+    -sqrt(1 - x**2)
+    >>> assoc_legendre(n,m,x)
+    assoc_legendre(n, m, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre,
+    hermite, hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Associated_Legendre_polynomials
+    .. [2] https://mathworld.wolfram.com/LegendrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LegendreP/
+    .. [4] https://functions.wolfram.com/Polynomials/LegendreP2/
+
+    """
+
+    @classmethod
+    def _eval_at_order(cls, n, m):
+        P = legendre_poly(n, _x, polys=True).diff((_x, m))
+        return S.NegativeOne**m * (1 - _x**2)**Rational(m, 2) * P.as_expr()
+
+    @classmethod
+    def eval(cls, n, m, x):
+        if m.could_extract_minus_sign():
+            # P^{-m}_n  --->  F * P^m_n
+            return S.NegativeOne**(-m) * (factorial(m + n)/factorial(n - m)) * assoc_legendre(n, -m, x)
+        if m == 0:
+            # P^0_n  --->  L_n
+            return legendre(n, x)
+        if x == 0:
+            return 2**m*sqrt(S.Pi) / (gamma((1 - m - n)/2)*gamma(1 - (m - n)/2))
+        if n.is_Number and m.is_Number and n.is_integer and m.is_integer:
+            if n.is_negative:
+                raise ValueError("%s : 1st index must be nonnegative integer (got %r)" % (cls, n))
+            if abs(m) > n:
+                raise ValueError("%s : abs('2nd index') must be <= '1st index' (got %r, %r)" % (cls, n, m))
+            return cls._eval_at_order(int(n), abs(int(m))).subs(_x, x)
+
+    def fdiff(self, argindex=3):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt m
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 3:
+            # Diff wrt x
+            # Find better formula, this is unsuitable for x = 1
+            n, m, x = self.args
+            return 1/(x**2 - 1)*(x*n*assoc_legendre(n, m, x) - (m + n)*assoc_legendre(n - 1, m, x))
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, m, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = factorial(2*n - 2*k)/(2**n*factorial(n - k)*factorial(
+            k)*factorial(n - 2*k - m))*S.NegativeOne**k*x**(n - m - 2*k)
+        return (1 - x**2)**(m/2) * Sum(kern, (k, 0, floor((n - m)*S.Half)))
+
+    def _eval_rewrite_as_polynomial(self, n, m, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, m, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, m, x = self.args
+        return self.func(n, m.conjugate(), x.conjugate())
+
+#----------------------------------------------------------------------------
+# Hermite polynomials
+#
+
+
+class hermite(OrthogonalPolynomial):
+    r"""
+    ``hermite(n, x)`` gives the $n$th Hermite polynomial in $x$, $H_n(x)$.
+
+    Explanation
+    ===========
+
+    The Hermite polynomials are orthogonal on $(-\infty, \infty)$
+    with respect to the weight $\exp\left(-x^2\right)$.
+
+    Examples
+    ========
+
+    >>> from sympy import hermite, diff
+    >>> from sympy.abc import x, n
+    >>> hermite(0, x)
+    1
+    >>> hermite(1, x)
+    2*x
+    >>> hermite(2, x)
+    4*x**2 - 2
+    >>> hermite(n, x)
+    hermite(n, x)
+    >>> diff(hermite(n,x), x)
+    2*n*hermite(n - 1, x)
+    >>> hermite(n, -x)
+    (-1)**n*hermite(n, x)
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite_prob,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_polynomial
+    .. [2] https://mathworld.wolfram.com/HermitePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/HermiteH/
+
+    """
+
+    _ortho_poly = staticmethod(hermite_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            # Symbolic result H_n(x)
+            # H_n(-x)  --->  (-1)**n * H_n(x)
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * hermite(n, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return 2**n * sqrt(S.Pi) / gamma((S.One - n)/2)
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                raise ValueError(
+                    "The index n must be nonnegative integer (got %r)" % n)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return 2*n*hermite(n - 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = S.NegativeOne**k / (factorial(k)*factorial(n - 2*k)) * (2*x)**(n - 2*k)
+        return factorial(n)*Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+    def _eval_rewrite_as_hermite_prob(self, n, x, **kwargs):
+        return sqrt(2)**n * hermite_prob(n, x*sqrt(2))
+
+
+class hermite_prob(OrthogonalPolynomial):
+    r"""
+    ``hermite_prob(n, x)`` gives the $n$th probabilist's Hermite polynomial
+    in $x$, $He_n(x)$.
+
+    Explanation
+    ===========
+
+    The probabilist's Hermite polynomials are orthogonal on $(-\infty, \infty)$
+    with respect to the weight $\exp\left(-\frac{x^2}{2}\right)$. They are monic
+    polynomials, related to the plain Hermite polynomials (:py:class:`~.hermite`) by
+
+    .. math :: He_n(x) = 2^{-n/2} H_n(x/\sqrt{2})
+
+    Examples
+    ========
+
+    >>> from sympy import hermite_prob, diff, I
+    >>> from sympy.abc import x, n
+    >>> hermite_prob(1, x)
+    x
+    >>> hermite_prob(5, x)
+    x**5 - 10*x**3 + 15*x
+    >>> diff(hermite_prob(n,x), x)
+    n*hermite_prob(n - 1, x)
+    >>> hermite_prob(n, -x)
+    (-1)**n*hermite_prob(n, x)
+
+    The sum of absolute values of coefficients of $He_n(x)$ is the number of
+    matchings in the complete graph $K_n$ or telephone number, A000085 in the OEIS:
+
+    >>> [hermite_prob(n,I) / I**n for n in range(11)]
+    [1, 1, 2, 4, 10, 26, 76, 232, 764, 2620, 9496]
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite,
+    laguerre, assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Hermite_polynomial
+    .. [2] https://mathworld.wolfram.com/HermitePolynomial.html
+    """
+
+    _ortho_poly = staticmethod(hermite_prob_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if not n.is_Number:
+            if x.could_extract_minus_sign():
+                return S.NegativeOne**n * hermite_prob(n, -x)
+            if x.is_zero:
+                return sqrt(S.Pi) / gamma((S.One-n) / 2)
+            elif x is S.Infinity:
+                return S.Infinity
+        else:
+            if n.is_negative:
+                ValueError("n must be a nonnegative integer, not %r" % n)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 2:
+            n, x = self.args
+            return n*hermite_prob(n-1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        k = Dummy("k")
+        kern = (-S.Half)**k * x**(n-2*k) / (factorial(k) * factorial(n-2*k))
+        return factorial(n)*Sum(kern, (k, 0, floor(n/2)))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+    def _eval_rewrite_as_hermite(self, n, x, **kwargs):
+        return sqrt(2)**(-n) * hermite(n, x/sqrt(2))
+
+
+#----------------------------------------------------------------------------
+# Laguerre polynomials
+#
+
+
+class laguerre(OrthogonalPolynomial):
+    r"""
+    Returns the $n$th Laguerre polynomial in $x$, $L_n(x)$.
+
+    Examples
+    ========
+
+    >>> from sympy import laguerre, diff
+    >>> from sympy.abc import x, n
+    >>> laguerre(0, x)
+    1
+    >>> laguerre(1, x)
+    1 - x
+    >>> laguerre(2, x)
+    x**2/2 - 2*x + 1
+    >>> laguerre(3, x)
+    -x**3/6 + 3*x**2/2 - 3*x + 1
+
+    >>> laguerre(n, x)
+    laguerre(n, x)
+
+    >>> diff(laguerre(n, x), x)
+    -assoc_laguerre(n - 1, 1, x)
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of Laguerre polynomial. Must be `n \ge 0`.
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    assoc_laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Laguerre_polynomial
+    .. [2] https://mathworld.wolfram.com/LaguerrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LaguerreL/
+    .. [4] https://functions.wolfram.com/Polynomials/LaguerreL3/
+
+    """
+
+    _ortho_poly = staticmethod(laguerre_poly)
+
+    @classmethod
+    def eval(cls, n, x):
+        if n.is_integer is False:
+            raise ValueError("Error: n should be an integer.")
+        if not n.is_Number:
+            # Symbolic result L_n(x)
+            # L_{n}(-x)  --->  exp(-x) * L_{-n-1}(x)
+            # L_{-n}(x)  --->  exp(x) * L_{n-1}(-x)
+            if n.could_extract_minus_sign() and not(-n - 1).could_extract_minus_sign():
+                return exp(x)*laguerre(-n - 1, -x)
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return S.One
+            elif x is S.NegativeInfinity:
+                return S.Infinity
+            elif x is S.Infinity:
+                return S.NegativeOne**n * S.Infinity
+        else:
+            if n.is_negative:
+                return exp(x)*laguerre(-n - 1, -x)
+            else:
+                return cls._eval_at_order(n, x)
+
+    def fdiff(self, argindex=2):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt x
+            n, x = self.args
+            return -assoc_laguerre(n - 1, 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N_0
+        if n.is_negative:
+            return exp(x) * self._eval_rewrite_as_Sum(-n - 1, -x, **kwargs)
+        if n.is_integer is False:
+            raise ValueError("Error: n should be an integer.")
+        k = Dummy("k")
+        kern = RisingFactorial(-n, k) / factorial(k)**2 * x**k
+        return Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, x, **kwargs)
+
+
+class assoc_laguerre(OrthogonalPolynomial):
+    r"""
+    Returns the $n$th generalized Laguerre polynomial in $x$, $L_n(x)$.
+
+    Examples
+    ========
+
+    >>> from sympy import assoc_laguerre, diff
+    >>> from sympy.abc import x, n, a
+    >>> assoc_laguerre(0, a, x)
+    1
+    >>> assoc_laguerre(1, a, x)
+    a - x + 1
+    >>> assoc_laguerre(2, a, x)
+    a**2/2 + 3*a/2 + x**2/2 + x*(-a - 2) + 1
+    >>> assoc_laguerre(3, a, x)
+    a**3/6 + a**2 + 11*a/6 - x**3/6 + x**2*(a/2 + 3/2) +
+        x*(-a**2/2 - 5*a/2 - 3) + 1
+
+    >>> assoc_laguerre(n, a, 0)
+    binomial(a + n, a)
+
+    >>> assoc_laguerre(n, a, x)
+    assoc_laguerre(n, a, x)
+
+    >>> assoc_laguerre(n, 0, x)
+    laguerre(n, x)
+
+    >>> diff(assoc_laguerre(n, a, x), x)
+    -assoc_laguerre(n - 1, a + 1, x)
+
+    >>> diff(assoc_laguerre(n, a, x), a)
+    Sum(assoc_laguerre(_k, a, x)/(-a + n), (_k, 0, n - 1))
+
+    Parameters
+    ==========
+
+    n : int
+        Degree of Laguerre polynomial. Must be `n \ge 0`.
+
+    alpha : Expr
+        Arbitrary expression. For ``alpha=0`` regular Laguerre
+        polynomials will be generated.
+
+    See Also
+    ========
+
+    jacobi, gegenbauer,
+    chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root,
+    legendre, assoc_legendre,
+    hermite, hermite_prob,
+    laguerre,
+    sympy.polys.orthopolys.jacobi_poly
+    sympy.polys.orthopolys.gegenbauer_poly
+    sympy.polys.orthopolys.chebyshevt_poly
+    sympy.polys.orthopolys.chebyshevu_poly
+    sympy.polys.orthopolys.hermite_poly
+    sympy.polys.orthopolys.hermite_prob_poly
+    sympy.polys.orthopolys.legendre_poly
+    sympy.polys.orthopolys.laguerre_poly
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Laguerre_polynomial#Generalized_Laguerre_polynomials
+    .. [2] https://mathworld.wolfram.com/AssociatedLaguerrePolynomial.html
+    .. [3] https://functions.wolfram.com/Polynomials/LaguerreL/
+    .. [4] https://functions.wolfram.com/Polynomials/LaguerreL3/
+
+    """
+
+    @classmethod
+    def eval(cls, n, alpha, x):
+        # L_{n}^{0}(x)  --->  L_{n}(x)
+        if alpha.is_zero:
+            return laguerre(n, x)
+
+        if not n.is_Number:
+            # We can evaluate for some special values of x
+            if x.is_zero:
+                return binomial(n + alpha, alpha)
+            elif x is S.Infinity and n > 0:
+                return S.NegativeOne**n * S.Infinity
+            elif x is S.NegativeInfinity and n > 0:
+                return S.Infinity
+        else:
+            # n is a given fixed integer, evaluate into polynomial
+            if n.is_negative:
+                raise ValueError(
+                    "The index n must be nonnegative integer (got %r)" % n)
+            else:
+                return laguerre_poly(n, x, alpha)
+
+    def fdiff(self, argindex=3):
+        from sympy.concrete.summations import Sum
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt alpha
+            n, alpha, x = self.args
+            k = Dummy("k")
+            return Sum(assoc_laguerre(k, alpha, x) / (n - alpha), (k, 0, n - 1))
+        elif argindex == 3:
+            # Diff wrt x
+            n, alpha, x = self.args
+            return -assoc_laguerre(n - 1, alpha + 1, x)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_Sum(self, n, alpha, x, **kwargs):
+        from sympy.concrete.summations import Sum
+        # Make sure n \in N_0
+        if n.is_negative or n.is_integer is False:
+            raise ValueError("Error: n should be a non-negative integer.")
+        k = Dummy("k")
+        kern = RisingFactorial(
+            -n, k) / (gamma(k + alpha + 1) * factorial(k)) * x**k
+        return gamma(n + alpha + 1) / factorial(n) * Sum(kern, (k, 0, n))
+
+    def _eval_rewrite_as_polynomial(self, n, alpha, x, **kwargs):
+        # This function is just kept for backwards compatibility
+        # but should not be used
+        return self._eval_rewrite_as_Sum(n, alpha, x, **kwargs)
+
+    def _eval_conjugate(self):
+        n, alpha, x = self.args
+        return self.func(n, alpha.conjugate(), x.conjugate())
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/singularity_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/singularity_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..a69026e6e657b1131880b47cb32202b6825b7158
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/singularity_functions.py
@@ -0,0 +1,235 @@
+from sympy.core import S, oo, diff
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Eq
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import Heaviside
+
+###############################################################################
+############################# SINGULARITY FUNCTION ############################
+###############################################################################
+
+
+class SingularityFunction(DefinedFunction):
+    r"""
+    Singularity functions are a class of discontinuous functions.
+
+    Explanation
+    ===========
+
+    Singularity functions take a variable, an offset, and an exponent as
+    arguments. These functions are represented using Macaulay brackets as:
+
+    SingularityFunction(x, a, n) := ^n
+
+    The singularity function will automatically evaluate to
+    ``Derivative(DiracDelta(x - a), x, -n - 1)`` if ``n < 0``
+    and ``(x - a)**n*Heaviside(x - a, 1)`` if ``n >= 0``.
+
+    Examples
+    ========
+
+    >>> from sympy import SingularityFunction, diff, Piecewise, DiracDelta, Heaviside, Symbol
+    >>> from sympy.abc import x, a, n
+    >>> SingularityFunction(x, a, n)
+    SingularityFunction(x, a, n)
+    >>> y = Symbol('y', positive=True)
+    >>> n = Symbol('n', nonnegative=True)
+    >>> SingularityFunction(y, -10, n)
+    (y + 10)**n
+    >>> y = Symbol('y', negative=True)
+    >>> SingularityFunction(y, 10, n)
+    0
+    >>> SingularityFunction(x, 4, -1).subs(x, 4)
+    oo
+    >>> SingularityFunction(x, 10, -2).subs(x, 10)
+    oo
+    >>> SingularityFunction(4, 1, 5)
+    243
+    >>> diff(SingularityFunction(x, 1, 5) + SingularityFunction(x, 1, 4), x)
+    4*SingularityFunction(x, 1, 3) + 5*SingularityFunction(x, 1, 4)
+    >>> diff(SingularityFunction(x, 4, 0), x, 2)
+    SingularityFunction(x, 4, -2)
+    >>> SingularityFunction(x, 4, 5).rewrite(Piecewise)
+    Piecewise(((x - 4)**5, x >= 4), (0, True))
+    >>> expr = SingularityFunction(x, a, n)
+    >>> y = Symbol('y', positive=True)
+    >>> n = Symbol('n', nonnegative=True)
+    >>> expr.subs({x: y, a: -10, n: n})
+    (y + 10)**n
+
+    The methods ``rewrite(DiracDelta)``, ``rewrite(Heaviside)``, and
+    ``rewrite('HeavisideDiracDelta')`` returns the same output. One can use any
+    of these methods according to their choice.
+
+    >>> expr = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
+    >>> expr.rewrite(Heaviside)
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    >>> expr.rewrite(DiracDelta)
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    >>> expr.rewrite('HeavisideDiracDelta')
+    (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+
+    See Also
+    ========
+
+    DiracDelta, Heaviside
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Singularity_function
+
+    """
+
+    is_real = True
+
+    def fdiff(self, argindex=1):
+        """
+        Returns the first derivative of a DiracDelta Function.
+
+        Explanation
+        ===========
+
+        The difference between ``diff()`` and ``fdiff()`` is: ``diff()`` is the
+        user-level function and ``fdiff()`` is an object method. ``fdiff()`` is
+        a convenience method available in the ``Function`` class. It returns
+        the derivative of the function without considering the chain rule.
+        ``diff(function, x)`` calls ``Function._eval_derivative`` which in turn
+        calls ``fdiff()`` internally to compute the derivative of the function.
+
+        """
+
+        if argindex == 1:
+            x, a, n = self.args
+            if n in (S.Zero, S.NegativeOne, S(-2), S(-3)):
+                return self.func(x, a, n-1)
+            elif n.is_positive:
+                return n*self.func(x, a, n-1)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    @classmethod
+    def eval(cls, variable, offset, exponent):
+        """
+        Returns a simplified form or a value of Singularity Function depending
+        on the argument passed by the object.
+
+        Explanation
+        ===========
+
+        The ``eval()`` method is automatically called when the
+        ``SingularityFunction`` class is about to be instantiated and it
+        returns either some simplified instance or the unevaluated instance
+        depending on the argument passed. In other words, ``eval()`` method is
+        not needed to be called explicitly, it is being called and evaluated
+        once the object is called.
+
+        Examples
+        ========
+
+        >>> from sympy import SingularityFunction, Symbol, nan
+        >>> from sympy.abc import x, a, n
+        >>> SingularityFunction(x, a, n)
+        SingularityFunction(x, a, n)
+        >>> SingularityFunction(5, 3, 2)
+        4
+        >>> SingularityFunction(x, a, nan)
+        nan
+        >>> SingularityFunction(x, 3, 0).subs(x, 3)
+        1
+        >>> SingularityFunction(4, 1, 5)
+        243
+        >>> x = Symbol('x', positive = True)
+        >>> a = Symbol('a', negative = True)
+        >>> n = Symbol('n', nonnegative = True)
+        >>> SingularityFunction(x, a, n)
+        (-a + x)**n
+        >>> x = Symbol('x', negative = True)
+        >>> a = Symbol('a', positive = True)
+        >>> SingularityFunction(x, a, n)
+        0
+
+        """
+
+        x = variable
+        a = offset
+        n = exponent
+        shift = (x - a)
+
+        if fuzzy_not(im(shift).is_zero):
+            raise ValueError("Singularity Functions are defined only for Real Numbers.")
+        if fuzzy_not(im(n).is_zero):
+            raise ValueError("Singularity Functions are not defined for imaginary exponents.")
+        if shift is S.NaN or n is S.NaN:
+            return S.NaN
+        if (n + 4).is_negative:
+            raise ValueError("Singularity Functions are not defined for exponents less than -4.")
+        if shift.is_extended_negative:
+            return S.Zero
+        if n.is_nonnegative:
+            if shift.is_zero:  # use literal 0 in case of Symbol('z', zero=True)
+                return S.Zero**n
+            if shift.is_extended_nonnegative:
+                return shift**n
+        if n in (S.NegativeOne, -2, -3, -4):
+            if shift.is_negative or shift.is_extended_positive:
+                return S.Zero
+            if shift.is_zero:
+                return oo
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        '''
+        Converts a Singularity Function expression into its Piecewise form.
+
+        '''
+        x, a, n = self.args
+
+        if n in (S.NegativeOne, S(-2), S(-3), S(-4)):
+            return Piecewise((oo, Eq(x - a, 0)), (0, True))
+        elif n.is_nonnegative:
+            return Piecewise(((x - a)**n, x - a >= 0), (0, True))
+
+    def _eval_rewrite_as_Heaviside(self, *args, **kwargs):
+        '''
+        Rewrites a Singularity Function expression using Heavisides and DiracDeltas.
+
+        '''
+        x, a, n = self.args
+
+        if n == -4:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 4)
+        if n == -3:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 3)
+        if n == -2:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 2)
+        if n == -1:
+            return diff(Heaviside(x - a), x.free_symbols.pop(), 1)
+        if n.is_nonnegative:
+            return (x - a)**n*Heaviside(x - a, 1)
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        z, a, n = self.args
+        shift = (z - a).subs(x, 0)
+        if n < 0:
+            return S.Zero
+        elif n.is_zero and shift.is_zero:
+            return S.Zero if cdir == -1 else S.One
+        elif shift.is_positive:
+            return shift**n
+        return S.Zero
+
+    def _eval_nseries(self, x, n, logx=None, cdir=0):
+        z, a, n = self.args
+        shift = (z - a).subs(x, 0)
+        if n < 0:
+            return S.Zero
+        elif n.is_zero and shift.is_zero:
+            return S.Zero if cdir == -1 else S.One
+        elif shift.is_positive:
+            return ((z - a)**n)._eval_nseries(x, n, logx=logx, cdir=cdir)
+        return S.Zero
+
+    _eval_rewrite_as_DiracDelta = _eval_rewrite_as_Heaviside
+    _eval_rewrite_as_HeavisideDiracDelta = _eval_rewrite_as_Heaviside
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/spherical_harmonics.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/spherical_harmonics.py
new file mode 100644
index 0000000000000000000000000000000000000000..541546b75e882b43c41814b5e92bb85ee41628d1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/spherical_harmonics.py
@@ -0,0 +1,334 @@
+from sympy.core.expr import Expr
+from sympy.core.function import DefinedFunction, ArgumentIndexError
+from sympy.core.numbers import I, pi
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.functions import assoc_legendre
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.complexes import Abs, conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sin, cos, cot
+
+_x = Dummy("x")
+
+class Ynm(DefinedFunction):
+    r"""
+    Spherical harmonics defined as
+
+    .. math::
+        Y_n^m(\theta, \varphi) := \sqrt{\frac{(2n+1)(n-m)!}{4\pi(n+m)!}}
+                                  \exp(i m \varphi)
+                                  \mathrm{P}_n^m\left(\cos(\theta)\right)
+
+    Explanation
+    ===========
+
+    ``Ynm()`` gives the spherical harmonic function of order $n$ and $m$
+    in $\theta$ and $\varphi$, $Y_n^m(\theta, \varphi)$. The four
+    parameters are as follows: $n \geq 0$ an integer and $m$ an integer
+    such that $-n \leq m \leq n$ holds. The two angles are real-valued
+    with $\theta \in [0, \pi]$ and $\varphi \in [0, 2\pi]$.
+
+    Examples
+    ========
+
+    >>> from sympy import Ynm, Symbol, simplify
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> Ynm(n, m, theta, phi)
+    Ynm(n, m, theta, phi)
+
+    Several symmetries are known, for the order:
+
+    >>> Ynm(n, -m, theta, phi)
+    (-1)**m*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    As well as for the angles:
+
+    >>> Ynm(n, m, -theta, phi)
+    Ynm(n, m, theta, phi)
+
+    >>> Ynm(n, m, theta, -phi)
+    exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    For specific integers $n$ and $m$ we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Ynm(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+
+    >>> simplify(Ynm(1, -1, theta, phi).expand(func=True))
+    sqrt(6)*exp(-I*phi)*sin(theta)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(1, 0, theta, phi).expand(func=True))
+    sqrt(3)*cos(theta)/(2*sqrt(pi))
+
+    >>> simplify(Ynm(1, 1, theta, phi).expand(func=True))
+    -sqrt(6)*exp(I*phi)*sin(theta)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(2, -2, theta, phi).expand(func=True))
+    sqrt(30)*exp(-2*I*phi)*sin(theta)**2/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, -1, theta, phi).expand(func=True))
+    sqrt(30)*exp(-I*phi)*sin(2*theta)/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, 0, theta, phi).expand(func=True))
+    sqrt(5)*(3*cos(theta)**2 - 1)/(4*sqrt(pi))
+
+    >>> simplify(Ynm(2, 1, theta, phi).expand(func=True))
+    -sqrt(30)*exp(I*phi)*sin(2*theta)/(8*sqrt(pi))
+
+    >>> simplify(Ynm(2, 2, theta, phi).expand(func=True))
+    sqrt(30)*exp(2*I*phi)*sin(theta)**2/(8*sqrt(pi))
+
+    We can differentiate the functions with respect
+    to both angles:
+
+    >>> from sympy import Ynm, Symbol, diff
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> diff(Ynm(n, m, theta, phi), theta)
+    m*cot(theta)*Ynm(n, m, theta, phi) + sqrt((-m + n)*(m + n + 1))*exp(-I*phi)*Ynm(n, m + 1, theta, phi)
+
+    >>> diff(Ynm(n, m, theta, phi), phi)
+    I*m*Ynm(n, m, theta, phi)
+
+    Further we can compute the complex conjugation:
+
+    >>> from sympy import Ynm, Symbol, conjugate
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> conjugate(Ynm(n, m, theta, phi))
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    To get back the well known expressions in spherical
+    coordinates, we use full expansion:
+
+    >>> from sympy import Ynm, Symbol, expand_func
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+
+    >>> expand_func(Ynm(n, m, theta, phi))
+    sqrt((2*n + 1)*factorial(-m + n)/factorial(m + n))*exp(I*m*phi)*assoc_legendre(n, m, cos(theta))/(2*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm_c, Znm
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+    .. [4] https://dlmf.nist.gov/14.30
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, theta, phi):
+        # Handle negative index m and arguments theta, phi
+        if m.could_extract_minus_sign():
+            m = -m
+            return S.NegativeOne**m * exp(-2*I*m*phi) * Ynm(n, m, theta, phi)
+        if theta.could_extract_minus_sign():
+            theta = -theta
+            return Ynm(n, m, theta, phi)
+        if phi.could_extract_minus_sign():
+            phi = -phi
+            return exp(-2*I*m*phi) * Ynm(n, m, theta, phi)
+
+        # TODO Add more simplififcation here
+
+    def _eval_expand_func(self, **hints):
+        n, m, theta, phi = self.args
+        rv = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+                exp(I*m*phi) * assoc_legendre(n, m, cos(theta)))
+        # We can do this because of the range of theta
+        return rv.subs(sqrt(-cos(theta)**2 + 1), sin(theta))
+
+    def fdiff(self, argindex=4):
+        if argindex == 1:
+            # Diff wrt n
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 2:
+            # Diff wrt m
+            raise ArgumentIndexError(self, argindex)
+        elif argindex == 3:
+            # Diff wrt theta
+            n, m, theta, phi = self.args
+            return (m * cot(theta) * Ynm(n, m, theta, phi) +
+                    sqrt((n - m)*(n + m + 1)) * exp(-I*phi) * Ynm(n, m + 1, theta, phi))
+        elif argindex == 4:
+            # Diff wrt phi
+            n, m, theta, phi = self.args
+            return I * m * Ynm(n, m, theta, phi)
+        else:
+            raise ArgumentIndexError(self, argindex)
+
+    def _eval_rewrite_as_polynomial(self, n, m, theta, phi, **kwargs):
+        # TODO: Make sure n \in N
+        # TODO: Assert |m| <= n ortherwise we should return 0
+        return self.expand(func=True)
+
+    def _eval_rewrite_as_sin(self, n, m, theta, phi, **kwargs):
+        return self.rewrite(cos)
+
+    def _eval_rewrite_as_cos(self, n, m, theta, phi, **kwargs):
+        # This method can be expensive due to extensive use of simplification!
+        from sympy.simplify import simplify, trigsimp
+        # TODO: Make sure n \in N
+        # TODO: Assert |m| <= n ortherwise we should return 0
+        term = simplify(self.expand(func=True))
+        # We can do this because of the range of theta
+        term = term.xreplace({Abs(sin(theta)):sin(theta)})
+        return simplify(trigsimp(term))
+
+    def _eval_conjugate(self):
+        # TODO: Make sure theta \in R and phi \in R
+        n, m, theta, phi = self.args
+        return S.NegativeOne**m * self.func(n, -m, theta, phi)
+
+    def as_real_imag(self, deep=True, **hints):
+        # TODO: Handle deep and hints
+        n, m, theta, phi = self.args
+        re = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+              cos(m*phi) * assoc_legendre(n, m, cos(theta)))
+        im = (sqrt((2*n + 1)/(4*pi) * factorial(n - m)/factorial(n + m)) *
+              sin(m*phi) * assoc_legendre(n, m, cos(theta)))
+        return (re, im)
+
+    def _eval_evalf(self, prec):
+        # Note: works without this function by just calling
+        #       mpmath for Legendre polynomials. But using
+        #       the dedicated function directly is cleaner.
+        from mpmath import mp, workprec
+        n = self.args[0]._to_mpmath(prec)
+        m = self.args[1]._to_mpmath(prec)
+        theta = self.args[2]._to_mpmath(prec)
+        phi = self.args[3]._to_mpmath(prec)
+        with workprec(prec):
+            res = mp.spherharm(n, m, theta, phi)
+        return Expr._from_mpmath(res, prec)
+
+
+def Ynm_c(n, m, theta, phi):
+    r"""
+    Conjugate spherical harmonics defined as
+
+    .. math::
+        \overline{Y_n^m(\theta, \varphi)} := (-1)^m Y_n^{-m}(\theta, \varphi).
+
+    Examples
+    ========
+
+    >>> from sympy import Ynm_c, Symbol, simplify
+    >>> from sympy.abc import n,m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+    >>> Ynm_c(n, m, theta, phi)
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+    >>> Ynm_c(n, m, -theta, phi)
+    (-1)**(2*m)*exp(-2*I*m*phi)*Ynm(n, m, theta, phi)
+
+    For specific integers $n$ and $m$ we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Ynm_c(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+    >>> simplify(Ynm_c(1, -1, theta, phi).expand(func=True))
+    sqrt(6)*exp(I*(-phi + 2*conjugate(phi)))*sin(theta)/(4*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm, Znm
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+
+    """
+    return conjugate(Ynm(n, m, theta, phi))
+
+
+class Znm(DefinedFunction):
+    r"""
+    Real spherical harmonics defined as
+
+    .. math::
+
+        Z_n^m(\theta, \varphi) :=
+        \begin{cases}
+          \frac{Y_n^m(\theta, \varphi) + \overline{Y_n^m(\theta, \varphi)}}{\sqrt{2}} &\quad m > 0 \\
+          Y_n^m(\theta, \varphi) &\quad m = 0 \\
+          \frac{Y_n^m(\theta, \varphi) - \overline{Y_n^m(\theta, \varphi)}}{i \sqrt{2}} &\quad m < 0 \\
+        \end{cases}
+
+    which gives in simplified form
+
+    .. math::
+
+        Z_n^m(\theta, \varphi) =
+        \begin{cases}
+          \frac{Y_n^m(\theta, \varphi) + (-1)^m Y_n^{-m}(\theta, \varphi)}{\sqrt{2}} &\quad m > 0 \\
+          Y_n^m(\theta, \varphi) &\quad m = 0 \\
+          \frac{Y_n^m(\theta, \varphi) - (-1)^m Y_n^{-m}(\theta, \varphi)}{i \sqrt{2}} &\quad m < 0 \\
+        \end{cases}
+
+    Examples
+    ========
+
+    >>> from sympy import Znm, Symbol, simplify
+    >>> from sympy.abc import n, m
+    >>> theta = Symbol("theta")
+    >>> phi = Symbol("phi")
+    >>> Znm(n, m, theta, phi)
+    Znm(n, m, theta, phi)
+
+    For specific integers n and m we can evaluate the harmonics
+    to more useful expressions:
+
+    >>> simplify(Znm(0, 0, theta, phi).expand(func=True))
+    1/(2*sqrt(pi))
+    >>> simplify(Znm(1, 1, theta, phi).expand(func=True))
+    -sqrt(3)*sin(theta)*cos(phi)/(2*sqrt(pi))
+    >>> simplify(Znm(2, 1, theta, phi).expand(func=True))
+    -sqrt(15)*sin(2*theta)*cos(phi)/(4*sqrt(pi))
+
+    See Also
+    ========
+
+    Ynm, Ynm_c
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Spherical_harmonics
+    .. [2] https://mathworld.wolfram.com/SphericalHarmonic.html
+    .. [3] https://functions.wolfram.com/Polynomials/SphericalHarmonicY/
+
+    """
+
+    @classmethod
+    def eval(cls, n, m, theta, phi):
+        if m.is_positive:
+            zz = (Ynm(n, m, theta, phi) + Ynm_c(n, m, theta, phi)) / sqrt(2)
+            return zz
+        elif m.is_zero:
+            return Ynm(n, m, theta, phi)
+        elif m.is_negative:
+            zz = (Ynm(n, m, theta, phi) - Ynm_c(n, m, theta, phi)) / (sqrt(2)*I)
+            return zz
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tensor_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tensor_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d996a58cbc8320620c9a1f6e68529c3b5e99aef
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tensor_functions.py
@@ -0,0 +1,474 @@
+from math import prod
+
+from sympy.core import S, Integer
+from sympy.core.function import DefinedFunction
+from sympy.core.logic import fuzzy_not
+from sympy.core.relational import Ne
+from sympy.core.sorting import default_sort_key
+from sympy.external.gmpy import SYMPY_INTS
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.utilities.iterables import has_dups
+
+###############################################################################
+###################### Kronecker Delta, Levi-Civita etc. ######################
+###############################################################################
+
+
+def Eijk(*args, **kwargs):
+    """
+    Represent the Levi-Civita symbol.
+
+    This is a compatibility wrapper to ``LeviCivita()``.
+
+    See Also
+    ========
+
+    LeviCivita
+
+    """
+    return LeviCivita(*args, **kwargs)
+
+
+def eval_levicivita(*args):
+    """Evaluate Levi-Civita symbol."""
+    n = len(args)
+    return prod(
+        prod(args[j] - args[i] for j in range(i + 1, n))
+        / factorial(i) for i in range(n))
+    # converting factorial(i) to int is slightly faster
+
+
+class LeviCivita(DefinedFunction):
+    """
+    Represent the Levi-Civita symbol.
+
+    Explanation
+    ===========
+
+    For even permutations of indices it returns 1, for odd permutations -1, and
+    for everything else (a repeated index) it returns 0.
+
+    Thus it represents an alternating pseudotensor.
+
+    Examples
+    ========
+
+    >>> from sympy import LeviCivita
+    >>> from sympy.abc import i, j, k
+    >>> LeviCivita(1, 2, 3)
+    1
+    >>> LeviCivita(1, 3, 2)
+    -1
+    >>> LeviCivita(1, 2, 2)
+    0
+    >>> LeviCivita(i, j, k)
+    LeviCivita(i, j, k)
+    >>> LeviCivita(i, j, i)
+    0
+
+    See Also
+    ========
+
+    Eijk
+
+    """
+
+    is_integer = True
+
+    @classmethod
+    def eval(cls, *args):
+        if all(isinstance(a, (SYMPY_INTS, Integer)) for a in args):
+            return eval_levicivita(*args)
+        if has_dups(args):
+            return S.Zero
+
+    def doit(self, **hints):
+        return eval_levicivita(*self.args)
+
+
+class KroneckerDelta(DefinedFunction):
+    """
+    The discrete, or Kronecker, delta function.
+
+    Explanation
+    ===========
+
+    A function that takes in two integers $i$ and $j$. It returns $0$ if $i$
+    and $j$ are not equal, or it returns $1$ if $i$ and $j$ are equal.
+
+    Examples
+    ========
+
+    An example with integer indices:
+
+        >>> from sympy import KroneckerDelta
+        >>> KroneckerDelta(1, 2)
+        0
+        >>> KroneckerDelta(3, 3)
+        1
+
+    Symbolic indices:
+
+        >>> from sympy.abc import i, j, k
+        >>> KroneckerDelta(i, j)
+        KroneckerDelta(i, j)
+        >>> KroneckerDelta(i, i)
+        1
+        >>> KroneckerDelta(i, i + 1)
+        0
+        >>> KroneckerDelta(i, i + 1 + k)
+        KroneckerDelta(i, i + k + 1)
+
+    Parameters
+    ==========
+
+    i : Number, Symbol
+        The first index of the delta function.
+    j : Number, Symbol
+        The second index of the delta function.
+
+    See Also
+    ========
+
+    eval
+    DiracDelta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Kronecker_delta
+
+    """
+
+    is_integer = True
+
+    @classmethod
+    def eval(cls, i, j, delta_range=None):
+        """
+        Evaluates the discrete delta function.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta
+        >>> from sympy.abc import i, j, k
+
+        >>> KroneckerDelta(i, j)
+        KroneckerDelta(i, j)
+        >>> KroneckerDelta(i, i)
+        1
+        >>> KroneckerDelta(i, i + 1)
+        0
+        >>> KroneckerDelta(i, i + 1 + k)
+        KroneckerDelta(i, i + k + 1)
+
+        # indirect doctest
+
+        """
+
+        if delta_range is not None:
+            dinf, dsup = delta_range
+            if (dinf - i > 0) == True:
+                return S.Zero
+            if (dinf - j > 0) == True:
+                return S.Zero
+            if (dsup - i < 0) == True:
+                return S.Zero
+            if (dsup - j < 0) == True:
+                return S.Zero
+
+        diff = i - j
+        if diff.is_zero:
+            return S.One
+        elif fuzzy_not(diff.is_zero):
+            return S.Zero
+
+        if i.assumptions0.get("below_fermi") and \
+                j.assumptions0.get("above_fermi"):
+            return S.Zero
+        if j.assumptions0.get("below_fermi") and \
+                i.assumptions0.get("above_fermi"):
+            return S.Zero
+        # to make KroneckerDelta canonical
+        # following lines will check if inputs are in order
+        # if not, will return KroneckerDelta with correct order
+        if default_sort_key(j) < default_sort_key(i):
+            if delta_range:
+                return cls(j, i, delta_range)
+            else:
+                return cls(j, i)
+
+    @property
+    def delta_range(self):
+        if len(self.args) > 2:
+            return self.args[2]
+
+    def _eval_power(self, expt):
+        if expt.is_positive:
+            return self
+        if expt.is_negative and expt is not S.NegativeOne:
+            return 1/self
+
+    @property
+    def is_above_fermi(self):
+        """
+        True if Delta can be non-zero above fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_above_fermi
+        True
+        >>> KroneckerDelta(p, i).is_above_fermi
+        False
+        >>> KroneckerDelta(p, q).is_above_fermi
+        True
+
+        See Also
+        ========
+
+        is_below_fermi, is_only_below_fermi, is_only_above_fermi
+
+        """
+        if self.args[0].assumptions0.get("below_fermi"):
+            return False
+        if self.args[1].assumptions0.get("below_fermi"):
+            return False
+        return True
+
+    @property
+    def is_below_fermi(self):
+        """
+        True if Delta can be non-zero below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_below_fermi
+        False
+        >>> KroneckerDelta(p, i).is_below_fermi
+        True
+        >>> KroneckerDelta(p, q).is_below_fermi
+        True
+
+        See Also
+        ========
+
+        is_above_fermi, is_only_above_fermi, is_only_below_fermi
+
+        """
+        if self.args[0].assumptions0.get("above_fermi"):
+            return False
+        if self.args[1].assumptions0.get("above_fermi"):
+            return False
+        return True
+
+    @property
+    def is_only_above_fermi(self):
+        """
+        True if Delta is restricted to above fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, a).is_only_above_fermi
+        True
+        >>> KroneckerDelta(p, q).is_only_above_fermi
+        False
+        >>> KroneckerDelta(p, i).is_only_above_fermi
+        False
+
+        See Also
+        ========
+
+        is_above_fermi, is_below_fermi, is_only_below_fermi
+
+        """
+        return ( self.args[0].assumptions0.get("above_fermi")
+                or
+                self.args[1].assumptions0.get("above_fermi")
+                ) or False
+
+    @property
+    def is_only_below_fermi(self):
+        """
+        True if Delta is restricted to below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, i).is_only_below_fermi
+        True
+        >>> KroneckerDelta(p, q).is_only_below_fermi
+        False
+        >>> KroneckerDelta(p, a).is_only_below_fermi
+        False
+
+        See Also
+        ========
+
+        is_above_fermi, is_below_fermi, is_only_above_fermi
+
+        """
+        return ( self.args[0].assumptions0.get("below_fermi")
+                or
+                self.args[1].assumptions0.get("below_fermi")
+                ) or False
+
+    @property
+    def indices_contain_equal_information(self):
+        """
+        Returns True if indices are either both above or below fermi.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> q = Symbol('q')
+        >>> KroneckerDelta(p, q).indices_contain_equal_information
+        True
+        >>> KroneckerDelta(p, q+1).indices_contain_equal_information
+        True
+        >>> KroneckerDelta(i, p).indices_contain_equal_information
+        False
+
+        """
+        if (self.args[0].assumptions0.get("below_fermi") and
+                self.args[1].assumptions0.get("below_fermi")):
+            return True
+        if (self.args[0].assumptions0.get("above_fermi")
+                and self.args[1].assumptions0.get("above_fermi")):
+            return True
+
+        # if both indices are general we are True, else false
+        return self.is_below_fermi and self.is_above_fermi
+
+    @property
+    def preferred_index(self):
+        """
+        Returns the index which is preferred to keep in the final expression.
+
+        Explanation
+        ===========
+
+        The preferred index is the index with more information regarding fermi
+        level. If indices contain the same information, 'a' is preferred before
+        'b'.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> j = Symbol('j', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> KroneckerDelta(p, i).preferred_index
+        i
+        >>> KroneckerDelta(p, a).preferred_index
+        a
+        >>> KroneckerDelta(i, j).preferred_index
+        i
+
+        See Also
+        ========
+
+        killable_index
+
+        """
+        if self._get_preferred_index():
+            return self.args[1]
+        else:
+            return self.args[0]
+
+    @property
+    def killable_index(self):
+        """
+        Returns the index which is preferred to substitute in the final
+        expression.
+
+        Explanation
+        ===========
+
+        The index to substitute is the index with less information regarding
+        fermi level. If indices contain the same information, 'a' is preferred
+        before 'b'.
+
+        Examples
+        ========
+
+        >>> from sympy import KroneckerDelta, Symbol
+        >>> a = Symbol('a', above_fermi=True)
+        >>> i = Symbol('i', below_fermi=True)
+        >>> j = Symbol('j', below_fermi=True)
+        >>> p = Symbol('p')
+        >>> KroneckerDelta(p, i).killable_index
+        p
+        >>> KroneckerDelta(p, a).killable_index
+        p
+        >>> KroneckerDelta(i, j).killable_index
+        j
+
+        See Also
+        ========
+
+        preferred_index
+
+        """
+        if self._get_preferred_index():
+            return self.args[0]
+        else:
+            return self.args[1]
+
+    def _get_preferred_index(self):
+        """
+        Returns the index which is preferred to keep in the final expression.
+
+        The preferred index is the index with more information regarding fermi
+        level. If indices contain the same information, index 0 is returned.
+
+        """
+        if not self.is_above_fermi:
+            if self.args[0].assumptions0.get("below_fermi"):
+                return 0
+            else:
+                return 1
+        elif not self.is_below_fermi:
+            if self.args[0].assumptions0.get("above_fermi"):
+                return 0
+            else:
+                return 1
+        else:
+            return 0
+
+    @property
+    def indices(self):
+        return self.args[0:2]
+
+    def _eval_rewrite_as_Piecewise(self, *args, **kwargs):
+        i, j = args
+        return Piecewise((0, Ne(i, j)), (1, True))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a9aedfc82ef4e1b99ccb226205d3eaf76052502c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bessel.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bessel.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4504db993e936e662a3505a23e0ccba2cf72d2b0
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bessel.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_beta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_beta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61bcee8ed16e0575ada7a08b54c828f815946791
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_beta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bsplines.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bsplines.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..51e01680e818d6c9b7d985c3f7240acc85169f82
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_bsplines.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_delta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_delta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca2c03c3c35e2a7acbb976a30dfcd079a0a3941c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_delta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_elliptic_integrals.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_elliptic_integrals.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9df005a2b79806767446234b4847002b41946ce3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_elliptic_integrals.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2343d4a224dc0d74f2a0827f01e324c3728e2c2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_error_functions.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b08e16f85e8f30a8d14d743525597b1fea01af7a49688c65dfcb3392daecacb6
+size 101483
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_gamma_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_gamma_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3aeb16701c4d7f6e6d6107f4ff034004f06c1a1e
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_gamma_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_hyper.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_hyper.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f551200157c793fb64bc5eb00ceb3893fc5026be
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_hyper.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_mathieu.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_mathieu.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..26f9a650b6aec41482ddc817a19234aee5ba675b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_mathieu.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_singularity_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_singularity_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c32f0a7a2aa4d5c77ff3461b4835dc00d60e9d7
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_singularity_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spec_polynomials.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spec_polynomials.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e535f5f1b63168d42a7ddfea07da55e1e3f886f3
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spec_polynomials.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spherical_harmonics.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spherical_harmonics.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c340dacaa662f5522f7db6aecc030a6643c08198
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_spherical_harmonics.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_tensor_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_tensor_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f689c3c8f0680db53b9e068376d0f43710d73c41
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_tensor_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_zeta_functions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_zeta_functions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c78bcc98343a9bc8dc099718984a6c8562680ae
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/__pycache__/test_zeta_functions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bessel.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bessel.py
new file mode 100644
index 0000000000000000000000000000000000000000..ccd1ce88ca9dea15f065e7c57d488498b8f79f4e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bessel.py
@@ -0,0 +1,807 @@
+from itertools import product
+
+from sympy.concrete.summations import Sum
+from sympy.core.function import (diff, expand_func)
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (conjugate, polar_lift)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.bessel import (besseli, besselj, besselk, bessely, hankel1, hankel2, hn1, hn2, jn, jn_zeros, yn)
+from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O
+from sympy.series.series import series
+from sympy.functions.special.bessel import (airyai, airybi,
+                                            airyaiprime, airybiprime, marcumq)
+from sympy.core.random import (random_complex_number as randcplx,
+                                      verify_numerically as tn,
+                                      test_derivative_numerically as td,
+                                      _randint)
+from sympy.simplify import besselsimp
+from sympy.testing.pytest import raises, slow
+
+from sympy.abc import z, n, k, x
+
+randint = _randint()
+
+
+def test_bessel_rand():
+    for f in [besselj, bessely, besseli, besselk, hankel1, hankel2]:
+        assert td(f(randcplx(), z), z)
+
+    for f in [jn, yn, hn1, hn2]:
+        assert td(f(randint(-10, 10), z), z)
+
+
+def test_bessel_twoinputs():
+    for f in [besselj, bessely, besseli, besselk, hankel1, hankel2, jn, yn]:
+        raises(TypeError, lambda: f(1))
+        raises(TypeError, lambda: f(1, 2, 3))
+
+
+def test_besselj_leading_term():
+    assert besselj(0, x).as_leading_term(x) == 1
+    assert besselj(1, sin(x)).as_leading_term(x) == x/2
+    assert besselj(1, 2*sqrt(x)).as_leading_term(x) == sqrt(x)
+
+    # https://github.com/sympy/sympy/issues/21701
+    assert (besselj(z, x)/x**z).as_leading_term(x) == 1/(2**z*gamma(z + 1))
+
+
+def test_bessely_leading_term():
+    assert bessely(0, x).as_leading_term(x) == (2*log(x) - 2*log(2) + 2*S.EulerGamma)/pi
+    assert bessely(1, sin(x)).as_leading_term(x) == -2/(pi*x)
+    assert bessely(1, 2*sqrt(x)).as_leading_term(x) == -1/(pi*sqrt(x))
+
+
+def test_besseli_leading_term():
+    assert besseli(0, x).as_leading_term(x) == 1
+    assert besseli(1, sin(x)).as_leading_term(x) == x/2
+    assert besseli(1, 2*sqrt(x)).as_leading_term(x) == sqrt(x)
+
+
+def test_besselk_leading_term():
+    assert besselk(0, x).as_leading_term(x) == -log(x) - S.EulerGamma + log(2)
+    assert besselk(1, sin(x)).as_leading_term(x) == 1/x
+    assert besselk(1, 2*sqrt(x)).as_leading_term(x) == 1/(2*sqrt(x))
+    assert besselk(S(5)/3, x).as_leading_term(x) == 2**(S(2)/3)*gamma(S(5)/3)/x**(S(5)/3)
+    assert besselk(S(2)/3, x).as_leading_term(x) == besselk(-S(2)/3, x).as_leading_term(x)
+    assert besselk(1,cos(x)).as_leading_term(x) == besselk(1,1)
+    assert besselk(3,1/x).as_leading_term(x) == sqrt(pi)*exp(-(1/x))/sqrt(2/x)
+    assert besselk(3,1/sin(x)).as_leading_term(x) == sqrt(pi)*exp(-(1/x))/sqrt(2/x)
+
+    nz = Symbol("nz", nonzero=True)
+    assert besselk(nz, x).as_leading_term(x).subs({nz:S(5)/7}) == besselk(S(5)/7, x).series(x).as_leading_term(x)
+    assert besselk(nz, x).as_leading_term(x).subs({nz:S(-15)/7}) == besselk(S(-15)/7, x).series(x).as_leading_term(x)
+    assert besselk(nz, x).as_leading_term(x).subs({nz:3}) == besselk(3, x).series(x).as_leading_term(x)
+    assert besselk(nz, x).as_leading_term(x).subs({nz:-2}) == besselk(-2, x).series(x).as_leading_term(x)
+
+
+def test_besselj_series():
+    assert besselj(0, x).series(x) == 1 - x**2/4 + x**4/64 + O(x**6)
+    assert besselj(0, x**(1.1)).series(x) == 1 + x**4.4/64 - x**2.2/4 + O(x**6)
+    assert besselj(0, x**2 + x).series(x) == 1 - x**2/4 - x**3/2\
+        - 15*x**4/64 + x**5/16 + O(x**6)
+    assert besselj(0, sqrt(x) + x).series(x, n=4) == 1 - x/4 - 15*x**2/64\
+        + 215*x**3/2304 - x**Rational(3, 2)/2 + x**Rational(5, 2)/16\
+        + 23*x**Rational(7, 2)/384 + O(x**4)
+    assert besselj(0, x/(1 - x)).series(x) == 1 - x**2/4 - x**3/2 - 47*x**4/64\
+        - 15*x**5/16 + O(x**6)
+    assert besselj(0, log(1 + x)).series(x) == 1 - x**2/4 + x**3/4\
+        - 41*x**4/192 + 17*x**5/96 + O(x**6)
+    assert besselj(1, sin(x)).series(x) == x/2 - 7*x**3/48 + 73*x**5/1920 + O(x**6)
+    assert besselj(1, 2*sqrt(x)).series(x) == sqrt(x) - x**Rational(3, 2)/2\
+        + x**Rational(5, 2)/12 - x**Rational(7, 2)/144 + x**Rational(9, 2)/2880\
+        - x**Rational(11, 2)/86400 + O(x**6)
+    assert besselj(-2, sin(x)).series(x, n=4) == besselj(2, sin(x)).series(x, n=4)
+
+
+def test_bessely_series():
+    const = 2*S.EulerGamma/pi - 2*log(2)/pi + 2*log(x)/pi
+    assert bessely(0, x).series(x, n=4) == const + x**2*(-log(x)/(2*pi)\
+        + (2 - 2*S.EulerGamma)/(4*pi) + log(2)/(2*pi)) + O(x**4*log(x))
+    assert bessely(1, x).series(x, n=4) == -2/(pi*x) + x*(log(x)/pi - log(2)/pi - \
+        (1 - 2*S.EulerGamma)/(2*pi)) + x**3*(-log(x)/(8*pi) + \
+        (S(5)/2 - 2*S.EulerGamma)/(16*pi) + log(2)/(8*pi)) + O(x**4*log(x))
+    assert bessely(2, x).series(x, n=4) == -4/(pi*x**2) - 1/pi + x**2*(log(x)/(4*pi) - \
+        log(2)/(4*pi) - (S(3)/2 - 2*S.EulerGamma)/(8*pi)) + O(x**4*log(x))
+    assert bessely(3, x).series(x, n=4) == -16/(pi*x**3) - 2/(pi*x) - \
+        x/(4*pi) + x**3*(log(x)/(24*pi) - log(2)/(24*pi) - \
+        (S(11)/6 - 2*S.EulerGamma)/(48*pi)) + O(x**4*log(x))
+    assert bessely(0, x**(1.1)).series(x, n=4) == 2*S.EulerGamma/pi\
+        - 2*log(2)/pi + 2.2*log(x)/pi + x**2.2*(-0.55*log(x)/pi\
+        + (2 - 2*S.EulerGamma)/(4*pi) + log(2)/(2*pi)) + O(x**4*log(x))
+    assert bessely(0, x**2 + x).series(x, n=4) == \
+        const - (2 - 2*S.EulerGamma)*(-x**3/(2*pi) - x**2/(4*pi)) + 2*x/pi\
+        + x**2*(-log(x)/(2*pi) - 1/pi + log(2)/(2*pi))\
+        + x**3*(-log(x)/pi + 1/(6*pi) + log(2)/pi) + O(x**4*log(x))
+    assert bessely(0, x/(1 - x)).series(x, n=3) == const\
+        + 2*x/pi + x**2*(-log(x)/(2*pi) + (2 - 2*S.EulerGamma)/(4*pi)\
+        + log(2)/(2*pi) + 1/pi) + O(x**3*log(x))
+    assert bessely(0, log(1 + x)).series(x, n=3) == const\
+        - x/pi + x**2*(-log(x)/(2*pi) + (2 - 2*S.EulerGamma)/(4*pi)\
+        + log(2)/(2*pi) + 5/(12*pi)) + O(x**3*log(x))
+    assert bessely(1, sin(x)).series(x, n=4) == -1/(pi*(-x**3/12 + x/2)) - \
+        (1 - 2*S.EulerGamma)*(-x**3/12 + x/2)/pi + x*(log(x)/pi - log(2)/pi) + \
+        x**3*(-7*log(x)/(24*pi) - 1/(6*pi) + (S(5)/2 - 2*S.EulerGamma)/(16*pi) +
+        7*log(2)/(24*pi)) + O(x**4*log(x))
+    assert bessely(1, 2*sqrt(x)).series(x, n=3) == -1/(pi*sqrt(x)) + \
+        sqrt(x)*(log(x)/pi - (1 - 2*S.EulerGamma)/pi) + x**(S(3)/2)*(-log(x)/(2*pi) + \
+        (S(5)/2 - 2*S.EulerGamma)/(2*pi)) + x**(S(5)/2)*(log(x)/(12*pi) - \
+        (S(10)/3 - 2*S.EulerGamma)/(12*pi)) + O(x**3*log(x))
+    assert bessely(-2, sin(x)).series(x, n=4) == bessely(2, sin(x)).series(x, n=4)
+
+
+def test_besseli_series():
+    assert besseli(0, x).series(x) == 1 + x**2/4 + x**4/64 + O(x**6)
+    assert besseli(0, x**(1.1)).series(x) == 1 + x**4.4/64 + x**2.2/4 + O(x**6)
+    assert besseli(0, x**2 + x).series(x) == 1 + x**2/4 + x**3/2 + 17*x**4/64 + \
+        x**5/16 + O(x**6)
+    assert besseli(0, sqrt(x) + x).series(x, n=4) == 1 + x/4 + 17*x**2/64 + \
+        217*x**3/2304 + x**(S(3)/2)/2 + x**(S(5)/2)/16 + 25*x**(S(7)/2)/384 + O(x**4)
+    assert besseli(0, x/(1 - x)).series(x) == 1 + x**2/4 + x**3/2 + 49*x**4/64 + \
+        17*x**5/16 + O(x**6)
+    assert besseli(0, log(1 + x)).series(x) == 1 + x**2/4 - x**3/4 + 47*x**4/192 - \
+        23*x**5/96 + O(x**6)
+    assert besseli(1, sin(x)).series(x) == x/2 - x**3/48 - 47*x**5/1920 + O(x**6)
+    assert besseli(1, 2*sqrt(x)).series(x) == sqrt(x) + x**(S(3)/2)/2 + x**(S(5)/2)/12 + \
+        x**(S(7)/2)/144 + x**(S(9)/2)/2880 + x**(S(11)/2)/86400 + O(x**6)
+    assert besseli(-2, sin(x)).series(x, n=4) == besseli(2, sin(x)).series(x, n=4)
+
+    #test for aseries
+    assert besseli(0,x).series(x, oo, n=4) == sqrt(2)*(sqrt(1/x) - (1/x)**(S(3)/2)/8 - \
+        3*(1/x)**(S(5)/2)/128 - 15*(1/x)**(S(7)/2)/1024 + O((1/x)**(S(9)/2), (x, oo)))*exp(x)/(2*sqrt(pi))
+    assert besseli(0,x).series(x,-oo, n=4) == sqrt(2)*(sqrt(-1/x) - (-1/x)**(S(3)/2)/8 - 3*(-1/x)**(S(5)/2)/128 - \
+        15*(-1/x)**(S(7)/2)/1024 + O((-1/x)**(S(9)/2), (x, -oo)))*exp(-x)/(2*sqrt(pi))
+
+
+def test_besselk_series():
+    const = log(2) - S.EulerGamma - log(x)
+    assert besselk(0, x).series(x, n=4) == const + \
+        x**2*(-log(x)/4 - S.EulerGamma/4 + log(2)/4 + S(1)/4) + O(x**4*log(x))
+    assert besselk(1, x).series(x, n=4) == 1/x + x*(log(x)/2 - log(2)/2 - \
+        S(1)/4 + S.EulerGamma/2) + x**3*(log(x)/16 - S(5)/64 - log(2)/16 + \
+        S.EulerGamma/16) + O(x**4*log(x))
+    assert besselk(2, x).series(x, n=4) == 2/x**2 - S(1)/2 + x**2*(-log(x)/8 - \
+        S.EulerGamma/8 + log(2)/8 + S(3)/32) + O(x**4*log(x))
+    assert besselk(2, x).series(x, n=1) == 2/x**2 - S(1)/2 + O(x) #edge case for series truncation
+    assert besselk(0, x**(1.1)).series(x, n=4) == log(2) - S.EulerGamma - \
+        1.1*log(x) + x**2.2*(-0.275*log(x) - S.EulerGamma/4 + \
+        log(2)/4 + S(1)/4) + O(x**4*log(x))
+    assert besselk(0, x**2 + x).series(x, n=4) == const + \
+        (2 - 2*S.EulerGamma)*(x**3/4 + x**2/8) - x + x**2*(-log(x)/4 + \
+        log(2)/4 + S(1)/2) + x**3*(-log(x)/2 - S(7)/12 + log(2)/2) + O(x**4*log(x))
+    assert besselk(0, x/(1 - x)).series(x, n=3) == const - x + x**2*(-log(x)/4 - \
+        S(1)/4 - S.EulerGamma/4 + log(2)/4) + O(x**3*log(x))
+    assert besselk(0, log(1 + x)).series(x, n=3) == const + x/2 + \
+        x**2*(-log(x)/4 - S.EulerGamma/4 + S(1)/24 + log(2)/4) + O(x**3*log(x))
+    assert besselk(1, 2*sqrt(x)).series(x, n=3) == 1/(2*sqrt(x)) + \
+        sqrt(x)*(log(x)/2 - S(1)/2 + S.EulerGamma) + x**(S(3)/2)*(log(x)/4 - S(5)/8 + \
+        S.EulerGamma/2) + x**(S(5)/2)*(log(x)/24 - S(5)/36 + S.EulerGamma/12) + O(x**3*log(x))
+    assert besselk(-2, sin(x)).series(x, n=4) == besselk(2, sin(x)).series(x, n=4)
+    assert besselk(2, x**2).series(x, n=2) == 2/x**4 - S(1)/2 + O(x**2) #edge case for series truncation
+    assert besselk(2, x**2).series(x, n=6) == 2/x**4 - S(1)/2 + x**4*(-log(x)/4 - S.EulerGamma/8 + log(2)/8 + S(3)/32) + O(x**6*log(x))
+    assert (x**2*besselk(2, x)).series(x, n=2) == 2 + O(x**2)
+
+    #test for aseries
+    assert besselk(0,x).series(x, oo, n=4) == sqrt(2)*sqrt(pi)*(sqrt(1/x) + (1/x)**(S(3)/2)/8 - \
+            3*(1/x)**(S(5)/2)/128 + 15*(1/x)**(S(7)/2)/1024 + O((1/x)**(S(9)/2), (x, oo)))*exp(-x)/2
+    assert besselk(0,x).series(x, -oo, n=4) == sqrt(2)*sqrt(pi)*(-I*sqrt(-1/x) + I*(-1/x)**(S(3)/2)/8 + \
+            3*I*(-1/x)**(S(5)/2)/128 + 15*I*(-1/x)**(S(7)/2)/1024 + O((-1/x)**(S(9)/2), (x, -oo)))*exp(-x)/2
+
+
+def test_besselk_frac_order_series():
+    assert besselk(S(5)/3, x).series(x, n=2) == 2**(S(2)/3)*gamma(S(5)/3)/x**(S(5)/3) - \
+        3*gamma(S(5)/3)*x**(S(1)/3)/(4*2**(S(1)/3)) + \
+            gamma(-S(5)/3)*x**(S(5)/3)/(4*2**(S(2)/3)) + O(x**2)
+    assert besselk(S(1)/2, x).series(x, n=2) == sqrt(pi/2)/sqrt(x) - \
+        sqrt(pi*x/2) + x**(S(3)/2)*sqrt(pi/2)/2 + O(x**2)
+    assert besselk(S(1)/2, sqrt(x)).series(x, n=2) == sqrt(pi/2)/x**(S(1)/4) - \
+        sqrt(pi/2)*x**(S(1)/4) + sqrt(pi/2)*x**(S(3)/4)/2 - \
+            sqrt(pi/2)*x**(S(5)/4)/6 + sqrt(pi/2)*x**(S(7)/4)/24 + O(x**2)
+    assert besselk(S(1)/2, x**2).series(x, n=2) == sqrt(pi/2)/x \
+        - sqrt(pi/2)*x + O(x**2)
+    assert besselk(-S(1)/2, x).series(x) == besselk(S(1)/2, x).series(x)
+    assert besselk(-S(7)/6, x).series(x) == besselk(S(7)/6, x).series(x)
+
+
+def test_diff():
+    assert besselj(n, z).diff(z) == besselj(n - 1, z)/2 - besselj(n + 1, z)/2
+    assert bessely(n, z).diff(z) == bessely(n - 1, z)/2 - bessely(n + 1, z)/2
+    assert besseli(n, z).diff(z) == besseli(n - 1, z)/2 + besseli(n + 1, z)/2
+    assert besselk(n, z).diff(z) == -besselk(n - 1, z)/2 - besselk(n + 1, z)/2
+    assert hankel1(n, z).diff(z) == hankel1(n - 1, z)/2 - hankel1(n + 1, z)/2
+    assert hankel2(n, z).diff(z) == hankel2(n - 1, z)/2 - hankel2(n + 1, z)/2
+
+
+def test_rewrite():
+    assert besselj(n, z).rewrite(jn) == sqrt(2*z/pi)*jn(n - S.Half, z)
+    assert bessely(n, z).rewrite(yn) == sqrt(2*z/pi)*yn(n - S.Half, z)
+    assert besseli(n, z).rewrite(besselj) == \
+        exp(-I*n*pi/2)*besselj(n, polar_lift(I)*z)
+    assert besselj(n, z).rewrite(besseli) == \
+        exp(I*n*pi/2)*besseli(n, polar_lift(-I)*z)
+
+    nu = randcplx()
+
+    assert tn(besselj(nu, z), besselj(nu, z).rewrite(besseli), z)
+    assert tn(besselj(nu, z), besselj(nu, z).rewrite(bessely), z)
+
+    assert tn(besseli(nu, z), besseli(nu, z).rewrite(besselj), z)
+    assert tn(besseli(nu, z), besseli(nu, z).rewrite(bessely), z)
+
+    assert tn(bessely(nu, z), bessely(nu, z).rewrite(besselj), z)
+    assert tn(bessely(nu, z), bessely(nu, z).rewrite(besseli), z)
+
+    assert tn(besselk(nu, z), besselk(nu, z).rewrite(besselj), z)
+    assert tn(besselk(nu, z), besselk(nu, z).rewrite(besseli), z)
+    assert tn(besselk(nu, z), besselk(nu, z).rewrite(bessely), z)
+
+    # check that a rewrite was triggered, when the order is set to a generic
+    # symbol 'nu'
+    assert yn(nu, z) != yn(nu, z).rewrite(jn)
+    assert hn1(nu, z) != hn1(nu, z).rewrite(jn)
+    assert hn2(nu, z) != hn2(nu, z).rewrite(jn)
+    assert jn(nu, z) != jn(nu, z).rewrite(yn)
+    assert hn1(nu, z) != hn1(nu, z).rewrite(yn)
+    assert hn2(nu, z) != hn2(nu, z).rewrite(yn)
+
+    # rewriting spherical bessel functions (SBFs) w.r.t. besselj, bessely is
+    # not allowed if a generic symbol 'nu' is used as the order of the SBFs
+    # to avoid inconsistencies (the order of bessel[jy] is allowed to be
+    # complex-valued, whereas SBFs are defined only for integer orders)
+    order = nu
+    for f in (besselj, bessely):
+        assert hn1(order, z) == hn1(order, z).rewrite(f)
+        assert hn2(order, z) == hn2(order, z).rewrite(f)
+
+    assert jn(order, z).rewrite(besselj) == sqrt(2)*sqrt(pi)*sqrt(1/z)*besselj(order + S.Half, z)/2
+    assert jn(order, z).rewrite(bessely) == (-1)**nu*sqrt(2)*sqrt(pi)*sqrt(1/z)*bessely(-order - S.Half, z)/2
+
+    # for integral orders rewriting SBFs w.r.t bessel[jy] is allowed
+    N = Symbol('n', integer=True)
+    ri = randint(-11, 10)
+    for order in (ri, N):
+        for f in (besselj, bessely):
+            assert yn(order, z) != yn(order, z).rewrite(f)
+            assert jn(order, z) != jn(order, z).rewrite(f)
+            assert hn1(order, z) != hn1(order, z).rewrite(f)
+            assert hn2(order, z) != hn2(order, z).rewrite(f)
+
+    for func, refunc in product((yn, jn, hn1, hn2),
+                                (jn, yn, besselj, bessely)):
+        assert tn(func(ri, z), func(ri, z).rewrite(refunc), z)
+
+
+def test_expand():
+    assert expand_func(besselj(S.Half, z).rewrite(jn)) == \
+        sqrt(2)*sin(z)/(sqrt(pi)*sqrt(z))
+    assert expand_func(bessely(S.Half, z).rewrite(yn)) == \
+        -sqrt(2)*cos(z)/(sqrt(pi)*sqrt(z))
+
+    # XXX: teach sin/cos to work around arguments like
+    # x*exp_polar(I*pi*n/2).  Then change besselsimp -> expand_func
+    assert besselsimp(besselj(S.Half, z)) == sqrt(2)*sin(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besselj(Rational(-1, 2), z)) == sqrt(2)*cos(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besselj(Rational(5, 2), z)) == \
+        -sqrt(2)*(z**2*sin(z) + 3*z*cos(z) - 3*sin(z))/(sqrt(pi)*z**Rational(5, 2))
+    assert besselsimp(besselj(Rational(-5, 2), z)) == \
+        -sqrt(2)*(z**2*cos(z) - 3*z*sin(z) - 3*cos(z))/(sqrt(pi)*z**Rational(5, 2))
+
+    assert besselsimp(bessely(S.Half, z)) == \
+        -(sqrt(2)*cos(z))/(sqrt(pi)*sqrt(z))
+    assert besselsimp(bessely(Rational(-1, 2), z)) == sqrt(2)*sin(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(bessely(Rational(5, 2), z)) == \
+        sqrt(2)*(z**2*cos(z) - 3*z*sin(z) - 3*cos(z))/(sqrt(pi)*z**Rational(5, 2))
+    assert besselsimp(bessely(Rational(-5, 2), z)) == \
+        -sqrt(2)*(z**2*sin(z) + 3*z*cos(z) - 3*sin(z))/(sqrt(pi)*z**Rational(5, 2))
+
+    assert besselsimp(besseli(S.Half, z)) == sqrt(2)*sinh(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besseli(Rational(-1, 2), z)) == \
+        sqrt(2)*cosh(z)/(sqrt(pi)*sqrt(z))
+    assert besselsimp(besseli(Rational(5, 2), z)) == \
+        sqrt(2)*(z**2*sinh(z) - 3*z*cosh(z) + 3*sinh(z))/(sqrt(pi)*z**Rational(5, 2))
+    assert besselsimp(besseli(Rational(-5, 2), z)) == \
+        sqrt(2)*(z**2*cosh(z) - 3*z*sinh(z) + 3*cosh(z))/(sqrt(pi)*z**Rational(5, 2))
+
+    assert besselsimp(besselk(S.Half, z)) == \
+        besselsimp(besselk(Rational(-1, 2), z)) == sqrt(pi)*exp(-z)/(sqrt(2)*sqrt(z))
+    assert besselsimp(besselk(Rational(5, 2), z)) == \
+        besselsimp(besselk(Rational(-5, 2), z)) == \
+        sqrt(2)*sqrt(pi)*(z**2 + 3*z + 3)*exp(-z)/(2*z**Rational(5, 2))
+
+    n = Symbol('n', integer=True, positive=True)
+
+    assert expand_func(besseli(n + 2, z)) == \
+        besseli(n, z) + (-2*n - 2)*(-2*n*besseli(n, z)/z + besseli(n - 1, z))/z
+    assert expand_func(besselj(n + 2, z)) == \
+        -besselj(n, z) + (2*n + 2)*(2*n*besselj(n, z)/z - besselj(n - 1, z))/z
+    assert expand_func(besselk(n + 2, z)) == \
+        besselk(n, z) + (2*n + 2)*(2*n*besselk(n, z)/z + besselk(n - 1, z))/z
+    assert expand_func(bessely(n + 2, z)) == \
+        -bessely(n, z) + (2*n + 2)*(2*n*bessely(n, z)/z - bessely(n - 1, z))/z
+
+    assert expand_func(besseli(n + S.Half, z).rewrite(jn)) == \
+        (sqrt(2)*sqrt(z)*exp(-I*pi*(n + S.Half)/2) *
+         exp_polar(I*pi/4)*jn(n, z*exp_polar(I*pi/2))/sqrt(pi))
+    assert expand_func(besselj(n + S.Half, z).rewrite(jn)) == \
+        sqrt(2)*sqrt(z)*jn(n, z)/sqrt(pi)
+
+    r = Symbol('r', real=True)
+    p = Symbol('p', positive=True)
+    i = Symbol('i', integer=True)
+
+    for besselx in [besselj, bessely, besseli, besselk]:
+        assert besselx(i, p).is_extended_real is True
+        assert besselx(i, x).is_extended_real is None
+        assert besselx(x, z).is_extended_real is None
+
+    for besselx in [besselj, besseli]:
+        assert besselx(i, r).is_extended_real is True
+    for besselx in [bessely, besselk]:
+        assert besselx(i, r).is_extended_real is None
+
+    for besselx in [besselj, bessely, besseli, besselk]:
+        assert expand_func(besselx(oo, x)) == besselx(oo, x, evaluate=False)
+        assert expand_func(besselx(-oo, x)) == besselx(-oo, x, evaluate=False)
+
+
+# Quite varying time, but often really slow
+@slow
+def test_slow_expand():
+    def check(eq, ans):
+        return tn(eq, ans) and eq == ans
+
+    rn = randcplx(a=1, b=0, d=0, c=2)
+
+    for besselx in [besselj, bessely, besseli, besselk]:
+        ri = S(2*randint(-11, 10) + 1) / 2  # half integer in [-21/2, 21/2]
+        assert tn(besselsimp(besselx(ri, z)), besselx(ri, z))
+
+    assert check(expand_func(besseli(rn, x)),
+                 besseli(rn - 2, x) - 2*(rn - 1)*besseli(rn - 1, x)/x)
+    assert check(expand_func(besseli(-rn, x)),
+                 besseli(-rn + 2, x) + 2*(-rn + 1)*besseli(-rn + 1, x)/x)
+
+    assert check(expand_func(besselj(rn, x)),
+                 -besselj(rn - 2, x) + 2*(rn - 1)*besselj(rn - 1, x)/x)
+    assert check(expand_func(besselj(-rn, x)),
+                 -besselj(-rn + 2, x) + 2*(-rn + 1)*besselj(-rn + 1, x)/x)
+
+    assert check(expand_func(besselk(rn, x)),
+                 besselk(rn - 2, x) + 2*(rn - 1)*besselk(rn - 1, x)/x)
+    assert check(expand_func(besselk(-rn, x)),
+                 besselk(-rn + 2, x) - 2*(-rn + 1)*besselk(-rn + 1, x)/x)
+
+    assert check(expand_func(bessely(rn, x)),
+                 -bessely(rn - 2, x) + 2*(rn - 1)*bessely(rn - 1, x)/x)
+    assert check(expand_func(bessely(-rn, x)),
+                 -bessely(-rn + 2, x) + 2*(-rn + 1)*bessely(-rn + 1, x)/x)
+
+
+def mjn(n, z):
+    return expand_func(jn(n, z))
+
+
+def myn(n, z):
+    return expand_func(yn(n, z))
+
+
+def test_jn():
+    z = symbols("z")
+    assert jn(0, 0) == 1
+    assert jn(1, 0) == 0
+    assert jn(-1, 0) == S.ComplexInfinity
+    assert jn(z, 0) == jn(z, 0, evaluate=False)
+    assert jn(0, oo) == 0
+    assert jn(0, -oo) == 0
+
+    assert mjn(0, z) == sin(z)/z
+    assert mjn(1, z) == sin(z)/z**2 - cos(z)/z
+    assert mjn(2, z) == (3/z**3 - 1/z)*sin(z) - (3/z**2) * cos(z)
+    assert mjn(3, z) == (15/z**4 - 6/z**2)*sin(z) + (1/z - 15/z**3)*cos(z)
+    assert mjn(4, z) == (1/z + 105/z**5 - 45/z**3)*sin(z) + \
+        (-105/z**4 + 10/z**2)*cos(z)
+    assert mjn(5, z) == (945/z**6 - 420/z**4 + 15/z**2)*sin(z) + \
+        (-1/z - 945/z**5 + 105/z**3)*cos(z)
+    assert mjn(6, z) == (-1/z + 10395/z**7 - 4725/z**5 + 210/z**3)*sin(z) + \
+        (-10395/z**6 + 1260/z**4 - 21/z**2)*cos(z)
+
+    assert expand_func(jn(n, z)) == jn(n, z)
+
+    # SBFs not defined for complex-valued orders
+    assert jn(2+3j, 5.2+0.3j).evalf() == jn(2+3j, 5.2+0.3j)
+
+    assert eq([jn(2, 5.2+0.3j).evalf(10)],
+              [0.09941975672 - 0.05452508024*I])
+
+
+def test_yn():
+    z = symbols("z")
+    assert myn(0, z) == -cos(z)/z
+    assert myn(1, z) == -cos(z)/z**2 - sin(z)/z
+    assert myn(2, z) == -((3/z**3 - 1/z)*cos(z) + (3/z**2)*sin(z))
+    assert expand_func(yn(n, z)) == yn(n, z)
+
+    # SBFs not defined for complex-valued orders
+    assert yn(2+3j, 5.2+0.3j).evalf() == yn(2+3j, 5.2+0.3j)
+
+    assert eq([yn(2, 5.2+0.3j).evalf(10)],
+              [0.185250342 + 0.01489557397*I])
+
+
+def test_sympify_yn():
+    assert S(15) in myn(3, pi).atoms()
+    assert myn(3, pi) == 15/pi**4 - 6/pi**2
+
+
+def eq(a, b, tol=1e-6):
+    for u, v in zip(a, b):
+        if not (abs(u - v) < tol):
+            return False
+    return True
+
+
+def test_jn_zeros():
+    assert eq(jn_zeros(0, 4), [3.141592, 6.283185, 9.424777, 12.566370])
+    assert eq(jn_zeros(1, 4), [4.493409, 7.725251, 10.904121, 14.066193])
+    assert eq(jn_zeros(2, 4), [5.763459, 9.095011, 12.322940, 15.514603])
+    assert eq(jn_zeros(3, 4), [6.987932, 10.417118, 13.698023, 16.923621])
+    assert eq(jn_zeros(4, 4), [8.182561, 11.704907, 15.039664, 18.301255])
+
+
+def test_bessel_eval():
+    n, m, k = Symbol('n', integer=True), Symbol('m'), Symbol('k', integer=True, zero=False)
+
+    for f in [besselj, besseli]:
+        assert f(0, 0) is S.One
+        assert f(2.1, 0) is S.Zero
+        assert f(-3, 0) is S.Zero
+        assert f(-10.2, 0) is S.ComplexInfinity
+        assert f(1 + 3*I, 0) is S.Zero
+        assert f(-3 + I, 0) is S.ComplexInfinity
+        assert f(-2*I, 0) is S.NaN
+        assert f(n, 0) != S.One and f(n, 0) != S.Zero
+        assert f(m, 0) != S.One and f(m, 0) != S.Zero
+        assert f(k, 0) is S.Zero
+
+    assert bessely(0, 0) is S.NegativeInfinity
+    assert besselk(0, 0) is S.Infinity
+    for f in [bessely, besselk]:
+        assert f(1 + I, 0) is S.ComplexInfinity
+        assert f(I, 0) is S.NaN
+
+    for f in [besselj, bessely]:
+        assert f(m, S.Infinity) is S.Zero
+        assert f(m, S.NegativeInfinity) is S.Zero
+
+    for f in [besseli, besselk]:
+        assert f(m, I*S.Infinity) is S.Zero
+        assert f(m, I*S.NegativeInfinity) is S.Zero
+
+    for f in [besseli, besselk]:
+        assert f(-4, z) == f(4, z)
+        assert f(-3, z) == f(3, z)
+        assert f(-n, z) == f(n, z)
+        assert f(-m, z) != f(m, z)
+
+    for f in [besselj, bessely]:
+        assert f(-4, z) == f(4, z)
+        assert f(-3, z) == -f(3, z)
+        assert f(-n, z) == (-1)**n*f(n, z)
+        assert f(-m, z) != (-1)**m*f(m, z)
+
+    for f in [besselj, besseli]:
+        assert f(m, -z) == (-z)**m*z**(-m)*f(m, z)
+
+    assert besseli(2, -z) == besseli(2, z)
+    assert besseli(3, -z) == -besseli(3, z)
+
+    assert besselj(0, -z) == besselj(0, z)
+    assert besselj(1, -z) == -besselj(1, z)
+
+    assert besseli(0, I*z) == besselj(0, z)
+    assert besseli(1, I*z) == I*besselj(1, z)
+    assert besselj(3, I*z) == -I*besseli(3, z)
+
+
+def test_bessel_nan():
+    # FIXME: could have these return NaN; for now just fix infinite recursion
+    for f in [besselj, bessely, besseli, besselk, hankel1, hankel2, yn, jn]:
+        assert f(1, S.NaN) == f(1, S.NaN, evaluate=False)
+
+
+def test_meromorphic():
+    assert besselj(2, x).is_meromorphic(x, 1) == True
+    assert besselj(2, x).is_meromorphic(x, 0) == True
+    assert besselj(2, x).is_meromorphic(x, oo) == False
+    assert besselj(S(2)/3, x).is_meromorphic(x, 1) == True
+    assert besselj(S(2)/3, x).is_meromorphic(x, 0) == False
+    assert besselj(S(2)/3, x).is_meromorphic(x, oo) == False
+    assert besselj(x, 2*x).is_meromorphic(x, 2) == False
+    assert besselk(0, x).is_meromorphic(x, 1) == True
+    assert besselk(2, x).is_meromorphic(x, 0) == True
+    assert besseli(0, x).is_meromorphic(x, 1) == True
+    assert besseli(2, x).is_meromorphic(x, 0) == True
+    assert bessely(0, x).is_meromorphic(x, 1) == True
+    assert bessely(0, x).is_meromorphic(x, 0) == False
+    assert bessely(2, x).is_meromorphic(x, 0) == True
+    assert hankel1(3, x**2 + 2*x).is_meromorphic(x, 1) == True
+    assert hankel1(0, x).is_meromorphic(x, 0) == False
+    assert hankel2(11, 4).is_meromorphic(x, 5) == True
+    assert hn1(6, 7*x**3 + 4).is_meromorphic(x, 7) == True
+    assert hn2(3, 2*x).is_meromorphic(x, 9) == True
+    assert jn(5, 2*x + 7).is_meromorphic(x, 4) == True
+    assert yn(8, x**2 + 11).is_meromorphic(x, 6) == True
+
+
+def test_conjugate():
+    n = Symbol('n')
+    z = Symbol('z', extended_real=False)
+    x = Symbol('x', extended_real=True)
+    y = Symbol('y', positive=True)
+    t = Symbol('t', negative=True)
+
+    for f in [besseli, besselj, besselk, bessely, hankel1, hankel2]:
+        assert f(n, -1).conjugate() != f(conjugate(n), -1)
+        assert f(n, x).conjugate() != f(conjugate(n), x)
+        assert f(n, t).conjugate() != f(conjugate(n), t)
+
+    rz = randcplx(b=0.5)
+
+    for f in [besseli, besselj, besselk, bessely]:
+        assert f(n, 1 + I).conjugate() == f(conjugate(n), 1 - I)
+        assert f(n, 0).conjugate() == f(conjugate(n), 0)
+        assert f(n, 1).conjugate() == f(conjugate(n), 1)
+        assert f(n, z).conjugate() == f(conjugate(n), conjugate(z))
+        assert f(n, y).conjugate() == f(conjugate(n), y)
+        assert tn(f(n, rz).conjugate(), f(conjugate(n), conjugate(rz)))
+
+    assert hankel1(n, 1 + I).conjugate() == hankel2(conjugate(n), 1 - I)
+    assert hankel1(n, 0).conjugate() == hankel2(conjugate(n), 0)
+    assert hankel1(n, 1).conjugate() == hankel2(conjugate(n), 1)
+    assert hankel1(n, y).conjugate() == hankel2(conjugate(n), y)
+    assert hankel1(n, z).conjugate() == hankel2(conjugate(n), conjugate(z))
+    assert tn(hankel1(n, rz).conjugate(), hankel2(conjugate(n), conjugate(rz)))
+
+    assert hankel2(n, 1 + I).conjugate() == hankel1(conjugate(n), 1 - I)
+    assert hankel2(n, 0).conjugate() == hankel1(conjugate(n), 0)
+    assert hankel2(n, 1).conjugate() == hankel1(conjugate(n), 1)
+    assert hankel2(n, y).conjugate() == hankel1(conjugate(n), y)
+    assert hankel2(n, z).conjugate() == hankel1(conjugate(n), conjugate(z))
+    assert tn(hankel2(n, rz).conjugate(), hankel1(conjugate(n), conjugate(rz)))
+
+
+def test_branching():
+    assert besselj(polar_lift(k), x) == besselj(k, x)
+    assert besseli(polar_lift(k), x) == besseli(k, x)
+
+    n = Symbol('n', integer=True)
+    assert besselj(n, exp_polar(2*pi*I)*x) == besselj(n, x)
+    assert besselj(n, polar_lift(x)) == besselj(n, x)
+    assert besseli(n, exp_polar(2*pi*I)*x) == besseli(n, x)
+    assert besseli(n, polar_lift(x)) == besseli(n, x)
+
+    def tn(func, s):
+        from sympy.core.random import uniform
+        c = uniform(1, 5)
+        expr = func(s, c*exp_polar(I*pi)) - func(s, c*exp_polar(-I*pi))
+        eps = 1e-15
+        expr2 = func(s + eps, -c + eps*I) - func(s + eps, -c - eps*I)
+        return abs(expr.n() - expr2.n()).n() < 1e-10
+
+    nu = Symbol('nu')
+    assert besselj(nu, exp_polar(2*pi*I)*x) == exp(2*pi*I*nu)*besselj(nu, x)
+    assert besseli(nu, exp_polar(2*pi*I)*x) == exp(2*pi*I*nu)*besseli(nu, x)
+    assert tn(besselj, 2)
+    assert tn(besselj, pi)
+    assert tn(besselj, I)
+    assert tn(besseli, 2)
+    assert tn(besseli, pi)
+    assert tn(besseli, I)
+
+
+def test_airy_base():
+    z = Symbol('z')
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+
+    assert conjugate(airyai(z)) == airyai(conjugate(z))
+    assert airyai(x).is_extended_real
+
+    assert airyai(x+I*y).as_real_imag() == (
+            airyai(x - I*y)/2 + airyai(x + I*y)/2,
+            I*(airyai(x - I*y) - airyai(x + I*y))/2)
+
+
+def test_airyai():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airyai(z), airyai)
+
+    assert airyai(0) == 3**Rational(1, 3)/(3*gamma(Rational(2, 3)))
+    assert airyai(oo) == 0
+    assert airyai(-oo) == 0
+
+    assert diff(airyai(z), z) == airyaiprime(z)
+
+    assert series(airyai(z), z, 0, 3) == (
+        3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) - 3**Rational(1, 6)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))
+
+    assert airyai(z).rewrite(hyper) == (
+        -3**Rational(2, 3)*z*hyper((), (Rational(4, 3),), z**3/9)/(3*gamma(Rational(1, 3))) +
+         3**Rational(1, 3)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))
+
+    assert isinstance(airyai(z).rewrite(besselj), airyai)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airyai(z).rewrite(besseli) == (
+        -z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(1, 3)) +
+         (z**Rational(3, 2))**Rational(1, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3)/3)
+    assert airyai(p).rewrite(besseli) == (
+        sqrt(p)*(besseli(Rational(-1, 3), 2*p**Rational(3, 2)/3) -
+                 besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airyai(2*(3*z**5)**Rational(1, 3))) == (
+        -sqrt(3)*(-1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airybi(2*3**Rational(1, 3)*z**Rational(5, 3))/6 +
+         (1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airyai(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airybi():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airybi(z), airybi)
+
+    assert airybi(0) == 3**Rational(5, 6)/(3*gamma(Rational(2, 3)))
+    assert airybi(oo) is oo
+    assert airybi(-oo) == 0
+
+    assert diff(airybi(z), z) == airybiprime(z)
+
+    assert series(airybi(z), z, 0, 3) == (
+        3**Rational(1, 3)*gamma(Rational(1, 3))/(2*pi) + 3**Rational(2, 3)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))
+
+    assert airybi(z).rewrite(hyper) == (
+        3**Rational(1, 6)*z*hyper((), (Rational(4, 3),), z**3/9)/gamma(Rational(1, 3)) +
+        3**Rational(5, 6)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))
+
+    assert isinstance(airybi(z).rewrite(besselj), airybi)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airybi(z).rewrite(besseli) == (
+        sqrt(3)*(z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(1, 3) +
+                 (z**Rational(3, 2))**Rational(1, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3))/3)
+    assert airybi(p).rewrite(besseli) == (
+        sqrt(3)*sqrt(p)*(besseli(Rational(-1, 3), 2*p**Rational(3, 2)/3) +
+                         besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airybi(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(1 - (z**5)**Rational(1, 3)/z**Rational(5, 3))*airyai(2*3**Rational(1, 3)*z**Rational(5, 3))/2 +
+        (1 + (z**5)**Rational(1, 3)/z**Rational(5, 3))*airybi(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airyaiprime():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airyaiprime(z), airyaiprime)
+
+    assert airyaiprime(0) == -3**Rational(2, 3)/(3*gamma(Rational(1, 3)))
+    assert airyaiprime(oo) == 0
+
+    assert diff(airyaiprime(z), z) == z*airyai(z)
+
+    assert series(airyaiprime(z), z, 0, 3) == (
+        -3**Rational(2, 3)/(3*gamma(Rational(1, 3))) + 3**Rational(1, 3)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))
+
+    assert airyaiprime(z).rewrite(hyper) == (
+        3**Rational(1, 3)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) -
+        3**Rational(2, 3)*hyper((), (Rational(1, 3),), z**3/9)/(3*gamma(Rational(1, 3))))
+
+    assert isinstance(airyaiprime(z).rewrite(besselj), airyaiprime)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airyaiprime(z).rewrite(besseli) == (
+        z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(2, 3)) -
+        (z**Rational(3, 2))**Rational(2, 3)*besseli(Rational(-1, 3), 2*z**Rational(3, 2)/3)/3)
+    assert airyaiprime(p).rewrite(besseli) == (
+        p*(-besseli(Rational(-2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airyaiprime(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(z**Rational(5, 3)/(z**5)**Rational(1, 3) - 1)*airybiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/6 +
+        (z**Rational(5, 3)/(z**5)**Rational(1, 3) + 1)*airyaiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_airybiprime():
+    z = Symbol('z', real=False)
+    t = Symbol('t', negative=True)
+    p = Symbol('p', positive=True)
+
+    assert isinstance(airybiprime(z), airybiprime)
+
+    assert airybiprime(0) == 3**Rational(1, 6)/gamma(Rational(1, 3))
+    assert airybiprime(oo) is oo
+    assert airybiprime(-oo) == 0
+
+    assert diff(airybiprime(z), z) == z*airybi(z)
+
+    assert series(airybiprime(z), z, 0, 3) == (
+        3**Rational(1, 6)/gamma(Rational(1, 3)) + 3**Rational(5, 6)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))
+
+    assert airybiprime(z).rewrite(hyper) == (
+        3**Rational(5, 6)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) +
+        3**Rational(1, 6)*hyper((), (Rational(1, 3),), z**3/9)/gamma(Rational(1, 3)))
+
+    assert isinstance(airybiprime(z).rewrite(besselj), airybiprime)
+    assert airyai(t).rewrite(besselj) == (
+        sqrt(-t)*(besselj(Rational(-1, 3), 2*(-t)**Rational(3, 2)/3) +
+                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
+    assert airybiprime(z).rewrite(besseli) == (
+        sqrt(3)*(z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(2, 3) +
+                 (z**Rational(3, 2))**Rational(2, 3)*besseli(Rational(-2, 3), 2*z**Rational(3, 2)/3))/3)
+    assert airybiprime(p).rewrite(besseli) == (
+        sqrt(3)*p*(besseli(Rational(-2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
+
+    assert expand_func(airybiprime(2*(3*z**5)**Rational(1, 3))) == (
+        sqrt(3)*(z**Rational(5, 3)/(z**5)**Rational(1, 3) - 1)*airyaiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2 +
+        (z**Rational(5, 3)/(z**5)**Rational(1, 3) + 1)*airybiprime(2*3**Rational(1, 3)*z**Rational(5, 3))/2)
+
+
+def test_marcumq():
+    m = Symbol('m')
+    a = Symbol('a')
+    b = Symbol('b')
+
+    assert marcumq(0, 0, 0) == 0
+    assert marcumq(m, 0, b) == uppergamma(m, b**2/2)/gamma(m)
+    assert marcumq(2, 0, 5) == 27*exp(Rational(-25, 2))/2
+    assert marcumq(0, a, 0) == 1 - exp(-a**2/2)
+    assert marcumq(0, pi, 0) == 1 - exp(-pi**2/2)
+    assert marcumq(1, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(2, a, a) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + exp(-a**2)*besseli(1, a**2)
+
+    assert diff(marcumq(1, a, 3), a) == a*(-marcumq(1, a, 3) + marcumq(2, a, 3))
+    assert diff(marcumq(2, 3, b), b) == -b**2*exp(-b**2/2 - Rational(9, 2))*besseli(1, 3*b)/3
+
+    x = Symbol('x')
+    assert marcumq(2, 3, 4).rewrite(Integral, x=x) == \
+           Integral(x**2*exp(-x**2/2 - Rational(9, 2))*besseli(1, 3*x), (x, 4, oo))/3
+    assert eq([marcumq(5, -2, 3).rewrite(Integral).evalf(10)],
+              [0.7905769565])
+
+    k = Symbol('k')
+    assert marcumq(-3, -5, -7).rewrite(Sum, k=k) == \
+           exp(-37)*Sum((Rational(5, 7))**k*besseli(k, 35), (k, 4, oo))
+    assert eq([marcumq(1, 3, 1).rewrite(Sum).evalf(10)],
+              [0.9891705502])
+
+    assert marcumq(1, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(2, a, a, evaluate=False).rewrite(besseli) == S.Half + exp(-a**2)*besseli(0, a**2)/2 + \
+           exp(-a**2)*besseli(1, a**2)
+    assert marcumq(3, a, a).rewrite(besseli) == (besseli(1, a**2) + besseli(2, a**2))*exp(-a**2) + \
+           S.Half + exp(-a**2)*besseli(0, a**2)/2
+    assert marcumq(5, 8, 8).rewrite(besseli) == exp(-64)*besseli(0, 64)/2 + \
+           (besseli(4, 64) + besseli(3, 64) + besseli(2, 64) + besseli(1, 64))*exp(-64) + S.Half
+    assert marcumq(m, a, a).rewrite(besseli) == marcumq(m, a, a)
+
+    x = Symbol('x', integer=True)
+    assert marcumq(x, a, a).rewrite(besseli) == marcumq(x, a, a)
+
+
+def test_issue_26134():
+    x = Symbol('x')
+    assert marcumq(2, 3, 4).rewrite(Integral, x=x).dummy_eq(
+        Integral(x**2*exp(-x**2/2 - Rational(9, 2))*besseli(1, 3*x), (x, 4, oo))/3)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_beta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_beta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..b34cb2febf9e2746d869cd878525d2794535aea5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_beta_functions.py
@@ -0,0 +1,89 @@
+from sympy.core.function import (diff, expand_func)
+from sympy.core.numbers import I, Rational, pi
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.combinatorial.numbers import catalan
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.beta_functions import (beta, betainc, betainc_regularized)
+from sympy.functions.special.gamma_functions import gamma, polygamma
+from sympy.functions.special.hyper import hyper
+from sympy.integrals.integrals import Integral
+from sympy.core.function import ArgumentIndexError
+from sympy.core.expr import unchanged
+from sympy.testing.pytest import raises
+
+
+def test_beta():
+    x, y = symbols('x y')
+    t = Dummy('t')
+
+    assert unchanged(beta, x, y)
+    assert unchanged(beta, x, x)
+
+    assert beta(5, -3).is_real == True
+    assert beta(3, y).is_real is None
+
+    assert expand_func(beta(x, y)) == gamma(x)*gamma(y)/gamma(x + y)
+    assert expand_func(beta(x, y) - beta(y, x)) == 0  # Symmetric
+    assert expand_func(beta(x, y)) == expand_func(beta(x, y + 1) + beta(x + 1, y)).simplify()
+
+    assert diff(beta(x, y), x) == beta(x, y)*(polygamma(0, x) - polygamma(0, x + y))
+    assert diff(beta(x, y), y) == beta(x, y)*(polygamma(0, y) - polygamma(0, x + y))
+
+    assert conjugate(beta(x, y)) == beta(conjugate(x), conjugate(y))
+
+    raises(ArgumentIndexError, lambda: beta(x, y).fdiff(3))
+
+    assert beta(x, y).rewrite(gamma) == gamma(x)*gamma(y)/gamma(x + y)
+    assert beta(x).rewrite(gamma) == gamma(x)**2/gamma(2*x)
+    assert beta(x, y).rewrite(Integral).dummy_eq(Integral(t**(x - 1) * (1 - t)**(y - 1), (t, 0, 1)))
+    assert beta(Rational(-19, 10), Rational(-1, 10)) == S.Zero
+    assert beta(Rational(-19, 10), Rational(-9, 10)) == \
+        800*2**(S(4)/5)*sqrt(pi)*gamma(S.One/10)/(171*gamma(-S(7)/5))
+    assert beta(Rational(19, 10), Rational(29, 10)) == 100/(551*catalan(Rational(19, 10)))
+    assert beta(1, 0) == S.ComplexInfinity
+    assert beta(0, 1) == S.ComplexInfinity
+    assert beta(2, 3) == S.One/12
+    assert unchanged(beta, x, x + 1)
+    assert unchanged(beta, x, 1)
+    assert unchanged(beta, 1, y)
+    assert beta(x, x + 1).doit() == 1/(x*(x+1)*catalan(x))
+    assert beta(1, y).doit() == 1/y
+    assert beta(x, 1).doit() == 1/x
+    assert beta(Rational(-19, 10), Rational(-1, 10), evaluate=False).doit() == S.Zero
+    assert beta(2) == beta(2, 2)
+    assert beta(x, evaluate=False) != beta(x, x)
+    assert beta(x, evaluate=False).doit() == beta(x, x)
+
+
+def test_betainc():
+    a, b, x1, x2 = symbols('a b x1 x2')
+
+    assert unchanged(betainc, a, b, x1, x2)
+    assert unchanged(betainc, a, b, 0, x1)
+
+    assert betainc(1, 2, 0, -5).is_real == True
+    assert betainc(1, 2, 0, x2).is_real is None
+    assert conjugate(betainc(I, 2, 3 - I, 1 + 4*I)) == betainc(-I, 2, 3 + I, 1 - 4*I)
+
+    assert betainc(a, b, 0, 1).rewrite(Integral).dummy_eq(beta(a, b).rewrite(Integral))
+    assert betainc(1, 2, 0, x2).rewrite(hyper) == x2*hyper((1, -1), (2,), x2)
+
+    assert betainc(1, 2, 3, 3).evalf() == 0
+
+
+def test_betainc_regularized():
+    a, b, x1, x2 = symbols('a b x1 x2')
+
+    assert unchanged(betainc_regularized, a, b, x1, x2)
+    assert unchanged(betainc_regularized, a, b, 0, x1)
+
+    assert betainc_regularized(3, 5, 0, -1).is_real == True
+    assert betainc_regularized(3, 5, 0, x2).is_real is None
+    assert conjugate(betainc_regularized(3*I, 1, 2 + I, 1 + 2*I)) == betainc_regularized(-3*I, 1, 2 - I, 1 - 2*I)
+
+    assert betainc_regularized(a, b, 0, 1).rewrite(Integral) == 1
+    assert betainc_regularized(1, 2, x1, x2).rewrite(hyper) == 2*x2*hyper((1, -1), (2,), x2) - 2*x1*hyper((1, -1), (2,), x1)
+
+    assert betainc_regularized(4, 1, 5, 5).evalf() == 0
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bsplines.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bsplines.py
new file mode 100644
index 0000000000000000000000000000000000000000..136831b96ba16c95edba12ecd47b6f1566b68427
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_bsplines.py
@@ -0,0 +1,167 @@
+from sympy.functions import bspline_basis_set, interpolating_spline
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.logic.boolalg import And
+from sympy.sets.sets import Interval
+from sympy.testing.pytest import slow
+
+x, y = symbols('x,y')
+
+
+def test_basic_degree_0():
+    d = 0
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    for i in range(len(splines)):
+        assert splines[i] == Piecewise((1, Interval(i, i + 1).contains(x)),
+                                       (0, True))
+
+
+def test_basic_degree_1():
+    d = 1
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    assert splines[0] == Piecewise((x, Interval(0, 1).contains(x)),
+                                   (2 - x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[1] == Piecewise((-1 + x, Interval(1, 2).contains(x)),
+                                   (3 - x, Interval(2, 3).contains(x)),
+                                   (0, True))
+    assert splines[2] == Piecewise((-2 + x, Interval(2, 3).contains(x)),
+                                   (4 - x, Interval(3, 4).contains(x)),
+                                   (0, True))
+
+
+def test_basic_degree_2():
+    d = 2
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    b0 = Piecewise((x**2/2, Interval(0, 1).contains(x)),
+                   (Rational(-3, 2) + 3*x - x**2, Interval(1, 2).contains(x)),
+                   (Rational(9, 2) - 3*x + x**2/2, Interval(2, 3).contains(x)),
+                   (0, True))
+    b1 = Piecewise((S.Half - x + x**2/2, Interval(1, 2).contains(x)),
+                   (Rational(-11, 2) + 5*x - x**2, Interval(2, 3).contains(x)),
+                   (8 - 4*x + x**2/2, Interval(3, 4).contains(x)),
+                   (0, True))
+    assert splines[0] == b0
+    assert splines[1] == b1
+
+
+def test_basic_degree_3():
+    d = 3
+    knots = range(5)
+    splines = bspline_basis_set(d, knots, x)
+    b0 = Piecewise(
+        (x**3/6, Interval(0, 1).contains(x)),
+        (Rational(2, 3) - 2*x + 2*x**2 - x**3/2, Interval(1, 2).contains(x)),
+        (Rational(-22, 3) + 10*x - 4*x**2 + x**3/2, Interval(2, 3).contains(x)),
+        (Rational(32, 3) - 8*x + 2*x**2 - x**3/6, Interval(3, 4).contains(x)),
+        (0, True)
+    )
+    assert splines[0] == b0
+
+
+def test_repeated_degree_1():
+    d = 1
+    knots = [0, 0, 1, 2, 2, 3, 4, 4]
+    splines = bspline_basis_set(d, knots, x)
+    assert splines[0] == Piecewise((1 - x, Interval(0, 1).contains(x)),
+                                   (0, True))
+    assert splines[1] == Piecewise((x, Interval(0, 1).contains(x)),
+                                   (2 - x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[2] == Piecewise((-1 + x, Interval(1, 2).contains(x)),
+                                   (0, True))
+    assert splines[3] == Piecewise((3 - x, Interval(2, 3).contains(x)),
+                                   (0, True))
+    assert splines[4] == Piecewise((-2 + x, Interval(2, 3).contains(x)),
+                                   (4 - x, Interval(3, 4).contains(x)),
+                                   (0, True))
+    assert splines[5] == Piecewise((-3 + x, Interval(3, 4).contains(x)),
+                                   (0, True))
+
+
+def test_repeated_degree_2():
+    d = 2
+    knots = [0, 0, 1, 2, 2, 3, 4, 4]
+    splines = bspline_basis_set(d, knots, x)
+
+    assert splines[0] == Piecewise(((-3*x**2/2 + 2*x), And(x <= 1, x >= 0)),
+                                   (x**2/2 - 2*x + 2, And(x <= 2, x >= 1)),
+                                   (0, True))
+    assert splines[1] == Piecewise((x**2/2, And(x <= 1, x >= 0)),
+                                   (-3*x**2/2 + 4*x - 2, And(x <= 2, x >= 1)),
+                                   (0, True))
+    assert splines[2] == Piecewise((x**2 - 2*x + 1, And(x <= 2, x >= 1)),
+                                   (x**2 - 6*x + 9, And(x <= 3, x >= 2)),
+                                   (0, True))
+    assert splines[3] == Piecewise((-3*x**2/2 + 8*x - 10, And(x <= 3, x >= 2)),
+                                   (x**2/2 - 4*x + 8, And(x <= 4, x >= 3)),
+                                   (0, True))
+    assert splines[4] == Piecewise((x**2/2 - 2*x + 2, And(x <= 3, x >= 2)),
+                                   (-3*x**2/2 + 10*x - 16, And(x <= 4, x >= 3)),
+                                   (0, True))
+
+# Tests for interpolating_spline
+
+
+def test_10_points_degree_1():
+    d = 1
+    X = [-5, 2, 3, 4, 7, 9, 10, 30, 31, 34]
+    Y = [-10, -2, 2, 4, 7, 6, 20, 45, 19, 25]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((x*Rational(8, 7) - Rational(30, 7), (x >= -5) & (x <= 2)), (4*x - 10, (x >= 2) & (x <= 3)),
+                               (2*x - 4, (x >= 3) & (x <= 4)), (x, (x >= 4) & (x <= 7)),
+                               (-x/2 + Rational(21, 2), (x >= 7) & (x <= 9)), (14*x - 120, (x >= 9) & (x <= 10)),
+                               (x*Rational(5, 4) + Rational(15, 2), (x >= 10) & (x <= 30)), (-26*x + 825, (x >= 30) & (x <= 31)),
+                               (2*x - 43, (x >= 31) & (x <= 34)))
+
+
+def test_3_points_degree_2():
+    d = 2
+    X = [-3, 10, 19]
+    Y = [3, -4, 30]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((505*x**2/2574 - x*Rational(4921, 2574) - Rational(1931, 429), (x >= -3) & (x <= 19)))
+
+
+def test_5_points_degree_2():
+    d = 2
+    X = [-3, 2, 4, 5, 10]
+    Y = [-1, 2, 5, 10, 14]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((4*x**2/329 + x*Rational(1007, 1645) + Rational(1196, 1645), (x >= -3) & (x <= 3)),
+                               (2701*x**2/1645 - x*Rational(15079, 1645) + Rational(5065, 329), (x >= 3) & (x <= Rational(9, 2))),
+                               (-1319*x**2/1645 + x*Rational(21101, 1645) - Rational(11216, 329), (x >= Rational(9, 2)) & (x <= 10)))
+
+
+@slow
+def test_6_points_degree_3():
+    d = 3
+    X = [-1, 0, 2, 3, 9, 12]
+    Y = [-4, 3, 3, 7, 9, 20]
+    spline = interpolating_spline(d, x, X, Y)
+
+    assert spline == Piecewise((6058*x**3/5301 - 18427*x**2/5301 + x*Rational(12622, 5301) + 3, (x >= -1) & (x <= 2)),
+                               (-8327*x**3/5301 + 67883*x**2/5301 - x*Rational(159998, 5301) + Rational(43661, 1767), (x >= 2) & (x <= 3)),
+                               (5414*x**3/47709 - 1386*x**2/589 + x*Rational(4267, 279) - Rational(12232, 589), (x >= 3) & (x <= 12)))
+
+
+def test_issue_19262():
+    Delta = symbols('Delta', positive=True)
+    knots = [i*Delta for i in range(4)]
+    basis = bspline_basis_set(1, knots, x)
+    y = symbols('y', nonnegative=True)
+    basis2 = bspline_basis_set(1, knots, y)
+    assert basis[0].subs(x, y) == basis2[0]
+    assert interpolating_spline(1, x,
+        [Delta*i for i in [1, 2, 4, 7]], [3, 6, 5, 7]
+        )  == Piecewise((3*x/Delta, (Delta <= x) & (x <= 2*Delta)),
+        (7 - x/(2*Delta), (x >= 2*Delta) & (x <= 4*Delta)),
+        (Rational(7, 3) + 2*x/(3*Delta), (x >= 4*Delta) & (x <= 7*Delta)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_delta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_delta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5a39d9e352143cf878cf69fa42f454f58be65c9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_delta_functions.py
@@ -0,0 +1,165 @@
+from sympy.core.numbers import (I, nan, oo, pi)
+from sympy.core.relational import (Eq, Ne)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import (adjoint, conjugate, sign, transpose)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.simplify.simplify import signsimp
+
+
+from sympy.testing.pytest import raises
+
+from sympy.core.expr import unchanged
+
+from sympy.core.function import ArgumentIndexError
+
+
+x, y = symbols('x y')
+i = symbols('t', nonzero=True)
+j = symbols('j', positive=True)
+k = symbols('k', negative=True)
+
+def test_DiracDelta():
+    assert DiracDelta(1) == 0
+    assert DiracDelta(5.1) == 0
+    assert DiracDelta(-pi) == 0
+    assert DiracDelta(5, 7) == 0
+    assert DiracDelta(x, 0) == DiracDelta(x)
+    assert DiracDelta(i) == 0
+    assert DiracDelta(j) == 0
+    assert DiracDelta(k) == 0
+    assert DiracDelta(nan) is nan
+    assert DiracDelta(0).func is DiracDelta
+    assert DiracDelta(x).func is DiracDelta
+    # FIXME: this is generally undefined @ x=0
+    #         But then limit(Delta(c)*Heaviside(x),x,-oo)
+    #         need's to be implemented.
+    # assert 0*DiracDelta(x) == 0
+
+    assert adjoint(DiracDelta(x)) == DiracDelta(x)
+    assert adjoint(DiracDelta(x - y)) == DiracDelta(x - y)
+    assert conjugate(DiracDelta(x)) == DiracDelta(x)
+    assert conjugate(DiracDelta(x - y)) == DiracDelta(x - y)
+    assert transpose(DiracDelta(x)) == DiracDelta(x)
+    assert transpose(DiracDelta(x - y)) == DiracDelta(x - y)
+
+    assert DiracDelta(x).diff(x) == DiracDelta(x, 1)
+    assert DiracDelta(x, 1).diff(x) == DiracDelta(x, 2)
+
+    assert DiracDelta(x).is_simple(x) is True
+    assert DiracDelta(3*x).is_simple(x) is True
+    assert DiracDelta(x**2).is_simple(x) is False
+    assert DiracDelta(sqrt(x)).is_simple(x) is False
+    assert DiracDelta(x).is_simple(y) is False
+
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=x) == DiracDelta(x)/abs(y)
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=y) == DiracDelta(y)/abs(x)
+    assert DiracDelta(x**2*y).expand(diracdelta=True, wrt=x) == DiracDelta(x**2*y)
+    assert DiracDelta(y).expand(diracdelta=True, wrt=x) == DiracDelta(y)
+    assert DiracDelta((x - 1)*(x - 2)*(x - 3)).expand(diracdelta=True, wrt=x) == (
+        DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
+
+    assert DiracDelta(2*x) != DiracDelta(x)  # scaling property
+    assert DiracDelta(x) == DiracDelta(-x)  # even function
+    assert DiracDelta(-x, 2) == DiracDelta(x, 2)
+    assert DiracDelta(-x, 1) == -DiracDelta(x, 1)  # odd deriv is odd
+    assert DiracDelta(-oo*x) == DiracDelta(oo*x)
+    assert DiracDelta(x - y) != DiracDelta(y - x)
+    assert signsimp(DiracDelta(x - y) - DiracDelta(y - x)) == 0
+
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=x) == DiracDelta(x)/abs(y)
+    assert DiracDelta(x*y).expand(diracdelta=True, wrt=y) == DiracDelta(y)/abs(x)
+    assert DiracDelta(x**2*y).expand(diracdelta=True, wrt=x) == DiracDelta(x**2*y)
+    assert DiracDelta(y).expand(diracdelta=True, wrt=x) == DiracDelta(y)
+    assert DiracDelta((x - 1)*(x - 2)*(x - 3)).expand(diracdelta=True) == (
+            DiracDelta(x - 3)/2 + DiracDelta(x - 2) + DiracDelta(x - 1)/2)
+
+    raises(ArgumentIndexError, lambda: DiracDelta(x).fdiff(2))
+    raises(ValueError, lambda: DiracDelta(x, -1))
+    raises(ValueError, lambda: DiracDelta(I))
+    raises(ValueError, lambda: DiracDelta(2 + 3*I))
+
+
+def test_heaviside():
+    assert Heaviside(-5) == 0
+    assert Heaviside(1) == 1
+    assert Heaviside(0) == S.Half
+
+    assert Heaviside(0, x) == x
+    assert unchanged(Heaviside,x, nan)
+    assert Heaviside(0, nan) == nan
+
+    h0  = Heaviside(x, 0)
+    h12 = Heaviside(x, S.Half)
+    h1  = Heaviside(x, 1)
+
+    assert h0.args == h0.pargs == (x, 0)
+    assert h1.args == h1.pargs == (x, 1)
+    assert h12.args == (x, S.Half)
+    assert h12.pargs == (x,) # default 1/2 suppressed
+
+    assert adjoint(Heaviside(x)) == Heaviside(x)
+    assert adjoint(Heaviside(x - y)) == Heaviside(x - y)
+    assert conjugate(Heaviside(x)) == Heaviside(x)
+    assert conjugate(Heaviside(x - y)) == Heaviside(x - y)
+    assert transpose(Heaviside(x)) == Heaviside(x)
+    assert transpose(Heaviside(x - y)) == Heaviside(x - y)
+
+    assert Heaviside(x).diff(x) == DiracDelta(x)
+    assert Heaviside(x + I).is_Function is True
+    assert Heaviside(I*x).is_Function is True
+
+    raises(ArgumentIndexError, lambda: Heaviside(x).fdiff(2))
+    raises(ValueError, lambda: Heaviside(I))
+    raises(ValueError, lambda: Heaviside(2 + 3*I))
+
+
+def test_rewrite():
+    x, y = Symbol('x', real=True), Symbol('y')
+    assert Heaviside(x).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (Heaviside(0), Eq(x, 0)), (1, True)))
+    assert Heaviside(y).rewrite(Piecewise) == (
+        Piecewise((0, y < 0), (Heaviside(0), Eq(y, 0)), (1, True)))
+    assert Heaviside(x, y).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (y, Eq(x, 0)), (1, True)))
+    assert Heaviside(x, 0).rewrite(Piecewise) == (
+        Piecewise((0, x <= 0), (1, True)))
+    assert Heaviside(x, 1).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (1, True)))
+    assert Heaviside(x, nan).rewrite(Piecewise) == (
+        Piecewise((0, x < 0), (nan, Eq(x, 0)), (1, True)))
+
+    assert Heaviside(x).rewrite(sign) == \
+        Heaviside(x, H0=Heaviside(0)).rewrite(sign) == \
+        Piecewise(
+            (sign(x)/2 + S(1)/2, Eq(Heaviside(0), S(1)/2)),
+            (Piecewise(
+                (sign(x)/2 + S(1)/2, Ne(x, 0)), (Heaviside(0), True)), True)
+        )
+
+    assert Heaviside(y).rewrite(sign) == Heaviside(y)
+    assert Heaviside(x, S.Half).rewrite(sign) == (sign(x)+1)/2
+    assert Heaviside(x, y).rewrite(sign) == \
+        Piecewise(
+            (sign(x)/2 + S(1)/2, Eq(y, S(1)/2)),
+            (Piecewise(
+                (sign(x)/2 + S(1)/2, Ne(x, 0)), (y, True)), True)
+        )
+
+    assert DiracDelta(y).rewrite(Piecewise) == Piecewise((DiracDelta(0), Eq(y, 0)), (0, True))
+    assert DiracDelta(y, 1).rewrite(Piecewise) == DiracDelta(y, 1)
+    assert DiracDelta(x - 5).rewrite(Piecewise) == (
+        Piecewise((DiracDelta(0), Eq(x - 5, 0)), (0, True)))
+
+    assert (x*DiracDelta(x - 10)).rewrite(SingularityFunction) == x*SingularityFunction(x, 10, -1)
+    assert 5*x*y*DiracDelta(y, 1).rewrite(SingularityFunction) == 5*x*y*SingularityFunction(y, 0, -2)
+    assert DiracDelta(0).rewrite(SingularityFunction) == SingularityFunction(0, 0, -1)
+    assert DiracDelta(0, 1).rewrite(SingularityFunction) == SingularityFunction(0, 0, -2)
+
+    assert Heaviside(x).rewrite(SingularityFunction) == SingularityFunction(x, 0, 0)
+    assert 5*x*y*Heaviside(y + 1).rewrite(SingularityFunction) == 5*x*y*SingularityFunction(y, -1, 0)
+    assert ((x - 3)**3*Heaviside(x - 3)).rewrite(SingularityFunction) == (x - 3)**3*SingularityFunction(x, 3, 0)
+    assert Heaviside(0).rewrite(SingularityFunction) == S.Half
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_elliptic_integrals.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_elliptic_integrals.py
new file mode 100644
index 0000000000000000000000000000000000000000..a11e531af32301a00b6fc864064d02f9318929e1
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_elliptic_integrals.py
@@ -0,0 +1,181 @@
+from sympy.core.numbers import (I, Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.elementary.hyperbolic import atanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (sin, tan)
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.integrals.integrals import Integral
+from sympy.series.order import O
+from sympy.functions.special.elliptic_integrals import (elliptic_k as K,
+    elliptic_f as F, elliptic_e as E, elliptic_pi as P)
+from sympy.core.random import (test_derivative_numerically as td,
+                                      random_complex_number as randcplx,
+                                      verify_numerically as tn)
+from sympy.abc import z, m, n
+
+i = Symbol('i', integer=True)
+j = Symbol('k', integer=True, positive=True)
+t = Dummy('t')
+
+def test_K():
+    assert K(0) == pi/2
+    assert K(S.Half) == 8*pi**Rational(3, 2)/gamma(Rational(-1, 4))**2
+    assert K(1) is zoo
+    assert K(-1) == gamma(Rational(1, 4))**2/(4*sqrt(2*pi))
+    assert K(oo) == 0
+    assert K(-oo) == 0
+    assert K(I*oo) == 0
+    assert K(-I*oo) == 0
+    assert K(zoo) == 0
+
+    assert K(z).diff(z) == (E(z) - (1 - z)*K(z))/(2*z*(1 - z))
+    assert td(K(z), z)
+
+    zi = Symbol('z', real=False)
+    assert K(zi).conjugate() == K(zi.conjugate())
+    zr = Symbol('z', negative=True)
+    assert K(zr).conjugate() == K(zr)
+
+    assert K(z).rewrite(hyper) == \
+        (pi/2)*hyper((S.Half, S.Half), (S.One,), z)
+    assert tn(K(z), (pi/2)*hyper((S.Half, S.Half), (S.One,), z))
+    assert K(z).rewrite(meijerg) == \
+        meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z)/2
+    assert tn(K(z), meijerg(((S.Half, S.Half), []), ((S.Zero,), (S.Zero,)), -z)/2)
+
+    assert K(z).series(z) == pi/2 + pi*z/8 + 9*pi*z**2/128 + \
+        25*pi*z**3/512 + 1225*pi*z**4/32768 + 3969*pi*z**5/131072 + O(z**6)
+
+    assert K(m).rewrite(Integral).dummy_eq(
+        Integral(1/sqrt(1 - m*sin(t)**2), (t, 0, pi/2)))
+
+def test_F():
+    assert F(z, 0) == z
+    assert F(0, m) == 0
+    assert F(pi*i/2, m) == i*K(m)
+    assert F(z, oo) == 0
+    assert F(z, -oo) == 0
+
+    assert F(-z, m) == -F(z, m)
+
+    assert F(z, m).diff(z) == 1/sqrt(1 - m*sin(z)**2)
+    assert F(z, m).diff(m) == E(z, m)/(2*m*(1 - m)) - F(z, m)/(2*m) - \
+        sin(2*z)/(4*(1 - m)*sqrt(1 - m*sin(z)**2))
+    r = randcplx()
+    assert td(F(z, r), z)
+    assert td(F(r, m), m)
+
+    mi = Symbol('m', real=False)
+    assert F(z, mi).conjugate() == F(z.conjugate(), mi.conjugate())
+    mr = Symbol('m', negative=True)
+    assert F(z, mr).conjugate() == F(z.conjugate(), mr)
+
+    assert F(z, m).series(z) == \
+        z + z**5*(3*m**2/40 - m/30) + m*z**3/6 + O(z**6)
+
+    assert F(z, m).rewrite(Integral).dummy_eq(
+        Integral(1/sqrt(1 - m*sin(t)**2), (t, 0, z)))
+
+def test_E():
+    assert E(z, 0) == z
+    assert E(0, m) == 0
+    assert E(i*pi/2, m) == i*E(m)
+    assert E(z, oo) is zoo
+    assert E(z, -oo) is zoo
+    assert E(0) == pi/2
+    assert E(1) == 1
+    assert E(oo) == I*oo
+    assert E(-oo) is oo
+    assert E(zoo) is zoo
+
+    assert E(-z, m) == -E(z, m)
+
+    assert E(z, m).diff(z) == sqrt(1 - m*sin(z)**2)
+    assert E(z, m).diff(m) == (E(z, m) - F(z, m))/(2*m)
+    assert E(z).diff(z) == (E(z) - K(z))/(2*z)
+    r = randcplx()
+    assert td(E(r, m), m)
+    assert td(E(z, r), z)
+    assert td(E(z), z)
+
+    mi = Symbol('m', real=False)
+    assert E(z, mi).conjugate() == E(z.conjugate(), mi.conjugate())
+    assert E(mi).conjugate() == E(mi.conjugate())
+    mr = Symbol('m', negative=True)
+    assert E(z, mr).conjugate() == E(z.conjugate(), mr)
+    assert E(mr).conjugate() == E(mr)
+
+    assert E(z).rewrite(hyper) == (pi/2)*hyper((Rational(-1, 2), S.Half), (S.One,), z)
+    assert tn(E(z), (pi/2)*hyper((Rational(-1, 2), S.Half), (S.One,), z))
+    assert E(z).rewrite(meijerg) == \
+        -meijerg(((S.Half, Rational(3, 2)), []), ((S.Zero,), (S.Zero,)), -z)/4
+    assert tn(E(z), -meijerg(((S.Half, Rational(3, 2)), []), ((S.Zero,), (S.Zero,)), -z)/4)
+
+    assert E(z, m).series(z) == \
+        z + z**5*(-m**2/40 + m/30) - m*z**3/6 + O(z**6)
+    assert E(z).series(z) == pi/2 - pi*z/8 - 3*pi*z**2/128 - \
+        5*pi*z**3/512 - 175*pi*z**4/32768 - 441*pi*z**5/131072 + O(z**6)
+    assert E(4*z/(z+1)).series(z) == \
+        pi/2 - pi*z/2 + pi*z**2/8 - 3*pi*z**3/8 - 15*pi*z**4/128 - 93*pi*z**5/128 + O(z**6)
+
+    assert E(z, m).rewrite(Integral).dummy_eq(
+        Integral(sqrt(1 - m*sin(t)**2), (t, 0, z)))
+    assert E(m).rewrite(Integral).dummy_eq(
+        Integral(sqrt(1 - m*sin(t)**2), (t, 0, pi/2)))
+
+def test_P():
+    assert P(0, z, m) == F(z, m)
+    assert P(1, z, m) == F(z, m) + \
+        (sqrt(1 - m*sin(z)**2)*tan(z) - E(z, m))/(1 - m)
+    assert P(n, i*pi/2, m) == i*P(n, m)
+    assert P(n, z, 0) == atanh(sqrt(n - 1)*tan(z))/sqrt(n - 1)
+    assert P(n, z, n) == F(z, n) - P(1, z, n) + tan(z)/sqrt(1 - n*sin(z)**2)
+    assert P(oo, z, m) == 0
+    assert P(-oo, z, m) == 0
+    assert P(n, z, oo) == 0
+    assert P(n, z, -oo) == 0
+    assert P(0, m) == K(m)
+    assert P(1, m) is zoo
+    assert P(n, 0) == pi/(2*sqrt(1 - n))
+    assert P(2, 1) is -oo
+    assert P(-1, 1) is oo
+    assert P(n, n) == E(n)/(1 - n)
+
+    assert P(n, -z, m) == -P(n, z, m)
+
+    ni, mi = Symbol('n', real=False), Symbol('m', real=False)
+    assert P(ni, z, mi).conjugate() == \
+        P(ni.conjugate(), z.conjugate(), mi.conjugate())
+    nr, mr = Symbol('n', negative=True), \
+        Symbol('m', negative=True)
+    assert P(nr, z, mr).conjugate() == P(nr, z.conjugate(), mr)
+    assert P(n, m).conjugate() == P(n.conjugate(), m.conjugate())
+
+    assert P(n, z, m).diff(n) == (E(z, m) + (m - n)*F(z, m)/n +
+        (n**2 - m)*P(n, z, m)/n - n*sqrt(1 -
+            m*sin(z)**2)*sin(2*z)/(2*(1 - n*sin(z)**2)))/(2*(m - n)*(n - 1))
+    assert P(n, z, m).diff(z) == 1/(sqrt(1 - m*sin(z)**2)*(1 - n*sin(z)**2))
+    assert P(n, z, m).diff(m) == (E(z, m)/(m - 1) + P(n, z, m) -
+        m*sin(2*z)/(2*(m - 1)*sqrt(1 - m*sin(z)**2)))/(2*(n - m))
+    assert P(n, m).diff(n) == (E(m) + (m - n)*K(m)/n +
+        (n**2 - m)*P(n, m)/n)/(2*(m - n)*(n - 1))
+    assert P(n, m).diff(m) == (E(m)/(m - 1) + P(n, m))/(2*(n - m))
+
+    # These tests fail due to
+    # https://github.com/fredrik-johansson/mpmath/issues/571#issuecomment-777201962
+    # https://github.com/sympy/sympy/issues/20933#issuecomment-777080385
+    #
+    # rx, ry = randcplx(), randcplx()
+    # assert td(P(n, rx, ry), n)
+    # assert td(P(rx, z, ry), z)
+    # assert td(P(rx, ry, m), m)
+
+    assert P(n, z, m).series(z) == z + z**3*(m/6 + n/3) + \
+        z**5*(3*m**2/40 + m*n/10 - m/30 + n**2/5 - n/15) + O(z**6)
+
+    assert P(n, z, m).rewrite(Integral).dummy_eq(
+        Integral(1/((1 - n*sin(t)**2)*sqrt(1 - m*sin(t)**2)), (t, 0, z)))
+    assert P(n, m).rewrite(Integral).dummy_eq(
+        Integral(1/((1 - n*sin(t)**2)*sqrt(1 - m*sin(t)**2)), (t, 0, pi/2)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_error_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_error_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..073371d3d584b97936729dc2e39c833ac347559b
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_error_functions.py
@@ -0,0 +1,860 @@
+from sympy.core.function import (diff, expand, expand_func)
+from sympy.core import EulerGamma
+from sympy.core.numbers import (E, Float, I, Rational, nan, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols, Dummy)
+from sympy.functions.elementary.complexes import (conjugate, im, polar_lift, re)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import (cosh, sinh)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, sinc)
+from sympy.functions.special.error_functions import (Chi, Ci, E1, Ei, Li, Shi, Si, erf, erf2, erf2inv, erfc, erfcinv, erfi, erfinv, expint, fresnelc, fresnels, li)
+from sympy.functions.special.gamma_functions import (gamma, uppergamma)
+from sympy.functions.special.hyper import (hyper, meijerg)
+from sympy.integrals.integrals import (Integral, integrate)
+from sympy.series.gruntz import gruntz
+from sympy.series.limits import limit
+from sympy.series.order import O
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.special.error_functions import _erfs, _eis
+from sympy.testing.pytest import raises
+
+x, y, z = symbols('x,y,z')
+w = Symbol("w", real=True)
+n = Symbol("n", integer=True)
+t = Dummy('t')
+
+
+def test_erf():
+    assert erf(nan) is nan
+
+    assert erf(oo) == 1
+    assert erf(-oo) == -1
+
+    assert erf(0) is S.Zero
+
+    assert erf(I*oo) == oo*I
+    assert erf(-I*oo) == -oo*I
+
+    assert erf(-2) == -erf(2)
+    assert erf(-x*y) == -erf(x*y)
+    assert erf(-x - y) == -erf(x + y)
+
+    assert erf(erfinv(x)) == x
+    assert erf(erfcinv(x)) == 1 - x
+    assert erf(erf2inv(0, x)) == x
+    assert erf(erf2inv(0, x, evaluate=False)) == x # To cover code in erf
+    assert erf(erf2inv(0, erf(erfcinv(1 - erf(erfinv(x)))))) == x
+
+    alpha = symbols('alpha', extended_real=True)
+    assert erf(alpha).is_real is True
+    assert erf(alpha).is_finite is True
+    alpha = symbols('alpha', extended_real=False)
+    assert erf(alpha).is_real is None
+    assert erf(alpha).is_finite is None
+    assert erf(alpha).is_zero is None
+    assert erf(alpha).is_positive is None
+    assert erf(alpha).is_negative is None
+    alpha = symbols('alpha', extended_positive=True)
+    assert erf(alpha).is_positive is True
+    alpha = symbols('alpha', extended_negative=True)
+    assert erf(alpha).is_negative is True
+    assert erf(I).is_real is False
+    assert erf(0, evaluate=False).is_real
+    assert erf(0, evaluate=False).is_zero
+
+    assert conjugate(erf(z)) == erf(conjugate(z))
+
+    assert erf(x).as_leading_term(x) == 2*x/sqrt(pi)
+    assert erf(x*y).as_leading_term(y) == 2*x*y/sqrt(pi)
+    assert (erf(x*y)/erf(y)).as_leading_term(y) == x
+    assert erf(1/x).as_leading_term(x) == S.One
+
+    assert erf(z).rewrite('uppergamma') == sqrt(z**2)*(1 - erfc(sqrt(z**2)))/z
+    assert erf(z).rewrite('erfc') == S.One - erfc(z)
+    assert erf(z).rewrite('erfi') == -I*erfi(I*z)
+    assert erf(z).rewrite('fresnels') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erf(z).rewrite('fresnelc') == (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erf(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], -z**2)/sqrt(pi)
+    assert erf(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)/sqrt(pi)
+    assert erf(z).rewrite('expint') == sqrt(z**2)/z - z*expint(S.Half, z**2)/sqrt(S.Pi)
+
+    assert limit(exp(x)*exp(x**2)*(erf(x + 1/exp(x)) - erf(x)), x, oo) == \
+        2/sqrt(pi)
+    assert limit((1 - erf(z))*exp(z**2)*z, z, oo) == 1/sqrt(pi)
+    assert limit((1 - erf(x))*exp(x**2)*sqrt(pi)*x, x, oo) == 1
+    assert limit(((1 - erf(x))*exp(x**2)*sqrt(pi)*x - 1)*2*x**2, x, oo) == -1
+    assert limit(erf(x)/x, x, 0) == 2/sqrt(pi)
+    assert limit(x**(-4) - sqrt(pi)*erf(x**2) / (2*x**6), x, 0) == S(1)/3
+
+    assert erf(x).as_real_imag() == \
+        (erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
+         -I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
+
+    assert erf(x).as_real_imag(deep=False) == \
+        (erf(re(x) - I*im(x))/2 + erf(re(x) + I*im(x))/2,
+         -I*(-erf(re(x) - I*im(x)) + erf(re(x) + I*im(x)))/2)
+
+    assert erf(w).as_real_imag() == (erf(w), 0)
+    assert erf(w).as_real_imag(deep=False) == (erf(w), 0)
+    # issue 13575
+    assert erf(I).as_real_imag() == (0, -I*erf(I))
+
+    raises(ArgumentIndexError, lambda: erf(x).fdiff(2))
+
+    assert erf(x).inverse() == erfinv
+
+
+def test_erf_series():
+    assert erf(x).series(x, 0, 7) == 2*x/sqrt(pi) - \
+        2*x**3/3/sqrt(pi) + x**5/5/sqrt(pi) + O(x**7)
+
+    assert erf(x).series(x, oo) == \
+        -exp(-x**2)*(3/(4*x**5) - 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))/sqrt(pi) + 1
+    assert erf(x**2).series(x, oo, n=8) == \
+        (-1/(2*x**6) + x**(-2) + O(x**(-8), (x, oo)))*exp(-x**4)/sqrt(pi)*-1 + 1
+    assert erf(sqrt(x)).series(x, oo, n=3) == (sqrt(1/x) - (1/x)**(S(3)/2)/2\
+        + 3*(1/x)**(S(5)/2)/4 + O(x**(-3), (x, oo)))*exp(-x)/sqrt(pi)*-1 + 1
+
+
+def test_erf_evalf():
+    assert abs( erf(Float(2.0)) - 0.995322265 ) < 1E-8 # XXX
+
+
+def test__erfs():
+    assert _erfs(z).diff(z) == -2/sqrt(S.Pi) + 2*z*_erfs(z)
+
+    assert _erfs(1/z).series(z) == \
+        z/sqrt(pi) - z**3/(2*sqrt(pi)) + 3*z**5/(4*sqrt(pi)) + O(z**6)
+
+    assert expand(erf(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == erf(z).diff(z)
+    assert _erfs(z).rewrite("intractable") == (-erf(z) + 1)*exp(z**2)
+    raises(ArgumentIndexError, lambda: _erfs(z).fdiff(2))
+
+
+def test_erfc():
+    assert erfc(nan) is nan
+
+    assert erfc(oo) is S.Zero
+    assert erfc(-oo) == 2
+
+    assert erfc(0) == 1
+
+    assert erfc(I*oo) == -oo*I
+    assert erfc(-I*oo) == oo*I
+
+    assert erfc(-x) == S(2) - erfc(x)
+    assert erfc(erfcinv(x)) == x
+
+    alpha = symbols('alpha', extended_real=True)
+    assert erfc(alpha).is_real is True
+    alpha = symbols('alpha', extended_real=False)
+    assert erfc(alpha).is_real is None
+    assert erfc(I).is_real is False
+    assert erfc(0, evaluate=False).is_real
+    assert erfc(0, evaluate=False).is_zero is False
+
+    assert erfc(erfinv(x)) == 1 - x
+
+    assert conjugate(erfc(z)) == erfc(conjugate(z))
+
+    assert erfc(x).as_leading_term(x) is S.One
+    assert erfc(1/x).as_leading_term(x) == S.Zero
+
+    assert erfc(z).rewrite('erf') == 1 - erf(z)
+    assert erfc(z).rewrite('erfi') == 1 + I*erfi(I*z)
+    assert erfc(z).rewrite('fresnels') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erfc(z).rewrite('fresnelc') == 1 - (1 + I)*(fresnelc(z*(1 - I)/sqrt(pi)) -
+        I*fresnels(z*(1 - I)/sqrt(pi)))
+    assert erfc(z).rewrite('hyper') == 1 - 2*z*hyper([S.Half], [3*S.Half], -z**2)/sqrt(pi)
+    assert erfc(z).rewrite('meijerg') == 1 - z*meijerg([S.Half], [], [0], [Rational(-1, 2)], z**2)/sqrt(pi)
+    assert erfc(z).rewrite('uppergamma') == 1 - sqrt(z**2)*(1 - erfc(sqrt(z**2)))/z
+    assert erfc(z).rewrite('expint') == S.One - sqrt(z**2)/z + z*expint(S.Half, z**2)/sqrt(S.Pi)
+    assert erfc(z).rewrite('tractable') == _erfs(z)*exp(-z**2)
+    assert expand_func(erf(x) + erfc(x)) is S.One
+
+    assert erfc(x).as_real_imag() == \
+        (erfc(re(x) - I*im(x))/2 + erfc(re(x) + I*im(x))/2,
+         -I*(-erfc(re(x) - I*im(x)) + erfc(re(x) + I*im(x)))/2)
+
+    assert erfc(x).as_real_imag(deep=False) == \
+        (erfc(re(x) - I*im(x))/2 + erfc(re(x) + I*im(x))/2,
+         -I*(-erfc(re(x) - I*im(x)) + erfc(re(x) + I*im(x)))/2)
+
+    assert erfc(w).as_real_imag() == (erfc(w), 0)
+    assert erfc(w).as_real_imag(deep=False) == (erfc(w), 0)
+    raises(ArgumentIndexError, lambda: erfc(x).fdiff(2))
+
+    assert erfc(x).inverse() == erfcinv
+
+
+def test_erfc_series():
+    assert erfc(x).series(x, 0, 7) == 1 - 2*x/sqrt(pi) + \
+        2*x**3/3/sqrt(pi) - x**5/5/sqrt(pi) + O(x**7)
+
+    assert erfc(x).series(x, oo) == \
+            (3/(4*x**5) - 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))*exp(-x**2)/sqrt(pi)
+
+
+def test_erfc_evalf():
+    assert abs( erfc(Float(2.0)) - 0.00467773 ) < 1E-8 # XXX
+
+
+def test_erfi():
+    assert erfi(nan) is nan
+
+    assert erfi(oo) is S.Infinity
+    assert erfi(-oo) is S.NegativeInfinity
+
+    assert erfi(0) is S.Zero
+
+    assert erfi(I*oo) == I
+    assert erfi(-I*oo) == -I
+
+    assert erfi(-x) == -erfi(x)
+
+    assert erfi(I*erfinv(x)) == I*x
+    assert erfi(I*erfcinv(x)) == I*(1 - x)
+    assert erfi(I*erf2inv(0, x)) == I*x
+    assert erfi(I*erf2inv(0, x, evaluate=False)) == I*x # To cover code in erfi
+
+    assert erfi(I).is_real is False
+    assert erfi(0, evaluate=False).is_real
+    assert erfi(0, evaluate=False).is_zero
+
+    assert conjugate(erfi(z)) == erfi(conjugate(z))
+
+    assert erfi(x).as_leading_term(x) == 2*x/sqrt(pi)
+    assert erfi(x*y).as_leading_term(y) == 2*x*y/sqrt(pi)
+    assert (erfi(x*y)/erfi(y)).as_leading_term(y) == x
+    assert erfi(1/x).as_leading_term(x) == erfi(1/x)
+
+    assert erfi(z).rewrite('erf') == -I*erf(I*z)
+    assert erfi(z).rewrite('erfc') == I*erfc(I*z) - I
+    assert erfi(z).rewrite('fresnels') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
+        I*fresnels(z*(1 + I)/sqrt(pi)))
+    assert erfi(z).rewrite('fresnelc') == (1 - I)*(fresnelc(z*(1 + I)/sqrt(pi)) -
+        I*fresnels(z*(1 + I)/sqrt(pi)))
+    assert erfi(z).rewrite('hyper') == 2*z*hyper([S.Half], [3*S.Half], z**2)/sqrt(pi)
+    assert erfi(z).rewrite('meijerg') == z*meijerg([S.Half], [], [0], [Rational(-1, 2)], -z**2)/sqrt(pi)
+    assert erfi(z).rewrite('uppergamma') == (sqrt(-z**2)/z*(uppergamma(S.Half,
+        -z**2)/sqrt(S.Pi) - S.One))
+    assert erfi(z).rewrite('expint') == sqrt(-z**2)/z - z*expint(S.Half, -z**2)/sqrt(S.Pi)
+    assert erfi(z).rewrite('tractable') == -I*(-_erfs(I*z)*exp(z**2) + 1)
+    assert expand_func(erfi(I*z)) == I*erf(z)
+
+    assert erfi(x).as_real_imag() == \
+        (erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
+         -I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
+    assert erfi(x).as_real_imag(deep=False) == \
+        (erfi(re(x) - I*im(x))/2 + erfi(re(x) + I*im(x))/2,
+         -I*(-erfi(re(x) - I*im(x)) + erfi(re(x) + I*im(x)))/2)
+
+    assert erfi(w).as_real_imag() == (erfi(w), 0)
+    assert erfi(w).as_real_imag(deep=False) == (erfi(w), 0)
+
+    raises(ArgumentIndexError, lambda: erfi(x).fdiff(2))
+
+
+def test_erfi_series():
+    assert erfi(x).series(x, 0, 7) == 2*x/sqrt(pi) + \
+        2*x**3/3/sqrt(pi) + x**5/5/sqrt(pi) + O(x**7)
+
+    assert erfi(x).series(x, oo) == \
+        (3/(4*x**5) + 1/(2*x**3) + 1/x + O(x**(-6), (x, oo)))*exp(x**2)/sqrt(pi) - I
+
+
+def test_erfi_evalf():
+    assert abs( erfi(Float(2.0)) - 18.5648024145756 ) < 1E-13  # XXX
+
+
+def test_erf2():
+
+    assert erf2(0, 0) is S.Zero
+    assert erf2(x, x) is S.Zero
+    assert erf2(nan, 0) is nan
+
+    assert erf2(-oo,  y) ==  erf(y) + 1
+    assert erf2( oo,  y) ==  erf(y) - 1
+    assert erf2(  x, oo) ==  1 - erf(x)
+    assert erf2(  x,-oo) == -1 - erf(x)
+    assert erf2(x, erf2inv(x, y)) == y
+
+    assert erf2(-x, -y) == -erf2(x,y)
+    assert erf2(-x,  y) == erf(y) + erf(x)
+    assert erf2( x, -y) == -erf(y) - erf(x)
+    assert erf2(x, y).rewrite('fresnels') == erf(y).rewrite(fresnels)-erf(x).rewrite(fresnels)
+    assert erf2(x, y).rewrite('fresnelc') == erf(y).rewrite(fresnelc)-erf(x).rewrite(fresnelc)
+    assert erf2(x, y).rewrite('hyper') == erf(y).rewrite(hyper)-erf(x).rewrite(hyper)
+    assert erf2(x, y).rewrite('meijerg') == erf(y).rewrite(meijerg)-erf(x).rewrite(meijerg)
+    assert erf2(x, y).rewrite('uppergamma') == erf(y).rewrite(uppergamma) - erf(x).rewrite(uppergamma)
+    assert erf2(x, y).rewrite('expint') == erf(y).rewrite(expint)-erf(x).rewrite(expint)
+
+    assert erf2(I, 0).is_real is False
+    assert erf2(0, 0, evaluate=False).is_real
+    assert erf2(0, 0, evaluate=False).is_zero
+    assert erf2(x, x, evaluate=False).is_zero
+    assert erf2(x, y).is_zero is None
+
+    assert expand_func(erf(x) + erf2(x, y)) == erf(y)
+
+    assert conjugate(erf2(x, y)) == erf2(conjugate(x), conjugate(y))
+
+    assert erf2(x, y).rewrite('erf')  == erf(y) - erf(x)
+    assert erf2(x, y).rewrite('erfc') == erfc(x) - erfc(y)
+    assert erf2(x, y).rewrite('erfi') == I*(erfi(I*x) - erfi(I*y))
+
+    assert erf2(x, y).diff(x) == erf2(x, y).fdiff(1)
+    assert erf2(x, y).diff(y) == erf2(x, y).fdiff(2)
+    assert erf2(x, y).diff(x) == -2*exp(-x**2)/sqrt(pi)
+    assert erf2(x, y).diff(y) == 2*exp(-y**2)/sqrt(pi)
+    raises(ArgumentIndexError, lambda: erf2(x, y).fdiff(3))
+
+    assert erf2(x, y).is_extended_real is None
+    xr, yr = symbols('xr yr', extended_real=True)
+    assert erf2(xr, yr).is_extended_real is True
+
+
+def test_erfinv():
+    assert erfinv(0) is S.Zero
+    assert erfinv(1) is S.Infinity
+    assert erfinv(nan) is S.NaN
+    assert erfinv(-1) is S.NegativeInfinity
+
+    assert erfinv(erf(w)) == w
+    assert erfinv(erf(-w)) == -w
+
+    assert erfinv(x).diff() == sqrt(pi)*exp(erfinv(x)**2)/2
+    raises(ArgumentIndexError, lambda: erfinv(x).fdiff(2))
+
+    assert erfinv(z).rewrite('erfcinv') == erfcinv(1-z)
+    assert erfinv(z).inverse() == erf
+
+
+def test_erfinv_evalf():
+    assert abs( erfinv(Float(0.2)) - 0.179143454621292 ) < 1E-13
+
+
+def test_erfcinv():
+    assert erfcinv(1) is S.Zero
+    assert erfcinv(0) is S.Infinity
+    assert erfcinv(0, evaluate=False).is_infinite is True
+    assert erfcinv(2, evaluate=False).is_infinite is True
+    assert erfcinv(nan) is S.NaN
+
+    assert erfcinv(x).diff() == -sqrt(pi)*exp(erfcinv(x)**2)/2
+    raises(ArgumentIndexError, lambda: erfcinv(x).fdiff(2))
+
+    assert erfcinv(z).rewrite('erfinv') == erfinv(1-z)
+    assert erfcinv(z).inverse() == erfc
+
+
+def test_erf2inv():
+    assert erf2inv(0, 0) is S.Zero
+    assert erf2inv(0, 1) is S.Infinity
+    assert erf2inv(1, 0) is S.One
+    assert erf2inv(0, y) == erfinv(y)
+    assert erf2inv(oo, y) == erfcinv(-y)
+    assert erf2inv(x, 0) == x
+    assert erf2inv(x, oo) == erfinv(x)
+    assert erf2inv(nan, 0) is nan
+    assert erf2inv(0, nan) is nan
+
+    assert erf2inv(x, y).diff(x) == exp(-x**2 + erf2inv(x, y)**2)
+    assert erf2inv(x, y).diff(y) == sqrt(pi)*exp(erf2inv(x, y)**2)/2
+    raises(ArgumentIndexError, lambda: erf2inv(x, y).fdiff(3))
+
+
+# NOTE we multiply by exp_polar(I*pi) and need this to be on the principal
+# branch, hence take x in the lower half plane (d=0).
+
+
+def mytn(expr1, expr2, expr3, x, d=0):
+    from sympy.core.random import verify_numerically, random_complex_number
+    subs = {}
+    for a in expr1.free_symbols:
+        if a != x:
+            subs[a] = random_complex_number()
+    return expr2 == expr3 and verify_numerically(expr1.subs(subs),
+                                               expr2.subs(subs), x, d=d)
+
+
+def mytd(expr1, expr2, x):
+    from sympy.core.random import test_derivative_numerically, \
+        random_complex_number
+    subs = {}
+    for a in expr1.free_symbols:
+        if a != x:
+            subs[a] = random_complex_number()
+    return expr1.diff(x) == expr2 and test_derivative_numerically(expr1.subs(subs), x)
+
+
+def tn_branch(func, s=None):
+    from sympy.core.random import uniform
+
+    def fn(x):
+        if s is None:
+            return func(x)
+        return func(s, x)
+    c = uniform(1, 5)
+    expr = fn(c*exp_polar(I*pi)) - fn(c*exp_polar(-I*pi))
+    eps = 1e-15
+    expr2 = fn(-c + eps*I) - fn(-c - eps*I)
+    return abs(expr.n() - expr2.n()).n() < 1e-10
+
+
+def test_ei():
+    assert Ei(0) is S.NegativeInfinity
+    assert Ei(oo) is S.Infinity
+    assert Ei(-oo) is S.Zero
+
+    assert tn_branch(Ei)
+    assert mytd(Ei(x), exp(x)/x, x)
+    assert mytn(Ei(x), Ei(x).rewrite(uppergamma),
+                -uppergamma(0, x*polar_lift(-1)) - I*pi, x)
+    assert mytn(Ei(x), Ei(x).rewrite(expint),
+                -expint(1, x*polar_lift(-1)) - I*pi, x)
+    assert Ei(x).rewrite(expint).rewrite(Ei) == Ei(x)
+    assert Ei(x*exp_polar(2*I*pi)) == Ei(x) + 2*I*pi
+    assert Ei(x*exp_polar(-2*I*pi)) == Ei(x) - 2*I*pi
+
+    assert mytn(Ei(x), Ei(x).rewrite(Shi), Chi(x) + Shi(x), x)
+    assert mytn(Ei(x*polar_lift(I)), Ei(x*polar_lift(I)).rewrite(Si),
+                Ci(x) + I*Si(x) + I*pi/2, x)
+
+    assert Ei(log(x)).rewrite(li) == li(x)
+    assert Ei(2*log(x)).rewrite(li) == li(x**2)
+
+    assert gruntz(Ei(x+exp(-x))*exp(-x)*x, x, oo) == 1
+
+    assert Ei(x).series(x) == EulerGamma + log(x) + x + x**2/4 + \
+        x**3/18 + x**4/96 + x**5/600 + O(x**6)
+    assert Ei(x).series(x, 1, 3) == Ei(1) + E*(x - 1) + O((x - 1)**3, (x, 1))
+    assert Ei(x).series(x, oo) == \
+        (120/x**5 + 24/x**4 + 6/x**3 + 2/x**2 + 1/x + 1 + O(x**(-6), (x, oo)))*exp(x)/x
+    assert Ei(x).series(x, -oo) == \
+        (120/x**5 + 24/x**4 + 6/x**3 + 2/x**2 + 1/x + 1 + O(x**(-6), (x, -oo)))*exp(x)/x
+    assert Ei(-x).series(x, oo) == \
+        -((-120/x**5 + 24/x**4 - 6/x**3 + 2/x**2 - 1/x + 1 + O(x**(-6), (x, oo)))*exp(-x)/x)
+
+    assert str(Ei(cos(2)).evalf(n=10)) == '-0.6760647401'
+    raises(ArgumentIndexError, lambda: Ei(x).fdiff(2))
+
+
+def test_expint():
+    assert mytn(expint(x, y), expint(x, y).rewrite(uppergamma),
+                y**(x - 1)*uppergamma(1 - x, y), x)
+    assert mytd(
+        expint(x, y), -y**(x - 1)*meijerg([], [1, 1], [0, 0, 1 - x], [], y), x)
+    assert mytd(expint(x, y), -expint(x - 1, y), y)
+    assert mytn(expint(1, x), expint(1, x).rewrite(Ei),
+                -Ei(x*polar_lift(-1)) + I*pi, x)
+
+    assert expint(-4, x) == exp(-x)/x + 4*exp(-x)/x**2 + 12*exp(-x)/x**3 \
+        + 24*exp(-x)/x**4 + 24*exp(-x)/x**5
+    assert expint(Rational(-3, 2), x) == \
+        exp(-x)/x + 3*exp(-x)/(2*x**2) + 3*sqrt(pi)*erfc(sqrt(x))/(4*x**S('5/2'))
+
+    assert tn_branch(expint, 1)
+    assert tn_branch(expint, 2)
+    assert tn_branch(expint, 3)
+    assert tn_branch(expint, 1.7)
+    assert tn_branch(expint, pi)
+
+    assert expint(y, x*exp_polar(2*I*pi)) == \
+        x**(y - 1)*(exp(2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
+    assert expint(y, x*exp_polar(-2*I*pi)) == \
+        x**(y - 1)*(exp(-2*I*pi*y) - 1)*gamma(-y + 1) + expint(y, x)
+    assert expint(2, x*exp_polar(2*I*pi)) == 2*I*pi*x + expint(2, x)
+    assert expint(2, x*exp_polar(-2*I*pi)) == -2*I*pi*x + expint(2, x)
+    assert expint(1, x).rewrite(Ei).rewrite(expint) == expint(1, x)
+    assert expint(x, y).rewrite(Ei) == expint(x, y)
+    assert expint(x, y).rewrite(Ci) == expint(x, y)
+
+    assert mytn(E1(x), E1(x).rewrite(Shi), Shi(x) - Chi(x), x)
+    assert mytn(E1(polar_lift(I)*x), E1(polar_lift(I)*x).rewrite(Si),
+                -Ci(x) + I*Si(x) - I*pi/2, x)
+
+    assert mytn(expint(2, x), expint(2, x).rewrite(Ei).rewrite(expint),
+                -x*E1(x) + exp(-x), x)
+    assert mytn(expint(3, x), expint(3, x).rewrite(Ei).rewrite(expint),
+                x**2*E1(x)/2 + (1 - x)*exp(-x)/2, x)
+
+    assert expint(Rational(3, 2), z).nseries(z) == \
+        2 + 2*z - z**2/3 + z**3/15 - z**4/84 + z**5/540 - \
+        2*sqrt(pi)*sqrt(z) + O(z**6)
+
+    assert E1(z).series(z) == -EulerGamma - log(z) + z - \
+        z**2/4 + z**3/18 - z**4/96 + z**5/600 + O(z**6)
+
+    assert expint(4, z).series(z) == Rational(1, 3) - z/2 + z**2/2 + \
+        z**3*(log(z)/6 - Rational(11, 36) + EulerGamma/6 - I*pi/6) - z**4/24 + \
+        z**5/240 + O(z**6)
+
+    assert expint(n, x).series(x, oo, n=3) == \
+        (n*(n + 1)/x**2 - n/x + 1 + O(x**(-3), (x, oo)))*exp(-x)/x
+
+    assert expint(z, y).series(z, 0, 2) == exp(-y)/y - z*meijerg(((), (1, 1)),
+                                  ((0, 0, 1), ()), y)/y + O(z**2)
+    raises(ArgumentIndexError, lambda: expint(x, y).fdiff(3))
+
+    neg = Symbol('neg', negative=True)
+    assert Ei(neg).rewrite(Si) == Shi(neg) + Chi(neg) - I*pi
+
+
+def test__eis():
+    assert _eis(z).diff(z) == -_eis(z) + 1/z
+
+    assert _eis(1/z).series(z) == \
+        z + z**2 + 2*z**3 + 6*z**4 + 24*z**5 + O(z**6)
+
+    assert Ei(z).rewrite('tractable') == exp(z)*_eis(z)
+    assert li(z).rewrite('tractable') == z*_eis(log(z))
+
+    assert _eis(z).rewrite('intractable') == exp(-z)*Ei(z)
+
+    assert expand(li(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == li(z).diff(z)
+
+    assert expand(Ei(z).rewrite('tractable').diff(z).rewrite('intractable')) \
+        == Ei(z).diff(z)
+
+    assert _eis(z).series(z, n=3) == EulerGamma + log(z) + z*(-log(z) - \
+        EulerGamma + 1) + z**2*(log(z)/2 - Rational(3, 4) + EulerGamma/2)\
+        + O(z**3*log(z))
+    raises(ArgumentIndexError, lambda: _eis(z).fdiff(2))
+
+
+def tn_arg(func):
+    def test(arg, e1, e2):
+        from sympy.core.random import uniform
+        v = uniform(1, 5)
+        v1 = func(arg*x).subs(x, v).n()
+        v2 = func(e1*v + e2*1e-15).n()
+        return abs(v1 - v2).n() < 1e-10
+    return test(exp_polar(I*pi/2), I, 1) and \
+        test(exp_polar(-I*pi/2), -I, 1) and \
+        test(exp_polar(I*pi), -1, I) and \
+        test(exp_polar(-I*pi), -1, -I)
+
+
+def test_li():
+    z = Symbol("z")
+    zr = Symbol("z", real=True)
+    zp = Symbol("z", positive=True)
+    zn = Symbol("z", negative=True)
+
+    assert li(0) is S.Zero
+    assert li(1) is -oo
+    assert li(oo) is oo
+
+    assert isinstance(li(z), li)
+    assert unchanged(li, -zp)
+    assert unchanged(li, zn)
+
+    assert diff(li(z), z) == 1/log(z)
+
+    assert conjugate(li(z)) == li(conjugate(z))
+    assert conjugate(li(-zr)) == li(-zr)
+    assert unchanged(conjugate, li(-zp))
+    assert unchanged(conjugate, li(zn))
+
+    assert li(z).rewrite(Li) == Li(z) + li(2)
+    assert li(z).rewrite(Ei) == Ei(log(z))
+    assert li(z).rewrite(uppergamma) == (-log(1/log(z))/2 - log(-log(z)) +
+                                         log(log(z))/2 - expint(1, -log(z)))
+    assert li(z).rewrite(Si) == (-log(I*log(z)) - log(1/log(z))/2 +
+                                 log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
+    assert li(z).rewrite(Ci) == (-log(I*log(z)) - log(1/log(z))/2 +
+                                 log(log(z))/2 + Ci(I*log(z)) + Shi(log(z)))
+    assert li(z).rewrite(Shi) == (-log(1/log(z))/2 + log(log(z))/2 +
+                                  Chi(log(z)) - Shi(log(z)))
+    assert li(z).rewrite(Chi) == (-log(1/log(z))/2 + log(log(z))/2 +
+                                  Chi(log(z)) - Shi(log(z)))
+    assert li(z).rewrite(hyper) ==(log(z)*hyper((1, 1), (2, 2), log(z)) -
+                                   log(1/log(z))/2 + log(log(z))/2 + EulerGamma)
+    assert li(z).rewrite(meijerg) == (-log(1/log(z))/2 - log(-log(z)) + log(log(z))/2 -
+                                      meijerg(((), (1,)), ((0, 0), ()), -log(z)))
+
+    assert gruntz(1/li(z), z, oo) is S.Zero
+    assert li(z).series(z) == log(z)**5/600 + log(z)**4/96 + log(z)**3/18 + log(z)**2/4 + \
+            log(z) + log(log(z)) + EulerGamma
+    raises(ArgumentIndexError, lambda: li(z).fdiff(2))
+
+
+def test_Li():
+    assert Li(2) is S.Zero
+    assert Li(oo) is oo
+
+    assert isinstance(Li(z), Li)
+
+    assert diff(Li(z), z) == 1/log(z)
+
+    assert gruntz(1/Li(z), z, oo) is S.Zero
+    assert Li(z).rewrite(li) == li(z) - li(2)
+    assert Li(z).series(z) == \
+        log(z)**5/600 + log(z)**4/96 + log(z)**3/18 + log(z)**2/4 + log(z) + log(log(z)) - li(2) + EulerGamma
+    raises(ArgumentIndexError, lambda: Li(z).fdiff(2))
+
+
+def test_si():
+    assert Si(I*x) == I*Shi(x)
+    assert Shi(I*x) == I*Si(x)
+    assert Si(-I*x) == -I*Shi(x)
+    assert Shi(-I*x) == -I*Si(x)
+    assert Si(-x) == -Si(x)
+    assert Shi(-x) == -Shi(x)
+    assert Si(exp_polar(2*pi*I)*x) == Si(x)
+    assert Si(exp_polar(-2*pi*I)*x) == Si(x)
+    assert Shi(exp_polar(2*pi*I)*x) == Shi(x)
+    assert Shi(exp_polar(-2*pi*I)*x) == Shi(x)
+
+    assert Si(oo) == pi/2
+    assert Si(-oo) == -pi/2
+    assert Shi(oo) is oo
+    assert Shi(-oo) is -oo
+
+    assert mytd(Si(x), sin(x)/x, x)
+    assert mytd(Shi(x), sinh(x)/x, x)
+
+    assert mytn(Si(x), Si(x).rewrite(Ei),
+                -I*(-Ei(x*exp_polar(-I*pi/2))/2
+               + Ei(x*exp_polar(I*pi/2))/2 - I*pi) + pi/2, x)
+    assert mytn(Si(x), Si(x).rewrite(expint),
+                -I*(-expint(1, x*exp_polar(-I*pi/2))/2 +
+                    expint(1, x*exp_polar(I*pi/2))/2) + pi/2, x)
+    assert mytn(Shi(x), Shi(x).rewrite(Ei),
+                Ei(x)/2 - Ei(x*exp_polar(I*pi))/2 + I*pi/2, x)
+    assert mytn(Shi(x), Shi(x).rewrite(expint),
+                expint(1, x)/2 - expint(1, x*exp_polar(I*pi))/2 - I*pi/2, x)
+
+    assert tn_arg(Si)
+    assert tn_arg(Shi)
+
+    assert Si(x)._eval_as_leading_term(x, None, 1) == x
+    assert Si(2*x)._eval_as_leading_term(x, None, 1) == 2*x
+    assert Si(sin(x))._eval_as_leading_term(x, None, 1) == x
+    assert Si(x + 1)._eval_as_leading_term(x, None, 1) == Si(1)
+    assert Si(1/x)._eval_as_leading_term(x, None, 1) == \
+        Si(1/x)._eval_as_leading_term(x, None, -1) == Si(1/x)
+
+    assert Si(x).nseries(x, n=8) == \
+        x - x**3/18 + x**5/600 - x**7/35280 + O(x**8)
+    assert Shi(x).nseries(x, n=8) == \
+        x + x**3/18 + x**5/600 + x**7/35280 + O(x**8)
+    assert Si(sin(x)).nseries(x, n=5) == x - 2*x**3/9 + O(x**5)
+    assert Si(x).nseries(x, 1, n=3) == \
+        Si(1) + (x - 1)*sin(1) + (x - 1)**2*(-sin(1)/2 + cos(1)/2) + O((x - 1)**3, (x, 1))
+
+    assert Si(x).series(x, oo) == -sin(x)*(-6/x**4 + x**(-2) + O(x**(-6), (x, oo))) - \
+        cos(x)*(24/x**5 - 2/x**3 + 1/x + O(x**(-6), (x, oo))) + pi/2
+
+    t = Symbol('t', Dummy=True)
+    assert Si(x).rewrite(sinc).dummy_eq(Integral(sinc(t), (t, 0, x)))
+
+    assert limit(Shi(x), x, S.Infinity) == S.Infinity
+    assert limit(Shi(x), x, S.NegativeInfinity) == S.NegativeInfinity
+
+
+def test_ci():
+    m1 = exp_polar(I*pi)
+    m1_ = exp_polar(-I*pi)
+    pI = exp_polar(I*pi/2)
+    mI = exp_polar(-I*pi/2)
+
+    assert Ci(m1*x) == Ci(x) + I*pi
+    assert Ci(m1_*x) == Ci(x) - I*pi
+    assert Ci(pI*x) == Chi(x) + I*pi/2
+    assert Ci(mI*x) == Chi(x) - I*pi/2
+    assert Chi(m1*x) == Chi(x) + I*pi
+    assert Chi(m1_*x) == Chi(x) - I*pi
+    assert Chi(pI*x) == Ci(x) + I*pi/2
+    assert Chi(mI*x) == Ci(x) - I*pi/2
+    assert Ci(exp_polar(2*I*pi)*x) == Ci(x) + 2*I*pi
+    assert Chi(exp_polar(-2*I*pi)*x) == Chi(x) - 2*I*pi
+    assert Chi(exp_polar(2*I*pi)*x) == Chi(x) + 2*I*pi
+    assert Ci(exp_polar(-2*I*pi)*x) == Ci(x) - 2*I*pi
+
+    assert Ci(oo) is S.Zero
+    assert Ci(-oo) == I*pi
+    assert Chi(oo) is oo
+    assert Chi(-oo) is oo
+
+    assert mytd(Ci(x), cos(x)/x, x)
+    assert mytd(Chi(x), cosh(x)/x, x)
+
+    assert mytn(Ci(x), Ci(x).rewrite(Ei),
+                Ei(x*exp_polar(-I*pi/2))/2 + Ei(x*exp_polar(I*pi/2))/2, x)
+    assert mytn(Chi(x), Chi(x).rewrite(Ei),
+                Ei(x)/2 + Ei(x*exp_polar(I*pi))/2 - I*pi/2, x)
+
+    assert tn_arg(Ci)
+    assert tn_arg(Chi)
+
+    assert Ci(x).nseries(x, n=4) == \
+        EulerGamma + log(x) - x**2/4 + O(x**4)
+    assert Chi(x).nseries(x, n=4) == \
+        EulerGamma + log(x) + x**2/4 + O(x**4)
+
+    assert Ci(x).series(x, oo) == -cos(x)*(-6/x**4 + x**(-2) + O(x**(-6), (x, oo))) + \
+        sin(x)*(24/x**5 - 2/x**3 + 1/x + O(x**(-6), (x, oo)))
+
+    assert Ci(x).series(x, -oo) == -cos(x)*(-6/x**4 + x**(-2) + O(x**(-6), (x, -oo))) + \
+        sin(x)*(24/x**5 - 2/x**3 + 1/x + O(x**(-6), (x, -oo))) + I*pi
+
+    assert limit(log(x) - Ci(2*x), x, 0) == -log(2) - EulerGamma
+    assert Ci(x).rewrite(uppergamma) == -expint(1, x*exp_polar(-I*pi/2))/2 -\
+                                        expint(1, x*exp_polar(I*pi/2))/2
+    assert Ci(x).rewrite(expint) == -expint(1, x*exp_polar(-I*pi/2))/2 -\
+                                        expint(1, x*exp_polar(I*pi/2))/2
+    raises(ArgumentIndexError, lambda: Ci(x).fdiff(2))
+
+
+def test_fresnel():
+    assert fresnels(0) is S.Zero
+    assert fresnels(oo) is S.Half
+    assert fresnels(-oo) == Rational(-1, 2)
+    assert fresnels(I*oo) == -I*S.Half
+
+    assert unchanged(fresnels, z)
+    assert fresnels(-z) == -fresnels(z)
+    assert fresnels(I*z) == -I*fresnels(z)
+    assert fresnels(-I*z) == I*fresnels(z)
+
+    assert conjugate(fresnels(z)) == fresnels(conjugate(z))
+
+    assert fresnels(z).diff(z) == sin(pi*z**2/2)
+
+    assert fresnels(z).rewrite(erf) == (S.One + I)/4 * (
+        erf((S.One + I)/2*sqrt(pi)*z) - I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    assert fresnels(z).rewrite(hyper) == \
+        pi*z**3/6 * hyper([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)], -pi**2*z**4/16)
+
+    assert fresnels(z).series(z, n=15) == \
+        pi*z**3/6 - pi**3*z**7/336 + pi**5*z**11/42240 + O(z**15)
+
+    assert fresnels(w).is_extended_real is True
+    assert fresnels(w).is_finite is True
+
+    assert fresnels(z).is_extended_real is None
+    assert fresnels(z).is_finite is None
+
+    assert fresnels(z).as_real_imag() == (fresnels(re(z) - I*im(z))/2 +
+                    fresnels(re(z) + I*im(z))/2,
+                    -I*(-fresnels(re(z) - I*im(z)) + fresnels(re(z) + I*im(z)))/2)
+
+    assert fresnels(z).as_real_imag(deep=False) == (fresnels(re(z) - I*im(z))/2 +
+                    fresnels(re(z) + I*im(z))/2,
+                    -I*(-fresnels(re(z) - I*im(z)) + fresnels(re(z) + I*im(z)))/2)
+
+    assert fresnels(w).as_real_imag() == (fresnels(w), 0)
+    assert fresnels(w).as_real_imag(deep=True) == (fresnels(w), 0)
+
+    assert fresnels(2 + 3*I).as_real_imag() == (
+            fresnels(2 + 3*I)/2 + fresnels(2 - 3*I)/2,
+            -I*(fresnels(2 + 3*I) - fresnels(2 - 3*I))/2
+            )
+
+    assert expand_func(integrate(fresnels(z), z)) == \
+        z*fresnels(z) + cos(pi*z**2/2)/pi
+
+    assert fresnels(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(9, 4) * \
+        meijerg(((), (1,)), ((Rational(3, 4),),
+        (Rational(1, 4), 0)), -pi**2*z**4/16)/(2*(-z)**Rational(3, 4)*(z**2)**Rational(3, 4))
+
+    assert fresnelc(0) is S.Zero
+    assert fresnelc(oo) == S.Half
+    assert fresnelc(-oo) == Rational(-1, 2)
+    assert fresnelc(I*oo) == I*S.Half
+
+    assert unchanged(fresnelc, z)
+    assert fresnelc(-z) == -fresnelc(z)
+    assert fresnelc(I*z) == I*fresnelc(z)
+    assert fresnelc(-I*z) == -I*fresnelc(z)
+
+    assert conjugate(fresnelc(z)) == fresnelc(conjugate(z))
+
+    assert fresnelc(z).diff(z) == cos(pi*z**2/2)
+
+    assert fresnelc(z).rewrite(erf) == (S.One - I)/4 * (
+        erf((S.One + I)/2*sqrt(pi)*z) + I*erf((S.One - I)/2*sqrt(pi)*z))
+
+    assert fresnelc(z).rewrite(hyper) == \
+        z * hyper([Rational(1, 4)], [S.Half, Rational(5, 4)], -pi**2*z**4/16)
+
+    assert fresnelc(w).is_extended_real is True
+
+    assert fresnelc(z).as_real_imag() == \
+        (fresnelc(re(z) - I*im(z))/2 + fresnelc(re(z) + I*im(z))/2,
+         -I*(-fresnelc(re(z) - I*im(z)) + fresnelc(re(z) + I*im(z)))/2)
+
+    assert fresnelc(z).as_real_imag(deep=False) == \
+        (fresnelc(re(z) - I*im(z))/2 + fresnelc(re(z) + I*im(z))/2,
+         -I*(-fresnelc(re(z) - I*im(z)) + fresnelc(re(z) + I*im(z)))/2)
+
+    assert fresnelc(2 + 3*I).as_real_imag() == (
+        fresnelc(2 - 3*I)/2 + fresnelc(2 + 3*I)/2,
+         -I*(fresnelc(2 + 3*I) - fresnelc(2 - 3*I))/2
+    )
+
+    assert expand_func(integrate(fresnelc(z), z)) == \
+        z*fresnelc(z) - sin(pi*z**2/2)/pi
+
+    assert fresnelc(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(3, 4) * \
+        meijerg(((), (1,)), ((Rational(1, 4),),
+        (Rational(3, 4), 0)), -pi**2*z**4/16)/(2*(-z)**Rational(1, 4)*(z**2)**Rational(1, 4))
+
+    from sympy.core.random import verify_numerically
+
+    verify_numerically(re(fresnels(z)), fresnels(z).as_real_imag()[0], z)
+    verify_numerically(im(fresnels(z)), fresnels(z).as_real_imag()[1], z)
+    verify_numerically(fresnels(z), fresnels(z).rewrite(hyper), z)
+    verify_numerically(fresnels(z), fresnels(z).rewrite(meijerg), z)
+
+    verify_numerically(re(fresnelc(z)), fresnelc(z).as_real_imag()[0], z)
+    verify_numerically(im(fresnelc(z)), fresnelc(z).as_real_imag()[1], z)
+    verify_numerically(fresnelc(z), fresnelc(z).rewrite(hyper), z)
+    verify_numerically(fresnelc(z), fresnelc(z).rewrite(meijerg), z)
+
+    raises(ArgumentIndexError, lambda: fresnels(z).fdiff(2))
+    raises(ArgumentIndexError, lambda: fresnelc(z).fdiff(2))
+
+    assert fresnels(x).taylor_term(-1, x) is S.Zero
+    assert fresnelc(x).taylor_term(-1, x) is S.Zero
+    assert fresnelc(x).taylor_term(1, x) == -pi**2*x**5/40
+
+
+def test_fresnel_series():
+    assert fresnelc(z).series(z, n=15) == \
+        z - pi**2*z**5/40 + pi**4*z**9/3456 - pi**6*z**13/599040 + O(z**15)
+
+    # issues 6510, 10102
+    fs = (S.Half - sin(pi*z**2/2)/(pi**2*z**3)
+        + (-1/(pi*z) + 3/(pi**3*z**5))*cos(pi*z**2/2))
+    fc = (S.Half - cos(pi*z**2/2)/(pi**2*z**3)
+        + (1/(pi*z) - 3/(pi**3*z**5))*sin(pi*z**2/2))
+    assert fresnels(z).series(z, oo) == fs + O(z**(-6), (z, oo))
+    assert fresnelc(z).series(z, oo) == fc + O(z**(-6), (z, oo))
+    assert (fresnels(z).series(z, -oo) + fs.subs(z, -z)).expand().is_Order
+    assert (fresnelc(z).series(z, -oo) + fc.subs(z, -z)).expand().is_Order
+    assert (fresnels(1/z).series(z) - fs.subs(z, 1/z)).expand().is_Order
+    assert (fresnelc(1/z).series(z) - fc.subs(z, 1/z)).expand().is_Order
+    assert ((2*fresnels(3*z)).series(z, oo) - 2*fs.subs(z, 3*z)).expand().is_Order
+    assert ((3*fresnelc(2*z)).series(z, oo) - 3*fc.subs(z, 2*z)).expand().is_Order
+
+
+def test_integral_rewrites(): #issues 26134, 26144, 26306
+    assert expint(n, x).rewrite(Integral).dummy_eq(Integral(t**-n * exp(-t*x), (t, 1, oo)))
+    assert Si(x).rewrite(Integral).dummy_eq(Integral(sinc(t), (t, 0, x)))
+    assert Ci(x).rewrite(Integral).dummy_eq(log(x) - Integral((1 - cos(t))/t, (t, 0, x)) + EulerGamma)
+    assert fresnels(x).rewrite(Integral).dummy_eq(Integral(sin(pi*t**2/2), (t, 0, x)))
+    assert fresnelc(x).rewrite(Integral).dummy_eq(Integral(cos(pi*t**2/2), (t, 0, x)))
+    assert Ei(x).rewrite(Integral).dummy_eq(Integral(exp(t)/t, (t, -oo, x)))
+    assert fresnels(x).diff(x) == fresnels(x).rewrite(Integral).diff(x)
+    assert fresnelc(x).diff(x) == fresnelc(x).rewrite(Integral).diff(x)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_gamma_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_gamma_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..14c57a31ce2edaa60fd5efc8bcbc95668961fd41
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_gamma_functions.py
@@ -0,0 +1,741 @@
+from sympy.core.function import expand_func, Subs
+from sympy.core import EulerGamma
+from sympy.core.numbers import (I, Rational, nan, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.combinatorial.factorials import factorial
+from sympy.functions.combinatorial.numbers import harmonic
+from sympy.functions.elementary.complexes import (Abs, conjugate, im, re)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.hyperbolic import tanh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin, atan)
+from sympy.functions.special.error_functions import (Ei, erf, erfc)
+from sympy.functions.special.gamma_functions import (digamma, gamma, loggamma, lowergamma, multigamma, polygamma, trigamma, uppergamma)
+from sympy.functions.special.zeta_functions import zeta
+from sympy.series.order import O
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+from sympy.core.random import (test_derivative_numerically as td,
+                                      random_complex_number as randcplx,
+                                      verify_numerically as tn)
+
+x = Symbol('x')
+y = Symbol('y')
+n = Symbol('n', integer=True)
+w = Symbol('w', real=True)
+
+def test_gamma():
+    assert gamma(nan) is nan
+    assert gamma(oo) is oo
+
+    assert gamma(-100) is zoo
+    assert gamma(0) is zoo
+    assert gamma(-100.0) is zoo
+
+    assert gamma(1) == 1
+    assert gamma(2) == 1
+    assert gamma(3) == 2
+
+    assert gamma(102) == factorial(101)
+
+    assert gamma(S.Half) == sqrt(pi)
+
+    assert gamma(Rational(3, 2)) == sqrt(pi)*S.Half
+    assert gamma(Rational(5, 2)) == sqrt(pi)*Rational(3, 4)
+    assert gamma(Rational(7, 2)) == sqrt(pi)*Rational(15, 8)
+
+    assert gamma(Rational(-1, 2)) == -2*sqrt(pi)
+    assert gamma(Rational(-3, 2)) == sqrt(pi)*Rational(4, 3)
+    assert gamma(Rational(-5, 2)) == sqrt(pi)*Rational(-8, 15)
+
+    assert gamma(Rational(-15, 2)) == sqrt(pi)*Rational(256, 2027025)
+
+    assert gamma(Rational(
+        -11, 8)).expand(func=True) == Rational(64, 33)*gamma(Rational(5, 8))
+    assert gamma(Rational(
+        -10, 3)).expand(func=True) == Rational(81, 280)*gamma(Rational(2, 3))
+    assert gamma(Rational(
+        14, 3)).expand(func=True) == Rational(880, 81)*gamma(Rational(2, 3))
+    assert gamma(Rational(
+        17, 7)).expand(func=True) == Rational(30, 49)*gamma(Rational(3, 7))
+    assert gamma(Rational(
+        19, 8)).expand(func=True) == Rational(33, 64)*gamma(Rational(3, 8))
+
+    assert gamma(x).diff(x) == gamma(x)*polygamma(0, x)
+
+    assert gamma(x - 1).expand(func=True) == gamma(x)/(x - 1)
+    assert gamma(x + 2).expand(func=True, mul=False) == x*(x + 1)*gamma(x)
+
+    assert conjugate(gamma(x)) == gamma(conjugate(x))
+
+    assert expand_func(gamma(x + Rational(3, 2))) == \
+        (x + S.Half)*gamma(x + S.Half)
+
+    assert expand_func(gamma(x - S.Half)) == \
+        gamma(S.Half + x)/(x - S.Half)
+
+    # Test a bug:
+    assert expand_func(gamma(x + Rational(3, 4))) == gamma(x + Rational(3, 4))
+
+    # XXX: Not sure about these tests. I can fix them by defining e.g.
+    # exp_polar.is_integer but I'm not sure if that makes sense.
+    assert gamma(3*exp_polar(I*pi)/4).is_nonnegative is False
+    assert gamma(3*exp_polar(I*pi)/4).is_extended_nonpositive is True
+
+    y = Symbol('y', nonpositive=True, integer=True)
+    assert gamma(y).is_real == False
+    y = Symbol('y', positive=True, noninteger=True)
+    assert gamma(y).is_real == True
+
+    assert gamma(-1.0, evaluate=False).is_real == False
+    assert gamma(0, evaluate=False).is_real == False
+    assert gamma(-2, evaluate=False).is_real == False
+
+
+def test_gamma_rewrite():
+    assert gamma(n).rewrite(factorial) == factorial(n - 1)
+
+
+def test_gamma_series():
+    assert gamma(x + 1).series(x, 0, 3) == \
+        1 - EulerGamma*x + x**2*(EulerGamma**2/2 + pi**2/12) + O(x**3)
+    assert gamma(x).series(x, -1, 3) == \
+        -1/(x + 1) + EulerGamma - 1 + (x + 1)*(-1 - pi**2/12 - EulerGamma**2/2 + \
+       EulerGamma) + (x + 1)**2*(-1 - pi**2/12 - EulerGamma**2/2 + EulerGamma**3/6 - \
+       polygamma(2, 1)/6 + EulerGamma*pi**2/12 + EulerGamma) + O((x + 1)**3, (x, -1))
+
+
+def tn_branch(s, func):
+    from sympy.core.random import uniform
+    c = uniform(1, 5)
+    expr = func(s, c*exp_polar(I*pi)) - func(s, c*exp_polar(-I*pi))
+    eps = 1e-15
+    expr2 = func(s + eps, -c + eps*I) - func(s + eps, -c - eps*I)
+    return abs(expr.n() - expr2.n()).n() < 1e-10
+
+
+def test_lowergamma():
+    from sympy.functions.special.error_functions import expint
+    from sympy.functions.special.hyper import meijerg
+    assert lowergamma(x, 0) == 0
+    assert lowergamma(x, y).diff(y) == y**(x - 1)*exp(-y)
+    assert td(lowergamma(randcplx(), y), y)
+    assert td(lowergamma(x, randcplx()), x)
+    assert lowergamma(x, y).diff(x) == \
+        gamma(x)*digamma(x) - uppergamma(x, y)*log(y) \
+        - meijerg([], [1, 1], [0, 0, x], [], y)
+
+    assert lowergamma(S.Half, x) == sqrt(pi)*erf(sqrt(x))
+    assert not lowergamma(S.Half - 3, x).has(lowergamma)
+    assert not lowergamma(S.Half + 3, x).has(lowergamma)
+    assert lowergamma(S.Half, x, evaluate=False).has(lowergamma)
+    assert tn(lowergamma(S.Half + 3, x, evaluate=False),
+              lowergamma(S.Half + 3, x), x)
+    assert tn(lowergamma(S.Half - 3, x, evaluate=False),
+              lowergamma(S.Half - 3, x), x)
+
+    assert tn_branch(-3, lowergamma)
+    assert tn_branch(-4, lowergamma)
+    assert tn_branch(Rational(1, 3), lowergamma)
+    assert tn_branch(pi, lowergamma)
+    assert lowergamma(3, exp_polar(4*pi*I)*x) == lowergamma(3, x)
+    assert lowergamma(y, exp_polar(5*pi*I)*x) == \
+        exp(4*I*pi*y)*lowergamma(y, x*exp_polar(pi*I))
+    assert lowergamma(-2, exp_polar(5*pi*I)*x) == \
+        lowergamma(-2, x*exp_polar(I*pi)) + 2*pi*I
+
+    assert conjugate(lowergamma(x, y)) == lowergamma(conjugate(x), conjugate(y))
+    assert conjugate(lowergamma(x, 0)) == 0
+    assert unchanged(conjugate, lowergamma(x, -oo))
+
+    assert lowergamma(0, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1, x, evaluate=False)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x + 1, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1/x, x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(0, x + 1)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(1, x + 1, evaluate=False)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(x + 1, x + 1)._eval_is_meromorphic(x, 0) == True
+    assert lowergamma(1/x, x + 1)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(0, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(S(1)/3, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1, 1/x, evaluate=False)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(x + 1, 1/x)._eval_is_meromorphic(x, 0) == False
+    assert lowergamma(1/x, 1/x)._eval_is_meromorphic(x, 0) == False
+
+    assert lowergamma(x, 2).series(x, oo, 3) == \
+        2**x*(1 + 2/(x + 1))*exp(-2)/x + O(exp(x*log(2))/x**3, (x, oo))
+
+    assert lowergamma(
+        x, y).rewrite(expint) == -y**x*expint(-x + 1, y) + gamma(x)
+    k = Symbol('k', integer=True)
+    assert lowergamma(
+        k, y).rewrite(expint) == -y**k*expint(-k + 1, y) + gamma(k)
+    k = Symbol('k', integer=True, positive=False)
+    assert lowergamma(k, y).rewrite(expint) == lowergamma(k, y)
+    assert lowergamma(x, y).rewrite(uppergamma) == gamma(x) - uppergamma(x, y)
+
+    assert lowergamma(70, 6) == factorial(69) - 69035724522603011058660187038367026272747334489677105069435923032634389419656200387949342530805432320 * exp(-6)
+    assert (lowergamma(S(77) / 2, 6) - lowergamma(S(77) / 2, 6, evaluate=False)).evalf() < 1e-16
+    assert (lowergamma(-S(77) / 2, 6) - lowergamma(-S(77) / 2, 6, evaluate=False)).evalf() < 1e-16
+
+
+def test_uppergamma():
+    from sympy.functions.special.error_functions import expint
+    from sympy.functions.special.hyper import meijerg
+    assert uppergamma(4, 0) == 6
+    assert uppergamma(x, y).diff(y) == -y**(x - 1)*exp(-y)
+    assert td(uppergamma(randcplx(), y), y)
+    assert uppergamma(x, y).diff(x) == \
+        uppergamma(x, y)*log(y) + meijerg([], [1, 1], [0, 0, x], [], y)
+    assert td(uppergamma(x, randcplx()), x)
+
+    p = Symbol('p', positive=True)
+    assert uppergamma(0, p) == -Ei(-p)
+    assert uppergamma(p, 0) == gamma(p)
+    assert uppergamma(S.Half, x) == sqrt(pi)*erfc(sqrt(x))
+    assert not uppergamma(S.Half - 3, x).has(uppergamma)
+    assert not uppergamma(S.Half + 3, x).has(uppergamma)
+    assert uppergamma(S.Half, x, evaluate=False).has(uppergamma)
+    assert tn(uppergamma(S.Half + 3, x, evaluate=False),
+              uppergamma(S.Half + 3, x), x)
+    assert tn(uppergamma(S.Half - 3, x, evaluate=False),
+              uppergamma(S.Half - 3, x), x)
+
+    assert unchanged(uppergamma, x, -oo)
+    assert unchanged(uppergamma, x, 0)
+
+    assert tn_branch(-3, uppergamma)
+    assert tn_branch(-4, uppergamma)
+    assert tn_branch(Rational(1, 3), uppergamma)
+    assert tn_branch(pi, uppergamma)
+    assert uppergamma(3, exp_polar(4*pi*I)*x) == uppergamma(3, x)
+    assert uppergamma(y, exp_polar(5*pi*I)*x) == \
+        exp(4*I*pi*y)*uppergamma(y, x*exp_polar(pi*I)) + \
+        gamma(y)*(1 - exp(4*pi*I*y))
+    assert uppergamma(-2, exp_polar(5*pi*I)*x) == \
+        uppergamma(-2, x*exp_polar(I*pi)) - 2*pi*I
+
+    assert uppergamma(-2, x) == expint(3, x)/x**2
+
+    assert conjugate(uppergamma(x, y)) == uppergamma(conjugate(x), conjugate(y))
+    assert unchanged(conjugate, uppergamma(x, -oo))
+
+    assert uppergamma(x, y).rewrite(expint) == y**x*expint(-x + 1, y)
+    assert uppergamma(x, y).rewrite(lowergamma) == gamma(x) - lowergamma(x, y)
+
+    assert uppergamma(70, 6) == 69035724522603011058660187038367026272747334489677105069435923032634389419656200387949342530805432320*exp(-6)
+    assert (uppergamma(S(77) / 2, 6) - uppergamma(S(77) / 2, 6, evaluate=False)).evalf() < 1e-16
+    assert (uppergamma(-S(77) / 2, 6) - uppergamma(-S(77) / 2, 6, evaluate=False)).evalf() < 1e-16
+
+
+def test_polygamma():
+    assert polygamma(n, nan) is nan
+
+    assert polygamma(0, oo) is oo
+    assert polygamma(0, -oo) is oo
+    assert polygamma(0, I*oo) is oo
+    assert polygamma(0, -I*oo) is oo
+    assert polygamma(1, oo) == 0
+    assert polygamma(5, oo) == 0
+
+    assert polygamma(0, -9) is zoo
+
+    assert polygamma(0, -9) is zoo
+    assert polygamma(0, -1) is zoo
+    assert polygamma(Rational(3, 2), -1) is zoo
+
+    assert polygamma(0, 0) is zoo
+
+    assert polygamma(0, 1) == -EulerGamma
+    assert polygamma(0, 7) == Rational(49, 20) - EulerGamma
+
+    assert polygamma(1, 1) == pi**2/6
+    assert polygamma(1, 2) == pi**2/6 - 1
+    assert polygamma(1, 3) == pi**2/6 - Rational(5, 4)
+    assert polygamma(3, 1) == pi**4 / 15
+    assert polygamma(3, 5) == 6*(Rational(-22369, 20736) + pi**4/90)
+    assert polygamma(5, 1) == 8 * pi**6 / 63
+
+    assert polygamma(1, S.Half) == pi**2 / 2
+    assert polygamma(2, S.Half) == -14*zeta(3)
+    assert polygamma(11, S.Half) == 176896*pi**12
+
+    def t(m, n):
+        x = S(m)/n
+        r = polygamma(0, x)
+        if r.has(polygamma):
+            return False
+        return abs(polygamma(0, x.n()).n() - r.n()).n() < 1e-10
+    assert t(1, 2)
+    assert t(3, 2)
+    assert t(-1, 2)
+    assert t(1, 4)
+    assert t(-3, 4)
+    assert t(1, 3)
+    assert t(4, 3)
+    assert t(3, 4)
+    assert t(2, 3)
+    assert t(123, 5)
+
+    assert polygamma(0, x).rewrite(zeta) == polygamma(0, x)
+    assert polygamma(1, x).rewrite(zeta) == zeta(2, x)
+    assert polygamma(2, x).rewrite(zeta) == -2*zeta(3, x)
+    assert polygamma(I, 2).rewrite(zeta) == polygamma(I, 2)
+    n1 = Symbol('n1')
+    n2 = Symbol('n2', real=True)
+    n3 = Symbol('n3', integer=True)
+    n4 = Symbol('n4', positive=True)
+    n5 = Symbol('n5', positive=True, integer=True)
+    assert polygamma(n1, x).rewrite(zeta) == polygamma(n1, x)
+    assert polygamma(n2, x).rewrite(zeta) == polygamma(n2, x)
+    assert polygamma(n3, x).rewrite(zeta) == polygamma(n3, x)
+    assert polygamma(n4, x).rewrite(zeta) == polygamma(n4, x)
+    assert polygamma(n5, x).rewrite(zeta) == (-1)**(n5 + 1) * factorial(n5) * zeta(n5 + 1, x)
+
+    assert polygamma(3, 7*x).diff(x) == 7*polygamma(4, 7*x)
+
+    assert polygamma(0, x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma
+    assert polygamma(2, x).rewrite(harmonic) == 2*harmonic(x - 1, 3) - 2*zeta(3)
+    ni = Symbol("n", integer=True)
+    assert polygamma(ni, x).rewrite(harmonic) == (-1)**(ni + 1)*(-harmonic(x - 1, ni + 1)
+                                                                 + zeta(ni + 1))*factorial(ni)
+
+    # Polygamma of non-negative integer order is unbranched:
+    k = Symbol('n', integer=True, nonnegative=True)
+    assert polygamma(k, exp_polar(2*I*pi)*x) == polygamma(k, x)
+
+    # but negative integers are branched!
+    k = Symbol('n', integer=True)
+    assert polygamma(k, exp_polar(2*I*pi)*x).args == (k, exp_polar(2*I*pi)*x)
+
+    # Polygamma of order -1 is loggamma:
+    assert polygamma(-1, x) == loggamma(x) - log(2*pi) / 2
+
+    # But smaller orders are iterated integrals and don't have a special name
+    assert polygamma(-2, x).func is polygamma
+
+    # Test a bug
+    assert polygamma(0, -x).expand(func=True) == polygamma(0, -x)
+
+    assert polygamma(2, 2.5).is_positive == False
+    assert polygamma(2, -2.5).is_positive == False
+    assert polygamma(3, 2.5).is_positive == True
+    assert polygamma(3, -2.5).is_positive is True
+    assert polygamma(-2, -2.5).is_positive is None
+    assert polygamma(-3, -2.5).is_positive is None
+
+    assert polygamma(2, 2.5).is_negative == True
+    assert polygamma(3, 2.5).is_negative == False
+    assert polygamma(3, -2.5).is_negative == False
+    assert polygamma(2, -2.5).is_negative is True
+    assert polygamma(-2, -2.5).is_negative is None
+    assert polygamma(-3, -2.5).is_negative is None
+
+    assert polygamma(I, 2).is_positive is None
+    assert polygamma(I, 3).is_negative is None
+
+    # issue 17350
+    assert (I*polygamma(I, pi)).as_real_imag() == \
+           (-im(polygamma(I, pi)), re(polygamma(I, pi)))
+    assert (tanh(polygamma(I, 1))).rewrite(exp) == \
+           (exp(polygamma(I, 1)) - exp(-polygamma(I, 1)))/(exp(polygamma(I, 1)) + exp(-polygamma(I, 1)))
+    assert (I / polygamma(I, 4)).rewrite(exp) == \
+           I*exp(-I*atan(im(polygamma(I, 4))/re(polygamma(I, 4))))/Abs(polygamma(I, 4))
+
+    # issue 12569
+    assert unchanged(im, polygamma(0, I))
+    assert polygamma(Symbol('a', positive=True), Symbol('b', positive=True)).is_real is True
+    assert polygamma(0, I).is_real is None
+
+    assert str(polygamma(pi, 3).evalf(n=10)) == "0.1169314564"
+    assert str(polygamma(2.3, 1.0).evalf(n=10)) == "-3.003302909"
+    assert str(polygamma(-1, 1).evalf(n=10)) == "-0.9189385332" # not zero
+    assert str(polygamma(I, 1).evalf(n=10)) == "-3.109856569 + 1.89089016*I"
+    assert str(polygamma(1, I).evalf(n=10)) == "-0.5369999034 - 0.7942335428*I"
+    assert str(polygamma(I, I).evalf(n=10)) == "6.332362889 + 45.92828268*I"
+
+
+def test_polygamma_expand_func():
+    assert polygamma(0, x).expand(func=True) == polygamma(0, x)
+    assert polygamma(0, 2*x).expand(func=True) == \
+        polygamma(0, x)/2 + polygamma(0, S.Half + x)/2 + log(2)
+    assert polygamma(1, 2*x).expand(func=True) == \
+        polygamma(1, x)/4 + polygamma(1, S.Half + x)/4
+    assert polygamma(2, x).expand(func=True) == \
+        polygamma(2, x)
+    assert polygamma(0, -1 + x).expand(func=True) == \
+        polygamma(0, x) - 1/(x - 1)
+    assert polygamma(0, 1 + x).expand(func=True) == \
+        1/x + polygamma(0, x )
+    assert polygamma(0, 2 + x).expand(func=True) == \
+        1/x + 1/(1 + x) + polygamma(0, x)
+    assert polygamma(0, 3 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x)
+    assert polygamma(0, 4 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x)
+    assert polygamma(1, 1 + x).expand(func=True) == \
+        polygamma(1, x) - 1/x**2
+    assert polygamma(1, 2 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2
+    assert polygamma(1, 3 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - 1/(2 + x)**2
+    assert polygamma(1, 4 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - \
+        1/(2 + x)**2 - 1/(3 + x)**2
+    assert polygamma(0, x + y).expand(func=True) == \
+        polygamma(0, x + y)
+    assert polygamma(1, x + y).expand(func=True) == \
+        polygamma(1, x + y)
+    assert polygamma(1, 3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(1, y + 4*x) - 1/(y + 4*x)**2 - \
+        1/(1 + y + 4*x)**2 - 1/(2 + y + 4*x)**2
+    assert polygamma(3, 3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(3, y + 4*x) - 6/(y + 4*x)**4 - \
+        6/(1 + y + 4*x)**4 - 6/(2 + y + 4*x)**4
+    assert polygamma(3, 4*x + y + 1).expand(func=True, multinomial=False) == \
+        polygamma(3, y + 4*x) - 6/(y + 4*x)**4
+    e = polygamma(3, 4*x + y + Rational(3, 2))
+    assert e.expand(func=True) == e
+    e = polygamma(3, x + y + Rational(3, 4))
+    assert e.expand(func=True, basic=False) == e
+
+    assert polygamma(-1, x, evaluate=False).expand(func=True) == \
+        loggamma(x) - log(pi)/2 - log(2)/2
+    p2 = polygamma(-2, x).expand(func=True) + x**2/2 - x/2 + S(1)/12
+    assert isinstance(p2, Subs)
+    assert p2.point == (-1,)
+
+
+def test_digamma():
+    assert digamma(nan) == nan
+
+    assert digamma(oo) == oo
+    assert digamma(-oo) == oo
+    assert digamma(I*oo) == oo
+    assert digamma(-I*oo) == oo
+
+    assert digamma(-9) == zoo
+
+    assert digamma(-9) == zoo
+    assert digamma(-1) == zoo
+
+    assert digamma(0) == zoo
+
+    assert digamma(1) == -EulerGamma
+    assert digamma(7) == Rational(49, 20) - EulerGamma
+
+    def t(m, n):
+        x = S(m)/n
+        r = digamma(x)
+        if r.has(digamma):
+            return False
+        return abs(digamma(x.n()).n() - r.n()).n() < 1e-10
+    assert t(1, 2)
+    assert t(3, 2)
+    assert t(-1, 2)
+    assert t(1, 4)
+    assert t(-3, 4)
+    assert t(1, 3)
+    assert t(4, 3)
+    assert t(3, 4)
+    assert t(2, 3)
+    assert t(123, 5)
+
+    assert digamma(x).rewrite(zeta) == polygamma(0, x)
+
+    assert digamma(x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma
+
+    assert digamma(I).is_real is None
+
+    assert digamma(x,evaluate=False).fdiff() == polygamma(1, x)
+
+    assert digamma(x,evaluate=False).is_real is None
+
+    assert digamma(x,evaluate=False).is_positive is None
+
+    assert digamma(x,evaluate=False).is_negative is None
+
+    assert digamma(x,evaluate=False).rewrite(polygamma) == polygamma(0, x)
+
+
+def test_digamma_expand_func():
+    assert digamma(x).expand(func=True) == polygamma(0, x)
+    assert digamma(2*x).expand(func=True) == \
+        polygamma(0, x)/2 + polygamma(0, Rational(1, 2) + x)/2 + log(2)
+    assert digamma(-1 + x).expand(func=True) == \
+        polygamma(0, x) - 1/(x - 1)
+    assert digamma(1 + x).expand(func=True) == \
+        1/x + polygamma(0, x )
+    assert digamma(2 + x).expand(func=True) == \
+        1/x + 1/(1 + x) + polygamma(0, x)
+    assert digamma(3 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x)
+    assert digamma(4 + x).expand(func=True) == \
+        polygamma(0, x) + 1/x + 1/(1 + x) + 1/(2 + x) + 1/(3 + x)
+    assert digamma(x + y).expand(func=True) == \
+        polygamma(0, x + y)
+
+def test_trigamma():
+    assert trigamma(nan) == nan
+
+    assert trigamma(oo) == 0
+
+    assert trigamma(1) == pi**2/6
+    assert trigamma(2) == pi**2/6 - 1
+    assert trigamma(3) == pi**2/6 - Rational(5, 4)
+
+    assert trigamma(x, evaluate=False).rewrite(zeta) == zeta(2, x)
+    assert trigamma(x, evaluate=False).rewrite(harmonic) == \
+        trigamma(x).rewrite(polygamma).rewrite(harmonic)
+
+    assert trigamma(x,evaluate=False).fdiff() == polygamma(2, x)
+
+    assert trigamma(x,evaluate=False).is_real is None
+
+    assert trigamma(x,evaluate=False).is_positive is None
+
+    assert trigamma(x,evaluate=False).is_negative is None
+
+    assert trigamma(x,evaluate=False).rewrite(polygamma) == polygamma(1, x)
+
+def test_trigamma_expand_func():
+    assert trigamma(2*x).expand(func=True) == \
+        polygamma(1, x)/4 + polygamma(1, Rational(1, 2) + x)/4
+    assert trigamma(1 + x).expand(func=True) == \
+        polygamma(1, x) - 1/x**2
+    assert trigamma(2 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2
+    assert trigamma(3 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - 1/(2 + x)**2
+    assert trigamma(4 + x).expand(func=True, multinomial=False) == \
+        polygamma(1, x) - 1/x**2 - 1/(1 + x)**2 - \
+        1/(2 + x)**2 - 1/(3 + x)**2
+    assert trigamma(x + y).expand(func=True) == \
+        polygamma(1, x + y)
+    assert trigamma(3 + 4*x + y).expand(func=True, multinomial=False) == \
+        polygamma(1, y + 4*x) - 1/(y + 4*x)**2 - \
+        1/(1 + y + 4*x)**2 - 1/(2 + y + 4*x)**2
+
+def test_loggamma():
+    raises(TypeError, lambda: loggamma(2, 3))
+    raises(ArgumentIndexError, lambda: loggamma(x).fdiff(2))
+
+    assert loggamma(-1) is oo
+    assert loggamma(-2) is oo
+    assert loggamma(0) is oo
+    assert loggamma(1) == 0
+    assert loggamma(2) == 0
+    assert loggamma(3) == log(2)
+    assert loggamma(4) == log(6)
+
+    n = Symbol("n", integer=True, positive=True)
+    assert loggamma(n) == log(gamma(n))
+    assert loggamma(-n) is oo
+    assert loggamma(n/2) == log(2**(-n + 1)*sqrt(pi)*gamma(n)/gamma(n/2 + S.Half))
+
+    assert loggamma(oo) is oo
+    assert loggamma(-oo) is zoo
+    assert loggamma(I*oo) is zoo
+    assert loggamma(-I*oo) is zoo
+    assert loggamma(zoo) is zoo
+    assert loggamma(nan) is nan
+
+    L = loggamma(Rational(16, 3))
+    E = -5*log(3) + loggamma(Rational(1, 3)) + log(4) + log(7) + log(10) + log(13)
+    assert expand_func(L).doit() == E
+    assert L.n() == E.n()
+
+    L = loggamma(Rational(19, 4))
+    E = -4*log(4) + loggamma(Rational(3, 4)) + log(3) + log(7) + log(11) + log(15)
+    assert expand_func(L).doit() == E
+    assert L.n() == E.n()
+
+    L = loggamma(Rational(23, 7))
+    E = -3*log(7) + log(2) + loggamma(Rational(2, 7)) + log(9) + log(16)
+    assert expand_func(L).doit() == E
+    assert L.n() == E.n()
+
+    L = loggamma(Rational(19, 4) - 7)
+    E = -log(9) - log(5) + loggamma(Rational(3, 4)) + 3*log(4) - 3*I*pi
+    assert expand_func(L).doit() == E
+    assert L.n() == E.n()
+
+    L = loggamma(Rational(23, 7) - 6)
+    E = -log(19) - log(12) - log(5) + loggamma(Rational(2, 7)) + 3*log(7) - 3*I*pi
+    assert expand_func(L).doit() == E
+    assert L.n() == E.n()
+
+    assert loggamma(x).diff(x) == polygamma(0, x)
+    s1 = loggamma(1/(x + sin(x)) + cos(x)).nseries(x, n=4)
+    s2 = (-log(2*x) - 1)/(2*x) - log(x/pi)/2 + (4 - log(2*x))*x/24 + O(x**2) + \
+        log(x)*x**2/2
+    assert (s1 - s2).expand(force=True).removeO() == 0
+    s1 = loggamma(1/x).series(x)
+    s2 = (1/x - S.Half)*log(1/x) - 1/x + log(2*pi)/2 + \
+        x/12 - x**3/360 + x**5/1260 + O(x**7)
+    assert ((s1 - s2).expand(force=True)).removeO() == 0
+
+    assert loggamma(x).rewrite('intractable') == log(gamma(x))
+
+    s1 = loggamma(x).series(x).cancel()
+    assert s1 == -log(x) - EulerGamma*x + pi**2*x**2/12 + x**3*polygamma(2, 1)/6 + \
+        pi**4*x**4/360 + x**5*polygamma(4, 1)/120 + O(x**6)
+    assert s1 == loggamma(x).rewrite('intractable').series(x).cancel()
+
+    assert conjugate(loggamma(x)) == loggamma(conjugate(x))
+    assert conjugate(loggamma(0)) is oo
+    assert conjugate(loggamma(1)) == loggamma(conjugate(1))
+    assert conjugate(loggamma(-oo)) == conjugate(zoo)
+
+    assert loggamma(Symbol('v', positive=True)).is_real is True
+    assert loggamma(Symbol('v', zero=True)).is_real is False
+    assert loggamma(Symbol('v', negative=True)).is_real is False
+    assert loggamma(Symbol('v', nonpositive=True)).is_real is False
+    assert loggamma(Symbol('v', nonnegative=True)).is_real is None
+    assert loggamma(Symbol('v', imaginary=True)).is_real is None
+    assert loggamma(Symbol('v', real=True)).is_real is None
+    assert loggamma(Symbol('v')).is_real is None
+
+    assert loggamma(S.Half).is_real is True
+    assert loggamma(0).is_real is False
+    assert loggamma(Rational(-1, 2)).is_real is False
+    assert loggamma(I).is_real is None
+    assert loggamma(2 + 3*I).is_real is None
+
+    def tN(N, M):
+        assert loggamma(1/x)._eval_nseries(x, n=N).getn() == M
+    tN(0, 0)
+    tN(1, 1)
+    tN(2, 2)
+    tN(3, 3)
+    tN(4, 4)
+    tN(5, 5)
+
+
+def test_polygamma_expansion():
+    # A. & S., pa. 259 and 260
+    assert polygamma(0, 1/x).nseries(x, n=3) == \
+        -log(x) - x/2 - x**2/12 + O(x**3)
+    assert polygamma(1, 1/x).series(x, n=5) == \
+        x + x**2/2 + x**3/6 + O(x**5)
+    assert polygamma(3, 1/x).nseries(x, n=11) == \
+        2*x**3 + 3*x**4 + 2*x**5 - x**7 + 4*x**9/3 + O(x**11)
+
+
+def test_polygamma_leading_term():
+    expr = -log(1/x) + polygamma(0, 1 + 1/x) + S.EulerGamma
+    assert expr.as_leading_term(x, logx=-y) == S.EulerGamma
+
+
+def test_issue_8657():
+    n = Symbol('n', negative=True, integer=True)
+    m = Symbol('m', integer=True)
+    o = Symbol('o', positive=True)
+    p = Symbol('p', negative=True, integer=False)
+    assert gamma(n).is_real is False
+    assert gamma(m).is_real is None
+    assert gamma(o).is_real is True
+    assert gamma(p).is_real is True
+    assert gamma(w).is_real is None
+
+
+def test_issue_8524():
+    x = Symbol('x', positive=True)
+    y = Symbol('y', negative=True)
+    z = Symbol('z', positive=False)
+    p = Symbol('p', negative=False)
+    q = Symbol('q', integer=True)
+    r = Symbol('r', integer=False)
+    e = Symbol('e', even=True, negative=True)
+    assert gamma(x).is_positive is True
+    assert gamma(y).is_positive is None
+    assert gamma(z).is_positive is None
+    assert gamma(p).is_positive is None
+    assert gamma(q).is_positive is None
+    assert gamma(r).is_positive is None
+    assert gamma(e + S.Half).is_positive is True
+    assert gamma(e - S.Half).is_positive is False
+
+def test_issue_14450():
+    assert uppergamma(Rational(3, 8), x).evalf() == uppergamma(Rational(3, 8), x)
+    assert lowergamma(x, Rational(3, 8)).evalf() == lowergamma(x, Rational(3, 8))
+    # some values from Wolfram Alpha for comparison
+    assert abs(uppergamma(Rational(3, 8), 2).evalf() - 0.07105675881) < 1e-9
+    assert abs(lowergamma(Rational(3, 8), 2).evalf() - 2.2993794256) < 1e-9
+
+def test_issue_14528():
+    k = Symbol('k', integer=True, nonpositive=True)
+    assert isinstance(gamma(k), gamma)
+
+def test_multigamma():
+    from sympy.concrete.products import Product
+    p = Symbol('p')
+    _k = Dummy('_k')
+
+    assert multigamma(x, p).dummy_eq(pi**(p*(p - 1)/4)*\
+        Product(gamma(x + (1 - _k)/2), (_k, 1, p)))
+
+    assert conjugate(multigamma(x, p)).dummy_eq(pi**((conjugate(p) - 1)*\
+        conjugate(p)/4)*Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p)))
+    assert conjugate(multigamma(x, 1)) == gamma(conjugate(x))
+
+    p = Symbol('p', positive=True)
+    assert conjugate(multigamma(x, p)).dummy_eq(pi**((p - 1)*p/4)*\
+        Product(gamma(conjugate(x) + (1-conjugate(_k))/2), (_k, 1, p)))
+
+    assert multigamma(nan, 1) is nan
+    assert multigamma(oo, 1).doit() is oo
+
+    assert multigamma(1, 1) == 1
+    assert multigamma(2, 1) == 1
+    assert multigamma(3, 1) == 2
+
+    assert multigamma(102, 1) == factorial(101)
+    assert multigamma(S.Half, 1) == sqrt(pi)
+
+    assert multigamma(1, 2) == pi
+    assert multigamma(2, 2) == pi/2
+
+    assert multigamma(1, 3) is zoo
+    assert multigamma(2, 3) == pi**2/2
+    assert multigamma(3, 3) == 3*pi**2/2
+
+    assert multigamma(x, 1).diff(x) == gamma(x)*polygamma(0, x)
+    assert multigamma(x, 2).diff(x) == sqrt(pi)*gamma(x)*gamma(x - S.Half)*\
+        polygamma(0, x) + sqrt(pi)*gamma(x)*gamma(x - S.Half)*polygamma(0, x - S.Half)
+
+    assert multigamma(x - 1, 1).expand(func=True) == gamma(x)/(x - 1)
+    assert multigamma(x + 2, 1).expand(func=True, mul=False) == x*(x + 1)*\
+        gamma(x)
+    assert multigamma(x - 1, 2).expand(func=True) == sqrt(pi)*gamma(x)*\
+        gamma(x + S.Half)/(x**3 - 3*x**2 + x*Rational(11, 4) - Rational(3, 4))
+    assert multigamma(x - 1, 3).expand(func=True) == pi**Rational(3, 2)*gamma(x)**2*\
+        gamma(x + S.Half)/(x**5 - 6*x**4 + 55*x**3/4 - 15*x**2 + x*Rational(31, 4) - Rational(3, 2))
+
+    assert multigamma(n, 1).rewrite(factorial) == factorial(n - 1)
+    assert multigamma(n, 2).rewrite(factorial) == sqrt(pi)*\
+        factorial(n - Rational(3, 2))*factorial(n - 1)
+    assert multigamma(n, 3).rewrite(factorial) == pi**Rational(3, 2)*\
+        factorial(n - 2)*factorial(n - Rational(3, 2))*factorial(n - 1)
+
+    assert multigamma(Rational(-1, 2), 3, evaluate=False).is_real == False
+    assert multigamma(S.Half, 3, evaluate=False).is_real == False
+    assert multigamma(0, 1, evaluate=False).is_real == False
+    assert multigamma(1, 3, evaluate=False).is_real == False
+    assert multigamma(-1.0, 3, evaluate=False).is_real == False
+    assert multigamma(0.7, 3, evaluate=False).is_real == True
+    assert multigamma(3, 3, evaluate=False).is_real == True
+
+def test_gamma_as_leading_term():
+    assert gamma(x).as_leading_term(x) == 1/x
+    assert gamma(2 + x).as_leading_term(x) == S(1)
+    assert gamma(cos(x)).as_leading_term(x) == S(1)
+    assert gamma(sin(x)).as_leading_term(x) == 1/x
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_hyper.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_hyper.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1be5b5f0db158ff76173e180ed8d88bd59461b9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_hyper.py
@@ -0,0 +1,403 @@
+from sympy.core.containers import Tuple
+from sympy.core.function import Derivative
+from sympy.core.numbers import (I, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.exponential import (exp, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import (appellf1, hyper, meijerg)
+from sympy.series.order import O
+from sympy.abc import x, z, k
+from sympy.series.limits import limit
+from sympy.testing.pytest import raises, slow
+from sympy.core.random import (
+    random_complex_number as randcplx,
+    verify_numerically as tn,
+    test_derivative_numerically as td)
+
+
+def test_TupleParametersBase():
+    # test that our implementation of the chain rule works
+    p = hyper((), (), z**2)
+    assert p.diff(z) == p*2*z
+
+
+def test_hyper():
+    raises(TypeError, lambda: hyper(1, 2, z))
+
+    assert hyper((2, 1), (1,), z) == hyper(Tuple(1, 2), Tuple(1), z)
+    assert hyper((2, 1, 2), (1, 2, 1, 3), z) == hyper((2,), (1, 3), z)
+    u = hyper((2, 1, 2), (1, 2, 1, 3), z, evaluate=False)
+    assert u.ap == Tuple(1, 2, 2)
+    assert u.bq == Tuple(1, 1, 2, 3)
+
+    h = hyper((1, 2), (3, 4, 5), z)
+    assert h.ap == Tuple(1, 2)
+    assert h.bq == Tuple(3, 4, 5)
+    assert h.argument == z
+    assert h.is_commutative is True
+    h = hyper((2, 1), (4, 3, 5), z)
+    assert h.ap == Tuple(1, 2)
+    assert h.bq == Tuple(3, 4, 5)
+    assert h.argument == z
+    assert h.is_commutative is True
+
+    # just a few checks to make sure that all arguments go where they should
+    assert tn(hyper(Tuple(), Tuple(), z), exp(z), z)
+    assert tn(z*hyper((1, 1), Tuple(2), -z), log(1 + z), z)
+
+    # differentiation
+    h = hyper(
+        (randcplx(), randcplx(), randcplx()), (randcplx(), randcplx()), z)
+    assert td(h, z)
+
+    a1, a2, b1, b2, b3 = symbols('a1:3, b1:4')
+    assert hyper((a1, a2), (b1, b2, b3), z).diff(z) == \
+        a1*a2/(b1*b2*b3) * hyper((a1 + 1, a2 + 1), (b1 + 1, b2 + 1, b3 + 1), z)
+
+    # differentiation wrt parameters is not supported
+    assert hyper([z], [], z).diff(z) == Derivative(hyper([z], [], z), z)
+
+    # hyper is unbranched wrt parameters
+    from sympy.functions.elementary.complexes import polar_lift
+    assert hyper([polar_lift(z)], [polar_lift(k)], polar_lift(x)) == \
+        hyper([z], [k], polar_lift(x))
+
+    # hyper does not automatically evaluate anyway, but the test is to make
+    # sure that the evaluate keyword is accepted
+    assert hyper((1, 2), (1,), z, evaluate=False).func is hyper
+
+
+def test_expand_func():
+    # evaluation at 1 of Gauss' hypergeometric function:
+    from sympy.abc import a, b, c
+    from sympy.core.function import expand_func
+    a1, b1, c1 = randcplx(), randcplx(), randcplx() + 5
+    assert expand_func(hyper([a, b], [c], 1)) == \
+        gamma(c)*gamma(-a - b + c)/(gamma(-a + c)*gamma(-b + c))
+    assert abs(expand_func(hyper([a1, b1], [c1], 1)).n()
+               - hyper([a1, b1], [c1], 1).n()) < 1e-10
+
+    # hyperexpand wrapper for hyper:
+    assert expand_func(hyper([], [], z)) == exp(z)
+    assert expand_func(hyper([1, 2, 3], [], z)) == hyper([1, 2, 3], [], z)
+    assert expand_func(meijerg([[1, 1], []], [[1], [0]], z)) == log(z + 1)
+    assert expand_func(meijerg([[1, 1], []], [[], []], z)) == \
+        meijerg([[1, 1], []], [[], []], z)
+
+
+def replace_dummy(expr, sym):
+    from sympy.core.symbol import Dummy
+    dum = expr.atoms(Dummy)
+    if not dum:
+        return expr
+    assert len(dum) == 1
+    return expr.xreplace({dum.pop(): sym})
+
+
+def test_hyper_rewrite_sum():
+    from sympy.concrete.summations import Sum
+    from sympy.core.symbol import Dummy
+    from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
+    _k = Dummy("k")
+    assert replace_dummy(hyper((1, 2), (1, 3), x).rewrite(Sum), _k) == \
+        Sum(x**_k / factorial(_k) * RisingFactorial(2, _k) /
+            RisingFactorial(3, _k), (_k, 0, oo))
+
+    assert hyper((1, 2, 3), (-1, 3), z).rewrite(Sum) == \
+        hyper((1, 2, 3), (-1, 3), z)
+
+
+def test_radius_of_convergence():
+    assert hyper((1, 2), [3], z).radius_of_convergence == 1
+    assert hyper((1, 2), [3, 4], z).radius_of_convergence is oo
+    assert hyper((1, 2, 3), [4], z).radius_of_convergence == 0
+    assert hyper((0, 1, 2), [4], z).radius_of_convergence is oo
+    assert hyper((-1, 1, 2), [-4], z).radius_of_convergence == 0
+    assert hyper((-1, -2, 2), [-1], z).radius_of_convergence is oo
+    assert hyper((-1, 2), [-1, -2], z).radius_of_convergence == 0
+    assert hyper([-1, 1, 3], [-2, 2], z).radius_of_convergence == 1
+    assert hyper([-1, 1], [-2, 2], z).radius_of_convergence is oo
+    assert hyper([-1, 1, 3], [-2], z).radius_of_convergence == 0
+    assert hyper((-1, 2, 3, 4), [], z).radius_of_convergence is oo
+
+    assert hyper([1, 1], [3], 1).convergence_statement == True
+    assert hyper([1, 1], [2], 1).convergence_statement == False
+    assert hyper([1, 1], [2], -1).convergence_statement == True
+    assert hyper([1, 1], [1], -1).convergence_statement == False
+
+
+def test_meijer():
+    raises(TypeError, lambda: meijerg(1, z))
+    raises(TypeError, lambda: meijerg(((1,), (2,)), (3,), (4,), z))
+
+    assert meijerg(((1, 2), (3,)), ((4,), (5,)), z) == \
+        meijerg(Tuple(1, 2), Tuple(3), Tuple(4), Tuple(5), z)
+
+    g = meijerg((1, 2), (3, 4, 5), (6, 7, 8, 9), (10, 11, 12, 13, 14), z)
+    assert g.an == Tuple(1, 2)
+    assert g.ap == Tuple(1, 2, 3, 4, 5)
+    assert g.aother == Tuple(3, 4, 5)
+    assert g.bm == Tuple(6, 7, 8, 9)
+    assert g.bq == Tuple(6, 7, 8, 9, 10, 11, 12, 13, 14)
+    assert g.bother == Tuple(10, 11, 12, 13, 14)
+    assert g.argument == z
+    assert g.nu == 75
+    assert g.delta == -1
+    assert g.is_commutative is True
+    assert g.is_number is False
+    #issue 13071
+    assert meijerg([[],[]], [[S.Half],[0]], 1).is_number is True
+
+    assert meijerg([1, 2], [3], [4], [5], z).delta == S.Half
+
+    # just a few checks to make sure that all arguments go where they should
+    assert tn(meijerg(Tuple(), Tuple(), Tuple(0), Tuple(), -z), exp(z), z)
+    assert tn(sqrt(pi)*meijerg(Tuple(), Tuple(),
+                               Tuple(0), Tuple(S.Half), z**2/4), cos(z), z)
+    assert tn(meijerg(Tuple(1, 1), Tuple(), Tuple(1), Tuple(0), z),
+              log(1 + z), z)
+
+    # test exceptions
+    raises(ValueError, lambda: meijerg(((3, 1), (2,)), ((oo,), (2, 0)), x))
+    raises(ValueError, lambda: meijerg(((3, 1), (2,)), ((1,), (2, 0)), x))
+
+    # differentiation
+    g = meijerg((randcplx(),), (randcplx() + 2*I,), Tuple(),
+                (randcplx(), randcplx()), z)
+    assert td(g, z)
+
+    g = meijerg(Tuple(), (randcplx(),), Tuple(),
+                (randcplx(), randcplx()), z)
+    assert td(g, z)
+
+    g = meijerg(Tuple(), Tuple(), Tuple(randcplx()),
+                Tuple(randcplx(), randcplx()), z)
+    assert td(g, z)
+
+    a1, a2, b1, b2, c1, c2, d1, d2 = symbols('a1:3, b1:3, c1:3, d1:3')
+    assert meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z).diff(z) == \
+        (meijerg((a1 - 1, a2), (b1, b2), (c1, c2), (d1, d2), z)
+         + (a1 - 1)*meijerg((a1, a2), (b1, b2), (c1, c2), (d1, d2), z))/z
+
+    assert meijerg([z, z], [], [], [], z).diff(z) == \
+        Derivative(meijerg([z, z], [], [], [], z), z)
+
+    # meijerg is unbranched wrt parameters
+    from sympy.functions.elementary.complexes import polar_lift as pl
+    assert meijerg([pl(a1)], [pl(a2)], [pl(b1)], [pl(b2)], pl(z)) == \
+        meijerg([a1], [a2], [b1], [b2], pl(z))
+
+    # integrand
+    from sympy.abc import a, b, c, d, s
+    assert meijerg([a], [b], [c], [d], z).integrand(s) == \
+        z**s*gamma(c - s)*gamma(-a + s + 1)/(gamma(b - s)*gamma(-d + s + 1))
+
+
+def test_meijerg_derivative():
+    assert meijerg([], [1, 1], [0, 0, x], [], z).diff(x) == \
+        log(z)*meijerg([], [1, 1], [0, 0, x], [], z) \
+        + 2*meijerg([], [1, 1, 1], [0, 0, x, 0], [], z)
+
+    y = randcplx()
+    a = 5  # mpmath chokes with non-real numbers, and Mod1 with floats
+    assert td(meijerg([x], [], [], [], y), x)
+    assert td(meijerg([x**2], [], [], [], y), x)
+    assert td(meijerg([], [x], [], [], y), x)
+    assert td(meijerg([], [], [x], [], y), x)
+    assert td(meijerg([], [], [], [x], y), x)
+    assert td(meijerg([x], [a], [a + 1], [], y), x)
+    assert td(meijerg([x], [a + 1], [a], [], y), x)
+    assert td(meijerg([x, a], [], [], [a + 1], y), x)
+    assert td(meijerg([x, a + 1], [], [], [a], y), x)
+    b = Rational(3, 2)
+    assert td(meijerg([a + 2], [b], [b - 3, x], [a], y), x)
+
+
+def test_meijerg_period():
+    assert meijerg([], [1], [0], [], x).get_period() == 2*pi
+    assert meijerg([1], [], [], [0], x).get_period() == 2*pi
+    assert meijerg([], [], [0], [], x).get_period() == 2*pi  # exp(x)
+    assert meijerg(
+        [], [], [0], [S.Half], x).get_period() == 2*pi  # cos(sqrt(x))
+    assert meijerg(
+        [], [], [S.Half], [0], x).get_period() == 4*pi  # sin(sqrt(x))
+    assert meijerg([1, 1], [], [1], [0], x).get_period() is oo  # log(1 + x)
+
+
+def test_hyper_unpolarify():
+    from sympy.functions.elementary.exponential import exp_polar
+    a = exp_polar(2*pi*I)*x
+    b = x
+    assert hyper([], [], a).argument == b
+    assert hyper([0], [], a).argument == a
+    assert hyper([0], [0], a).argument == b
+    assert hyper([0, 1], [0], a).argument == a
+    assert hyper([0, 1], [0], exp_polar(2*pi*I)).argument == 1
+
+
+@slow
+def test_hyperrep():
+    from sympy.functions.special.hyper import (HyperRep, HyperRep_atanh,
+        HyperRep_power1, HyperRep_power2, HyperRep_log1, HyperRep_asin1,
+        HyperRep_asin2, HyperRep_sqrts1, HyperRep_sqrts2, HyperRep_log2,
+        HyperRep_cosasin, HyperRep_sinasin)
+    # First test the base class works.
+    from sympy.functions.elementary.exponential import exp_polar
+    from sympy.functions.elementary.piecewise import Piecewise
+    a, b, c, d, z = symbols('a b c d z')
+
+    class myrep(HyperRep):
+        @classmethod
+        def _expr_small(cls, x):
+            return a
+
+        @classmethod
+        def _expr_small_minus(cls, x):
+            return b
+
+        @classmethod
+        def _expr_big(cls, x, n):
+            return c*n
+
+        @classmethod
+        def _expr_big_minus(cls, x, n):
+            return d*n
+    assert myrep(z).rewrite('nonrep') == Piecewise((0, abs(z) > 1), (a, True))
+    assert myrep(exp_polar(I*pi)*z).rewrite('nonrep') == \
+        Piecewise((0, abs(z) > 1), (b, True))
+    assert myrep(exp_polar(2*I*pi)*z).rewrite('nonrep') == \
+        Piecewise((c, abs(z) > 1), (a, True))
+    assert myrep(exp_polar(3*I*pi)*z).rewrite('nonrep') == \
+        Piecewise((d, abs(z) > 1), (b, True))
+    assert myrep(exp_polar(4*I*pi)*z).rewrite('nonrep') == \
+        Piecewise((2*c, abs(z) > 1), (a, True))
+    assert myrep(exp_polar(5*I*pi)*z).rewrite('nonrep') == \
+        Piecewise((2*d, abs(z) > 1), (b, True))
+    assert myrep(z).rewrite('nonrepsmall') == a
+    assert myrep(exp_polar(I*pi)*z).rewrite('nonrepsmall') == b
+
+    def t(func, hyp, z):
+        """ Test that func is a valid representation of hyp. """
+        # First test that func agrees with hyp for small z
+        if not tn(func.rewrite('nonrepsmall'), hyp, z,
+                  a=Rational(-1, 2), b=Rational(-1, 2), c=S.Half, d=S.Half):
+            return False
+        # Next check that the two small representations agree.
+        if not tn(
+            func.rewrite('nonrepsmall').subs(
+                z, exp_polar(I*pi)*z).replace(exp_polar, exp),
+            func.subs(z, exp_polar(I*pi)*z).rewrite('nonrepsmall'),
+                z, a=Rational(-1, 2), b=Rational(-1, 2), c=S.Half, d=S.Half):
+            return False
+        # Next check continuity along exp_polar(I*pi)*t
+        expr = func.subs(z, exp_polar(I*pi)*z).rewrite('nonrep')
+        if abs(expr.subs(z, 1 + 1e-15).n() - expr.subs(z, 1 - 1e-15).n()) > 1e-10:
+            return False
+        # Finally check continuity of the big reps.
+
+        def dosubs(func, a, b):
+            rv = func.subs(z, exp_polar(a)*z).rewrite('nonrep')
+            return rv.subs(z, exp_polar(b)*z).replace(exp_polar, exp)
+        for n in [0, 1, 2, 3, 4, -1, -2, -3, -4]:
+            expr1 = dosubs(func, 2*I*pi*n, I*pi/2)
+            expr2 = dosubs(func, 2*I*pi*n + I*pi, -I*pi/2)
+            if not tn(expr1, expr2, z):
+                return False
+            expr1 = dosubs(func, 2*I*pi*(n + 1), -I*pi/2)
+            expr2 = dosubs(func, 2*I*pi*n + I*pi, I*pi/2)
+            if not tn(expr1, expr2, z):
+                return False
+        return True
+
+    # Now test the various representatives.
+    a = Rational(1, 3)
+    assert t(HyperRep_atanh(z), hyper([S.Half, 1], [Rational(3, 2)], z), z)
+    assert t(HyperRep_power1(a, z), hyper([-a], [], z), z)
+    assert t(HyperRep_power2(a, z), hyper([a, a - S.Half], [2*a], z), z)
+    assert t(HyperRep_log1(z), -z*hyper([1, 1], [2], z), z)
+    assert t(HyperRep_asin1(z), hyper([S.Half, S.Half], [Rational(3, 2)], z), z)
+    assert t(HyperRep_asin2(z), hyper([1, 1], [Rational(3, 2)], z), z)
+    assert t(HyperRep_sqrts1(a, z), hyper([-a, S.Half - a], [S.Half], z), z)
+    assert t(HyperRep_sqrts2(a, z),
+             -2*z/(2*a + 1)*hyper([-a - S.Half, -a], [S.Half], z).diff(z), z)
+    assert t(HyperRep_log2(z), -z/4*hyper([Rational(3, 2), 1, 1], [2, 2], z), z)
+    assert t(HyperRep_cosasin(a, z), hyper([-a, a], [S.Half], z), z)
+    assert t(HyperRep_sinasin(a, z), 2*a*z*hyper([1 - a, 1 + a], [Rational(3, 2)], z), z)
+
+
+@slow
+def test_meijerg_eval():
+    from sympy.functions.elementary.exponential import exp_polar
+    from sympy.functions.special.bessel import besseli
+    from sympy.abc import l
+    a = randcplx()
+    arg = x*exp_polar(k*pi*I)
+    expr1 = pi*meijerg([[], [(a + 1)/2]], [[a/2], [-a/2, (a + 1)/2]], arg**2/4)
+    expr2 = besseli(a, arg)
+
+    # Test that the two expressions agree for all arguments.
+    for x_ in [0.5, 1.5]:
+        for k_ in [0.0, 0.1, 0.3, 0.5, 0.8, 1, 5.751, 15.3]:
+            assert abs((expr1 - expr2).n(subs={x: x_, k: k_})) < 1e-10
+            assert abs((expr1 - expr2).n(subs={x: x_, k: -k_})) < 1e-10
+
+    # Test continuity independently
+    eps = 1e-13
+    expr2 = expr1.subs(k, l)
+    for x_ in [0.5, 1.5]:
+        for k_ in [0.5, Rational(1, 3), 0.25, 0.75, Rational(2, 3), 1.0, 1.5]:
+            assert abs((expr1 - expr2).n(
+                       subs={x: x_, k: k_ + eps, l: k_ - eps})) < 1e-10
+            assert abs((expr1 - expr2).n(
+                       subs={x: x_, k: -k_ + eps, l: -k_ - eps})) < 1e-10
+
+    expr = (meijerg(((0.5,), ()), ((0.5, 0, 0.5), ()), exp_polar(-I*pi)/4)
+            + meijerg(((0.5,), ()), ((0.5, 0, 0.5), ()), exp_polar(I*pi)/4)) \
+        /(2*sqrt(pi))
+    assert (expr - pi/exp(1)).n(chop=True) == 0
+
+
+def test_limits():
+    k, x = symbols('k, x')
+    assert hyper((1,), (Rational(4, 3), Rational(5, 3)), k**2).series(k) == \
+           1 + 9*k**2/20 + 81*k**4/1120 + O(k**6) # issue 6350
+
+    # https://github.com/sympy/sympy/issues/11465
+    assert limit(1/hyper((1, ), (1, ), x), x, 0) == 1
+
+
+def test_appellf1():
+    a, b1, b2, c, x, y = symbols('a b1 b2 c x y')
+    assert appellf1(a, b2, b1, c, y, x) == appellf1(a, b1, b2, c, x, y)
+    assert appellf1(a, b1, b1, c, y, x) == appellf1(a, b1, b1, c, x, y)
+    assert appellf1(a, b1, b2, c, S.Zero, S.Zero) is S.One
+
+    f = appellf1(a, b1, b2, c, S.Zero, S.Zero, evaluate=False)
+    assert f.func is appellf1
+    assert f.doit() is S.One
+
+
+def test_derivative_appellf1():
+    from sympy.core.function import diff
+    a, b1, b2, c, x, y, z = symbols('a b1 b2 c x y z')
+    assert diff(appellf1(a, b1, b2, c, x, y), x) == a*b1*appellf1(a + 1, b2, b1 + 1, c + 1, y, x)/c
+    assert diff(appellf1(a, b1, b2, c, x, y), y) == a*b2*appellf1(a + 1, b1, b2 + 1, c + 1, x, y)/c
+    assert diff(appellf1(a, b1, b2, c, x, y), z) == 0
+    assert diff(appellf1(a, b1, b2, c, x, y), a) ==  Derivative(appellf1(a, b1, b2, c, x, y), a)
+
+
+def test_eval_nseries():
+    a1, b1, a2, b2 = symbols('a1 b1 a2 b2')
+    assert hyper((1,2), (1,2,3), x**2)._eval_nseries(x, 7, None) == \
+        1 + x**2/3 + x**4/24 + x**6/360 + O(x**7)
+    assert exp(x)._eval_nseries(x,7,None) == \
+        hyper((a1, b1), (a1, b1), x)._eval_nseries(x, 7, None)
+    assert hyper((a1, a2), (b1, b2), x)._eval_nseries(z, 7, None) ==\
+        hyper((a1, a2), (b1, b2), x) + O(z**7)
+    assert hyper((-S(1)/2, S(1)/2), (1,), 4*x/(x + 1)).nseries(x) == \
+        1 - x + x**2/4 - 3*x**3/4 - 15*x**4/64 - 93*x**5/64 + O(x**6)
+    assert (pi/2*hyper((-S(1)/2, S(1)/2), (1,), 4*x/(x + 1))).nseries(x) == \
+        pi/2 - pi*x/2 + pi*x**2/8 - 3*pi*x**3/8 - 15*pi*x**4/128 - 93*pi*x**5/128 + O(x**6)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_mathieu.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_mathieu.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9296f0657d920c8d297f820fb3ab8b6a53129ab
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_mathieu.py
@@ -0,0 +1,29 @@
+from sympy.core.function import diff
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, sin)
+from sympy.functions.special.mathieu_functions import (mathieuc, mathieucprime, mathieus, mathieusprime)
+
+from sympy.abc import a, q, z
+
+
+def test_mathieus():
+    assert isinstance(mathieus(a, q, z), mathieus)
+    assert mathieus(a, 0, z) == sin(sqrt(a)*z)
+    assert conjugate(mathieus(a, q, z)) == mathieus(conjugate(a), conjugate(q), conjugate(z))
+    assert diff(mathieus(a, q, z), z) == mathieusprime(a, q, z)
+
+def test_mathieuc():
+    assert isinstance(mathieuc(a, q, z), mathieuc)
+    assert mathieuc(a, 0, z) == cos(sqrt(a)*z)
+    assert diff(mathieuc(a, q, z), z) == mathieucprime(a, q, z)
+
+def test_mathieusprime():
+    assert isinstance(mathieusprime(a, q, z), mathieusprime)
+    assert mathieusprime(a, 0, z) == sqrt(a)*cos(sqrt(a)*z)
+    assert diff(mathieusprime(a, q, z), z) == (-a + 2*q*cos(2*z))*mathieus(a, q, z)
+
+def test_mathieucprime():
+    assert isinstance(mathieucprime(a, q, z), mathieucprime)
+    assert mathieucprime(a, 0, z) == -sqrt(a)*sin(sqrt(a)*z)
+    assert diff(mathieucprime(a, q, z), z) == (-a + 2*q*cos(2*z))*mathieuc(a, q, z)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_singularity_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_singularity_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..dbd85cb0c7e5524d4fe1441615879b9776ad1693
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_singularity_functions.py
@@ -0,0 +1,129 @@
+from sympy.core.function import (Derivative, diff)
+from sympy.core.numbers import (Float, I, nan, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.delta_functions import (DiracDelta, Heaviside)
+from sympy.functions.special.singularity_functions import SingularityFunction
+from sympy.series.order import O
+
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+
+x, y, a, n = symbols('x y a n')
+
+
+def test_fdiff():
+    assert SingularityFunction(x, 4, 5).fdiff() == 5*SingularityFunction(x, 4, 4)
+    assert SingularityFunction(x, 4, -1).fdiff() == SingularityFunction(x, 4, -2)
+    assert SingularityFunction(x, 4, -2).fdiff() == SingularityFunction(x, 4, -3)
+    assert SingularityFunction(x, 4, -3).fdiff() == SingularityFunction(x, 4, -4)
+    assert SingularityFunction(x, 4, 0).fdiff() == SingularityFunction(x, 4, -1)
+
+    assert SingularityFunction(y, 6, 2).diff(y) == 2*SingularityFunction(y, 6, 1)
+    assert SingularityFunction(y, -4, -1).diff(y) == SingularityFunction(y, -4, -2)
+    assert SingularityFunction(y, 4, 0).diff(y) == SingularityFunction(y, 4, -1)
+    assert SingularityFunction(y, 4, 0).diff(y, 2) == SingularityFunction(y, 4, -2)
+
+    n = Symbol('n', positive=True)
+    assert SingularityFunction(x, a, n).fdiff() == n*SingularityFunction(x, a, n - 1)
+    assert SingularityFunction(y, a, n).diff(y) == n*SingularityFunction(y, a, n - 1)
+
+    expr_in = 4*SingularityFunction(x, a, n) + 3*SingularityFunction(x, a, -1) + -10*SingularityFunction(x, a, 0)
+    expr_out = n*4*SingularityFunction(x, a, n - 1) + 3*SingularityFunction(x, a, -2) - 10*SingularityFunction(x, a, -1)
+    assert diff(expr_in, x) == expr_out
+
+    assert SingularityFunction(x, -10, 5).diff(evaluate=False) == (
+        Derivative(SingularityFunction(x, -10, 5), x))
+
+    raises(ArgumentIndexError, lambda: SingularityFunction(x, 4, 5).fdiff(2))
+
+
+def test_eval():
+    assert SingularityFunction(x, a, n).func == SingularityFunction
+    assert unchanged(SingularityFunction, x, 5, n)
+    assert SingularityFunction(5, 3, 2) == 4
+    assert SingularityFunction(3, 5, 1) == 0
+    assert SingularityFunction(3, 3, 0) == 1
+    assert SingularityFunction(3, 3, 1) == 0
+    assert SingularityFunction(Symbol('z', zero=True), 0, 1) == 0  # like sin(z) == 0
+    assert SingularityFunction(4, 4, -1) is oo
+    assert SingularityFunction(4, 2, -1) == 0
+    assert SingularityFunction(4, 7, -1) == 0
+    assert SingularityFunction(5, 6, -2) == 0
+    assert SingularityFunction(4, 2, -2) == 0
+    assert SingularityFunction(4, 4, -2) is oo
+    assert SingularityFunction(4, 2, -3) == 0
+    assert SingularityFunction(8, 8, -3) is oo
+    assert SingularityFunction(4, 2, -4) == 0
+    assert SingularityFunction(8, 8, -4) is oo
+    assert (SingularityFunction(6.1, 4, 5)).evalf(5) == Float('40.841', '5')
+    assert SingularityFunction(6.1, pi, 2) == (-pi + 6.1)**2
+    assert SingularityFunction(x, a, nan) is nan
+    assert SingularityFunction(x, nan, 1) is nan
+    assert SingularityFunction(nan, a, n) is nan
+
+    raises(ValueError, lambda: SingularityFunction(x, a, I))
+    raises(ValueError, lambda: SingularityFunction(2*I, I, n))
+    raises(ValueError, lambda: SingularityFunction(x, a, -5))
+
+
+def test_leading_term():
+    l = Symbol('l', positive=True)
+    assert SingularityFunction(x, 3, 2).as_leading_term(x) == 0
+    assert SingularityFunction(x, -2, 1).as_leading_term(x) == 2
+    assert SingularityFunction(x, 0, 0).as_leading_term(x) == 1
+    assert SingularityFunction(x, 0, 0).as_leading_term(x, cdir=-1) == 0
+    assert SingularityFunction(x, 0, -1).as_leading_term(x) == 0
+    assert SingularityFunction(x, 0, -2).as_leading_term(x) == 0
+    assert SingularityFunction(x, 0, -3).as_leading_term(x) == 0
+    assert SingularityFunction(x, 0, -4).as_leading_term(x) == 0
+    assert (SingularityFunction(x + l, 0, 1)/2\
+        - SingularityFunction(x + l, l/2, 1)\
+        + SingularityFunction(x + l, l, 1)/2).as_leading_term(x) == -x/2
+
+
+def test_series():
+    l = Symbol('l', positive=True)
+    assert SingularityFunction(x, -3, 2).series(x) == x**2 + 6*x + 9
+    assert SingularityFunction(x, -2, 1).series(x) == x + 2
+    assert SingularityFunction(x, 0, 0).series(x) == 1
+    assert SingularityFunction(x, 0, 0).series(x, dir='-') == 0
+    assert SingularityFunction(x, 0, -1).series(x) == 0
+    assert SingularityFunction(x, 0, -2).series(x) == 0
+    assert SingularityFunction(x, 0, -3).series(x) == 0
+    assert SingularityFunction(x, 0, -4).series(x) == 0
+    assert (SingularityFunction(x + l, 0, 1)/2\
+        - SingularityFunction(x + l, l/2, 1)\
+        + SingularityFunction(x + l, l, 1)/2).nseries(x) == -x/2 + O(x**6)
+
+
+def test_rewrite():
+    assert SingularityFunction(x, 4, 5).rewrite(Piecewise) == (
+        Piecewise(((x - 4)**5, x - 4 >= 0), (0, True)))
+    assert SingularityFunction(x, -10, 0).rewrite(Piecewise) == (
+        Piecewise((1, x + 10 >= 0), (0, True)))
+    assert SingularityFunction(x, 2, -1).rewrite(Piecewise) == (
+        Piecewise((oo, Eq(x - 2, 0)), (0, True)))
+    assert SingularityFunction(x, 0, -2).rewrite(Piecewise) == (
+        Piecewise((oo, Eq(x, 0)), (0, True)))
+
+    n = Symbol('n', nonnegative=True)
+    p = SingularityFunction(x, a, n).rewrite(Piecewise)
+    assert p == (
+        Piecewise(((x - a)**n, x - a >= 0), (0, True)))
+    assert p.subs(x, a).subs(n, 0) == 1
+
+    expr_in = SingularityFunction(x, 4, 5) + SingularityFunction(x, -3, -1) - SingularityFunction(x, 0, -2)
+    expr_out = (x - 4)**5*Heaviside(x - 4, 1) + DiracDelta(x + 3) - DiracDelta(x, 1)
+    assert expr_in.rewrite(Heaviside) == expr_out
+    assert expr_in.rewrite(DiracDelta) == expr_out
+    assert expr_in.rewrite('HeavisideDiracDelta') == expr_out
+
+    expr_in = SingularityFunction(x, a, n) + SingularityFunction(x, a, -1) - SingularityFunction(x, a, -2)
+    expr_out = (x - a)**n*Heaviside(x - a, 1) + DiracDelta(x - a) + DiracDelta(a - x, 1)
+    assert expr_in.rewrite(Heaviside) == expr_out
+    assert expr_in.rewrite(DiracDelta) == expr_out
+    assert expr_in.rewrite('HeavisideDiracDelta') == expr_out
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spec_polynomials.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spec_polynomials.py
new file mode 100644
index 0000000000000000000000000000000000000000..584ad3cf97df8b9d92da9fc7805ab4296f40671c
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spec_polynomials.py
@@ -0,0 +1,475 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import (Derivative, diff)
+from sympy.core.numbers import (Rational, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, Symbol)
+from sympy.functions.combinatorial.factorials import (RisingFactorial, binomial, factorial)
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.integers import floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import cos
+from sympy.functions.special.gamma_functions import gamma
+from sympy.functions.special.hyper import hyper
+from sympy.functions.special.polynomials import (assoc_laguerre, assoc_legendre, chebyshevt, chebyshevt_root, chebyshevu, chebyshevu_root, gegenbauer, hermite, hermite_prob, jacobi, jacobi_normalized, laguerre, legendre)
+from sympy.polys.orthopolys import laguerre_poly
+from sympy.polys.polyroots import roots
+
+from sympy.core.expr import unchanged
+from sympy.core.function import ArgumentIndexError
+from sympy.testing.pytest import raises
+
+
+x = Symbol('x')
+
+
+def test_jacobi():
+    n = Symbol("n")
+    a = Symbol("a")
+    b = Symbol("b")
+
+    assert jacobi(0, a, b, x) == 1
+    assert jacobi(1, a, b, x) == a/2 - b/2 + x*(a/2 + b/2 + 1)
+
+    assert jacobi(n, a, a, x) == RisingFactorial(
+        a + 1, n)*gegenbauer(n, a + S.Half, x)/RisingFactorial(2*a + 1, n)
+    assert jacobi(n, a, -a, x) == ((-1)**a*(-x + 1)**(-a/2)*(x + 1)**(a/2)*assoc_legendre(n, a, x)*
+                                   factorial(-a + n)*gamma(a + n + 1)/(factorial(a + n)*gamma(n + 1)))
+    assert jacobi(n, -b, b, x) == ((-x + 1)**(b/2)*(x + 1)**(-b/2)*assoc_legendre(n, b, x)*
+                                   gamma(-b + n + 1)/gamma(n + 1))
+    assert jacobi(n, 0, 0, x) == legendre(n, x)
+    assert jacobi(n, S.Half, S.Half, x) == RisingFactorial(
+        Rational(3, 2), n)*chebyshevu(n, x)/factorial(n + 1)
+    assert jacobi(n, Rational(-1, 2), Rational(-1, 2), x) == RisingFactorial(
+        S.Half, n)*chebyshevt(n, x)/factorial(n)
+
+    X = jacobi(n, a, b, x)
+    assert isinstance(X, jacobi)
+
+    assert jacobi(n, a, b, -x) == (-1)**n*jacobi(n, b, a, x)
+    assert jacobi(n, a, b, 0) == 2**(-n)*gamma(a + n + 1)*hyper(
+        (-b - n, -n), (a + 1,), -1)/(factorial(n)*gamma(a + 1))
+    assert jacobi(n, a, b, 1) == RisingFactorial(a + 1, n)/factorial(n)
+
+    m = Symbol("m", positive=True)
+    assert jacobi(m, a, b, oo) == oo*RisingFactorial(a + b + m + 1, m)
+    assert unchanged(jacobi, n, a, b, oo)
+
+    assert conjugate(jacobi(m, a, b, x)) == \
+        jacobi(m, conjugate(a), conjugate(b), conjugate(x))
+
+    _k = Dummy('k')
+    assert diff(jacobi(n, a, b, x), n) == Derivative(jacobi(n, a, b, x), n)
+    assert diff(jacobi(n, a, b, x), a).dummy_eq(Sum((jacobi(n, a, b, x) +
+        (2*_k + a + b + 1)*RisingFactorial(_k + b + 1, -_k + n)*jacobi(_k, a,
+        b, x)/((-_k + n)*RisingFactorial(_k + a + b + 1, -_k + n)))/(_k + a
+        + b + n + 1), (_k, 0, n - 1)))
+    assert diff(jacobi(n, a, b, x), b).dummy_eq(Sum(((-1)**(-_k + n)*(2*_k +
+        a + b + 1)*RisingFactorial(_k + a + 1, -_k + n)*jacobi(_k, a, b, x)/
+        ((-_k + n)*RisingFactorial(_k + a + b + 1, -_k + n)) + jacobi(n, a,
+        b, x))/(_k + a + b + n + 1), (_k, 0, n - 1)))
+    assert diff(jacobi(n, a, b, x), x) == \
+        (a/2 + b/2 + n/2 + S.Half)*jacobi(n - 1, a + 1, b + 1, x)
+
+    assert jacobi_normalized(n, a, b, x) == \
+           (jacobi(n, a, b, x)/sqrt(2**(a + b + 1)*gamma(a + n + 1)*gamma(b + n + 1)
+                                    /((a + b + 2*n + 1)*factorial(n)*gamma(a + b + n + 1))))
+
+    raises(ValueError, lambda: jacobi(-2.1, a, b, x))
+    raises(ValueError, lambda: jacobi(Dummy(positive=True, integer=True), 1, 2, oo))
+
+    assert jacobi(n, a, b, x).rewrite(Sum).dummy_eq(Sum((S.Half - x/2)
+        **_k*RisingFactorial(-n, _k)*RisingFactorial(_k + a + 1, -_k + n)*
+        RisingFactorial(a + b + n + 1, _k)/factorial(_k), (_k, 0, n))/factorial(n))
+    assert jacobi(n, a, b, x).rewrite("polynomial").dummy_eq(Sum((S.Half - x/2)
+        **_k*RisingFactorial(-n, _k)*RisingFactorial(_k + a + 1, -_k + n)*
+        RisingFactorial(a + b + n + 1, _k)/factorial(_k), (_k, 0, n))/factorial(n))
+    raises(ArgumentIndexError, lambda: jacobi(n, a, b, x).fdiff(5))
+
+
+def test_gegenbauer():
+    n = Symbol("n")
+    a = Symbol("a")
+
+    assert gegenbauer(0, a, x) == 1
+    assert gegenbauer(1, a, x) == 2*a*x
+    assert gegenbauer(2, a, x) == -a + x**2*(2*a**2 + 2*a)
+    assert gegenbauer(3, a, x) == \
+        x**3*(4*a**3/3 + 4*a**2 + a*Rational(8, 3)) + x*(-2*a**2 - 2*a)
+
+    assert gegenbauer(-1, a, x) == 0
+    assert gegenbauer(n, S.Half, x) == legendre(n, x)
+    assert gegenbauer(n, 1, x) == chebyshevu(n, x)
+    assert gegenbauer(n, -1, x) == 0
+
+    X = gegenbauer(n, a, x)
+    assert isinstance(X, gegenbauer)
+
+    assert gegenbauer(n, a, -x) == (-1)**n*gegenbauer(n, a, x)
+    assert gegenbauer(n, a, 0) == 2**n*sqrt(pi) * \
+        gamma(a + n/2)/(gamma(a)*gamma(-n/2 + S.Half)*gamma(n + 1))
+    assert gegenbauer(n, a, 1) == gamma(2*a + n)/(gamma(2*a)*gamma(n + 1))
+
+    assert gegenbauer(n, Rational(3, 4), -1) is zoo
+    assert gegenbauer(n, Rational(1, 4), -1) == (sqrt(2)*cos(pi*(n + S.One/4))*
+                      gamma(n + S.Half)/(sqrt(pi)*gamma(n + 1)))
+
+    m = Symbol("m", positive=True)
+    assert gegenbauer(m, a, oo) == oo*RisingFactorial(a, m)
+    assert unchanged(gegenbauer, n, a, oo)
+
+    assert conjugate(gegenbauer(n, a, x)) == gegenbauer(n, conjugate(a), conjugate(x))
+
+    _k = Dummy('k')
+
+    assert diff(gegenbauer(n, a, x), n) == Derivative(gegenbauer(n, a, x), n)
+    assert diff(gegenbauer(n, a, x), a).dummy_eq(Sum((2*(-1)**(-_k + n) + 2)*
+        (_k + a)*gegenbauer(_k, a, x)/((-_k + n)*(_k + 2*a + n)) + ((2*_k +
+        2)/((_k + 2*a)*(2*_k + 2*a + 1)) + 2/(_k + 2*a + n))*gegenbauer(n, a
+        , x), (_k, 0, n - 1)))
+    assert diff(gegenbauer(n, a, x), x) == 2*a*gegenbauer(n - 1, a + 1, x)
+
+    assert gegenbauer(n, a, x).rewrite(Sum).dummy_eq(
+        Sum((-1)**_k*(2*x)**(-2*_k + n)*RisingFactorial(a, -_k + n)
+        /(factorial(_k)*factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    assert gegenbauer(n, a, x).rewrite("polynomial").dummy_eq(
+        Sum((-1)**_k*(2*x)**(-2*_k + n)*RisingFactorial(a, -_k + n)
+        /(factorial(_k)*factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+
+    raises(ArgumentIndexError, lambda: gegenbauer(n, a, x).fdiff(4))
+
+
+def test_legendre():
+    assert legendre(0, x) == 1
+    assert legendre(1, x) == x
+    assert legendre(2, x) == ((3*x**2 - 1)/2).expand()
+    assert legendre(3, x) == ((5*x**3 - 3*x)/2).expand()
+    assert legendre(4, x) == ((35*x**4 - 30*x**2 + 3)/8).expand()
+    assert legendre(5, x) == ((63*x**5 - 70*x**3 + 15*x)/8).expand()
+    assert legendre(6, x) == ((231*x**6 - 315*x**4 + 105*x**2 - 5)/16).expand()
+
+    assert legendre(10, -1) == 1
+    assert legendre(11, -1) == -1
+    assert legendre(10, 1) == 1
+    assert legendre(11, 1) == 1
+    assert legendre(10, 0) != 0
+    assert legendre(11, 0) == 0
+
+    assert legendre(-1, x) == 1
+    k = Symbol('k')
+    assert legendre(5 - k, x).subs(k, 2) == ((5*x**3 - 3*x)/2).expand()
+
+    assert roots(legendre(4, x), x) == {
+        sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
+        -sqrt(Rational(3, 7) - Rational(2, 35)*sqrt(30)): 1,
+        sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
+        -sqrt(Rational(3, 7) + Rational(2, 35)*sqrt(30)): 1,
+    }
+
+    n = Symbol("n")
+
+    X = legendre(n, x)
+    assert isinstance(X, legendre)
+    assert unchanged(legendre, n, x)
+
+    assert legendre(n, 0) == sqrt(pi)/(gamma(S.Half - n/2)*gamma(n/2 + 1))
+    assert legendre(n, 1) == 1
+    assert legendre(n, oo) is oo
+    assert legendre(-n, x) == legendre(n - 1, x)
+    assert legendre(n, -x) == (-1)**n*legendre(n, x)
+    assert unchanged(legendre, -n + k, x)
+
+    assert conjugate(legendre(n, x)) == legendre(n, conjugate(x))
+
+    assert diff(legendre(n, x), x) == \
+        n*(x*legendre(n, x) - legendre(n - 1, x))/(x**2 - 1)
+    assert diff(legendre(n, x), n) == Derivative(legendre(n, x), n)
+
+    _k = Dummy('k')
+    assert legendre(n, x).rewrite(Sum).dummy_eq(Sum((-1)**_k*(S.Half -
+            x/2)**_k*(x/2 + S.Half)**(-_k + n)*binomial(n, _k)**2, (_k, 0, n)))
+    assert legendre(n, x).rewrite("polynomial").dummy_eq(Sum((-1)**_k*(S.Half -
+            x/2)**_k*(x/2 + S.Half)**(-_k + n)*binomial(n, _k)**2, (_k, 0, n)))
+    raises(ArgumentIndexError, lambda: legendre(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: legendre(n, x).fdiff(3))
+
+
+def test_assoc_legendre():
+    Plm = assoc_legendre
+    Q = sqrt(1 - x**2)
+
+    assert Plm(0, 0, x) == 1
+    assert Plm(1, 0, x) == x
+    assert Plm(1, 1, x) == -Q
+    assert Plm(2, 0, x) == (3*x**2 - 1)/2
+    assert Plm(2, 1, x) == -3*x*Q
+    assert Plm(2, 2, x) == 3*Q**2
+    assert Plm(3, 0, x) == (5*x**3 - 3*x)/2
+    assert Plm(3, 1, x).expand() == (( 3*(1 - 5*x**2)/2 ).expand() * Q).expand()
+    assert Plm(3, 2, x) == 15*x * Q**2
+    assert Plm(3, 3, x) == -15 * Q**3
+
+    # negative m
+    assert Plm(1, -1, x) == -Plm(1, 1, x)/2
+    assert Plm(2, -2, x) == Plm(2, 2, x)/24
+    assert Plm(2, -1, x) == -Plm(2, 1, x)/6
+    assert Plm(3, -3, x) == -Plm(3, 3, x)/720
+    assert Plm(3, -2, x) == Plm(3, 2, x)/120
+    assert Plm(3, -1, x) == -Plm(3, 1, x)/12
+
+    n = Symbol("n")
+    m = Symbol("m")
+    X = Plm(n, m, x)
+    assert isinstance(X, assoc_legendre)
+
+    assert Plm(n, 0, x) == legendre(n, x)
+    assert Plm(n, m, 0) == 2**m*sqrt(pi)/(gamma(-m/2 - n/2 +
+                           S.Half)*gamma(-m/2 + n/2 + 1))
+
+    assert diff(Plm(m, n, x), x) == (m*x*assoc_legendre(m, n, x) -
+                (m + n)*assoc_legendre(m - 1, n, x))/(x**2 - 1)
+
+    _k = Dummy('k')
+    assert Plm(m, n, x).rewrite(Sum).dummy_eq(
+            (1 - x**2)**(n/2)*Sum((-1)**_k*2**(-m)*x**(-2*_k + m - n)*factorial
+             (-2*_k + 2*m)/(factorial(_k)*factorial(-_k + m)*factorial(-2*_k + m
+              - n)), (_k, 0, floor(m/2 - n/2))))
+    assert Plm(m, n, x).rewrite("polynomial").dummy_eq(
+            (1 - x**2)**(n/2)*Sum((-1)**_k*2**(-m)*x**(-2*_k + m - n)*factorial
+             (-2*_k + 2*m)/(factorial(_k)*factorial(-_k + m)*factorial(-2*_k + m
+              - n)), (_k, 0, floor(m/2 - n/2))))
+    assert conjugate(assoc_legendre(n, m, x)) == \
+        assoc_legendre(n, conjugate(m), conjugate(x))
+    raises(ValueError, lambda: Plm(0, 1, x))
+    raises(ValueError, lambda: Plm(-1, 1, x))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(2))
+    raises(ArgumentIndexError, lambda: Plm(n, m, x).fdiff(4))
+
+
+def test_chebyshev():
+    assert chebyshevt(0, x) == 1
+    assert chebyshevt(1, x) == x
+    assert chebyshevt(2, x) == 2*x**2 - 1
+    assert chebyshevt(3, x) == 4*x**3 - 3*x
+
+    for n in range(1, 4):
+        for k in range(n):
+            z = chebyshevt_root(n, k)
+            assert chebyshevt(n, z) == 0
+        raises(ValueError, lambda: chebyshevt_root(n, n))
+
+    for n in range(1, 4):
+        for k in range(n):
+            z = chebyshevu_root(n, k)
+            assert chebyshevu(n, z) == 0
+        raises(ValueError, lambda: chebyshevu_root(n, n))
+
+    n = Symbol("n")
+    X = chebyshevt(n, x)
+    assert isinstance(X, chebyshevt)
+    assert unchanged(chebyshevt, n, x)
+    assert chebyshevt(n, -x) == (-1)**n*chebyshevt(n, x)
+    assert chebyshevt(-n, x) == chebyshevt(n, x)
+
+    assert chebyshevt(n, 0) == cos(pi*n/2)
+    assert chebyshevt(n, 1) == 1
+    assert chebyshevt(n, oo) is oo
+
+    assert conjugate(chebyshevt(n, x)) == chebyshevt(n, conjugate(x))
+
+    assert diff(chebyshevt(n, x), x) == n*chebyshevu(n - 1, x)
+
+    X = chebyshevu(n, x)
+    assert isinstance(X, chebyshevu)
+
+    y = Symbol('y')
+    assert chebyshevu(n, -x) == (-1)**n*chebyshevu(n, x)
+    assert chebyshevu(-n, x) == -chebyshevu(n - 2, x)
+    assert unchanged(chebyshevu, -n + y, x)
+
+    assert chebyshevu(n, 0) == cos(pi*n/2)
+    assert chebyshevu(n, 1) == n + 1
+    assert chebyshevu(n, oo) is oo
+
+    assert conjugate(chebyshevu(n, x)) == chebyshevu(n, conjugate(x))
+
+    assert diff(chebyshevu(n, x), x) == \
+        (-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
+
+    _k = Dummy('k')
+    assert chebyshevt(n, x).rewrite(Sum).dummy_eq(Sum(x**(-2*_k + n)
+                    *(x**2 - 1)**_k*binomial(n, 2*_k), (_k, 0, floor(n/2))))
+    assert chebyshevt(n, x).rewrite("polynomial").dummy_eq(Sum(x**(-2*_k + n)
+                    *(x**2 - 1)**_k*binomial(n, 2*_k), (_k, 0, floor(n/2))))
+    assert chebyshevu(n, x).rewrite(Sum).dummy_eq(Sum((-1)**_k*(2*x)
+                    **(-2*_k + n)*factorial(-_k + n)/(factorial(_k)*
+                       factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    assert chebyshevu(n, x).rewrite("polynomial").dummy_eq(Sum((-1)**_k*(2*x)
+                    **(-2*_k + n)*factorial(-_k + n)/(factorial(_k)*
+                       factorial(-2*_k + n)), (_k, 0, floor(n/2))))
+    raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(3))
+    raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(3))
+
+
+def test_hermite():
+    assert hermite(0, x) == 1
+    assert hermite(1, x) == 2*x
+    assert hermite(2, x) == 4*x**2 - 2
+    assert hermite(3, x) == 8*x**3 - 12*x
+    assert hermite(4, x) == 16*x**4 - 48*x**2 + 12
+    assert hermite(6, x) == 64*x**6 - 480*x**4 + 720*x**2 - 120
+
+    n = Symbol("n")
+    assert unchanged(hermite, n, x)
+    assert hermite(n, -x) == (-1)**n*hermite(n, x)
+    assert unchanged(hermite, -n, x)
+
+    assert hermite(n, 0) == 2**n*sqrt(pi)/gamma(S.Half - n/2)
+    assert hermite(n, oo) is oo
+
+    assert conjugate(hermite(n, x)) == hermite(n, conjugate(x))
+
+    _k = Dummy('k')
+    assert hermite(n, x).rewrite(Sum).dummy_eq(factorial(n)*Sum((-1)
+        **_k*(2*x)**(-2*_k + n)/(factorial(_k)*factorial(-2*_k + n)), (_k,
+        0, floor(n/2))))
+    assert hermite(n, x).rewrite("polynomial").dummy_eq(factorial(n)*Sum((-1)
+        **_k*(2*x)**(-2*_k + n)/(factorial(_k)*factorial(-2*_k + n)), (_k,
+        0, floor(n/2))))
+
+    assert diff(hermite(n, x), x) == 2*n*hermite(n - 1, x)
+    assert diff(hermite(n, x), n) == Derivative(hermite(n, x), n)
+    raises(ArgumentIndexError, lambda: hermite(n, x).fdiff(3))
+
+    assert hermite(n, x).rewrite(hermite_prob) == \
+            sqrt(2)**n * hermite_prob(n, x*sqrt(2))
+
+
+def test_hermite_prob():
+    assert hermite_prob(0, x) == 1
+    assert hermite_prob(1, x) == x
+    assert hermite_prob(2, x) == x**2 - 1
+    assert hermite_prob(3, x) == x**3 - 3*x
+    assert hermite_prob(4, x) == x**4 - 6*x**2 + 3
+    assert hermite_prob(6, x) == x**6 - 15*x**4 + 45*x**2 - 15
+
+    n = Symbol("n")
+    assert unchanged(hermite_prob, n, x)
+    assert hermite_prob(n, -x) == (-1)**n*hermite_prob(n, x)
+    assert unchanged(hermite_prob, -n, x)
+
+    assert hermite_prob(n, 0) == sqrt(pi)/gamma(S.Half - n/2)
+    assert hermite_prob(n, oo) is oo
+
+    assert conjugate(hermite_prob(n, x)) == hermite_prob(n, conjugate(x))
+
+    _k = Dummy('k')
+    assert hermite_prob(n, x).rewrite(Sum).dummy_eq(factorial(n) *
+        Sum((-S.Half)**_k * x**(n-2*_k) / (factorial(_k) * factorial(n-2*_k)),
+        (_k, 0, floor(n/2))))
+    assert hermite_prob(n, x).rewrite("polynomial").dummy_eq(factorial(n) *
+        Sum((-S.Half)**_k * x**(n-2*_k) / (factorial(_k) * factorial(n-2*_k)),
+        (_k, 0, floor(n/2))))
+
+    assert diff(hermite_prob(n, x), x) == n*hermite_prob(n-1, x)
+    assert diff(hermite_prob(n, x), n) == Derivative(hermite_prob(n, x), n)
+    raises(ArgumentIndexError, lambda: hermite_prob(n, x).fdiff(3))
+
+    assert hermite_prob(n, x).rewrite(hermite) == \
+            sqrt(2)**(-n) * hermite(n, x/sqrt(2))
+
+
+def test_laguerre():
+    n = Symbol("n")
+    m = Symbol("m", negative=True)
+
+    # Laguerre polynomials:
+    assert laguerre(0, x) == 1
+    assert laguerre(1, x) == -x + 1
+    assert laguerre(2, x) == x**2/2 - 2*x + 1
+    assert laguerre(3, x) == -x**3/6 + 3*x**2/2 - 3*x + 1
+    assert laguerre(-2, x) == (x + 1)*exp(x)
+
+    X = laguerre(n, x)
+    assert isinstance(X, laguerre)
+
+    assert laguerre(n, 0) == 1
+    assert laguerre(n, oo) == (-1)**n*oo
+    assert laguerre(n, -oo) is oo
+
+    assert conjugate(laguerre(n, x)) == laguerre(n, conjugate(x))
+
+    _k = Dummy('k')
+
+    assert laguerre(n, x).rewrite(Sum).dummy_eq(
+        Sum(x**_k*RisingFactorial(-n, _k)/factorial(_k)**2, (_k, 0, n)))
+    assert laguerre(n, x).rewrite("polynomial").dummy_eq(
+        Sum(x**_k*RisingFactorial(-n, _k)/factorial(_k)**2, (_k, 0, n)))
+    assert laguerre(m, x).rewrite(Sum).dummy_eq(
+        exp(x)*Sum((-x)**_k*RisingFactorial(m + 1, _k)/factorial(_k)**2,
+            (_k, 0, -m - 1)))
+    assert laguerre(m, x).rewrite("polynomial").dummy_eq(
+        exp(x)*Sum((-x)**_k*RisingFactorial(m + 1, _k)/factorial(_k)**2,
+            (_k, 0, -m - 1)))
+
+    assert diff(laguerre(n, x), x) == -assoc_laguerre(n - 1, 1, x)
+
+    k = Symbol('k')
+    assert laguerre(-n, x) == exp(x)*laguerre(n - 1, -x)
+    assert laguerre(-3, x) == exp(x)*laguerre(2, -x)
+    assert unchanged(laguerre, -n + k, x)
+
+    raises(ValueError, lambda: laguerre(-2.1, x))
+    raises(ValueError, lambda: laguerre(Rational(5, 2), x))
+    raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: laguerre(n, x).fdiff(3))
+
+
+def test_assoc_laguerre():
+    n = Symbol("n")
+    m = Symbol("m")
+    alpha = Symbol("alpha")
+
+    # generalized Laguerre polynomials:
+    assert assoc_laguerre(0, alpha, x) == 1
+    assert assoc_laguerre(1, alpha, x) == -x + alpha + 1
+    assert assoc_laguerre(2, alpha, x).expand() == \
+        (x**2/2 - (alpha + 2)*x + (alpha + 2)*(alpha + 1)/2).expand()
+    assert assoc_laguerre(3, alpha, x).expand() == \
+        (-x**3/6 + (alpha + 3)*x**2/2 - (alpha + 2)*(alpha + 3)*x/2 +
+        (alpha + 1)*(alpha + 2)*(alpha + 3)/6).expand()
+
+    # Test the lowest 10 polynomials with laguerre_poly, to make sure it works:
+    for i in range(10):
+        assert assoc_laguerre(i, 0, x).expand() == laguerre_poly(i, x)
+
+    X = assoc_laguerre(n, m, x)
+    assert isinstance(X, assoc_laguerre)
+
+    assert assoc_laguerre(n, 0, x) == laguerre(n, x)
+    assert assoc_laguerre(n, alpha, 0) == binomial(alpha + n, alpha)
+    p = Symbol("p", positive=True)
+    assert assoc_laguerre(p, alpha, oo) == (-1)**p*oo
+    assert assoc_laguerre(p, alpha, -oo) is oo
+
+    assert diff(assoc_laguerre(n, alpha, x), x) == \
+        -assoc_laguerre(n - 1, alpha + 1, x)
+    _k = Dummy('k')
+    assert diff(assoc_laguerre(n, alpha, x), alpha).dummy_eq(
+        Sum(assoc_laguerre(_k, alpha, x)/(-alpha + n), (_k, 0, n - 1)))
+
+    assert conjugate(assoc_laguerre(n, alpha, x)) == \
+        assoc_laguerre(n, conjugate(alpha), conjugate(x))
+
+    assert assoc_laguerre(n, alpha, x).rewrite(Sum).dummy_eq(
+            gamma(alpha + n + 1)*Sum(x**_k*RisingFactorial(-n, _k)/
+            (factorial(_k)*gamma(_k + alpha + 1)), (_k, 0, n))/factorial(n))
+    assert assoc_laguerre(n, alpha, x).rewrite("polynomial").dummy_eq(
+            gamma(alpha + n + 1)*Sum(x**_k*RisingFactorial(-n, _k)/
+            (factorial(_k)*gamma(_k + alpha + 1)), (_k, 0, n))/factorial(n))
+    raises(ValueError, lambda: assoc_laguerre(-2.1, alpha, x))
+    raises(ArgumentIndexError, lambda: assoc_laguerre(n, alpha, x).fdiff(1))
+    raises(ArgumentIndexError, lambda: assoc_laguerre(n, alpha, x).fdiff(4))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spherical_harmonics.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spherical_harmonics.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e0d4ffebabb62c13d3fc2996e8ba23866467720
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_spherical_harmonics.py
@@ -0,0 +1,66 @@
+from sympy.core.function import diff
+from sympy.core.numbers import (I, pi)
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import conjugate
+from sympy.functions.elementary.exponential import exp
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (cos, cot, sin)
+from sympy.functions.special.spherical_harmonics import Ynm, Znm, Ynm_c
+
+
+def test_Ynm():
+    # https://en.wikipedia.org/wiki/Spherical_harmonics
+    th, ph = Symbol("theta", real=True), Symbol("phi", real=True)
+    from sympy.abc import n,m
+
+    assert Ynm(0, 0, th, ph).expand(func=True) == 1/(2*sqrt(pi))
+    assert Ynm(1, -1, th, ph) == -exp(-2*I*ph)*Ynm(1, 1, th, ph)
+    assert Ynm(1, -1, th, ph).expand(func=True) == sqrt(6)*sin(th)*exp(-I*ph)/(4*sqrt(pi))
+    assert Ynm(1, 0, th, ph).expand(func=True) == sqrt(3)*cos(th)/(2*sqrt(pi))
+    assert Ynm(1, 1, th, ph).expand(func=True) == -sqrt(6)*sin(th)*exp(I*ph)/(4*sqrt(pi))
+    assert Ynm(2, 0, th, ph).expand(func=True) == 3*sqrt(5)*cos(th)**2/(4*sqrt(pi)) - sqrt(5)/(4*sqrt(pi))
+    assert Ynm(2, 1, th, ph).expand(func=True) == -sqrt(30)*sin(th)*exp(I*ph)*cos(th)/(4*sqrt(pi))
+    assert Ynm(2, -2, th, ph).expand(func=True) == (-sqrt(30)*exp(-2*I*ph)*cos(th)**2/(8*sqrt(pi))
+                                                    + sqrt(30)*exp(-2*I*ph)/(8*sqrt(pi)))
+    assert Ynm(2, 2, th, ph).expand(func=True) == (-sqrt(30)*exp(2*I*ph)*cos(th)**2/(8*sqrt(pi))
+                                                   + sqrt(30)*exp(2*I*ph)/(8*sqrt(pi)))
+
+    assert diff(Ynm(n, m, th, ph), th) == (m*cot(th)*Ynm(n, m, th, ph)
+                                           + sqrt((-m + n)*(m + n + 1))*exp(-I*ph)*Ynm(n, m + 1, th, ph))
+    assert diff(Ynm(n, m, th, ph), ph) == I*m*Ynm(n, m, th, ph)
+
+    assert conjugate(Ynm(n, m, th, ph)) == (-1)**(2*m)*exp(-2*I*m*ph)*Ynm(n, m, th, ph)
+
+    assert Ynm(n, m, -th, ph) == Ynm(n, m, th, ph)
+    assert Ynm(n, m, th, -ph) == exp(-2*I*m*ph)*Ynm(n, m, th, ph)
+    assert Ynm(n, -m, th, ph) == (-1)**m*exp(-2*I*m*ph)*Ynm(n, m, th, ph)
+
+
+def test_Ynm_c():
+    th, ph = Symbol("theta", real=True), Symbol("phi", real=True)
+    from sympy.abc import n,m
+
+    assert Ynm_c(n, m, th, ph) == (-1)**(2*m)*exp(-2*I*m*ph)*Ynm(n, m, th, ph)
+
+
+def test_Znm():
+    # https://en.wikipedia.org/wiki/Solid_harmonics#List_of_lowest_functions
+    th, ph = Symbol("theta", real=True), Symbol("phi", real=True)
+
+    assert Znm(0, 0, th, ph) == Ynm(0, 0, th, ph)
+    assert Znm(1, -1, th, ph) == (-sqrt(2)*I*(Ynm(1, 1, th, ph)
+                                  - exp(-2*I*ph)*Ynm(1, 1, th, ph))/2)
+    assert Znm(1, 0, th, ph) == Ynm(1, 0, th, ph)
+    assert Znm(1, 1, th, ph) == (sqrt(2)*(Ynm(1, 1, th, ph)
+                                 + exp(-2*I*ph)*Ynm(1, 1, th, ph))/2)
+    assert Znm(0, 0, th, ph).expand(func=True) == 1/(2*sqrt(pi))
+    assert Znm(1, -1, th, ph).expand(func=True) == (sqrt(3)*I*sin(th)*exp(I*ph)/(4*sqrt(pi))
+                                                    - sqrt(3)*I*sin(th)*exp(-I*ph)/(4*sqrt(pi)))
+    assert Znm(1, 0, th, ph).expand(func=True) == sqrt(3)*cos(th)/(2*sqrt(pi))
+    assert Znm(1, 1, th, ph).expand(func=True) == (-sqrt(3)*sin(th)*exp(I*ph)/(4*sqrt(pi))
+                                                   - sqrt(3)*sin(th)*exp(-I*ph)/(4*sqrt(pi)))
+    assert Znm(2, -1, th, ph).expand(func=True) == (sqrt(15)*I*sin(th)*exp(I*ph)*cos(th)/(4*sqrt(pi))
+                                                    - sqrt(15)*I*sin(th)*exp(-I*ph)*cos(th)/(4*sqrt(pi)))
+    assert Znm(2, 0, th, ph).expand(func=True) == 3*sqrt(5)*cos(th)**2/(4*sqrt(pi)) - sqrt(5)/(4*sqrt(pi))
+    assert Znm(2, 1, th, ph).expand(func=True) == (-sqrt(15)*sin(th)*exp(I*ph)*cos(th)/(4*sqrt(pi))
+                                                   - sqrt(15)*sin(th)*exp(-I*ph)*cos(th)/(4*sqrt(pi)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_tensor_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_tensor_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d4f31c45ae0a60a6f72dc5551794b2110f5ab99
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_tensor_functions.py
@@ -0,0 +1,145 @@
+from sympy.core.relational import Ne
+from sympy.core.symbol import (Dummy, Symbol, symbols)
+from sympy.functions.elementary.complexes import (adjoint, conjugate, transpose)
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.special.tensor_functions import (Eijk, KroneckerDelta, LeviCivita)
+
+from sympy.physics.secondquant import evaluate_deltas, F
+
+x, y = symbols('x y')
+
+
+def test_levicivita():
+    assert Eijk(1, 2, 3) == LeviCivita(1, 2, 3)
+    assert LeviCivita(1, 2, 3) == 1
+    assert LeviCivita(int(1), int(2), int(3)) == 1
+    assert LeviCivita(1, 3, 2) == -1
+    assert LeviCivita(1, 2, 2) == 0
+    i, j, k = symbols('i j k')
+    assert LeviCivita(i, j, k) == LeviCivita(i, j, k, evaluate=False)
+    assert LeviCivita(i, j, i) == 0
+    assert LeviCivita(1, i, i) == 0
+    assert LeviCivita(i, j, k).doit() == (j - i)*(k - i)*(k - j)/2
+    assert LeviCivita(1, 2, 3, 1) == 0
+    assert LeviCivita(4, 5, 1, 2, 3) == 1
+    assert LeviCivita(4, 5, 2, 1, 3) == -1
+
+    assert LeviCivita(i, j, k).is_integer is True
+
+    assert adjoint(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
+    assert conjugate(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
+    assert transpose(LeviCivita(i, j, k)) == LeviCivita(i, j, k)
+
+
+def test_kronecker_delta():
+    i, j = symbols('i j')
+    k = Symbol('k', nonzero=True)
+    assert KroneckerDelta(1, 1) == 1
+    assert KroneckerDelta(1, 2) == 0
+    assert KroneckerDelta(k, 0) == 0
+    assert KroneckerDelta(x, x) == 1
+    assert KroneckerDelta(x**2 - y**2, x**2 - y**2) == 1
+    assert KroneckerDelta(i, i) == 1
+    assert KroneckerDelta(i, i + 1) == 0
+    assert KroneckerDelta(0, 0) == 1
+    assert KroneckerDelta(0, 1) == 0
+    assert KroneckerDelta(i + k, i) == 0
+    assert KroneckerDelta(i + k, i + k) == 1
+    assert KroneckerDelta(i + k, i + 1 + k) == 0
+    assert KroneckerDelta(i, j).subs({"i": 1, "j": 0}) == 0
+    assert KroneckerDelta(i, j).subs({"i": 3, "j": 3}) == 1
+
+    assert KroneckerDelta(i, j)**0 == 1
+    for n in range(1, 10):
+        assert KroneckerDelta(i, j)**n == KroneckerDelta(i, j)
+        assert KroneckerDelta(i, j)**-n == 1/KroneckerDelta(i, j)
+
+    assert KroneckerDelta(i, j).is_integer is True
+
+    assert adjoint(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
+    assert conjugate(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
+    assert transpose(KroneckerDelta(i, j)) == KroneckerDelta(i, j)
+    # to test if canonical
+    assert (KroneckerDelta(i, j) == KroneckerDelta(j, i)) == True
+
+    assert KroneckerDelta(i, j).rewrite(Piecewise) == Piecewise((0, Ne(i, j)), (1, True))
+
+    # Tests with range:
+    assert KroneckerDelta(i, j, (0, i)).args == (i, j, (0, i))
+    assert KroneckerDelta(i, j, (-j, i)).delta_range == (-j, i)
+
+    # If index is out of range, return zero:
+    assert KroneckerDelta(i, j, (0, i-1)) == 0
+    assert KroneckerDelta(-1, j, (0, i-1)) == 0
+    assert KroneckerDelta(j, -1, (0, i-1)) == 0
+    assert KroneckerDelta(j, i, (0, i-1)) == 0
+
+
+def test_kronecker_delta_secondquant():
+    """secondquant-specific methods"""
+    D = KroneckerDelta
+    i, j, v, w = symbols('i j v w', below_fermi=True, cls=Dummy)
+    a, b, t, u = symbols('a b t u', above_fermi=True, cls=Dummy)
+    p, q, r, s = symbols('p q r s', cls=Dummy)
+
+    assert D(i, a) == 0
+    assert D(i, t) == 0
+
+    assert D(i, j).is_above_fermi is False
+    assert D(a, b).is_above_fermi is True
+    assert D(p, q).is_above_fermi is True
+    assert D(i, q).is_above_fermi is False
+    assert D(q, i).is_above_fermi is False
+    assert D(q, v).is_above_fermi is False
+    assert D(a, q).is_above_fermi is True
+
+    assert D(i, j).is_below_fermi is True
+    assert D(a, b).is_below_fermi is False
+    assert D(p, q).is_below_fermi is True
+    assert D(p, j).is_below_fermi is True
+    assert D(q, b).is_below_fermi is False
+
+    assert D(i, j).is_only_above_fermi is False
+    assert D(a, b).is_only_above_fermi is True
+    assert D(p, q).is_only_above_fermi is False
+    assert D(i, q).is_only_above_fermi is False
+    assert D(q, i).is_only_above_fermi is False
+    assert D(a, q).is_only_above_fermi is True
+
+    assert D(i, j).is_only_below_fermi is True
+    assert D(a, b).is_only_below_fermi is False
+    assert D(p, q).is_only_below_fermi is False
+    assert D(p, j).is_only_below_fermi is True
+    assert D(q, b).is_only_below_fermi is False
+
+    assert not D(i, q).indices_contain_equal_information
+    assert not D(a, q).indices_contain_equal_information
+    assert D(p, q).indices_contain_equal_information
+    assert D(a, b).indices_contain_equal_information
+    assert D(i, j).indices_contain_equal_information
+
+    assert D(q, b).preferred_index == b
+    assert D(q, b).killable_index == q
+    assert D(q, t).preferred_index == t
+    assert D(q, t).killable_index == q
+    assert D(q, i).preferred_index == i
+    assert D(q, i).killable_index == q
+    assert D(q, v).preferred_index == v
+    assert D(q, v).killable_index == q
+    assert D(q, p).preferred_index == p
+    assert D(q, p).killable_index == q
+
+    EV = evaluate_deltas
+    assert EV(D(a, q)*F(q)) == F(a)
+    assert EV(D(i, q)*F(q)) == F(i)
+    assert EV(D(a, q)*F(a)) == D(a, q)*F(a)
+    assert EV(D(i, q)*F(i)) == D(i, q)*F(i)
+    assert EV(D(a, b)*F(a)) == F(b)
+    assert EV(D(a, b)*F(b)) == F(a)
+    assert EV(D(i, j)*F(i)) == F(j)
+    assert EV(D(i, j)*F(j)) == F(i)
+    assert EV(D(p, q)*F(q)) == F(p)
+    assert EV(D(p, q)*F(p)) == F(q)
+    assert EV(D(p, j)*D(p, i)*F(i)) == F(j)
+    assert EV(D(p, j)*D(p, i)*F(j)) == F(i)
+    assert EV(D(p, q)*D(p, i))*F(i) == D(q, i)*F(i)
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_zeta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_zeta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2083b0b6e8cb38fde17fb1ede2a34be6338b1dc
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/tests/test_zeta_functions.py
@@ -0,0 +1,286 @@
+from sympy.concrete.summations import Sum
+from sympy.core.function import expand_func
+from sympy.core.numbers import (Float, I, Rational, nan, oo, pi, zoo)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions.elementary.complexes import (Abs, polar_lift)
+from sympy.functions.elementary.exponential import (exp, exp_polar, log)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.special.zeta_functions import (dirichlet_eta, lerchphi, polylog, riemann_xi, stieltjes, zeta)
+from sympy.series.order import O
+from sympy.core.function import ArgumentIndexError
+from sympy.functions.combinatorial.numbers import bernoulli, factorial, genocchi, harmonic
+from sympy.testing.pytest import raises
+from sympy.core.random import (test_derivative_numerically as td,
+                      random_complex_number as randcplx, verify_numerically)
+
+x = Symbol('x')
+a = Symbol('a')
+b = Symbol('b', negative=True)
+z = Symbol('z')
+s = Symbol('s')
+
+
+def test_zeta_eval():
+
+    assert zeta(nan) is nan
+    assert zeta(x, nan) is nan
+
+    assert zeta(0) == Rational(-1, 2)
+    assert zeta(0, x) == S.Half - x
+    assert zeta(0, b) == S.Half - b
+
+    assert zeta(1) is zoo
+    assert zeta(1, 2) is zoo
+    assert zeta(1, -7) is zoo
+    assert zeta(1, x) is zoo
+
+    assert zeta(2, 1) == pi**2/6
+    assert zeta(3, 1) == zeta(3)
+
+    assert zeta(2) == pi**2/6
+    assert zeta(4) == pi**4/90
+    assert zeta(6) == pi**6/945
+
+    assert zeta(4, 3) == pi**4/90 - Rational(17, 16)
+    assert zeta(7, 4) == zeta(7) - Rational(282251, 279936)
+    assert zeta(S.Half, 2).func == zeta
+    assert expand_func(zeta(S.Half, 2)) == zeta(S.Half) - 1
+    assert zeta(x, 3).func == zeta
+    assert expand_func(zeta(x, 3)) == zeta(x) - 1 - 1/2**x
+
+    assert zeta(2, 0) is nan
+    assert zeta(3, -1) is nan
+    assert zeta(4, -2) is nan
+
+    assert zeta(oo) == 1
+
+    assert zeta(-1) == Rational(-1, 12)
+    assert zeta(-2) == 0
+    assert zeta(-3) == Rational(1, 120)
+    assert zeta(-4) == 0
+    assert zeta(-5) == Rational(-1, 252)
+
+    assert zeta(-1, 3) == Rational(-37, 12)
+    assert zeta(-1, 7) == Rational(-253, 12)
+    assert zeta(-1, -4) == Rational(-121, 12)
+    assert zeta(-1, -9) == Rational(-541, 12)
+
+    assert zeta(-4, 3) == -17
+    assert zeta(-4, -8) == 8772
+
+    assert zeta(0, 1) == Rational(-1, 2)
+    assert zeta(0, -1) == Rational(3, 2)
+
+    assert zeta(0, 2) == Rational(-3, 2)
+    assert zeta(0, -2) == Rational(5, 2)
+
+    assert zeta(
+        3).evalf(20).epsilon_eq(Float("1.2020569031595942854", 20), 1e-19)
+
+
+def test_zeta_series():
+    assert zeta(x, a).series(a, z, 2) == \
+        zeta(x, z) - x*(a-z)*zeta(x+1, z) + O((a-z)**2, (a, z))
+
+
+def test_dirichlet_eta_eval():
+    assert dirichlet_eta(0) == S.Half
+    assert dirichlet_eta(-1) == Rational(1, 4)
+    assert dirichlet_eta(1) == log(2)
+    assert dirichlet_eta(1, S.Half).simplify() == pi/2
+    assert dirichlet_eta(1, 2) == 1 - log(2)
+    assert dirichlet_eta(2) == pi**2/12
+    assert dirichlet_eta(4) == pi**4*Rational(7, 720)
+    assert str(dirichlet_eta(I).evalf(n=10)) == '0.5325931818 + 0.2293848577*I'
+    assert str(dirichlet_eta(I, I).evalf(n=10)) == '3.462349253 + 0.220285771*I'
+
+
+def test_riemann_xi_eval():
+    assert riemann_xi(2) == pi/6
+    assert riemann_xi(0) == Rational(1, 2)
+    assert riemann_xi(1) == Rational(1, 2)
+    assert riemann_xi(3).rewrite(zeta) == 3*zeta(3)/(2*pi)
+    assert riemann_xi(4) == pi**2/15
+
+
+def test_rewriting():
+    from sympy.functions.elementary.piecewise import Piecewise
+    assert isinstance(dirichlet_eta(x).rewrite(zeta), Piecewise)
+    assert isinstance(dirichlet_eta(x).rewrite(genocchi), Piecewise)
+    assert zeta(x).rewrite(dirichlet_eta) == dirichlet_eta(x)/(1 - 2**(1 - x))
+    assert zeta(x).rewrite(dirichlet_eta, a=2) == zeta(x)
+    assert verify_numerically(dirichlet_eta(x), dirichlet_eta(x).rewrite(zeta), x)
+    assert verify_numerically(dirichlet_eta(x), dirichlet_eta(x).rewrite(genocchi), x)
+    assert verify_numerically(zeta(x), zeta(x).rewrite(dirichlet_eta), x)
+
+    assert zeta(x, a).rewrite(lerchphi) == lerchphi(1, x, a)
+    assert polylog(s, z).rewrite(lerchphi) == lerchphi(z, s, 1)*z
+
+    assert lerchphi(1, x, a).rewrite(zeta) == zeta(x, a)
+    assert z*lerchphi(z, s, 1).rewrite(polylog) == polylog(s, z)
+
+
+def test_derivatives():
+    from sympy.core.function import Derivative
+    assert zeta(x, a).diff(x) == Derivative(zeta(x, a), x)
+    assert zeta(x, a).diff(a) == -x*zeta(x + 1, a)
+    assert lerchphi(
+        z, s, a).diff(z) == (lerchphi(z, s - 1, a) - a*lerchphi(z, s, a))/z
+    assert lerchphi(z, s, a).diff(a) == -s*lerchphi(z, s + 1, a)
+    assert polylog(s, z).diff(z) == polylog(s - 1, z)/z
+
+    b = randcplx()
+    c = randcplx()
+    assert td(zeta(b, x), x)
+    assert td(polylog(b, z), z)
+    assert td(lerchphi(c, b, x), x)
+    assert td(lerchphi(x, b, c), x)
+    raises(ArgumentIndexError, lambda: lerchphi(c, b, x).fdiff(2))
+    raises(ArgumentIndexError, lambda: lerchphi(c, b, x).fdiff(4))
+    raises(ArgumentIndexError, lambda: polylog(b, z).fdiff(1))
+    raises(ArgumentIndexError, lambda: polylog(b, z).fdiff(3))
+
+
+def myexpand(func, target):
+    expanded = expand_func(func)
+    if target is not None:
+        return expanded == target
+    if expanded == func:  # it didn't expand
+        return False
+
+    # check to see that the expanded and original evaluate to the same value
+    subs = {}
+    for a in func.free_symbols:
+        subs[a] = randcplx()
+    return abs(func.subs(subs).n()
+               - expanded.replace(exp_polar, exp).subs(subs).n()) < 1e-10
+
+
+def test_polylog_expansion():
+    assert polylog(s, 0) == 0
+    assert polylog(s, 1) == zeta(s)
+    assert polylog(s, -1) == -dirichlet_eta(s)
+    assert polylog(s, exp_polar(I*pi*Rational(4, 3))) == polylog(s, exp(I*pi*Rational(4, 3)))
+    assert polylog(s, exp_polar(I*pi)/3) == polylog(s, exp(I*pi)/3)
+
+    assert myexpand(polylog(1, z), -log(1 - z))
+    assert myexpand(polylog(0, z), z/(1 - z))
+    assert myexpand(polylog(-1, z), z/(1 - z)**2)
+    assert ((1-z)**3 * expand_func(polylog(-2, z))).simplify() == z*(1 + z)
+    assert myexpand(polylog(-5, z), None)
+
+
+def test_polylog_series():
+    assert polylog(1, z).series(z, n=5) == z + z**2/2 + z**3/3 + z**4/4 + O(z**5)
+    assert polylog(1, sqrt(z)).series(z, n=3) == z/2 + z**2/4 + sqrt(z)\
+        + z**(S(3)/2)/3 + z**(S(5)/2)/5 + O(z**3)
+
+    # https://github.com/sympy/sympy/issues/9497
+    assert polylog(S(3)/2, -z).series(z, 0, 5) == -z + sqrt(2)*z**2/4\
+        - sqrt(3)*z**3/9 + z**4/8 + O(z**5)
+
+
+def test_issue_8404():
+    i = Symbol('i', integer=True)
+    assert Abs(Sum(1/(3*i + 1)**2, (i, 0, S.Infinity)).doit().n(4)
+        - 1.122) < 0.001
+
+
+def test_polylog_values():
+    assert polylog(2, 2) == pi**2/4 - I*pi*log(2)
+    assert polylog(2, S.Half) == pi**2/12 - log(2)**2/2
+    for z in [S.Half, 2, (sqrt(5)-1)/2, -(sqrt(5)-1)/2, -(sqrt(5)+1)/2, (3-sqrt(5))/2]:
+        assert Abs(polylog(2, z).evalf() - polylog(2, z, evaluate=False).evalf()) < 1e-15
+    z = Symbol("z")
+    for s in [-1, 0]:
+        for _ in range(10):
+            assert verify_numerically(polylog(s, z), polylog(s, z, evaluate=False),
+                                      z, a=-3, b=-2, c=S.Half, d=2)
+            assert verify_numerically(polylog(s, z), polylog(s, z, evaluate=False),
+                                      z, a=2, b=-2, c=5, d=2)
+
+    from sympy.integrals.integrals import Integral
+    assert polylog(0, Integral(1, (x, 0, 1))) == -S.Half
+
+
+def test_lerchphi_expansion():
+    assert myexpand(lerchphi(1, s, a), zeta(s, a))
+    assert myexpand(lerchphi(z, s, 1), polylog(s, z)/z)
+
+    # direct summation
+    assert myexpand(lerchphi(z, -1, a), a/(1 - z) + z/(1 - z)**2)
+    assert myexpand(lerchphi(z, -3, a), None)
+    # polylog reduction
+    assert myexpand(lerchphi(z, s, S.Half),
+                    2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z)
+                              - polylog(s, polar_lift(-1)*sqrt(z))/sqrt(z)))
+    assert myexpand(lerchphi(z, s, 2), -1/z + polylog(s, z)/z**2)
+    assert myexpand(lerchphi(z, s, Rational(3, 2)), None)
+    assert myexpand(lerchphi(z, s, Rational(7, 3)), None)
+    assert myexpand(lerchphi(z, s, Rational(-1, 3)), None)
+    assert myexpand(lerchphi(z, s, Rational(-5, 2)), None)
+
+    # hurwitz zeta reduction
+    assert myexpand(lerchphi(-1, s, a),
+                    2**(-s)*zeta(s, a/2) - 2**(-s)*zeta(s, (a + 1)/2))
+    assert myexpand(lerchphi(I, s, a), None)
+    assert myexpand(lerchphi(-I, s, a), None)
+    assert myexpand(lerchphi(exp(I*pi*Rational(2, 5)), s, a), None)
+
+
+def test_stieltjes():
+    assert isinstance(stieltjes(x), stieltjes)
+    assert isinstance(stieltjes(x, a), stieltjes)
+
+    # Zero'th constant EulerGamma
+    assert stieltjes(0) == S.EulerGamma
+    assert stieltjes(0, 1) == S.EulerGamma
+
+    # Not defined
+    assert stieltjes(nan) is nan
+    assert stieltjes(0, nan) is nan
+    assert stieltjes(-1) is S.ComplexInfinity
+    assert stieltjes(1.5) is S.ComplexInfinity
+    assert stieltjes(z, 0) is S.ComplexInfinity
+    assert stieltjes(z, -1) is S.ComplexInfinity
+
+
+def test_stieltjes_evalf():
+    assert abs(stieltjes(0).evalf() - 0.577215664) < 1E-9
+    assert abs(stieltjes(0, 0.5).evalf() - 1.963510026) < 1E-9
+    assert abs(stieltjes(1, 2).evalf() + 0.072815845) < 1E-9
+
+
+def test_issue_10475():
+    a = Symbol('a', extended_real=True)
+    b = Symbol('b', extended_positive=True)
+    s = Symbol('s', zero=False)
+
+    assert zeta(2 + I).is_finite
+    assert zeta(1).is_finite is False
+    assert zeta(x).is_finite is None
+    assert zeta(x + I).is_finite is None
+    assert zeta(a).is_finite is None
+    assert zeta(b).is_finite is None
+    assert zeta(-b).is_finite is True
+    assert zeta(b**2 - 2*b + 1).is_finite is None
+    assert zeta(a + I).is_finite is True
+    assert zeta(b + 1).is_finite is True
+    assert zeta(s + 1).is_finite is True
+
+
+def test_issue_14177():
+    n = Symbol('n', nonnegative=True, integer=True)
+
+    assert zeta(-n).rewrite(bernoulli) == bernoulli(n+1) / (-n-1)
+    assert zeta(-n, a).rewrite(bernoulli) == bernoulli(n+1, a) / (-n-1)
+    z2n = -(2*I*pi)**(2*n)*bernoulli(2*n) / (2*factorial(2*n))
+    assert zeta(2*n).rewrite(bernoulli) == z2n
+    assert expand_func(zeta(s, n+1)) == zeta(s) - harmonic(n, s)
+    assert expand_func(zeta(-b, -n)) is nan
+    assert expand_func(zeta(-b, n)) == zeta(-b, n)
+
+    n = Symbol('n')
+
+    assert zeta(2*n) == zeta(2*n) # As sign of z (= 2*n) is not determined
diff --git a/.venv/lib/python3.12/site-packages/sympy/functions/special/zeta_functions.py b/.venv/lib/python3.12/site-packages/sympy/functions/special/zeta_functions.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f410f0f1086de91490c714cd3becf11df9ab189
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/functions/special/zeta_functions.py
@@ -0,0 +1,786 @@
+""" Riemann zeta and related function. """
+
+from sympy.core.add import Add
+from sympy.core.cache import cacheit
+from sympy.core.function import ArgumentIndexError, expand_mul, DefinedFunction
+from sympy.core.logic import fuzzy_not
+from sympy.core.numbers import pi, I, Integer
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.combinatorial.numbers import bernoulli, factorial, genocchi, harmonic
+from sympy.functions.elementary.complexes import re, unpolarify, Abs, polar_lift
+from sympy.functions.elementary.exponential import log, exp_polar, exp
+from sympy.functions.elementary.integers import ceiling, floor
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.polys.polytools import Poly
+
+###############################################################################
+###################### LERCH TRANSCENDENT #####################################
+###############################################################################
+
+
+class lerchphi(DefinedFunction):
+    r"""
+    Lerch transcendent (Lerch phi function).
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(a) > 0$, $|z| < 1$ and $s \in \mathbb{C}$, the
+    Lerch transcendent is defined as
+
+    .. math :: \Phi(z, s, a) = \sum_{n=0}^\infty \frac{z^n}{(n + a)^s},
+
+    where the standard branch of the argument is used for $n + a$,
+    and by analytic continuation for other values of the parameters.
+
+    A commonly used related function is the Lerch zeta function, defined by
+
+    .. math:: L(q, s, a) = \Phi(e^{2\pi i q}, s, a).
+
+    **Analytic Continuation and Branching Behavior**
+
+    It can be shown that
+
+    .. math:: \Phi(z, s, a) = z\Phi(z, s, a+1) + a^{-s}.
+
+    This provides the analytic continuation to $\operatorname{Re}(a) \le 0$.
+
+    Assume now $\operatorname{Re}(a) > 0$. The integral representation
+
+    .. math:: \Phi_0(z, s, a) = \int_0^\infty \frac{t^{s-1} e^{-at}}{1 - ze^{-t}}
+                                \frac{\mathrm{d}t}{\Gamma(s)}
+
+    provides an analytic continuation to $\mathbb{C} - [1, \infty)$.
+    Finally, for $x \in (1, \infty)$ we find
+
+    .. math:: \lim_{\epsilon \to 0^+} \Phi_0(x + i\epsilon, s, a)
+             -\lim_{\epsilon \to 0^+} \Phi_0(x - i\epsilon, s, a)
+             = \frac{2\pi i \log^{s-1}{x}}{x^a \Gamma(s)},
+
+    using the standard branch for both $\log{x}$ and
+    $\log{\log{x}}$ (a branch of $\log{\log{x}}$ is needed to
+    evaluate $\log{x}^{s-1}$).
+    This concludes the analytic continuation. The Lerch transcendent is thus
+    branched at $z \in \{0, 1, \infty\}$ and
+    $a \in \mathbb{Z}_{\le 0}$. For fixed $z, a$ outside these
+    branch points, it is an entire function of $s$.
+
+    Examples
+    ========
+
+    The Lerch transcendent is a fairly general function, for this reason it does
+    not automatically evaluate to simpler functions. Use ``expand_func()`` to
+    achieve this.
+
+    If $z=1$, the Lerch transcendent reduces to the Hurwitz zeta function:
+
+    >>> from sympy import lerchphi, expand_func
+    >>> from sympy.abc import z, s, a
+    >>> expand_func(lerchphi(1, s, a))
+    zeta(s, a)
+
+    More generally, if $z$ is a root of unity, the Lerch transcendent
+    reduces to a sum of Hurwitz zeta functions:
+
+    >>> expand_func(lerchphi(-1, s, a))
+    zeta(s, a/2)/2**s - zeta(s, a/2 + 1/2)/2**s
+
+    If $a=1$, the Lerch transcendent reduces to the polylogarithm:
+
+    >>> expand_func(lerchphi(z, s, 1))
+    polylog(s, z)/z
+
+    More generally, if $a$ is rational, the Lerch transcendent reduces
+    to a sum of polylogarithms:
+
+    >>> from sympy import S
+    >>> expand_func(lerchphi(z, s, S(1)/2))
+    2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
+                polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))
+    >>> expand_func(lerchphi(z, s, S(3)/2))
+    -2**s/z + 2**(s - 1)*(polylog(s, sqrt(z))/sqrt(z) -
+                          polylog(s, sqrt(z)*exp_polar(I*pi))/sqrt(z))/z
+
+    The derivatives with respect to $z$ and $a$ can be computed in
+    closed form:
+
+    >>> lerchphi(z, s, a).diff(z)
+    (-a*lerchphi(z, s, a) + lerchphi(z, s - 1, a))/z
+    >>> lerchphi(z, s, a).diff(a)
+    -s*lerchphi(z, s + 1, a)
+
+    See Also
+    ========
+
+    polylog, zeta
+
+    References
+    ==========
+
+    .. [1] Bateman, H.; Erdelyi, A. (1953), Higher Transcendental Functions,
+           Vol. I, New York: McGraw-Hill. Section 1.11.
+    .. [2] https://dlmf.nist.gov/25.14
+    .. [3] https://en.wikipedia.org/wiki/Lerch_transcendent
+
+    """
+
+    def _eval_expand_func(self, **hints):
+        z, s, a = self.args
+        if z == 1:
+            return zeta(s, a)
+        if s.is_Integer and s <= 0:
+            t = Dummy('t')
+            p = Poly((t + a)**(-s), t)
+            start = 1/(1 - t)
+            res = S.Zero
+            for c in reversed(p.all_coeffs()):
+                res += c*start
+                start = t*start.diff(t)
+            return res.subs(t, z)
+
+        if a.is_Rational:
+            # See section 18 of
+            #   Kelly B. Roach.  Hypergeometric Function Representations.
+            #   In: Proceedings of the 1997 International Symposium on Symbolic and
+            #   Algebraic Computation, pages 205-211, New York, 1997. ACM.
+            # TODO should something be polarified here?
+            add = S.Zero
+            mul = S.One
+            # First reduce a to the interaval (0, 1]
+            if a > 1:
+                n = floor(a)
+                if n == a:
+                    n -= 1
+                a -= n
+                mul = z**(-n)
+                add = Add(*[-z**(k - n)/(a + k)**s for k in range(n)])
+            elif a <= 0:
+                n = floor(-a) + 1
+                a += n
+                mul = z**n
+                add = Add(*[z**(n - 1 - k)/(a - k - 1)**s for k in range(n)])
+
+            m, n = S([a.p, a.q])
+            zet = exp_polar(2*pi*I/n)
+            root = z**(1/n)
+            up_zet = unpolarify(zet)
+            addargs = []
+            for k in range(n):
+                p = polylog(s, zet**k*root)
+                if isinstance(p, polylog):
+                    p = p._eval_expand_func(**hints)
+                addargs.append(p/(up_zet**k*root)**m)
+            return add + mul*n**(s - 1)*Add(*addargs)
+
+        # TODO use minpoly instead of ad-hoc methods when issue 5888 is fixed
+        if isinstance(z, exp) and (z.args[0]/(pi*I)).is_Rational or z in [-1, I, -I]:
+            # TODO reference?
+            if z == -1:
+                p, q = S([1, 2])
+            elif z == I:
+                p, q = S([1, 4])
+            elif z == -I:
+                p, q = S([-1, 4])
+            else:
+                arg = z.args[0]/(2*pi*I)
+                p, q = S([arg.p, arg.q])
+            return Add(*[exp(2*pi*I*k*p/q)/q**s*zeta(s, (k + a)/q)
+                         for k in range(q)])
+
+        return lerchphi(z, s, a)
+
+    def fdiff(self, argindex=1):
+        z, s, a = self.args
+        if argindex == 3:
+            return -s*lerchphi(z, s + 1, a)
+        elif argindex == 1:
+            return (lerchphi(z, s - 1, a) - a*lerchphi(z, s, a))/z
+        else:
+            raise ArgumentIndexError
+
+    def _eval_rewrite_helper(self, target):
+        res = self._eval_expand_func()
+        if res.has(target):
+            return res
+        else:
+            return self
+
+    def _eval_rewrite_as_zeta(self, z, s, a, **kwargs):
+        return self._eval_rewrite_helper(zeta)
+
+    def _eval_rewrite_as_polylog(self, z, s, a, **kwargs):
+        return self._eval_rewrite_helper(polylog)
+
+###############################################################################
+###################### POLYLOGARITHM ##########################################
+###############################################################################
+
+
+class polylog(DefinedFunction):
+    r"""
+    Polylogarithm function.
+
+    Explanation
+    ===========
+
+    For $|z| < 1$ and $s \in \mathbb{C}$, the polylogarithm is
+    defined by
+
+    .. math:: \operatorname{Li}_s(z) = \sum_{n=1}^\infty \frac{z^n}{n^s},
+
+    where the standard branch of the argument is used for $n$. It admits
+    an analytic continuation which is branched at $z=1$ (notably not on the
+    sheet of initial definition), $z=0$ and $z=\infty$.
+
+    The name polylogarithm comes from the fact that for $s=1$, the
+    polylogarithm is related to the ordinary logarithm (see examples), and that
+
+    .. math:: \operatorname{Li}_{s+1}(z) =
+                    \int_0^z \frac{\operatorname{Li}_s(t)}{t} \mathrm{d}t.
+
+    The polylogarithm is a special case of the Lerch transcendent:
+
+    .. math:: \operatorname{Li}_{s}(z) = z \Phi(z, s, 1).
+
+    Examples
+    ========
+
+    For $z \in \{0, 1, -1\}$, the polylogarithm is automatically expressed
+    using other functions:
+
+    >>> from sympy import polylog
+    >>> from sympy.abc import s
+    >>> polylog(s, 0)
+    0
+    >>> polylog(s, 1)
+    zeta(s)
+    >>> polylog(s, -1)
+    -dirichlet_eta(s)
+
+    If $s$ is a negative integer, $0$ or $1$, the polylogarithm can be
+    expressed using elementary functions. This can be done using
+    ``expand_func()``:
+
+    >>> from sympy import expand_func
+    >>> from sympy.abc import z
+    >>> expand_func(polylog(1, z))
+    -log(1 - z)
+    >>> expand_func(polylog(0, z))
+    z/(1 - z)
+
+    The derivative with respect to $z$ can be computed in closed form:
+
+    >>> polylog(s, z).diff(z)
+    polylog(s - 1, z)/z
+
+    The polylogarithm can be expressed in terms of the lerch transcendent:
+
+    >>> from sympy import lerchphi
+    >>> polylog(s, z).rewrite(lerchphi)
+    z*lerchphi(z, s, 1)
+
+    See Also
+    ========
+
+    zeta, lerchphi
+
+    """
+
+    @classmethod
+    def eval(cls, s, z):
+        if z.is_number:
+            if z is S.One:
+                return zeta(s)
+            elif z is S.NegativeOne:
+                return -dirichlet_eta(s)
+            elif z is S.Zero:
+                return S.Zero
+            elif s == 2:
+                dilogtable = _dilogtable()
+                if z in dilogtable:
+                    return dilogtable[z]
+
+        if z.is_zero:
+            return S.Zero
+
+        # Make an effort to determine if z is 1 to avoid replacing into
+        # expression with singularity
+        zone = z.equals(S.One)
+
+        if zone:
+            return zeta(s)
+        elif zone is False:
+            # For s = 0 or -1 use explicit formulas to evaluate, but
+            # automatically expanding polylog(1, z) to -log(1-z) seems
+            # undesirable for summation methods based on hypergeometric
+            # functions
+            if s is S.Zero:
+                return z/(1 - z)
+            elif s is S.NegativeOne:
+                return z/(1 - z)**2
+            if s.is_zero:
+                return z/(1 - z)
+
+        # polylog is branched, but not over the unit disk
+        if z.has(exp_polar, polar_lift) and (zone or (Abs(z) <= S.One) == True):
+            return cls(s, unpolarify(z))
+
+    def fdiff(self, argindex=1):
+        s, z = self.args
+        if argindex == 2:
+            return polylog(s - 1, z)/z
+        raise ArgumentIndexError
+
+    def _eval_rewrite_as_lerchphi(self, s, z, **kwargs):
+        return z*lerchphi(z, s, 1)
+
+    def _eval_expand_func(self, **hints):
+        s, z = self.args
+        if s == 1:
+            return -log(1 - z)
+        if s.is_Integer and s <= 0:
+            u = Dummy('u')
+            start = u/(1 - u)
+            for _ in range(-s):
+                start = u*start.diff(u)
+            return expand_mul(start).subs(u, z)
+        return polylog(s, z)
+
+    def _eval_is_zero(self):
+        z = self.args[1]
+        if z.is_zero:
+            return True
+
+    def _eval_nseries(self, x, n, logx, cdir=0):
+        from sympy.series.order import Order
+        nu, z = self.args
+
+        z0 = z.subs(x, 0)
+        if z0 is S.NaN:
+            z0 = z.limit(x, 0, dir='-' if re(cdir).is_negative else '+')
+
+        if z0.is_zero:
+            # In case of powers less than 1, number of terms need to be computed
+            # separately to avoid repeated callings of _eval_nseries with wrong n
+            try:
+                _, exp = z.leadterm(x)
+            except (ValueError, NotImplementedError):
+                return self
+
+            if exp.is_positive:
+                newn = ceiling(n/exp)
+                o = Order(x**n, x)
+                r = z._eval_nseries(x, n, logx, cdir).removeO()
+                if r is S.Zero:
+                    return o
+
+                term = r
+                s = [term]
+                for k in range(2, newn):
+                    term *= r
+                    s.append(term/k**nu)
+                return Add(*s) + o
+
+        return super(polylog, self)._eval_nseries(x, n, logx, cdir)
+
+###############################################################################
+###################### HURWITZ GENERALIZED ZETA FUNCTION ######################
+###############################################################################
+
+
+class zeta(DefinedFunction):
+    r"""
+    Hurwitz zeta function (or Riemann zeta function).
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(a) > 0$ and $\operatorname{Re}(s) > 1$, this
+    function is defined as
+
+    .. math:: \zeta(s, a) = \sum_{n=0}^\infty \frac{1}{(n + a)^s},
+
+    where the standard choice of argument for $n + a$ is used. For fixed
+    $a$ not a nonpositive integer the Hurwitz zeta function admits a
+    meromorphic continuation to all of $\mathbb{C}$; it is an unbranched
+    function with a simple pole at $s = 1$.
+
+    The Hurwitz zeta function is a special case of the Lerch transcendent:
+
+    .. math:: \zeta(s, a) = \Phi(1, s, a).
+
+    This formula defines an analytic continuation for all possible values of
+    $s$ and $a$ (also $\operatorname{Re}(a) < 0$), see the documentation of
+    :class:`lerchphi` for a description of the branching behavior.
+
+    If no value is passed for $a$ a default value of $a = 1$ is assumed,
+    yielding the Riemann zeta function.
+
+    Examples
+    ========
+
+    For $a = 1$ the Hurwitz zeta function reduces to the famous Riemann
+    zeta function:
+
+    .. math:: \zeta(s, 1) = \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s}.
+
+    >>> from sympy import zeta
+    >>> from sympy.abc import s
+    >>> zeta(s, 1)
+    zeta(s)
+    >>> zeta(s)
+    zeta(s)
+
+    The Riemann zeta function can also be expressed using the Dirichlet eta
+    function:
+
+    >>> from sympy import dirichlet_eta
+    >>> zeta(s).rewrite(dirichlet_eta)
+    dirichlet_eta(s)/(1 - 2**(1 - s))
+
+    The Riemann zeta function at nonnegative even and negative integer
+    values is related to the Bernoulli numbers and polynomials:
+
+    >>> zeta(2)
+    pi**2/6
+    >>> zeta(4)
+    pi**4/90
+    >>> zeta(0)
+    -1/2
+    >>> zeta(-1)
+    -1/12
+    >>> zeta(-4)
+    0
+
+    The specific formulae are:
+
+    .. math:: \zeta(2n) = -\frac{(2\pi i)^{2n} B_{2n}}{2(2n)!}
+    .. math:: \zeta(-n,a) = -\frac{B_{n+1}(a)}{n+1}
+
+    No closed-form expressions are known at positive odd integers, but
+    numerical evaluation is possible:
+
+    >>> zeta(3).n()
+    1.20205690315959
+
+    The derivative of $\zeta(s, a)$ with respect to $a$ can be computed:
+
+    >>> from sympy.abc import a
+    >>> zeta(s, a).diff(a)
+    -s*zeta(s + 1, a)
+
+    However the derivative with respect to $s$ has no useful closed form
+    expression:
+
+    >>> zeta(s, a).diff(s)
+    Derivative(zeta(s, a), s)
+
+    The Hurwitz zeta function can be expressed in terms of the Lerch
+    transcendent, :class:`~.lerchphi`:
+
+    >>> from sympy import lerchphi
+    >>> zeta(s, a).rewrite(lerchphi)
+    lerchphi(1, s, a)
+
+    See Also
+    ========
+
+    dirichlet_eta, lerchphi, polylog
+
+    References
+    ==========
+
+    .. [1] https://dlmf.nist.gov/25.11
+    .. [2] https://en.wikipedia.org/wiki/Hurwitz_zeta_function
+
+    """
+
+    @classmethod
+    def eval(cls, s, a=None):
+        if a is S.One:
+            return cls(s)
+        elif s is S.NaN or a is S.NaN:
+            return S.NaN
+        elif s is S.One:
+            return S.ComplexInfinity
+        elif s is S.Infinity:
+            return S.One
+        elif a is S.Infinity:
+            return S.Zero
+
+        sint = s.is_Integer
+        if a is None:
+            a = S.One
+        if sint and s.is_nonpositive:
+            return bernoulli(1-s, a) / (s-1)
+        elif a is S.One:
+            if sint and s.is_even:
+                return -(2*pi*I)**s * bernoulli(s) / (2*factorial(s))
+        elif sint and a.is_Integer and a.is_positive:
+            return cls(s) - harmonic(a-1, s)
+        elif a.is_Integer and a.is_nonpositive and \
+                (s.is_integer is False or s.is_nonpositive is False):
+            return S.NaN
+
+    def _eval_rewrite_as_bernoulli(self, s, a=1, **kwargs):
+        if a == 1 and s.is_integer and s.is_nonnegative and s.is_even:
+            return -(2*pi*I)**s * bernoulli(s) / (2*factorial(s))
+        return bernoulli(1-s, a) / (s-1)
+
+    def _eval_rewrite_as_dirichlet_eta(self, s, a=1, **kwargs):
+        if a != 1:
+            return self
+        s = self.args[0]
+        return dirichlet_eta(s)/(1 - 2**(1 - s))
+
+    def _eval_rewrite_as_lerchphi(self, s, a=1, **kwargs):
+        return lerchphi(1, s, a)
+
+    def _eval_is_finite(self):
+        return fuzzy_not((self.args[0] - 1).is_zero)
+
+    def _eval_expand_func(self, **hints):
+        s = self.args[0]
+        a = self.args[1] if len(self.args) > 1 else S.One
+        if a.is_integer:
+            if a.is_positive:
+                return zeta(s) - harmonic(a-1, s)
+            if a.is_nonpositive and (s.is_integer is False or
+                    s.is_nonpositive is False):
+                return S.NaN
+        return self
+
+    def fdiff(self, argindex=1):
+        if len(self.args) == 2:
+            s, a = self.args
+        else:
+            s, a = self.args + (1,)
+        if argindex == 2:
+            return -s*zeta(s + 1, a)
+        else:
+            raise ArgumentIndexError
+
+    def _eval_as_leading_term(self, x, logx, cdir):
+        if len(self.args) == 2:
+            s, a = self.args
+        else:
+            s, a = self.args + (S.One,)
+
+        try:
+            c, e = a.leadterm(x)
+        except NotImplementedError:
+            return self
+
+        if e.is_negative and not s.is_positive:
+            raise NotImplementedError
+
+        return super(zeta, self)._eval_as_leading_term(x, logx=logx, cdir=cdir)
+
+
+class dirichlet_eta(DefinedFunction):
+    r"""
+    Dirichlet eta function.
+
+    Explanation
+    ===========
+
+    For $\operatorname{Re}(s) > 0$ and $0 < x \le 1$, this function is defined as
+
+    .. math:: \eta(s, a) = \sum_{n=0}^\infty \frac{(-1)^n}{(n+a)^s}.
+
+    It admits a unique analytic continuation to all of $\mathbb{C}$ for any
+    fixed $a$ not a nonpositive integer. It is an entire, unbranched function.
+
+    It can be expressed using the Hurwitz zeta function as
+
+    .. math:: \eta(s, a) = \zeta(s,a) - 2^{1-s} \zeta\left(s, \frac{a+1}{2}\right)
+
+    and using the generalized Genocchi function as
+
+    .. math:: \eta(s, a) = \frac{G(1-s, a)}{2(s-1)}.
+
+    In both cases the limiting value of $\log2 - \psi(a) + \psi\left(\frac{a+1}{2}\right)$
+    is used when $s = 1$.
+
+    Examples
+    ========
+
+    >>> from sympy import dirichlet_eta, zeta
+    >>> from sympy.abc import s
+    >>> dirichlet_eta(s).rewrite(zeta)
+    Piecewise((log(2), Eq(s, 1)), ((1 - 2**(1 - s))*zeta(s), True))
+
+    See Also
+    ========
+
+    zeta
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Dirichlet_eta_function
+    .. [2] Peter Luschny, "An introduction to the Bernoulli function",
+           https://arxiv.org/abs/2009.06743
+
+    """
+
+    @classmethod
+    def eval(cls, s, a=None):
+        if a is S.One:
+            return cls(s)
+        if a is None:
+            if s == 1:
+                return log(2)
+            z = zeta(s)
+            if not z.has(zeta):
+                return (1 - 2**(1-s)) * z
+            return
+        elif s == 1:
+            from sympy.functions.special.gamma_functions import digamma
+            return log(2) - digamma(a) + digamma((a+1)/2)
+        z1 = zeta(s, a)
+        z2 = zeta(s, (a+1)/2)
+        if not z1.has(zeta) and not z2.has(zeta):
+            return z1 - 2**(1-s) * z2
+
+    def _eval_rewrite_as_zeta(self, s, a=1, **kwargs):
+        from sympy.functions.special.gamma_functions import digamma
+        if a == 1:
+            return Piecewise((log(2), Eq(s, 1)), ((1 - 2**(1-s)) * zeta(s), True))
+        return Piecewise((log(2) - digamma(a) + digamma((a+1)/2), Eq(s, 1)),
+                (zeta(s, a) - 2**(1-s) * zeta(s, (a+1)/2), True))
+
+    def _eval_rewrite_as_genocchi(self, s, a=S.One, **kwargs):
+        from sympy.functions.special.gamma_functions import digamma
+        return Piecewise((log(2) - digamma(a) + digamma((a+1)/2), Eq(s, 1)),
+                (genocchi(1-s, a) / (2 * (s-1)), True))
+
+    def _eval_evalf(self, prec):
+        if all(i.is_number for i in self.args):
+            return self.rewrite(zeta)._eval_evalf(prec)
+
+
+class riemann_xi(DefinedFunction):
+    r"""
+    Riemann Xi function.
+
+    Examples
+    ========
+
+    The Riemann Xi function is closely related to the Riemann zeta function.
+    The zeros of Riemann Xi function are precisely the non-trivial zeros
+    of the zeta function.
+
+    >>> from sympy import riemann_xi, zeta
+    >>> from sympy.abc import s
+    >>> riemann_xi(s).rewrite(zeta)
+    s*(s - 1)*gamma(s/2)*zeta(s)/(2*pi**(s/2))
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Riemann_Xi_function
+
+    """
+
+
+    @classmethod
+    def eval(cls, s):
+        from sympy.functions.special.gamma_functions import gamma
+        z = zeta(s)
+        if s in (S.Zero, S.One):
+            return S.Half
+
+        if not isinstance(z, zeta):
+            return s*(s - 1)*gamma(s/2)*z/(2*pi**(s/2))
+
+    def _eval_rewrite_as_zeta(self, s, **kwargs):
+        from sympy.functions.special.gamma_functions import gamma
+        return s*(s - 1)*gamma(s/2)*zeta(s)/(2*pi**(s/2))
+
+
+class stieltjes(DefinedFunction):
+    r"""
+    Represents Stieltjes constants, $\gamma_{k}$ that occur in
+    Laurent Series expansion of the Riemann zeta function.
+
+    Examples
+    ========
+
+    >>> from sympy import stieltjes
+    >>> from sympy.abc import n, m
+    >>> stieltjes(n)
+    stieltjes(n)
+
+    The zero'th stieltjes constant:
+
+    >>> stieltjes(0)
+    EulerGamma
+    >>> stieltjes(0, 1)
+    EulerGamma
+
+    For generalized stieltjes constants:
+
+    >>> stieltjes(n, m)
+    stieltjes(n, m)
+
+    Constants are only defined for integers >= 0:
+
+    >>> stieltjes(-1)
+    zoo
+
+    References
+    ==========
+
+    .. [1] https://en.wikipedia.org/wiki/Stieltjes_constants
+
+    """
+
+    @classmethod
+    def eval(cls, n, a=None):
+        if a is not None:
+            a = sympify(a)
+            if a is S.NaN:
+                return S.NaN
+            if a.is_Integer and a.is_nonpositive:
+                return S.ComplexInfinity
+
+        if n.is_Number:
+            if n is S.NaN:
+                return S.NaN
+            elif n < 0:
+                return S.ComplexInfinity
+            elif not n.is_Integer:
+                return S.ComplexInfinity
+            elif n is S.Zero and a in [None, 1]:
+                return S.EulerGamma
+
+        if n.is_extended_negative:
+            return S.ComplexInfinity
+
+        if n.is_zero and a in [None, 1]:
+            return S.EulerGamma
+
+        if n.is_integer == False:
+            return S.ComplexInfinity
+
+
+@cacheit
+def _dilogtable():
+    return {
+        S.Half: pi**2/12 - log(2)**2/2,
+        Integer(2) : pi**2/4 - I*pi*log(2),
+        -(sqrt(5) - 1)/2 : -pi**2/15 + log((sqrt(5)-1)/2)**2/2,
+        -(sqrt(5) + 1)/2 : -pi**2/10 - log((sqrt(5)+1)/2)**2,
+        (3 - sqrt(5))/2 : pi**2/15 - log((sqrt(5)-1)/2)**2,
+        (sqrt(5) - 1)/2 : pi**2/10 - log((sqrt(5)-1)/2)**2,
+        I : I*S.Catalan - pi**2/48,
+        -I : -I*S.Catalan - pi**2/48,
+        1 - I : pi**2/16 - I*S.Catalan - pi*I/4*log(2),
+        1 + I : pi**2/16 + I*S.Catalan + pi*I/4*log(2),
+        (1 - I)/2 : -log(2)**2/8 + pi*I*log(2)/8 + 5*pi**2/96 - I*S.Catalan
+    }
diff --git a/.venv/lib/python3.12/site-packages/sympy/galgebra.py b/.venv/lib/python3.12/site-packages/sympy/galgebra.py
new file mode 100644
index 0000000000000000000000000000000000000000..be812bfcbcece834c86d7b55eb846286acd0ac08
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/galgebra.py
@@ -0,0 +1 @@
+raise ImportError("""As of SymPy 1.0 the galgebra module is maintained separately at https://github.com/pygae/galgebra""")
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__init__.py b/.venv/lib/python3.12/site-packages/sympy/geometry/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb85d4ff5d53eb44a039a95cfc2fff687322cc76
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/__init__.py
@@ -0,0 +1,45 @@
+"""
+A geometry module for the SymPy library. This module contains all of the
+entities and functions needed to construct basic geometrical data and to
+perform simple informational queries.
+
+Usage:
+======
+
+Examples
+========
+
+"""
+from sympy.geometry.point import Point, Point2D, Point3D
+from sympy.geometry.line import Line, Ray, Segment, Line2D, Segment2D, Ray2D, \
+    Line3D, Segment3D, Ray3D
+from sympy.geometry.plane import Plane
+from sympy.geometry.ellipse import Ellipse, Circle
+from sympy.geometry.polygon import Polygon, RegularPolygon, Triangle, rad, deg
+from sympy.geometry.util import are_similar, centroid, convex_hull, idiff, \
+    intersection, closest_points, farthest_points
+from sympy.geometry.exceptions import GeometryError
+from sympy.geometry.curve import Curve
+from sympy.geometry.parabola import Parabola
+
+__all__ = [
+    'Point', 'Point2D', 'Point3D',
+
+    'Line', 'Ray', 'Segment', 'Line2D', 'Segment2D', 'Ray2D', 'Line3D',
+    'Segment3D', 'Ray3D',
+
+    'Plane',
+
+    'Ellipse', 'Circle',
+
+    'Polygon', 'RegularPolygon', 'Triangle', 'rad', 'deg',
+
+    'are_similar', 'centroid', 'convex_hull', 'idiff', 'intersection',
+    'closest_points', 'farthest_points',
+
+    'GeometryError',
+
+    'Curve',
+
+    'Parabola',
+]
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c81c8f883e510e6a2e637937e488a74b515d353
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/curve.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/curve.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ad2e8cddb5356c2bf111318d8a248ee971736fa
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/curve.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/ellipse.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/ellipse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e117ae641a472e49cf12448b0a33f5090faf1542
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/ellipse.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/entity.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/entity.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af198f51212e35cbf8e7ff3eb79008f8a3910745
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/entity.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/exceptions.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/exceptions.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef3b3311b5a3f1dae3b3433da3c565610edde888
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/exceptions.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/line.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/line.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae7bdaf74042f81ac1fadd66c80bf02755eab933
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/line.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/parabola.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/parabola.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ebc3398b2edd0dc75e8bdb732daa000264806e92
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/parabola.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/plane.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/plane.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2acc1aa5ae4208ab1e19f61f1cf3f8ebf24c1f5c
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/plane.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/point.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/point.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9070dfc0bc51827b849e60040f5914476e6571a5
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/point.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/polygon.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/polygon.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..00ede7b7bb2818f5b6c7c9f95a544968ef94db89
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/polygon.cpython-312.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa153a6b647afa6aa02c9b76c1fa056c0366737093aaa46ecccaa767c7845b11
+size 101672
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0083bdd1bb97ec97a259835b9e422f5a2d5a3b2b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/__pycache__/util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/curve.py b/.venv/lib/python3.12/site-packages/sympy/geometry/curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..c074f22cad79b1261ad44be4ccface972cdd3b82
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/curve.py
@@ -0,0 +1,424 @@
+"""Curves in 2-dimensional Euclidean space.
+
+Contains
+========
+Curve
+
+"""
+
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.core import diff
+from sympy.core.containers import Tuple
+from sympy.core.symbol import _symbol
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point
+from sympy.integrals import integrate
+from sympy.matrices import Matrix, rot_axis3
+from sympy.utilities.iterables import is_sequence
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Curve(GeometrySet):
+    """A curve in space.
+
+    A curve is defined by parametric functions for the coordinates, a
+    parameter and the lower and upper bounds for the parameter value.
+
+    Parameters
+    ==========
+
+    function : list of functions
+    limits : 3-tuple
+        Function parameter and lower and upper bounds.
+
+    Attributes
+    ==========
+
+    functions
+    parameter
+    limits
+
+    Raises
+    ======
+
+    ValueError
+        When `functions` are specified incorrectly.
+        When `limits` are specified incorrectly.
+
+    Examples
+    ========
+
+    >>> from sympy import Curve, sin, cos, interpolate
+    >>> from sympy.abc import t, a
+    >>> C = Curve((sin(t), cos(t)), (t, 0, 2))
+    >>> C.functions
+    (sin(t), cos(t))
+    >>> C.limits
+    (t, 0, 2)
+    >>> C.parameter
+    t
+    >>> C = Curve((t, interpolate([1, 4, 9, 16], t)), (t, 0, 1)); C
+    Curve((t, t**2), (t, 0, 1))
+    >>> C.subs(t, 4)
+    Point2D(4, 16)
+    >>> C.arbitrary_point(a)
+    Point2D(a, a**2)
+
+    See Also
+    ========
+
+    sympy.core.function.Function
+    sympy.polys.polyfuncs.interpolate
+
+    """
+
+    def __new__(cls, function, limits):
+        if not is_sequence(function) or len(function) != 2:
+            raise ValueError("Function argument should be (x(t), y(t)) "
+                "but got %s" % str(function))
+        if not is_sequence(limits) or len(limits) != 3:
+            raise ValueError("Limit argument should be (t, tmin, tmax) "
+                "but got %s" % str(limits))
+
+        return GeometryEntity.__new__(cls, Tuple(*function), Tuple(*limits))
+
+    def __call__(self, f):
+        return self.subs(self.parameter, f)
+
+    def _eval_subs(self, old, new):
+        if old == self.parameter:
+            return Point(*[f.subs(old, new) for f in self.functions])
+
+    def _eval_evalf(self, prec=15, **options):
+        f, (t, a, b) = self.args
+        dps = prec_to_dps(prec)
+        f = tuple([i.evalf(n=dps, **options) for i in f])
+        a, b = [i.evalf(n=dps, **options) for i in (a, b)]
+        return self.func(f, (t, a, b))
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the curve.
+
+        Parameters
+        ==========
+
+        parameter : str or Symbol, optional
+            Default value is 't'.
+            The Curve's parameter is selected with None or self.parameter
+            otherwise the provided symbol is used.
+
+        Returns
+        =======
+
+        Point :
+            Returns a point in parametric form.
+
+        Raises
+        ======
+
+        ValueError
+            When `parameter` already appears in the functions.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, Symbol
+        >>> from sympy.abc import s
+        >>> C = Curve([2*s, s**2], (s, 0, 2))
+        >>> C.arbitrary_point()
+        Point2D(2*t, t**2)
+        >>> C.arbitrary_point(C.parameter)
+        Point2D(2*s, s**2)
+        >>> C.arbitrary_point(None)
+        Point2D(2*s, s**2)
+        >>> C.arbitrary_point(Symbol('a'))
+        Point2D(2*a, a**2)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        """
+        if parameter is None:
+            return Point(*self.functions)
+
+        tnew = _symbol(parameter, self.parameter, real=True)
+        t = self.parameter
+        if (tnew.name != t.name and
+                tnew.name in (f.name for f in self.free_symbols)):
+            raise ValueError('Symbol %s already appears in object '
+                'and cannot be used as a parameter.' % tnew.name)
+        return Point(*[w.subs(t, tnew) for w in self.functions])
+
+    @property
+    def free_symbols(self):
+        """Return a set of symbols other than the bound symbols used to
+        parametrically define the Curve.
+
+        Returns
+        =======
+
+        set :
+            Set of all non-parameterized symbols.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t, a
+        >>> from sympy import Curve
+        >>> Curve((t, t**2), (t, 0, 2)).free_symbols
+        set()
+        >>> Curve((t, t**2), (t, a, 2)).free_symbols
+        {a}
+
+        """
+        free = set()
+        for a in self.functions + self.limits[1:]:
+            free |= a.free_symbols
+        free = free.difference({self.parameter})
+        return free
+
+    @property
+    def ambient_dimension(self):
+        """The dimension of the curve.
+
+        Returns
+        =======
+
+        int :
+            the dimension of curve.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve((t, t**2), (t, 0, 2))
+        >>> C.ambient_dimension
+        2
+
+        """
+
+        return len(self.args[0])
+
+    @property
+    def functions(self):
+        """The functions specifying the curve.
+
+        Returns
+        =======
+
+        functions :
+            list of parameterized coordinate functions.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve((t, t**2), (t, 0, 2))
+        >>> C.functions
+        (t, t**2)
+
+        See Also
+        ========
+
+        parameter
+
+        """
+        return self.args[0]
+
+    @property
+    def limits(self):
+        """The limits for the curve.
+
+        Returns
+        =======
+
+        limits : tuple
+            Contains parameter and lower and upper limits.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve([t, t**3], (t, -2, 2))
+        >>> C.limits
+        (t, -2, 2)
+
+        See Also
+        ========
+
+        plot_interval
+
+        """
+        return self.args[1]
+
+    @property
+    def parameter(self):
+        """The curve function variable.
+
+        Returns
+        =======
+
+        Symbol :
+            returns a bound symbol.
+
+        Examples
+        ========
+
+        >>> from sympy.abc import t
+        >>> from sympy import Curve
+        >>> C = Curve([t, t**2], (t, 0, 2))
+        >>> C.parameter
+        t
+
+        See Also
+        ========
+
+        functions
+
+        """
+        return self.args[1][0]
+
+    @property
+    def length(self):
+        """The curve length.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import t
+        >>> Curve((t, t), (t, 0, 1)).length
+        sqrt(2)
+
+        """
+        integrand = sqrt(sum(diff(func, self.limits[0])**2 for func in self.functions))
+        return integrate(integrand, self.limits)
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the curve.
+
+        Parameters
+        ==========
+
+        parameter : str or Symbol, optional
+            Default value is 't';
+            otherwise the provided symbol is used.
+
+        Returns
+        =======
+
+        List :
+            the plot interval as below:
+                [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, sin
+        >>> from sympy.abc import x, s
+        >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval()
+        [t, 1, 2]
+        >>> Curve((x, sin(x)), (x, 1, 2)).plot_interval(s)
+        [s, 1, 2]
+
+        See Also
+        ========
+
+        limits : Returns limits of the parameter interval
+
+        """
+        t = _symbol(parameter, self.parameter, real=True)
+        return [t] + list(self.limits[1:])
+
+    def rotate(self, angle=0, pt=None):
+        """This function is used to rotate a curve along given point ``pt`` at given angle(in radian).
+
+        Parameters
+        ==========
+
+        angle :
+            the angle at which the curve will be rotated(in radian) in counterclockwise direction.
+            default value of angle is 0.
+
+        pt : Point
+            the point along which the curve will be rotated.
+            If no point given, the curve will be rotated around origin.
+
+        Returns
+        =======
+
+        Curve :
+            returns a curve rotated at given angle along given point.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve, pi
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).rotate(pi/2)
+        Curve((-x, x), (x, 0, 1))
+
+        """
+        if pt:
+            pt = -Point(pt, dim=2)
+        else:
+            pt = Point(0,0)
+        rv = self.translate(*pt.args)
+        f = list(rv.functions)
+        f.append(0)
+        f = Matrix(1, 3, f)
+        f *= rot_axis3(angle)
+        rv = self.func(f[0, :2].tolist()[0], self.limits)
+        pt = -pt
+        return rv.translate(*pt.args)
+
+    def scale(self, x=1, y=1, pt=None):
+        """Override GeometryEntity.scale since Curve is not made up of Points.
+
+        Returns
+        =======
+
+        Curve :
+            returns scaled curve.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).scale(2)
+        Curve((2*x, x), (x, 0, 1))
+
+        """
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        fx, fy = self.functions
+        return self.func((fx*x, fy*y), self.limits)
+
+    def translate(self, x=0, y=0):
+        """Translate the Curve by (x, y).
+
+        Returns
+        =======
+
+        Curve :
+            returns a translated curve.
+
+        Examples
+        ========
+
+        >>> from sympy import Curve
+        >>> from sympy.abc import x
+        >>> Curve((x, x), (x, 0, 1)).translate(1, 2)
+        Curve((x + 1, x + 2), (x, 0, 1))
+
+        """
+        fx, fy = self.functions
+        return self.func((fx + x, fy + y), self.limits)
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/ellipse.py b/.venv/lib/python3.12/site-packages/sympy/geometry/ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..199db25fde9b019893a275d69959154990e8a4a7
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/ellipse.py
@@ -0,0 +1,1768 @@
+"""Elliptical geometrical entities.
+
+Contains
+* Ellipse
+* Circle
+
+"""
+
+from sympy.core.expr import Expr
+from sympy.core.relational import Eq
+from sympy.core import S, pi, sympify
+from sympy.core.evalf import N
+from sympy.core.parameters import global_parameters
+from sympy.core.logic import fuzzy_bool
+from sympy.core.numbers import Rational, oo
+from sympy.core.sorting import ordered
+from sympy.core.symbol import Dummy, uniquely_named_symbol, _symbol
+from sympy.simplify.simplify import simplify
+from sympy.simplify.trigsimp import trigsimp
+from sympy.functions.elementary.miscellaneous import sqrt, Max
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.functions.special.elliptic_integrals import elliptic_e
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .line import Line, Segment, Ray2D, Segment2D, Line2D, LinearEntity3D
+from .point import Point, Point2D, Point3D
+from .util import idiff, find
+from sympy.polys import DomainError, Poly, PolynomialError
+from sympy.polys.polyutils import _not_a_coeff, _nsort
+from sympy.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import filldedent, func_name
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+x, y = [Dummy('ellipse_dummy', real=True) for i in range(2)]
+
+
+class Ellipse(GeometrySet):
+    """An elliptical GeometryEntity.
+
+    Parameters
+    ==========
+
+    center : Point, optional
+        Default value is Point(0, 0)
+    hradius : number or SymPy expression, optional
+    vradius : number or SymPy expression, optional
+    eccentricity : number or SymPy expression, optional
+        Two of `hradius`, `vradius` and `eccentricity` must be supplied to
+        create an Ellipse. The third is derived from the two supplied.
+
+    Attributes
+    ==========
+
+    center
+    hradius
+    vradius
+    area
+    circumference
+    eccentricity
+    periapsis
+    apoapsis
+    focus_distance
+    foci
+
+    Raises
+    ======
+
+    GeometryError
+        When `hradius`, `vradius` and `eccentricity` are incorrectly supplied
+        as parameters.
+    TypeError
+        When `center` is not a Point.
+
+    See Also
+    ========
+
+    Circle
+
+    Notes
+    -----
+    Constructed from a center and two radii, the first being the horizontal
+    radius (along the x-axis) and the second being the vertical radius (along
+    the y-axis).
+
+    When symbolic value for hradius and vradius are used, any calculation that
+    refers to the foci or the major or minor axis will assume that the ellipse
+    has its major radius on the x-axis. If this is not true then a manual
+    rotation is necessary.
+
+    Examples
+    ========
+
+    >>> from sympy import Ellipse, Point, Rational
+    >>> e1 = Ellipse(Point(0, 0), 5, 1)
+    >>> e1.hradius, e1.vradius
+    (5, 1)
+    >>> e2 = Ellipse(Point(3, 1), hradius=3, eccentricity=Rational(4, 5))
+    >>> e2
+    Ellipse(Point2D(3, 1), 3, 9/5)
+
+    """
+
+    def __contains__(self, o):
+        if isinstance(o, Point):
+            res = self.equation(x, y).subs({x: o.x, y: o.y})
+            return trigsimp(simplify(res)) is S.Zero
+        elif isinstance(o, Ellipse):
+            return self == o
+        return False
+
+    def __eq__(self, o):
+        """Is the other GeometryEntity the same as this ellipse?"""
+        return isinstance(o, Ellipse) and (self.center == o.center and
+                                           self.hradius == o.hradius and
+                                           self.vradius == o.vradius)
+
+    def __hash__(self):
+        return super().__hash__()
+
+    def __new__(
+        cls, center=None, hradius=None, vradius=None, eccentricity=None, **kwargs):
+
+        hradius = sympify(hradius)
+        vradius = sympify(vradius)
+
+        if center is None:
+            center = Point(0, 0)
+        else:
+            if len(center) != 2:
+                raise ValueError('The center of "{}" must be a two dimensional point'.format(cls))
+            center = Point(center, dim=2)
+
+        if len(list(filter(lambda x: x is not None, (hradius, vradius, eccentricity)))) != 2:
+            raise ValueError(filldedent('''
+                Exactly two arguments of "hradius", "vradius", and
+                "eccentricity" must not be None.'''))
+
+        if eccentricity is not None:
+            eccentricity = sympify(eccentricity)
+            if eccentricity.is_negative:
+                raise GeometryError("Eccentricity of ellipse/circle should lie between [0, 1)")
+            elif hradius is None:
+                hradius = vradius / sqrt(1 - eccentricity**2)
+            elif vradius is None:
+                vradius = hradius * sqrt(1 - eccentricity**2)
+
+        if hradius == vradius:
+            return Circle(center, hradius, **kwargs)
+
+        if S.Zero in (hradius, vradius):
+            return Segment(Point(center[0] - hradius, center[1] - vradius), Point(center[0] + hradius, center[1] + vradius))
+
+        if hradius.is_real is False or vradius.is_real is False:
+            raise GeometryError("Invalid value encountered when computing hradius / vradius.")
+
+        return GeometryEntity.__new__(cls, center, hradius, vradius, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG ellipse element for the Ellipse.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+
+        c = N(self.center)
+        h, v = N(self.hradius), N(self.vradius)
+        return (
+            ''
+        ).format(2. * scale_factor, fill_color, c.x, c.y, h, v)
+
+    @property
+    def ambient_dimension(self):
+        return 2
+
+    @property
+    def apoapsis(self):
+        """The apoapsis of the ellipse.
+
+        The greatest distance between the focus and the contour.
+
+        Returns
+        =======
+
+        apoapsis : number
+
+        See Also
+        ========
+
+        periapsis : Returns shortest distance between foci and contour
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.apoapsis
+        2*sqrt(2) + 3
+
+        """
+        return self.major * (1 + self.eccentricity)
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the ellipse.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        arbitrary_point : Point
+
+        Raises
+        ======
+
+        ValueError
+            When `parameter` already appears in the functions.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e1 = Ellipse(Point(0, 0), 3, 2)
+        >>> e1.arbitrary_point()
+        Point2D(3*cos(t), 2*sin(t))
+
+        """
+        t = _symbol(parameter, real=True)
+        if t.name in (f.name for f in self.free_symbols):
+            raise ValueError(filldedent('Symbol %s already appears in object '
+                                        'and cannot be used as a parameter.' % t.name))
+        return Point(self.center.x + self.hradius*cos(t),
+                     self.center.y + self.vradius*sin(t))
+
+    @property
+    def area(self):
+        """The area of the ellipse.
+
+        Returns
+        =======
+
+        area : number
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.area
+        3*pi
+
+        """
+        return simplify(S.Pi * self.hradius * self.vradius)
+
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+
+        h, v = self.hradius, self.vradius
+        return (self.center.x - h, self.center.y - v, self.center.x + h, self.center.y + v)
+
+    @property
+    def center(self):
+        """The center of the ellipse.
+
+        Returns
+        =======
+
+        center : number
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.center
+        Point2D(0, 0)
+
+        """
+        return self.args[0]
+
+    @property
+    def circumference(self):
+        """The circumference of the ellipse.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.circumference
+        12*elliptic_e(8/9)
+
+        """
+        if self.eccentricity == 1:
+            # degenerate
+            return 4*self.major
+        elif self.eccentricity == 0:
+            # circle
+            return 2*pi*self.hradius
+        else:
+            return 4*self.major*elliptic_e(self.eccentricity**2)
+
+    @property
+    def eccentricity(self):
+        """The eccentricity of the ellipse.
+
+        Returns
+        =======
+
+        eccentricity : number
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse, sqrt
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, sqrt(2))
+        >>> e1.eccentricity
+        sqrt(7)/3
+
+        """
+        return self.focus_distance / self.major
+
+    def encloses_point(self, p):
+        """
+        Return True if p is enclosed by (is inside of) self.
+
+        Notes
+        -----
+        Being on the border of self is considered False.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        encloses_point : True, False or None
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse, S
+        >>> from sympy.abc import t
+        >>> e = Ellipse((0, 0), 3, 2)
+        >>> e.encloses_point((0, 0))
+        True
+        >>> e.encloses_point(e.arbitrary_point(t).subs(t, S.Half))
+        False
+        >>> e.encloses_point((4, 0))
+        False
+
+        """
+        p = Point(p, dim=2)
+        if p in self:
+            return False
+
+        if len(self.foci) == 2:
+            # if the combined distance from the foci to p (h1 + h2) is less
+            # than the combined distance from the foci to the minor axis
+            # (which is the same as the major axis length) then p is inside
+            # the ellipse
+            h1, h2 = [f.distance(p) for f in self.foci]
+            test = 2*self.major - (h1 + h2)
+        else:
+            test = self.radius - self.center.distance(p)
+
+        return fuzzy_bool(test.is_positive)
+
+    def equation(self, x='x', y='y', _slope=None):
+        """
+        Returns the equation of an ellipse aligned with the x and y axes;
+        when slope is given, the equation returned corresponds to an ellipse
+        with a major axis having that slope.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            Label for the x-axis. Default value is 'x'.
+        y : str, optional
+            Label for the y-axis. Default value is 'y'.
+        _slope : Expr, optional
+                The slope of the major axis. Ignored when 'None'.
+
+        Returns
+        =======
+
+        equation : SymPy expression
+
+        See Also
+        ========
+
+        arbitrary_point : Returns parameterized point on ellipse
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse, pi
+        >>> from sympy.abc import x, y
+        >>> e1 = Ellipse(Point(1, 0), 3, 2)
+        >>> eq1 = e1.equation(x, y); eq1
+        y**2/4 + (x/3 - 1/3)**2 - 1
+        >>> eq2 = e1.equation(x, y, _slope=1); eq2
+        (-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1
+
+        A point on e1 satisfies eq1. Let's use one on the x-axis:
+
+        >>> p1 = e1.center + Point(e1.major, 0)
+        >>> assert eq1.subs(x, p1.x).subs(y, p1.y) == 0
+
+        When rotated the same as the rotated ellipse, about the center
+        point of the ellipse, it will satisfy the rotated ellipse's
+        equation, too:
+
+        >>> r1 = p1.rotate(pi/4, e1.center)
+        >>> assert eq2.subs(x, r1.x).subs(y, r1.y) == 0
+
+        References
+        ==========
+
+        .. [1] https://math.stackexchange.com/questions/108270/what-is-the-equation-of-an-ellipse-that-is-not-aligned-with-the-axis
+        .. [2] https://en.wikipedia.org/wiki/Ellipse#Shifted_ellipse
+
+        """
+
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+
+        dx = x - self.center.x
+        dy = y - self.center.y
+
+        if _slope is not None:
+            L = (dy - _slope*dx)**2
+            l = (_slope*dy + dx)**2
+            h = 1 + _slope**2
+            b = h*self.major**2
+            a = h*self.minor**2
+            return l/b + L/a - 1
+
+        else:
+            t1 = (dx/self.hradius)**2
+            t2 = (dy/self.vradius)**2
+            return t1 + t2 - 1
+
+    def evolute(self, x='x', y='y'):
+        """The equation of evolute of the ellipse.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            Label for the x-axis. Default value is 'x'.
+        y : str, optional
+            Label for the y-axis. Default value is 'y'.
+
+        Returns
+        =======
+
+        equation : SymPy expression
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e1 = Ellipse(Point(1, 0), 3, 2)
+        >>> e1.evolute()
+        2**(2/3)*y**(2/3) + (3*x - 3)**(2/3) - 5**(2/3)
+        """
+        if len(self.args) != 3:
+            raise NotImplementedError('Evolute of arbitrary Ellipse is not supported.')
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+        t1 = (self.hradius*(x - self.center.x))**Rational(2, 3)
+        t2 = (self.vradius*(y - self.center.y))**Rational(2, 3)
+        return t1 + t2 - (self.hradius**2 - self.vradius**2)**Rational(2, 3)
+
+    @property
+    def foci(self):
+        """The foci of the ellipse.
+
+        Notes
+        -----
+        The foci can only be calculated if the major/minor axes are known.
+
+        Raises
+        ======
+
+        ValueError
+            When the major and minor axis cannot be determined.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+        focus_distance : Returns the distance between focus and center
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.foci
+        (Point2D(-2*sqrt(2), 0), Point2D(2*sqrt(2), 0))
+
+        """
+        c = self.center
+        hr, vr = self.hradius, self.vradius
+        if hr == vr:
+            return (c, c)
+
+        # calculate focus distance manually, since focus_distance calls this
+        # routine
+        fd = sqrt(self.major**2 - self.minor**2)
+        if hr == self.minor:
+            # foci on the y-axis
+            return (c + Point(0, -fd), c + Point(0, fd))
+        elif hr == self.major:
+            # foci on the x-axis
+            return (c + Point(-fd, 0), c + Point(fd, 0))
+
+    @property
+    def focus_distance(self):
+        """The focal distance of the ellipse.
+
+        The distance between the center and one focus.
+
+        Returns
+        =======
+
+        focus_distance : number
+
+        See Also
+        ========
+
+        foci
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.focus_distance
+        2*sqrt(2)
+
+        """
+        return Point.distance(self.center, self.foci[0])
+
+    @property
+    def hradius(self):
+        """The horizontal radius of the ellipse.
+
+        Returns
+        =======
+
+        hradius : number
+
+        See Also
+        ========
+
+        vradius, major, minor
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.hradius
+        3
+
+        """
+        return self.args[1]
+
+    def intersection(self, o):
+        """The intersection of this ellipse and another geometrical entity
+        `o`.
+
+        Parameters
+        ==========
+
+        o : GeometryEntity
+
+        Returns
+        =======
+
+        intersection : list of GeometryEntity objects
+
+        Notes
+        -----
+        Currently supports intersections with Point, Line, Segment, Ray,
+        Circle and Ellipse types.
+
+        See Also
+        ========
+
+        sympy.geometry.entity.GeometryEntity
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse, Point, Line
+        >>> e = Ellipse(Point(0, 0), 5, 7)
+        >>> e.intersection(Point(0, 0))
+        []
+        >>> e.intersection(Point(5, 0))
+        [Point2D(5, 0)]
+        >>> e.intersection(Line(Point(0,0), Point(0, 1)))
+        [Point2D(0, -7), Point2D(0, 7)]
+        >>> e.intersection(Line(Point(5,0), Point(5, 1)))
+        [Point2D(5, 0)]
+        >>> e.intersection(Line(Point(6,0), Point(6, 1)))
+        []
+        >>> e = Ellipse(Point(-1, 0), 4, 3)
+        >>> e.intersection(Ellipse(Point(1, 0), 4, 3))
+        [Point2D(0, -3*sqrt(15)/4), Point2D(0, 3*sqrt(15)/4)]
+        >>> e.intersection(Ellipse(Point(5, 0), 4, 3))
+        [Point2D(2, -3*sqrt(7)/4), Point2D(2, 3*sqrt(7)/4)]
+        >>> e.intersection(Ellipse(Point(100500, 0), 4, 3))
+        []
+        >>> e.intersection(Ellipse(Point(0, 0), 3, 4))
+        [Point2D(3, 0), Point2D(-363/175, -48*sqrt(111)/175), Point2D(-363/175, 48*sqrt(111)/175)]
+        >>> e.intersection(Ellipse(Point(-1, 0), 3, 4))
+        [Point2D(-17/5, -12/5), Point2D(-17/5, 12/5), Point2D(7/5, -12/5), Point2D(7/5, 12/5)]
+        """
+        # TODO: Replace solve with nonlinsolve, when nonlinsolve will be able to solve in real domain
+
+        if isinstance(o, Point):
+            if o in self:
+                return [o]
+            else:
+                return []
+
+        elif isinstance(o, (Segment2D, Ray2D)):
+            ellipse_equation = self.equation(x, y)
+            result = solve([ellipse_equation, Line(
+                o.points[0], o.points[1]).equation(x, y)], [x, y],
+                set=True)[1]
+            return list(ordered([Point(i) for i in result if i in o]))
+
+        elif isinstance(o, Polygon):
+            return o.intersection(self)
+
+        elif isinstance(o, (Ellipse, Line2D)):
+            if o == self:
+                return self
+            else:
+                ellipse_equation = self.equation(x, y)
+                return list(ordered([Point(i) for i in solve(
+                    [ellipse_equation, o.equation(x, y)], [x, y],
+                    set=True)[1]]))
+        elif isinstance(o, LinearEntity3D):
+            raise TypeError('Entity must be two dimensional, not three dimensional')
+        else:
+            raise TypeError('Intersection not handled for %s' % func_name(o))
+
+    def is_tangent(self, o):
+        """Is `o` tangent to the ellipse?
+
+        Parameters
+        ==========
+
+        o : GeometryEntity
+            An Ellipse, LinearEntity or Polygon
+
+        Raises
+        ======
+
+        NotImplementedError
+            When the wrong type of argument is supplied.
+
+        Returns
+        =======
+
+        is_tangent: boolean
+            True if o is tangent to the ellipse, False otherwise.
+
+        See Also
+        ========
+
+        tangent_lines
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse, Line
+        >>> p0, p1, p2 = Point(0, 0), Point(3, 0), Point(3, 3)
+        >>> e1 = Ellipse(p0, 3, 2)
+        >>> l1 = Line(p1, p2)
+        >>> e1.is_tangent(l1)
+        True
+
+        """
+        if isinstance(o, Point2D):
+            return False
+        elif isinstance(o, Ellipse):
+            intersect = self.intersection(o)
+            if isinstance(intersect, Ellipse):
+                return True
+            elif intersect:
+                return all((self.tangent_lines(i)[0]).equals(o.tangent_lines(i)[0]) for i in intersect)
+            else:
+                return False
+        elif isinstance(o, Line2D):
+            hit = self.intersection(o)
+            if not hit:
+                return False
+            if len(hit) == 1:
+                return True
+            # might return None if it can't decide
+            return hit[0].equals(hit[1])
+        elif isinstance(o, (Segment2D, Ray2D)):
+            intersect = self.intersection(o)
+            if len(intersect) == 1:
+                return o in self.tangent_lines(intersect[0])[0]
+            else:
+                return False
+        elif isinstance(o, Polygon):
+            return all(self.is_tangent(s) for s in o.sides)
+        elif isinstance(o, (LinearEntity3D, Point3D)):
+            raise TypeError('Entity must be two dimensional, not three dimensional')
+        else:
+            raise TypeError('Is_tangent not handled for %s' % func_name(o))
+
+    @property
+    def major(self):
+        """Longer axis of the ellipse (if it can be determined) else hradius.
+
+        Returns
+        =======
+
+        major : number or expression
+
+        See Also
+        ========
+
+        hradius, vradius, minor
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse, Symbol
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.major
+        3
+
+        >>> a = Symbol('a')
+        >>> b = Symbol('b')
+        >>> Ellipse(p1, a, b).major
+        a
+        >>> Ellipse(p1, b, a).major
+        b
+
+        >>> m = Symbol('m')
+        >>> M = m + 1
+        >>> Ellipse(p1, m, M).major
+        m + 1
+
+        """
+        ab = self.args[1:3]
+        if len(ab) == 1:
+            return ab[0]
+        a, b = ab
+        o = b - a < 0
+        if o == True:
+            return a
+        elif o == False:
+            return b
+        return self.hradius
+
+    @property
+    def minor(self):
+        """Shorter axis of the ellipse (if it can be determined) else vradius.
+
+        Returns
+        =======
+
+        minor : number or expression
+
+        See Also
+        ========
+
+        hradius, vradius, major
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse, Symbol
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.minor
+        1
+
+        >>> a = Symbol('a')
+        >>> b = Symbol('b')
+        >>> Ellipse(p1, a, b).minor
+        b
+        >>> Ellipse(p1, b, a).minor
+        a
+
+        >>> m = Symbol('m')
+        >>> M = m + 1
+        >>> Ellipse(p1, m, M).minor
+        m
+
+        """
+        ab = self.args[1:3]
+        if len(ab) == 1:
+            return ab[0]
+        a, b = ab
+        o = a - b < 0
+        if o == True:
+            return a
+        elif o == False:
+            return b
+        return self.vradius
+
+    def normal_lines(self, p, prec=None):
+        """Normal lines between `p` and the ellipse.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        normal_lines : list with 1, 2 or 4 Lines
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e = Ellipse((0, 0), 2, 3)
+        >>> c = e.center
+        >>> e.normal_lines(c + Point(1, 0))
+        [Line2D(Point2D(0, 0), Point2D(1, 0))]
+        >>> e.normal_lines(c)
+        [Line2D(Point2D(0, 0), Point2D(0, 1)), Line2D(Point2D(0, 0), Point2D(1, 0))]
+
+        Off-axis points require the solution of a quartic equation. This
+        often leads to very large expressions that may be of little practical
+        use. An approximate solution of `prec` digits can be obtained by
+        passing in the desired value:
+
+        >>> e.normal_lines((3, 3), prec=2)
+        [Line2D(Point2D(-0.81, -2.7), Point2D(0.19, -1.2)),
+        Line2D(Point2D(1.5, -2.0), Point2D(2.5, -2.7))]
+
+        Whereas the above solution has an operation count of 12, the exact
+        solution has an operation count of 2020.
+        """
+        p = Point(p, dim=2)
+
+        # XXX change True to something like self.angle == 0 if the arbitrarily
+        # rotated ellipse is introduced.
+        # https://github.com/sympy/sympy/issues/2815)
+        if True:
+            rv = []
+            if p.x == self.center.x:
+                rv.append(Line(self.center, slope=oo))
+            if p.y == self.center.y:
+                rv.append(Line(self.center, slope=0))
+            if rv:
+                # at these special orientations of p either 1 or 2 normals
+                # exist and we are done
+                return rv
+
+        # find the 4 normal points and construct lines through them with
+        # the corresponding slope
+        eq = self.equation(x, y)
+        dydx = idiff(eq, y, x)
+        norm = -1/dydx
+        slope = Line(p, (x, y)).slope
+        seq = slope - norm
+
+        # TODO: Replace solve with solveset, when this line is tested
+        yis = solve(seq, y)[0]
+        xeq = eq.subs(y, yis).as_numer_denom()[0].expand()
+        if len(xeq.free_symbols) == 1:
+            try:
+                # this is so much faster, it's worth a try
+                xsol = Poly(xeq, x).real_roots()
+            except (DomainError, PolynomialError, NotImplementedError):
+                # TODO: Replace solve with solveset, when these lines are tested
+                xsol = _nsort(solve(xeq, x), separated=True)[0]
+            points = [Point(i, solve(eq.subs(x, i), y)[0]) for i in xsol]
+        else:
+            raise NotImplementedError(
+                'intersections for the general ellipse are not supported')
+        slopes = [norm.subs(zip((x, y), pt.args)) for pt in points]
+        if prec is not None:
+            points = [pt.n(prec) for pt in points]
+            slopes = [i if _not_a_coeff(i) else i.n(prec) for i in slopes]
+        return [Line(pt, slope=s) for pt, s in zip(points, slopes)]
+
+    @property
+    def periapsis(self):
+        """The periapsis of the ellipse.
+
+        The shortest distance between the focus and the contour.
+
+        Returns
+        =======
+
+        periapsis : number
+
+        See Also
+        ========
+
+        apoapsis : Returns greatest distance between focus and contour
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.periapsis
+        3 - 2*sqrt(2)
+
+        """
+        return self.major * (1 - self.eccentricity)
+
+    @property
+    def semilatus_rectum(self):
+        """
+        Calculates the semi-latus rectum of the Ellipse.
+
+        Semi-latus rectum is defined as one half of the chord through a
+        focus parallel to the conic section directrix of a conic section.
+
+        Returns
+        =======
+
+        semilatus_rectum : number
+
+        See Also
+        ========
+
+        apoapsis : Returns greatest distance between focus and contour
+
+        periapsis : The shortest distance between the focus and the contour
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.semilatus_rectum
+        1/3
+
+        References
+        ==========
+
+        .. [1] https://mathworld.wolfram.com/SemilatusRectum.html
+        .. [2] https://en.wikipedia.org/wiki/Ellipse#Semi-latus_rectum
+
+        """
+        return self.major * (1 - self.eccentricity ** 2)
+
+    def auxiliary_circle(self):
+        """Returns a Circle whose diameter is the major axis of the ellipse.
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse, Point, symbols
+        >>> c = Point(1, 2)
+        >>> Ellipse(c, 8, 7).auxiliary_circle()
+        Circle(Point2D(1, 2), 8)
+        >>> a, b = symbols('a b')
+        >>> Ellipse(c, a, b).auxiliary_circle()
+        Circle(Point2D(1, 2), Max(a, b))
+        """
+        return Circle(self.center, Max(self.hradius, self.vradius))
+
+    def director_circle(self):
+        """
+        Returns a Circle consisting of all points where two perpendicular
+        tangent lines to the ellipse cross each other.
+
+        Returns
+        =======
+
+        Circle
+            A director circle returned as a geometric object.
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse, Point, symbols
+        >>> c = Point(3,8)
+        >>> Ellipse(c, 7, 9).director_circle()
+        Circle(Point2D(3, 8), sqrt(130))
+        >>> a, b = symbols('a b')
+        >>> Ellipse(c, a, b).director_circle()
+        Circle(Point2D(3, 8), sqrt(a**2 + b**2))
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Director_circle
+
+        """
+        return Circle(self.center, sqrt(self.hradius**2 + self.vradius**2))
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the Ellipse.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e1 = Ellipse(Point(0, 0), 3, 2)
+        >>> e1.plot_interval()
+        [t, -pi, pi]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, -S.Pi, S.Pi]
+
+    def random_point(self, seed=None):
+        """A random point on the ellipse.
+
+        Returns
+        =======
+
+        point : Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e1 = Ellipse(Point(0, 0), 3, 2)
+        >>> e1.random_point() # gives some random point
+        Point2D(...)
+        >>> p1 = e1.random_point(seed=0); p1.n(2)
+        Point2D(2.1, 1.4)
+
+        Notes
+        =====
+
+        When creating a random point, one may simply replace the
+        parameter with a random number. When doing so, however, the
+        random number should be made a Rational or else the point
+        may not test as being in the ellipse:
+
+        >>> from sympy.abc import t
+        >>> from sympy import Rational
+        >>> arb = e1.arbitrary_point(t); arb
+        Point2D(3*cos(t), 2*sin(t))
+        >>> arb.subs(t, .1) in e1
+        False
+        >>> arb.subs(t, Rational(.1)) in e1
+        True
+        >>> arb.subs(t, Rational('.1')) in e1
+        True
+
+        See Also
+        ========
+        sympy.geometry.point.Point
+        arbitrary_point : Returns parameterized point on ellipse
+        """
+        t = _symbol('t', real=True)
+        x, y = self.arbitrary_point(t).args
+        # get a random value in [-1, 1) corresponding to cos(t)
+        # and confirm that it will test as being in the ellipse
+        if seed is not None:
+            rng = random.Random(seed)
+        else:
+            rng = random
+        # simplify this now or else the Float will turn s into a Float
+        r = Rational(rng.random())
+        c = 2*r - 1
+        s = sqrt(1 - c**2)
+        return Point(x.subs(cos(t), c), y.subs(sin(t), s))
+
+    def reflect(self, line):
+        """Override GeometryEntity.reflect since the radius
+        is not a GeometryEntity.
+
+        Examples
+        ========
+
+        >>> from sympy import Circle, Line
+        >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+        Circle(Point2D(1, 0), -1)
+        >>> from sympy import Ellipse, Line, Point
+        >>> Ellipse(Point(3, 4), 1, 3).reflect(Line(Point(0, -4), Point(5, 0)))
+        Traceback (most recent call last):
+        ...
+        NotImplementedError:
+        General Ellipse is not supported but the equation of the reflected
+        Ellipse is given by the zeros of: f(x, y) = (9*x/41 + 40*y/41 +
+        37/41)**2 + (40*x/123 - 3*y/41 - 364/123)**2 - 1
+
+        Notes
+        =====
+
+        Until the general ellipse (with no axis parallel to the x-axis) is
+        supported a NotImplemented error is raised and the equation whose
+        zeros define the rotated ellipse is given.
+
+        """
+
+        if line.slope in (0, oo):
+            c = self.center
+            c = c.reflect(line)
+            return self.func(c, -self.hradius, self.vradius)
+        else:
+            x, y = [uniquely_named_symbol(
+                name, (self, line), modify=lambda s: '_' + s, real=True)
+                for name in 'xy']
+            expr = self.equation(x, y)
+            p = Point(x, y).reflect(line)
+            result = expr.subs(zip((x, y), p.args
+                                   ), simultaneous=True)
+            raise NotImplementedError(filldedent(
+                'General Ellipse is not supported but the equation '
+                'of the reflected Ellipse is given by the zeros of: ' +
+                "f(%s, %s) = %s" % (str(x), str(y), str(result))))
+
+    def rotate(self, angle=0, pt=None):
+        """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+        Note: since the general ellipse is not supported, only rotations that
+        are integer multiples of pi/2 are allowed.
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse, pi
+        >>> Ellipse((1, 0), 2, 1).rotate(pi/2)
+        Ellipse(Point2D(0, 1), 1, 2)
+        >>> Ellipse((1, 0), 2, 1).rotate(pi)
+        Ellipse(Point2D(-1, 0), 2, 1)
+        """
+        if self.hradius == self.vradius:
+            return self.func(self.center.rotate(angle, pt), self.hradius)
+        if (angle/S.Pi).is_integer:
+            return super().rotate(angle, pt)
+        if (2*angle/S.Pi).is_integer:
+            return self.func(self.center.rotate(angle, pt), self.vradius, self.hradius)
+        # XXX see https://github.com/sympy/sympy/issues/2815 for general ellipes
+        raise NotImplementedError('Only rotations of pi/2 are currently supported for Ellipse.')
+
+    def scale(self, x=1, y=1, pt=None):
+        """Override GeometryEntity.scale since it is the major and minor
+        axes which must be scaled and they are not GeometryEntities.
+
+        Examples
+        ========
+
+        >>> from sympy import Ellipse
+        >>> Ellipse((0, 0), 2, 1).scale(2, 4)
+        Circle(Point2D(0, 0), 4)
+        >>> Ellipse((0, 0), 2, 1).scale(2)
+        Ellipse(Point2D(0, 0), 4, 1)
+        """
+        c = self.center
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        h = self.hradius
+        v = self.vradius
+        return self.func(c.scale(x, y), hradius=h*x, vradius=v*y)
+
+    def tangent_lines(self, p):
+        """Tangent lines between `p` and the ellipse.
+
+        If `p` is on the ellipse, returns the tangent line through point `p`.
+        Otherwise, returns the tangent line(s) from `p` to the ellipse, or
+        None if no tangent line is possible (e.g., `p` inside ellipse).
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        tangent_lines : list with 1 or 2 Lines
+
+        Raises
+        ======
+
+        NotImplementedError
+            Can only find tangent lines for a point, `p`, on the ellipse.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> e1 = Ellipse(Point(0, 0), 3, 2)
+        >>> e1.tangent_lines(Point(3, 0))
+        [Line2D(Point2D(3, 0), Point2D(3, -12))]
+
+        """
+        p = Point(p, dim=2)
+        if self.encloses_point(p):
+            return []
+
+        if p in self:
+            delta = self.center - p
+            rise = (self.vradius**2)*delta.x
+            run = -(self.hradius**2)*delta.y
+            p2 = Point(simplify(p.x + run),
+                       simplify(p.y + rise))
+            return [Line(p, p2)]
+        else:
+            if len(self.foci) == 2:
+                f1, f2 = self.foci
+                maj = self.hradius
+                test = (2*maj -
+                        Point.distance(f1, p) -
+                        Point.distance(f2, p))
+            else:
+                test = self.radius - Point.distance(self.center, p)
+            if test.is_number and test.is_positive:
+                return []
+            # else p is outside the ellipse or we can't tell. In case of the
+            # latter, the solutions returned will only be valid if
+            # the point is not inside the ellipse; if it is, nan will result.
+            eq = self.equation(x, y)
+            dydx = idiff(eq, y, x)
+            slope = Line(p, Point(x, y)).slope
+
+            # TODO: Replace solve with solveset, when this line is tested
+            tangent_points = solve([slope - dydx, eq], [x, y])
+
+            # handle horizontal and vertical tangent lines
+            if len(tangent_points) == 1:
+                if tangent_points[0][
+                           0] == p.x or tangent_points[0][1] == p.y:
+                    return [Line(p, p + Point(1, 0)), Line(p, p + Point(0, 1))]
+                else:
+                    return [Line(p, p + Point(0, 1)), Line(p, tangent_points[0])]
+
+            # others
+            return [Line(p, tangent_points[0]), Line(p, tangent_points[1])]
+
+    @property
+    def vradius(self):
+        """The vertical radius of the ellipse.
+
+        Returns
+        =======
+
+        vradius : number
+
+        See Also
+        ========
+
+        hradius, major, minor
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.vradius
+        1
+
+        """
+        return self.args[2]
+
+
+    def second_moment_of_area(self, point=None):
+        """Returns the second moment and product moment area of an ellipse.
+
+        Parameters
+        ==========
+
+        point : Point, two-tuple of sympifiable objects, or None(default=None)
+            point is the point about which second moment of area is to be found.
+            If "point=None" it will be calculated about the axis passing through the
+            centroid of the ellipse.
+
+        Returns
+        =======
+
+        I_xx, I_yy, I_xy : number or SymPy expression
+            I_xx, I_yy are second moment of area of an ellise.
+            I_xy is product moment of area of an ellipse.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ellipse
+        >>> p1 = Point(0, 0)
+        >>> e1 = Ellipse(p1, 3, 1)
+        >>> e1.second_moment_of_area()
+        (3*pi/4, 27*pi/4, 0)
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/List_of_second_moments_of_area
+
+        """
+
+        I_xx = (S.Pi*(self.hradius)*(self.vradius**3))/4
+        I_yy = (S.Pi*(self.hradius**3)*(self.vradius))/4
+        I_xy = 0
+
+        if point is None:
+            return I_xx, I_yy, I_xy
+
+        # parallel axis theorem
+        I_xx = I_xx + self.area*((point[1] - self.center.y)**2)
+        I_yy = I_yy + self.area*((point[0] - self.center.x)**2)
+        I_xy = I_xy + self.area*(point[0] - self.center.x)*(point[1] - self.center.y)
+
+        return I_xx, I_yy, I_xy
+
+
+    def polar_second_moment_of_area(self):
+        """Returns the polar second moment of area of an Ellipse
+
+        It is a constituent of the second moment of area, linked through
+        the perpendicular axis theorem. While the planar second moment of
+        area describes an object's resistance to deflection (bending) when
+        subjected to a force applied to a plane parallel to the central
+        axis, the polar second moment of area describes an object's
+        resistance to deflection when subjected to a moment applied in a
+        plane perpendicular to the object's central axis (i.e. parallel to
+        the cross-section)
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Circle, Ellipse
+        >>> c = Circle((5, 5), 4)
+        >>> c.polar_second_moment_of_area()
+        128*pi
+        >>> a, b = symbols('a, b')
+        >>> e = Ellipse((0, 0), a, b)
+        >>> e.polar_second_moment_of_area()
+        pi*a**3*b/4 + pi*a*b**3/4
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia
+
+        """
+        second_moment = self.second_moment_of_area()
+        return second_moment[0] + second_moment[1]
+
+
+    def section_modulus(self, point=None):
+        """Returns a tuple with the section modulus of an ellipse
+
+        Section modulus is a geometric property of an ellipse defined as the
+        ratio of second moment of area to the distance of the extreme end of
+        the ellipse from the centroidal axis.
+
+        Parameters
+        ==========
+
+        point : Point, two-tuple of sympifyable objects, or None(default=None)
+            point is the point at which section modulus is to be found.
+            If "point=None" section modulus will be calculated for the
+            point farthest from the centroidal axis of the ellipse.
+
+        Returns
+        =======
+
+        S_x, S_y: numbers or SymPy expressions
+                  S_x is the section modulus with respect to the x-axis
+                  S_y is the section modulus with respect to the y-axis
+                  A negative sign indicates that the section modulus is
+                  determined for a point below the centroidal axis.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol, Ellipse, Circle, Point2D
+        >>> d = Symbol('d', positive=True)
+        >>> c = Circle((0, 0), d/2)
+        >>> c.section_modulus()
+        (pi*d**3/32, pi*d**3/32)
+        >>> e = Ellipse(Point2D(0, 0), 2, 4)
+        >>> e.section_modulus()
+        (8*pi, 4*pi)
+        >>> e.section_modulus((2, 2))
+        (16*pi, 4*pi)
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Section_modulus
+
+        """
+        x_c, y_c = self.center
+        if point is None:
+            # taking x and y as maximum distances from centroid
+            x_min, y_min, x_max, y_max = self.bounds
+            y = max(y_c - y_min, y_max - y_c)
+            x = max(x_c - x_min, x_max - x_c)
+        else:
+            # taking x and y as distances of the given point from the center
+            point = Point2D(point)
+            y = point.y - y_c
+            x = point.x - x_c
+
+        second_moment = self.second_moment_of_area()
+        S_x = second_moment[0]/y
+        S_y = second_moment[1]/x
+
+        return S_x, S_y
+
+
+class Circle(Ellipse):
+    r"""A circle in space.
+
+    Constructed simply from a center and a radius, from three
+    non-collinear points, or the equation of a circle.
+
+    Parameters
+    ==========
+
+    center : Point
+    radius : number or SymPy expression
+    points : sequence of three Points
+    equation : equation of a circle
+
+    Attributes
+    ==========
+
+    radius (synonymous with hradius, vradius, major and minor)
+    circumference
+    equation
+
+    Raises
+    ======
+
+    GeometryError
+        When the given equation is not that of a circle.
+        When trying to construct circle from incorrect parameters.
+
+    See Also
+    ========
+
+    Ellipse, sympy.geometry.point.Point
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Circle, Eq
+    >>> from sympy.abc import x, y, a, b
+
+    A circle constructed from a center and radius:
+
+    >>> c1 = Circle(Point(0, 0), 5)
+    >>> c1.hradius, c1.vradius, c1.radius
+    (5, 5, 5)
+
+    A circle constructed from three points:
+
+    >>> c2 = Circle(Point(0, 0), Point(1, 1), Point(1, 0))
+    >>> c2.hradius, c2.vradius, c2.radius, c2.center
+    (sqrt(2)/2, sqrt(2)/2, sqrt(2)/2, Point2D(1/2, 1/2))
+
+    A circle can be constructed from an equation in the form
+    `ax^2 + by^2 + gx + hy + c = 0`, too:
+
+    >>> Circle(x**2 + y**2 - 25)
+    Circle(Point2D(0, 0), 5)
+
+    If the variables corresponding to x and y are named something
+    else, their name or symbol can be supplied:
+
+    >>> Circle(Eq(a**2 + b**2, 25), x='a', y=b)
+    Circle(Point2D(0, 0), 5)
+    """
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+        if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+            x = kwargs.get('x', 'x')
+            y = kwargs.get('y', 'y')
+            equation = args[0].expand()
+            if isinstance(equation, Eq):
+                equation = equation.lhs - equation.rhs
+            x = find(x, equation)
+            y = find(y, equation)
+
+            try:
+                a, b, c, d, e = linear_coeffs(equation, x**2, y**2, x, y)
+            except ValueError:
+                raise GeometryError("The given equation is not that of a circle.")
+
+            if S.Zero in (a, b) or a != b:
+                raise GeometryError("The given equation is not that of a circle.")
+
+            center_x = -c/a/2
+            center_y = -d/b/2
+            r2 = (center_x**2) + (center_y**2) - e/a
+
+            return Circle((center_x, center_y), sqrt(r2), evaluate=evaluate)
+
+        else:
+            c, r = None, None
+            if len(args) == 3:
+                args = [Point(a, dim=2, evaluate=evaluate) for a in args]
+                t = Triangle(*args)
+                if not isinstance(t, Triangle):
+                    return t
+                c = t.circumcenter
+                r = t.circumradius
+            elif len(args) == 2:
+                # Assume (center, radius) pair
+                c = Point(args[0], dim=2, evaluate=evaluate)
+                r = args[1]
+                # this will prohibit imaginary radius
+                try:
+                    r = Point(r, 0, evaluate=evaluate).x
+                except ValueError:
+                    raise GeometryError("Circle with imaginary radius is not permitted")
+
+            if not (c is None or r is None):
+                if r == 0:
+                    return c
+                return GeometryEntity.__new__(cls, c, r, **kwargs)
+
+            raise GeometryError("Circle.__new__ received unknown arguments")
+
+    def _eval_evalf(self, prec=15, **options):
+        pt, r = self.args
+        dps = prec_to_dps(prec)
+        pt = pt.evalf(n=dps, **options)
+        r = r.evalf(n=dps, **options)
+        return self.func(pt, r, evaluate=False)
+
+    @property
+    def circumference(self):
+        """The circumference of the circle.
+
+        Returns
+        =======
+
+        circumference : number or SymPy expression
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Circle
+        >>> c1 = Circle(Point(3, 4), 6)
+        >>> c1.circumference
+        12*pi
+
+        """
+        return 2 * S.Pi * self.radius
+
+    def equation(self, x='x', y='y'):
+        """The equation of the circle.
+
+        Parameters
+        ==========
+
+        x : str or Symbol, optional
+            Default value is 'x'.
+        y : str or Symbol, optional
+            Default value is 'y'.
+
+        Returns
+        =======
+
+        equation : SymPy expression
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Circle
+        >>> c1 = Circle(Point(0, 0), 5)
+        >>> c1.equation()
+        x**2 + y**2 - 25
+
+        """
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+        t1 = (x - self.center.x)**2
+        t2 = (y - self.center.y)**2
+        return t1 + t2 - self.major**2
+
+    def intersection(self, o):
+        """The intersection of this circle with another geometrical entity.
+
+        Parameters
+        ==========
+
+        o : GeometryEntity
+
+        Returns
+        =======
+
+        intersection : list of GeometryEntities
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Circle, Line, Ray
+        >>> p1, p2, p3 = Point(0, 0), Point(5, 5), Point(6, 0)
+        >>> p4 = Point(5, 0)
+        >>> c1 = Circle(p1, 5)
+        >>> c1.intersection(p2)
+        []
+        >>> c1.intersection(p4)
+        [Point2D(5, 0)]
+        >>> c1.intersection(Ray(p1, p2))
+        [Point2D(5*sqrt(2)/2, 5*sqrt(2)/2)]
+        >>> c1.intersection(Line(p2, p3))
+        []
+
+        """
+        return Ellipse.intersection(self, o)
+
+    @property
+    def radius(self):
+        """The radius of the circle.
+
+        Returns
+        =======
+
+        radius : number or SymPy expression
+
+        See Also
+        ========
+
+        Ellipse.major, Ellipse.minor, Ellipse.hradius, Ellipse.vradius
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Circle
+        >>> c1 = Circle(Point(3, 4), 6)
+        >>> c1.radius
+        6
+
+        """
+        return self.args[1]
+
+    def reflect(self, line):
+        """Override GeometryEntity.reflect since the radius
+        is not a GeometryEntity.
+
+        Examples
+        ========
+
+        >>> from sympy import Circle, Line
+        >>> Circle((0, 1), 1).reflect(Line((0, 0), (1, 1)))
+        Circle(Point2D(1, 0), -1)
+        """
+        c = self.center
+        c = c.reflect(line)
+        return self.func(c, -self.radius)
+
+    def scale(self, x=1, y=1, pt=None):
+        """Override GeometryEntity.scale since the radius
+        is not a GeometryEntity.
+
+        Examples
+        ========
+
+        >>> from sympy import Circle
+        >>> Circle((0, 0), 1).scale(2, 2)
+        Circle(Point2D(0, 0), 2)
+        >>> Circle((0, 0), 1).scale(2, 4)
+        Ellipse(Point2D(0, 0), 2, 4)
+        """
+        c = self.center
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        c = c.scale(x, y)
+        x, y = [abs(i) for i in (x, y)]
+        if x == y:
+            return self.func(c, x*self.radius)
+        h = v = self.radius
+        return Ellipse(c, hradius=h*x, vradius=v*y)
+
+    @property
+    def vradius(self):
+        """
+        This Ellipse property is an alias for the Circle's radius.
+
+        Whereas hradius, major and minor can use Ellipse's conventions,
+        the vradius does not exist for a circle. It is always a positive
+        value in order that the Circle, like Polygons, will have an
+        area that can be positive or negative as determined by the sign
+        of the hradius.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Circle
+        >>> c1 = Circle(Point(3, 4), 6)
+        >>> c1.vradius
+        6
+        """
+        return abs(self.radius)
+
+
+from .polygon import Polygon, Triangle
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/entity.py b/.venv/lib/python3.12/site-packages/sympy/geometry/entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..5ea1e807542c43eb955c2d778cec0f101d78bdce
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/entity.py
@@ -0,0 +1,641 @@
+"""The definition of the base geometrical entity with attributes common to
+all derived geometrical entities.
+
+Contains
+========
+
+GeometryEntity
+GeometricSet
+
+Notes
+=====
+
+A GeometryEntity is any object that has special geometric properties.
+A GeometrySet is a superclass of any GeometryEntity that can also
+be viewed as a sympy.sets.Set.  In particular, points are the only
+GeometryEntity not considered a Set.
+
+Rn is a GeometrySet representing n-dimensional Euclidean space. R2 and
+R3 are currently the only ambient spaces implemented.
+
+"""
+from __future__ import annotations
+
+from sympy.core.basic import Basic
+from sympy.core.containers import Tuple
+from sympy.core.evalf import EvalfMixin, N
+from sympy.core.numbers import oo
+from sympy.core.symbol import Dummy
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.trigonometric import cos, sin, atan
+from sympy.matrices import eye
+from sympy.multipledispatch import dispatch
+from sympy.printing import sstr
+from sympy.sets import Set, Union, FiniteSet
+from sympy.sets.handlers.intersection import intersection_sets
+from sympy.sets.handlers.union import union_sets
+from sympy.solvers.solvers import solve
+from sympy.utilities.misc import func_name
+from sympy.utilities.iterables import is_sequence
+
+
+# How entities are ordered; used by __cmp__ in GeometryEntity
+ordering_of_classes = [
+    "Point2D",
+    "Point3D",
+    "Point",
+    "Segment2D",
+    "Ray2D",
+    "Line2D",
+    "Segment3D",
+    "Line3D",
+    "Ray3D",
+    "Segment",
+    "Ray",
+    "Line",
+    "Plane",
+    "Triangle",
+    "RegularPolygon",
+    "Polygon",
+    "Circle",
+    "Ellipse",
+    "Curve",
+    "Parabola"
+]
+
+
+x, y = [Dummy('entity_dummy') for i in range(2)]
+T = Dummy('entity_dummy', real=True)
+
+
+class GeometryEntity(Basic, EvalfMixin):
+    """The base class for all geometrical entities.
+
+    This class does not represent any particular geometric entity, it only
+    provides the implementation of some methods common to all subclasses.
+
+    """
+
+    __slots__: tuple[str, ...] = ()
+
+    def __cmp__(self, other):
+        """Comparison of two GeometryEntities."""
+        n1 = self.__class__.__name__
+        n2 = other.__class__.__name__
+        c = (n1 > n2) - (n1 < n2)
+        if not c:
+            return 0
+
+        i1 = -1
+        for cls in self.__class__.__mro__:
+            try:
+                i1 = ordering_of_classes.index(cls.__name__)
+                break
+            except ValueError:
+                i1 = -1
+        if i1 == -1:
+            return c
+
+        i2 = -1
+        for cls in other.__class__.__mro__:
+            try:
+                i2 = ordering_of_classes.index(cls.__name__)
+                break
+            except ValueError:
+                i2 = -1
+        if i2 == -1:
+            return c
+
+        return (i1 > i2) - (i1 < i2)
+
+    def __contains__(self, other):
+        """Subclasses should implement this method for anything more complex than equality."""
+        if type(self) is type(other):
+            return self == other
+        raise NotImplementedError()
+
+    def __getnewargs__(self):
+        """Returns a tuple that will be passed to __new__ on unpickling."""
+        return tuple(self.args)
+
+    def __ne__(self, o):
+        """Test inequality of two geometrical entities."""
+        return not self == o
+
+    def __new__(cls, *args, **kwargs):
+        # Points are sequences, but they should not
+        # be converted to Tuples, so use this detection function instead.
+        def is_seq_and_not_point(a):
+            # we cannot use isinstance(a, Point) since we cannot import Point
+            if hasattr(a, 'is_Point') and a.is_Point:
+                return False
+            return is_sequence(a)
+
+        args = [Tuple(*a) if is_seq_and_not_point(a) else sympify(a) for a in args]
+        return Basic.__new__(cls, *args)
+
+    def __radd__(self, a):
+        """Implementation of reverse add method."""
+        return a.__add__(self)
+
+    def __rtruediv__(self, a):
+        """Implementation of reverse division method."""
+        return a.__truediv__(self)
+
+    def __repr__(self):
+        """String representation of a GeometryEntity that can be evaluated
+        by sympy."""
+        return type(self).__name__ + repr(self.args)
+
+    def __rmul__(self, a):
+        """Implementation of reverse multiplication method."""
+        return a.__mul__(self)
+
+    def __rsub__(self, a):
+        """Implementation of reverse subtraction method."""
+        return a.__sub__(self)
+
+    def __str__(self):
+        """String representation of a GeometryEntity."""
+        return type(self).__name__ + sstr(self.args)
+
+    def _eval_subs(self, old, new):
+        from sympy.geometry.point import Point, Point3D
+        if is_sequence(old) or is_sequence(new):
+            if isinstance(self, Point3D):
+                old = Point3D(old)
+                new = Point3D(new)
+            else:
+                old = Point(old)
+                new = Point(new)
+            return  self._subs(old, new)
+
+    def _repr_svg_(self):
+        """SVG representation of a GeometryEntity suitable for IPython"""
+
+        try:
+            bounds = self.bounds
+        except (NotImplementedError, TypeError):
+            # if we have no SVG representation, return None so IPython
+            # will fall back to the next representation
+            return None
+
+        if not all(x.is_number and x.is_finite for x in bounds):
+            return None
+
+        svg_top = '''
+            
+                
+                    
+                
+                
+                    
+                
+                
+                    
+                
+            '''
+
+        # Establish SVG canvas that will fit all the data + small space
+        xmin, ymin, xmax, ymax = map(N, bounds)
+        if xmin == xmax and ymin == ymax:
+            # This is a point; buffer using an arbitrary size
+            xmin, ymin, xmax, ymax = xmin - .5, ymin -.5, xmax + .5, ymax + .5
+        else:
+            # Expand bounds by a fraction of the data ranges
+            expand = 0.1  # or 10%; this keeps arrowheads in view (R plots use 4%)
+            widest_part = max([xmax - xmin, ymax - ymin])
+            expand_amount = widest_part * expand
+            xmin -= expand_amount
+            ymin -= expand_amount
+            xmax += expand_amount
+            ymax += expand_amount
+        dx = xmax - xmin
+        dy = ymax - ymin
+        width = min([max([100., dx]), 300])
+        height = min([max([100., dy]), 300])
+
+        scale_factor = 1. if max(width, height) == 0 else max(dx, dy) / max(width, height)
+        try:
+            svg = self._svg(scale_factor)
+        except (NotImplementedError, TypeError):
+            # if we have no SVG representation, return None so IPython
+            # will fall back to the next representation
+            return None
+
+        view_box = "{} {} {} {}".format(xmin, ymin, dx, dy)
+        transform = "matrix(1,0,0,-1,0,{})".format(ymax + ymin)
+        svg_top = svg_top.format(view_box, width, height)
+
+        return svg_top + (
+            '{}'
+            ).format(transform, svg)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the GeometryEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        raise NotImplementedError()
+
+    def _sympy_(self):
+        return self
+
+    @property
+    def ambient_dimension(self):
+        """What is the dimension of the space that the object is contained in?"""
+        raise NotImplementedError()
+
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+
+        raise NotImplementedError()
+
+    def encloses(self, o):
+        """
+        Return True if o is inside (not on or outside) the boundaries of self.
+
+        The object will be decomposed into Points and individual Entities need
+        only define an encloses_point method for their class.
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Ellipse.encloses_point
+        sympy.geometry.polygon.Polygon.encloses_point
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point, Polygon
+        >>> t  = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+        >>> t2 = Polygon(*RegularPolygon(Point(0, 0), 2, 3).vertices)
+        >>> t2.encloses(t)
+        True
+        >>> t.encloses(t2)
+        False
+
+        """
+
+        from sympy.geometry.point import Point
+        from sympy.geometry.line import Segment, Ray, Line
+        from sympy.geometry.ellipse import Ellipse
+        from sympy.geometry.polygon import Polygon, RegularPolygon
+
+        if isinstance(o, Point):
+            return self.encloses_point(o)
+        elif isinstance(o, Segment):
+            return all(self.encloses_point(x) for x in o.points)
+        elif isinstance(o, (Ray, Line)):
+            return False
+        elif isinstance(o, Ellipse):
+            return self.encloses_point(o.center) and \
+                self.encloses_point(
+                Point(o.center.x + o.hradius, o.center.y)) and \
+                not self.intersection(o)
+        elif isinstance(o, Polygon):
+            if isinstance(o, RegularPolygon):
+                if not self.encloses_point(o.center):
+                    return False
+            return all(self.encloses_point(v) for v in o.vertices)
+        raise NotImplementedError()
+
+    def equals(self, o):
+        return self == o
+
+    def intersection(self, o):
+        """
+        Returns a list of all of the intersections of self with o.
+
+        Notes
+        =====
+
+        An entity is not required to implement this method.
+
+        If two different types of entities can intersect, the item with
+        higher index in ordering_of_classes should implement
+        intersections with anything having a lower index.
+
+        See Also
+        ========
+
+        sympy.geometry.util.intersection
+
+        """
+        raise NotImplementedError()
+
+    def is_similar(self, other):
+        """Is this geometrical entity similar to another geometrical entity?
+
+        Two entities are similar if a uniform scaling (enlarging or
+        shrinking) of one of the entities will allow one to obtain the other.
+
+        Notes
+        =====
+
+        This method is not intended to be used directly but rather
+        through the `are_similar` function found in util.py.
+        An entity is not required to implement this method.
+        If two different types of entities can be similar, it is only
+        required that one of them be able to determine this.
+
+        See Also
+        ========
+
+        scale
+
+        """
+        raise NotImplementedError()
+
+    def reflect(self, line):
+        """
+        Reflects an object across a line.
+
+        Parameters
+        ==========
+
+        line: Line
+
+        Examples
+        ========
+
+        >>> from sympy import pi, sqrt, Line, RegularPolygon
+        >>> l = Line((0, pi), slope=sqrt(2))
+        >>> pent = RegularPolygon((1, 2), 1, 5)
+        >>> rpent = pent.reflect(l)
+        >>> rpent
+        RegularPolygon(Point2D(-2*sqrt(2)*pi/3 - 1/3 + 4*sqrt(2)/3, 2/3 + 2*sqrt(2)/3 + 2*pi/3), -1, 5, -atan(2*sqrt(2)) + 3*pi/5)
+
+        >>> from sympy import pi, Line, Circle, Point
+        >>> l = Line((0, pi), slope=1)
+        >>> circ = Circle(Point(0, 0), 5)
+        >>> rcirc = circ.reflect(l)
+        >>> rcirc
+        Circle(Point2D(-pi, pi), -5)
+
+        """
+        from sympy.geometry.point import Point
+
+        g = self
+        l = line
+        o = Point(0, 0)
+        if l.slope.is_zero:
+            v = l.args[0].y
+            if not v:  # x-axis
+                return g.scale(y=-1)
+            reps = [(p, p.translate(y=2*(v - p.y))) for p in g.atoms(Point)]
+        elif l.slope is oo:
+            v = l.args[0].x
+            if not v:  # y-axis
+                return g.scale(x=-1)
+            reps = [(p, p.translate(x=2*(v - p.x))) for p in g.atoms(Point)]
+        else:
+            if not hasattr(g, 'reflect') and not all(
+                    isinstance(arg, Point) for arg in g.args):
+                raise NotImplementedError(
+                    'reflect undefined or non-Point args in %s' % g)
+            a = atan(l.slope)
+            c = l.coefficients
+            d = -c[-1]/c[1]  # y-intercept
+            # apply the transform to a single point
+            xf = Point(x, y)
+            xf = xf.translate(y=-d).rotate(-a, o).scale(y=-1
+                ).rotate(a, o).translate(y=d)
+            # replace every point using that transform
+            reps = [(p, xf.xreplace({x: p.x, y: p.y})) for p in g.atoms(Point)]
+        return g.xreplace(dict(reps))
+
+    def rotate(self, angle, pt=None):
+        """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+        The default pt is the origin, Point(0, 0)
+
+        See Also
+        ========
+
+        scale, translate
+
+        Examples
+        ========
+
+        >>> from sympy import Point, RegularPolygon, Polygon, pi
+        >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+        >>> t # vertex on x axis
+        Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+        >>> t.rotate(pi/2) # vertex on y axis now
+        Triangle(Point2D(0, 1), Point2D(-sqrt(3)/2, -1/2), Point2D(sqrt(3)/2, -1/2))
+
+        """
+        newargs = []
+        for a in self.args:
+            if isinstance(a, GeometryEntity):
+                newargs.append(a.rotate(angle, pt))
+            else:
+                newargs.append(a)
+        return type(self)(*newargs)
+
+    def scale(self, x=1, y=1, pt=None):
+        """Scale the object by multiplying the x,y-coordinates by x and y.
+
+        If pt is given, the scaling is done relative to that point; the
+        object is shifted by -pt, scaled, and shifted by pt.
+
+        See Also
+        ========
+
+        rotate, translate
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point, Polygon
+        >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+        >>> t
+        Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+        >>> t.scale(2)
+        Triangle(Point2D(2, 0), Point2D(-1, sqrt(3)/2), Point2D(-1, -sqrt(3)/2))
+        >>> t.scale(2, 2)
+        Triangle(Point2D(2, 0), Point2D(-1, sqrt(3)), Point2D(-1, -sqrt(3)))
+
+        """
+        from sympy.geometry.point import Point
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        return type(self)(*[a.scale(x, y) for a in self.args])  # if this fails, override this class
+
+    def translate(self, x=0, y=0):
+        """Shift the object by adding to the x,y-coordinates the values x and y.
+
+        See Also
+        ========
+
+        rotate, scale
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point, Polygon
+        >>> t = Polygon(*RegularPolygon(Point(0, 0), 1, 3).vertices)
+        >>> t
+        Triangle(Point2D(1, 0), Point2D(-1/2, sqrt(3)/2), Point2D(-1/2, -sqrt(3)/2))
+        >>> t.translate(2)
+        Triangle(Point2D(3, 0), Point2D(3/2, sqrt(3)/2), Point2D(3/2, -sqrt(3)/2))
+        >>> t.translate(2, 2)
+        Triangle(Point2D(3, 2), Point2D(3/2, sqrt(3)/2 + 2), Point2D(3/2, 2 - sqrt(3)/2))
+
+        """
+        newargs = []
+        for a in self.args:
+            if isinstance(a, GeometryEntity):
+                newargs.append(a.translate(x, y))
+            else:
+                newargs.append(a)
+        return self.func(*newargs)
+
+    def parameter_value(self, other, t):
+        """Return the parameter corresponding to the given point.
+        Evaluating an arbitrary point of the entity at this parameter
+        value will return the given point.
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Point
+        >>> from sympy.abc import t
+        >>> a = Point(0, 0)
+        >>> b = Point(2, 2)
+        >>> Line(a, b).parameter_value((1, 1), t)
+        {t: 1/2}
+        >>> Line(a, b).arbitrary_point(t).subs(_)
+        Point2D(1, 1)
+        """
+        from sympy.geometry.point import Point
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if not isinstance(other, Point):
+            raise ValueError("other must be a point")
+        sol = solve(self.arbitrary_point(T) - other, T, dict=True)
+        if not sol:
+            raise ValueError("Given point is not on %s" % func_name(self))
+        return {t: sol[0][T]}
+
+
+class GeometrySet(GeometryEntity, Set):
+    """Parent class of all GeometryEntity that are also Sets
+    (compatible with sympy.sets)
+    """
+    __slots__ = ()
+
+    def _contains(self, other):
+        """sympy.sets uses the _contains method, so include it for compatibility."""
+
+        if isinstance(other, Set) and other.is_FiniteSet:
+            return all(self.__contains__(i) for i in other)
+
+        return self.__contains__(other)
+
+@dispatch(GeometrySet, Set)  # type:ignore # noqa:F811
+def union_sets(self, o): # noqa:F811
+    """ Returns the union of self and o
+    for use with sympy.sets.Set, if possible. """
+
+
+    # if its a FiniteSet, merge any points
+    # we contain and return a union with the rest
+    if o.is_FiniteSet:
+        other_points = [p for p in o if not self._contains(p)]
+        if len(other_points) == len(o):
+            return None
+        return Union(self, FiniteSet(*other_points))
+    if self._contains(o):
+        return self
+    return None
+
+
+@dispatch(GeometrySet, Set)  # type: ignore # noqa:F811
+def intersection_sets(self, o): # noqa:F811
+    """ Returns a sympy.sets.Set of intersection objects,
+    if possible. """
+
+    from sympy.geometry.point import Point
+
+    try:
+        # if o is a FiniteSet, find the intersection directly
+        # to avoid infinite recursion
+        if o.is_FiniteSet:
+            inter = FiniteSet(*(p for p in o if self.contains(p)))
+        else:
+            inter = self.intersection(o)
+    except NotImplementedError:
+        # sympy.sets.Set.reduce expects None if an object
+        # doesn't know how to simplify
+        return None
+
+    # put the points in a FiniteSet
+    points = FiniteSet(*[p for p in inter if isinstance(p, Point)])
+    non_points = [p for p in inter if not isinstance(p, Point)]
+
+    return Union(*(non_points + [points]))
+
+def translate(x, y):
+    """Return the matrix to translate a 2-D point by x and y."""
+    rv = eye(3)
+    rv[2, 0] = x
+    rv[2, 1] = y
+    return rv
+
+
+def scale(x, y, pt=None):
+    """Return the matrix to multiply a 2-D point's coordinates by x and y.
+
+    If pt is given, the scaling is done relative to that point."""
+    rv = eye(3)
+    rv[0, 0] = x
+    rv[1, 1] = y
+    if pt:
+        from sympy.geometry.point import Point
+        pt = Point(pt, dim=2)
+        tr1 = translate(*(-pt).args)
+        tr2 = translate(*pt.args)
+        return tr1*rv*tr2
+    return rv
+
+
+def rotate(th):
+    """Return the matrix to rotate a 2-D point about the origin by ``angle``.
+
+    The angle is measured in radians. To Point a point about a point other
+    then the origin, translate the Point, do the rotation, and
+    translate it back:
+
+    >>> from sympy.geometry.entity import rotate, translate
+    >>> from sympy import Point, pi
+    >>> rot_about_11 = translate(-1, -1)*rotate(pi/2)*translate(1, 1)
+    >>> Point(1, 1).transform(rot_about_11)
+    Point2D(1, 1)
+    >>> Point(0, 0).transform(rot_about_11)
+    Point2D(2, 0)
+    """
+    s = sin(th)
+    rv = eye(3)*cos(th)
+    rv[0, 1] = s
+    rv[1, 0] = -s
+    rv[2, 2] = 1
+    return rv
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/exceptions.py b/.venv/lib/python3.12/site-packages/sympy/geometry/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..41d97af718de2cebad3accefcd60e43ccf74a3f6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/exceptions.py
@@ -0,0 +1,5 @@
+"""Geometry Errors."""
+
+class GeometryError(ValueError):
+    """An exception raised by classes in the geometry module."""
+    pass
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/line.py b/.venv/lib/python3.12/site-packages/sympy/geometry/line.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed73d43d0c9581f9d51f299cf4425acb11958e57
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/line.py
@@ -0,0 +1,2877 @@
+"""Line-like geometrical entities.
+
+Contains
+========
+LinearEntity
+Line
+Ray
+Segment
+LinearEntity2D
+Line2D
+Ray2D
+Segment2D
+LinearEntity3D
+Line3D
+Ray3D
+Segment3D
+
+"""
+
+from sympy.core.containers import Tuple
+from sympy.core.evalf import N
+from sympy.core.expr import Expr
+from sympy.core.numbers import Rational, oo, Float
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, Dummy, uniquely_named_symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import (_pi_coeff, acos, tan, atan2)
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .point import Point, Point3D
+from .util import find, intersection
+from sympy.logic.boolalg import And
+from sympy.matrices import Matrix
+from sympy.sets.sets import Intersection
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.solvers.solveset import linear_coeffs
+from sympy.utilities.misc import Undecidable, filldedent
+
+
+import random
+
+
+t, u = [Dummy('line_dummy') for i in range(2)]
+
+
+class LinearEntity(GeometrySet):
+    """A base class for all linear entities (Line, Ray and Segment)
+    in n-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    ambient_dimension
+    direction
+    length
+    p1
+    p2
+    points
+
+    Notes
+    =====
+
+    This is an abstract class and is not meant to be instantiated.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity
+
+    """
+    def __new__(cls, p1, p2=None, **kwargs):
+        p1, p2 = Point._normalize_dimension(p1, p2)
+        if p1 == p2:
+            # sometimes we return a single point if we are not given two unique
+            # points. This is done in the specific subclass
+            raise ValueError(
+                "%s.__new__ requires two unique Points." % cls.__name__)
+        if len(p1) != len(p2):
+            raise ValueError(
+                "%s.__new__ requires two Points of equal dimension." % cls.__name__)
+
+        return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+    def __contains__(self, other):
+        """Return a definitive answer or else raise an error if it cannot
+        be determined that other is on the boundaries of self."""
+        result = self.contains(other)
+
+        if result is not None:
+            return result
+        else:
+            raise Undecidable(
+                "Cannot decide whether '%s' contains '%s'" % (self, other))
+
+    def _span_test(self, other):
+        """Test whether the point `other` lies in the positive span of `self`.
+        A point x is 'in front' of a point y if x.dot(y) >= 0.  Return
+        -1 if `other` is behind `self.p1`, 0 if `other` is `self.p1` and
+        and 1 if `other` is in front of `self.p1`."""
+        if self.p1 == other:
+            return 0
+
+        rel_pos = other - self.p1
+        d = self.direction
+        if d.dot(rel_pos) > 0:
+            return 1
+        return -1
+
+    @property
+    def ambient_dimension(self):
+        """A property method that returns the dimension of LinearEntity
+        object.
+
+        Parameters
+        ==========
+
+        p1 : LinearEntity
+
+        Returns
+        =======
+
+        dimension : integer
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.ambient_dimension
+        2
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.ambient_dimension
+        3
+
+        """
+        return len(self.p1)
+
+    def angle_between(l1, l2):
+        """Return the non-reflex angle formed by rays emanating from
+        the origin with directions the same as the direction vectors
+        of the linear entities.
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Notes
+        =====
+
+        From the dot product of vectors v1 and v2 it is known that:
+
+            ``dot(v1, v2) = |v1|*|v2|*cos(A)``
+
+        where A is the angle formed between the two vectors. We can
+        get the directional vectors of the two lines and readily
+        find the angle between the two using the above formula.
+
+        See Also
+        ========
+
+        is_perpendicular, Ray2D.closing_angle
+
+        Examples
+        ========
+
+        >>> from sympy import Line
+        >>> e = Line((0, 0), (1, 0))
+        >>> ne = Line((0, 0), (1, 1))
+        >>> sw = Line((1, 1), (0, 0))
+        >>> ne.angle_between(e)
+        pi/4
+        >>> sw.angle_between(e)
+        3*pi/4
+
+        To obtain the non-obtuse angle at the intersection of lines, use
+        the ``smallest_angle_between`` method:
+
+        >>> sw.smallest_angle_between(e)
+        pi/4
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+        >>> l1.angle_between(l2)
+        acos(-sqrt(2)/3)
+        >>> l1.smallest_angle_between(l2)
+        acos(sqrt(2)/3)
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        v1, v2 = l1.direction, l2.direction
+        return acos(v1.dot(v2)/(abs(v1)*abs(v2)))
+
+    def smallest_angle_between(l1, l2):
+        """Return the smallest angle formed at the intersection of the
+        lines containing the linear entities.
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(0, 4), Point(2, -2)
+        >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+        >>> l1.smallest_angle_between(l2)
+        pi/4
+
+        See Also
+        ========
+
+        angle_between, is_perpendicular, Ray2D.closing_angle
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        v1, v2 = l1.direction, l2.direction
+        return acos(abs(v1.dot(v2))/(abs(v1)*abs(v2)))
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the Line.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            The name of the parameter which will be used for the parametric
+            point. The default value is 't'. When this parameter is 0, the
+            first point used to define the line will be returned, and when
+            it is 1 the second point will be returned.
+
+        Returns
+        =======
+
+        point : Point
+
+        Raises
+        ======
+
+        ValueError
+            When ``parameter`` already appears in the Line's definition.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.arbitrary_point()
+        Point2D(4*t + 1, 3*t)
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 1)
+        >>> l1 = Line3D(p1, p2)
+        >>> l1.arbitrary_point()
+        Point3D(4*t + 1, 3*t, t)
+
+        """
+        t = _symbol(parameter, real=True)
+        if t.name in (f.name for f in self.free_symbols):
+            raise ValueError(filldedent('''
+                Symbol %s already appears in object
+                and cannot be used as a parameter.
+                ''' % t.name))
+        # multiply on the right so the variable gets
+        # combined with the coordinates of the point
+        return self.p1 + (self.p2 - self.p1)*t
+
+    @staticmethod
+    def are_concurrent(*lines):
+        """Is a sequence of linear entities concurrent?
+
+        Two or more linear entities are concurrent if they all
+        intersect at a single point.
+
+        Parameters
+        ==========
+
+        lines
+            A sequence of linear entities.
+
+        Returns
+        =======
+
+        True : if the set of linear entities intersect in one point
+        False : otherwise.
+
+        See Also
+        ========
+
+        sympy.geometry.util.intersection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> p3, p4 = Point(-2, -2), Point(0, 2)
+        >>> l1, l2, l3 = Line(p1, p2), Line(p1, p3), Line(p1, p4)
+        >>> Line.are_concurrent(l1, l2, l3)
+        True
+        >>> l4 = Line(p2, p3)
+        >>> Line.are_concurrent(l2, l3, l4)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 5, 2)
+        >>> p3, p4 = Point3D(-2, -2, -2), Point3D(0, 2, 1)
+        >>> l1, l2, l3 = Line3D(p1, p2), Line3D(p1, p3), Line3D(p1, p4)
+        >>> Line3D.are_concurrent(l1, l2, l3)
+        True
+        >>> l4 = Line3D(p2, p3)
+        >>> Line3D.are_concurrent(l2, l3, l4)
+        False
+
+        """
+        common_points = Intersection(*lines)
+        if common_points.is_FiniteSet and len(common_points) == 1:
+            return True
+        return False
+
+    def contains(self, other):
+        """Subclasses should implement this method and should return
+            True if other is on the boundaries of self;
+            False if not on the boundaries of self;
+            None if a determination cannot be made."""
+        raise NotImplementedError()
+
+    @property
+    def direction(self):
+        """The direction vector of the LinearEntity.
+
+        Returns
+        =======
+
+        p : a Point; the ray from the origin to this point is the
+            direction of `self`
+
+        Examples
+        ========
+
+        >>> from sympy import Line
+        >>> a, b = (1, 1), (1, 3)
+        >>> Line(a, b).direction
+        Point2D(0, 2)
+        >>> Line(b, a).direction
+        Point2D(0, -2)
+
+        This can be reported so the distance from the origin is 1:
+
+        >>> Line(b, a).direction.unit
+        Point2D(0, -1)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.unit
+
+        """
+        return self.p2 - self.p1
+
+    def intersection(self, other):
+        """The intersection with another geometrical entity.
+
+        Parameters
+        ==========
+
+        o : Point or LinearEntity
+
+        Returns
+        =======
+
+        intersection : list of geometrical entities
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Segment
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(7, 7)
+        >>> l1 = Line(p1, p2)
+        >>> l1.intersection(p3)
+        [Point2D(7, 7)]
+        >>> p4, p5 = Point(5, 0), Point(0, 3)
+        >>> l2 = Line(p4, p5)
+        >>> l1.intersection(l2)
+        [Point2D(15/8, 15/8)]
+        >>> p6, p7 = Point(0, 5), Point(2, 6)
+        >>> s1 = Segment(p6, p7)
+        >>> l1.intersection(s1)
+        []
+        >>> from sympy import Point3D, Line3D, Segment3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(7, 7, 7)
+        >>> l1 = Line3D(p1, p2)
+        >>> l1.intersection(p3)
+        [Point3D(7, 7, 7)]
+        >>> l1 = Line3D(Point3D(4,19,12), Point3D(5,25,17))
+        >>> l2 = Line3D(Point3D(-3, -15, -19), direction_ratio=[2,8,8])
+        >>> l1.intersection(l2)
+        [Point3D(1, 1, -3)]
+        >>> p6, p7 = Point3D(0, 5, 2), Point3D(2, 6, 3)
+        >>> s1 = Segment3D(p6, p7)
+        >>> l1.intersection(s1)
+        []
+
+        """
+        def intersect_parallel_rays(ray1, ray2):
+            if ray1.direction.dot(ray2.direction) > 0:
+                # rays point in the same direction
+                # so return the one that is "in front"
+                return [ray2] if ray1._span_test(ray2.p1) >= 0 else [ray1]
+            else:
+                # rays point in opposite directions
+                st = ray1._span_test(ray2.p1)
+                if st < 0:
+                    return []
+                elif st == 0:
+                    return [ray2.p1]
+                return [Segment(ray1.p1, ray2.p1)]
+
+        def intersect_parallel_ray_and_segment(ray, seg):
+            st1, st2 = ray._span_test(seg.p1), ray._span_test(seg.p2)
+            if st1 < 0 and st2 < 0:
+                return []
+            elif st1 >= 0 and st2 >= 0:
+                return [seg]
+            elif st1 >= 0:  # st2 < 0:
+                return [Segment(ray.p1, seg.p1)]
+            else:  # st1 < 0 and st2 >= 0:
+                return [Segment(ray.p1, seg.p2)]
+
+        def intersect_parallel_segments(seg1, seg2):
+            if seg1.contains(seg2):
+                return [seg2]
+            if seg2.contains(seg1):
+                return [seg1]
+
+            # direct the segments so they're oriented the same way
+            if seg1.direction.dot(seg2.direction) < 0:
+                seg2 = Segment(seg2.p2, seg2.p1)
+            # order the segments so seg1 is "behind" seg2
+            if seg1._span_test(seg2.p1) < 0:
+                seg1, seg2 = seg2, seg1
+            if seg2._span_test(seg1.p2) < 0:
+                return []
+            return [Segment(seg2.p1, seg1.p2)]
+
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if other.is_Point:
+            if self.contains(other):
+                return [other]
+            else:
+                return []
+        elif isinstance(other, LinearEntity):
+            # break into cases based on whether
+            # the lines are parallel, non-parallel intersecting, or skew
+            pts = Point._normalize_dimension(self.p1, self.p2, other.p1, other.p2)
+            rank = Point.affine_rank(*pts)
+
+            if rank == 1:
+                # we're collinear
+                if isinstance(self, Line):
+                    return [other]
+                if isinstance(other, Line):
+                    return [self]
+
+                if isinstance(self, Ray) and isinstance(other, Ray):
+                    return intersect_parallel_rays(self, other)
+                if isinstance(self, Ray) and isinstance(other, Segment):
+                    return intersect_parallel_ray_and_segment(self, other)
+                if isinstance(self, Segment) and isinstance(other, Ray):
+                    return intersect_parallel_ray_and_segment(other, self)
+                if isinstance(self, Segment) and isinstance(other, Segment):
+                    return intersect_parallel_segments(self, other)
+            elif rank == 2:
+                # we're in the same plane
+                l1 = Line(*pts[:2])
+                l2 = Line(*pts[2:])
+
+                # check to see if we're parallel.  If we are, we can't
+                # be intersecting, since the collinear case was already
+                # handled
+                if l1.direction.is_scalar_multiple(l2.direction):
+                    return []
+
+                # find the intersection as if everything were lines
+                # by solving the equation t*d + p1 == s*d' + p1'
+                m = Matrix([l1.direction, -l2.direction]).transpose()
+                v = Matrix([l2.p1 - l1.p1]).transpose()
+
+                # we cannot use m.solve(v) because that only works for square matrices
+                m_rref, pivots = m.col_insert(2, v).rref(simplify=True)
+                # rank == 2 ensures we have 2 pivots, but let's check anyway
+                if len(pivots) != 2:
+                    raise GeometryError("Failed when solving Mx=b when M={} and b={}".format(m, v))
+                coeff = m_rref[0, 2]
+                line_intersection = l1.direction*coeff + self.p1
+
+                # if both are lines, skip a containment check
+                if isinstance(self, Line) and isinstance(other, Line):
+                    return [line_intersection]
+
+                if ((isinstance(self, Line) or
+                     self.contains(line_intersection)) and
+                        other.contains(line_intersection)):
+                    return [line_intersection]
+                if not self.atoms(Float) and not other.atoms(Float):
+                    # if it can fail when there are no Floats then
+                    # maybe the following parametric check should be
+                    # done
+                    return []
+                # floats may fail exact containment so check that the
+                # arbitrary points, when  equal, both give a
+                # non-negative parameter when the arbitrary point
+                # coordinates are equated
+                tu = solve(self.arbitrary_point(t) - other.arbitrary_point(u),
+                    t, u, dict=True)[0]
+                def ok(p, l):
+                    if isinstance(l, Line):
+                        # p > -oo
+                        return True
+                    if isinstance(l, Ray):
+                        # p >= 0
+                        return p.is_nonnegative
+                    if isinstance(l, Segment):
+                        # 0 <= p <= 1
+                        return p.is_nonnegative and (1 - p).is_nonnegative
+                    raise ValueError("unexpected line type")
+                if ok(tu[t], self) and ok(tu[u], other):
+                    return [line_intersection]
+                return []
+            else:
+                # we're skew
+                return []
+
+        return other.intersection(self)
+
+    def is_parallel(l1, l2):
+        """Are two linear entities parallel?
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        True : if l1 and l2 are parallel,
+        False : otherwise.
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> p3, p4 = Point(3, 4), Point(6, 7)
+        >>> l1, l2 = Line(p1, p2), Line(p3, p4)
+        >>> Line.is_parallel(l1, l2)
+        True
+        >>> p5 = Point(6, 6)
+        >>> l3 = Line(p3, p5)
+        >>> Line.is_parallel(l1, l3)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(3, 4, 5)
+        >>> p3, p4 = Point3D(2, 1, 1), Point3D(8, 9, 11)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p3, p4)
+        >>> Line3D.is_parallel(l1, l2)
+        True
+        >>> p5 = Point3D(6, 6, 6)
+        >>> l3 = Line3D(p3, p5)
+        >>> Line3D.is_parallel(l1, l3)
+        False
+
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        return l1.direction.is_scalar_multiple(l2.direction)
+
+    def is_perpendicular(l1, l2):
+        """Are two linear entities perpendicular?
+
+        Parameters
+        ==========
+
+        l1 : LinearEntity
+        l2 : LinearEntity
+
+        Returns
+        =======
+
+        True : if l1 and l2 are perpendicular,
+        False : otherwise.
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(-1, 1)
+        >>> l1, l2 = Line(p1, p2), Line(p1, p3)
+        >>> l1.is_perpendicular(l2)
+        True
+        >>> p4 = Point(5, 3)
+        >>> l3 = Line(p1, p4)
+        >>> l1.is_perpendicular(l3)
+        False
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(-1, 2, 0)
+        >>> l1, l2 = Line3D(p1, p2), Line3D(p2, p3)
+        >>> l1.is_perpendicular(l2)
+        False
+        >>> p4 = Point3D(5, 3, 7)
+        >>> l3 = Line3D(p1, p4)
+        >>> l1.is_perpendicular(l3)
+        False
+
+        """
+        if not isinstance(l1, LinearEntity) and not isinstance(l2, LinearEntity):
+            raise TypeError('Must pass only LinearEntity objects')
+
+        return S.Zero.equals(l1.direction.dot(l2.direction))
+
+    def is_similar(self, other):
+        """
+        Return True if self and other are contained in the same line.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 1), Point(3, 4), Point(2, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l2 = Line(p1, p3)
+        >>> l1.is_similar(l2)
+        True
+        """
+        l = Line(self.p1, self.p2)
+        return l.contains(other)
+
+    @property
+    def length(self):
+        """
+        The length of the line.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> l1 = Line(p1, p2)
+        >>> l1.length
+        oo
+        """
+        return S.Infinity
+
+    @property
+    def p1(self):
+        """The first defining point of a linear entity.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.p1
+        Point2D(0, 0)
+
+        """
+        return self.args[0]
+
+    @property
+    def p2(self):
+        """The second defining point of a linear entity.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.p2
+        Point2D(5, 3)
+
+        """
+        return self.args[1]
+
+    def parallel_line(self, p):
+        """Create a new Line parallel to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        is_parallel
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+        >>> l1 = Line(p1, p2)
+        >>> l2 = l1.parallel_line(p3)
+        >>> p3 in l2
+        True
+        >>> l1.is_parallel(l2)
+        True
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> l2 = l1.parallel_line(p3)
+        >>> p3 in l2
+        True
+        >>> l1.is_parallel(l2)
+        True
+
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        return Line(p, p + self.direction)
+
+    def perpendicular_line(self, p):
+        """Create a new Line perpendicular to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(2, 3, 4), Point3D(-2, 2, 0)
+        >>> L = Line3D(p1, p2)
+        >>> P = L.perpendicular_line(p3); P
+        Line3D(Point3D(-2, 2, 0), Point3D(4/29, 6/29, 8/29))
+        >>> L.is_perpendicular(P)
+        True
+
+        In 3D the, the first point used to define the line is the point
+        through which the perpendicular was required to pass; the
+        second point is (arbitrarily) contained in the given line:
+
+        >>> P.p2 in L
+        True
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        if p in self:
+            p = p + self.direction.orthogonal_direction
+        return Line(p, self.projection(p))
+
+    def perpendicular_segment(self, p):
+        """Create a perpendicular line segment from `p` to this line.
+
+        The endpoints of the segment are ``p`` and the closest point in
+        the line containing self. (If self is not a line, the point might
+        not be in self.)
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        segment : Segment
+
+        Notes
+        =====
+
+        Returns `p` itself if `p` is on this linear entity.
+
+        See Also
+        ========
+
+        perpendicular_line
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 2)
+        >>> l1 = Line(p1, p2)
+        >>> s1 = l1.perpendicular_segment(p3)
+        >>> l1.is_perpendicular(s1)
+        True
+        >>> p3 in s1
+        True
+        >>> l1.perpendicular_segment(Point(4, 0))
+        Segment2D(Point2D(4, 0), Point2D(2, 2))
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 2, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> s1 = l1.perpendicular_segment(p3)
+        >>> l1.is_perpendicular(s1)
+        True
+        >>> p3 in s1
+        True
+        >>> l1.perpendicular_segment(Point3D(4, 0, 0))
+        Segment3D(Point3D(4, 0, 0), Point3D(4/3, 4/3, 4/3))
+
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        if p in self:
+            return p
+        l = self.perpendicular_line(p)
+        # The intersection should be unique, so unpack the singleton
+        p2, = Intersection(Line(self.p1, self.p2), l)
+
+        return Segment(p, p2)
+
+    @property
+    def points(self):
+        """The two points used to define this linear entity.
+
+        Returns
+        =======
+
+        points : tuple of Points
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 11)
+        >>> l1 = Line(p1, p2)
+        >>> l1.points
+        (Point2D(0, 0), Point2D(5, 11))
+
+        """
+        return (self.p1, self.p2)
+
+    def projection(self, other):
+        """Project a point, line, ray, or segment onto this linear entity.
+
+        Parameters
+        ==========
+
+        other : Point or LinearEntity (Line, Ray, Segment)
+
+        Returns
+        =======
+
+        projection : Point or LinearEntity (Line, Ray, Segment)
+            The return type matches the type of the parameter ``other``.
+
+        Raises
+        ======
+
+        GeometryError
+            When method is unable to perform projection.
+
+        Notes
+        =====
+
+        A projection involves taking the two points that define
+        the linear entity and projecting those points onto a
+        Line and then reforming the linear entity using these
+        projections.
+        A point P is projected onto a line L by finding the point
+        on L that is closest to P. This point is the intersection
+        of L and the line perpendicular to L that passes through P.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, perpendicular_line
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Segment, Rational
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(Rational(1, 2), 0)
+        >>> l1 = Line(p1, p2)
+        >>> l1.projection(p3)
+        Point2D(1/4, 1/4)
+        >>> p4, p5 = Point(10, 0), Point(12, 1)
+        >>> s1 = Segment(p4, p5)
+        >>> l1.projection(s1)
+        Segment2D(Point2D(5, 5), Point2D(13/2, 13/2))
+        >>> p1, p2, p3 = Point(0, 0, 1), Point(1, 1, 2), Point(2, 0, 1)
+        >>> l1 = Line(p1, p2)
+        >>> l1.projection(p3)
+        Point3D(2/3, 2/3, 5/3)
+        >>> p4, p5 = Point(10, 0, 1), Point(12, 1, 3)
+        >>> s1 = Segment(p4, p5)
+        >>> l1.projection(s1)
+        Segment3D(Point3D(10/3, 10/3, 13/3), Point3D(5, 5, 6))
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+
+        def proj_point(p):
+            return Point.project(p - self.p1, self.direction) + self.p1
+
+        if isinstance(other, Point):
+            return proj_point(other)
+        elif isinstance(other, LinearEntity):
+            p1, p2 = proj_point(other.p1), proj_point(other.p2)
+            # test to see if we're degenerate
+            if p1 == p2:
+                return p1
+            projected = other.__class__(p1, p2)
+            projected = Intersection(self, projected)
+            if projected.is_empty:
+                return projected
+            # if we happen to have intersected in only a point, return that
+            if projected.is_FiniteSet and len(projected) == 1:
+                # projected is a set of size 1, so unpack it in `a`
+                a, = projected
+                return a
+            # order args so projection is in the same direction as self
+            if self.direction.dot(projected.direction) < 0:
+                p1, p2 = projected.args
+                projected = projected.func(p2, p1)
+            return projected
+
+        raise GeometryError(
+            "Do not know how to project %s onto %s" % (other, self))
+
+    def random_point(self, seed=None):
+        """A random point on a LinearEntity.
+
+        Returns
+        =======
+
+        point : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line, Ray, Segment
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> line = Line(p1, p2)
+        >>> r = line.random_point(seed=42)  # seed value is optional
+        >>> r.n(3)
+        Point2D(-0.72, -0.432)
+        >>> r in line
+        True
+        >>> Ray(p1, p2).random_point(seed=42).n(3)
+        Point2D(0.72, 0.432)
+        >>> Segment(p1, p2).random_point(seed=42).n(3)
+        Point2D(3.2, 1.92)
+
+        """
+        if seed is not None:
+            rng = random.Random(seed)
+        else:
+            rng = random
+        pt = self.arbitrary_point(t)
+        if isinstance(self, Ray):
+            v = abs(rng.gauss(0, 1))
+        elif isinstance(self, Segment):
+            v = rng.random()
+        elif isinstance(self, Line):
+            v = rng.gauss(0, 1)
+        else:
+            raise NotImplementedError('unhandled line type')
+        return pt.subs(t, Rational(v))
+
+    def bisectors(self, other):
+        """Returns the perpendicular lines which pass through the intersections
+        of self and other that are in the same plane.
+
+        Parameters
+        ==========
+
+        line : Line3D
+
+        Returns
+        =======
+
+        list: two Line instances
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+        >>> r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+        >>> r1.bisectors(r2)
+        [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)), Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+
+        """
+        if not isinstance(other, LinearEntity):
+            raise GeometryError("Expecting LinearEntity, not %s" % other)
+
+        l1, l2 = self, other
+
+        # make sure dimensions match or else a warning will rise from
+        # intersection calculation
+        if l1.p1.ambient_dimension != l2.p1.ambient_dimension:
+            if isinstance(l1, Line2D):
+                l1, l2 = l2, l1
+            _, p1 = Point._normalize_dimension(l1.p1, l2.p1, on_morph='ignore')
+            _, p2 = Point._normalize_dimension(l1.p2, l2.p2, on_morph='ignore')
+            l2 = Line(p1, p2)
+
+        point = intersection(l1, l2)
+
+        # Three cases: Lines may intersect in a point, may be equal or may not intersect.
+        if not point:
+            raise GeometryError("The lines do not intersect")
+        else:
+            pt = point[0]
+            if isinstance(pt, Line):
+                # Intersection is a line because both lines are coincident
+                return [self]
+
+
+        d1 = l1.direction.unit
+        d2 = l2.direction.unit
+
+        bis1 = Line(pt, pt + d1 + d2)
+        bis2 = Line(pt, pt + d1 - d2)
+
+        return [bis1, bis2]
+
+
+class Line(LinearEntity):
+    """An infinite line in space.
+
+    A 2D line is declared with two distinct points, point and slope, or
+    an equation. A 3D line may be defined with a point and a direction ratio.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+    slope : SymPy expression
+    direction_ratio : list
+    equation : equation of a line
+
+    Notes
+    =====
+
+    `Line` will automatically subclass to `Line2D` or `Line3D` based
+    on the dimension of `p1`.  The `slope` argument is only relevant
+    for `Line2D` and the `direction_ratio` argument is only relevant
+    for `Line3D`.
+
+    The order of the points will define the direction of the line
+    which is used when calculating the angle between lines.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line2D
+    sympy.geometry.line.Line3D
+
+    Examples
+    ========
+
+    >>> from sympy import Line, Segment, Point, Eq
+    >>> from sympy.abc import x, y, a, b
+
+    >>> L = Line(Point(2,3), Point(3,5))
+    >>> L
+    Line2D(Point2D(2, 3), Point2D(3, 5))
+    >>> L.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> L.equation()
+    -2*x + y + 1
+    >>> L.coefficients
+    (-2, 1, 1)
+
+    Instantiate with keyword ``slope``:
+
+    >>> Line(Point(0, 0), slope=0)
+    Line2D(Point2D(0, 0), Point2D(1, 0))
+
+    Instantiate with another linear object
+
+    >>> s = Segment((0, 0), (0, 1))
+    >>> Line(s).equation()
+    x
+
+    The line corresponding to an equation in the for `ax + by + c = 0`,
+    can be entered:
+
+    >>> Line(3*x + y + 18)
+    Line2D(Point2D(0, -18), Point2D(1, -21))
+
+    If `x` or `y` has a different name, then they can be specified, too,
+    as a string (to match the name) or symbol:
+
+    >>> Line(Eq(3*a + b, -18), x='a', y=b)
+    Line2D(Point2D(0, -18), Point2D(1, -21))
+    """
+    def __new__(cls, *args, **kwargs):
+        if len(args) == 1 and isinstance(args[0], (Expr, Eq)):
+            missing = uniquely_named_symbol('?', args)
+            if not kwargs:
+                x = 'x'
+                y = 'y'
+            else:
+                x = kwargs.pop('x', missing)
+                y = kwargs.pop('y', missing)
+            if kwargs:
+                raise ValueError('expecting only x and y as keywords')
+
+            equation = args[0]
+            if isinstance(equation, Eq):
+                equation = equation.lhs - equation.rhs
+
+            def find_or_missing(x):
+                try:
+                    return find(x, equation)
+                except ValueError:
+                    return missing
+            x = find_or_missing(x)
+            y = find_or_missing(y)
+
+            a, b, c = linear_coeffs(equation, x, y)
+
+            if b:
+                return Line((0, -c/b), slope=-a/b)
+            if a:
+                return Line((-c/a, 0), slope=oo)
+
+            raise ValueError('not found in equation: %s' % (set('xy') - {x, y}))
+
+        else:
+            if len(args) > 0:
+                p1 = args[0]
+                if len(args) > 1:
+                    p2 = args[1]
+                else:
+                    p2 = None
+
+                if isinstance(p1, LinearEntity):
+                    if p2:
+                        raise ValueError('If p1 is a LinearEntity, p2 must be None.')
+                    dim = len(p1.p1)
+                else:
+                    p1 = Point(p1)
+                    dim = len(p1)
+                    if p2 is not None or isinstance(p2, Point) and p2.ambient_dimension != dim:
+                        p2 = Point(p2)
+
+                if dim == 2:
+                    return Line2D(p1, p2, **kwargs)
+                elif dim == 3:
+                    return Line3D(p1, p2, **kwargs)
+                return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def contains(self, other):
+        """
+        Return True if `other` is on this Line, or False otherwise.
+
+        Examples
+        ========
+
+        >>> from sympy import Line,Point
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> l = Line(p1, p2)
+        >>> l.contains(p1)
+        True
+        >>> l.contains((0, 1))
+        True
+        >>> l.contains((0, 0))
+        False
+        >>> a = (0, 0, 0)
+        >>> b = (1, 1, 1)
+        >>> c = (2, 2, 2)
+        >>> l1 = Line(a, b)
+        >>> l2 = Line(b, a)
+        >>> l1 == l2
+        False
+        >>> l1 in l2
+        True
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            return Point.is_collinear(other, self.p1, self.p2)
+        if isinstance(other, LinearEntity):
+            return Point.is_collinear(self.p1, self.p2, other.p1, other.p2)
+        return False
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between a line and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> s = Line(p1, p2)
+        >>> s.distance(Point(-1, 1))
+        sqrt(2)
+        >>> s.distance((-1, 2))
+        3*sqrt(2)/2
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 1)
+        >>> s = Line(p1, p2)
+        >>> s.distance(Point(-1, 1, 1))
+        2*sqrt(6)/3
+        >>> s.distance((-1, 1, 1))
+        2*sqrt(6)/3
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if self.contains(other):
+            return S.Zero
+        return self.perpendicular_segment(other).length
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        if not isinstance(other, Line):
+            return False
+        return Point.is_collinear(self.p1, other.p1, self.p2, other.p2)
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of line. Gives
+        values that will produce a line that is +/- 5 units long (where a
+        unit is the distance between the two points that define the line).
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list (plot interval)
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.plot_interval()
+        [t, -5, 5]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, -5, 5]
+
+
+class Ray(LinearEntity):
+    """A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point
+        The source of the Ray
+    p2 : Point or radian value
+        This point determines the direction in which the Ray propagates.
+        If given as an angle it is interpreted in radians with the positive
+        direction being ccw.
+
+    Attributes
+    ==========
+
+    source
+
+    See Also
+    ========
+
+    sympy.geometry.line.Ray2D
+    sympy.geometry.line.Ray3D
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line
+
+    Notes
+    =====
+
+    `Ray` will automatically subclass to `Ray2D` or `Ray3D` based on the
+    dimension of `p1`.
+
+    Examples
+    ========
+
+    >>> from sympy import Ray, Point, pi
+    >>> r = Ray(Point(2, 3), Point(3, 5))
+    >>> r
+    Ray2D(Point2D(2, 3), Point2D(3, 5))
+    >>> r.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> r.source
+    Point2D(2, 3)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.slope
+    2
+    >>> Ray(Point(0, 0), angle=pi/4).slope
+    1
+
+    """
+    def __new__(cls, p1, p2=None, **kwargs):
+        p1 = Point(p1)
+        if p2 is not None:
+            p1, p2 = Point._normalize_dimension(p1, Point(p2))
+        dim = len(p1)
+
+        if dim == 2:
+            return Ray2D(p1, p2, **kwargs)
+        elif dim == 3:
+            return Ray3D(p1, p2, **kwargs)
+        return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+        return (
+            ''
+        ).format(2.*scale_factor, path, fill_color)
+
+    def contains(self, other):
+        """
+        Is other GeometryEntity contained in this Ray?
+
+        Examples
+        ========
+
+        >>> from sympy import Ray,Point,Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 4)
+        >>> r = Ray(p1, p2)
+        >>> r.contains(p1)
+        True
+        >>> r.contains((1, 1))
+        True
+        >>> r.contains((1, 3))
+        False
+        >>> s = Segment((1, 1), (2, 2))
+        >>> r.contains(s)
+        True
+        >>> s = Segment((1, 2), (2, 5))
+        >>> r.contains(s)
+        False
+        >>> r1 = Ray((2, 2), (3, 3))
+        >>> r.contains(r1)
+        True
+        >>> r1 = Ray((2, 2), (3, 5))
+        >>> r.contains(r1)
+        False
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            if Point.is_collinear(self.p1, self.p2, other):
+                # if we're in the direction of the ray, our
+                # direction vector dot the ray's direction vector
+                # should be non-negative
+                return bool((self.p2 - self.p1).dot(other - self.p1) >= S.Zero)
+            return False
+        elif isinstance(other, Ray):
+            if Point.is_collinear(self.p1, self.p2, other.p1, other.p2):
+                return bool((self.p2 - self.p1).dot(other.p2 - other.p1) > S.Zero)
+            return False
+        elif isinstance(other, Segment):
+            return other.p1 in self and other.p2 in self
+
+        # No other known entity can be contained in a Ray
+        return False
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between the ray and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> s = Ray(p1, p2)
+        >>> s.distance(Point(-1, -1))
+        sqrt(2)
+        >>> s.distance((-1, 2))
+        3*sqrt(2)/2
+        >>> p1, p2 = Point(0, 0, 0), Point(1, 1, 2)
+        >>> s = Ray(p1, p2)
+        >>> s
+        Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 2))
+        >>> s.distance(Point(-1, -1, 2))
+        4*sqrt(3)/3
+        >>> s.distance((-1, -1, 2))
+        4*sqrt(3)/3
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if self.contains(other):
+            return S.Zero
+
+        proj = Line(self.p1, self.p2).projection(other)
+        if self.contains(proj):
+            return abs(other - proj)
+        else:
+            return abs(other - self.source)
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        if not isinstance(other, Ray):
+            return False
+        return self.source == other.source and other.p2 in self
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the Ray. Gives
+        values that will produce a ray that is 10 units long (where a unit is
+        the distance between the two points that define the ray).
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Ray, pi
+        >>> r = Ray((0, 0), angle=pi/4)
+        >>> r.plot_interval()
+        [t, 0, 10]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, 0, 10]
+
+    @property
+    def source(self):
+        """The point from which the ray emanates.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2 = Point(0, 0), Point(4, 1)
+        >>> r1 = Ray(p1, p2)
+        >>> r1.source
+        Point2D(0, 0)
+        >>> p1, p2 = Point(0, 0, 0), Point(4, 1, 5)
+        >>> r1 = Ray(p2, p1)
+        >>> r1.source
+        Point3D(4, 1, 5)
+
+        """
+        return self.p1
+
+
+class Segment(LinearEntity):
+    """A line segment in space.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment2D
+    sympy.geometry.line.Segment3D
+    sympy.geometry.point.Point
+    sympy.geometry.line.Line
+
+    Notes
+    =====
+
+    If 2D or 3D points are used to define `Segment`, it will
+    be automatically subclassed to `Segment2D` or `Segment3D`.
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Segment
+    >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+    Segment2D(Point2D(1, 0), Point2D(1, 1))
+    >>> s = Segment(Point(4, 3), Point(1, 1))
+    >>> s.points
+    (Point2D(4, 3), Point2D(1, 1))
+    >>> s.slope
+    2/3
+    >>> s.length
+    sqrt(13)
+    >>> s.midpoint
+    Point2D(5/2, 2)
+    >>> Segment((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+    Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+    >>> s = Segment(Point(4, 3, 9), Point(1, 1, 7)); s
+    Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.points
+    (Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.length
+    sqrt(17)
+    >>> s.midpoint
+    Point3D(5/2, 2, 8)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1, p2 = Point._normalize_dimension(Point(p1), Point(p2))
+        dim = len(p1)
+
+        if dim == 2:
+            return Segment2D(p1, p2, **kwargs)
+        elif dim == 3:
+            return Segment3D(p1, p2, **kwargs)
+        return LinearEntity.__new__(cls, p1, p2, **kwargs)
+
+    def contains(self, other):
+        """
+        Is the other GeometryEntity contained within this Segment?
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> s = Segment(p1, p2)
+        >>> s2 = Segment(p2, p1)
+        >>> s.contains(s2)
+        True
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 1, 1), Point3D(3, 4, 5)
+        >>> s = Segment3D(p1, p2)
+        >>> s2 = Segment3D(p2, p1)
+        >>> s.contains(s2)
+        True
+        >>> s.contains((p1 + p2)/2)
+        True
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            if Point.is_collinear(other, self.p1, self.p2):
+                if isinstance(self, Segment2D):
+                    # if it is collinear and is in the bounding box of the
+                    # segment then it must be on the segment
+                    vert = (1/self.slope).equals(0)
+                    if vert is False:
+                        isin = (self.p1.x - other.x)*(self.p2.x - other.x) <= 0
+                        if isin in (True, False):
+                            return isin
+                    if vert is True:
+                        isin = (self.p1.y - other.y)*(self.p2.y - other.y) <= 0
+                        if isin in (True, False):
+                            return isin
+                # use the triangle inequality
+                d1, d2 = other - self.p1, other - self.p2
+                d = self.p2 - self.p1
+                # without the call to simplify, SymPy cannot tell that an expression
+                # like (a+b)*(a/2+b/2) is always non-negative.  If it cannot be
+                # determined, raise an Undecidable error
+                try:
+                    # the triangle inequality says that |d1|+|d2| >= |d| and is strict
+                    # only if other lies in the line segment
+                    return bool(simplify(Eq(abs(d1) + abs(d2) - abs(d), 0)))
+                except TypeError:
+                    raise Undecidable("Cannot determine if {} is in {}".format(other, self))
+        if isinstance(other, Segment):
+            return other.p1 in self and other.p2 in self
+
+        return False
+
+    def equals(self, other):
+        """Returns True if self and other are the same mathematical entities"""
+        return isinstance(other, self.func) and list(
+            ordered(self.args)) == list(ordered(other.args))
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between a line segment and a point.
+
+        Raises
+        ======
+
+        NotImplementedError is raised if `other` is not a Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 1), Point(3, 4)
+        >>> s = Segment(p1, p2)
+        >>> s.distance(Point(10, 15))
+        sqrt(170)
+        >>> s.distance((0, 12))
+        sqrt(73)
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 3), Point3D(1, 1, 4)
+        >>> s = Segment3D(p1, p2)
+        >>> s.distance(Point3D(10, 15, 12))
+        sqrt(341)
+        >>> s.distance((10, 15, 12))
+        sqrt(341)
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if isinstance(other, Point):
+            vp1 = other - self.p1
+            vp2 = other - self.p2
+
+            dot_prod_sign_1 = self.direction.dot(vp1) >= 0
+            dot_prod_sign_2 = self.direction.dot(vp2) <= 0
+            if dot_prod_sign_1 and dot_prod_sign_2:
+                return Line(self.p1, self.p2).distance(other)
+            if dot_prod_sign_1 and not dot_prod_sign_2:
+                return abs(vp2)
+            if not dot_prod_sign_1 and dot_prod_sign_2:
+                return abs(vp1)
+        raise NotImplementedError()
+
+    @property
+    def length(self):
+        """The length of the line segment.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.length
+        5
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+        >>> s1 = Segment3D(p1, p2)
+        >>> s1.length
+        sqrt(34)
+
+        """
+        return Point.distance(self.p1, self.p2)
+
+    @property
+    def midpoint(self):
+        """The midpoint of the line segment.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(4, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.midpoint
+        Point2D(2, 3/2)
+        >>> from sympy import Point3D, Segment3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(4, 3, 3)
+        >>> s1 = Segment3D(p1, p2)
+        >>> s1.midpoint
+        Point3D(2, 3/2, 3/2)
+
+        """
+        return Point.midpoint(self.p1, self.p2)
+
+    def perpendicular_bisector(self, p=None):
+        """The perpendicular bisector of this segment.
+
+        If no point is specified or the point specified is not on the
+        bisector then the bisector is returned as a Line. Otherwise a
+        Segment is returned that joins the point specified and the
+        intersection of the bisector and the segment.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        bisector : Line or Segment
+
+        See Also
+        ========
+
+        LinearEntity.perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2, p3 = Point(0, 0), Point(6, 6), Point(5, 1)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.perpendicular_bisector()
+        Line2D(Point2D(3, 3), Point2D(-3, 9))
+
+        >>> s1.perpendicular_bisector(p3)
+        Segment2D(Point2D(5, 1), Point2D(3, 3))
+
+        """
+        l = self.perpendicular_line(self.midpoint)
+        if p is not None:
+            p2 = Point(p, dim=self.ambient_dimension)
+            if p2 in l:
+                return Segment(p2, self.midpoint)
+        return l
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the Segment gives
+        values that will produce the full segment in a plot.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Segment
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> s1 = Segment(p1, p2)
+        >>> s1.plot_interval()
+        [t, 0, 1]
+
+        """
+        t = _symbol(parameter, real=True)
+        return [t, 0, 1]
+
+
+class LinearEntity2D(LinearEntity):
+    """A base class for all linear entities (line, ray and segment)
+    in a 2-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    p1
+    p2
+    coefficients
+    slope
+    points
+
+    Notes
+    =====
+
+    This is an abstract class and is not meant to be instantiated.
+
+    See Also
+    ========
+
+    sympy.geometry.entity.GeometryEntity
+
+    """
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+        verts = self.points
+        xs = [p.x for p in verts]
+        ys = [p.y for p in verts]
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def perpendicular_line(self, p):
+        """Create a new Line perpendicular to this linear entity which passes
+        through the point `p`.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        line : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.is_perpendicular, perpendicular_segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+        >>> L = Line(p1, p2)
+        >>> P = L.perpendicular_line(p3); P
+        Line2D(Point2D(-2, 2), Point2D(-5, 4))
+        >>> L.is_perpendicular(P)
+        True
+
+        In 2D, the first point of the perpendicular line is the
+        point through which was required to pass; the second
+        point is arbitrarily chosen. To get a line that explicitly
+        uses a point in the line, create a line from the perpendicular
+        segment from the line to the point:
+
+        >>> Line(L.perpendicular_segment(p3))
+        Line2D(Point2D(-2, 2), Point2D(4/13, 6/13))
+        """
+        p = Point(p, dim=self.ambient_dimension)
+        # any two lines in R^2 intersect, so blindly making
+        # a line through p in an orthogonal direction will work
+        # and is faster than finding the projection point as in 3D
+        return Line(p, p + self.direction.orthogonal_direction)
+
+    @property
+    def slope(self):
+        """The slope of this linear entity, or infinity if vertical.
+
+        Returns
+        =======
+
+        slope : number or SymPy expression
+
+        See Also
+        ========
+
+        coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(0, 0), Point(3, 5)
+        >>> l1 = Line(p1, p2)
+        >>> l1.slope
+        5/3
+
+        >>> p3 = Point(0, 4)
+        >>> l2 = Line(p1, p3)
+        >>> l2.slope
+        oo
+
+        """
+        d1, d2 = (self.p1 - self.p2).args
+        if d1 == 0:
+            return S.Infinity
+        return simplify(d2/d1)
+
+
+class Line2D(LinearEntity2D, Line):
+    """An infinite line in space 2D.
+
+    A line is declared with two distinct points or a point and slope
+    as defined using keyword `slope`.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    pt : Point
+    slope : SymPy expression
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point
+
+    Examples
+    ========
+
+    >>> from sympy import Line, Segment, Point
+    >>> L = Line(Point(2,3), Point(3,5))
+    >>> L
+    Line2D(Point2D(2, 3), Point2D(3, 5))
+    >>> L.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> L.equation()
+    -2*x + y + 1
+    >>> L.coefficients
+    (-2, 1, 1)
+
+    Instantiate with keyword ``slope``:
+
+    >>> Line(Point(0, 0), slope=0)
+    Line2D(Point2D(0, 0), Point2D(1, 0))
+
+    Instantiate with another linear object
+
+    >>> s = Segment((0, 0), (0, 1))
+    >>> Line(s).equation()
+    x
+    """
+    def __new__(cls, p1, pt=None, slope=None, **kwargs):
+        if isinstance(p1, LinearEntity):
+            if pt is not None:
+                raise ValueError('When p1 is a LinearEntity, pt should be None')
+            p1, pt = Point._normalize_dimension(*p1.args, dim=2)
+        else:
+            p1 = Point(p1, dim=2)
+        if pt is not None and slope is None:
+            try:
+                p2 = Point(pt, dim=2)
+            except (NotImplementedError, TypeError, ValueError):
+                raise ValueError(filldedent('''
+                    The 2nd argument was not a valid Point.
+                    If it was a slope, enter it with keyword "slope".
+                    '''))
+        elif slope is not None and pt is None:
+            slope = sympify(slope)
+            if slope.is_finite is False:
+                # when infinite slope, don't change x
+                dx = 0
+                dy = 1
+            else:
+                # go over 1 up slope
+                dx = 1
+                dy = slope
+            # XXX avoiding simplification by adding to coords directly
+            p2 = Point(p1.x + dx, p1.y + dy, evaluate=False)
+        else:
+            raise ValueError('A 2nd Point or keyword "slope" must be used.')
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+
+        return (
+            ''
+        ).format(2.*scale_factor, path, fill_color)
+
+    @property
+    def coefficients(self):
+        """The coefficients (`a`, `b`, `c`) for `ax + by + c = 0`.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line2D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> from sympy.abc import x, y
+        >>> p1, p2 = Point(0, 0), Point(5, 3)
+        >>> l = Line(p1, p2)
+        >>> l.coefficients
+        (-3, 5, 0)
+
+        >>> p3 = Point(x, y)
+        >>> l2 = Line(p1, p3)
+        >>> l2.coefficients
+        (-y, x, 0)
+
+        """
+        p1, p2 = self.points
+        if p1.x == p2.x:
+            return (S.One, S.Zero, -p1.x)
+        elif p1.y == p2.y:
+            return (S.Zero, S.One, -p1.y)
+        return tuple([simplify(i) for i in
+                      (self.p1.y - self.p2.y,
+                       self.p2.x - self.p1.x,
+                       self.p1.x*self.p2.y - self.p1.y*self.p2.x)])
+
+    def equation(self, x='x', y='y'):
+        """The equation of the line: ax + by + c.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            The name to use for the x-axis, default value is 'x'.
+        y : str, optional
+            The name to use for the y-axis, default value is 'y'.
+
+        Returns
+        =======
+
+        equation : SymPy expression
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line2D.coefficients
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 0), Point(5, 3)
+        >>> l1 = Line(p1, p2)
+        >>> l1.equation()
+        -3*x + 4*y + 3
+
+        """
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+        p1, p2 = self.points
+        if p1.x == p2.x:
+            return x - p1.x
+        elif p1.y == p2.y:
+            return y - p1.y
+
+        a, b, c = self.coefficients
+        return a*x + b*y + c
+
+
+class Ray2D(LinearEntity2D, Ray):
+    """
+    A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point
+        The source of the Ray
+    p2 : Point or radian value
+        This point determines the direction in which the Ray propagates.
+        If given as an angle it is interpreted in radians with the positive
+        direction being ccw.
+
+    Attributes
+    ==========
+
+    source
+    xdirection
+    ydirection
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Line
+
+    Examples
+    ========
+
+    >>> from sympy import Point, pi, Ray
+    >>> r = Ray(Point(2, 3), Point(3, 5))
+    >>> r
+    Ray2D(Point2D(2, 3), Point2D(3, 5))
+    >>> r.points
+    (Point2D(2, 3), Point2D(3, 5))
+    >>> r.source
+    Point2D(2, 3)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.slope
+    2
+    >>> Ray(Point(0, 0), angle=pi/4).slope
+    1
+
+    """
+    def __new__(cls, p1, pt=None, angle=None, **kwargs):
+        p1 = Point(p1, dim=2)
+        if pt is not None and angle is None:
+            try:
+                p2 = Point(pt, dim=2)
+            except (NotImplementedError, TypeError, ValueError):
+                raise ValueError(filldedent('''
+                    The 2nd argument was not a valid Point; if
+                    it was meant to be an angle it should be
+                    given with keyword "angle".'''))
+            if p1 == p2:
+                raise ValueError('A Ray requires two distinct points.')
+        elif angle is not None and pt is None:
+            # we need to know if the angle is an odd multiple of pi/2
+            angle = sympify(angle)
+            c = _pi_coeff(angle)
+            p2 = None
+            if c is not None:
+                if c.is_Rational:
+                    if c.q == 2:
+                        if c.p == 1:
+                            p2 = p1 + Point(0, 1)
+                        elif c.p == 3:
+                            p2 = p1 + Point(0, -1)
+                    elif c.q == 1:
+                        if c.p == 0:
+                            p2 = p1 + Point(1, 0)
+                        elif c.p == 1:
+                            p2 = p1 + Point(-1, 0)
+                if p2 is None:
+                    c *= S.Pi
+            else:
+                c = angle % (2*S.Pi)
+            if not p2:
+                m = 2*c/S.Pi
+                left = And(1 < m, m < 3)  # is it in quadrant 2 or 3?
+                x = Piecewise((-1, left), (Piecewise((0, Eq(m % 1, 0)), (1, True)), True))
+                y = Piecewise((-tan(c), left), (Piecewise((1, Eq(m, 1)), (-1, Eq(m, 3)), (tan(c), True)), True))
+                p2 = p1 + Point(x, y)
+        else:
+            raise ValueError('A 2nd point or keyword "angle" must be used.')
+
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    @property
+    def xdirection(self):
+        """The x direction of the ray.
+
+        Positive infinity if the ray points in the positive x direction,
+        negative infinity if the ray points in the negative x direction,
+        or 0 if the ray is vertical.
+
+        See Also
+        ========
+
+        ydirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, -1)
+        >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+        >>> r1.xdirection
+        oo
+        >>> r2.xdirection
+        0
+
+        """
+        if self.p1.x < self.p2.x:
+            return S.Infinity
+        elif self.p1.x == self.p2.x:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def ydirection(self):
+        """The y direction of the ray.
+
+        Positive infinity if the ray points in the positive y direction,
+        negative infinity if the ray points in the negative y direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Ray
+        >>> p1, p2, p3 = Point(0, 0), Point(-1, -1), Point(-1, 0)
+        >>> r1, r2 = Ray(p1, p2), Ray(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+
+        """
+        if self.p1.y < self.p2.y:
+            return S.Infinity
+        elif self.p1.y == self.p2.y:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    def closing_angle(r1, r2):
+        """Return the angle by which r2 must be rotated so it faces the same
+        direction as r1.
+
+        Parameters
+        ==========
+
+        r1 : Ray2D
+        r2 : Ray2D
+
+        Returns
+        =======
+
+        angle : angle in radians (ccw angle is positive)
+
+        See Also
+        ========
+
+        LinearEntity.angle_between
+
+        Examples
+        ========
+
+        >>> from sympy import Ray, pi
+        >>> r1 = Ray((0, 0), (1, 0))
+        >>> r2 = r1.rotate(-pi/2)
+        >>> angle = r1.closing_angle(r2); angle
+        pi/2
+        >>> r2.rotate(angle).direction.unit == r1.direction.unit
+        True
+        >>> r2.closing_angle(r1)
+        -pi/2
+        """
+        if not all(isinstance(r, Ray2D) for r in (r1, r2)):
+            # although the direction property is defined for
+            # all linear entities, only the Ray is truly a
+            # directed object
+            raise TypeError('Both arguments must be Ray2D objects.')
+
+        a1 = atan2(*list(reversed(r1.direction.args)))
+        a2 = atan2(*list(reversed(r2.direction.args)))
+        if a1*a2 < 0:
+            a1 = 2*S.Pi + a1 if a1 < 0 else a1
+            a2 = 2*S.Pi + a2 if a2 < 0 else a2
+        return a1 - a2
+
+
+class Segment2D(LinearEntity2D, Segment):
+    """A line segment in 2D space.
+
+    Parameters
+    ==========
+
+    p1 : Point
+    p2 : Point
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Line
+
+    Examples
+    ========
+
+    >>> from sympy import Point, Segment
+    >>> Segment((1, 0), (1, 1)) # tuples are interpreted as pts
+    Segment2D(Point2D(1, 0), Point2D(1, 1))
+    >>> s = Segment(Point(4, 3), Point(1, 1)); s
+    Segment2D(Point2D(4, 3), Point2D(1, 1))
+    >>> s.points
+    (Point2D(4, 3), Point2D(1, 1))
+    >>> s.slope
+    2/3
+    >>> s.length
+    sqrt(13)
+    >>> s.midpoint
+    Point2D(5/2, 2)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point(p1, dim=2)
+        p2 = Point(p2, dim=2)
+
+        if p1 == p2:
+            return p1
+
+        return LinearEntity2D.__new__(cls, p1, p2, **kwargs)
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the LinearEntity.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = (N(self.p1), N(self.p2))
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {}".format(coords[0], " L ".join(coords[1:]))
+        return (
+            ''
+        ).format(2.*scale_factor, path, fill_color)
+
+
+class LinearEntity3D(LinearEntity):
+    """An base class for all linear entities (line, ray and segment)
+    in a 3-dimensional Euclidean space.
+
+    Attributes
+    ==========
+
+    p1
+    p2
+    direction_ratio
+    direction_cosine
+    points
+
+    Notes
+    =====
+
+    This is a base class and is not meant to be instantiated.
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point3D(p1, dim=3)
+        p2 = Point3D(p2, dim=3)
+        if p1 == p2:
+            # if it makes sense to return a Point, handle in subclass
+            raise ValueError(
+                "%s.__new__ requires two unique Points." % cls.__name__)
+
+        return GeometryEntity.__new__(cls, p1, p2, **kwargs)
+
+    ambient_dimension = 3
+
+    @property
+    def direction_ratio(self):
+        """The direction ratio of a given line in 3D.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+        >>> l = Line3D(p1, p2)
+        >>> l.direction_ratio
+        [5, 3, 1]
+        """
+        p1, p2 = self.points
+        return p1.direction_ratio(p2)
+
+    @property
+    def direction_cosine(self):
+        """The normalized direction ratio of a given line in 3D.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D.equation
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(5, 3, 1)
+        >>> l = Line3D(p1, p2)
+        >>> l.direction_cosine
+        [sqrt(35)/7, 3*sqrt(35)/35, sqrt(35)/35]
+        >>> sum(i**2 for i in _)
+        1
+        """
+        p1, p2 = self.points
+        return p1.direction_cosine(p2)
+
+
+class Line3D(LinearEntity3D, Line):
+    """An infinite 3D line in space.
+
+    A line is declared with two distinct points or a point and direction_ratio
+    as defined using keyword `direction_ratio`.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+    pt : Point3D
+    direction_ratio : list
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D
+    sympy.geometry.line.Line
+    sympy.geometry.line.Line2D
+
+    Examples
+    ========
+
+    >>> from sympy import Line3D, Point3D
+    >>> L = Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+    >>> L
+    Line3D(Point3D(2, 3, 4), Point3D(3, 5, 1))
+    >>> L.points
+    (Point3D(2, 3, 4), Point3D(3, 5, 1))
+    """
+    def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+        if isinstance(p1, LinearEntity3D):
+            if pt is not None:
+                raise ValueError('if p1 is a LinearEntity, pt must be None.')
+            p1, pt = p1.args
+        else:
+            p1 = Point(p1, dim=3)
+        if pt is not None and len(direction_ratio) == 0:
+            pt = Point(pt, dim=3)
+        elif len(direction_ratio) == 3 and pt is None:
+            pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+                         p1.z + direction_ratio[2])
+        else:
+            raise ValueError('A 2nd Point or keyword "direction_ratio" must '
+                             'be used.')
+
+        return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+    def equation(self, x='x', y='y', z='z'):
+        """Return the equations that define the line in 3D.
+
+        Parameters
+        ==========
+
+        x : str, optional
+            The name to use for the x-axis, default value is 'x'.
+        y : str, optional
+            The name to use for the y-axis, default value is 'y'.
+        z : str, optional
+            The name to use for the z-axis, default value is 'z'.
+
+        Returns
+        =======
+
+        equation : Tuple of simultaneous equations
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, solve
+        >>> from sympy.abc import x, y, z
+        >>> p1, p2 = Point3D(1, 0, 0), Point3D(5, 3, 0)
+        >>> l1 = Line3D(p1, p2)
+        >>> eq = l1.equation(x, y, z); eq
+        (-3*x + 4*y + 3, z)
+        >>> solve(eq.subs(z, 0), (x, y, z))
+        {x: 4*y/3 + 1}
+        """
+        x, y, z, k = [_symbol(i, real=True) for i in (x, y, z, 'k')]
+        p1, p2 = self.points
+        d1, d2, d3 = p1.direction_ratio(p2)
+        x1, y1, z1 = p1
+        eqs = [-d1*k + x - x1, -d2*k + y - y1, -d3*k + z - z1]
+        # eliminate k from equations by solving first eq with k for k
+        for i, e in enumerate(eqs):
+            if e.has(k):
+                kk = solve(e, k)[0]
+                eqs.pop(i)
+                break
+        return Tuple(*[i.subs(k, kk).as_numer_denom()[0] for i in eqs])
+
+    def distance(self, other):
+        """
+        Finds the shortest distance between a line and another object.
+
+        Parameters
+        ==========
+
+        Point3D, Line3D, Plane, tuple, list
+
+        Returns
+        =======
+
+        distance
+
+        Notes
+        =====
+
+        This method accepts only 3D entities as it's parameter
+
+        Tuples and lists are converted to Point3D and therefore must be of
+        length 3, 2 or 1.
+
+        NotImplementedError is raised if `other` is not an instance of one
+        of the specified classes: Point3D, Line3D, or Plane.
+
+        Examples
+        ========
+
+        >>> from sympy.geometry import Line3D
+        >>> l1 = Line3D((0, 0, 0), (0, 0, 1))
+        >>> l2 = Line3D((0, 1, 0), (1, 1, 1))
+        >>> l1.distance(l2)
+        1
+
+        The computed distance may be symbolic, too:
+
+        >>> from sympy.abc import x, y
+        >>> l1 = Line3D((0, 0, 0), (0, 0, 1))
+        >>> l2 = Line3D((0, x, 0), (y, x, 1))
+        >>> l1.distance(l2)
+        Abs(x*y)/Abs(sqrt(y**2))
+
+        """
+
+        from .plane import Plane  # Avoid circular import
+
+        if isinstance(other, (tuple, list)):
+            try:
+                other = Point3D(other)
+            except ValueError:
+                pass
+
+        if isinstance(other, Point3D):
+            return super().distance(other)
+
+        if isinstance(other, Line3D):
+            if self == other:
+                return S.Zero
+            if self.is_parallel(other):
+                return super().distance(other.p1)
+
+            # Skew lines
+            self_direction = Matrix(self.direction_ratio)
+            other_direction = Matrix(other.direction_ratio)
+            normal = self_direction.cross(other_direction)
+            plane_through_self = Plane(p1=self.p1, normal_vector=normal)
+            return other.p1.distance(plane_through_self)
+
+        if isinstance(other, Plane):
+            return other.distance(self)
+
+        msg = f"{other} has type {type(other)}, which is unsupported"
+        raise NotImplementedError(msg)
+
+
+class Ray3D(LinearEntity3D, Ray):
+    """
+    A Ray is a semi-line in the space with a source point and a direction.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+        The source of the Ray
+    p2 : Point or a direction vector
+    direction_ratio: Determines the direction in which the Ray propagates.
+
+
+    Attributes
+    ==========
+
+    source
+    xdirection
+    ydirection
+    zdirection
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D, Line3D
+
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D, Ray3D
+    >>> r = Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r
+    Ray3D(Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r.points
+    (Point3D(2, 3, 4), Point3D(3, 5, 0))
+    >>> r.source
+    Point3D(2, 3, 4)
+    >>> r.xdirection
+    oo
+    >>> r.ydirection
+    oo
+    >>> r.direction_ratio
+    [1, 2, -4]
+
+    """
+    def __new__(cls, p1, pt=None, direction_ratio=(), **kwargs):
+        if isinstance(p1, LinearEntity3D):
+            if pt is not None:
+                raise ValueError('If p1 is a LinearEntity, pt must be None')
+            p1, pt = p1.args
+        else:
+            p1 = Point(p1, dim=3)
+        if pt is not None and len(direction_ratio) == 0:
+            pt = Point(pt, dim=3)
+        elif len(direction_ratio) == 3 and pt is None:
+            pt = Point3D(p1.x + direction_ratio[0], p1.y + direction_ratio[1],
+                         p1.z + direction_ratio[2])
+        else:
+            raise ValueError(filldedent('''
+                A 2nd Point or keyword "direction_ratio" must be used.
+            '''))
+
+        return LinearEntity3D.__new__(cls, p1, pt, **kwargs)
+
+    @property
+    def xdirection(self):
+        """The x direction of the ray.
+
+        Positive infinity if the ray points in the positive x direction,
+        negative infinity if the ray points in the negative x direction,
+        or 0 if the ray is vertical.
+
+        See Also
+        ========
+
+        ydirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, -1, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.xdirection
+        oo
+        >>> r2.xdirection
+        0
+
+        """
+        if self.p1.x < self.p2.x:
+            return S.Infinity
+        elif self.p1.x == self.p2.x:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def ydirection(self):
+        """The y direction of the ray.
+
+        Positive infinity if the ray points in the positive y direction,
+        negative infinity if the ray points in the negative y direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+
+        """
+        if self.p1.y < self.p2.y:
+            return S.Infinity
+        elif self.p1.y == self.p2.y:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+    @property
+    def zdirection(self):
+        """The z direction of the ray.
+
+        Positive infinity if the ray points in the positive z direction,
+        negative infinity if the ray points in the negative z direction,
+        or 0 if the ray is horizontal.
+
+        See Also
+        ========
+
+        xdirection
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Ray3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(-1, -1, -1), Point3D(-1, 0, 0)
+        >>> r1, r2 = Ray3D(p1, p2), Ray3D(p1, p3)
+        >>> r1.ydirection
+        -oo
+        >>> r2.ydirection
+        0
+        >>> r2.zdirection
+        0
+
+        """
+        if self.p1.z < self.p2.z:
+            return S.Infinity
+        elif self.p1.z == self.p2.z:
+            return S.Zero
+        else:
+            return S.NegativeInfinity
+
+
+class Segment3D(LinearEntity3D, Segment):
+    """A line segment in a 3D space.
+
+    Parameters
+    ==========
+
+    p1 : Point3D
+    p2 : Point3D
+
+    Attributes
+    ==========
+
+    length : number or SymPy expression
+    midpoint : Point3D
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point3D, Line3D
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D, Segment3D
+    >>> Segment3D((1, 0, 0), (1, 1, 1)) # tuples are interpreted as pts
+    Segment3D(Point3D(1, 0, 0), Point3D(1, 1, 1))
+    >>> s = Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7)); s
+    Segment3D(Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.points
+    (Point3D(4, 3, 9), Point3D(1, 1, 7))
+    >>> s.length
+    sqrt(17)
+    >>> s.midpoint
+    Point3D(5/2, 2, 8)
+
+    """
+    def __new__(cls, p1, p2, **kwargs):
+        p1 = Point(p1, dim=3)
+        p2 = Point(p2, dim=3)
+
+        if p1 == p2:
+            return p1
+
+        return LinearEntity3D.__new__(cls, p1, p2, **kwargs)
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/parabola.py b/.venv/lib/python3.12/site-packages/sympy/geometry/parabola.py
new file mode 100644
index 0000000000000000000000000000000000000000..183c593785bb610e6f451a0c87abb2aa34d22494
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/parabola.py
@@ -0,0 +1,422 @@
+"""Parabolic geometrical entity.
+
+Contains
+* Parabola
+
+"""
+
+from sympy.core import S
+from sympy.core.sorting import ordered
+from sympy.core.symbol import _symbol, symbols
+from sympy.geometry.entity import GeometryEntity, GeometrySet
+from sympy.geometry.point import Point, Point2D
+from sympy.geometry.line import Line, Line2D, Ray2D, Segment2D, LinearEntity3D
+from sympy.geometry.ellipse import Ellipse
+from sympy.functions import sign
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+
+
+class Parabola(GeometrySet):
+    """A parabolic GeometryEntity.
+
+    A parabola is declared with a point, that is called 'focus', and
+    a line, that is called 'directrix'.
+    Only vertical or horizontal parabolas are currently supported.
+
+    Parameters
+    ==========
+
+    focus : Point
+        Default value is Point(0, 0)
+    directrix : Line
+
+    Attributes
+    ==========
+
+    focus
+    directrix
+    axis of symmetry
+    focal length
+    p parameter
+    vertex
+    eccentricity
+
+    Raises
+    ======
+    ValueError
+        When `focus` is not a two dimensional point.
+        When `focus` is a point of directrix.
+    NotImplementedError
+        When `directrix` is neither horizontal nor vertical.
+
+    Examples
+    ========
+
+    >>> from sympy import Parabola, Point, Line
+    >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7,8)))
+    >>> p1.focus
+    Point2D(0, 0)
+    >>> p1.directrix
+    Line2D(Point2D(5, 8), Point2D(7, 8))
+
+    """
+
+    def __new__(cls, focus=None, directrix=None, **kwargs):
+
+        if focus:
+            focus = Point(focus, dim=2)
+        else:
+            focus = Point(0, 0)
+
+        directrix = Line(directrix)
+
+        if directrix.contains(focus):
+            raise ValueError('The focus must not be a point of directrix')
+
+        return GeometryEntity.__new__(cls, focus, directrix, **kwargs)
+
+    @property
+    def ambient_dimension(self):
+        """Returns the ambient dimension of parabola.
+
+        Returns
+        =======
+
+        ambient_dimension : integer
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> f1 = Point(0, 0)
+        >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+        >>> p1.ambient_dimension
+        2
+
+        """
+        return 2
+
+    @property
+    def axis_of_symmetry(self):
+        """Return the axis of symmetry of the parabola: a line
+        perpendicular to the directrix passing through the focus.
+
+        Returns
+        =======
+
+        axis_of_symmetry : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.axis_of_symmetry
+        Line2D(Point2D(0, 0), Point2D(0, 1))
+
+        """
+        return self.directrix.perpendicular_line(self.focus)
+
+    @property
+    def directrix(self):
+        """The directrix of the parabola.
+
+        Returns
+        =======
+
+        directrix : Line
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> l1 = Line(Point(5, 8), Point(7, 8))
+        >>> p1 = Parabola(Point(0, 0), l1)
+        >>> p1.directrix
+        Line2D(Point2D(5, 8), Point2D(7, 8))
+
+        """
+        return self.args[1]
+
+    @property
+    def eccentricity(self):
+        """The eccentricity of the parabola.
+
+        Returns
+        =======
+
+        eccentricity : number
+
+        A parabola may also be characterized as a conic section with an
+        eccentricity of 1. As a consequence of this, all parabolas are
+        similar, meaning that while they can be different sizes,
+        they are all the same shape.
+
+        See Also
+        ========
+
+        https://en.wikipedia.org/wiki/Parabola
+
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.eccentricity
+        1
+
+        Notes
+        -----
+        The eccentricity for every Parabola is 1 by definition.
+
+        """
+        return S.One
+
+    def equation(self, x='x', y='y'):
+        """The equation of the parabola.
+
+        Parameters
+        ==========
+        x : str, optional
+            Label for the x-axis. Default value is 'x'.
+        y : str, optional
+            Label for the y-axis. Default value is 'y'.
+
+        Returns
+        =======
+        equation : SymPy expression
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.equation()
+        -x**2 - 16*y + 64
+        >>> p1.equation('f')
+        -f**2 - 16*y + 64
+        >>> p1.equation(y='z')
+        -x**2 - 16*z + 64
+
+        """
+        x = _symbol(x, real=True)
+        y = _symbol(y, real=True)
+
+        m = self.directrix.slope
+        if m is S.Infinity:
+            t1 = 4 * (self.p_parameter) * (x - self.vertex.x)
+            t2 = (y - self.vertex.y)**2
+        elif m == 0:
+            t1 = 4 * (self.p_parameter) * (y - self.vertex.y)
+            t2 = (x - self.vertex.x)**2
+        else:
+            a, b = self.focus
+            c, d = self.directrix.coefficients[:2]
+            t1 = (x - a)**2 + (y - b)**2
+            t2 = self.directrix.equation(x, y)**2/(c**2 + d**2)
+        return t1 - t2
+
+    @property
+    def focal_length(self):
+        """The focal length of the parabola.
+
+        Returns
+        =======
+
+        focal_lenght : number or symbolic expression
+
+        Notes
+        =====
+
+        The distance between the vertex and the focus
+        (or the vertex and directrix), measured along the axis
+        of symmetry, is the "focal length".
+
+        See Also
+        ========
+
+        https://en.wikipedia.org/wiki/Parabola
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.focal_length
+        4
+
+        """
+        distance = self.directrix.distance(self.focus)
+        focal_length = distance/2
+
+        return focal_length
+
+    @property
+    def focus(self):
+        """The focus of the parabola.
+
+        Returns
+        =======
+
+        focus : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> f1 = Point(0, 0)
+        >>> p1 = Parabola(f1, Line(Point(5, 8), Point(7, 8)))
+        >>> p1.focus
+        Point2D(0, 0)
+
+        """
+        return self.args[0]
+
+    def intersection(self, o):
+        """The intersection of the parabola and another geometrical entity `o`.
+
+        Parameters
+        ==========
+
+        o : GeometryEntity, LinearEntity
+
+        Returns
+        =======
+
+        intersection : list of GeometryEntity objects
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Ellipse, Line, Segment
+        >>> p1 = Point(0,0)
+        >>> l1 = Line(Point(1, -2), Point(-1,-2))
+        >>> parabola1 = Parabola(p1, l1)
+        >>> parabola1.intersection(Ellipse(Point(0, 0), 2, 5))
+        [Point2D(-2, 0), Point2D(2, 0)]
+        >>> parabola1.intersection(Line(Point(-7, 3), Point(12, 3)))
+        [Point2D(-4, 3), Point2D(4, 3)]
+        >>> parabola1.intersection(Segment((-12, -65), (14, -68)))
+        []
+
+        """
+        x, y = symbols('x y', real=True)
+        parabola_eq = self.equation()
+        if isinstance(o, Parabola):
+            if o in self:
+                return [o]
+            else:
+                return list(ordered([Point(i) for i in solve(
+                    [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+        elif isinstance(o, Point2D):
+            if simplify(parabola_eq.subs([(x, o._args[0]), (y, o._args[1])])) == 0:
+                return [o]
+            else:
+                return []
+        elif isinstance(o, (Segment2D, Ray2D)):
+            result = solve([parabola_eq,
+                Line2D(o.points[0], o.points[1]).equation()],
+                [x, y], set=True)[1]
+            return list(ordered([Point2D(i) for i in result if i in o]))
+        elif isinstance(o, (Line2D, Ellipse)):
+            return list(ordered([Point2D(i) for i in solve(
+                [parabola_eq, o.equation()], [x, y], set=True)[1]]))
+        elif isinstance(o, LinearEntity3D):
+            raise TypeError('Entity must be two dimensional, not three dimensional')
+        else:
+            raise TypeError('Wrong type of argument were put')
+
+    @property
+    def p_parameter(self):
+        """P is a parameter of parabola.
+
+        Returns
+        =======
+
+        p : number or symbolic expression
+
+        Notes
+        =====
+
+        The absolute value of p is the focal length. The sign on p tells
+        which way the parabola faces. Vertical parabolas that open up
+        and horizontal that open right, give a positive value for p.
+        Vertical parabolas that open down and horizontal that open left,
+        give a negative value for p.
+
+
+        See Also
+        ========
+
+        https://www.sparknotes.com/math/precalc/conicsections/section2/
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.p_parameter
+        -4
+
+        """
+        m = self.directrix.slope
+        if m is S.Infinity:
+            x = self.directrix.coefficients[2]
+            p = sign(self.focus.args[0] + x)
+        elif m == 0:
+            y = self.directrix.coefficients[2]
+            p = sign(self.focus.args[1] + y)
+        else:
+            d = self.directrix.projection(self.focus)
+            p = sign(self.focus.x - d.x)
+        return p * self.focal_length
+
+    @property
+    def vertex(self):
+        """The vertex of the parabola.
+
+        Returns
+        =======
+
+        vertex : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Parabola, Point, Line
+        >>> p1 = Parabola(Point(0, 0), Line(Point(5, 8), Point(7, 8)))
+        >>> p1.vertex
+        Point2D(0, 4)
+
+        """
+        focus = self.focus
+        m = self.directrix.slope
+        if m is S.Infinity:
+            vertex = Point(focus.args[0] - self.p_parameter, focus.args[1])
+        elif m == 0:
+            vertex = Point(focus.args[0], focus.args[1] - self.p_parameter)
+        else:
+            vertex = self.axis_of_symmetry.intersection(self)[0]
+        return vertex
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/plane.py b/.venv/lib/python3.12/site-packages/sympy/geometry/plane.py
new file mode 100644
index 0000000000000000000000000000000000000000..509dc4be5dc41c5df7c33561fdbe5bb0b6620352
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/plane.py
@@ -0,0 +1,878 @@
+"""Geometrical Planes.
+
+Contains
+========
+Plane
+
+"""
+
+from sympy.core import Dummy, Rational, S, Symbol
+from sympy.core.symbol import _symbol
+from sympy.functions.elementary.trigonometric import cos, sin, acos, asin, sqrt
+from .entity import GeometryEntity
+from .line import (Line, Ray, Segment, Line3D, LinearEntity, LinearEntity3D,
+                   Ray3D, Segment3D)
+from .point import Point, Point3D
+from sympy.matrices import Matrix
+from sympy.polys.polytools import cancel
+from sympy.solvers import solve, linsolve
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import random
+
+
+x, y, z, t = [Dummy('plane_dummy') for i in range(4)]
+
+
+class Plane(GeometryEntity):
+    """
+    A plane is a flat, two-dimensional surface. A plane is the two-dimensional
+    analogue of a point (zero-dimensions), a line (one-dimension) and a solid
+    (three-dimensions). A plane can generally be constructed by two types of
+    inputs. They are:
+    - three non-collinear points
+    - a point and the plane's normal vector
+
+    Attributes
+    ==========
+
+    p1
+    normal_vector
+
+    Examples
+    ========
+
+    >>> from sympy import Plane, Point3D
+    >>> Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+    Plane(Point3D(1, 1, 1), (-1, 2, -1))
+    >>> Plane((1, 1, 1), (2, 3, 4), (2, 2, 2))
+    Plane(Point3D(1, 1, 1), (-1, 2, -1))
+    >>> Plane(Point3D(1, 1, 1), normal_vector=(1,4,7))
+    Plane(Point3D(1, 1, 1), (1, 4, 7))
+
+    """
+    def __new__(cls, p1, a=None, b=None, **kwargs):
+        p1 = Point3D(p1, dim=3)
+        if a and b:
+            p2 = Point(a, dim=3)
+            p3 = Point(b, dim=3)
+            if Point3D.are_collinear(p1, p2, p3):
+                raise ValueError('Enter three non-collinear points')
+            a = p1.direction_ratio(p2)
+            b = p1.direction_ratio(p3)
+            normal_vector = tuple(Matrix(a).cross(Matrix(b)))
+        else:
+            a = kwargs.pop('normal_vector', a)
+            evaluate = kwargs.get('evaluate', True)
+            if is_sequence(a) and len(a) == 3:
+                normal_vector = Point3D(a).args if evaluate else a
+            else:
+                raise ValueError(filldedent('''
+                    Either provide 3 3D points or a point with a
+                    normal vector expressed as a sequence of length 3'''))
+            if all(coord.is_zero for coord in normal_vector):
+                raise ValueError('Normal vector cannot be zero vector')
+        return GeometryEntity.__new__(cls, p1, normal_vector, **kwargs)
+
+    def __contains__(self, o):
+        k = self.equation(x, y, z)
+        if isinstance(o, (LinearEntity, LinearEntity3D)):
+            d = Point3D(o.arbitrary_point(t))
+            e = k.subs([(x, d.x), (y, d.y), (z, d.z)])
+            return e.equals(0)
+        try:
+            o = Point(o, dim=3, strict=True)
+            d = k.xreplace(dict(zip((x, y, z), o.args)))
+            return d.equals(0)
+        except TypeError:
+            return False
+
+    def _eval_evalf(self, prec=15, **options):
+        pt, tup = self.args
+        dps = prec_to_dps(prec)
+        pt = pt.evalf(n=dps, **options)
+        tup = tuple([i.evalf(n=dps, **options) for i in tup])
+        return self.func(pt, normal_vector=tup, evaluate=False)
+
+    def angle_between(self, o):
+        """Angle between the plane and other geometric entity.
+
+        Parameters
+        ==========
+
+        LinearEntity3D, Plane.
+
+        Returns
+        =======
+
+        angle : angle in radians
+
+        Notes
+        =====
+
+        This method accepts only 3D entities as it's parameter, but if you want
+        to calculate the angle between a 2D entity and a plane you should
+        first convert to a 3D entity by projecting onto a desired plane and
+        then proceed to calculate the angle.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 2, 2), normal_vector=(1, 2, 3))
+        >>> b = Line3D(Point3D(1, 3, 4), Point3D(2, 2, 2))
+        >>> a.angle_between(b)
+        -asin(sqrt(21)/6)
+
+        """
+        if isinstance(o, LinearEntity3D):
+            a = Matrix(self.normal_vector)
+            b = Matrix(o.direction_ratio)
+            c = a.dot(b)
+            d = sqrt(sum(i**2 for i in self.normal_vector))
+            e = sqrt(sum(i**2 for i in o.direction_ratio))
+            return asin(c/(d*e))
+        if isinstance(o, Plane):
+            a = Matrix(self.normal_vector)
+            b = Matrix(o.normal_vector)
+            c = a.dot(b)
+            d = sqrt(sum(i**2 for i in self.normal_vector))
+            e = sqrt(sum(i**2 for i in o.normal_vector))
+            return acos(c/(d*e))
+
+
+    def arbitrary_point(self, u=None, v=None):
+        """ Returns an arbitrary point on the Plane. If given two
+        parameters, the point ranges over the entire plane. If given 1
+        or no parameters, returns a point with one parameter which,
+        when varying from 0 to 2*pi, moves the point in a circle of
+        radius 1 about p1 of the Plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Ray
+        >>> from sympy.abc import u, v, t, r
+        >>> p = Plane((1, 1, 1), normal_vector=(1, 0, 0))
+        >>> p.arbitrary_point(u, v)
+        Point3D(1, u + 1, v + 1)
+        >>> p.arbitrary_point(t)
+        Point3D(1, cos(t) + 1, sin(t) + 1)
+
+        While arbitrary values of u and v can move the point anywhere in
+        the plane, the single-parameter point can be used to construct a
+        ray whose arbitrary point can be located at angle t and radius
+        r from p.p1:
+
+        >>> Ray(p.p1, _).arbitrary_point(r)
+        Point3D(1, r*cos(t) + 1, r*sin(t) + 1)
+
+        Returns
+        =======
+
+        Point3D
+
+        """
+        circle = v is None
+        if circle:
+            u = _symbol(u or 't', real=True)
+        else:
+            u = _symbol(u or 'u', real=True)
+            v = _symbol(v or 'v', real=True)
+        x, y, z = self.normal_vector
+        a, b, c = self.p1.args
+        # x1, y1, z1 is a nonzero vector parallel to the plane
+        if x.is_zero and y.is_zero:
+            x1, y1, z1 = S.One, S.Zero, S.Zero
+        else:
+            x1, y1, z1 = -y, x, S.Zero
+        # x2, y2, z2 is also parallel to the plane, and orthogonal to x1, y1, z1
+        x2, y2, z2 = tuple(Matrix((x, y, z)).cross(Matrix((x1, y1, z1))))
+        if circle:
+            x1, y1, z1 = (w/sqrt(x1**2 + y1**2 + z1**2) for w in (x1, y1, z1))
+            x2, y2, z2 = (w/sqrt(x2**2 + y2**2 + z2**2) for w in (x2, y2, z2))
+            p = Point3D(a + x1*cos(u) + x2*sin(u), \
+                        b + y1*cos(u) + y2*sin(u), \
+                        c + z1*cos(u) + z2*sin(u))
+        else:
+            p = Point3D(a + x1*u + x2*v, b + y1*u + y2*v, c + z1*u + z2*v)
+        return p
+
+
+    @staticmethod
+    def are_concurrent(*planes):
+        """Is a sequence of Planes concurrent?
+
+        Two or more Planes are concurrent if their intersections
+        are a common line.
+
+        Parameters
+        ==========
+
+        planes: list
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(5, 0, 0), normal_vector=(1, -1, 1))
+        >>> b = Plane(Point3D(0, -2, 0), normal_vector=(3, 1, 1))
+        >>> c = Plane(Point3D(0, -1, 0), normal_vector=(5, -1, 9))
+        >>> Plane.are_concurrent(a, b)
+        True
+        >>> Plane.are_concurrent(a, b, c)
+        False
+
+        """
+        planes = list(uniq(planes))
+        for i in planes:
+            if not isinstance(i, Plane):
+                raise ValueError('All objects should be Planes but got %s' % i.func)
+        if len(planes) < 2:
+            return False
+        planes = list(planes)
+        first = planes.pop(0)
+        sol = first.intersection(planes[0])
+        if sol == []:
+            return False
+        else:
+            line = sol[0]
+            for i in planes[1:]:
+                l = first.intersection(i)
+                if not l or l[0] not in line:
+                    return False
+            return True
+
+
+    def distance(self, o):
+        """Distance between the plane and another geometric entity.
+
+        Parameters
+        ==========
+
+        Point3D, LinearEntity3D, Plane.
+
+        Returns
+        =======
+
+        distance
+
+        Notes
+        =====
+
+        This method accepts only 3D entities as it's parameter, but if you want
+        to calculate the distance between a 2D entity and a plane you should
+        first convert to a 3D entity by projecting onto a desired plane and
+        then proceed to calculate the distance.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+        >>> b = Point3D(1, 2, 3)
+        >>> a.distance(b)
+        sqrt(3)
+        >>> c = Line3D(Point3D(2, 3, 1), Point3D(1, 2, 2))
+        >>> a.distance(c)
+        0
+
+        """
+        if self.intersection(o) != []:
+            return S.Zero
+
+        if isinstance(o, (Segment3D, Ray3D)):
+            a, b = o.p1, o.p2
+            pi, = self.intersection(Line3D(a, b))
+            if pi in o:
+                return self.distance(pi)
+            elif a in Segment3D(pi, b):
+                return self.distance(a)
+            else:
+                assert isinstance(o, Segment3D) is True
+                return self.distance(b)
+
+        # following code handles `Point3D`, `LinearEntity3D`, `Plane`
+        a = o if isinstance(o, Point3D) else o.p1
+        n = Point3D(self.normal_vector).unit
+        d = (a - self.p1).dot(n)
+        return abs(d)
+
+
+    def equals(self, o):
+        """
+        Returns True if self and o are the same mathematical entities.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+        >>> b = Plane(Point3D(1, 2, 3), normal_vector=(2, 2, 2))
+        >>> c = Plane(Point3D(1, 2, 3), normal_vector=(-1, 4, 6))
+        >>> a.equals(a)
+        True
+        >>> a.equals(b)
+        True
+        >>> a.equals(c)
+        False
+        """
+        if isinstance(o, Plane):
+            a = self.equation()
+            b = o.equation()
+            return cancel(a/b).is_constant()
+        else:
+            return False
+
+
+    def equation(self, x=None, y=None, z=None):
+        """The equation of the Plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 2), Point3D(2, 4, 7), Point3D(3, 5, 1))
+        >>> a.equation()
+        -23*x + 11*y - 2*z + 16
+        >>> a = Plane(Point3D(1, 4, 2), normal_vector=(6, 6, 6))
+        >>> a.equation()
+        6*x + 6*y + 6*z - 42
+
+        """
+        x, y, z = [i if i else Symbol(j, real=True) for i, j in zip((x, y, z), 'xyz')]
+        a = Point3D(x, y, z)
+        b = self.p1.direction_ratio(a)
+        c = self.normal_vector
+        return (sum(i*j for i, j in zip(b, c)))
+
+
+    def intersection(self, o):
+        """ The intersection with other geometrical entity.
+
+        Parameters
+        ==========
+
+        Point, Point3D, LinearEntity, LinearEntity3D, Plane
+
+        Returns
+        =======
+
+        List
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Line3D, Plane
+        >>> a = Plane(Point3D(1, 2, 3), normal_vector=(1, 1, 1))
+        >>> b = Point3D(1, 2, 3)
+        >>> a.intersection(b)
+        [Point3D(1, 2, 3)]
+        >>> c = Line3D(Point3D(1, 4, 7), Point3D(2, 2, 2))
+        >>> a.intersection(c)
+        [Point3D(2, 2, 2)]
+        >>> d = Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+        >>> e = Plane(Point3D(2, 0, 0), normal_vector=(3, 4, -3))
+        >>> d.intersection(e)
+        [Line3D(Point3D(78/23, -24/23, 0), Point3D(147/23, 321/23, 23))]
+
+        """
+        if not isinstance(o, GeometryEntity):
+            o = Point(o, dim=3)
+        if isinstance(o, Point):
+            if o in self:
+                return [o]
+            else:
+                return []
+        if isinstance(o, (LinearEntity, LinearEntity3D)):
+            # recast to 3D
+            p1, p2 = o.p1, o.p2
+            if isinstance(o, Segment):
+                o = Segment3D(p1, p2)
+            elif isinstance(o, Ray):
+                o = Ray3D(p1, p2)
+            elif isinstance(o, Line):
+                o = Line3D(p1, p2)
+            else:
+                raise ValueError('unhandled linear entity: %s' % o.func)
+            if o in self:
+                return [o]
+            else:
+                a = Point3D(o.arbitrary_point(t))
+                p1, n = self.p1, Point3D(self.normal_vector)
+
+                # TODO: Replace solve with solveset, when this line is tested
+                c = solve((a - p1).dot(n), t)
+                if not c:
+                    return []
+                else:
+                    c = [i for i in c if i.is_real is not False]
+                    if len(c) > 1:
+                        c = [i for i in c if i.is_real]
+                    if len(c) != 1:
+                        raise Undecidable("not sure which point is real")
+                    p = a.subs(t, c[0])
+                    if p not in o:
+                        return []  # e.g. a segment might not intersect a plane
+                    return [p]
+        if isinstance(o, Plane):
+            if self.equals(o):
+                return [self]
+            if self.is_parallel(o):
+                return []
+            else:
+                x, y, z = map(Dummy, 'xyz')
+                a, b = Matrix([self.normal_vector]), Matrix([o.normal_vector])
+                c = list(a.cross(b))
+                d = self.equation(x, y, z)
+                e = o.equation(x, y, z)
+                result = list(linsolve([d, e], x, y, z))[0]
+                for i in (x, y, z): result = result.subs(i, 0)
+                return [Line3D(Point3D(result), direction_ratio=c)]
+
+
+    def is_coplanar(self, o):
+        """ Returns True if `o` is coplanar with self, else False.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane
+        >>> o = (0, 0, 0)
+        >>> p = Plane(o, (1, 1, 1))
+        >>> p2 = Plane(o, (2, 2, 2))
+        >>> p == p2
+        False
+        >>> p.is_coplanar(p2)
+        True
+        """
+        if isinstance(o, Plane):
+            return not cancel(self.equation(x, y, z)/o.equation(x, y, z)).has(x, y, z)
+        if isinstance(o, Point3D):
+            return o in self
+        elif isinstance(o, LinearEntity3D):
+            return all(i in self for i in self)
+        elif isinstance(o, GeometryEntity):  # XXX should only be handling 2D objects now
+            return all(i == 0 for i in self.normal_vector[:2])
+
+
+    def is_parallel(self, l):
+        """Is the given geometric entity parallel to the plane?
+
+        Parameters
+        ==========
+
+        LinearEntity3D or Plane
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> b = Plane(Point3D(3,1,3), normal_vector=(4, 8, 12))
+        >>> a.is_parallel(b)
+        True
+
+        """
+        if isinstance(l, LinearEntity3D):
+            a = l.direction_ratio
+            b = self.normal_vector
+            return sum(i*j for i, j in zip(a, b)) == 0
+        if isinstance(l, Plane):
+            a = Matrix(l.normal_vector)
+            b = Matrix(self.normal_vector)
+            return bool(a.cross(b).is_zero_matrix)
+
+
+    def is_perpendicular(self, l):
+        """Is the given geometric entity perpendicualar to the given plane?
+
+        Parameters
+        ==========
+
+        LinearEntity3D or Plane
+
+        Returns
+        =======
+
+        Boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> b = Plane(Point3D(2, 2, 2), normal_vector=(-1, 2, -1))
+        >>> a.is_perpendicular(b)
+        True
+
+        """
+        if isinstance(l, LinearEntity3D):
+            a = Matrix(l.direction_ratio)
+            b = Matrix(self.normal_vector)
+            if a.cross(b).is_zero_matrix:
+                return True
+            else:
+                return False
+        elif isinstance(l, Plane):
+            a = Matrix(l.normal_vector)
+            b = Matrix(self.normal_vector)
+            if a.dot(b) == 0:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    @property
+    def normal_vector(self):
+        """Normal vector of the given plane.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+        >>> a.normal_vector
+        (-1, 2, -1)
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 4, 7))
+        >>> a.normal_vector
+        (1, 4, 7)
+
+        """
+        return self.args[1]
+
+    @property
+    def p1(self):
+        """The only defining point of the plane. Others can be obtained from the
+        arbitrary_point method.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D, Plane
+        >>> a = Plane(Point3D(1, 1, 1), Point3D(2, 3, 4), Point3D(2, 2, 2))
+        >>> a.p1
+        Point3D(1, 1, 1)
+
+        """
+        return self.args[0]
+
+    def parallel_plane(self, pt):
+        """
+        Plane parallel to the given plane and passing through the point pt.
+
+        Parameters
+        ==========
+
+        pt: Point3D
+
+        Returns
+        =======
+
+        Plane
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1, 4, 6), normal_vector=(2, 4, 6))
+        >>> a.parallel_plane(Point3D(2, 3, 5))
+        Plane(Point3D(2, 3, 5), (2, 4, 6))
+
+        """
+        a = self.normal_vector
+        return Plane(pt, normal_vector=a)
+
+    def perpendicular_line(self, pt):
+        """A line perpendicular to the given plane.
+
+        Parameters
+        ==========
+
+        pt: Point3D
+
+        Returns
+        =======
+
+        Line3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a = Plane(Point3D(1,4,6), normal_vector=(2, 4, 6))
+        >>> a.perpendicular_line(Point3D(9, 8, 7))
+        Line3D(Point3D(9, 8, 7), Point3D(11, 12, 13))
+
+        """
+        a = self.normal_vector
+        return Line3D(pt, direction_ratio=a)
+
+    def perpendicular_plane(self, *pts):
+        """
+        Return a perpendicular passing through the given points. If the
+        direction ratio between the points is the same as the Plane's normal
+        vector then, to select from the infinite number of possible planes,
+        a third point will be chosen on the z-axis (or the y-axis
+        if the normal vector is already parallel to the z-axis). If less than
+        two points are given they will be supplied as follows: if no point is
+        given then pt1 will be self.p1; if a second point is not given it will
+        be a point through pt1 on a line parallel to the z-axis (if the normal
+        is not already the z-axis, otherwise on the line parallel to the
+        y-axis).
+
+        Parameters
+        ==========
+
+        pts: 0, 1 or 2 Point3D
+
+        Returns
+        =======
+
+        Plane
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+        >>> Z = (0, 0, 1)
+        >>> p = Plane(a, normal_vector=Z)
+        >>> p.perpendicular_plane(a, b)
+        Plane(Point3D(0, 0, 0), (1, 0, 0))
+        """
+        if len(pts) > 2:
+            raise ValueError('No more than 2 pts should be provided.')
+
+        pts = list(pts)
+        if len(pts) == 0:
+            pts.append(self.p1)
+        if len(pts) == 1:
+            x, y, z = self.normal_vector
+            if x == y == 0:
+                dir = (0, 1, 0)
+            else:
+                dir = (0, 0, 1)
+            pts.append(pts[0] + Point3D(*dir))
+
+        p1, p2 = [Point(i, dim=3) for i in pts]
+        l = Line3D(p1, p2)
+        n = Line3D(p1, direction_ratio=self.normal_vector)
+        if l in n:  # XXX should an error be raised instead?
+            # there are infinitely many perpendicular planes;
+            x, y, z = self.normal_vector
+            if x == y == 0:
+                # the z axis is the normal so pick a pt on the y-axis
+                p3 = Point3D(0, 1, 0)  # case 1
+            else:
+                # else pick a pt on the z axis
+                p3 = Point3D(0, 0, 1)  # case 2
+            # in case that point is already given, move it a bit
+            if p3 in l:
+                p3 *= 2  # case 3
+        else:
+            p3 = p1 + Point3D(*self.normal_vector)  # case 4
+        return Plane(p1, p2, p3)
+
+    def projection_line(self, line):
+        """Project the given line onto the plane through the normal plane
+        containing the line.
+
+        Parameters
+        ==========
+
+        LinearEntity or LinearEntity3D
+
+        Returns
+        =======
+
+        Point3D, Line3D, Ray3D or Segment3D
+
+        Notes
+        =====
+
+        For the interaction between 2D and 3D lines(segments, rays), you should
+        convert the line to 3D by using this method. For example for finding the
+        intersection between a 2D and a 3D line, convert the 2D line to a 3D line
+        by projecting it on a required plane and then proceed to find the
+        intersection between those lines.
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Line, Line3D, Point3D
+        >>> a = Plane(Point3D(1, 1, 1), normal_vector=(1, 1, 1))
+        >>> b = Line(Point3D(1, 1), Point3D(2, 2))
+        >>> a.projection_line(b)
+        Line3D(Point3D(4/3, 4/3, 1/3), Point3D(5/3, 5/3, -1/3))
+        >>> c = Line3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+        >>> a.projection_line(c)
+        Point3D(1, 1, 1)
+
+        """
+        if not isinstance(line, (LinearEntity, LinearEntity3D)):
+            raise NotImplementedError('Enter a linear entity only')
+        a, b = self.projection(line.p1), self.projection(line.p2)
+        if a == b:
+            # projection does not imply intersection so for
+            # this case (line parallel to plane's normal) we
+            # return the projection point
+            return a
+        if isinstance(line, (Line, Line3D)):
+            return Line3D(a, b)
+        if isinstance(line, (Ray, Ray3D)):
+            return Ray3D(a, b)
+        if isinstance(line, (Segment, Segment3D)):
+            return Segment3D(a, b)
+
+    def projection(self, pt):
+        """Project the given point onto the plane along the plane normal.
+
+        Parameters
+        ==========
+
+        Point or Point3D
+
+        Returns
+        =======
+
+        Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane, Point3D
+        >>> A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+
+        The projection is along the normal vector direction, not the z
+        axis, so (1, 1) does not project to (1, 1, 2) on the plane A:
+
+        >>> b = Point3D(1, 1)
+        >>> A.projection(b)
+        Point3D(5/3, 5/3, 2/3)
+        >>> _ in A
+        True
+
+        But the point (1, 1, 2) projects to (1, 1) on the XY-plane:
+
+        >>> XY = Plane((0, 0, 0), (0, 0, 1))
+        >>> XY.projection((1, 1, 2))
+        Point3D(1, 1, 0)
+        """
+        rv = Point(pt, dim=3)
+        if rv in self:
+            return rv
+        return self.intersection(Line3D(rv, rv + Point3D(self.normal_vector)))[0]
+
+    def random_point(self, seed=None):
+        """ Returns a random point on the Plane.
+
+        Returns
+        =======
+
+        Point3D
+
+        Examples
+        ========
+
+        >>> from sympy import Plane
+        >>> p = Plane((1, 0, 0), normal_vector=(0, 1, 0))
+        >>> r = p.random_point(seed=42)  # seed value is optional
+        >>> r.n(3)
+        Point3D(2.29, 0, -1.35)
+
+        The random point can be moved to lie on the circle of radius
+        1 centered on p1:
+
+        >>> c = p.p1 + (r - p.p1).unit
+        >>> c.distance(p.p1).equals(1)
+        True
+        """
+        if seed is not None:
+            rng = random.Random(seed)
+        else:
+            rng = random
+        params = {
+            x: 2*Rational(rng.gauss(0, 1)) - 1,
+            y: 2*Rational(rng.gauss(0, 1)) - 1}
+        return self.arbitrary_point(x, y).subs(params)
+
+    def parameter_value(self, other, u, v=None):
+        """Return the parameter(s) corresponding to the given point.
+
+        Examples
+        ========
+
+        >>> from sympy import pi, Plane
+        >>> from sympy.abc import t, u, v
+        >>> p = Plane((2, 0, 0), (0, 0, 1), (0, 1, 0))
+
+        By default, the parameter value returned defines a point
+        that is a distance of 1 from the Plane's p1 value and
+        in line with the given point:
+
+        >>> on_circle = p.arbitrary_point(t).subs(t, pi/4)
+        >>> on_circle.distance(p.p1)
+        1
+        >>> p.parameter_value(on_circle, t)
+        {t: pi/4}
+
+        Moving the point twice as far from p1 does not change
+        the parameter value:
+
+        >>> off_circle = p.p1 + (on_circle - p.p1)*2
+        >>> off_circle.distance(p.p1)
+        2
+        >>> p.parameter_value(off_circle, t)
+        {t: pi/4}
+
+        If the 2-value parameter is desired, supply the two
+        parameter symbols and a replacement dictionary will
+        be returned:
+
+        >>> p.parameter_value(on_circle, u, v)
+        {u: sqrt(10)/10, v: sqrt(10)/30}
+        >>> p.parameter_value(off_circle, u, v)
+        {u: sqrt(10)/5, v: sqrt(10)/15}
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if not isinstance(other, Point):
+            raise ValueError("other must be a point")
+        if other == self.p1:
+            return other
+        if isinstance(u, Symbol) and v is None:
+            delta = self.arbitrary_point(u) - self.p1
+            eq = delta - (other - self.p1).unit
+            sol = solve(eq, u, dict=True)
+        elif isinstance(u, Symbol) and isinstance(v, Symbol):
+            pt = self.arbitrary_point(u, v)
+            sol = solve(pt - other, (u, v), dict=True)
+        else:
+            raise ValueError('expecting 1 or 2 symbols')
+        if not sol:
+            raise ValueError("Given point is not on %s" % func_name(self))
+        return sol[0]  # {t: tval} or {u: uval, v: vval}
+
+    @property
+    def ambient_dimension(self):
+        return self.p1.ambient_dimension
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/point.py b/.venv/lib/python3.12/site-packages/sympy/geometry/point.py
new file mode 100644
index 0000000000000000000000000000000000000000..19e6c566f06de4df086912470dc35d0f4af3bd38
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/point.py
@@ -0,0 +1,1378 @@
+"""Geometrical Points.
+
+Contains
+========
+Point
+Point2D
+Point3D
+
+When methods of Point require 1 or more points as arguments, they
+can be passed as a sequence of coordinates or Points:
+
+>>> from sympy import Point
+>>> Point(1, 1).is_collinear((2, 2), (3, 4))
+False
+>>> Point(1, 1).is_collinear(Point(2, 2), Point(3, 4))
+False
+
+"""
+
+import warnings
+
+from sympy.core import S, sympify, Expr
+from sympy.core.add import Add
+from sympy.core.containers import Tuple
+from sympy.core.numbers import Float
+from sympy.core.parameters import global_parameters
+from sympy.simplify.simplify import nsimplify, simplify
+from sympy.geometry.exceptions import GeometryError
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.complexes import im
+from sympy.functions.elementary.trigonometric import cos, sin
+from sympy.matrices import Matrix
+from sympy.matrices.expressions import Transpose
+from sympy.utilities.iterables import uniq, is_sequence
+from sympy.utilities.misc import filldedent, func_name, Undecidable
+
+from .entity import GeometryEntity
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+
+class Point(GeometryEntity):
+    """A point in a n-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords : sequence of n-coordinate values. In the special
+        case where n=2 or 3, a Point2D or Point3D will be created
+        as appropriate.
+    evaluate : if `True` (default), all floats are turn into
+        exact types.
+    dim : number of coordinates the point should have.  If coordinates
+        are unspecified, they are padded with zeros.
+    on_morph : indicates what should happen when the number of
+        coordinates of a point need to be changed by adding or
+        removing zeros.  Possible values are `'warn'`, `'error'`, or
+        `ignore` (default).  No warning or error is given when `*args`
+        is empty and `dim` is given. An error is always raised when
+        trying to remove nonzero coordinates.
+
+
+    Attributes
+    ==========
+
+    length
+    origin: A `Point` representing the origin of the
+        appropriately-dimensioned space.
+
+    Raises
+    ======
+
+    TypeError : When instantiating with anything but a Point or sequence
+    ValueError : when instantiating with a sequence with length < 2 or
+        when trying to reduce dimensions if keyword `on_morph='error'` is
+        set.
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment : Connects two Points
+
+    Examples
+    ========
+
+    >>> from sympy import Point
+    >>> from sympy.abc import x
+    >>> Point(1, 2, 3)
+    Point3D(1, 2, 3)
+    >>> Point([1, 2])
+    Point2D(1, 2)
+    >>> Point(0, x)
+    Point2D(0, x)
+    >>> Point(dim=4)
+    Point(0, 0, 0, 0)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point(0.5, 0.25)
+    Point2D(1/2, 1/4)
+    >>> Point(0.5, 0.25, evaluate=False)
+    Point2D(0.5, 0.25)
+
+    """
+
+    is_Point = True
+
+    def __new__(cls, *args, **kwargs):
+        evaluate = kwargs.get('evaluate', global_parameters.evaluate)
+        on_morph = kwargs.get('on_morph', 'ignore')
+
+        # unpack into coords
+        coords = args[0] if len(args) == 1 else args
+
+        # check args and handle quickly handle Point instances
+        if isinstance(coords, Point):
+            # even if we're mutating the dimension of a point, we
+            # don't reevaluate its coordinates
+            evaluate = False
+            if len(coords) == kwargs.get('dim', len(coords)):
+                return coords
+
+        if not is_sequence(coords):
+            raise TypeError(filldedent('''
+                Expecting sequence of coordinates, not `{}`'''
+                                       .format(func_name(coords))))
+        # A point where only `dim` is specified is initialized
+        # to zeros.
+        if len(coords) == 0 and kwargs.get('dim', None):
+            coords = (S.Zero,)*kwargs.get('dim')
+
+        coords = Tuple(*coords)
+        dim = kwargs.get('dim', len(coords))
+
+        if len(coords) < 2:
+            raise ValueError(filldedent('''
+                Point requires 2 or more coordinates or
+                keyword `dim` > 1.'''))
+        if len(coords) != dim:
+            message = ("Dimension of {} needs to be changed "
+                       "from {} to {}.").format(coords, len(coords), dim)
+            if on_morph == 'ignore':
+                pass
+            elif on_morph == "error":
+                raise ValueError(message)
+            elif on_morph == 'warn':
+                warnings.warn(message, stacklevel=2)
+            else:
+                raise ValueError(filldedent('''
+                        on_morph value should be 'error',
+                        'warn' or 'ignore'.'''))
+        if any(coords[dim:]):
+            raise ValueError('Nonzero coordinates cannot be removed.')
+        if any(a.is_number and im(a).is_zero is False for a in coords):
+            raise ValueError('Imaginary coordinates are not permitted.')
+        if not all(isinstance(a, Expr) for a in coords):
+            raise TypeError('Coordinates must be valid SymPy expressions.')
+
+        # pad with zeros appropriately
+        coords = coords[:dim] + (S.Zero,)*(dim - len(coords))
+
+        # Turn any Floats into rationals and simplify
+        # any expressions before we instantiate
+        if evaluate:
+            coords = coords.xreplace({
+                f: simplify(nsimplify(f, rational=True))
+                 for f in coords.atoms(Float)})
+
+        # return 2D or 3D instances
+        if len(coords) == 2:
+            kwargs['_nocheck'] = True
+            return Point2D(*coords, **kwargs)
+        elif len(coords) == 3:
+            kwargs['_nocheck'] = True
+            return Point3D(*coords, **kwargs)
+
+        # the general Point
+        return GeometryEntity.__new__(cls, *coords)
+
+    def __abs__(self):
+        """Returns the distance between this point and the origin."""
+        origin = Point([0]*len(self))
+        return Point.distance(origin, self)
+
+    def __add__(self, other):
+        """Add other to self by incrementing self's coordinates by
+        those of other.
+
+        Notes
+        =====
+
+        >>> from sympy import Point
+
+        When sequences of coordinates are passed to Point methods, they
+        are converted to a Point internally. This __add__ method does
+        not do that so if floating point values are used, a floating
+        point result (in terms of SymPy Floats) will be returned.
+
+        >>> Point(1, 2) + (.1, .2)
+        Point2D(1.1, 2.2)
+
+        If this is not desired, the `translate` method can be used or
+        another Point can be added:
+
+        >>> Point(1, 2).translate(.1, .2)
+        Point2D(11/10, 11/5)
+        >>> Point(1, 2) + Point(.1, .2)
+        Point2D(11/10, 11/5)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.translate
+
+        """
+        try:
+            s, o = Point._normalize_dimension(self, Point(other, evaluate=False))
+        except TypeError:
+            raise GeometryError("Don't know how to add {} and a Point object".format(other))
+
+        coords = [simplify(a + b) for a, b in zip(s, o)]
+        return Point(coords, evaluate=False)
+
+    def __contains__(self, item):
+        return item in self.args
+
+    def __truediv__(self, divisor):
+        """Divide point's coordinates by a factor."""
+        divisor = sympify(divisor)
+        coords = [simplify(x/divisor) for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __eq__(self, other):
+        if not isinstance(other, Point) or len(self.args) != len(other.args):
+            return False
+        return self.args == other.args
+
+    def __getitem__(self, key):
+        return self.args[key]
+
+    def __hash__(self):
+        return hash(self.args)
+
+    def __iter__(self):
+        return self.args.__iter__()
+
+    def __len__(self):
+        return len(self.args)
+
+    def __mul__(self, factor):
+        """Multiply point's coordinates by a factor.
+
+        Notes
+        =====
+
+        >>> from sympy import Point
+
+        When multiplying a Point by a floating point number,
+        the coordinates of the Point will be changed to Floats:
+
+        >>> Point(1, 2)*0.1
+        Point2D(0.1, 0.2)
+
+        If this is not desired, the `scale` method can be used or
+        else only multiply or divide by integers:
+
+        >>> Point(1, 2).scale(1.1, 1.1)
+        Point2D(11/10, 11/5)
+        >>> Point(1, 2)*11/10
+        Point2D(11/10, 11/5)
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.scale
+        """
+        factor = sympify(factor)
+        coords = [simplify(x*factor) for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __rmul__(self, factor):
+        """Multiply a factor by point's coordinates."""
+        return self.__mul__(factor)
+
+    def __neg__(self):
+        """Negate the point."""
+        coords = [-x for x in self.args]
+        return Point(coords, evaluate=False)
+
+    def __sub__(self, other):
+        """Subtract two points, or subtract a factor from this point's
+        coordinates."""
+        return self + [-x for x in other]
+
+    @classmethod
+    def _normalize_dimension(cls, *points, **kwargs):
+        """Ensure that points have the same dimension.
+        By default `on_morph='warn'` is passed to the
+        `Point` constructor."""
+        # if we have a built-in ambient dimension, use it
+        dim = getattr(cls, '_ambient_dimension', None)
+        # override if we specified it
+        dim = kwargs.get('dim', dim)
+        # if no dim was given, use the highest dimensional point
+        if dim is None:
+            dim = max(i.ambient_dimension for i in points)
+        if all(i.ambient_dimension == dim for i in points):
+            return list(points)
+        kwargs['dim'] = dim
+        kwargs['on_morph'] = kwargs.get('on_morph', 'warn')
+        return [Point(i, **kwargs) for i in points]
+
+    @staticmethod
+    def affine_rank(*args):
+        """The affine rank of a set of points is the dimension
+        of the smallest affine space containing all the points.
+        For example, if the points lie on a line (and are not all
+        the same) their affine rank is 1.  If the points lie on a plane
+        but not a line, their affine rank is 2.  By convention, the empty
+        set has affine rank -1."""
+
+        if len(args) == 0:
+            return -1
+        # make sure we're genuinely points
+        # and translate every point to the origin
+        points = Point._normalize_dimension(*[Point(i) for i in args])
+        origin = points[0]
+        points = [i - origin for i in points[1:]]
+
+        m = Matrix([i.args for i in points])
+        # XXX fragile -- what is a better way?
+        return m.rank(iszerofunc = lambda x:
+            abs(x.n(2)) < 1e-12 if x.is_number else x.is_zero)
+
+    @property
+    def ambient_dimension(self):
+        """Number of components this point has."""
+        return getattr(self, '_ambient_dimension', len(self))
+
+    @classmethod
+    def are_coplanar(cls, *points):
+        """Return True if there exists a plane in which all the points
+        lie.  A trivial True value is returned if `len(points) < 3` or
+        all Points are 2-dimensional.
+
+        Parameters
+        ==========
+
+        A set of points
+
+        Raises
+        ======
+
+        ValueError : if less than 3 unique points are given
+
+        Returns
+        =======
+
+        boolean
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 2)
+        >>> p2 = Point3D(2, 7, 2)
+        >>> p3 = Point3D(0, 0, 2)
+        >>> p4 = Point3D(1, 1, 2)
+        >>> Point3D.are_coplanar(p1, p2, p3, p4)
+        True
+        >>> p5 = Point3D(0, 1, 3)
+        >>> Point3D.are_coplanar(p1, p2, p3, p5)
+        False
+
+        """
+        if len(points) <= 1:
+            return True
+
+        points = cls._normalize_dimension(*[Point(i) for i in points])
+        # quick exit if we are in 2D
+        if points[0].ambient_dimension == 2:
+            return True
+        points = list(uniq(points))
+        return Point.affine_rank(*points) <= 2
+
+    def distance(self, other):
+        """The Euclidean distance between self and another GeometricEntity.
+
+        Returns
+        =======
+
+        distance : number or symbolic expression.
+
+        Raises
+        ======
+
+        TypeError : if other is not recognized as a GeometricEntity or is a
+                    GeometricEntity for which distance is not defined.
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.length
+        sympy.geometry.point.Point.taxicab_distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Line
+        >>> p1, p2 = Point(1, 1), Point(4, 5)
+        >>> l = Line((3, 1), (2, 2))
+        >>> p1.distance(p2)
+        5
+        >>> p1.distance(l)
+        sqrt(2)
+
+        The computed distance may be symbolic, too:
+
+        >>> from sympy.abc import x, y
+        >>> p3 = Point(x, y)
+        >>> p3.distance((0, 0))
+        sqrt(x**2 + y**2)
+
+        """
+        if not isinstance(other, GeometryEntity):
+            try:
+                other = Point(other, dim=self.ambient_dimension)
+            except TypeError:
+                raise TypeError("not recognized as a GeometricEntity: %s" % type(other))
+        if isinstance(other, Point):
+            s, p = Point._normalize_dimension(self, Point(other))
+            return sqrt(Add(*((a - b)**2 for a, b in zip(s, p))))
+        distance = getattr(other, 'distance', None)
+        if distance is None:
+            raise TypeError("distance between Point and %s is not defined" % type(other))
+        return distance(self)
+
+    def dot(self, p):
+        """Return dot product of self with another Point."""
+        if not is_sequence(p):
+            p = Point(p)  # raise the error via Point
+        return Add(*(a*b for a, b in zip(self, p)))
+
+    def equals(self, other):
+        """Returns whether the coordinates of self and other agree."""
+        # a point is equal to another point if all its components are equal
+        if not isinstance(other, Point) or len(self) != len(other):
+            return False
+        return all(a.equals(b) for a, b in zip(self, other))
+
+    def _eval_evalf(self, prec=15, **options):
+        """Evaluate the coordinates of the point.
+
+        This method will, where possible, create and return a new Point
+        where the coordinates are evaluated as floating point numbers to
+        the precision indicated (default=15).
+
+        Parameters
+        ==========
+
+        prec : int
+
+        Returns
+        =======
+
+        point : Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Rational
+        >>> p1 = Point(Rational(1, 2), Rational(3, 2))
+        >>> p1
+        Point2D(1/2, 3/2)
+        >>> p1.evalf()
+        Point2D(0.5, 1.5)
+
+        """
+        dps = prec_to_dps(prec)
+        coords = [x.evalf(n=dps, **options) for x in self.args]
+        return Point(*coords, evaluate=False)
+
+    def intersection(self, other):
+        """The intersection between this point and another GeometryEntity.
+
+        Parameters
+        ==========
+
+        other : GeometryEntity or sequence of coordinates
+
+        Returns
+        =======
+
+        intersection : list of Points
+
+        Notes
+        =====
+
+        The return value will either be an empty list if there is no
+        intersection, otherwise it will contain this point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 1), Point(0, 0)
+        >>> p1.intersection(p2)
+        []
+        >>> p1.intersection(p3)
+        [Point2D(0, 0)]
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other)
+        if isinstance(other, Point):
+            if self == other:
+                return [self]
+            p1, p2 = Point._normalize_dimension(self, other)
+            if p1 == self and p1 == p2:
+                return [self]
+            return []
+        return other.intersection(self)
+
+    def is_collinear(self, *args):
+        """Returns `True` if there exists a line
+        that contains `self` and `points`.  Returns `False` otherwise.
+        A trivially True value is returned if no points are given.
+
+        Parameters
+        ==========
+
+        args : sequence of Points
+
+        Returns
+        =======
+
+        is_collinear : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> from sympy.abc import x
+        >>> p1, p2 = Point(0, 0), Point(1, 1)
+        >>> p3, p4, p5 = Point(2, 2), Point(x, x), Point(1, 2)
+        >>> Point.is_collinear(p1, p2, p3, p4)
+        True
+        >>> Point.is_collinear(p1, p2, p3, p5)
+        False
+
+        """
+        points = (self,) + args
+        points = Point._normalize_dimension(*[Point(i) for i in points])
+        points = list(uniq(points))
+        return Point.affine_rank(*points) <= 1
+
+    def is_concyclic(self, *args):
+        """Do `self` and the given sequence of points lie in a circle?
+
+        Returns True if the set of points are concyclic and
+        False otherwise. A trivial value of True is returned
+        if there are fewer than 2 other points.
+
+        Parameters
+        ==========
+
+        args : sequence of Points
+
+        Returns
+        =======
+
+        is_concyclic : boolean
+
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+
+        Define 4 points that are on the unit circle:
+
+        >>> p1, p2, p3, p4 = Point(1, 0), (0, 1), (-1, 0), (0, -1)
+
+        >>> p1.is_concyclic() == p1.is_concyclic(p2, p3, p4) == True
+        True
+
+        Define a point not on that circle:
+
+        >>> p = Point(1, 1)
+
+        >>> p.is_concyclic(p1, p2, p3)
+        False
+
+        """
+        points = (self,) + args
+        points = Point._normalize_dimension(*[Point(i) for i in points])
+        points = list(uniq(points))
+        if not Point.affine_rank(*points) <= 2:
+            return False
+        origin = points[0]
+        points = [p - origin for p in points]
+        # points are concyclic if they are coplanar and
+        # there is a point c so that ||p_i-c|| == ||p_j-c|| for all
+        # i and j.  Rearranging this equation gives us the following
+        # condition: the matrix `mat` must not a pivot in the last
+        # column.
+        mat = Matrix([list(i) + [i.dot(i)] for i in points])
+        rref, pivots = mat.rref()
+        if len(origin) not in pivots:
+            return True
+        return False
+
+    @property
+    def is_nonzero(self):
+        """True if any coordinate is nonzero, False if every coordinate is zero,
+        and None if it cannot be determined."""
+        is_zero = self.is_zero
+        if is_zero is None:
+            return None
+        return not is_zero
+
+    def is_scalar_multiple(self, p):
+        """Returns whether each coordinate of `self` is a scalar
+        multiple of the corresponding coordinate in point p.
+        """
+        s, o = Point._normalize_dimension(self, Point(p))
+        # 2d points happen a lot, so optimize this function call
+        if s.ambient_dimension == 2:
+            (x1, y1), (x2, y2) = s.args, o.args
+            rv = (x1*y2 - x2*y1).equals(0)
+            if rv is None:
+                raise Undecidable(filldedent(
+                    '''Cannot determine if %s is a scalar multiple of
+                    %s''' % (s, o)))
+
+        # if the vectors p1 and p2 are linearly dependent, then they must
+        # be scalar multiples of each other
+        m = Matrix([s.args, o.args])
+        return m.rank() < 2
+
+    @property
+    def is_zero(self):
+        """True if every coordinate is zero, False if any coordinate is not zero,
+        and None if it cannot be determined."""
+        nonzero = [x.is_nonzero for x in self.args]
+        if any(nonzero):
+            return False
+        if any(x is None for x in nonzero):
+            return None
+        return True
+
+    @property
+    def length(self):
+        """
+        Treating a Point as a Line, this returns 0 for the length of a Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p = Point(0, 1)
+        >>> p.length
+        0
+        """
+        return S.Zero
+
+    def midpoint(self, p):
+        """The midpoint between self and point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        midpoint : Point
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(13, 5)
+        >>> p1.midpoint(p2)
+        Point2D(7, 3)
+
+        """
+        s, p = Point._normalize_dimension(self, Point(p))
+        return Point([simplify((a + b)*S.Half) for a, b in zip(s, p)])
+
+    @property
+    def origin(self):
+        """A point of all zeros of the same ambient dimension
+        as the current point"""
+        return Point([0]*len(self), evaluate=False)
+
+    @property
+    def orthogonal_direction(self):
+        """Returns a non-zero point that is orthogonal to the
+        line containing `self` and the origin.
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Point
+        >>> a = Point(1, 2, 3)
+        >>> a.orthogonal_direction
+        Point3D(-2, 1, 0)
+        >>> b = _
+        >>> Line(b, b.origin).is_perpendicular(Line(a, a.origin))
+        True
+        """
+        dim = self.ambient_dimension
+        # if a coordinate is zero, we can put a 1 there and zeros elsewhere
+        if self[0].is_zero:
+            return Point([1] + (dim - 1)*[0])
+        if self[1].is_zero:
+            return Point([0,1] + (dim - 2)*[0])
+        # if the first two coordinates aren't zero, we can create a non-zero
+        # orthogonal vector by swapping them, negating one, and padding with zeros
+        return Point([-self[1], self[0]] + (dim - 2)*[0])
+
+    @staticmethod
+    def project(a, b):
+        """Project the point `a` onto the line between the origin
+        and point `b` along the normal direction.
+
+        Parameters
+        ==========
+
+        a : Point
+        b : Point
+
+        Returns
+        =======
+
+        p : Point
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.projection
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Point
+        >>> a = Point(1, 2)
+        >>> b = Point(2, 5)
+        >>> z = a.origin
+        >>> p = Point.project(a, b)
+        >>> Line(p, a).is_perpendicular(Line(p, b))
+        True
+        >>> Point.is_collinear(z, p, b)
+        True
+        """
+        a, b = Point._normalize_dimension(Point(a), Point(b))
+        if b.is_zero:
+            raise ValueError("Cannot project to the zero vector.")
+        return b*(a.dot(b) / b.dot(b))
+
+    def taxicab_distance(self, p):
+        """The Taxicab Distance from self to point p.
+
+        Returns the sum of the horizontal and vertical distances to point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        taxicab_distance : The sum of the horizontal
+        and vertical distances to point p.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(4, 5)
+        >>> p1.taxicab_distance(p2)
+        7
+
+        """
+        s, p = Point._normalize_dimension(self, Point(p))
+        return Add(*(abs(a - b) for a, b in zip(s, p)))
+
+    def canberra_distance(self, p):
+        """The Canberra Distance from self to point p.
+
+        Returns the weighted sum of horizontal and vertical distances to
+        point p.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        canberra_distance : The weighted sum of horizontal and vertical
+        distances to point p. The weight used is the sum of absolute values
+        of the coordinates.
+
+        Examples
+        ========
+
+        >>> from sympy import Point
+        >>> p1, p2 = Point(1, 1), Point(3, 3)
+        >>> p1.canberra_distance(p2)
+        1
+        >>> p1, p2 = Point(0, 0), Point(3, 3)
+        >>> p1.canberra_distance(p2)
+        2
+
+        Raises
+        ======
+
+        ValueError when both vectors are zero.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        """
+
+        s, p = Point._normalize_dimension(self, Point(p))
+        if self.is_zero and p.is_zero:
+            raise ValueError("Cannot project to the zero vector.")
+        return Add(*((abs(a - b)/(abs(a) + abs(b))) for a, b in zip(s, p)))
+
+    @property
+    def unit(self):
+        """Return the Point that is in the same direction as `self`
+        and a distance of 1 from the origin"""
+        return self / abs(self)
+
+
+class Point2D(Point):
+    """A point in a 2-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords
+        A sequence of 2 coordinate values.
+
+    Attributes
+    ==========
+
+    x
+    y
+    length
+
+    Raises
+    ======
+
+    TypeError
+        When trying to add or subtract points with different dimensions.
+        When trying to create a point with more than two dimensions.
+        When `intersection` is called with object other than a Point.
+
+    See Also
+    ========
+
+    sympy.geometry.line.Segment : Connects two Points
+
+    Examples
+    ========
+
+    >>> from sympy import Point2D
+    >>> from sympy.abc import x
+    >>> Point2D(1, 2)
+    Point2D(1, 2)
+    >>> Point2D([1, 2])
+    Point2D(1, 2)
+    >>> Point2D(0, x)
+    Point2D(0, x)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point2D(0.5, 0.25)
+    Point2D(1/2, 1/4)
+    >>> Point2D(0.5, 0.25, evaluate=False)
+    Point2D(0.5, 0.25)
+
+    """
+
+    _ambient_dimension = 2
+
+    def __new__(cls, *args, _nocheck=False, **kwargs):
+        if not _nocheck:
+            kwargs['dim'] = 2
+            args = Point(*args, **kwargs)
+        return GeometryEntity.__new__(cls, *args)
+
+    def __contains__(self, item):
+        return item == self
+
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+
+        return (self.x, self.y, self.x, self.y)
+
+    def rotate(self, angle, pt=None):
+        """Rotate ``angle`` radians counterclockwise about Point ``pt``.
+
+        See Also
+        ========
+
+        translate, scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D, pi
+        >>> t = Point2D(1, 0)
+        >>> t.rotate(pi/2)
+        Point2D(0, 1)
+        >>> t.rotate(pi/2, (2, 0))
+        Point2D(2, -1)
+
+        """
+        c = cos(angle)
+        s = sin(angle)
+
+        rv = self
+        if pt is not None:
+            pt = Point(pt, dim=2)
+            rv -= pt
+        x, y = rv.args
+        rv = Point(c*x - s*y, s*x + c*y)
+        if pt is not None:
+            rv += pt
+        return rv
+
+    def scale(self, x=1, y=1, pt=None):
+        """Scale the coordinates of the Point by multiplying by
+        ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+        and then adding ``pt`` back again (i.e. ``pt`` is the point of
+        reference for the scaling).
+
+        See Also
+        ========
+
+        rotate, translate
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> t = Point2D(1, 1)
+        >>> t.scale(2)
+        Point2D(2, 1)
+        >>> t.scale(2, 2)
+        Point2D(2, 2)
+
+        """
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        return Point(self.x*x, self.y*y)
+
+    def transform(self, matrix):
+        """Return the point after applying the transformation described
+        by the 3x3 Matrix, ``matrix``.
+
+        See Also
+        ========
+        sympy.geometry.point.Point2D.rotate
+        sympy.geometry.point.Point2D.scale
+        sympy.geometry.point.Point2D.translate
+        """
+        if not (matrix.is_Matrix and matrix.shape == (3, 3)):
+            raise ValueError("matrix must be a 3x3 matrix")
+        x, y = self.args
+        return Point(*(Matrix(1, 3, [x, y, 1])*matrix).tolist()[0][:2])
+
+    def translate(self, x=0, y=0):
+        """Shift the Point by adding x and y to the coordinates of the Point.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point2D.rotate, scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> t = Point2D(0, 1)
+        >>> t.translate(2)
+        Point2D(2, 1)
+        >>> t.translate(2, 2)
+        Point2D(2, 3)
+        >>> t + Point2D(2, 2)
+        Point2D(2, 3)
+
+        """
+        return Point(self.x + x, self.y + y)
+
+    @property
+    def coordinates(self):
+        """
+        Returns the two coordinates of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.coordinates
+        (0, 1)
+        """
+        return self.args
+
+    @property
+    def x(self):
+        """
+        Returns the X coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.x
+        0
+        """
+        return self.args[0]
+
+    @property
+    def y(self):
+        """
+        Returns the Y coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point2D
+        >>> p = Point2D(0, 1)
+        >>> p.y
+        1
+        """
+        return self.args[1]
+
+class Point3D(Point):
+    """A point in a 3-dimensional Euclidean space.
+
+    Parameters
+    ==========
+
+    coords
+        A sequence of 3 coordinate values.
+
+    Attributes
+    ==========
+
+    x
+    y
+    z
+    length
+
+    Raises
+    ======
+
+    TypeError
+        When trying to add or subtract points with different dimensions.
+        When `intersection` is called with object other than a Point.
+
+    Examples
+    ========
+
+    >>> from sympy import Point3D
+    >>> from sympy.abc import x
+    >>> Point3D(1, 2, 3)
+    Point3D(1, 2, 3)
+    >>> Point3D([1, 2, 3])
+    Point3D(1, 2, 3)
+    >>> Point3D(0, x, 3)
+    Point3D(0, x, 3)
+
+    Floats are automatically converted to Rational unless the
+    evaluate flag is False:
+
+    >>> Point3D(0.5, 0.25, 2)
+    Point3D(1/2, 1/4, 2)
+    >>> Point3D(0.5, 0.25, 3, evaluate=False)
+    Point3D(0.5, 0.25, 3)
+
+    """
+
+    _ambient_dimension = 3
+
+    def __new__(cls, *args, _nocheck=False, **kwargs):
+        if not _nocheck:
+            kwargs['dim'] = 3
+            args = Point(*args, **kwargs)
+        return GeometryEntity.__new__(cls, *args)
+
+    def __contains__(self, item):
+        return item == self
+
+    @staticmethod
+    def are_collinear(*points):
+        """Is a sequence of points collinear?
+
+        Test whether or not a set of points are collinear. Returns True if
+        the set of points are collinear, or False otherwise.
+
+        Parameters
+        ==========
+
+        points : sequence of Point
+
+        Returns
+        =======
+
+        are_collinear : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.line.Line3D
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> from sympy.abc import x
+        >>> p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+        >>> p3, p4, p5 = Point3D(2, 2, 2), Point3D(x, x, x), Point3D(1, 2, 6)
+        >>> Point3D.are_collinear(p1, p2, p3, p4)
+        True
+        >>> Point3D.are_collinear(p1, p2, p3, p5)
+        False
+        """
+        return Point.is_collinear(*points)
+
+    def direction_cosine(self, point):
+        """
+        Gives the direction cosine between 2 points
+
+        Parameters
+        ==========
+
+        p : Point3D
+
+        Returns
+        =======
+
+        list
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 3)
+        >>> p1.direction_cosine(Point3D(2, 3, 5))
+        [sqrt(6)/6, sqrt(6)/6, sqrt(6)/3]
+        """
+        a = self.direction_ratio(point)
+        b = sqrt(Add(*(i**2 for i in a)))
+        return [(point.x - self.x) / b,(point.y - self.y) / b,
+                (point.z - self.z) / b]
+
+    def direction_ratio(self, point):
+        """
+        Gives the direction ratio between 2 points
+
+        Parameters
+        ==========
+
+        p : Point3D
+
+        Returns
+        =======
+
+        list
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1 = Point3D(1, 2, 3)
+        >>> p1.direction_ratio(Point3D(2, 3, 5))
+        [1, 1, 2]
+        """
+        return [(point.x - self.x),(point.y - self.y),(point.z - self.z)]
+
+    def intersection(self, other):
+        """The intersection between this point and another GeometryEntity.
+
+        Parameters
+        ==========
+
+        other : GeometryEntity or sequence of coordinates
+
+        Returns
+        =======
+
+        intersection : list of Points
+
+        Notes
+        =====
+
+        The return value will either be an empty list if there is no
+        intersection, otherwise it will contain this point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p1, p2, p3 = Point3D(0, 0, 0), Point3D(1, 1, 1), Point3D(0, 0, 0)
+        >>> p1.intersection(p2)
+        []
+        >>> p1.intersection(p3)
+        [Point3D(0, 0, 0)]
+
+        """
+        if not isinstance(other, GeometryEntity):
+            other = Point(other, dim=3)
+        if isinstance(other, Point3D):
+            if self == other:
+                return [self]
+            return []
+        return other.intersection(self)
+
+    def scale(self, x=1, y=1, z=1, pt=None):
+        """Scale the coordinates of the Point by multiplying by
+        ``x`` and ``y`` after subtracting ``pt`` -- default is (0, 0) --
+        and then adding ``pt`` back again (i.e. ``pt`` is the point of
+        reference for the scaling).
+
+        See Also
+        ========
+
+        translate
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> t = Point3D(1, 1, 1)
+        >>> t.scale(2)
+        Point3D(2, 1, 1)
+        >>> t.scale(2, 2)
+        Point3D(2, 2, 1)
+
+        """
+        if pt:
+            pt = Point3D(pt)
+            return self.translate(*(-pt).args).scale(x, y, z).translate(*pt.args)
+        return Point3D(self.x*x, self.y*y, self.z*z)
+
+    def transform(self, matrix):
+        """Return the point after applying the transformation described
+        by the 4x4 Matrix, ``matrix``.
+
+        See Also
+        ========
+        sympy.geometry.point.Point3D.scale
+        sympy.geometry.point.Point3D.translate
+        """
+        if not (matrix.is_Matrix and matrix.shape == (4, 4)):
+            raise ValueError("matrix must be a 4x4 matrix")
+        x, y, z = self.args
+        m = Transpose(matrix)
+        return Point3D(*(Matrix(1, 4, [x, y, z, 1])*m).tolist()[0][:3])
+
+    def translate(self, x=0, y=0, z=0):
+        """Shift the Point by adding x and y to the coordinates of the Point.
+
+        See Also
+        ========
+
+        scale
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> t = Point3D(0, 1, 1)
+        >>> t.translate(2)
+        Point3D(2, 1, 1)
+        >>> t.translate(2, 2)
+        Point3D(2, 3, 1)
+        >>> t + Point3D(2, 2, 2)
+        Point3D(2, 3, 3)
+
+        """
+        return Point3D(self.x + x, self.y + y, self.z + z)
+
+    @property
+    def coordinates(self):
+        """
+        Returns the three coordinates of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 2)
+        >>> p.coordinates
+        (0, 1, 2)
+        """
+        return self.args
+
+    @property
+    def x(self):
+        """
+        Returns the X coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 3)
+        >>> p.x
+        0
+        """
+        return self.args[0]
+
+    @property
+    def y(self):
+        """
+        Returns the Y coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 2)
+        >>> p.y
+        1
+        """
+        return self.args[1]
+
+    @property
+    def z(self):
+        """
+        Returns the Z coordinate of the Point.
+
+        Examples
+        ========
+
+        >>> from sympy import Point3D
+        >>> p = Point3D(0, 1, 1)
+        >>> p.z
+        1
+        """
+        return self.args[2]
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/polygon.py b/.venv/lib/python3.12/site-packages/sympy/geometry/polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..63031183438e2d228f881fd82e1b0ecca04ec534
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/polygon.py
@@ -0,0 +1,2891 @@
+from sympy.core import Expr, S, oo, pi, sympify
+from sympy.core.evalf import N
+from sympy.core.sorting import default_sort_key, ordered
+from sympy.core.symbol import _symbol, Dummy, Symbol
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.piecewise import Piecewise
+from sympy.functions.elementary.trigonometric import cos, sin, tan
+from .ellipse import Circle
+from .entity import GeometryEntity, GeometrySet
+from .exceptions import GeometryError
+from .line import Line, Segment, Ray
+from .point import Point
+from sympy.logic import And
+from sympy.matrices import Matrix
+from sympy.simplify.simplify import simplify
+from sympy.solvers.solvers import solve
+from sympy.utilities.iterables import has_dups, has_variety, uniq, rotate_left, least_rotation
+from sympy.utilities.misc import as_int, func_name
+
+from mpmath.libmp.libmpf import prec_to_dps
+
+import warnings
+
+
+x, y, T = [Dummy('polygon_dummy', real=True) for i in range(3)]
+
+
+class Polygon(GeometrySet):
+    """A two-dimensional polygon.
+
+    A simple polygon in space. Can be constructed from a sequence of points
+    or from a center, radius, number of sides and rotation angle.
+
+    Parameters
+    ==========
+
+    vertices
+        A sequence of points.
+
+    n : int, optional
+        If $> 0$, an n-sided RegularPolygon is created.
+        Default value is $0$.
+
+    Attributes
+    ==========
+
+    area
+    angles
+    perimeter
+    vertices
+    centroid
+    sides
+
+    Raises
+    ======
+
+    GeometryError
+        If all parameters are not Points.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, sympy.geometry.line.Segment, Triangle
+
+    Notes
+    =====
+
+    Polygons are treated as closed paths rather than 2D areas so
+    some calculations can be be negative or positive (e.g., area)
+    based on the orientation of the points.
+
+    Any consecutive identical points are reduced to a single point
+    and any points collinear and between two points will be removed
+    unless they are needed to define an explicit intersection (see examples).
+
+    A Triangle, Segment or Point will be returned when there are 3 or
+    fewer points provided.
+
+    Examples
+    ========
+
+    >>> from sympy import Polygon, pi
+    >>> p1, p2, p3, p4, p5 = [(0, 0), (1, 0), (5, 1), (0, 1), (3, 0)]
+    >>> Polygon(p1, p2, p3, p4)
+    Polygon(Point2D(0, 0), Point2D(1, 0), Point2D(5, 1), Point2D(0, 1))
+    >>> Polygon(p1, p2)
+    Segment2D(Point2D(0, 0), Point2D(1, 0))
+    >>> Polygon(p1, p2, p5)
+    Segment2D(Point2D(0, 0), Point2D(3, 0))
+
+    The area of a polygon is calculated as positive when vertices are
+    traversed in a ccw direction. When the sides of a polygon cross the
+    area will have positive and negative contributions. The following
+    defines a Z shape where the bottom right connects back to the top
+    left.
+
+    >>> Polygon((0, 2), (2, 2), (0, 0), (2, 0)).area
+    0
+
+    When the keyword `n` is used to define the number of sides of the
+    Polygon then a RegularPolygon is created and the other arguments are
+    interpreted as center, radius and rotation. The unrotated RegularPolygon
+    will always have a vertex at Point(r, 0) where `r` is the radius of the
+    circle that circumscribes the RegularPolygon. Its method `spin` can be
+    used to increment that angle.
+
+    >>> p = Polygon((0,0), 1, n=3)
+    >>> p
+    RegularPolygon(Point2D(0, 0), 1, 3, 0)
+    >>> p.vertices[0]
+    Point2D(1, 0)
+    >>> p.args[0]
+    Point2D(0, 0)
+    >>> p.spin(pi/2)
+    >>> p.vertices[0]
+    Point2D(0, 1)
+
+    """
+
+    __slots__ = ()
+
+    def __new__(cls, *args, n = 0, **kwargs):
+        if n:
+            args = list(args)
+            # return a virtual polygon with n sides
+            if len(args) == 2:  # center, radius
+                args.append(n)
+            elif len(args) == 3:  # center, radius, rotation
+                args.insert(2, n)
+            return RegularPolygon(*args, **kwargs)
+
+        vertices = [Point(a, dim=2, **kwargs) for a in args]
+
+        # remove consecutive duplicates
+        nodup = []
+        for p in vertices:
+            if nodup and p == nodup[-1]:
+                continue
+            nodup.append(p)
+        if len(nodup) > 1 and nodup[-1] == nodup[0]:
+            nodup.pop()  # last point was same as first
+
+        # remove collinear points
+        i = -3
+        while i < len(nodup) - 3 and len(nodup) > 2:
+            a, b, c = nodup[i], nodup[i + 1], nodup[i + 2]
+            if Point.is_collinear(a, b, c):
+                nodup.pop(i + 1)
+                if a == c:
+                    nodup.pop(i)
+            else:
+                i += 1
+
+        vertices = list(nodup)
+
+        if len(vertices) > 3:
+            return GeometryEntity.__new__(cls, *vertices, **kwargs)
+        elif len(vertices) == 3:
+            return Triangle(*vertices, **kwargs)
+        elif len(vertices) == 2:
+            return Segment(*vertices, **kwargs)
+        else:
+            return Point(*vertices, **kwargs)
+
+    @property
+    def area(self):
+        """
+        The area of the polygon.
+
+        Notes
+        =====
+
+        The area calculation can be positive or negative based on the
+        orientation of the points. If any side of the polygon crosses
+        any other side, there will be areas having opposite signs.
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Ellipse.area
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.area
+        3
+
+        In the Z shaped polygon (with the lower right connecting back
+        to the upper left) the areas cancel out:
+
+        >>> Z = Polygon((0, 1), (1, 1), (0, 0), (1, 0))
+        >>> Z.area
+        0
+
+        In the M shaped polygon, areas do not cancel because no side
+        crosses any other (though there is a point of contact).
+
+        >>> M = Polygon((0, 0), (0, 1), (2, 0), (3, 1), (3, 0))
+        >>> M.area
+        -3/2
+
+        """
+        area = 0
+        args = self.args
+        for i in range(len(args)):
+            x1, y1 = args[i - 1].args
+            x2, y2 = args[i].args
+            area += x1*y2 - x2*y1
+        return simplify(area) / 2
+
+    @staticmethod
+    def _is_clockwise(a, b, c):
+        """Return True/False for cw/ccw orientation.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> a, b, c = [Point(i) for i in [(0, 0), (1, 1), (1, 0)]]
+        >>> Polygon._is_clockwise(a, b, c)
+        True
+        >>> Polygon._is_clockwise(a, c, b)
+        False
+        """
+        ba = b - a
+        ca = c - a
+        t_area = simplify(ba.x*ca.y - ca.x*ba.y)
+        res = t_area.is_nonpositive
+        if res is None:
+            raise ValueError("Can't determine orientation")
+        return res
+
+    @property
+    def angles(self):
+        """The internal angle at each vertex.
+
+        Returns
+        =======
+
+        angles : dict
+            A dictionary where each key is a vertex and each value is the
+            internal angle at that vertex. The vertices are represented as
+            Points.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.LinearEntity.angle_between
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.angles[p1]
+        pi/2
+        >>> poly.angles[p2]
+        acos(-4*sqrt(17)/17)
+
+        """
+
+        args = self.vertices
+        n = len(args)
+        ret = {}
+        for i in range(n):
+            a, b, c = args[i - 2], args[i - 1], args[i]
+            reflex_ang = Ray(b, a).angle_between(Ray(b, c))
+            if self._is_clockwise(a, b, c):
+                ret[b] = 2*S.Pi - reflex_ang
+            else:
+                ret[b] = reflex_ang
+
+        # internal sum should be pi*(n - 2), not pi*(n+2)
+        # so if ratio is (n+2)/(n-2) > 1 it is wrong
+        wrong = ((sum(ret.values())/S.Pi-1)/(n - 2) - 1).is_positive
+        if wrong:
+            two_pi = 2*S.Pi
+            for b in ret:
+                ret[b] = two_pi - ret[b]
+        elif wrong is None:
+            raise ValueError("could not determine Polygon orientation.")
+        return ret
+
+    @property
+    def ambient_dimension(self):
+        return self.vertices[0].ambient_dimension
+
+    @property
+    def perimeter(self):
+        """The perimeter of the polygon.
+
+        Returns
+        =======
+
+        perimeter : number or Basic instance
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.length
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.perimeter
+        sqrt(17) + 7
+        """
+        p = 0
+        args = self.vertices
+        for i in range(len(args)):
+            p += args[i - 1].distance(args[i])
+        return simplify(p)
+
+    @property
+    def vertices(self):
+        """The vertices of the polygon.
+
+        Returns
+        =======
+
+        vertices : list of Points
+
+        Notes
+        =====
+
+        When iterating over the vertices, it is more efficient to index self
+        rather than to request the vertices and index them. Only use the
+        vertices when you want to process all of them at once. This is even
+        more important with RegularPolygons that calculate each vertex.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.vertices
+        [Point2D(0, 0), Point2D(1, 0), Point2D(5, 1), Point2D(0, 1)]
+        >>> poly.vertices[0]
+        Point2D(0, 0)
+
+        """
+        return list(self.args)
+
+    @property
+    def centroid(self):
+        """The centroid of the polygon.
+
+        Returns
+        =======
+
+        centroid : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.util.centroid
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.centroid
+        Point2D(31/18, 11/18)
+
+        """
+        A = 1/(6*self.area)
+        cx, cy = 0, 0
+        args = self.args
+        for i in range(len(args)):
+            x1, y1 = args[i - 1].args
+            x2, y2 = args[i].args
+            v = x1*y2 - x2*y1
+            cx += v*(x1 + x2)
+            cy += v*(y1 + y2)
+        return Point(simplify(A*cx), simplify(A*cy))
+
+
+    def second_moment_of_area(self, point=None):
+        """Returns the second moment and product moment of area of a two dimensional polygon.
+
+        Parameters
+        ==========
+
+        point : Point, two-tuple of sympifyable objects, or None(default=None)
+            point is the point about which second moment of area is to be found.
+            If "point=None" it will be calculated about the axis passing through the
+            centroid of the polygon.
+
+        Returns
+        =======
+
+        I_xx, I_yy, I_xy : number or SymPy expression
+                           I_xx, I_yy are second moment of area of a two dimensional polygon.
+                           I_xy is product moment of area of a two dimensional polygon.
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, symbols
+        >>> a, b = symbols('a, b')
+        >>> p1, p2, p3, p4, p5 = [(0, 0), (a, 0), (a, b), (0, b), (a/3, b/3)]
+        >>> rectangle = Polygon(p1, p2, p3, p4)
+        >>> rectangle.second_moment_of_area()
+        (a*b**3/12, a**3*b/12, 0)
+        >>> rectangle.second_moment_of_area(p5)
+        (a*b**3/9, a**3*b/9, a**2*b**2/36)
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Second_moment_of_area
+
+        """
+
+        I_xx, I_yy, I_xy = 0, 0, 0
+        args = self.vertices
+        for i in range(len(args)):
+            x1, y1 = args[i-1].args
+            x2, y2 = args[i].args
+            v = x1*y2 - x2*y1
+            I_xx += (y1**2 + y1*y2 + y2**2)*v
+            I_yy += (x1**2 + x1*x2 + x2**2)*v
+            I_xy += (x1*y2 + 2*x1*y1 + 2*x2*y2 + x2*y1)*v
+        A = self.area
+        c_x = self.centroid[0]
+        c_y = self.centroid[1]
+        # parallel axis theorem
+        I_xx_c = (I_xx/12) - (A*(c_y**2))
+        I_yy_c = (I_yy/12) - (A*(c_x**2))
+        I_xy_c = (I_xy/24) - (A*(c_x*c_y))
+        if point is None:
+            return I_xx_c, I_yy_c, I_xy_c
+
+        I_xx = (I_xx_c + A*((point[1]-c_y)**2))
+        I_yy = (I_yy_c + A*((point[0]-c_x)**2))
+        I_xy = (I_xy_c + A*((point[0]-c_x)*(point[1]-c_y)))
+
+        return I_xx, I_yy, I_xy
+
+
+    def first_moment_of_area(self, point=None):
+        """
+        Returns the first moment of area of a two-dimensional polygon with
+        respect to a certain point of interest.
+
+        First moment of area is a measure of the distribution of the area
+        of a polygon in relation to an axis. The first moment of area of
+        the entire polygon about its own centroid is always zero. Therefore,
+        here it is calculated for an area, above or below a certain point
+        of interest, that makes up a smaller portion of the polygon. This
+        area is bounded by the point of interest and the extreme end
+        (top or bottom) of the polygon. The first moment for this area is
+        is then determined about the centroidal axis of the initial polygon.
+
+        References
+        ==========
+
+        .. [1] https://skyciv.com/docs/tutorials/section-tutorials/calculating-the-statical-or-first-moment-of-area-of-beam-sections/?cc=BMD
+        .. [2] https://mechanicalc.com/reference/cross-sections
+
+        Parameters
+        ==========
+
+        point: Point, two-tuple of sympifyable objects, or None (default=None)
+            point is the point above or below which the area of interest lies
+            If ``point=None`` then the centroid acts as the point of interest.
+
+        Returns
+        =======
+
+        Q_x, Q_y: number or SymPy expressions
+            Q_x is the first moment of area about the x-axis
+            Q_y is the first moment of area about the y-axis
+            A negative sign indicates that the section modulus is
+            determined for a section below (or left of) the centroidal axis
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> a, b = 50, 10
+        >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]
+        >>> p = Polygon(p1, p2, p3, p4)
+        >>> p.first_moment_of_area()
+        (625, 3125)
+        >>> p.first_moment_of_area(point=Point(30, 7))
+        (525, 3000)
+        """
+        if point:
+            xc, yc = self.centroid
+        else:
+            point = self.centroid
+            xc, yc = point
+
+        h_line = Line(point, slope=0)
+        v_line = Line(point, slope=S.Infinity)
+
+        h_poly = self.cut_section(h_line)
+        v_poly = self.cut_section(v_line)
+
+        poly_1 = h_poly[0] if h_poly[0].area <= h_poly[1].area else h_poly[1]
+        poly_2 = v_poly[0] if v_poly[0].area <= v_poly[1].area else v_poly[1]
+
+        Q_x = (poly_1.centroid.y - yc)*poly_1.area
+        Q_y = (poly_2.centroid.x - xc)*poly_2.area
+
+        return Q_x, Q_y
+
+
+    def polar_second_moment_of_area(self):
+        """Returns the polar modulus of a two-dimensional polygon
+
+        It is a constituent of the second moment of area, linked through
+        the perpendicular axis theorem. While the planar second moment of
+        area describes an object's resistance to deflection (bending) when
+        subjected to a force applied to a plane parallel to the central
+        axis, the polar second moment of area describes an object's
+        resistance to deflection when subjected to a moment applied in a
+        plane perpendicular to the object's central axis (i.e. parallel to
+        the cross-section)
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, symbols
+        >>> a, b = symbols('a, b')
+        >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))
+        >>> rectangle.polar_second_moment_of_area()
+        a**3*b/12 + a*b**3/12
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Polar_moment_of_inertia
+
+        """
+        second_moment = self.second_moment_of_area()
+        return second_moment[0] + second_moment[1]
+
+
+    def section_modulus(self, point=None):
+        """Returns a tuple with the section modulus of a two-dimensional
+        polygon.
+
+        Section modulus is a geometric property of a polygon defined as the
+        ratio of second moment of area to the distance of the extreme end of
+        the polygon from the centroidal axis.
+
+        Parameters
+        ==========
+
+        point : Point, two-tuple of sympifyable objects, or None(default=None)
+            point is the point at which section modulus is to be found.
+            If "point=None" it will be calculated for the point farthest from the
+            centroidal axis of the polygon.
+
+        Returns
+        =======
+
+        S_x, S_y: numbers or SymPy expressions
+                  S_x is the section modulus with respect to the x-axis
+                  S_y is the section modulus with respect to the y-axis
+                  A negative sign indicates that the section modulus is
+                  determined for a point below the centroidal axis
+
+        Examples
+        ========
+
+        >>> from sympy import symbols, Polygon, Point
+        >>> a, b = symbols('a, b', positive=True)
+        >>> rectangle = Polygon((0, 0), (a, 0), (a, b), (0, b))
+        >>> rectangle.section_modulus()
+        (a*b**2/6, a**2*b/6)
+        >>> rectangle.section_modulus(Point(a/4, b/4))
+        (-a*b**2/3, -a**2*b/3)
+
+        References
+        ==========
+
+        .. [1] https://en.wikipedia.org/wiki/Section_modulus
+
+        """
+        x_c, y_c = self.centroid
+        if point is None:
+            # taking x and y as maximum distances from centroid
+            x_min, y_min, x_max, y_max = self.bounds
+            y = max(y_c - y_min, y_max - y_c)
+            x = max(x_c - x_min, x_max - x_c)
+        else:
+            # taking x and y as distances of the given point from the centroid
+            y = point.y - y_c
+            x = point.x - x_c
+
+        second_moment= self.second_moment_of_area()
+        S_x = second_moment[0]/y
+        S_y = second_moment[1]/x
+
+        return S_x, S_y
+
+
+    @property
+    def sides(self):
+        """The directed line segments that form the sides of the polygon.
+
+        Returns
+        =======
+
+        sides : list of sides
+            Each side is a directed Segment.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.sides
+        [Segment2D(Point2D(0, 0), Point2D(1, 0)),
+        Segment2D(Point2D(1, 0), Point2D(5, 1)),
+        Segment2D(Point2D(5, 1), Point2D(0, 1)), Segment2D(Point2D(0, 1), Point2D(0, 0))]
+
+        """
+        res = []
+        args = self.vertices
+        for i in range(-len(args), 0):
+            res.append(Segment(args[i], args[i + 1]))
+        return res
+
+    @property
+    def bounds(self):
+        """Return a tuple (xmin, ymin, xmax, ymax) representing the bounding
+        rectangle for the geometric figure.
+
+        """
+
+        verts = self.vertices
+        xs = [p.x for p in verts]
+        ys = [p.y for p in verts]
+        return (min(xs), min(ys), max(xs), max(ys))
+
+    def is_convex(self):
+        """Is the polygon convex?
+
+        A polygon is convex if all its interior angles are less than 180
+        degrees and there are no intersections between sides.
+
+        Returns
+        =======
+
+        is_convex : boolean
+            True if this polygon is convex, False otherwise.
+
+        See Also
+        ========
+
+        sympy.geometry.util.convex_hull
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly = Polygon(p1, p2, p3, p4)
+        >>> poly.is_convex()
+        True
+
+        """
+        # Determine orientation of points
+        args = self.vertices
+        cw = self._is_clockwise(args[-2], args[-1], args[0])
+        for i in range(1, len(args)):
+            if cw ^ self._is_clockwise(args[i - 2], args[i - 1], args[i]):
+                return False
+        # check for intersecting sides
+        sides = self.sides
+        for i, si in enumerate(sides):
+            pts = si.args
+            # exclude the sides connected to si
+            for j in range(1 if i == len(sides) - 1 else 0, i - 1):
+                sj = sides[j]
+                if sj.p1 not in pts and sj.p2 not in pts:
+                    hit = si.intersection(sj)
+                    if hit:
+                        return False
+        return True
+
+    def encloses_point(self, p):
+        """
+        Return True if p is enclosed by (is inside of) self.
+
+        Notes
+        =====
+
+        Being on the border of self is considered False.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        encloses_point : True, False or None
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.encloses_point
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, Point
+        >>> p = Polygon((0, 0), (4, 0), (4, 4))
+        >>> p.encloses_point(Point(2, 1))
+        True
+        >>> p.encloses_point(Point(2, 2))
+        False
+        >>> p.encloses_point(Point(5, 5))
+        False
+
+        References
+        ==========
+
+        .. [1] https://paulbourke.net/geometry/polygonmesh/#insidepoly
+
+        """
+        p = Point(p, dim=2)
+        if p in self.vertices or any(p in s for s in self.sides):
+            return False
+
+        # move to p, checking that the result is numeric
+        lit = []
+        for v in self.vertices:
+            lit.append(v - p)  # the difference is simplified
+            if lit[-1].free_symbols:
+                return None
+
+        poly = Polygon(*lit)
+
+        # polygon closure is assumed in the following test but Polygon removes duplicate pts so
+        # the last point has to be added so all sides are computed. Using Polygon.sides is
+        # not good since Segments are unordered.
+        args = poly.args
+        indices = list(range(-len(args), 1))
+
+        if poly.is_convex():
+            orientation = None
+            for i in indices:
+                a = args[i]
+                b = args[i + 1]
+                test = ((-a.y)*(b.x - a.x) - (-a.x)*(b.y - a.y)).is_negative
+                if orientation is None:
+                    orientation = test
+                elif test is not orientation:
+                    return False
+            return True
+
+        hit_odd = False
+        p1x, p1y = args[0].args
+        for i in indices[1:]:
+            p2x, p2y = args[i].args
+            if 0 > min(p1y, p2y):
+                if 0 <= max(p1y, p2y):
+                    if 0 <= max(p1x, p2x):
+                        if p1y != p2y:
+                            xinters = (-p1y)*(p2x - p1x)/(p2y - p1y) + p1x
+                            if p1x == p2x or 0 <= xinters:
+                                hit_odd = not hit_odd
+            p1x, p1y = p2x, p2y
+        return hit_odd
+
+    def arbitrary_point(self, parameter='t'):
+        """A parameterized point on the polygon.
+
+        The parameter, varying from 0 to 1, assigns points to the position on
+        the perimeter that is that fraction of the total perimeter. So the
+        point evaluated at t=1/2 would return the point from the first vertex
+        that is 1/2 way around the polygon.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        arbitrary_point : Point
+
+        Raises
+        ======
+
+        ValueError
+            When `parameter` already appears in the Polygon's definition.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, Symbol
+        >>> t = Symbol('t', real=True)
+        >>> tri = Polygon((0, 0), (1, 0), (1, 1))
+        >>> p = tri.arbitrary_point('t')
+        >>> perimeter = tri.perimeter
+        >>> s1, s2 = [s.length for s in tri.sides[:2]]
+        >>> p.subs(t, (s1 + s2/2)/perimeter)
+        Point2D(1, 1/2)
+
+        """
+        t = _symbol(parameter, real=True)
+        if t.name in (f.name for f in self.free_symbols):
+            raise ValueError('Symbol %s already appears in object and cannot be used as a parameter.' % t.name)
+        sides = []
+        perimeter = self.perimeter
+        perim_fraction_start = 0
+        for s in self.sides:
+            side_perim_fraction = s.length/perimeter
+            perim_fraction_end = perim_fraction_start + side_perim_fraction
+            pt = s.arbitrary_point(parameter).subs(
+                t, (t - perim_fraction_start)/side_perim_fraction)
+            sides.append(
+                (pt, (And(perim_fraction_start <= t, t < perim_fraction_end))))
+            perim_fraction_start = perim_fraction_end
+        return Piecewise(*sides)
+
+    def parameter_value(self, other, t):
+        if not isinstance(other,GeometryEntity):
+            other = Point(other, dim=self.ambient_dimension)
+        if not isinstance(other,Point):
+            raise ValueError("other must be a point")
+        if other.free_symbols:
+            raise NotImplementedError('non-numeric coordinates')
+        unknown = False
+        p = self.arbitrary_point(T)
+        for pt, cond in p.args:
+            sol = solve(pt - other, T, dict=True)
+            if not sol:
+                continue
+            value = sol[0][T]
+            if simplify(cond.subs(T, value)) == True:
+                return {t: value}
+            unknown = True
+        if unknown:
+            raise ValueError("Given point may not be on %s" % func_name(self))
+        raise ValueError("Given point is not on %s" % func_name(self))
+
+    def plot_interval(self, parameter='t'):
+        """The plot interval for the default geometric plot of the polygon.
+
+        Parameters
+        ==========
+
+        parameter : str, optional
+            Default value is 't'.
+
+        Returns
+        =======
+
+        plot_interval : list (plot interval)
+            [parameter, lower_bound, upper_bound]
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon
+        >>> p = Polygon((0, 0), (1, 0), (1, 1))
+        >>> p.plot_interval()
+        [t, 0, 1]
+
+        """
+        t = Symbol(parameter, real=True)
+        return [t, 0, 1]
+
+    def intersection(self, o):
+        """The intersection of polygon and geometry entity.
+
+        The intersection may be empty and can contain individual Points and
+        complete Line Segments.
+
+        Parameters
+        ==========
+
+        other: GeometryEntity
+
+        Returns
+        =======
+
+        intersection : list
+            The list of Segments and Points
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon, Line
+        >>> p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+        >>> poly1 = Polygon(p1, p2, p3, p4)
+        >>> p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])
+        >>> poly2 = Polygon(p5, p6, p7)
+        >>> poly1.intersection(poly2)
+        [Point2D(1/3, 1), Point2D(2/3, 0), Point2D(9/5, 1/5), Point2D(7/3, 1)]
+        >>> poly1.intersection(Line(p1, p2))
+        [Segment2D(Point2D(0, 0), Point2D(1, 0))]
+        >>> poly1.intersection(p1)
+        [Point2D(0, 0)]
+        """
+        intersection_result = []
+        k = o.sides if isinstance(o, Polygon) else [o]
+        for side in self.sides:
+            for side1 in k:
+                intersection_result.extend(side.intersection(side1))
+
+        intersection_result = list(uniq(intersection_result))
+        points = [entity for entity in intersection_result if isinstance(entity, Point)]
+        segments = [entity for entity in intersection_result if isinstance(entity, Segment)]
+
+        if points and segments:
+            points_in_segments = list(uniq([point for point in points for segment in segments if point in segment]))
+            if points_in_segments:
+                for i in points_in_segments:
+                    points.remove(i)
+            return list(ordered(segments + points))
+        else:
+            return list(ordered(intersection_result))
+
+
+    def cut_section(self, line):
+        """
+        Returns a tuple of two polygon segments that lie above and below
+        the intersecting line respectively.
+
+        Parameters
+        ==========
+
+        line: Line object of geometry module
+            line which cuts the Polygon. The part of the Polygon that lies
+            above and below this line is returned.
+
+        Returns
+        =======
+
+        upper_polygon, lower_polygon: Polygon objects or None
+            upper_polygon is the polygon that lies above the given line.
+            lower_polygon is the polygon that lies below the given line.
+            upper_polygon and lower polygon are ``None`` when no polygon
+            exists above the line or below the line.
+
+        Raises
+        ======
+
+        ValueError: When the line does not intersect the polygon
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, Line
+        >>> a, b = 20, 10
+        >>> p1, p2, p3, p4 = [(0, b), (0, 0), (a, 0), (a, b)]
+        >>> rectangle = Polygon(p1, p2, p3, p4)
+        >>> t = rectangle.cut_section(Line((0, 5), slope=0))
+        >>> t
+        (Polygon(Point2D(0, 10), Point2D(0, 5), Point2D(20, 5), Point2D(20, 10)),
+        Polygon(Point2D(0, 5), Point2D(0, 0), Point2D(20, 0), Point2D(20, 5)))
+        >>> upper_segment, lower_segment = t
+        >>> upper_segment.area
+        100
+        >>> upper_segment.centroid
+        Point2D(10, 15/2)
+        >>> lower_segment.centroid
+        Point2D(10, 5/2)
+
+        References
+        ==========
+
+        .. [1] https://github.com/sympy/sympy/wiki/A-method-to-return-a-cut-section-of-any-polygon-geometry
+
+        """
+        intersection_points = self.intersection(line)
+        if not intersection_points:
+            raise ValueError("This line does not intersect the polygon")
+
+        points = list(self.vertices)
+        points.append(points[0])
+
+        eq = line.equation(x, y)
+
+        # considering equation of line to be `ax +by + c`
+        a = eq.coeff(x)
+        b = eq.coeff(y)
+
+        upper_vertices = []
+        lower_vertices = []
+        # prev is true when previous point is above the line
+        prev = True
+        prev_point = None
+        for point in points:
+            # when coefficient of y is 0, right side of the line is
+            # considered
+            compare = eq.subs({x: point.x, y: point.y})/b if b \
+                    else eq.subs(x, point.x)/a
+
+            # if point lies above line
+            if compare > 0:
+                if not prev:
+                    # if previous point lies below the line, the intersection
+                    # point of the polygon edge and the line has to be included
+                    edge = Line(point, prev_point)
+                    new_point = edge.intersection(line)
+                    upper_vertices.append(new_point[0])
+                    lower_vertices.append(new_point[0])
+
+                upper_vertices.append(point)
+                prev = True
+            else:
+                if prev and prev_point:
+                    edge = Line(point, prev_point)
+                    new_point = edge.intersection(line)
+                    upper_vertices.append(new_point[0])
+                    lower_vertices.append(new_point[0])
+                lower_vertices.append(point)
+                prev = False
+            prev_point = point
+
+        upper_polygon, lower_polygon = None, None
+        if upper_vertices and isinstance(Polygon(*upper_vertices), Polygon):
+            upper_polygon = Polygon(*upper_vertices)
+        if lower_vertices and isinstance(Polygon(*lower_vertices), Polygon):
+            lower_polygon = Polygon(*lower_vertices)
+
+        return upper_polygon, lower_polygon
+
+
+    def distance(self, o):
+        """
+        Returns the shortest distance between self and o.
+
+        If o is a point, then self does not need to be convex.
+        If o is another polygon self and o must be convex.
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon, RegularPolygon
+        >>> p1, p2 = map(Point, [(0, 0), (7, 5)])
+        >>> poly = Polygon(*RegularPolygon(p1, 1, 3).vertices)
+        >>> poly.distance(p2)
+        sqrt(61)
+        """
+        if isinstance(o, Point):
+            dist = oo
+            for side in self.sides:
+                current = side.distance(o)
+                if current == 0:
+                    return S.Zero
+                elif current < dist:
+                    dist = current
+            return dist
+        elif isinstance(o, Polygon) and self.is_convex() and o.is_convex():
+            return self._do_poly_distance(o)
+        raise NotImplementedError()
+
+    def _do_poly_distance(self, e2):
+        """
+        Calculates the least distance between the exteriors of two
+        convex polygons e1 and e2. Does not check for the convexity
+        of the polygons as this is checked by Polygon.distance.
+
+        Notes
+        =====
+
+            - Prints a warning if the two polygons possibly intersect as the return
+              value will not be valid in such a case. For a more through test of
+              intersection use intersection().
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.distance
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Polygon
+        >>> square = Polygon(Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+        >>> triangle = Polygon(Point(1, 2), Point(2, 2), Point(2, 1))
+        >>> square._do_poly_distance(triangle)
+        sqrt(2)/2
+
+        Description of method used
+        ==========================
+
+        Method:
+        [1] https://web.archive.org/web/20150509035744/http://cgm.cs.mcgill.ca/~orm/mind2p.html
+        Uses rotating calipers:
+        [2] https://en.wikipedia.org/wiki/Rotating_calipers
+        and antipodal points:
+        [3] https://en.wikipedia.org/wiki/Antipodal_point
+        """
+        e1 = self
+
+        '''Tests for a possible intersection between the polygons and outputs a warning'''
+        e1_center = e1.centroid
+        e2_center = e2.centroid
+        e1_max_radius = S.Zero
+        e2_max_radius = S.Zero
+        for vertex in e1.vertices:
+            r = Point.distance(e1_center, vertex)
+            if e1_max_radius < r:
+                e1_max_radius = r
+        for vertex in e2.vertices:
+            r = Point.distance(e2_center, vertex)
+            if e2_max_radius < r:
+                e2_max_radius = r
+        center_dist = Point.distance(e1_center, e2_center)
+        if center_dist <= e1_max_radius + e2_max_radius:
+            warnings.warn("Polygons may intersect producing erroneous output",
+                          stacklevel=3)
+
+        '''
+        Find the upper rightmost vertex of e1 and the lowest leftmost vertex of e2
+        '''
+        e1_ymax = Point(0, -oo)
+        e2_ymin = Point(0, oo)
+
+        for vertex in e1.vertices:
+            if vertex.y > e1_ymax.y or (vertex.y == e1_ymax.y and vertex.x > e1_ymax.x):
+                e1_ymax = vertex
+        for vertex in e2.vertices:
+            if vertex.y < e2_ymin.y or (vertex.y == e2_ymin.y and vertex.x < e2_ymin.x):
+                e2_ymin = vertex
+        min_dist = Point.distance(e1_ymax, e2_ymin)
+
+        '''
+        Produce a dictionary with vertices of e1 as the keys and, for each vertex, the points
+        to which the vertex is connected as its value. The same is then done for e2.
+        '''
+        e1_connections = {}
+        e2_connections = {}
+
+        for side in e1.sides:
+            if side.p1 in e1_connections:
+                e1_connections[side.p1].append(side.p2)
+            else:
+                e1_connections[side.p1] = [side.p2]
+
+            if side.p2 in e1_connections:
+                e1_connections[side.p2].append(side.p1)
+            else:
+                e1_connections[side.p2] = [side.p1]
+
+        for side in e2.sides:
+            if side.p1 in e2_connections:
+                e2_connections[side.p1].append(side.p2)
+            else:
+                e2_connections[side.p1] = [side.p2]
+
+            if side.p2 in e2_connections:
+                e2_connections[side.p2].append(side.p1)
+            else:
+                e2_connections[side.p2] = [side.p1]
+
+        e1_current = e1_ymax
+        e2_current = e2_ymin
+        support_line = Line(Point(S.Zero, S.Zero), Point(S.One, S.Zero))
+
+        '''
+        Determine which point in e1 and e2 will be selected after e2_ymin and e1_ymax,
+        this information combined with the above produced dictionaries determines the
+        path that will be taken around the polygons
+        '''
+        point1 = e1_connections[e1_ymax][0]
+        point2 = e1_connections[e1_ymax][1]
+        angle1 = support_line.angle_between(Line(e1_ymax, point1))
+        angle2 = support_line.angle_between(Line(e1_ymax, point2))
+        if angle1 < angle2:
+            e1_next = point1
+        elif angle2 < angle1:
+            e1_next = point2
+        elif Point.distance(e1_ymax, point1) > Point.distance(e1_ymax, point2):
+            e1_next = point2
+        else:
+            e1_next = point1
+
+        point1 = e2_connections[e2_ymin][0]
+        point2 = e2_connections[e2_ymin][1]
+        angle1 = support_line.angle_between(Line(e2_ymin, point1))
+        angle2 = support_line.angle_between(Line(e2_ymin, point2))
+        if angle1 > angle2:
+            e2_next = point1
+        elif angle2 > angle1:
+            e2_next = point2
+        elif Point.distance(e2_ymin, point1) > Point.distance(e2_ymin, point2):
+            e2_next = point2
+        else:
+            e2_next = point1
+
+        '''
+        Loop which determines the distance between anti-podal pairs and updates the
+        minimum distance accordingly. It repeats until it reaches the starting position.
+        '''
+        while True:
+            e1_angle = support_line.angle_between(Line(e1_current, e1_next))
+            e2_angle = pi - support_line.angle_between(Line(
+                e2_current, e2_next))
+
+            if (e1_angle < e2_angle) is True:
+                support_line = Line(e1_current, e1_next)
+                e1_segment = Segment(e1_current, e1_next)
+                min_dist_current = e1_segment.distance(e2_current)
+
+                if min_dist_current.evalf() < min_dist.evalf():
+                    min_dist = min_dist_current
+
+                if e1_connections[e1_next][0] != e1_current:
+                    e1_current = e1_next
+                    e1_next = e1_connections[e1_next][0]
+                else:
+                    e1_current = e1_next
+                    e1_next = e1_connections[e1_next][1]
+            elif (e1_angle > e2_angle) is True:
+                support_line = Line(e2_next, e2_current)
+                e2_segment = Segment(e2_current, e2_next)
+                min_dist_current = e2_segment.distance(e1_current)
+
+                if min_dist_current.evalf() < min_dist.evalf():
+                    min_dist = min_dist_current
+
+                if e2_connections[e2_next][0] != e2_current:
+                    e2_current = e2_next
+                    e2_next = e2_connections[e2_next][0]
+                else:
+                    e2_current = e2_next
+                    e2_next = e2_connections[e2_next][1]
+            else:
+                support_line = Line(e1_current, e1_next)
+                e1_segment = Segment(e1_current, e1_next)
+                e2_segment = Segment(e2_current, e2_next)
+                min1 = e1_segment.distance(e2_next)
+                min2 = e2_segment.distance(e1_next)
+
+                min_dist_current = min(min1, min2)
+                if min_dist_current.evalf() < min_dist.evalf():
+                    min_dist = min_dist_current
+
+                if e1_connections[e1_next][0] != e1_current:
+                    e1_current = e1_next
+                    e1_next = e1_connections[e1_next][0]
+                else:
+                    e1_current = e1_next
+                    e1_next = e1_connections[e1_next][1]
+
+                if e2_connections[e2_next][0] != e2_current:
+                    e2_current = e2_next
+                    e2_next = e2_connections[e2_next][0]
+                else:
+                    e2_current = e2_next
+                    e2_next = e2_connections[e2_next][1]
+            if e1_current == e1_ymax and e2_current == e2_ymin:
+                break
+        return min_dist
+
+    def _svg(self, scale_factor=1., fill_color="#66cc99"):
+        """Returns SVG path element for the Polygon.
+
+        Parameters
+        ==========
+
+        scale_factor : float
+            Multiplication factor for the SVG stroke-width.  Default is 1.
+        fill_color : str, optional
+            Hex string for fill color. Default is "#66cc99".
+        """
+        verts = map(N, self.vertices)
+        coords = ["{},{}".format(p.x, p.y) for p in verts]
+        path = "M {} L {} z".format(coords[0], " L ".join(coords[1:]))
+        return (
+            ''
+            ).format(2. * scale_factor, path, fill_color)
+
+    def _hashable_content(self):
+
+        D = {}
+        def ref_list(point_list):
+            kee = {}
+            for i, p in enumerate(ordered(set(point_list))):
+                kee[p] = i
+                D[i] = p
+            return [kee[p] for p in point_list]
+
+        S1 = ref_list(self.args)
+        r_nor = rotate_left(S1, least_rotation(S1))
+        S2 = ref_list(list(reversed(self.args)))
+        r_rev = rotate_left(S2, least_rotation(S2))
+        if r_nor < r_rev:
+            r = r_nor
+        else:
+            r = r_rev
+        canonical_args = [ D[order] for order in r ]
+        return tuple(canonical_args)
+
+    def __contains__(self, o):
+        """
+        Return True if o is contained within the boundary lines of self.altitudes
+
+        Parameters
+        ==========
+
+        other : GeometryEntity
+
+        Returns
+        =======
+
+        contained in : bool
+            The points (and sides, if applicable) are contained in self.
+
+        See Also
+        ========
+
+        sympy.geometry.entity.GeometryEntity.encloses
+
+        Examples
+        ========
+
+        >>> from sympy import Line, Segment, Point
+        >>> p = Point(0, 0)
+        >>> q = Point(1, 1)
+        >>> s = Segment(p, q*2)
+        >>> l = Line(p, q)
+        >>> p in q
+        False
+        >>> p in s
+        True
+        >>> q*3 in s
+        False
+        >>> s in l
+        True
+
+        """
+
+        if isinstance(o, Polygon):
+            return self == o
+        elif isinstance(o, Segment):
+            return any(o in s for s in self.sides)
+        elif isinstance(o, Point):
+            if o in self.vertices:
+                return True
+            for side in self.sides:
+                if o in side:
+                    return True
+
+        return False
+
+    def bisectors(p, prec=None):
+        """Returns angle bisectors of a polygon. If prec is given
+        then approximate the point defining the ray to that precision.
+
+        The distance between the points defining the bisector ray is 1.
+
+        Examples
+        ========
+
+        >>> from sympy import Polygon, Point
+        >>> p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
+        >>> p.bisectors(2)
+        {Point2D(0, 0): Ray2D(Point2D(0, 0), Point2D(0.71, 0.71)),
+         Point2D(0, 3): Ray2D(Point2D(0, 3), Point2D(0.23, 2.0)),
+         Point2D(1, 1): Ray2D(Point2D(1, 1), Point2D(0.19, 0.42)),
+         Point2D(2, 0): Ray2D(Point2D(2, 0), Point2D(1.1, 0.38))}
+        """
+        b = {}
+        pts = list(p.args)
+        pts.append(pts[0])  # close it
+        cw = Polygon._is_clockwise(*pts[:3])
+        if cw:
+            pts = list(reversed(pts))
+        for v, a in p.angles.items():
+            i = pts.index(v)
+            p1, p2 = Point._normalize_dimension(pts[i], pts[i + 1])
+            ray = Ray(p1, p2).rotate(a/2, v)
+            dir = ray.direction
+            ray = Ray(ray.p1, ray.p1 + dir/dir.distance((0, 0)))
+            if prec is not None:
+                ray = Ray(ray.p1, ray.p2.n(prec))
+            b[v] = ray
+        return b
+
+
+class RegularPolygon(Polygon):
+    """
+    A regular polygon.
+
+    Such a polygon has all internal angles equal and all sides the same length.
+
+    Parameters
+    ==========
+
+    center : Point
+    radius : number or Basic instance
+        The distance from the center to a vertex
+    n : int
+        The number of sides
+
+    Attributes
+    ==========
+
+    vertices
+    center
+    radius
+    rotation
+    apothem
+    interior_angle
+    exterior_angle
+    circumcircle
+    incircle
+    angles
+
+    Raises
+    ======
+
+    GeometryError
+        If the `center` is not a Point, or the `radius` is not a number or Basic
+        instance, or the number of sides, `n`, is less than three.
+
+    Notes
+    =====
+
+    A RegularPolygon can be instantiated with Polygon with the kwarg n.
+
+    Regular polygons are instantiated with a center, radius, number of sides
+    and a rotation angle. Whereas the arguments of a Polygon are vertices, the
+    vertices of the RegularPolygon must be obtained with the vertices method.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Polygon
+
+    Examples
+    ========
+
+    >>> from sympy import RegularPolygon, Point
+    >>> r = RegularPolygon(Point(0, 0), 5, 3)
+    >>> r
+    RegularPolygon(Point2D(0, 0), 5, 3, 0)
+    >>> r.vertices[0]
+    Point2D(5, 0)
+
+    """
+
+    __slots__ = ('_n', '_center', '_radius', '_rot')
+
+    def __new__(self, c, r, n, rot=0, **kwargs):
+        r, n, rot = map(sympify, (r, n, rot))
+        c = Point(c, dim=2, **kwargs)
+        if not isinstance(r, Expr):
+            raise GeometryError("r must be an Expr object, not %s" % r)
+        if n.is_Number:
+            as_int(n)  # let an error raise if necessary
+            if n < 3:
+                raise GeometryError("n must be a >= 3, not %s" % n)
+
+        obj = GeometryEntity.__new__(self, c, r, n, **kwargs)
+        obj._n = n
+        obj._center = c
+        obj._radius = r
+        obj._rot = rot % (2*S.Pi/n) if rot.is_number else rot
+        return obj
+
+    def _eval_evalf(self, prec=15, **options):
+        c, r, n, a = self.args
+        dps = prec_to_dps(prec)
+        c, r, a = [i.evalf(n=dps, **options) for i in (c, r, a)]
+        return self.func(c, r, n, a)
+
+    @property
+    def args(self):
+        """
+        Returns the center point, the radius,
+        the number of sides, and the orientation angle.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> r = RegularPolygon(Point(0, 0), 5, 3)
+        >>> r.args
+        (Point2D(0, 0), 5, 3, 0)
+        """
+        return self._center, self._radius, self._n, self._rot
+
+    def __str__(self):
+        return 'RegularPolygon(%s, %s, %s, %s)' % tuple(self.args)
+
+    def __repr__(self):
+        return 'RegularPolygon(%s, %s, %s, %s)' % tuple(self.args)
+
+    @property
+    def area(self):
+        """Returns the area.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon
+        >>> square = RegularPolygon((0, 0), 1, 4)
+        >>> square.area
+        2
+        >>> _ == square.length**2
+        True
+        """
+        c, r, n, rot = self.args
+        return sign(r)*n*self.length**2/(4*tan(pi/n))
+
+    @property
+    def length(self):
+        """Returns the length of the sides.
+
+        The half-length of the side and the apothem form two legs
+        of a right triangle whose hypotenuse is the radius of the
+        regular polygon.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon
+        >>> from sympy import sqrt
+        >>> s = square_in_unit_circle = RegularPolygon((0, 0), 1, 4)
+        >>> s.length
+        sqrt(2)
+        >>> sqrt((_/2)**2 + s.apothem**2) == s.radius
+        True
+
+        """
+        return self.radius*2*sin(pi/self._n)
+
+    @property
+    def center(self):
+        """The center of the RegularPolygon
+
+        This is also the center of the circumscribing circle.
+
+        Returns
+        =======
+
+        center : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.ellipse.Ellipse.center
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+        >>> rp.center
+        Point2D(0, 0)
+        """
+        return self._center
+
+    centroid = center
+
+    @property
+    def circumcenter(self):
+        """
+        Alias for center.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+        >>> rp.circumcenter
+        Point2D(0, 0)
+        """
+        return self.center
+
+    @property
+    def radius(self):
+        """Radius of the RegularPolygon
+
+        This is also the radius of the circumscribing circle.
+
+        Returns
+        =======
+
+        radius : number or instance of Basic
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy import RegularPolygon, Point
+        >>> radius = Symbol('r')
+        >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+        >>> rp.radius
+        r
+
+        """
+        return self._radius
+
+    @property
+    def circumradius(self):
+        """
+        Alias for radius.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy import RegularPolygon, Point
+        >>> radius = Symbol('r')
+        >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+        >>> rp.circumradius
+        r
+        """
+        return self.radius
+
+    @property
+    def rotation(self):
+        """CCW angle by which the RegularPolygon is rotated
+
+        Returns
+        =======
+
+        rotation : number or instance of Basic
+
+        Examples
+        ========
+
+        >>> from sympy import pi
+        >>> from sympy.abc import a
+        >>> from sympy import RegularPolygon, Point
+        >>> RegularPolygon(Point(0, 0), 3, 4, pi/4).rotation
+        pi/4
+
+        Numerical rotation angles are made canonical:
+
+        >>> RegularPolygon(Point(0, 0), 3, 4, a).rotation
+        a
+        >>> RegularPolygon(Point(0, 0), 3, 4, pi).rotation
+        0
+
+        """
+        return self._rot
+
+    @property
+    def apothem(self):
+        """The inradius of the RegularPolygon.
+
+        The apothem/inradius is the radius of the inscribed circle.
+
+        Returns
+        =======
+
+        apothem : number or instance of Basic
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.length, sympy.geometry.ellipse.Circle.radius
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy import RegularPolygon, Point
+        >>> radius = Symbol('r')
+        >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+        >>> rp.apothem
+        sqrt(2)*r/2
+
+        """
+        return self.radius * cos(S.Pi/self._n)
+
+    @property
+    def inradius(self):
+        """
+        Alias for apothem.
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy import RegularPolygon, Point
+        >>> radius = Symbol('r')
+        >>> rp = RegularPolygon(Point(0, 0), radius, 4)
+        >>> rp.inradius
+        sqrt(2)*r/2
+        """
+        return self.apothem
+
+    @property
+    def interior_angle(self):
+        """Measure of the interior angles.
+
+        Returns
+        =======
+
+        interior_angle : number
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.angle_between
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+        >>> rp.interior_angle
+        3*pi/4
+
+        """
+        return (self._n - 2)*S.Pi/self._n
+
+    @property
+    def exterior_angle(self):
+        """Measure of the exterior angles.
+
+        Returns
+        =======
+
+        exterior_angle : number
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.angle_between
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+        >>> rp.exterior_angle
+        pi/4
+
+        """
+        return 2*S.Pi/self._n
+
+    @property
+    def circumcircle(self):
+        """The circumcircle of the RegularPolygon.
+
+        Returns
+        =======
+
+        circumcircle : Circle
+
+        See Also
+        ========
+
+        circumcenter, sympy.geometry.ellipse.Circle
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 4, 8)
+        >>> rp.circumcircle
+        Circle(Point2D(0, 0), 4)
+
+        """
+        return Circle(self.center, self.radius)
+
+    @property
+    def incircle(self):
+        """The incircle of the RegularPolygon.
+
+        Returns
+        =======
+
+        incircle : Circle
+
+        See Also
+        ========
+
+        inradius, sympy.geometry.ellipse.Circle
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 4, 7)
+        >>> rp.incircle
+        Circle(Point2D(0, 0), 4*cos(pi/7))
+
+        """
+        return Circle(self.center, self.apothem)
+
+    @property
+    def angles(self):
+        """
+        Returns a dictionary with keys, the vertices of the Polygon,
+        and values, the interior angle at each vertex.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> r = RegularPolygon(Point(0, 0), 5, 3)
+        >>> r.angles
+        {Point2D(-5/2, -5*sqrt(3)/2): pi/3,
+         Point2D(-5/2, 5*sqrt(3)/2): pi/3,
+         Point2D(5, 0): pi/3}
+        """
+        ret = {}
+        ang = self.interior_angle
+        for v in self.vertices:
+            ret[v] = ang
+        return ret
+
+    def encloses_point(self, p):
+        """
+        Return True if p is enclosed by (is inside of) self.
+
+        Notes
+        =====
+
+        Being on the border of self is considered False.
+
+        The general Polygon.encloses_point method is called only if
+        a point is not within or beyond the incircle or circumcircle,
+        respectively.
+
+        Parameters
+        ==========
+
+        p : Point
+
+        Returns
+        =======
+
+        encloses_point : True, False or None
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Ellipse.encloses_point
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, S, Point, Symbol
+        >>> p = RegularPolygon((0, 0), 3, 4)
+        >>> p.encloses_point(Point(0, 0))
+        True
+        >>> r, R = p.inradius, p.circumradius
+        >>> p.encloses_point(Point((r + R)/2, 0))
+        True
+        >>> p.encloses_point(Point(R/2, R/2 + (R - r)/10))
+        False
+        >>> t = Symbol('t', real=True)
+        >>> p.encloses_point(p.arbitrary_point().subs(t, S.Half))
+        False
+        >>> p.encloses_point(Point(5, 5))
+        False
+
+        """
+
+        c = self.center
+        d = Segment(c, p).length
+        if d >= self.radius:
+            return False
+        elif d < self.inradius:
+            return True
+        else:
+            # now enumerate the RegularPolygon like a general polygon.
+            return Polygon.encloses_point(self, p)
+
+    def spin(self, angle):
+        """Increment *in place* the virtual Polygon's rotation by ccw angle.
+
+        See also: rotate method which moves the center.
+
+        >>> from sympy import Polygon, Point, pi
+        >>> r = Polygon(Point(0,0), 1, n=3)
+        >>> r.vertices[0]
+        Point2D(1, 0)
+        >>> r.spin(pi/6)
+        >>> r.vertices[0]
+        Point2D(sqrt(3)/2, 1/2)
+
+        See Also
+        ========
+
+        rotation
+        rotate : Creates a copy of the RegularPolygon rotated about a Point
+
+        """
+        self._rot += angle
+
+    def rotate(self, angle, pt=None):
+        """Override GeometryEntity.rotate to first rotate the RegularPolygon
+        about its center.
+
+        >>> from sympy import Point, RegularPolygon, pi
+        >>> t = RegularPolygon(Point(1, 0), 1, 3)
+        >>> t.vertices[0] # vertex on x-axis
+        Point2D(2, 0)
+        >>> t.rotate(pi/2).vertices[0] # vertex on y axis now
+        Point2D(0, 2)
+
+        See Also
+        ========
+
+        rotation
+        spin : Rotates a RegularPolygon in place
+
+        """
+
+        r = type(self)(*self.args)  # need a copy or else changes are in-place
+        r._rot += angle
+        return GeometryEntity.rotate(r, angle, pt)
+
+    def scale(self, x=1, y=1, pt=None):
+        """Override GeometryEntity.scale since it is the radius that must be
+        scaled (if x == y) or else a new Polygon must be returned.
+
+        >>> from sympy import RegularPolygon
+
+        Symmetric scaling returns a RegularPolygon:
+
+        >>> RegularPolygon((0, 0), 1, 4).scale(2, 2)
+        RegularPolygon(Point2D(0, 0), 2, 4, 0)
+
+        Asymmetric scaling returns a kite as a Polygon:
+
+        >>> RegularPolygon((0, 0), 1, 4).scale(2, 1)
+        Polygon(Point2D(2, 0), Point2D(0, 1), Point2D(-2, 0), Point2D(0, -1))
+
+        """
+        if pt:
+            pt = Point(pt, dim=2)
+            return self.translate(*(-pt).args).scale(x, y).translate(*pt.args)
+        if x != y:
+            return Polygon(*self.vertices).scale(x, y)
+        c, r, n, rot = self.args
+        r *= x
+        return self.func(c, r, n, rot)
+
+    def reflect(self, line):
+        """Override GeometryEntity.reflect since this is not made of only
+        points.
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Line
+
+        >>> RegularPolygon((0, 0), 1, 4).reflect(Line((0, 1), slope=-2))
+        RegularPolygon(Point2D(4/5, 2/5), -1, 4, atan(4/3))
+
+        """
+        c, r, n, rot = self.args
+        v = self.vertices[0]
+        d = v - c
+        cc = c.reflect(line)
+        vv = v.reflect(line)
+        dd = vv - cc
+        # calculate rotation about the new center
+        # which will align the vertices
+        l1 = Ray((0, 0), dd)
+        l2 = Ray((0, 0), d)
+        ang = l1.closing_angle(l2)
+        rot += ang
+        # change sign of radius as point traversal is reversed
+        return self.func(cc, -r, n, rot)
+
+    @property
+    def vertices(self):
+        """The vertices of the RegularPolygon.
+
+        Returns
+        =======
+
+        vertices : list
+            Each vertex is a Point.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import RegularPolygon, Point
+        >>> rp = RegularPolygon(Point(0, 0), 5, 4)
+        >>> rp.vertices
+        [Point2D(5, 0), Point2D(0, 5), Point2D(-5, 0), Point2D(0, -5)]
+
+        """
+        c = self._center
+        r = abs(self._radius)
+        rot = self._rot
+        v = 2*S.Pi/self._n
+
+        return [Point(c.x + r*cos(k*v + rot), c.y + r*sin(k*v + rot))
+                for k in range(self._n)]
+
+    def __eq__(self, o):
+        if not isinstance(o, Polygon):
+            return False
+        elif not isinstance(o, RegularPolygon):
+            return Polygon.__eq__(o, self)
+        return self.args == o.args
+
+    def __hash__(self):
+        return super().__hash__()
+
+
+class Triangle(Polygon):
+    """
+    A polygon with three vertices and three sides.
+
+    Parameters
+    ==========
+
+    points : sequence of Points
+    keyword: asa, sas, or sss to specify sides/angles of the triangle
+
+    Attributes
+    ==========
+
+    vertices
+    altitudes
+    orthocenter
+    circumcenter
+    circumradius
+    circumcircle
+    inradius
+    incircle
+    exradii
+    medians
+    medial
+    nine_point_circle
+
+    Raises
+    ======
+
+    GeometryError
+        If the number of vertices is not equal to three, or one of the vertices
+        is not a Point, or a valid keyword is not given.
+
+    See Also
+    ========
+
+    sympy.geometry.point.Point, Polygon
+
+    Examples
+    ========
+
+    >>> from sympy import Triangle, Point
+    >>> Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+    Triangle(Point2D(0, 0), Point2D(4, 0), Point2D(4, 3))
+
+    Keywords sss, sas, or asa can be used to give the desired
+    side lengths (in order) and interior angles (in degrees) that
+    define the triangle:
+
+    >>> Triangle(sss=(3, 4, 5))
+    Triangle(Point2D(0, 0), Point2D(3, 0), Point2D(3, 4))
+    >>> Triangle(asa=(30, 1, 30))
+    Triangle(Point2D(0, 0), Point2D(1, 0), Point2D(1/2, sqrt(3)/6))
+    >>> Triangle(sas=(1, 45, 2))
+    Triangle(Point2D(0, 0), Point2D(2, 0), Point2D(sqrt(2)/2, sqrt(2)/2))
+
+    """
+
+    def __new__(cls, *args, **kwargs):
+        if len(args) != 3:
+            if 'sss' in kwargs:
+                return _sss(*[simplify(a) for a in kwargs['sss']])
+            if 'asa' in kwargs:
+                return _asa(*[simplify(a) for a in kwargs['asa']])
+            if 'sas' in kwargs:
+                return _sas(*[simplify(a) for a in kwargs['sas']])
+            msg = "Triangle instantiates with three points or a valid keyword."
+            raise GeometryError(msg)
+
+        vertices = [Point(a, dim=2, **kwargs) for a in args]
+
+        # remove consecutive duplicates
+        nodup = []
+        for p in vertices:
+            if nodup and p == nodup[-1]:
+                continue
+            nodup.append(p)
+        if len(nodup) > 1 and nodup[-1] == nodup[0]:
+            nodup.pop()  # last point was same as first
+
+        # remove collinear points
+        i = -3
+        while i < len(nodup) - 3 and len(nodup) > 2:
+            a, b, c = sorted(
+                [nodup[i], nodup[i + 1], nodup[i + 2]], key=default_sort_key)
+            if Point.is_collinear(a, b, c):
+                nodup[i] = a
+                nodup[i + 1] = None
+                nodup.pop(i + 1)
+            i += 1
+
+        vertices = list(filter(lambda x: x is not None, nodup))
+
+        if len(vertices) == 3:
+            return GeometryEntity.__new__(cls, *vertices, **kwargs)
+        elif len(vertices) == 2:
+            return Segment(*vertices, **kwargs)
+        else:
+            return Point(*vertices, **kwargs)
+
+    @property
+    def vertices(self):
+        """The triangle's vertices
+
+        Returns
+        =======
+
+        vertices : tuple
+            Each element in the tuple is a Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+        >>> t.vertices
+        (Point2D(0, 0), Point2D(4, 0), Point2D(4, 3))
+
+        """
+        return self.args
+
+    def is_similar(t1, t2):
+        """Is another triangle similar to this one.
+
+        Two triangles are similar if one can be uniformly scaled to the other.
+
+        Parameters
+        ==========
+
+        other: Triangle
+
+        Returns
+        =======
+
+        is_similar : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.entity.GeometryEntity.is_similar
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+        >>> t2 = Triangle(Point(0, 0), Point(-4, 0), Point(-4, -3))
+        >>> t1.is_similar(t2)
+        True
+
+        >>> t2 = Triangle(Point(0, 0), Point(-4, 0), Point(-4, -4))
+        >>> t1.is_similar(t2)
+        False
+
+        """
+        if not isinstance(t2, Polygon):
+            return False
+
+        s1_1, s1_2, s1_3 = [side.length for side in t1.sides]
+        s2 = [side.length for side in t2.sides]
+
+        def _are_similar(u1, u2, u3, v1, v2, v3):
+            e1 = simplify(u1/v1)
+            e2 = simplify(u2/v2)
+            e3 = simplify(u3/v3)
+            return bool(e1 == e2) and bool(e2 == e3)
+
+        # There's only 6 permutations, so write them out
+        return _are_similar(s1_1, s1_2, s1_3, *s2) or \
+            _are_similar(s1_1, s1_3, s1_2, *s2) or \
+            _are_similar(s1_2, s1_1, s1_3, *s2) or \
+            _are_similar(s1_2, s1_3, s1_1, *s2) or \
+            _are_similar(s1_3, s1_1, s1_2, *s2) or \
+            _are_similar(s1_3, s1_2, s1_1, *s2)
+
+    def is_equilateral(self):
+        """Are all the sides the same length?
+
+        Returns
+        =======
+
+        is_equilateral : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.entity.GeometryEntity.is_similar, RegularPolygon
+        is_isosceles, is_right, is_scalene
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+        >>> t1.is_equilateral()
+        False
+
+        >>> from sympy import sqrt
+        >>> t2 = Triangle(Point(0, 0), Point(10, 0), Point(5, 5*sqrt(3)))
+        >>> t2.is_equilateral()
+        True
+
+        """
+        return not has_variety(s.length for s in self.sides)
+
+    def is_isosceles(self):
+        """Are two or more of the sides the same length?
+
+        Returns
+        =======
+
+        is_isosceles : boolean
+
+        See Also
+        ========
+
+        is_equilateral, is_right, is_scalene
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(2, 4))
+        >>> t1.is_isosceles()
+        True
+
+        """
+        return has_dups(s.length for s in self.sides)
+
+    def is_scalene(self):
+        """Are all the sides of the triangle of different lengths?
+
+        Returns
+        =======
+
+        is_scalene : boolean
+
+        See Also
+        ========
+
+        is_equilateral, is_isosceles, is_right
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(1, 4))
+        >>> t1.is_scalene()
+        True
+
+        """
+        return not has_dups(s.length for s in self.sides)
+
+    def is_right(self):
+        """Is the triangle right-angled.
+
+        Returns
+        =======
+
+        is_right : boolean
+
+        See Also
+        ========
+
+        sympy.geometry.line.LinearEntity.is_perpendicular
+        is_equilateral, is_isosceles, is_scalene
+
+        Examples
+        ========
+
+        >>> from sympy import Triangle, Point
+        >>> t1 = Triangle(Point(0, 0), Point(4, 0), Point(4, 3))
+        >>> t1.is_right()
+        True
+
+        """
+        s = self.sides
+        return Segment.is_perpendicular(s[0], s[1]) or \
+            Segment.is_perpendicular(s[1], s[2]) or \
+            Segment.is_perpendicular(s[0], s[2])
+
+    @property
+    def altitudes(self):
+        """The altitudes of the triangle.
+
+        An altitude of a triangle is a segment through a vertex,
+        perpendicular to the opposite side, with length being the
+        height of the vertex measured from the line containing the side.
+
+        Returns
+        =======
+
+        altitudes : dict
+            The dictionary consists of keys which are vertices and values
+            which are Segments.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.Segment.length
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.altitudes[p1]
+        Segment2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+        """
+        s = self.sides
+        v = self.vertices
+        return {v[0]: s[1].perpendicular_segment(v[0]),
+                v[1]: s[2].perpendicular_segment(v[1]),
+                v[2]: s[0].perpendicular_segment(v[2])}
+
+    @property
+    def orthocenter(self):
+        """The orthocenter of the triangle.
+
+        The orthocenter is the intersection of the altitudes of a triangle.
+        It may lie inside, outside or on the triangle.
+
+        Returns
+        =======
+
+        orthocenter : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.orthocenter
+        Point2D(0, 0)
+
+        """
+        a = self.altitudes
+        v = self.vertices
+        return Line(a[v[0]]).intersection(Line(a[v[1]]))[0]
+
+    @property
+    def circumcenter(self):
+        """The circumcenter of the triangle
+
+        The circumcenter is the center of the circumcircle.
+
+        Returns
+        =======
+
+        circumcenter : Point
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.circumcenter
+        Point2D(1/2, 1/2)
+        """
+        a, b, c = [x.perpendicular_bisector() for x in self.sides]
+        return a.intersection(b)[0]
+
+    @property
+    def circumradius(self):
+        """The radius of the circumcircle of the triangle.
+
+        Returns
+        =======
+
+        circumradius : number of Basic instance
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Circle.radius
+
+        Examples
+        ========
+
+        >>> from sympy import Symbol
+        >>> from sympy import Point, Triangle
+        >>> a = Symbol('a')
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, a)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.circumradius
+        sqrt(a**2/4 + 1/4)
+        """
+        return Point.distance(self.circumcenter, self.vertices[0])
+
+    @property
+    def circumcircle(self):
+        """The circle which passes through the three vertices of the triangle.
+
+        Returns
+        =======
+
+        circumcircle : Circle
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Circle
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.circumcircle
+        Circle(Point2D(1/2, 1/2), sqrt(2)/2)
+
+        """
+        return Circle(self.circumcenter, self.circumradius)
+
+    def bisectors(self):
+        """The angle bisectors of the triangle.
+
+        An angle bisector of a triangle is a straight line through a vertex
+        which cuts the corresponding angle in half.
+
+        Returns
+        =======
+
+        bisectors : dict
+            Each key is a vertex (Point) and each value is the corresponding
+            bisector (Segment).
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point, sympy.geometry.line.Segment
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle, Segment
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> from sympy import sqrt
+        >>> t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
+        True
+
+        """
+        # use lines containing sides so containment check during
+        # intersection calculation can be avoided, thus reducing
+        # the processing time for calculating the bisectors
+        s = [Line(l) for l in self.sides]
+        v = self.vertices
+        c = self.incenter
+        l1 = Segment(v[0], Line(v[0], c).intersection(s[1])[0])
+        l2 = Segment(v[1], Line(v[1], c).intersection(s[2])[0])
+        l3 = Segment(v[2], Line(v[2], c).intersection(s[0])[0])
+        return {v[0]: l1, v[1]: l2, v[2]: l3}
+
+    @property
+    def incenter(self):
+        """The center of the incircle.
+
+        The incircle is the circle which lies inside the triangle and touches
+        all three sides.
+
+        Returns
+        =======
+
+        incenter : Point
+
+        See Also
+        ========
+
+        incircle, sympy.geometry.point.Point
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.incenter
+        Point2D(1 - sqrt(2)/2, 1 - sqrt(2)/2)
+
+        """
+        s = self.sides
+        l = Matrix([s[i].length for i in [1, 2, 0]])
+        p = sum(l)
+        v = self.vertices
+        x = simplify(l.dot(Matrix([vi.x for vi in v]))/p)
+        y = simplify(l.dot(Matrix([vi.y for vi in v]))/p)
+        return Point(x, y)
+
+    @property
+    def inradius(self):
+        """The radius of the incircle.
+
+        Returns
+        =======
+
+        inradius : number of Basic instance
+
+        See Also
+        ========
+
+        incircle, sympy.geometry.ellipse.Circle.radius
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(4, 0), Point(0, 3)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.inradius
+        1
+
+        """
+        return simplify(2 * self.area / self.perimeter)
+
+    @property
+    def incircle(self):
+        """The incircle of the triangle.
+
+        The incircle is the circle which lies inside the triangle and touches
+        all three sides.
+
+        Returns
+        =======
+
+        incircle : Circle
+
+        See Also
+        ========
+
+        sympy.geometry.ellipse.Circle
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(2, 0), Point(0, 2)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.incircle
+        Circle(Point2D(2 - sqrt(2), 2 - sqrt(2)), 2 - sqrt(2))
+
+        """
+        return Circle(self.incenter, self.inradius)
+
+    @property
+    def exradii(self):
+        """The radius of excircles of a triangle.
+
+        An excircle of the triangle is a circle lying outside the triangle,
+        tangent to one of its sides and tangent to the extensions of the
+        other two.
+
+        Returns
+        =======
+
+        exradii : dict
+
+        See Also
+        ========
+
+        sympy.geometry.polygon.Triangle.inradius
+
+        Examples
+        ========
+
+        The exradius touches the side of the triangle to which it is keyed, e.g.
+        the exradius touching side 2 is:
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(6, 0), Point(0, 2)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.exradii[t.sides[2]]
+        -2 + sqrt(10)
+
+        References
+        ==========
+
+        .. [1] https://mathworld.wolfram.com/Exradius.html
+        .. [2] https://mathworld.wolfram.com/Excircles.html
+
+        """
+
+        side = self.sides
+        a = side[0].length
+        b = side[1].length
+        c = side[2].length
+        s = (a+b+c)/2
+        area = self.area
+        exradii = {self.sides[0]: simplify(area/(s-a)),
+                   self.sides[1]: simplify(area/(s-b)),
+                   self.sides[2]: simplify(area/(s-c))}
+
+        return exradii
+
+    @property
+    def excenters(self):
+        """Excenters of the triangle.
+
+        An excenter is the center of a circle that is tangent to a side of the
+        triangle and the extensions of the other two sides.
+
+        Returns
+        =======
+
+        excenters : dict
+
+
+        Examples
+        ========
+
+        The excenters are keyed to the side of the triangle to which their corresponding
+        excircle is tangent: The center is keyed, e.g. the excenter of a circle touching
+        side 0 is:
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(6, 0), Point(0, 2)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.excenters[t.sides[0]]
+        Point2D(12*sqrt(10), 2/3 + sqrt(10)/3)
+
+        See Also
+        ========
+
+        sympy.geometry.polygon.Triangle.exradii
+
+        References
+        ==========
+
+        .. [1] https://mathworld.wolfram.com/Excircles.html
+
+        """
+
+        s = self.sides
+        v = self.vertices
+        a = s[0].length
+        b = s[1].length
+        c = s[2].length
+        x = [v[0].x, v[1].x, v[2].x]
+        y = [v[0].y, v[1].y, v[2].y]
+
+        exc_coords = {
+            "x1": simplify(-a*x[0]+b*x[1]+c*x[2]/(-a+b+c)),
+            "x2": simplify(a*x[0]-b*x[1]+c*x[2]/(a-b+c)),
+            "x3": simplify(a*x[0]+b*x[1]-c*x[2]/(a+b-c)),
+            "y1": simplify(-a*y[0]+b*y[1]+c*y[2]/(-a+b+c)),
+            "y2": simplify(a*y[0]-b*y[1]+c*y[2]/(a-b+c)),
+            "y3": simplify(a*y[0]+b*y[1]-c*y[2]/(a+b-c))
+        }
+
+        excenters = {
+            s[0]: Point(exc_coords["x1"], exc_coords["y1"]),
+            s[1]: Point(exc_coords["x2"], exc_coords["y2"]),
+            s[2]: Point(exc_coords["x3"], exc_coords["y3"])
+        }
+
+        return excenters
+
+    @property
+    def medians(self):
+        """The medians of the triangle.
+
+        A median of a triangle is a straight line through a vertex and the
+        midpoint of the opposite side, and divides the triangle into two
+        equal areas.
+
+        Returns
+        =======
+
+        medians : dict
+            Each key is a vertex (Point) and each value is the median (Segment)
+            at that point.
+
+        See Also
+        ========
+
+        sympy.geometry.point.Point.midpoint, sympy.geometry.line.Segment.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.medians[p1]
+        Segment2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+        """
+        s = self.sides
+        v = self.vertices
+        return {v[0]: Segment(v[0], s[1].midpoint),
+                v[1]: Segment(v[1], s[2].midpoint),
+                v[2]: Segment(v[2], s[0].midpoint)}
+
+    @property
+    def medial(self):
+        """The medial triangle of the triangle.
+
+        The triangle which is formed from the midpoints of the three sides.
+
+        Returns
+        =======
+
+        medial : Triangle
+
+        See Also
+        ========
+
+        sympy.geometry.line.Segment.midpoint
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.medial
+        Triangle(Point2D(1/2, 0), Point2D(1/2, 1/2), Point2D(0, 1/2))
+
+        """
+        s = self.sides
+        return Triangle(s[0].midpoint, s[1].midpoint, s[2].midpoint)
+
+    @property
+    def nine_point_circle(self):
+        """The nine-point circle of the triangle.
+
+        Nine-point circle is the circumcircle of the medial triangle, which
+        passes through the feet of altitudes and the middle points of segments
+        connecting the vertices and the orthocenter.
+
+        Returns
+        =======
+
+        nine_point_circle : Circle
+
+        See also
+        ========
+
+        sympy.geometry.line.Segment.midpoint
+        sympy.geometry.polygon.Triangle.medial
+        sympy.geometry.polygon.Triangle.orthocenter
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.nine_point_circle
+        Circle(Point2D(1/4, 1/4), sqrt(2)/4)
+
+        """
+        return Circle(*self.medial.vertices)
+
+    @property
+    def eulerline(self):
+        """The Euler line of the triangle.
+
+        The line which passes through circumcenter, centroid and orthocenter.
+
+        Returns
+        =======
+
+        eulerline : Line (or Point for equilateral triangles in which case all
+                    centers coincide)
+
+        Examples
+        ========
+
+        >>> from sympy import Point, Triangle
+        >>> p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+        >>> t = Triangle(p1, p2, p3)
+        >>> t.eulerline
+        Line2D(Point2D(0, 0), Point2D(1/2, 1/2))
+
+        """
+        if self.is_equilateral():
+            return self.orthocenter
+        return Line(self.orthocenter, self.circumcenter)
+
+def rad(d):
+    """Return the radian value for the given degrees (pi = 180 degrees)."""
+    return d*pi/180
+
+
+def deg(r):
+    """Return the degree value for the given radians (pi = 180 degrees)."""
+    return r/pi*180
+
+
+def _slope(d):
+    rv = tan(rad(d))
+    return rv
+
+
+def _asa(d1, l, d2):
+    """Return triangle having side with length l on the x-axis."""
+    xy = Line((0, 0), slope=_slope(d1)).intersection(
+        Line((l, 0), slope=_slope(180 - d2)))[0]
+    return Triangle((0, 0), (l, 0), xy)
+
+
+def _sss(l1, l2, l3):
+    """Return triangle having side of length l1 on the x-axis."""
+    c1 = Circle((0, 0), l3)
+    c2 = Circle((l1, 0), l2)
+    inter = [a for a in c1.intersection(c2) if a.y.is_nonnegative]
+    if not inter:
+        return None
+    pt = inter[0]
+    return Triangle((0, 0), (l1, 0), pt)
+
+
+def _sas(l1, d, l2):
+    """Return triangle having side with length l2 on the x-axis."""
+    p1 = Point(0, 0)
+    p2 = Point(l2, 0)
+    p3 = Point(cos(rad(d))*l1, sin(rad(d))*l1)
+    return Triangle(p1, p2, p3)
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__init__.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7237c4bd498a5d8ef4668ed9d6fa848128bbc458
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/__init__.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c341231a203ef071ff1bd69d3aacc3ac90862c9
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_curve.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..333ed8294c9f01c4a99801c9e4a140058c412513
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_ellipse.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d6801b4e7153594f1184dd5c9b652a6c897ca0b
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_entity.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cac59953e4cf6f42c37f894fc74fb777a5fab24f
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_geometrysets.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6fce01b58747ff6dc8fc0812b06a01a55197c757
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_line.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8ed7d6d24bb7daa5eb3d7cc08c42ffd0f2079e48
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_parabola.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5997748052e14caadc47e710153ca85381312c2
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_plane.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a0ac0fd7f5d7cf5676e950b845975a907c506691
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_point.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f5e62dec4a59e0bc571f1113224768c8fa9bcd03
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_polygon.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-312.pyc b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-312.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f7b18325fe4aa44b0c78fc3a057509dc13392add
Binary files /dev/null and b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/__pycache__/test_util.cpython-312.pyc differ
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_curve.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_curve.py
new file mode 100644
index 0000000000000000000000000000000000000000..50aa80273a1d8eb9e414a8d591571f3127352dad
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_curve.py
@@ -0,0 +1,120 @@
+from sympy.core.containers import Tuple
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.hyperbolic import asinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Curve, Line, Point, Ellipse, Ray, Segment, Circle, Polygon, RegularPolygon
+from sympy.testing.pytest import raises, slow
+
+
+def test_curve():
+    x = Symbol('x', real=True)
+    s = Symbol('s')
+    z = Symbol('z')
+
+    # this curve is independent of the indicated parameter
+    c = Curve([2*s, s**2], (z, 0, 2))
+
+    assert c.parameter == z
+    assert c.functions == (2*s, s**2)
+    assert c.arbitrary_point() == Point(2*s, s**2)
+    assert c.arbitrary_point(z) == Point(2*s, s**2)
+
+    # this is how it is normally used
+    c = Curve([2*s, s**2], (s, 0, 2))
+
+    assert c.parameter == s
+    assert c.functions == (2*s, s**2)
+    t = Symbol('t')
+    # the t returned as assumptions
+    assert c.arbitrary_point() != Point(2*t, t**2)
+    t = Symbol('t', real=True)
+    # now t has the same assumptions so the test passes
+    assert c.arbitrary_point() == Point(2*t, t**2)
+    assert c.arbitrary_point(z) == Point(2*z, z**2)
+    assert c.arbitrary_point(c.parameter) == Point(2*s, s**2)
+    assert c.arbitrary_point(None) == Point(2*s, s**2)
+    assert c.plot_interval() == [t, 0, 2]
+    assert c.plot_interval(z) == [z, 0, 2]
+
+    assert Curve([x, x], (x, 0, 1)).rotate(pi/2) == Curve([-x, x], (x, 0, 1))
+    assert Curve([x, x], (x, 0, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+        1, 3).arbitrary_point(s) == \
+        Line((0, 0), (1, 1)).rotate(pi/2, (1, 2)).scale(2, 3).translate(
+            1, 3).arbitrary_point(s) == \
+        Point(-2*s + 7, 3*s + 6)
+
+    raises(ValueError, lambda: Curve((s), (s, 1, 2)))
+    raises(ValueError, lambda: Curve((x, x * 2), (1, x)))
+
+    raises(ValueError, lambda: Curve((s, s + t), (s, 1, 2)).arbitrary_point())
+    raises(ValueError, lambda: Curve((s, s + t), (t, 1, 2)).arbitrary_point(s))
+
+
+@slow
+def test_free_symbols():
+    a, b, c, d, e, f, s = symbols('a:f,s')
+    assert Point(a, b).free_symbols == {a, b}
+    assert Line((a, b), (c, d)).free_symbols == {a, b, c, d}
+    assert Ray((a, b), (c, d)).free_symbols == {a, b, c, d}
+    assert Ray((a, b), angle=c).free_symbols == {a, b, c}
+    assert Segment((a, b), (c, d)).free_symbols == {a, b, c, d}
+    assert Line((a, b), slope=c).free_symbols == {a, b, c}
+    assert Curve((a*s, b*s), (s, c, d)).free_symbols == {a, b, c, d}
+    assert Ellipse((a, b), c, d).free_symbols == {a, b, c, d}
+    assert Ellipse((a, b), c, eccentricity=d).free_symbols == \
+        {a, b, c, d}
+    assert Ellipse((a, b), vradius=c, eccentricity=d).free_symbols == \
+        {a, b, c, d}
+    assert Circle((a, b), c).free_symbols == {a, b, c}
+    assert Circle((a, b), (c, d), (e, f)).free_symbols == \
+        {e, d, c, b, f, a}
+    assert Polygon((a, b), (c, d), (e, f)).free_symbols == \
+        {e, b, d, f, a, c}
+    assert RegularPolygon((a, b), c, d, e).free_symbols == {e, a, b, c, d}
+
+
+def test_transform():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    c = Curve((x, x**2), (x, 0, 1))
+    cout = Curve((2*x - 4, 3*x**2 - 10), (x, 0, 1))
+    pts = [Point(0, 0), Point(S.Half, Rational(1, 4)), Point(1, 1)]
+    pts_out = [Point(-4, -10), Point(-3, Rational(-37, 4)), Point(-2, -7)]
+
+    assert c.scale(2, 3, (4, 5)) == cout
+    assert [c.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts
+    assert [cout.subs(x, xi/2) for xi in Tuple(0, 1, 2)] == pts_out
+    assert Curve((x + y, 3*x), (x, 0, 1)).subs(y, S.Half) == \
+        Curve((x + S.Half, 3*x), (x, 0, 1))
+    assert Curve((x, 3*x), (x, 0, 1)).translate(4, 5) == \
+        Curve((x + 4, 3*x + 5), (x, 0, 1))
+
+
+def test_length():
+    t = Symbol('t', real=True)
+
+    c1 = Curve((t, 0), (t, 0, 1))
+    assert c1.length == 1
+
+    c2 = Curve((t, t), (t, 0, 1))
+    assert c2.length == sqrt(2)
+
+    c3 = Curve((t ** 2, t), (t, 2, 5))
+    assert c3.length == -sqrt(17) - asinh(4) / 4 + asinh(10) / 4 + 5 * sqrt(101) / 2
+
+
+def test_parameter_value():
+    t = Symbol('t')
+    C = Curve([2*t, t**2], (t, 0, 2))
+    assert C.parameter_value((2, 1), t) == {t: 1}
+    raises(ValueError, lambda: C.parameter_value((2, 0), t))
+
+
+def test_issue_17997():
+    t, s = symbols('t s')
+    c = Curve((t, t**2), (t, 0, 10))
+    p = Curve([2*s, s**2], (s, 0, 2))
+    assert c(2) == Point(2, 4)
+    assert p(1) == Point(2, 1)
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_ellipse.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_ellipse.py
new file mode 100644
index 0000000000000000000000000000000000000000..a79eba8c35771bda9f0980aca68d937f8e625c0a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_ellipse.py
@@ -0,0 +1,613 @@
+from sympy.core import expand
+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 (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import sec
+from sympy.geometry.line import Segment2D
+from sympy.geometry.point import Point2D
+from sympy.geometry import (Circle, Ellipse, GeometryError, Line, Point,
+                            Polygon, Ray, RegularPolygon, Segment,
+                            Triangle, intersection)
+from sympy.testing.pytest import raises, slow
+from sympy.integrals.integrals import integrate
+from sympy.functions.special.elliptic_integrals import elliptic_e
+from sympy.functions.elementary.miscellaneous import Max
+
+
+def test_ellipse_equation_using_slope():
+    from sympy.abc import x, y
+
+    e1 = Ellipse(Point(1, 0), 3, 2)
+    assert str(e1.equation(_slope=1)) == str((-x + y + 1)**2/8 + (x + y - 1)**2/18 - 1)
+
+    e2 = Ellipse(Point(0, 0), 4, 1)
+    assert str(e2.equation(_slope=1)) == str((-x + y)**2/2 + (x + y)**2/32 - 1)
+
+    e3 = Ellipse(Point(1, 5), 6, 2)
+    assert str(e3.equation(_slope=2)) == str((-2*x + y - 3)**2/20 + (x + 2*y - 11)**2/180 - 1)
+
+
+def test_object_from_equation():
+    from sympy.abc import x, y, a, b, c, d, e
+    assert Circle(x**2 + y**2 + 3*x + 4*y - 8) == Circle(Point2D(S(-3) / 2, -2), sqrt(57) / 2)
+    assert Circle(x**2 + y**2 + 6*x + 8*y + 25) == Circle(Point2D(-3, -4), 0)
+    assert Circle(a**2 + b**2 + 6*a + 8*b + 25, x='a', y='b') == Circle(Point2D(-3, -4), 0)
+    assert Circle(x**2 + y**2 - 25) == Circle(Point2D(0, 0), 5)
+    assert Circle(x**2 + y**2) == Circle(Point2D(0, 0), 0)
+    assert Circle(a**2 + b**2, x='a', y='b') == Circle(Point2D(0, 0), 0)
+    assert Circle(x**2 + y**2 + 6*x + 8) == Circle(Point2D(-3, 0), 1)
+    assert Circle(x**2 + y**2 + 6*y + 8) == Circle(Point2D(0, -3), 1)
+    assert Circle((x - 1)**2 + y**2 - 9) == Circle(Point2D(1, 0), 3)
+    assert Circle(6*(x**2) + 6*(y**2) + 6*x + 8*y - 25) == Circle(Point2D(Rational(-1, 2), Rational(-2, 3)), 5*sqrt(7)/6)
+    assert Circle(Eq(a**2 + b**2, 25), x='a', y=b) == Circle(Point2D(0, 0), 5)
+    raises(GeometryError, lambda: Circle(x**2 + y**2 + 3*x + 4*y + 26))
+    raises(GeometryError, lambda: Circle(x**2 + y**2 + 25))
+    raises(GeometryError, lambda: Circle(a**2 + b**2 + 25, x='a', y='b'))
+    raises(GeometryError, lambda: Circle(x**2 + 6*y + 8))
+    raises(GeometryError, lambda: Circle(6*(x ** 2) + 4*(y**2) + 6*x + 8*y + 25))
+    raises(ValueError, lambda: Circle(a**2 + b**2 + 3*a + 4*b - 8))
+    # .equation() adds 'real=True' assumption; '==' would fail if assumptions differed
+    x, y = symbols('x y', real=True)
+    eq = a*x**2 + a*y**2 + c*x + d*y + e
+    assert expand(Circle(eq).equation()*a) == eq
+
+
+@slow
+def test_ellipse_geom():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    t = Symbol('t', real=True)
+    y1 = Symbol('y1', real=True)
+    half = S.Half
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    p4 = Point(0, 1)
+
+    e1 = Ellipse(p1, 1, 1)
+    e2 = Ellipse(p2, half, 1)
+    e3 = Ellipse(p1, y1, y1)
+    c1 = Circle(p1, 1)
+    c2 = Circle(p2, 1)
+    c3 = Circle(Point(sqrt(2), sqrt(2)), 1)
+    l1 = Line(p1, p2)
+
+    # Test creation with three points
+    cen, rad = Point(3*half, 2), 5*half
+    assert Circle(Point(0, 0), Point(3, 0), Point(0, 4)) == Circle(cen, rad)
+    assert Circle(Point(0, 0), Point(1, 1), Point(2, 2)) == Segment2D(Point2D(0, 0), Point2D(2, 2))
+
+    raises(ValueError, lambda: Ellipse(None, None, None, 1))
+    raises(ValueError, lambda: Ellipse())
+    raises(GeometryError, lambda: Circle(Point(0, 0)))
+    raises(GeometryError, lambda: Circle(Symbol('x')*Symbol('y')))
+
+    # Basic Stuff
+    assert Ellipse(None, 1, 1).center == Point(0, 0)
+    assert e1 == c1
+    assert e1 != e2
+    assert e1 != l1
+    assert p4 in e1
+    assert e1 in e1
+    assert e2 in e2
+    assert 1 not in e2
+    assert p2 not in e2
+    assert e1.area == pi
+    assert e2.area == pi/2
+    assert e3.area == pi*y1*abs(y1)
+    assert c1.area == e1.area
+    assert c1.circumference == e1.circumference
+    assert e3.circumference == 2*pi*y1
+    assert e1.plot_interval() == e2.plot_interval() == [t, -pi, pi]
+    assert e1.plot_interval(x) == e2.plot_interval(x) == [x, -pi, pi]
+
+    assert c1.minor == 1
+    assert c1.major == 1
+    assert c1.hradius == 1
+    assert c1.vradius == 1
+
+    assert Ellipse((1, 1), 0, 0) == Point(1, 1)
+    assert Ellipse((1, 1), 1, 0) == Segment(Point(0, 1), Point(2, 1))
+    assert Ellipse((1, 1), 0, 1) == Segment(Point(1, 0), Point(1, 2))
+
+    # Private Functions
+    assert hash(c1) == hash(Circle(Point(1, 0), Point(0, 1), Point(0, -1)))
+    assert c1 in e1
+    assert (Line(p1, p2) in e1) is False
+    assert e1.__cmp__(e1) == 0
+    assert e1.__cmp__(Point(0, 0)) > 0
+
+    # Encloses
+    assert e1.encloses(Segment(Point(-0.5, -0.5), Point(0.5, 0.5))) is True
+    assert e1.encloses(Line(p1, p2)) is False
+    assert e1.encloses(Ray(p1, p2)) is False
+    assert e1.encloses(e1) is False
+    assert e1.encloses(
+        Polygon(Point(-0.5, -0.5), Point(-0.5, 0.5), Point(0.5, 0.5))) is True
+    assert e1.encloses(RegularPolygon(p1, 0.5, 3)) is True
+    assert e1.encloses(RegularPolygon(p1, 5, 3)) is False
+    assert e1.encloses(RegularPolygon(p2, 5, 3)) is False
+
+    assert e2.arbitrary_point() in e2
+    raises(ValueError, lambda: Ellipse(Point(x, y), 1, 1).arbitrary_point(parameter='x'))
+
+    # Foci
+    f1, f2 = Point(sqrt(12), 0), Point(-sqrt(12), 0)
+    ef = Ellipse(Point(0, 0), 4, 2)
+    assert ef.foci in [(f1, f2), (f2, f1)]
+
+    # Tangents
+    v = sqrt(2) / 2
+    p1_1 = Point(v, v)
+    p1_2 = p2 + Point(half, 0)
+    p1_3 = p2 + Point(0, 1)
+    assert e1.tangent_lines(p4) == c1.tangent_lines(p4)
+    assert e2.tangent_lines(p1_2) == [Line(Point(Rational(3, 2), 1), Point(Rational(3, 2), S.Half))]
+    assert e2.tangent_lines(p1_3) == [Line(Point(1, 2), Point(Rational(5, 4), 2))]
+    assert c1.tangent_lines(p1_1) != [Line(p1_1, Point(0, sqrt(2)))]
+    assert c1.tangent_lines(p1) == []
+    assert e2.is_tangent(Line(p1_2, p2 + Point(half, 1)))
+    assert e2.is_tangent(Line(p1_3, p2 + Point(half, 1)))
+    assert c1.is_tangent(Line(p1_1, Point(0, sqrt(2))))
+    assert e1.is_tangent(Line(Point(0, 0), Point(1, 1))) is False
+    assert c1.is_tangent(e1) is True
+    assert c1.is_tangent(Ellipse(Point(2, 0), 1, 1)) is True
+    assert c1.is_tangent(
+        Polygon(Point(1, 1), Point(1, -1), Point(2, 0))) is False
+    assert c1.is_tangent(
+        Polygon(Point(1, 1), Point(1, 0), Point(2, 0))) is False
+    assert Circle(Point(5, 5), 3).is_tangent(Circle(Point(0, 5), 1)) is False
+
+    assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(0, 0)) == \
+        [Line(Point(0, 0), Point(Rational(77, 25), Rational(132, 25))),
+     Line(Point(0, 0), Point(Rational(33, 5), Rational(22, 5)))]
+    assert Ellipse(Point(5, 5), 2, 1).tangent_lines(Point(3, 4)) == \
+        [Line(Point(3, 4), Point(4, 4)), Line(Point(3, 4), Point(3, 5))]
+    assert Circle(Point(5, 5), 2).tangent_lines(Point(3, 3)) == \
+        [Line(Point(3, 3), Point(4, 3)), Line(Point(3, 3), Point(3, 4))]
+    assert Circle(Point(5, 5), 2).tangent_lines(Point(5 - 2*sqrt(2), 5)) == \
+        [Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 - sqrt(2))),
+     Line(Point(5 - 2*sqrt(2), 5), Point(5 - sqrt(2), 5 + sqrt(2))), ]
+    assert Circle(Point(5, 5), 5).tangent_lines(Point(4, 0)) == \
+        [Line(Point(4, 0), Point(Rational(40, 13), Rational(5, 13))),
+     Line(Point(4, 0), Point(5, 0))]
+    assert Circle(Point(5, 5), 5).tangent_lines(Point(0, 6)) == \
+        [Line(Point(0, 6), Point(0, 7)),
+        Line(Point(0, 6), Point(Rational(5, 13), Rational(90, 13)))]
+
+    # for numerical calculations, we shouldn't demand exact equality,
+    # so only test up to the desired precision
+    def lines_close(l1, l2, prec):
+        """ tests whether l1 and 12 are within 10**(-prec)
+        of each other """
+        return abs(l1.p1 - l2.p1) < 10**(-prec) and abs(l1.p2 - l2.p2) < 10**(-prec)
+    def line_list_close(ll1, ll2, prec):
+        return all(lines_close(l1, l2, prec) for l1, l2 in zip(ll1, ll2))
+
+    e = Ellipse(Point(0, 0), 2, 1)
+    assert e.normal_lines(Point(0, 0)) == \
+        [Line(Point(0, 0), Point(0, 1)), Line(Point(0, 0), Point(1, 0))]
+    assert e.normal_lines(Point(1, 0)) == \
+        [Line(Point(0, 0), Point(1, 0))]
+    assert e.normal_lines((0, 1)) == \
+        [Line(Point(0, 0), Point(0, 1))]
+    assert line_list_close(e.normal_lines(Point(1, 1), 2), [
+        Line(Point(Rational(-51, 26), Rational(-1, 5)), Point(Rational(-25, 26), Rational(17, 83))),
+        Line(Point(Rational(28, 29), Rational(-7, 8)), Point(Rational(57, 29), Rational(-9, 2)))], 2)
+    # test the failure of Poly.intervals and checks a point on the boundary
+    p = Point(sqrt(3), S.Half)
+    assert p in e
+    assert line_list_close(e.normal_lines(p, 2), [
+        Line(Point(Rational(-341, 171), Rational(-1, 13)), Point(Rational(-170, 171), Rational(5, 64))),
+        Line(Point(Rational(26, 15), Rational(-1, 2)), Point(Rational(41, 15), Rational(-43, 26)))], 2)
+    # be sure to use the slope that isn't undefined on boundary
+    e = Ellipse((0, 0), 2, 2*sqrt(3)/3)
+    assert line_list_close(e.normal_lines((1, 1), 2), [
+        Line(Point(Rational(-64, 33), Rational(-20, 71)), Point(Rational(-31, 33), Rational(2, 13))),
+        Line(Point(1, -1), Point(2, -4))], 2)
+    # general ellipse fails except under certain conditions
+    e = Ellipse((0, 0), x, 1)
+    assert e.normal_lines((x + 1, 0)) == [Line(Point(0, 0), Point(1, 0))]
+    raises(NotImplementedError, lambda: e.normal_lines((x + 1, 1)))
+    # Properties
+    major = 3
+    minor = 1
+    e4 = Ellipse(p2, minor, major)
+    assert e4.focus_distance == sqrt(major**2 - minor**2)
+    ecc = e4.focus_distance / major
+    assert e4.eccentricity == ecc
+    assert e4.periapsis == major*(1 - ecc)
+    assert e4.apoapsis == major*(1 + ecc)
+    assert e4.semilatus_rectum == major*(1 - ecc ** 2)
+    # independent of orientation
+    e4 = Ellipse(p2, major, minor)
+    assert e4.focus_distance == sqrt(major**2 - minor**2)
+    ecc = e4.focus_distance / major
+    assert e4.eccentricity == ecc
+    assert e4.periapsis == major*(1 - ecc)
+    assert e4.apoapsis == major*(1 + ecc)
+
+    # Intersection
+    l1 = Line(Point(1, -5), Point(1, 5))
+    l2 = Line(Point(-5, -1), Point(5, -1))
+    l3 = Line(Point(-1, -1), Point(1, 1))
+    l4 = Line(Point(-10, 0), Point(0, 10))
+    pts_c1_l3 = [Point(sqrt(2)/2, sqrt(2)/2), Point(-sqrt(2)/2, -sqrt(2)/2)]
+
+    assert intersection(e2, l4) == []
+    assert intersection(c1, Point(1, 0)) == [Point(1, 0)]
+    assert intersection(c1, l1) == [Point(1, 0)]
+    assert intersection(c1, l2) == [Point(0, -1)]
+    assert intersection(c1, l3) in [pts_c1_l3, [pts_c1_l3[1], pts_c1_l3[0]]]
+    assert intersection(c1, c2) == [Point(0, 1), Point(1, 0)]
+    assert intersection(c1, c3) == [Point(sqrt(2)/2, sqrt(2)/2)]
+    assert e1.intersection(l1) == [Point(1, 0)]
+    assert e2.intersection(l4) == []
+    assert e1.intersection(Circle(Point(0, 2), 1)) == [Point(0, 1)]
+    assert e1.intersection(Circle(Point(5, 0), 1)) == []
+    assert e1.intersection(Ellipse(Point(2, 0), 1, 1)) == [Point(1, 0)]
+    assert e1.intersection(Ellipse(Point(5, 0), 1, 1)) == []
+    assert e1.intersection(Point(2, 0)) == []
+    assert e1.intersection(e1) == e1
+    assert intersection(Ellipse(Point(0, 0), 2, 1), Ellipse(Point(3, 0), 1, 2)) == [Point(2, 0)]
+    assert intersection(Circle(Point(0, 0), 2), Circle(Point(3, 0), 1)) == [Point(2, 0)]
+    assert intersection(Circle(Point(0, 0), 2), Circle(Point(7, 0), 1)) == []
+    assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 1, 0.2)
+        ) == [Point(5.0, 0, evaluate=False)]
+    assert intersection(Ellipse(Point(0, 0), 5, 17), Ellipse(Point(4, 0), 0.999, 0.2)) == []
+    assert Circle((0, 0), S.Half).intersection(
+        Triangle((-1, 0), (1, 0), (0, 1))) == [
+        Point(Rational(-1, 2), 0), Point(S.Half, 0)]
+    raises(TypeError, lambda: intersection(e2, Line((0, 0, 0), (0, 0, 1))))
+    raises(TypeError, lambda: intersection(e2, Rational(12)))
+    raises(TypeError, lambda: Ellipse.intersection(e2, 1))
+    # some special case intersections
+    csmall = Circle(p1, 3)
+    cbig = Circle(p1, 5)
+    cout = Circle(Point(5, 5), 1)
+    # one circle inside of another
+    assert csmall.intersection(cbig) == []
+    # separate circles
+    assert csmall.intersection(cout) == []
+    # coincident circles
+    assert csmall.intersection(csmall) == csmall
+
+    v = sqrt(2)
+    t1 = Triangle(Point(0, v), Point(0, -v), Point(v, 0))
+    points = intersection(t1, c1)
+    assert len(points) == 4
+    assert Point(0, 1) in points
+    assert Point(0, -1) in points
+    assert Point(v/2, v/2) in points
+    assert Point(v/2, -v/2) in points
+
+    circ = Circle(Point(0, 0), 5)
+    elip = Ellipse(Point(0, 0), 5, 20)
+    assert intersection(circ, elip) in \
+        [[Point(5, 0), Point(-5, 0)], [Point(-5, 0), Point(5, 0)]]
+    assert elip.tangent_lines(Point(0, 0)) == []
+    elip = Ellipse(Point(0, 0), 3, 2)
+    assert elip.tangent_lines(Point(3, 0)) == \
+        [Line(Point(3, 0), Point(3, -12))]
+
+    e1 = Ellipse(Point(0, 0), 5, 10)
+    e2 = Ellipse(Point(2, 1), 4, 8)
+    a = Rational(53, 17)
+    c = 2*sqrt(3991)/17
+    ans = [Point(a - c/8, a/2 + c), Point(a + c/8, a/2 - c)]
+    assert e1.intersection(e2) == ans
+    e2 = Ellipse(Point(x, y), 4, 8)
+    c = sqrt(3991)
+    ans = [Point(-c/68 + a, c*Rational(2, 17) + a/2), Point(c/68 + a, c*Rational(-2, 17) + a/2)]
+    assert [p.subs({x: 2, y:1}) for p in e1.intersection(e2)] == ans
+
+    # Combinations of above
+    assert e3.is_tangent(e3.tangent_lines(p1 + Point(y1, 0))[0])
+
+    e = Ellipse((1, 2), 3, 2)
+    assert e.tangent_lines(Point(10, 0)) == \
+        [Line(Point(10, 0), Point(1, 0)),
+        Line(Point(10, 0), Point(Rational(14, 5), Rational(18, 5)))]
+
+    # encloses_point
+    e = Ellipse((0, 0), 1, 2)
+    assert e.encloses_point(e.center)
+    assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
+    assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
+    assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
+    assert e.encloses_point(
+        e.center + Point(e.hradius + Rational(1, 10), 0)) is False
+    e = Ellipse((0, 0), 2, 1)
+    assert e.encloses_point(e.center)
+    assert e.encloses_point(e.center + Point(0, e.vradius - Rational(1, 10)))
+    assert e.encloses_point(e.center + Point(e.hradius - Rational(1, 10), 0))
+    assert e.encloses_point(e.center + Point(e.hradius, 0)) is False
+    assert e.encloses_point(
+        e.center + Point(e.hradius + Rational(1, 10), 0)) is False
+    assert c1.encloses_point(Point(1, 0)) is False
+    assert c1.encloses_point(Point(0.3, 0.4)) is True
+
+    assert e.scale(2, 3) == Ellipse((0, 0), 4, 3)
+    assert e.scale(3, 6) == Ellipse((0, 0), 6, 6)
+    assert e.rotate(pi) == e
+    assert e.rotate(pi, (1, 2)) == Ellipse(Point(2, 4), 2, 1)
+    raises(NotImplementedError, lambda: e.rotate(pi/3))
+
+    # Circle rotation tests (Issue #11743)
+    # Link - https://github.com/sympy/sympy/issues/11743
+    cir = Circle(Point(1, 0), 1)
+    assert cir.rotate(pi/2) == Circle(Point(0, 1), 1)
+    assert cir.rotate(pi/3) == Circle(Point(S.Half, sqrt(3)/2), 1)
+    assert cir.rotate(pi/3, Point(1, 0)) == Circle(Point(1, 0), 1)
+    assert cir.rotate(pi/3, Point(0, 1)) == Circle(Point(S.Half + sqrt(3)/2, S.Half + sqrt(3)/2), 1)
+
+
+def test_construction():
+    e1 = Ellipse(hradius=2, vradius=1, eccentricity=None)
+    assert e1.eccentricity == sqrt(3)/2
+
+    e2 = Ellipse(hradius=2, vradius=None, eccentricity=sqrt(3)/2)
+    assert e2.vradius == 1
+
+    e3 = Ellipse(hradius=None, vradius=1, eccentricity=sqrt(3)/2)
+    assert e3.hradius == 2
+
+    # filter(None, iterator) filters out anything falsey, including 0
+    # eccentricity would be filtered out in this case and the constructor would throw an error
+    e4 = Ellipse(Point(0, 0), hradius=1, eccentricity=0)
+    assert e4.vradius == 1
+
+    #tests for eccentricity > 1
+    raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = S(3)/2))
+    raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity=sec(5)))
+    raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity=S.Pi-S(2)))
+
+    #tests for eccentricity = 1
+    #if vradius is not defined
+    assert Ellipse(None, 1, None, 1).length == 2
+    #if hradius is not defined
+    raises(GeometryError, lambda: Ellipse(None, None, 1, eccentricity = 1))
+
+    #tests for eccentricity < 0
+    raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = -3))
+    raises(GeometryError, lambda: Ellipse(Point(3, 1), hradius=3, eccentricity = -0.5))
+
+def test_ellipse_random_point():
+    y1 = Symbol('y1', real=True)
+    e3 = Ellipse(Point(0, 0), y1, y1)
+    rx, ry = Symbol('rx'), Symbol('ry')
+    for ind in range(0, 5):
+        r = e3.random_point()
+        # substitution should give zero*y1**2
+        assert e3.equation(rx, ry).subs(zip((rx, ry), r.args)).equals(0)
+    # test for the case with seed
+    r = e3.random_point(seed=1)
+    assert e3.equation(rx, ry).subs(zip((rx, ry), r.args)).equals(0)
+
+
+def test_repr():
+    assert repr(Circle((0, 1), 2)) == 'Circle(Point2D(0, 1), 2)'
+
+
+def test_transform():
+    c = Circle((1, 1), 2)
+    assert c.scale(-1) == Circle((-1, 1), 2)
+    assert c.scale(y=-1) == Circle((1, -1), 2)
+    assert c.scale(2) == Ellipse((2, 1), 4, 2)
+
+    assert Ellipse((0, 0), 2, 3).scale(2, 3, (4, 5)) == \
+        Ellipse(Point(-4, -10), 4, 9)
+    assert Circle((0, 0), 2).scale(2, 3, (4, 5)) == \
+        Ellipse(Point(-4, -10), 4, 6)
+    assert Ellipse((0, 0), 2, 3).scale(3, 3, (4, 5)) == \
+        Ellipse(Point(-8, -10), 6, 9)
+    assert Circle((0, 0), 2).scale(3, 3, (4, 5)) == \
+        Circle(Point(-8, -10), 6)
+    assert Circle(Point(-8, -10), 6).scale(Rational(1, 3), Rational(1, 3), (4, 5)) == \
+        Circle((0, 0), 2)
+    assert Circle((0, 0), 2).translate(4, 5) == \
+        Circle((4, 5), 2)
+    assert Circle((0, 0), 2).scale(3, 3) == \
+        Circle((0, 0), 6)
+
+
+def test_bounds():
+    e1 = Ellipse(Point(0, 0), 3, 5)
+    e2 = Ellipse(Point(2, -2), 7, 7)
+    c1 = Circle(Point(2, -2), 7)
+    c2 = Circle(Point(-2, 0), Point(0, 2), Point(2, 0))
+    assert e1.bounds == (-3, -5, 3, 5)
+    assert e2.bounds == (-5, -9, 9, 5)
+    assert c1.bounds == (-5, -9, 9, 5)
+    assert c2.bounds == (-2, -2, 2, 2)
+
+
+def test_reflect():
+    b = Symbol('b')
+    m = Symbol('m')
+    l = Line((0, b), slope=m)
+    t1 = Triangle((0, 0), (1, 0), (2, 3))
+    assert t1.area == -t1.reflect(l).area
+    e = Ellipse((1, 0), 1, 2)
+    assert e.area == -e.reflect(Line((1, 0), slope=0)).area
+    assert e.area == -e.reflect(Line((1, 0), slope=oo)).area
+    raises(NotImplementedError, lambda: e.reflect(Line((1, 0), slope=m)))
+    assert Circle((0, 1), 1).reflect(Line((0, 0), (1, 1))) == Circle(Point2D(1, 0), -1)
+
+
+def test_is_tangent():
+    e1 = Ellipse(Point(0, 0), 3, 5)
+    c1 = Circle(Point(2, -2), 7)
+    assert e1.is_tangent(Point(0, 0)) is False
+    assert e1.is_tangent(Point(3, 0)) is False
+    assert e1.is_tangent(e1) is True
+    assert e1.is_tangent(Ellipse((0, 0), 1, 2)) is False
+    assert e1.is_tangent(Ellipse((0, 0), 3, 2)) is True
+    assert c1.is_tangent(Ellipse((2, -2), 7, 1)) is True
+    assert c1.is_tangent(Circle((11, -2), 2)) is True
+    assert c1.is_tangent(Circle((7, -2), 2)) is True
+    assert c1.is_tangent(Ray((-5, -2), (-15, -20))) is False
+    assert c1.is_tangent(Ray((-3, -2), (-15, -20))) is False
+    assert c1.is_tangent(Ray((-3, -22), (15, 20))) is False
+    assert c1.is_tangent(Ray((9, 20), (9, -20))) is True
+    assert c1.is_tangent(Ray((2, 5), (9, 5))) is True
+    assert c1.is_tangent(Segment((2, 5), (9, 5))) is True
+    assert e1.is_tangent(Segment((2, 2), (-7, 7))) is False
+    assert e1.is_tangent(Segment((0, 0), (1, 2))) is False
+    assert c1.is_tangent(Segment((0, 0), (-5, -2))) is False
+    assert e1.is_tangent(Segment((3, 0), (12, 12))) is False
+    assert e1.is_tangent(Segment((12, 12), (3, 0))) is False
+    assert e1.is_tangent(Segment((-3, 0), (3, 0))) is False
+    assert e1.is_tangent(Segment((-3, 5), (3, 5))) is True
+    assert e1.is_tangent(Line((10, 0), (10, 10))) is False
+    assert e1.is_tangent(Line((0, 0), (1, 1))) is False
+    assert e1.is_tangent(Line((-3, 0), (-2.99, -0.001))) is False
+    assert e1.is_tangent(Line((-3, 0), (-3, 1))) is True
+    assert e1.is_tangent(Polygon((0, 0), (5, 5), (5, -5))) is False
+    assert e1.is_tangent(Polygon((-100, -50), (-40, -334), (-70, -52))) is False
+    assert e1.is_tangent(Polygon((-3, 0), (3, 0), (0, 1))) is False
+    assert e1.is_tangent(Polygon((-3, 0), (3, 0), (0, 5))) is False
+    assert e1.is_tangent(Polygon((-3, 0), (0, -5), (3, 0), (0, 5))) is False
+    assert e1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is True
+    assert c1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is False
+    assert e1.is_tangent(Polygon((0, 0), (3, 0), (7, 7), (0, 5))) is False
+    assert e1.is_tangent(Polygon((3, 12), (3, -12), (6, 5))) is False
+    assert e1.is_tangent(Polygon((3, 12), (3, -12), (0, -5), (0, 5))) is False
+    assert e1.is_tangent(Polygon((3, 0), (5, 7), (6, -5))) is False
+    assert c1.is_tangent(Segment((0, 0), (-5, -2))) is False
+    assert e1.is_tangent(Segment((-3, 0), (3, 0))) is False
+    assert e1.is_tangent(Segment((-3, 5), (3, 5))) is True
+    assert e1.is_tangent(Polygon((0, 0), (5, 5), (5, -5))) is False
+    assert e1.is_tangent(Polygon((-100, -50), (-40, -334), (-70, -52))) is False
+    assert e1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is True
+    assert c1.is_tangent(Polygon((-3, -5), (-3, 5), (3, 5), (3, -5))) is False
+    assert e1.is_tangent(Polygon((3, 12), (3, -12), (0, -5), (0, 5))) is False
+    assert e1.is_tangent(Polygon((3, 0), (5, 7), (6, -5))) is False
+    raises(TypeError, lambda: e1.is_tangent(Point(0, 0, 0)))
+    raises(TypeError, lambda: e1.is_tangent(Rational(5)))
+
+
+def test_parameter_value():
+    t = Symbol('t')
+    e = Ellipse(Point(0, 0), 3, 5)
+    assert e.parameter_value((3, 0), t) == {t: 0}
+    raises(ValueError, lambda: e.parameter_value((4, 0), t))
+
+
+@slow
+def test_second_moment_of_area():
+    x, y = symbols('x, y')
+    e = Ellipse(Point(0, 0), 5, 4)
+    I_yy = 2*4*integrate(sqrt(25 - x**2)*x**2, (x, -5, 5))/5
+    I_xx = 2*5*integrate(sqrt(16 - y**2)*y**2, (y, -4, 4))/4
+    Y = 3*sqrt(1 - x**2/5**2)
+    I_xy = integrate(integrate(y, (y, -Y, Y))*x, (x, -5, 5))
+    assert I_yy == e.second_moment_of_area()[1]
+    assert I_xx == e.second_moment_of_area()[0]
+    assert I_xy == e.second_moment_of_area()[2]
+    #checking for other point
+    t1 = e.second_moment_of_area(Point(6,5))
+    t2 = (580*pi, 845*pi, 600*pi)
+    assert t1==t2
+
+
+def test_section_modulus_and_polar_second_moment_of_area():
+    d = Symbol('d', positive=True)
+    c = Circle((3, 7), 8)
+    assert c.polar_second_moment_of_area() == 2048*pi
+    assert c.section_modulus() == (128*pi, 128*pi)
+    c = Circle((2, 9), d/2)
+    assert c.polar_second_moment_of_area() == pi*d**3*Abs(d)/64 + pi*d*Abs(d)**3/64
+    assert c.section_modulus() == (pi*d**3/S(32), pi*d**3/S(32))
+
+    a, b = symbols('a, b', positive=True)
+    e = Ellipse((4, 6), a, b)
+    assert e.section_modulus() == (pi*a*b**2/S(4), pi*a**2*b/S(4))
+    assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4)
+    e = e.rotate(pi/2) # no change in polar and section modulus
+    assert e.section_modulus() == (pi*a**2*b/S(4), pi*a*b**2/S(4))
+    assert e.polar_second_moment_of_area() == pi*a**3*b/S(4) + pi*a*b**3/S(4)
+
+    e = Ellipse((a, b), 2, 6)
+    assert e.section_modulus() == (18*pi, 6*pi)
+    assert e.polar_second_moment_of_area() == 120*pi
+
+    e = Ellipse(Point(0, 0), 2, 2)
+    assert e.section_modulus() == (2*pi, 2*pi)
+    assert e.section_modulus(Point(2, 2)) == (2*pi, 2*pi)
+    assert e.section_modulus((2, 2)) == (2*pi, 2*pi)
+
+
+def test_circumference():
+    M = Symbol('M')
+    m = Symbol('m')
+    assert Ellipse(Point(0, 0), M, m).circumference == 4 * M * elliptic_e((M ** 2 - m ** 2) / M**2)
+
+    assert Ellipse(Point(0, 0), 5, 4).circumference == 20 * elliptic_e(S(9) / 25)
+
+    # circle
+    assert Ellipse(None, 1, None, 0).circumference == 2*pi
+
+    # test numerically
+    assert abs(Ellipse(None, hradius=5, vradius=3).circumference.evalf(16) - 25.52699886339813) < 1e-10
+
+
+def test_issue_15259():
+    assert Circle((1, 2), 0) == Point(1, 2)
+
+
+def test_issue_15797_equals():
+    Ri = 0.024127189424130748
+    Ci = (0.0864931002830291, 0.0819863295239654)
+    A = Point(0, 0.0578591400998346)
+    c = Circle(Ci, Ri)  # evaluated
+    assert c.is_tangent(c.tangent_lines(A)[0]) == True
+    assert c.center.x.is_Rational
+    assert c.center.y.is_Rational
+    assert c.radius.is_Rational
+    u = Circle(Ci, Ri, evaluate=False)  # unevaluated
+    assert u.center.x.is_Float
+    assert u.center.y.is_Float
+    assert u.radius.is_Float
+
+
+def test_auxiliary_circle():
+    x, y, a, b = symbols('x y a b')
+    e = Ellipse((x, y), a, b)
+    # the general result
+    assert e.auxiliary_circle() == Circle((x, y), Max(a, b))
+    # a special case where Ellipse is a Circle
+    assert Circle((3, 4), 8).auxiliary_circle() == Circle((3, 4), 8)
+
+
+def test_director_circle():
+    x, y, a, b = symbols('x y a b')
+    e = Ellipse((x, y), a, b)
+    # the general result
+    assert e.director_circle() == Circle((x, y), sqrt(a**2 + b**2))
+    # a special case where Ellipse is a Circle
+    assert Circle((3, 4), 8).director_circle() == Circle((3, 4), 8*sqrt(2))
+
+
+def test_evolute():
+    #ellipse centered at h,k
+    x, y, h, k = symbols('x y h k',real = True)
+    a, b = symbols('a b')
+    e = Ellipse(Point(h, k), a, b)
+    t1 = (e.hradius*(x - e.center.x))**Rational(2, 3)
+    t2 = (e.vradius*(y - e.center.y))**Rational(2, 3)
+    E = t1 + t2 - (e.hradius**2 - e.vradius**2)**Rational(2, 3)
+    assert e.evolute() == E
+    #Numerical Example
+    e = Ellipse(Point(1, 1), 6, 3)
+    t1 = (6*(x - 1))**Rational(2, 3)
+    t2 = (3*(y - 1))**Rational(2, 3)
+    E = t1 + t2 - (27)**Rational(2, 3)
+    assert e.evolute() == E
+
+
+def test_svg():
+    e1 = Ellipse(Point(1, 0), 3, 2)
+    assert e1._svg(2, "#FFAAFF") == ''
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_entity.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_entity.py
new file mode 100644
index 0000000000000000000000000000000000000000..0d440fd5dbd193c7c490b45a706fab2703e247ec
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_entity.py
@@ -0,0 +1,120 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.geometry import (Circle, Ellipse, Point, Line, Parabola,
+    Polygon, Ray, RegularPolygon, Segment, Triangle, Plane, Curve)
+from sympy.geometry.entity import scale, GeometryEntity
+from sympy.testing.pytest import raises
+
+
+def test_entity():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+
+    assert GeometryEntity(x, y) in GeometryEntity(x, y)
+    raises(NotImplementedError, lambda: Point(0, 0) in GeometryEntity(x, y))
+
+    assert GeometryEntity(x, y) == GeometryEntity(x, y)
+    assert GeometryEntity(x, y).equals(GeometryEntity(x, y))
+
+    c = Circle((0, 0), 5)
+    assert GeometryEntity.encloses(c, Point(0, 0))
+    assert GeometryEntity.encloses(c, Segment((0, 0), (1, 1)))
+    assert GeometryEntity.encloses(c, Line((0, 0), (1, 1))) is False
+    assert GeometryEntity.encloses(c, Circle((0, 0), 4))
+    assert GeometryEntity.encloses(c, Polygon(Point(0, 0), Point(1, 0), Point(0, 1)))
+    assert GeometryEntity.encloses(c, RegularPolygon(Point(8, 8), 1, 3)) is False
+
+
+def test_svg():
+    a = Symbol('a')
+    b = Symbol('b')
+    d = Symbol('d')
+
+    entity = Circle(Point(a, b), d)
+    assert entity._repr_svg_() is None
+
+    entity = Circle(Point(0, 0), S.Infinity)
+    assert entity._repr_svg_() is None
+
+
+def test_subs():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    p = Point(x, 2)
+    q = Point(1, 1)
+    r = Point(3, 4)
+    for o in [p,
+              Segment(p, q),
+              Ray(p, q),
+              Line(p, q),
+              Triangle(p, q, r),
+              RegularPolygon(p, 3, 6),
+              Polygon(p, q, r, Point(5, 4)),
+              Circle(p, 3),
+              Ellipse(p, 3, 4)]:
+        assert 'y' in str(o.subs(x, y))
+    assert p.subs({x: 1}) == Point(1, 2)
+    assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+    assert Point(1, 2).subs((1, 2), Point(3, 4)) == Point(3, 4)
+    assert Point(1, 2).subs(Point(1, 2), Point(3, 4)) == Point(3, 4)
+    assert Point(1, 2).subs({(1, 2)}) == Point(2, 2)
+    raises(ValueError, lambda: Point(1, 2).subs(1))
+    raises(TypeError, lambda: Point(1, 1).subs((Point(1, 1), Point(1,
+           2)), 1, 2))
+
+
+def test_transform():
+    assert scale(1, 2, (3, 4)).tolist() == \
+        [[1, 0, 0], [0, 2, 0], [0, -4, 1]]
+
+
+def test_reflect_entity_overrides():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    b = Symbol('b')
+    m = Symbol('m')
+    l = Line((0, b), slope=m)
+    p = Point(x, y)
+    r = p.reflect(l)
+    c = Circle((x, y), 3)
+    cr = c.reflect(l)
+    assert cr == Circle(r, -3)
+    assert c.area == -cr.area
+
+    pent = RegularPolygon((1, 2), 1, 5)
+    slope = S.ComplexInfinity
+    while slope is S.ComplexInfinity:
+        slope = Rational(*(x._random()/2).as_real_imag())
+    l = Line(pent.vertices[1], slope=slope)
+    rpent = pent.reflect(l)
+    assert rpent.center == pent.center.reflect(l)
+    rvert = [i.reflect(l) for i in pent.vertices]
+    for v in rpent.vertices:
+        for i in range(len(rvert)):
+            ri = rvert[i]
+            if ri.equals(v):
+                rvert.remove(ri)
+                break
+    assert not rvert
+    assert pent.area.equals(-rpent.area)
+
+
+def test_geometry_EvalfMixin():
+    x = pi
+    t = Symbol('t')
+    for g in [
+            Point(x, x),
+            Plane(Point(0, x, 0), (0, 0, x)),
+            Curve((x*t, x), (t, 0, x)),
+            Ellipse((x, x), x, -x),
+            Circle((x, x), x),
+            Line((0, x), (x, 0)),
+            Segment((0, x), (x, 0)),
+            Ray((0, x), (x, 0)),
+            Parabola((0, x), Line((-x, 0), (x, 0))),
+            Polygon((0, 0), (0, x), (x, 0), (x, x)),
+            RegularPolygon((0, x), x, 4, x),
+            Triangle((0, 0), (x, 0), (x, x)),
+            ]:
+        assert str(g).replace('pi', '3.1') == str(g.n(2))
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_geometrysets.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_geometrysets.py
new file mode 100644
index 0000000000000000000000000000000000000000..c52898b3c9ba4e9db80c244db3aebf88db2cc8b4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_geometrysets.py
@@ -0,0 +1,38 @@
+from sympy.core.numbers import Rational
+from sympy.core.singleton import S
+from sympy.geometry import Circle, Line, Point, Polygon, Segment
+from sympy.sets import FiniteSet, Union, Intersection, EmptySet
+
+
+def test_booleans():
+    """ test basic unions and intersections """
+    half = S.Half
+
+    p1, p2, p3, p4 = map(Point, [(0, 0), (1, 0), (5, 1), (0, 1)])
+    p5, p6, p7 = map(Point, [(3, 2), (1, -1), (0, 2)])
+    l1 = Line(Point(0,0), Point(1,1))
+    l2 = Line(Point(half, half), Point(5,5))
+    l3 = Line(p2, p3)
+    l4 = Line(p3, p4)
+    poly1 = Polygon(p1, p2, p3, p4)
+    poly2 = Polygon(p5, p6, p7)
+    poly3 = Polygon(p1, p2, p5)
+    assert Union(l1, l2).equals(l1)
+    assert Intersection(l1, l2).equals(l1)
+    assert Intersection(l1, l4) == FiniteSet(Point(1,1))
+    assert Intersection(Union(l1, l4), l3) == FiniteSet(Point(Rational(-1, 3), Rational(-1, 3)), Point(5, 1))
+    assert Intersection(l1, FiniteSet(Point(7,-7))) == EmptySet
+    assert Intersection(Circle(Point(0,0), 3), Line(p1,p2)) == FiniteSet(Point(-3,0), Point(3,0))
+    assert Intersection(l1, FiniteSet(p1)) == FiniteSet(p1)
+    assert Union(l1, FiniteSet(p1)) == l1
+
+    fs = FiniteSet(Point(Rational(1, 3), 1), Point(Rational(2, 3), 0), Point(Rational(9, 5), Rational(1, 5)), Point(Rational(7, 3), 1))
+    # test the intersection of polygons
+    assert Intersection(poly1, poly2) == fs
+    # make sure if we union polygons with subsets, the subsets go away
+    assert Union(poly1, poly2, fs) == Union(poly1, poly2)
+    # make sure that if we union with a FiniteSet that isn't a subset,
+    # that the points in the intersection stop being listed
+    assert Union(poly1, FiniteSet(Point(0,0), Point(3,5))) == Union(poly1, FiniteSet(Point(3,5)))
+    # intersect two polygons that share an edge
+    assert Intersection(poly1, poly3) == Union(FiniteSet(Point(Rational(3, 2), 1), Point(2, 1)), Segment(Point(0, 0), Point(1, 0)))
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_line.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_line.py
new file mode 100644
index 0000000000000000000000000000000000000000..5158ec05ab414020fbbe2681a2658454dd15b6eb
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_line.py
@@ -0,0 +1,861 @@
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.relational import Eq
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.sets import EmptySet
+from sympy.simplify.simplify import simplify
+from sympy.functions.elementary.trigonometric import tan
+from sympy.geometry import (Circle, GeometryError, Line, Point, Ray,
+    Segment, Triangle, intersection, Point3D, Line3D, Ray3D, Segment3D,
+    Point2D, Line2D, Plane)
+from sympy.geometry.line import Undecidable
+from sympy.geometry.polygon import _asa as asa
+from sympy.utilities.iterables import cartes
+from sympy.testing.pytest import raises, warns
+
+
+x = Symbol('x', real=True)
+y = Symbol('y', real=True)
+z = Symbol('z', real=True)
+k = Symbol('k', real=True)
+x1 = Symbol('x1', real=True)
+y1 = Symbol('y1', real=True)
+t = Symbol('t', real=True)
+a, b = symbols('a,b', real=True)
+m = symbols('m', real=True)
+
+
+def test_object_from_equation():
+    from sympy.abc import x, y, a, b
+    assert Line(3*x + y + 18) == Line2D(Point2D(0, -18), Point2D(1, -21))
+    assert Line(3*x + 5 * y + 1) == Line2D(
+        Point2D(0, Rational(-1, 5)), Point2D(1, Rational(-4, 5)))
+    assert Line(3*a + b + 18, x="a", y="b") == Line2D(
+        Point2D(0, -18), Point2D(1, -21))
+    assert Line(3*x + y) == Line2D(Point2D(0, 0), Point2D(1, -3))
+    assert Line(x + y) == Line2D(Point2D(0, 0), Point2D(1, -1))
+    assert Line(Eq(3*a + b, -18), x="a", y=b) == Line2D(
+        Point2D(0, -18), Point2D(1, -21))
+    # issue 22361
+    assert Line(x - 1) == Line2D(Point2D(1, 0), Point2D(1, 1))
+    assert Line(2*x - 2, y=x) == Line2D(Point2D(0, 1), Point2D(1, 1))
+    assert Line(y) == Line2D(Point2D(0, 0), Point2D(1, 0))
+    assert Line(2*y, x=y) == Line2D(Point2D(0, 0), Point2D(0, 1))
+    assert Line(y, x=y) == Line2D(Point2D(0, 0), Point2D(0, 1))
+    raises(ValueError, lambda: Line(x / y))
+    raises(ValueError, lambda: Line(a / b, x='a', y='b'))
+    raises(ValueError, lambda: Line(y / x))
+    raises(ValueError, lambda: Line(b / a, x='a', y='b'))
+    raises(ValueError, lambda: Line((x + 1)**2 + y))
+
+
+def feq(a, b):
+    """Test if two floating point values are 'equal'."""
+    t_float = Float("1.0E-10")
+    return -t_float < a - b < t_float
+
+
+def test_angle_between():
+    a = Point(1, 2, 3, 4)
+    b = a.orthogonal_direction
+    o = a.origin
+    assert feq(Line.angle_between(Line(Point(0, 0), Point(1, 1)),
+                                  Line(Point(0, 0), Point(5, 0))).evalf(), pi.evalf() / 4)
+    assert Line(a, o).angle_between(Line(b, o)) == pi / 2
+    z = Point3D(0, 0, 0)
+    assert Line3D.angle_between(Line3D(z, Point3D(1, 1, 1)),
+                                Line3D(z, Point3D(5, 0, 0))) == acos(sqrt(3) / 3)
+    # direction of points is used to determine angle
+    assert Line3D.angle_between(Line3D(z, Point3D(1, 1, 1)),
+                                Line3D(Point3D(5, 0, 0), z)) == acos(-sqrt(3) / 3)
+
+
+def test_closing_angle():
+    a = Ray((0, 0), angle=0)
+    b = Ray((1, 2), angle=pi/2)
+    assert a.closing_angle(b) == -pi/2
+    assert b.closing_angle(a) == pi/2
+    assert a.closing_angle(a) == 0
+
+
+def test_smallest_angle():
+    a = Line(Point(1, 1), Point(1, 2))
+    b = Line(Point(1, 1),Point(2, 3))
+    assert a.smallest_angle_between(b) == acos(2*sqrt(5)/5)
+
+
+def test_svg():
+    a = Line(Point(1, 1),Point(1, 2))
+    assert a._svg() == ''
+    a = Segment(Point(1, 0),Point(1, 1))
+    assert a._svg() == ''
+    a = Ray(Point(2, 3), Point(3, 5))
+    assert a._svg() == ''
+
+
+def test_arbitrary_point():
+    l1 = Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+    l2 = Line(Point(x1, x1), Point(y1, y1))
+    assert l2.arbitrary_point() in l2
+    assert Ray((1, 1), angle=pi / 4).arbitrary_point() == \
+           Point(t + 1, t + 1)
+    assert Segment((1, 1), (2, 3)).arbitrary_point() == Point(1 + t, 1 + 2 * t)
+    assert l1.perpendicular_segment(l1.arbitrary_point()) == l1.arbitrary_point()
+    assert Ray3D((1, 1, 1), direction_ratio=[1, 2, 3]).arbitrary_point() == \
+           Point3D(t + 1, 2 * t + 1, 3 * t + 1)
+    assert Segment3D(Point3D(0, 0, 0), Point3D(1, 1, 1)).midpoint == \
+           Point3D(S.Half, S.Half, S.Half)
+    assert Segment3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1)).length == sqrt(3) * sqrt((x1 - y1) ** 2)
+    assert Segment3D((1, 1, 1), (2, 3, 4)).arbitrary_point() == \
+           Point3D(t + 1, 2 * t + 1, 3 * t + 1)
+    raises(ValueError, (lambda: Line((x, 1), (2, 3)).arbitrary_point(x)))
+
+
+def test_are_concurrent_2d():
+    l1 = Line(Point(0, 0), Point(1, 1))
+    l2 = Line(Point(x1, x1), Point(x1, 1 + x1))
+    assert Line.are_concurrent(l1) is False
+    assert Line.are_concurrent(l1, l2)
+    assert Line.are_concurrent(l1, l1, l1, l2)
+    assert Line.are_concurrent(l1, l2, Line(Point(5, x1), Point(Rational(-3, 5), x1)))
+    assert Line.are_concurrent(l1, Line(Point(0, 0), Point(-x1, x1)), l2) is False
+
+
+def test_are_concurrent_3d():
+    p1 = Point3D(0, 0, 0)
+    l1 = Line(p1, Point3D(1, 1, 1))
+    parallel_1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+    parallel_2 = Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))
+    assert Line3D.are_concurrent(l1) is False
+    assert Line3D.are_concurrent(l1, Line(Point3D(x1, x1, x1), Point3D(y1, y1, y1))) is False
+    assert Line3D.are_concurrent(l1, Line3D(p1, Point3D(x1, x1, x1)),
+                                 Line(Point3D(x1, x1, x1), Point3D(x1, 1 + x1, 1))) is True
+    assert Line3D.are_concurrent(parallel_1, parallel_2) is False
+
+
+def test_arguments():
+    """Functions accepting `Point` objects in `geometry`
+    should also accept tuples, lists, and generators and
+    automatically convert them to points."""
+    from sympy.utilities.iterables import subsets
+
+    singles2d = ((1, 2), [1, 3], Point(1, 5))
+    doubles2d = subsets(singles2d, 2)
+    l2d = Line(Point2D(1, 2), Point2D(2, 3))
+    singles3d = ((1, 2, 3), [1, 2, 4], Point(1, 2, 6))
+    doubles3d = subsets(singles3d, 2)
+    l3d = Line(Point3D(1, 2, 3), Point3D(1, 1, 2))
+    singles4d = ((1, 2, 3, 4), [1, 2, 3, 5], Point(1, 2, 3, 7))
+    doubles4d = subsets(singles4d, 2)
+    l4d = Line(Point(1, 2, 3, 4), Point(2, 2, 2, 2))
+    # test 2D
+    test_single = ['contains', 'distance', 'equals', 'parallel_line', 'perpendicular_line', 'perpendicular_segment',
+                   'projection', 'intersection']
+    for p in doubles2d:
+        Line2D(*p)
+    for func in test_single:
+        for p in singles2d:
+            getattr(l2d, func)(p)
+    # test 3D
+    for p in doubles3d:
+        Line3D(*p)
+    for func in test_single:
+        for p in singles3d:
+            getattr(l3d, func)(p)
+    # test 4D
+    for p in doubles4d:
+        Line(*p)
+    for func in test_single:
+        for p in singles4d:
+            getattr(l4d, func)(p)
+
+
+def test_basic_properties_2d():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    p10 = Point(2000, 2000)
+    p_r3 = Ray(p1, p2).random_point()
+    p_r4 = Ray(p2, p1).random_point()
+
+    l1 = Line(p1, p2)
+    l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+    l4 = Line(p1, Point(1, 0))
+
+    r1 = Ray(p1, Point(0, 1))
+    r2 = Ray(Point(0, 1), p1)
+
+    s1 = Segment(p1, p10)
+    p_s1 = s1.random_point()
+
+    assert Line((1, 1), slope=1) == Line((1, 1), (2, 2))
+    assert Line((1, 1), slope=oo) == Line((1, 1), (1, 2))
+    assert Line((1, 1), slope=oo).bounds == (1, 1, 1, 2)
+    assert Line((1, 1), slope=-oo) == Line((1, 1), (1, 2))
+    assert Line(p1, p2).scale(2, 1) == Line(p1, Point(2, 1))
+    assert Line(p1, p2) == Line(p1, p2)
+    assert Line(p1, p2) != Line(p2, p1)
+    assert l1 != Line(Point(x1, x1), Point(y1, y1))
+    assert l1 != l3
+    assert Line(p1, p10) != Line(p10, p1)
+    assert Line(p1, p10) != p1
+    assert p1 in l1  # is p1 on the line l1?
+    assert p1 not in l3
+    assert s1 in Line(p1, p10)
+    assert Ray(Point(0, 0), Point(0, 1)) in Ray(Point(0, 0), Point(0, 2))
+    assert Ray(Point(0, 0), Point(0, 2)) in Ray(Point(0, 0), Point(0, 1))
+    assert Ray(Point(0, 0), Point(0, 2)).xdirection == S.Zero
+    assert Ray(Point(0, 0), Point(1, 2)).xdirection == S.Infinity
+    assert Ray(Point(0, 0), Point(-1, 2)).xdirection == S.NegativeInfinity
+    assert Ray(Point(0, 0), Point(2, 0)).ydirection == S.Zero
+    assert Ray(Point(0, 0), Point(2, 2)).ydirection == S.Infinity
+    assert Ray(Point(0, 0), Point(2, -2)).ydirection == S.NegativeInfinity
+    assert (r1 in s1) is False
+    assert Segment(p1, p2) in s1
+    assert Ray(Point(x1, x1), Point(x1, 1 + x1)) != Ray(p1, Point(-1, 5))
+    assert Segment(p1, p2).midpoint == Point(S.Half, S.Half)
+    assert Segment(p1, Point(-x1, x1)).length == sqrt(2 * (x1 ** 2))
+
+    assert l1.slope == 1
+    assert l3.slope is oo
+    assert l4.slope == 0
+    assert Line(p1, Point(0, 1)).slope is oo
+    assert Line(r1.source, r1.random_point()).slope == r1.slope
+    assert Line(r2.source, r2.random_point()).slope == r2.slope
+    assert Segment(Point(0, -1), Segment(p1, Point(0, 1)).random_point()).slope == Segment(p1, Point(0, 1)).slope
+
+    assert l4.coefficients == (0, 1, 0)
+    assert Line((-x, x), (-x + 1, x - 1)).coefficients == (1, 1, 0)
+    assert Line(p1, Point(0, 1)).coefficients == (1, 0, 0)
+    # issue 7963
+    r = Ray((0, 0), angle=x)
+    assert r.subs(x, 3 * pi / 4) == Ray((0, 0), (-1, 1))
+    assert r.subs(x, 5 * pi / 4) == Ray((0, 0), (-1, -1))
+    assert r.subs(x, -pi / 4) == Ray((0, 0), (1, -1))
+    assert r.subs(x, pi / 2) == Ray((0, 0), (0, 1))
+    assert r.subs(x, -pi / 2) == Ray((0, 0), (0, -1))
+
+    for ind in range(0, 5):
+        assert l3.random_point() in l3
+
+    assert p_r3.x >= p1.x and p_r3.y >= p1.y
+    assert p_r4.x <= p2.x and p_r4.y <= p2.y
+    assert p1.x <= p_s1.x <= p10.x and p1.y <= p_s1.y <= p10.y
+    assert hash(s1) != hash(Segment(p10, p1))
+
+    assert s1.plot_interval() == [t, 0, 1]
+    assert Line(p1, p10).plot_interval() == [t, -5, 5]
+    assert Ray((0, 0), angle=pi / 4).plot_interval() == [t, 0, 10]
+
+
+def test_basic_properties_3d():
+    p1 = Point3D(0, 0, 0)
+    p2 = Point3D(1, 1, 1)
+    p3 = Point3D(x1, x1, x1)
+    p5 = Point3D(x1, 1 + x1, 1)
+
+    l1 = Line3D(p1, p2)
+    l3 = Line3D(p3, p5)
+
+    r1 = Ray3D(p1, Point3D(-1, 5, 0))
+    r3 = Ray3D(p1, p2)
+
+    s1 = Segment3D(p1, p2)
+
+    assert Line3D((1, 1, 1), direction_ratio=[2, 3, 4]) == Line3D(Point3D(1, 1, 1), Point3D(3, 4, 5))
+    assert Line3D((1, 1, 1), direction_ratio=[1, 5, 7]) == Line3D(Point3D(1, 1, 1), Point3D(2, 6, 8))
+    assert Line3D((1, 1, 1), direction_ratio=[1, 2, 3]) == Line3D(Point3D(1, 1, 1), Point3D(2, 3, 4))
+    assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).direction_cosine == [1, 0, 0]
+    assert Line3D(Line3D(p1, Point3D(0, 1, 0))) == Line3D(p1, Point3D(0, 1, 0))
+    assert Ray3D(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))) == Ray3D(p1, Point3D(1, 0, 0))
+    assert Line3D(p1, p2) != Line3D(p2, p1)
+    assert l1 != l3
+    assert l1 != Line3D(p3, Point3D(y1, y1, y1))
+    assert r3 != r1
+    assert Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 1)) in Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2))
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)) in Ray3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).xdirection == S.Infinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).ydirection == S.Infinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 2)).zdirection == S.Infinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(-2, 2, 2)).xdirection == S.NegativeInfinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, -2, 2)).ydirection == S.NegativeInfinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, -2)).zdirection == S.NegativeInfinity
+    assert Ray3D(Point3D(0, 0, 0), Point3D(0, 2, 2)).xdirection == S.Zero
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 0, 2)).ydirection == S.Zero
+    assert Ray3D(Point3D(0, 0, 0), Point3D(2, 2, 0)).zdirection == S.Zero
+    assert p1 in l1
+    assert p1 not in l3
+
+    assert l1.direction_ratio == [1, 1, 1]
+
+    assert s1.midpoint == Point3D(S.Half, S.Half, S.Half)
+    # Test zdirection
+    assert Ray3D(p1, Point3D(0, 0, -1)).zdirection is S.NegativeInfinity
+
+
+def test_contains():
+    p1 = Point(0, 0)
+
+    r = Ray(p1, Point(4, 4))
+    r1 = Ray3D(p1, Point3D(0, 0, -1))
+    r2 = Ray3D(p1, Point3D(0, 1, 0))
+    r3 = Ray3D(p1, Point3D(0, 0, 1))
+
+    l = Line(Point(0, 1), Point(3, 4))
+    # Segment contains
+    assert Point(0, (a + b) / 2) in Segment((0, a), (0, b))
+    assert Point((a + b) / 2, 0) in Segment((a, 0), (b, 0))
+    assert Point3D(0, 1, 0) in Segment3D((0, 1, 0), (0, 1, 0))
+    assert Point3D(1, 0, 0) in Segment3D((1, 0, 0), (1, 0, 0))
+    assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains([]) is True
+    assert Segment3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).contains(
+        Segment3D(Point3D(2, 2, 2), Point3D(3, 2, 2))) is False
+    # Line contains
+    assert l.contains(Point(0, 1)) is True
+    assert l.contains((0, 1)) is True
+    assert l.contains((0, 0)) is False
+    # Ray contains
+    assert r.contains(p1) is True
+    assert r.contains((1, 1)) is True
+    assert r.contains((1, 3)) is False
+    assert r.contains(Segment((1, 1), (2, 2))) is True
+    assert r.contains(Segment((1, 2), (2, 5))) is False
+    assert r.contains(Ray((2, 2), (3, 3))) is True
+    assert r.contains(Ray((2, 2), (3, 5))) is False
+    assert r1.contains(Segment3D(p1, Point3D(0, 0, -10))) is True
+    assert r1.contains(Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))) is False
+    assert r2.contains(Point3D(0, 0, 0)) is True
+    assert r3.contains(Point3D(0, 0, 0)) is True
+    assert Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0)).contains([]) is False
+    assert Line3D((0, 0, 0), (x, y, z)).contains((2 * x, 2 * y, 2 * z))
+    with warns(UserWarning, test_stacklevel=False):
+        assert Line3D(p1, Point3D(0, 1, 0)).contains(Point(1.0, 1.0)) is False
+
+    with warns(UserWarning, test_stacklevel=False):
+        assert r3.contains(Point(1.0, 1.0)) is False
+
+
+def test_contains_nonreal_symbols():
+    u, v, w, z = symbols('u, v, w, z')
+    l = Segment(Point(u, w), Point(v, z))
+    p = Point(u*Rational(2, 3) + v/3, w*Rational(2, 3) + z/3)
+    assert l.contains(p)
+
+
+def test_distance_2d():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    half = S.Half
+
+    s1 = Segment(Point(0, 0), Point(1, 1))
+    s2 = Segment(Point(half, half), Point(1, 0))
+
+    r = Ray(p1, p2)
+
+    assert s1.distance(Point(0, 0)) == 0
+    assert s1.distance((0, 0)) == 0
+    assert s2.distance(Point(0, 0)) == 2 ** half / 2
+    assert s2.distance(Point(Rational(3) / 2, Rational(3) / 2)) == 2 ** half
+    assert Line(p1, p2).distance(Point(-1, 1)) == sqrt(2)
+    assert Line(p1, p2).distance(Point(1, -1)) == sqrt(2)
+    assert Line(p1, p2).distance(Point(2, 2)) == 0
+    assert Line(p1, p2).distance((-1, 1)) == sqrt(2)
+    assert Line((0, 0), (0, 1)).distance(p1) == 0
+    assert Line((0, 0), (0, 1)).distance(p2) == 1
+    assert Line((0, 0), (1, 0)).distance(p1) == 0
+    assert Line((0, 0), (1, 0)).distance(p2) == 1
+    assert r.distance(Point(-1, -1)) == sqrt(2)
+    assert r.distance(Point(1, 1)) == 0
+    assert r.distance(Point(-1, 1)) == sqrt(2)
+    assert Ray((1, 1), (2, 2)).distance(Point(1.5, 3)) == 3 * sqrt(2) / 4
+    assert r.distance((1, 1)) == 0
+
+
+def test_dimension_normalization():
+    with warns(UserWarning, test_stacklevel=False):
+        assert Ray((1, 1), (2, 1, 2)) == Ray((1, 1, 0), (2, 1, 2))
+
+
+def test_distance_3d():
+    p1, p2 = Point3D(0, 0, 0), Point3D(1, 1, 1)
+    p3 = Point3D(Rational(3) / 2, Rational(3) / 2, Rational(3) / 2)
+
+    s1 = Segment3D(Point3D(0, 0, 0), Point3D(1, 1, 1))
+    s2 = Segment3D(Point3D(S.Half, S.Half, S.Half), Point3D(1, 0, 1))
+
+    r = Ray3D(p1, p2)
+
+    assert s1.distance(p1) == 0
+    assert s2.distance(p1) == sqrt(3) / 2
+    assert s2.distance(p3) == 2 * sqrt(6) / 3
+    assert s1.distance((0, 0, 0)) == 0
+    assert s2.distance((0, 0, 0)) == sqrt(3) / 2
+    assert s1.distance(p1) == 0
+    assert s2.distance(p1) == sqrt(3) / 2
+    assert s2.distance(p3) == 2 * sqrt(6) / 3
+    assert s1.distance((0, 0, 0)) == 0
+    assert s2.distance((0, 0, 0)) == sqrt(3) / 2
+    # Line to point
+    assert Line3D(p1, p2).distance(Point3D(-1, 1, 1)) == 2 * sqrt(6) / 3
+    assert Line3D(p1, p2).distance(Point3D(1, -1, 1)) == 2 * sqrt(6) / 3
+    assert Line3D(p1, p2).distance(Point3D(2, 2, 2)) == 0
+    assert Line3D(p1, p2).distance((2, 2, 2)) == 0
+    assert Line3D(p1, p2).distance((1, -1, 1)) == 2 * sqrt(6) / 3
+    assert Line3D((0, 0, 0), (0, 1, 0)).distance(p1) == 0
+    assert Line3D((0, 0, 0), (0, 1, 0)).distance(p2) == sqrt(2)
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(p1) == 0
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(p2) == sqrt(2)
+    # Line to line
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Line3D((0, 0, 0), (0, 1, 2))) == 0
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Line3D((0, 0, 0), (1, 0, 0))) == 0
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Line3D((10, 0, 0), (10, 1, 2))) == 0
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Line3D((0, 1, 0), (0, 1, 1))) == 1
+    # Line to plane
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Plane((2, 0, 0), (0, 0, 1))) == 0
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Plane((0, 1, 0), (0, 1, 0))) == 1
+    assert Line3D((0, 0, 0), (1, 0, 0)).distance(Plane((1, 1, 3), (1, 0, 0))) == 0
+    # Ray to point
+    assert r.distance(Point3D(-1, -1, -1)) == sqrt(3)
+    assert r.distance(Point3D(1, 1, 1)) == 0
+    assert r.distance((-1, -1, -1)) == sqrt(3)
+    assert r.distance((1, 1, 1)) == 0
+    assert Ray3D((0, 0, 0), (1, 1, 2)).distance((-1, -1, 2)) == 4 * sqrt(3) / 3
+    assert Ray3D((1, 1, 1), (2, 2, 2)).distance(Point3D(1.5, -3, -1)) == Rational(9) / 2
+    assert Ray3D((1, 1, 1), (2, 2, 2)).distance(Point3D(1.5, 3, 1)) == sqrt(78) / 6
+
+
+def test_equals():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+
+    l1 = Line(p1, p2)
+    l2 = Line((0, 5), slope=m)
+    l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+    assert l1.perpendicular_line(p1.args).equals(Line(Point(0, 0), Point(1, -1)))
+    assert l1.perpendicular_line(p1).equals(Line(Point(0, 0), Point(1, -1)))
+    assert Line(Point(x1, x1), Point(y1, y1)).parallel_line(Point(-x1, x1)). \
+        equals(Line(Point(-x1, x1), Point(-y1, 2 * x1 - y1)))
+    assert l3.parallel_line(p1.args).equals(Line(Point(0, 0), Point(0, -1)))
+    assert l3.parallel_line(p1).equals(Line(Point(0, 0), Point(0, -1)))
+    assert (l2.distance(Point(2, 3)) - 2 * abs(m + 1) / sqrt(m ** 2 + 1)).equals(0)
+    assert Line3D(p1, Point3D(0, 1, 0)).equals(Point(1.0, 1.0)) is False
+    assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).equals(Line3D(Point3D(-5, 0, 0), Point3D(-1, 0, 0))) is True
+    assert Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)).equals(Line3D(p1, Point3D(0, 1, 0))) is False
+    assert Ray3D(p1, Point3D(0, 0, -1)).equals(Point(1.0, 1.0)) is False
+    assert Ray3D(p1, Point3D(0, 0, -1)).equals(Ray3D(p1, Point3D(0, 0, -1))) is True
+    assert Line3D((0, 0), (t, t)).perpendicular_line(Point(0, 1, 0)).equals(
+        Line3D(Point3D(0, 1, 0), Point3D(S.Half, S.Half, 0)))
+    assert Line3D((0, 0), (t, t)).perpendicular_segment(Point(0, 1, 0)).equals(Segment3D((0, 1), (S.Half, S.Half)))
+    assert Line3D(p1, Point3D(0, 1, 0)).equals(Point(1.0, 1.0)) is False
+
+
+def test_equation():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    l1 = Line(p1, p2)
+    l3 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+    assert simplify(l1.equation()) in (x - y, y - x)
+    assert simplify(l3.equation()) in (x - x1, x1 - x)
+    assert simplify(l1.equation()) in (x - y, y - x)
+    assert simplify(l3.equation()) in (x - x1, x1 - x)
+
+    assert Line(p1, Point(1, 0)).equation(x=x, y=y) == y
+    assert Line(p1, Point(0, 1)).equation() == x
+    assert Line(Point(2, 0), Point(2, 1)).equation() == x - 2
+    assert Line(p2, Point(2, 1)).equation() == y - 1
+
+    assert Line3D(Point(x1, x1, x1), Point(y1, y1, y1)
+        ).equation() == (-x + y, -x + z)
+    assert Line3D(Point(1, 2, 3), Point(2, 3, 4)
+        ).equation() == (-x + y - 1, -x + z - 2)
+    assert Line3D(Point(1, 2, 3), Point(1, 3, 4)
+        ).equation() == (x - 1, -y + z - 1)
+    assert Line3D(Point(1, 2, 3), Point(2, 2, 4)
+        ).equation() == (y - 2, -x + z - 2)
+    assert Line3D(Point(1, 2, 3), Point(2, 3, 3)
+        ).equation() == (-x + y - 1, z - 3)
+    assert Line3D(Point(1, 2, 3), Point(1, 2, 4)
+        ).equation() == (x - 1, y - 2)
+    assert Line3D(Point(1, 2, 3), Point(1, 3, 3)
+        ).equation() == (x - 1, z - 3)
+    assert Line3D(Point(1, 2, 3), Point(2, 2, 3)
+        ).equation() == (y - 2, z - 3)
+
+
+def test_intersection_2d():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+    p3 = Point(x1, x1)
+    p4 = Point(y1, y1)
+
+    l1 = Line(p1, p2)
+    l3 = Line(Point(0, 0), Point(3, 4))
+
+    r1 = Ray(Point(1, 1), Point(2, 2))
+    r2 = Ray(Point(0, 0), Point(3, 4))
+    r4 = Ray(p1, p2)
+    r6 = Ray(Point(0, 1), Point(1, 2))
+    r7 = Ray(Point(0.5, 0.5), Point(1, 1))
+
+    s1 = Segment(p1, p2)
+    s2 = Segment(Point(0.25, 0.25), Point(0.5, 0.5))
+    s3 = Segment(Point(0, 0), Point(3, 4))
+
+    assert intersection(l1, p1) == [p1]
+    assert intersection(l1, Point(x1, 1 + x1)) == []
+    assert intersection(l1, Line(p3, p4)) in [[l1], [Line(p3, p4)]]
+    assert intersection(l1, l1.parallel_line(Point(x1, 1 + x1))) == []
+    assert intersection(l3, l3) == [l3]
+    assert intersection(l3, r2) == [r2]
+    assert intersection(l3, s3) == [s3]
+    assert intersection(s3, l3) == [s3]
+    assert intersection(Segment(Point(-10, 10), Point(10, 10)), Segment(Point(-5, -5), Point(-5, 5))) == []
+    assert intersection(r2, l3) == [r2]
+    assert intersection(r1, Ray(Point(2, 2), Point(0, 0))) == [Segment(Point(1, 1), Point(2, 2))]
+    assert intersection(r1, Ray(Point(1, 1), Point(-1, -1))) == [Point(1, 1)]
+    assert intersection(r1, Segment(Point(0, 0), Point(2, 2))) == [Segment(Point(1, 1), Point(2, 2))]
+
+    assert r4.intersection(s2) == [s2]
+    assert r4.intersection(Segment(Point(2, 3), Point(3, 4))) == []
+    assert r4.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == [Segment(p1, Point(0.5, 0.5))]
+    assert r4.intersection(Ray(p2, p1)) == [s1]
+    assert Ray(p2, p1).intersection(r6) == []
+    assert r4.intersection(r7) == r7.intersection(r4) == [r7]
+    assert Ray3D((0, 0), (3, 0)).intersection(Ray3D((1, 0), (3, 0))) == [Ray3D((1, 0), (3, 0))]
+    assert Ray3D((1, 0), (3, 0)).intersection(Ray3D((0, 0), (3, 0))) == [Ray3D((1, 0), (3, 0))]
+    assert Ray(Point(0, 0), Point(0, 4)).intersection(Ray(Point(0, 1), Point(0, -1))) == \
+           [Segment(Point(0, 0), Point(0, 1))]
+
+    assert Segment3D((0, 0), (3, 0)).intersection(
+        Segment3D((1, 0), (2, 0))) == [Segment3D((1, 0), (2, 0))]
+    assert Segment3D((1, 0), (2, 0)).intersection(
+        Segment3D((0, 0), (3, 0))) == [Segment3D((1, 0), (2, 0))]
+    assert Segment3D((0, 0), (3, 0)).intersection(
+        Segment3D((3, 0), (4, 0))) == [Point3D((3, 0))]
+    assert Segment3D((0, 0), (3, 0)).intersection(
+        Segment3D((2, 0), (5, 0))) == [Segment3D((2, 0), (3, 0))]
+    assert Segment3D((0, 0), (3, 0)).intersection(
+        Segment3D((-2, 0), (1, 0))) == [Segment3D((0, 0), (1, 0))]
+    assert Segment3D((0, 0), (3, 0)).intersection(
+        Segment3D((-2, 0), (0, 0))) == [Point3D(0, 0)]
+    assert s1.intersection(Segment(Point(1, 1), Point(2, 2))) == [Point(1, 1)]
+    assert s1.intersection(Segment(Point(0.5, 0.5), Point(1.5, 1.5))) == [Segment(Point(0.5, 0.5), p2)]
+    assert s1.intersection(Segment(Point(4, 4), Point(5, 5))) == []
+    assert s1.intersection(Segment(Point(-1, -1), p1)) == [p1]
+    assert s1.intersection(Segment(Point(-1, -1), Point(0.5, 0.5))) == [Segment(p1, Point(0.5, 0.5))]
+    assert s1.intersection(Line(Point(1, 0), Point(2, 1))) == []
+    assert s1.intersection(s2) == [s2]
+    assert s2.intersection(s1) == [s2]
+
+    assert asa(120, 8, 52) == \
+           Triangle(
+               Point(0, 0),
+               Point(8, 0),
+               Point(-4 * cos(19 * pi / 90) / sin(2 * pi / 45),
+                     4 * sqrt(3) * cos(19 * pi / 90) / sin(2 * pi / 45)))
+    assert Line((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
+    assert Line((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
+    assert Ray((0, 0), (1, 1)).intersection(Ray((1, 0), (1, 2))) == [Point(1, 1)]
+    assert Ray((0, 0), (1, 1)).intersection(Segment((1, 0), (1, 2))) == [Point(1, 1)]
+    assert Ray((0, 0), (10, 10)).contains(Segment((1, 1), (2, 2))) is True
+    assert Segment((1, 1), (2, 2)) in Line((0, 0), (10, 10))
+    assert s1.intersection(Ray((1, 1), (4, 4))) == [Point(1, 1)]
+
+    # This test is disabled because it hangs after rref changes which simplify
+    # intermediate results and return a different representation from when the
+    # test was written.
+    # # 16628 - this should be fast
+    # p0 = Point2D(Rational(249, 5), Rational(497999, 10000))
+    # p1 = Point2D((-58977084786*sqrt(405639795226) + 2030690077184193 +
+    #     20112207807*sqrt(630547164901) + 99600*sqrt(255775022850776494562626))
+    #     /(2000*sqrt(255775022850776494562626) + 1991998000*sqrt(405639795226)
+    #     + 1991998000*sqrt(630547164901) + 1622561172902000),
+    #     (-498000*sqrt(255775022850776494562626) - 995999*sqrt(630547164901) +
+    #     90004251917891999 +
+    #     496005510002*sqrt(405639795226))/(10000*sqrt(255775022850776494562626)
+    #     + 9959990000*sqrt(405639795226) + 9959990000*sqrt(630547164901) +
+    #     8112805864510000))
+    # p2 = Point2D(Rational(497, 10), Rational(-497, 10))
+    # p3 = Point2D(Rational(-497, 10), Rational(-497, 10))
+    # l = Line(p0, p1)
+    # s = Segment(p2, p3)
+    # n = (-52673223862*sqrt(405639795226) - 15764156209307469 -
+    #     9803028531*sqrt(630547164901) +
+    #     33200*sqrt(255775022850776494562626))
+    # d = sqrt(405639795226) + 315274080450 + 498000*sqrt(
+    #     630547164901) + sqrt(255775022850776494562626)
+    # assert intersection(l, s) == [
+    #     Point2D(n/d*Rational(3, 2000), Rational(-497, 10))]
+
+
+def test_line_intersection():
+    # see also test_issue_11238 in test_matrices.py
+    x0 = tan(pi*Rational(13, 45))
+    x1 = sqrt(3)
+    x2 = x0**2
+    x, y = [8*x0/(x0 + x1), (24*x0 - 8*x1*x2)/(x2 - 3)]
+    assert Line(Point(0, 0), Point(1, -sqrt(3))).contains(Point(x, y)) is True
+
+
+def test_intersection_3d():
+    p1 = Point3D(0, 0, 0)
+    p2 = Point3D(1, 1, 1)
+
+    l1 = Line3D(p1, p2)
+    l2 = Line3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+    r1 = Ray3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+    r2 = Ray3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+    s1 = Segment3D(Point3D(0, 0, 0), Point3D(3, 4, 0))
+
+    assert intersection(l1, p1) == [p1]
+    assert intersection(l1, Point3D(x1, 1 + x1, 1)) == []
+    assert intersection(l1, l1.parallel_line(p1)) == [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1))]
+    assert intersection(l2, r2) == [r2]
+    assert intersection(l2, s1) == [s1]
+    assert intersection(r2, l2) == [r2]
+    assert intersection(r1, Ray3D(Point3D(1, 1, 1), Point3D(-1, -1, -1))) == [Point3D(1, 1, 1)]
+    assert intersection(r1, Segment3D(Point3D(0, 0, 0), Point3D(2, 2, 2))) == [
+        Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))]
+    assert intersection(Ray3D(Point3D(1, 0, 0), Point3D(-1, 0, 0)), Ray3D(Point3D(0, 1, 0), Point3D(0, -1, 0))) \
+           == [Point3D(0, 0, 0)]
+    assert intersection(r1, Ray3D(Point3D(2, 2, 2), Point3D(0, 0, 0))) == \
+           [Segment3D(Point3D(1, 1, 1), Point3D(2, 2, 2))]
+    assert intersection(s1, r2) == [s1]
+
+    assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).intersection(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) == \
+           [Point3D(2, 2, 1)]
+    assert Line3D((0, 1, 2), (0, 2, 3)).intersection(Line3D((0, 1, 2), (0, 1, 1))) == [Point3D(0, 1, 2)]
+    assert Line3D((0, 0), (t, t)).intersection(Line3D((0, 1), (t, t))) == \
+           [Point3D(t, t)]
+
+    assert Ray3D(Point3D(0, 0, 0), Point3D(0, 4, 0)).intersection(Ray3D(Point3D(0, 1, 1), Point3D(0, -1, 1))) == []
+
+
+def test_is_parallel():
+    p1 = Point3D(0, 0, 0)
+    p2 = Point3D(1, 1, 1)
+    p3 = Point3D(x1, x1, x1)
+
+    l2 = Line(Point(x1, x1), Point(y1, y1))
+    l2_1 = Line(Point(x1, x1), Point(x1, 1 + x1))
+
+    assert Line.is_parallel(Line(Point(0, 0), Point(1, 1)), l2)
+    assert Line.is_parallel(l2, Line(Point(x1, x1), Point(x1, 1 + x1))) is False
+    assert Line.is_parallel(l2, l2.parallel_line(Point(-x1, x1)))
+    assert Line.is_parallel(l2_1, l2_1.parallel_line(Point(0, 0)))
+    assert Line3D(p1, p2).is_parallel(Line3D(p1, p2))  # same as in 2D
+    assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).is_parallel(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) is False
+    assert Line3D(p1, p2).parallel_line(p3) == Line3D(Point3D(x1, x1, x1),
+                                                      Point3D(x1 + 1, x1 + 1, x1 + 1))
+    assert Line3D(p1, p2).parallel_line(p3.args) == \
+           Line3D(Point3D(x1, x1, x1), Point3D(x1 + 1, x1 + 1, x1 + 1))
+    assert Line3D(Point3D(4, 0, 1), Point3D(0, 4, 1)).is_parallel(Line3D(Point3D(0, 0, 1), Point3D(4, 4, 1))) is False
+
+
+def test_is_perpendicular():
+    p1 = Point(0, 0)
+    p2 = Point(1, 1)
+
+    l1 = Line(p1, p2)
+    l2 = Line(Point(x1, x1), Point(y1, y1))
+    l1_1 = Line(p1, Point(-x1, x1))
+    # 2D
+    assert Line.is_perpendicular(l1, l1_1)
+    assert Line.is_perpendicular(l1, l2) is False
+    p = l1.random_point()
+    assert l1.perpendicular_segment(p) == p
+    # 3D
+    assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)),
+                                   Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))) is True
+    assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0)),
+                                   Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))) is False
+    assert Line3D.is_perpendicular(Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1)),
+                                   Line3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1))) is False
+
+
+def test_is_similar():
+    p1 = Point(2000, 2000)
+    p2 = p1.scale(2, 2)
+
+    r1 = Ray3D(Point3D(1, 1, 1), Point3D(1, 0, 0))
+    r2 = Ray(Point(0, 0), Point(0, 1))
+
+    s1 = Segment(Point(0, 0), p1)
+
+    assert s1.is_similar(Segment(p1, p2))
+    assert s1.is_similar(r2) is False
+    assert r1.is_similar(Line3D(Point3D(1, 1, 1), Point3D(1, 0, 0))) is True
+    assert r1.is_similar(Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))) is False
+
+
+def test_length():
+    s2 = Segment3D(Point3D(x1, x1, x1), Point3D(y1, y1, y1))
+    assert Line(Point(0, 0), Point(1, 1)).length is oo
+    assert s2.length == sqrt(3) * sqrt((x1 - y1) ** 2)
+    assert Line3D(Point3D(0, 0, 0), Point3D(1, 1, 1)).length is oo
+
+
+def test_projection():
+    p1 = Point(0, 0)
+    p2 = Point3D(0, 0, 0)
+    p3 = Point(-x1, x1)
+
+    l1 = Line(p1, Point(1, 1))
+    l2 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+    l3 = Line3D(p2, Point3D(1, 1, 1))
+
+    r1 = Ray(Point(1, 1), Point(2, 2))
+
+    s1 = Segment(Point2D(0, 0), Point2D(0, 1))
+    s2 = Segment(Point2D(1, 0), Point2D(2, 1/2))
+
+    assert Line(Point(x1, x1), Point(y1, y1)).projection(Point(y1, y1)) == Point(y1, y1)
+    assert Line(Point(x1, x1), Point(x1, 1 + x1)).projection(Point(1, 1)) == Point(x1, 1)
+    assert Segment(Point(-2, 2), Point(0, 4)).projection(r1) == Segment(Point(-1, 3), Point(0, 4))
+    assert Segment(Point(0, 4), Point(-2, 2)).projection(r1) == Segment(Point(0, 4), Point(-1, 3))
+    assert s2.projection(s1) == EmptySet
+    assert l1.projection(p3) == p1
+    assert l1.projection(Ray(p1, Point(-1, 5))) == Ray(Point(0, 0), Point(2, 2))
+    assert l1.projection(Ray(p1, Point(-1, 1))) == p1
+    assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
+    assert r1.projection(Ray(Point(0, 4), Point(-1, -5))) == Segment(Point(1, 1), Point(2, 2))
+    assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(Point(1, 1), Point(2, 2))
+    assert r1.projection(Ray(Point(1, 1), Point(-1, -1))) == Point(1, 1)
+    assert r1.projection(Ray(Point(0, 4), Point(-1, -5))) == Segment(Point(1, 1), Point(2, 2))
+    assert r1.projection(Segment(Point(-1, 5), Point(-5, -10))) == Segment(Point(1, 1), Point(2, 2))
+
+    assert l3.projection(Ray3D(p2, Point3D(-1, 5, 0))) == Ray3D(Point3D(0, 0, 0), Point3D(Rational(4, 3), Rational(4, 3), Rational(4, 3)))
+    assert l3.projection(Ray3D(p2, Point3D(-1, 1, 1))) == Ray3D(Point3D(0, 0, 0), Point3D(Rational(1, 3), Rational(1, 3), Rational(1, 3)))
+    assert l2.projection(Point3D(5, 5, 0)) == Point3D(5, 0)
+    assert l2.projection(Line3D(Point3D(0, 1, 0), Point3D(1, 1, 0))).equals(l2)
+
+
+def test_perpendicular_line():
+    # 3d - requires a particular orthogonal to be selected
+    p1, p2, p3 = Point(0, 0, 0), Point(2, 3, 4), Point(-2, 2, 0)
+    l = Line(p1, p2)
+    p = l.perpendicular_line(p3)
+    assert p.p1 == p3
+    assert p.p2 in l
+    # 2d - does not require special selection
+    p1, p2, p3 = Point(0, 0), Point(2, 3), Point(-2, 2)
+    l = Line(p1, p2)
+    p = l.perpendicular_line(p3)
+    assert p.p1 == p3
+    # p is directed from l to p3
+    assert p.direction.unit == (p3 - l.projection(p3)).unit
+
+
+def test_perpendicular_bisector():
+    s1 = Segment(Point(0, 0), Point(1, 1))
+    aline = Line(Point(S.Half, S.Half), Point(Rational(3, 2), Rational(-1, 2)))
+    on_line = Segment(Point(S.Half, S.Half), Point(Rational(3, 2), Rational(-1, 2))).midpoint
+
+    assert s1.perpendicular_bisector().equals(aline)
+    assert s1.perpendicular_bisector(on_line).equals(Segment(s1.midpoint, on_line))
+    assert s1.perpendicular_bisector(on_line + (1, 0)).equals(aline)
+
+
+def test_raises():
+    d, e = symbols('a,b', real=True)
+    s = Segment((d, 0), (e, 0))
+
+    raises(TypeError, lambda: Line((1, 1), 1))
+    raises(ValueError, lambda: Line(Point(0, 0), Point(0, 0)))
+    raises(Undecidable, lambda: Point(2 * d, 0) in s)
+    raises(ValueError, lambda: Ray3D(Point(1.0, 1.0)))
+    raises(ValueError, lambda: Line3D(Point3D(0, 0, 0), Point3D(0, 0, 0)))
+    raises(TypeError, lambda: Line3D((1, 1), 1))
+    raises(ValueError, lambda: Line3D(Point3D(0, 0, 0)))
+    raises(TypeError, lambda: Ray((1, 1), 1))
+    raises(GeometryError, lambda: Line(Point(0, 0), Point(1, 0))
+           .projection(Circle(Point(0, 0), 1)))
+
+
+def test_ray_generation():
+    assert Ray((1, 1), angle=pi / 4) == Ray((1, 1), (2, 2))
+    assert Ray((1, 1), angle=pi / 2) == Ray((1, 1), (1, 2))
+    assert Ray((1, 1), angle=-pi / 2) == Ray((1, 1), (1, 0))
+    assert Ray((1, 1), angle=-3 * pi / 2) == Ray((1, 1), (1, 2))
+    assert Ray((1, 1), angle=5 * pi / 2) == Ray((1, 1), (1, 2))
+    assert Ray((1, 1), angle=5.0 * pi / 2) == Ray((1, 1), (1, 2))
+    assert Ray((1, 1), angle=pi) == Ray((1, 1), (0, 1))
+    assert Ray((1, 1), angle=3.0 * pi) == Ray((1, 1), (0, 1))
+    assert Ray((1, 1), angle=4.0 * pi) == Ray((1, 1), (2, 1))
+    assert Ray((1, 1), angle=0) == Ray((1, 1), (2, 1))
+    assert Ray((1, 1), angle=4.05 * pi) == Ray(Point(1, 1),
+                                               Point(2, -sqrt(5) * sqrt(2 * sqrt(5) + 10) / 4 - sqrt(
+                                                   2 * sqrt(5) + 10) / 4 + 2 + sqrt(5)))
+    assert Ray((1, 1), angle=4.02 * pi) == Ray(Point(1, 1),
+                                               Point(2, 1 + tan(4.02 * pi)))
+    assert Ray((1, 1), angle=5) == Ray((1, 1), (2, 1 + tan(5)))
+
+    assert Ray3D((1, 1, 1), direction_ratio=[4, 4, 4]) == Ray3D(Point3D(1, 1, 1), Point3D(5, 5, 5))
+    assert Ray3D((1, 1, 1), direction_ratio=[1, 2, 3]) == Ray3D(Point3D(1, 1, 1), Point3D(2, 3, 4))
+    assert Ray3D((1, 1, 1), direction_ratio=[1, 1, 1]) == Ray3D(Point3D(1, 1, 1), Point3D(2, 2, 2))
+
+
+def test_issue_7814():
+    circle = Circle(Point(x, 0), y)
+    line = Line(Point(k, z), slope=0)
+    _s = sqrt((y - z)*(y + z))
+    assert line.intersection(circle) == [Point2D(x + _s, z), Point2D(x - _s, z)]
+
+
+def test_issue_2941():
+    def _check():
+        for f, g in cartes(*[(Line, Ray, Segment)] * 2):
+            l1 = f(a, b)
+            l2 = g(c, d)
+            assert l1.intersection(l2) == l2.intersection(l1)
+    # intersect at end point
+    c, d = (-2, -2), (-2, 0)
+    a, b = (0, 0), (1, 1)
+    _check()
+    # midline intersection
+    c, d = (-2, -3), (-2, 0)
+    _check()
+
+
+def test_parameter_value():
+    t = Symbol('t')
+    p1, p2 = Point(0, 1), Point(5, 6)
+    l = Line(p1, p2)
+    assert l.parameter_value((5, 6), t) == {t: 1}
+    raises(ValueError, lambda: l.parameter_value((0, 0), t))
+
+
+def test_bisectors():
+    r1 = Line3D(Point3D(0, 0, 0), Point3D(1, 0, 0))
+    r2 = Line3D(Point3D(0, 0, 0), Point3D(0, 1, 0))
+    bisections = r1.bisectors(r2)
+    assert bisections == [Line3D(Point3D(0, 0, 0), Point3D(1, 1, 0)),
+        Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+    ans = [Line3D(Point3D(0, 0, 0), Point3D(1, 0, 1)),
+        Line3D(Point3D(0, 0, 0), Point3D(-1, 0, 1))]
+    l1 = (0, 0, 0), (0, 0, 1)
+    l2 = (0, 0), (1, 0)
+    for a, b in cartes((Line, Segment, Ray), repeat=2):
+        assert a(*l1).bisectors(b(*l2)) == ans
+
+
+def test_issue_8615():
+    a = Line3D(Point3D(6, 5, 0), Point3D(6, -6, 0))
+    b = Line3D(Point3D(6, -1, 19/10), Point3D(6, -1, 0))
+    assert a.intersection(b) == [Point3D(6, -1, 0)]
+
+
+def test_issue_12598():
+    r1 = Ray(Point(0, 1), Point(0.98, 0.79).n(2))
+    r2 = Ray(Point(0, 0), Point(0.71, 0.71).n(2))
+    assert str(r1.intersection(r2)[0]) == 'Point2D(0.82, 0.82)'
+    l1 = Line((0, 0), (1, 1))
+    l2 = Segment((-1, 1), (0, -1)).n(2)
+    assert str(l1.intersection(l2)[0]) == 'Point2D(-0.33, -0.33)'
+    l2 = Segment((-1, 1), (-1/2, 1/2)).n(2)
+    assert not l1.intersection(l2)
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_parabola.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_parabola.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a683f26619952d93475aca9ebd3d47cfb3657a6
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_parabola.py
@@ -0,0 +1,143 @@
+from sympy.core.numbers import (Rational, oo)
+from sympy.core.singleton import S
+from sympy.core.symbol import symbols
+from sympy.functions.elementary.complexes import sign
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry.ellipse import (Circle, Ellipse)
+from sympy.geometry.line import (Line, Ray2D, Segment2D)
+from sympy.geometry.parabola import Parabola
+from sympy.geometry.point import (Point, Point2D)
+from sympy.testing.pytest import raises
+
+from sympy.abc import x, y
+
+def test_parabola_geom():
+    a, b = symbols('a b')
+    p1 = Point(0, 0)
+    p2 = Point(3, 7)
+    p3 = Point(0, 4)
+    p4 = Point(6, 0)
+    p5 = Point(a, a)
+    d1 = Line(Point(4, 0), Point(4, 9))
+    d2 = Line(Point(7, 6), Point(3, 6))
+    d3 = Line(Point(4, 0), slope=oo)
+    d4 = Line(Point(7, 6), slope=0)
+    d5 = Line(Point(b, a), slope=oo)
+    d6 = Line(Point(a, b), slope=0)
+
+    half = S.Half
+
+    pa1 = Parabola(None, d2)
+    pa2 = Parabola(directrix=d1)
+    pa3 = Parabola(p1, d1)
+    pa4 = Parabola(p2, d2)
+    pa5 = Parabola(p2, d4)
+    pa6 = Parabola(p3, d2)
+    pa7 = Parabola(p2, d1)
+    pa8 = Parabola(p4, d1)
+    pa9 = Parabola(p4, d3)
+    pa10 = Parabola(p5, d5)
+    pa11 = Parabola(p5, d6)
+    d = Line(Point(3, 7), Point(2, 9))
+    pa12 = Parabola(Point(7, 8), d)
+    pa12r = Parabola(Point(7, 8).reflect(d), d)
+
+    raises(ValueError, lambda:
+           Parabola(Point(7, 8, 9), Line(Point(6, 7), Point(7, 7))))
+    raises(ValueError, lambda:
+           Parabola(Point(0, 2), Line(Point(7, 2), Point(6, 2))))
+    raises(ValueError, lambda: Parabola(Point(7, 8), Point(3, 8)))
+
+    # Basic Stuff
+    assert pa1.focus == Point(0, 0)
+    assert pa1.ambient_dimension == S(2)
+    assert pa2 == pa3
+    assert pa4 != pa7
+    assert pa6 != pa7
+    assert pa6.focus == Point2D(0, 4)
+    assert pa6.focal_length == 1
+    assert pa6.p_parameter == -1
+    assert pa6.vertex == Point2D(0, 5)
+    assert pa6.eccentricity == 1
+    assert pa7.focus == Point2D(3, 7)
+    assert pa7.focal_length == half
+    assert pa7.p_parameter == -half
+    assert pa7.vertex == Point2D(7*half, 7)
+    assert pa4.focal_length == half
+    assert pa4.p_parameter == half
+    assert pa4.vertex == Point2D(3, 13*half)
+    assert pa8.focal_length == 1
+    assert pa8.p_parameter == 1
+    assert pa8.vertex == Point2D(5, 0)
+    assert pa4.focal_length == pa5.focal_length
+    assert pa4.p_parameter == pa5.p_parameter
+    assert pa4.vertex == pa5.vertex
+    assert pa4.equation() == pa5.equation()
+    assert pa8.focal_length == pa9.focal_length
+    assert pa8.p_parameter == pa9.p_parameter
+    assert pa8.vertex == pa9.vertex
+    assert pa8.equation() == pa9.equation()
+    assert pa10.focal_length == pa11.focal_length == sqrt((a - b) ** 2) / 2 # if a, b real == abs(a - b)/2
+    assert pa11.vertex == Point(*pa10.vertex[::-1]) == Point(a,
+                            a - sqrt((a - b)**2)*sign(a - b)/2) # change axis x->y, y->x on pa10
+    aos = pa12.axis_of_symmetry
+    assert aos == Line(Point(7, 8), Point(5, 7))
+    assert pa12.directrix == Line(Point(3, 7), Point(2, 9))
+    assert pa12.directrix.angle_between(aos) == S.Pi/2
+    assert pa12.eccentricity == 1
+    assert pa12.equation(x, y) == (x - 7)**2 + (y - 8)**2 - (-2*x - y + 13)**2/5
+    assert pa12.focal_length == 9*sqrt(5)/10
+    assert pa12.focus == Point(7, 8)
+    assert pa12.p_parameter == 9*sqrt(5)/10
+    assert pa12.vertex == Point2D(S(26)/5, S(71)/10)
+    assert pa12r.focal_length == 9*sqrt(5)/10
+    assert pa12r.focus == Point(-S(1)/5, S(22)/5)
+    assert pa12r.p_parameter == -9*sqrt(5)/10
+    assert pa12r.vertex == Point(S(8)/5, S(53)/10)
+
+
+def test_parabola_intersection():
+    l1 = Line(Point(1, -2), Point(-1,-2))
+    l2 = Line(Point(1, 2), Point(-1,2))
+    l3 = Line(Point(1, 0), Point(-1,0))
+
+    p1 = Point(0,0)
+    p2 = Point(0, -2)
+    p3 = Point(120, -12)
+    parabola1 = Parabola(p1, l1)
+
+    # parabola with parabola
+    assert parabola1.intersection(parabola1) == [parabola1]
+    assert parabola1.intersection(Parabola(p1, l2)) == [Point2D(-2, 0), Point2D(2, 0)]
+    assert parabola1.intersection(Parabola(p2, l3)) == [Point2D(0, -1)]
+    assert parabola1.intersection(Parabola(Point(16, 0), l1)) == [Point2D(8, 15)]
+    assert parabola1.intersection(Parabola(Point(0, 16), l1)) == [Point2D(-6, 8), Point2D(6, 8)]
+    assert parabola1.intersection(Parabola(p3, l3)) == []
+    # parabola with point
+    assert parabola1.intersection(p1) == []
+    assert parabola1.intersection(Point2D(0, -1)) == [Point2D(0, -1)]
+    assert parabola1.intersection(Point2D(4, 3)) == [Point2D(4, 3)]
+    # parabola with line
+    assert parabola1.intersection(Line(Point2D(-7, 3), Point(12, 3))) == [Point2D(-4, 3), Point2D(4, 3)]
+    assert parabola1.intersection(Line(Point(-4, -1), Point(4, -1))) == [Point(0, -1)]
+    assert parabola1.intersection(Line(Point(2, 0), Point(0, -2))) == [Point2D(2, 0)]
+    raises(TypeError, lambda: parabola1.intersection(Line(Point(0, 0, 0), Point(1, 1, 1))))
+    # parabola with segment
+    assert parabola1.intersection(Segment2D((-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
+    assert parabola1.intersection(Segment2D((0, -5), (0, 6))) == [Point2D(0, -1)]
+    assert parabola1.intersection(Segment2D((-12, -65), (14, -68))) == []
+    # parabola with ray
+    assert parabola1.intersection(Ray2D((-4, -5), (4, 3))) == [Point2D(0, -1), Point2D(4, 3)]
+    assert parabola1.intersection(Ray2D((0, 7), (1, 14))) == [Point2D(14 + 2*sqrt(57), 105 + 14*sqrt(57))]
+    assert parabola1.intersection(Ray2D((0, 7), (0, 14))) == []
+    # parabola with ellipse/circle
+    assert parabola1.intersection(Circle(p1, 2)) == [Point2D(-2, 0), Point2D(2, 0)]
+    assert parabola1.intersection(Circle(p2, 1)) == [Point2D(0, -1)]
+    assert parabola1.intersection(Ellipse(p2, 2, 1)) == [Point2D(0, -1)]
+    assert parabola1.intersection(Ellipse(Point(0, 19), 5, 7)) == []
+    assert parabola1.intersection(Ellipse((0, 3), 12, 4)) == [
+           Point2D(0, -1),
+           Point2D(-4*sqrt(17)/3, Rational(59, 9)),
+           Point2D(4*sqrt(17)/3, Rational(59, 9))]
+    # parabola with unsupported type
+    raises(TypeError, lambda: parabola1.intersection(2))
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_plane.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_plane.py
new file mode 100644
index 0000000000000000000000000000000000000000..1010fce5c3bc68348eacee13f29c1d7588f17e39
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_plane.py
@@ -0,0 +1,268 @@
+from sympy.core.numbers import (Rational, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Dummy, symbols)
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (asin, cos, sin)
+from sympy.geometry import Line, Point, Ray, Segment, Point3D, Line3D, Ray3D, Segment3D, Plane, Circle
+from sympy.geometry.util import are_coplanar
+from sympy.testing.pytest import raises
+
+
+def test_plane():
+    x, y, z, u, v = symbols('x y z u v', real=True)
+    p1 = Point3D(0, 0, 0)
+    p2 = Point3D(1, 1, 1)
+    p3 = Point3D(1, 2, 3)
+    pl3 = Plane(p1, p2, p3)
+    pl4 = Plane(p1, normal_vector=(1, 1, 1))
+    pl4b = Plane(p1, p2)
+    pl5 = Plane(p3, normal_vector=(1, 2, 3))
+    pl6 = Plane(Point3D(2, 3, 7), normal_vector=(2, 2, 2))
+    pl7 = Plane(Point3D(1, -5, -6), normal_vector=(1, -2, 1))
+    pl8 = Plane(p1, normal_vector=(0, 0, 1))
+    pl9 = Plane(p1, normal_vector=(0, 12, 0))
+    pl10 = Plane(p1, normal_vector=(-2, 0, 0))
+    pl11 = Plane(p2, normal_vector=(0, 0, 1))
+    l1 = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+    l2 = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+    l3 = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+
+    raises(ValueError, lambda: Plane(p1, p1, p1))
+
+    assert Plane(p1, p2, p3) != Plane(p1, p3, p2)
+    assert Plane(p1, p2, p3).is_coplanar(Plane(p1, p3, p2))
+    assert Plane(p1, p2, p3).is_coplanar(p1)
+    assert Plane(p1, p2, p3).is_coplanar(Circle(p1, 1)) is False
+    assert Plane(p1, normal_vector=(0, 0, 1)).is_coplanar(Circle(p1, 1))
+
+    assert pl3 == Plane(Point3D(0, 0, 0), normal_vector=(1, -2, 1))
+    assert pl3 != pl4
+    assert pl4 == pl4b
+    assert pl5 == Plane(Point3D(1, 2, 3), normal_vector=(1, 2, 3))
+
+    assert pl5.equation(x, y, z) == x + 2*y + 3*z - 14
+    assert pl3.equation(x, y, z) == x - 2*y + z
+
+    assert pl3.p1 == p1
+    assert pl4.p1 == p1
+    assert pl5.p1 == p3
+
+    assert pl4.normal_vector == (1, 1, 1)
+    assert pl5.normal_vector == (1, 2, 3)
+
+    assert p1 in pl3
+    assert p1 in pl4
+    assert p3 in pl5
+
+    assert pl3.projection(Point(0, 0)) == p1
+    p = pl3.projection(Point3D(1, 1, 0))
+    assert p == Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6))
+    assert p in pl3
+
+    l = pl3.projection_line(Line(Point(0, 0), Point(1, 1)))
+    assert l == Line3D(Point3D(0, 0, 0), Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6)))
+    assert l in pl3
+    # get a segment that does not intersect the plane which is also
+    # parallel to pl3's normal veector
+    t = Dummy()
+    r = pl3.random_point()
+    a = pl3.perpendicular_line(r).arbitrary_point(t)
+    s = Segment3D(a.subs(t, 1), a.subs(t, 2))
+    assert s.p1 not in pl3 and s.p2 not in pl3
+    assert pl3.projection_line(s).equals(r)
+    assert pl3.projection_line(Segment(Point(1, 0), Point(1, 1))) == \
+               Segment3D(Point3D(Rational(5, 6), Rational(1, 3), Rational(-1, 6)), Point3D(Rational(7, 6), Rational(2, 3), Rational(1, 6)))
+    assert pl6.projection_line(Ray(Point(1, 0), Point(1, 1))) == \
+               Ray3D(Point3D(Rational(14, 3), Rational(11, 3), Rational(11, 3)), Point3D(Rational(13, 3), Rational(13, 3), Rational(10, 3)))
+    assert pl3.perpendicular_line(r.args) == pl3.perpendicular_line(r)
+
+    assert pl3.is_parallel(pl6) is False
+    assert pl4.is_parallel(pl6)
+    assert pl3.is_parallel(Line(p1, p2))
+    assert pl6.is_parallel(l1) is False
+
+    assert pl3.is_perpendicular(pl6)
+    assert pl4.is_perpendicular(pl7)
+    assert pl6.is_perpendicular(pl7)
+    assert pl6.is_perpendicular(pl4) is False
+    assert pl6.is_perpendicular(l1) is False
+    assert pl6.is_perpendicular(Line((0, 0, 0), (1, 1, 1)))
+    assert pl6.is_perpendicular((1, 1)) is False
+
+    assert pl6.distance(pl6.arbitrary_point(u, v)) == 0
+    assert pl7.distance(pl7.arbitrary_point(u, v)) == 0
+    assert pl6.distance(pl6.arbitrary_point(t)) == 0
+    assert pl7.distance(pl7.arbitrary_point(t)) == 0
+    assert pl6.p1.distance(pl6.arbitrary_point(t)).simplify() == 1
+    assert pl7.p1.distance(pl7.arbitrary_point(t)).simplify() == 1
+    assert pl3.arbitrary_point(t) == Point3D(-sqrt(30)*sin(t)/30 + \
+        2*sqrt(5)*cos(t)/5, sqrt(30)*sin(t)/15 + sqrt(5)*cos(t)/5, sqrt(30)*sin(t)/6)
+    assert pl3.arbitrary_point(u, v) == Point3D(2*u - v, u + 2*v, 5*v)
+
+    assert pl7.distance(Point3D(1, 3, 5)) == 5*sqrt(6)/6
+    assert pl6.distance(Point3D(0, 0, 0)) == 4*sqrt(3)
+    assert pl6.distance(pl6.p1) == 0
+    assert pl7.distance(pl6) == 0
+    assert pl7.distance(l1) == 0
+    assert pl6.distance(Segment3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == \
+        pl6.distance(Point3D(1, 3, 4)) == 4*sqrt(3)/3
+    assert pl6.distance(Segment3D(Point3D(1, 3, 4), Point3D(0, 3, 7))) == \
+        pl6.distance(Point3D(0, 3, 7)) == 2*sqrt(3)/3
+    assert pl6.distance(Segment3D(Point3D(0, 3, 7), Point3D(-1, 3, 10))) == 0
+    assert pl6.distance(Segment3D(Point3D(-1, 3, 10), Point3D(-2, 3, 13))) == 0
+    assert pl6.distance(Segment3D(Point3D(-2, 3, 13), Point3D(-3, 3, 16))) == \
+        pl6.distance(Point3D(-2, 3, 13)) == 2*sqrt(3)/3
+    assert pl6.distance(Plane(Point3D(5, 5, 5), normal_vector=(8, 8, 8))) == sqrt(3)
+    assert pl6.distance(Ray3D(Point3D(1, 3, 4), direction_ratio=[1, 0, -3])) == 4*sqrt(3)/3
+    assert pl6.distance(Ray3D(Point3D(2, 3, 1), direction_ratio=[-1, 0, 3])) == 0
+
+
+    assert pl6.angle_between(pl3) == pi/2
+    assert pl6.angle_between(pl6) == 0
+    assert pl6.angle_between(pl4) == 0
+    assert pl7.angle_between(Line3D(Point3D(2, 3, 5), Point3D(2, 4, 6))) == \
+        -asin(sqrt(3)/6)
+    assert pl6.angle_between(Ray3D(Point3D(2, 4, 1), Point3D(6, 5, 3))) == \
+        asin(sqrt(7)/3)
+    assert pl7.angle_between(Segment3D(Point3D(5, 6, 1), Point3D(1, 2, 4))) == \
+        asin(7*sqrt(246)/246)
+
+    assert are_coplanar(l1, l2, l3) is False
+    assert are_coplanar(l1) is False
+    assert are_coplanar(Point3D(2, 7, 2), Point3D(0, 0, 2),
+        Point3D(1, 1, 2), Point3D(1, 2, 2))
+    assert are_coplanar(Plane(p1, p2, p3), Plane(p1, p3, p2))
+    assert Plane.are_concurrent(pl3, pl4, pl5) is False
+    assert Plane.are_concurrent(pl6) is False
+    raises(ValueError, lambda: Plane.are_concurrent(Point3D(0, 0, 0)))
+    raises(ValueError, lambda: Plane((1, 2, 3), normal_vector=(0, 0, 0)))
+
+    assert pl3.parallel_plane(Point3D(1, 2, 5)) == Plane(Point3D(1, 2, 5), \
+                                                      normal_vector=(1, -2, 1))
+
+    # perpendicular_plane
+    p = Plane((0, 0, 0), (1, 0, 0))
+    # default
+    assert p.perpendicular_plane() == Plane(Point3D(0, 0, 0), (0, 1, 0))
+    # 1 pt
+    assert p.perpendicular_plane(Point3D(1, 0, 1)) == \
+        Plane(Point3D(1, 0, 1), (0, 1, 0))
+    # pts as tuples
+    assert p.perpendicular_plane((1, 0, 1), (1, 1, 1)) == \
+        Plane(Point3D(1, 0, 1), (0, 0, -1))
+    # more than two planes
+    raises(ValueError, lambda: p.perpendicular_plane((1, 0, 1), (1, 1, 1), (1, 1, 0)))
+
+    a, b = Point3D(0, 0, 0), Point3D(0, 1, 0)
+    Z = (0, 0, 1)
+    p = Plane(a, normal_vector=Z)
+    # case 4
+    assert p.perpendicular_plane(a, b) == Plane(a, (1, 0, 0))
+    n = Point3D(*Z)
+    # case 1
+    assert p.perpendicular_plane(a, n) == Plane(a, (-1, 0, 0))
+    # case 2
+    assert Plane(a, normal_vector=b.args).perpendicular_plane(a, a + b) == \
+        Plane(Point3D(0, 0, 0), (1, 0, 0))
+    # case 1&3
+    assert Plane(b, normal_vector=Z).perpendicular_plane(b, b + n) == \
+        Plane(Point3D(0, 1, 0), (-1, 0, 0))
+    # case 2&3
+    assert Plane(b, normal_vector=b.args).perpendicular_plane(n, n + b) == \
+        Plane(Point3D(0, 0, 1), (1, 0, 0))
+
+    p = Plane(a, normal_vector=(0, 0, 1))
+    assert p.perpendicular_plane() == Plane(a, normal_vector=(1, 0, 0))
+
+    assert pl6.intersection(pl6) == [pl6]
+    assert pl4.intersection(pl4.p1) == [pl4.p1]
+    assert pl3.intersection(pl6) == [
+        Line3D(Point3D(8, 4, 0), Point3D(2, 4, 6))]
+    assert pl3.intersection(Line3D(Point3D(1,2,4), Point3D(4,4,2))) == [
+        Point3D(2, Rational(8, 3), Rational(10, 3))]
+    assert pl3.intersection(Plane(Point3D(6, 0, 0), normal_vector=(2, -5, 3))
+        ) == [Line3D(Point3D(-24, -12, 0), Point3D(-25, -13, -1))]
+    assert pl6.intersection(Ray3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == [
+        Point3D(-1, 3, 10)]
+    assert pl6.intersection(Segment3D(Point3D(2, 3, 1), Point3D(1, 3, 4))) == []
+    assert pl7.intersection(Line(Point(2, 3), Point(4, 2))) == [
+        Point3D(Rational(13, 2), Rational(3, 4), 0)]
+    r = Ray(Point(2, 3), Point(4, 2))
+    assert Plane((1,2,0), normal_vector=(0,0,1)).intersection(r) == [
+        Ray3D(Point(2, 3), Point(4, 2))]
+    assert pl9.intersection(pl8) == [Line3D(Point3D(0, 0, 0), Point3D(12, 0, 0))]
+    assert pl10.intersection(pl11) == [Line3D(Point3D(0, 0, 1), Point3D(0, 2, 1))]
+    assert pl4.intersection(pl8) == [Line3D(Point3D(0, 0, 0), Point3D(1, -1, 0))]
+    assert pl11.intersection(pl8) == []
+    assert pl9.intersection(pl11) == [Line3D(Point3D(0, 0, 1), Point3D(12, 0, 1))]
+    assert pl9.intersection(pl4) == [Line3D(Point3D(0, 0, 0), Point3D(12, 0, -12))]
+    assert pl3.random_point() in pl3
+    assert pl3.random_point(seed=1) in pl3
+
+    # test geometrical entity using equals
+    assert pl4.intersection(pl4.p1)[0].equals(pl4.p1)
+    assert pl3.intersection(pl6)[0].equals(Line3D(Point3D(8, 4, 0), Point3D(2, 4, 6)))
+    pl8 = Plane((1, 2, 0), normal_vector=(0, 0, 1))
+    assert pl8.intersection(Line3D(p1, (1, 12, 0)))[0].equals(Line((0, 0, 0), (0.1, 1.2, 0)))
+    assert pl8.intersection(Ray3D(p1, (1, 12, 0)))[0].equals(Ray((0, 0, 0), (1, 12, 0)))
+    assert pl8.intersection(Segment3D(p1, (21, 1, 0)))[0].equals(Segment3D(p1, (21, 1, 0)))
+    assert pl8.intersection(Plane(p1, normal_vector=(0, 0, 112)))[0].equals(pl8)
+    assert pl8.intersection(Plane(p1, normal_vector=(0, 12, 0)))[0].equals(
+        Line3D(p1, direction_ratio=(112 * pi, 0, 0)))
+    assert pl8.intersection(Plane(p1, normal_vector=(11, 0, 1)))[0].equals(
+        Line3D(p1, direction_ratio=(0, -11, 0)))
+    assert pl8.intersection(Plane(p1, normal_vector=(1, 0, 11)))[0].equals(
+        Line3D(p1, direction_ratio=(0, 11, 0)))
+    assert pl8.intersection(Plane(p1, normal_vector=(-1, -1, -11)))[0].equals(
+        Line3D(p1, direction_ratio=(1, -1, 0)))
+    assert pl3.random_point() in pl3
+    assert len(pl8.intersection(Ray3D(Point3D(0, 2, 3), Point3D(1, 0, 3)))) == 0
+    # check if two plane are equals
+    assert pl6.intersection(pl6)[0].equals(pl6)
+    assert pl8.equals(Plane(p1, normal_vector=(0, 12, 0))) is False
+    assert pl8.equals(pl8)
+    assert pl8.equals(Plane(p1, normal_vector=(0, 0, -12)))
+    assert pl8.equals(Plane(p1, normal_vector=(0, 0, -12*sqrt(3))))
+    assert pl8.equals(p1) is False
+
+    # issue 8570
+    l2 = Line3D(Point3D(Rational(50000004459633, 5000000000000),
+                        Rational(-891926590718643, 1000000000000000),
+                        Rational(231800966893633, 100000000000000)),
+                Point3D(Rational(50000004459633, 50000000000000),
+                        Rational(-222981647679771, 250000000000000),
+                        Rational(231800966893633, 100000000000000)))
+
+    p2 = Plane(Point3D(Rational(402775636372767, 100000000000000),
+                       Rational(-97224357654973, 100000000000000),
+                       Rational(216793600814789, 100000000000000)),
+               (-S('9.00000087501922'), -S('4.81170658872543e-13'),
+                S('0.0')))
+
+    assert str([i.n(2) for i in p2.intersection(l2)]) == \
+           '[Point3D(4.0, -0.89, 2.3)]'
+
+
+def test_dimension_normalization():
+    A = Plane(Point3D(1, 1, 2), normal_vector=(1, 1, 1))
+    b = Point(1, 1)
+    assert A.projection(b) == Point(Rational(5, 3), Rational(5, 3), Rational(2, 3))
+
+    a, b = Point(0, 0), Point3D(0, 1)
+    Z = (0, 0, 1)
+    p = Plane(a, normal_vector=Z)
+    assert p.perpendicular_plane(a, b) == Plane(Point3D(0, 0, 0), (1, 0, 0))
+    assert Plane((1, 2, 1), (2, 1, 0), (3, 1, 2)
+        ).intersection((2, 1)) == [Point(2, 1, 0)]
+
+
+def test_parameter_value():
+    t, u, v = symbols("t, u v")
+    p1, p2, p3 = Point(0, 0, 0), Point(0, 0, 1), Point(0, 1, 0)
+    p = Plane(p1, p2, p3)
+    assert p.parameter_value((0, -3, 2), t) == {t: asin(2*sqrt(13)/13)}
+    assert p.parameter_value((0, -3, 2), u, v) == {u: 3, v: 2}
+    assert p.parameter_value(p1, t) == p1
+    raises(ValueError, lambda: p.parameter_value((1, 0, 0), t))
+    raises(ValueError, lambda: p.parameter_value(Line(Point(0, 0), Point(1, 1)), t))
+    raises(ValueError, lambda: p.parameter_value((0, -3, 2), t, 1))
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_point.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_point.py
new file mode 100644
index 0000000000000000000000000000000000000000..1f2b2768eb3fba2009f702351de1aac3ed6e71d4
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_point.py
@@ -0,0 +1,481 @@
+from sympy.core.basic import Basic
+from sympy.core.numbers import (I, Rational, pi)
+from sympy.core.parameters import evaluate
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.core.sympify import sympify
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Line, Point, Point2D, Point3D, Line3D, Plane
+from sympy.geometry.entity import rotate, scale, translate, GeometryEntity
+from sympy.matrices import Matrix
+from sympy.utilities.iterables import subsets, permutations, cartes
+from sympy.utilities.misc import Undecidable
+from sympy.testing.pytest import raises, warns
+
+
+def test_point():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    x1 = Symbol('x1', real=True)
+    x2 = Symbol('x2', real=True)
+    y1 = Symbol('y1', real=True)
+    y2 = Symbol('y2', real=True)
+    half = S.Half
+    p1 = Point(x1, x2)
+    p2 = Point(y1, y2)
+    p3 = Point(0, 0)
+    p4 = Point(1, 1)
+    p5 = Point(0, 1)
+    line = Line(Point(1, 0), slope=1)
+
+    assert p1 in p1
+    assert p1 not in p2
+    assert p2.y == y2
+    assert (p3 + p4) == p4
+    assert (p2 - p1) == Point(y1 - x1, y2 - x2)
+    assert -p2 == Point(-y1, -y2)
+    raises(TypeError, lambda: Point(1))
+    raises(ValueError, lambda: Point([1]))
+    raises(ValueError, lambda: Point(3, I))
+    raises(ValueError, lambda: Point(2*I, I))
+    raises(ValueError, lambda: Point(3 + I, I))
+
+    assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
+    assert Point.midpoint(p3, p4) == Point(half, half)
+    assert Point.midpoint(p1, p4) == Point(half + half*x1, half + half*x2)
+    assert Point.midpoint(p2, p2) == p2
+    assert p2.midpoint(p2) == p2
+    assert p1.origin == Point(0, 0)
+
+    assert Point.distance(p3, p4) == sqrt(2)
+    assert Point.distance(p1, p1) == 0
+    assert Point.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2)
+    raises(TypeError, lambda: Point.distance(p1, 0))
+    raises(TypeError, lambda: Point.distance(p1, GeometryEntity()))
+
+    # distance should be symmetric
+    assert p1.distance(line) == line.distance(p1)
+    assert p4.distance(line) == line.distance(p4)
+
+    assert Point.taxicab_distance(p4, p3) == 2
+
+    assert Point.canberra_distance(p4, p5) == 1
+    raises(ValueError, lambda: Point.canberra_distance(p3, p3))
+
+    p1_1 = Point(x1, x1)
+    p1_2 = Point(y2, y2)
+    p1_3 = Point(x1 + 1, x1)
+    assert Point.is_collinear(p3)
+
+    with warns(UserWarning, test_stacklevel=False):
+        assert Point.is_collinear(p3, Point(p3, dim=4))
+    assert p3.is_collinear()
+    assert Point.is_collinear(p3, p4)
+    assert Point.is_collinear(p3, p4, p1_1, p1_2)
+    assert Point.is_collinear(p3, p4, p1_1, p1_3) is False
+    assert Point.is_collinear(p3, p3, p4, p5) is False
+
+    raises(TypeError, lambda: Point.is_collinear(line))
+    raises(TypeError, lambda: p1_1.is_collinear(line))
+
+    assert p3.intersection(Point(0, 0)) == [p3]
+    assert p3.intersection(p4) == []
+    assert p3.intersection(line) == []
+    with warns(UserWarning, test_stacklevel=False):
+        assert Point.intersection(Point(0, 0, 0), Point(0, 0)) == [Point(0, 0, 0)]
+
+    x_pos = Symbol('x', positive=True)
+    p2_1 = Point(x_pos, 0)
+    p2_2 = Point(0, x_pos)
+    p2_3 = Point(-x_pos, 0)
+    p2_4 = Point(0, -x_pos)
+    p2_5 = Point(x_pos, 5)
+    assert Point.is_concyclic(p2_1)
+    assert Point.is_concyclic(p2_1, p2_2)
+    assert Point.is_concyclic(p2_1, p2_2, p2_3, p2_4)
+    for pts in permutations((p2_1, p2_2, p2_3, p2_5)):
+        assert Point.is_concyclic(*pts) is False
+    assert Point.is_concyclic(p4, p4 * 2, p4 * 3) is False
+    assert Point(0, 0).is_concyclic((1, 1), (2, 2), (2, 1)) is False
+    assert Point.is_concyclic(Point(0, 0, 0, 0), Point(1, 0, 0, 0), Point(1, 1, 0, 0), Point(1, 1, 1, 0)) is False
+
+    assert p1.is_scalar_multiple(p1)
+    assert p1.is_scalar_multiple(2*p1)
+    assert not p1.is_scalar_multiple(p2)
+    assert Point.is_scalar_multiple(Point(1, 1), (-1, -1))
+    assert Point.is_scalar_multiple(Point(0, 0), (0, -1))
+    # test when is_scalar_multiple can't be determined
+    raises(Undecidable, lambda: Point.is_scalar_multiple(Point(sympify("x1%y1"), sympify("x2%y2")), Point(0, 1)))
+
+    assert Point(0, 1).orthogonal_direction == Point(1, 0)
+    assert Point(1, 0).orthogonal_direction == Point(0, 1)
+
+    assert p1.is_zero is None
+    assert p3.is_zero
+    assert p4.is_zero is False
+    assert p1.is_nonzero is None
+    assert p3.is_nonzero is False
+    assert p4.is_nonzero
+
+    assert p4.scale(2, 3) == Point(2, 3)
+    assert p3.scale(2, 3) == p3
+
+    assert p4.rotate(pi, Point(0.5, 0.5)) == p3
+    assert p1.__radd__(p2) == p1.midpoint(p2).scale(2, 2)
+    assert (-p3).__rsub__(p4) == p3.midpoint(p4).scale(2, 2)
+
+    assert p4 * 5 == Point(5, 5)
+    assert p4 / 5 == Point(0.2, 0.2)
+    assert 5 * p4 == Point(5, 5)
+
+    raises(ValueError, lambda: Point(0, 0) + 10)
+
+    # Point differences should be simplified
+    assert Point(x*(x - 1), y) - Point(x**2 - x, y + 1) == Point(0, -1)
+
+    a, b = S.Half, Rational(1, 3)
+    assert Point(a, b).evalf(2) == \
+        Point(a.n(2), b.n(2), evaluate=False)
+    raises(ValueError, lambda: Point(1, 2) + 1)
+
+    # test project
+    assert Point.project((0, 1), (1, 0)) == Point(0, 0)
+    assert Point.project((1, 1), (1, 0)) == Point(1, 0)
+    raises(ValueError, lambda: Point.project(p1, Point(0, 0)))
+
+    # test transformations
+    p = Point(1, 0)
+    assert p.rotate(pi/2) == Point(0, 1)
+    assert p.rotate(pi/2, p) == p
+    p = Point(1, 1)
+    assert p.scale(2, 3) == Point(2, 3)
+    assert p.translate(1, 2) == Point(2, 3)
+    assert p.translate(1) == Point(2, 1)
+    assert p.translate(y=1) == Point(1, 2)
+    assert p.translate(*p.args) == Point(2, 2)
+
+    # Check invalid input for transform
+    raises(ValueError, lambda: p3.transform(p3))
+    raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
+
+    # test __contains__
+    assert 0 in Point(0, 0, 0, 0)
+    assert 1 not in Point(0, 0, 0, 0)
+
+    # test affine_rank
+    assert Point.affine_rank() == -1
+
+
+def test_point3D():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    x1 = Symbol('x1', real=True)
+    x2 = Symbol('x2', real=True)
+    x3 = Symbol('x3', real=True)
+    y1 = Symbol('y1', real=True)
+    y2 = Symbol('y2', real=True)
+    y3 = Symbol('y3', real=True)
+    half = S.Half
+    p1 = Point3D(x1, x2, x3)
+    p2 = Point3D(y1, y2, y3)
+    p3 = Point3D(0, 0, 0)
+    p4 = Point3D(1, 1, 1)
+    p5 = Point3D(0, 1, 2)
+
+    assert p1 in p1
+    assert p1 not in p2
+    assert p2.y == y2
+    assert (p3 + p4) == p4
+    assert (p2 - p1) == Point3D(y1 - x1, y2 - x2, y3 - x3)
+    assert -p2 == Point3D(-y1, -y2, -y3)
+
+    assert Point(34.05, sqrt(3)) == Point(Rational(681, 20), sqrt(3))
+    assert Point3D.midpoint(p3, p4) == Point3D(half, half, half)
+    assert Point3D.midpoint(p1, p4) == Point3D(half + half*x1, half + half*x2,
+                                         half + half*x3)
+    assert Point3D.midpoint(p2, p2) == p2
+    assert p2.midpoint(p2) == p2
+
+    assert Point3D.distance(p3, p4) == sqrt(3)
+    assert Point3D.distance(p1, p1) == 0
+    assert Point3D.distance(p3, p2) == sqrt(p2.x**2 + p2.y**2 + p2.z**2)
+
+    p1_1 = Point3D(x1, x1, x1)
+    p1_2 = Point3D(y2, y2, y2)
+    p1_3 = Point3D(x1 + 1, x1, x1)
+    Point3D.are_collinear(p3)
+    assert Point3D.are_collinear(p3, p4)
+    assert Point3D.are_collinear(p3, p4, p1_1, p1_2)
+    assert Point3D.are_collinear(p3, p4, p1_1, p1_3) is False
+    assert Point3D.are_collinear(p3, p3, p4, p5) is False
+
+    assert p3.intersection(Point3D(0, 0, 0)) == [p3]
+    assert p3.intersection(p4) == []
+
+
+    assert p4 * 5 == Point3D(5, 5, 5)
+    assert p4 / 5 == Point3D(0.2, 0.2, 0.2)
+    assert 5 * p4 == Point3D(5, 5, 5)
+
+    raises(ValueError, lambda: Point3D(0, 0, 0) + 10)
+
+    # Test coordinate properties
+    assert p1.coordinates == (x1, x2, x3)
+    assert p2.coordinates == (y1, y2, y3)
+    assert p3.coordinates == (0, 0, 0)
+    assert p4.coordinates == (1, 1, 1)
+    assert p5.coordinates == (0, 1, 2)
+    assert p5.x == 0
+    assert p5.y == 1
+    assert p5.z == 2
+
+    # Point differences should be simplified
+    assert Point3D(x*(x - 1), y, 2) - Point3D(x**2 - x, y + 1, 1) == \
+        Point3D(0, -1, 1)
+
+    a, b, c = S.Half, Rational(1, 3), Rational(1, 4)
+    assert Point3D(a, b, c).evalf(2) == \
+        Point(a.n(2), b.n(2), c.n(2), evaluate=False)
+    raises(ValueError, lambda: Point3D(1, 2, 3) + 1)
+
+    # test transformations
+    p = Point3D(1, 1, 1)
+    assert p.scale(2, 3) == Point3D(2, 3, 1)
+    assert p.translate(1, 2) == Point3D(2, 3, 1)
+    assert p.translate(1) == Point3D(2, 1, 1)
+    assert p.translate(z=1) == Point3D(1, 1, 2)
+    assert p.translate(*p.args) == Point3D(2, 2, 2)
+
+    # Test __new__
+    assert Point3D(0.1, 0.2, evaluate=False, on_morph='ignore').args[0].is_Float
+
+    # Test length property returns correctly
+    assert p.length == 0
+    assert p1_1.length == 0
+    assert p1_2.length == 0
+
+    # Test are_colinear type error
+    raises(TypeError, lambda: Point3D.are_collinear(p, x))
+
+    # Test are_coplanar
+    assert Point.are_coplanar()
+    assert Point.are_coplanar((1, 2, 0), (1, 2, 0), (1, 3, 0))
+    assert Point.are_coplanar((1, 2, 0), (1, 2, 3))
+    with warns(UserWarning, test_stacklevel=False):
+        raises(ValueError, lambda: Point2D.are_coplanar((1, 2), (1, 2, 3)))
+    assert Point3D.are_coplanar((1, 2, 0), (1, 2, 3))
+    assert Point.are_coplanar((0, 0, 0), (1, 1, 0), (1, 1, 1), (1, 2, 1)) is False
+    planar2 = Point3D(1, -1, 1)
+    planar3 = Point3D(-1, 1, 1)
+    assert Point3D.are_coplanar(p, planar2, planar3) == True
+    assert Point3D.are_coplanar(p, planar2, planar3, p3) == False
+    assert Point.are_coplanar(p, planar2)
+    planar2 = Point3D(1, 1, 2)
+    planar3 = Point3D(1, 1, 3)
+    assert Point3D.are_coplanar(p, planar2, planar3)  # line, not plane
+    plane = Plane((1, 2, 1), (2, 1, 0), (3, 1, 2))
+    assert Point.are_coplanar(*[plane.projection(((-1)**i, i)) for i in range(4)])
+
+    # all 2D points are coplanar
+    assert Point.are_coplanar(Point(x, y), Point(x, x + y), Point(y, x + 2)) is True
+
+    # Test Intersection
+    assert planar2.intersection(Line3D(p, planar3)) == [Point3D(1, 1, 2)]
+
+    # Test Scale
+    assert planar2.scale(1, 1, 1) == planar2
+    assert planar2.scale(2, 2, 2, planar3) == Point3D(1, 1, 1)
+    assert planar2.scale(1, 1, 1, p3) == planar2
+
+    # Test Transform
+    identity = Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]])
+    assert p.transform(identity) == p
+    trans = Matrix([[1, 0, 0, 1], [0, 1, 0, 1], [0, 0, 1, 1], [0, 0, 0, 1]])
+    assert p.transform(trans) == Point3D(2, 2, 2)
+    raises(ValueError, lambda: p.transform(p))
+    raises(ValueError, lambda: p.transform(Matrix([[1, 0], [0, 1]])))
+
+    # Test Equals
+    assert p.equals(x1) == False
+
+    # Test __sub__
+    p_4d = Point(0, 0, 0, 1)
+    with warns(UserWarning, test_stacklevel=False):
+        assert p - p_4d == Point(1, 1, 1, -1)
+    p_4d3d = Point(0, 0, 1, 0)
+    with warns(UserWarning, test_stacklevel=False):
+        assert p - p_4d3d == Point(1, 1, 0, 0)
+
+
+def test_Point2D():
+
+    # Test Distance
+    p1 = Point2D(1, 5)
+    p2 = Point2D(4, 2.5)
+    p3 = (6, 3)
+    assert p1.distance(p2) == sqrt(61)/2
+    assert p2.distance(p3) == sqrt(17)/2
+
+    # Test coordinates
+    assert p1.x == 1
+    assert p1.y == 5
+    assert p2.x == 4
+    assert p2.y == S(5)/2
+    assert p1.coordinates == (1, 5)
+    assert p2.coordinates == (4, S(5)/2)
+
+    # test bounds
+    assert p1.bounds == (1, 5, 1, 5)
+
+def test_issue_9214():
+    p1 = Point3D(4, -2, 6)
+    p2 = Point3D(1, 2, 3)
+    p3 = Point3D(7, 2, 3)
+
+    assert Point3D.are_collinear(p1, p2, p3) is False
+
+
+def test_issue_11617():
+    p1 = Point3D(1,0,2)
+    p2 = Point2D(2,0)
+
+    with warns(UserWarning, test_stacklevel=False):
+        assert p1.distance(p2) == sqrt(5)
+
+
+def test_transform():
+    p = Point(1, 1)
+    assert p.transform(rotate(pi/2)) == Point(-1, 1)
+    assert p.transform(scale(3, 2)) == Point(3, 2)
+    assert p.transform(translate(1, 2)) == Point(2, 3)
+    assert Point(1, 1).scale(2, 3, (4, 5)) == \
+        Point(-2, -7)
+    assert Point(1, 1).translate(4, 5) == \
+        Point(5, 6)
+
+
+def test_concyclic_doctest_bug():
+    p1, p2 = Point(-1, 0), Point(1, 0)
+    p3, p4 = Point(0, 1), Point(-1, 2)
+    assert Point.is_concyclic(p1, p2, p3)
+    assert not Point.is_concyclic(p1, p2, p3, p4)
+
+
+def test_arguments():
+    """Functions accepting `Point` objects in `geometry`
+    should also accept tuples and lists and
+    automatically convert them to points."""
+
+    singles2d = ((1,2), [1,2], Point(1,2))
+    singles2d2 = ((1,3), [1,3], Point(1,3))
+    doubles2d = cartes(singles2d, singles2d2)
+    p2d = Point2D(1,2)
+    singles3d = ((1,2,3), [1,2,3], Point(1,2,3))
+    doubles3d = subsets(singles3d, 2)
+    p3d = Point3D(1,2,3)
+    singles4d = ((1,2,3,4), [1,2,3,4], Point(1,2,3,4))
+    doubles4d = subsets(singles4d, 2)
+    p4d = Point(1,2,3,4)
+
+    # test 2D
+    test_single = ['distance', 'is_scalar_multiple', 'taxicab_distance', 'midpoint', 'intersection', 'dot', 'equals', '__add__', '__sub__']
+    test_double = ['is_concyclic', 'is_collinear']
+    for p in singles2d:
+        Point2D(p)
+    for func in test_single:
+        for p in singles2d:
+            getattr(p2d, func)(p)
+    for func in test_double:
+        for p in doubles2d:
+            getattr(p2d, func)(*p)
+
+    # test 3D
+    test_double = ['is_collinear']
+    for p in singles3d:
+        Point3D(p)
+    for func in test_single:
+        for p in singles3d:
+            getattr(p3d, func)(p)
+    for func in test_double:
+        for p in doubles3d:
+            getattr(p3d, func)(*p)
+
+    # test 4D
+    test_double = ['is_collinear']
+    for p in singles4d:
+        Point(p)
+    for func in test_single:
+        for p in singles4d:
+            getattr(p4d, func)(p)
+    for func in test_double:
+        for p in doubles4d:
+            getattr(p4d, func)(*p)
+
+    # test evaluate=False for ops
+    x = Symbol('x')
+    a = Point(0, 1)
+    assert a + (0.1, x) == Point(0.1, 1 + x, evaluate=False)
+    a = Point(0, 1)
+    assert a/10.0 == Point(0, 0.1, evaluate=False)
+    a = Point(0, 1)
+    assert a*10.0 == Point(0, 10.0, evaluate=False)
+
+    # test evaluate=False when changing dimensions
+    u = Point(.1, .2, evaluate=False)
+    u4 = Point(u, dim=4, on_morph='ignore')
+    assert u4.args == (.1, .2, 0, 0)
+    assert all(i.is_Float for i in u4.args[:2])
+    # and even when *not* changing dimensions
+    assert all(i.is_Float for i in Point(u).args)
+
+    # never raise error if creating an origin
+    assert Point(dim=3, on_morph='error')
+
+    # raise error with unmatched dimension
+    raises(ValueError, lambda: Point(1, 1, dim=3, on_morph='error'))
+    # test unknown on_morph
+    raises(ValueError, lambda: Point(1, 1, dim=3, on_morph='unknown'))
+    # test invalid expressions
+    raises(TypeError, lambda: Point(Basic(), Basic()))
+
+def test_unit():
+    assert Point(1, 1).unit == Point(sqrt(2)/2, sqrt(2)/2)
+
+
+def test_dot():
+    raises(TypeError, lambda: Point(1, 2).dot(Line((0, 0), (1, 1))))
+
+
+def test__normalize_dimension():
+    assert Point._normalize_dimension(Point(1, 2), Point(3, 4)) == [
+        Point(1, 2), Point(3, 4)]
+    assert Point._normalize_dimension(
+        Point(1, 2), Point(3, 4, 0), on_morph='ignore') == [
+        Point(1, 2, 0), Point(3, 4, 0)]
+
+
+def test_issue_22684():
+    # Used to give an error
+    with evaluate(False):
+        Point(1, 2)
+
+
+def test_direction_cosine():
+    p1 = Point3D(0, 0, 0)
+    p2 = Point3D(1, 1, 1)
+
+    assert p1.direction_cosine(Point3D(1, 0, 0)) == [1, 0, 0]
+    assert p1.direction_cosine(Point3D(0, 1, 0)) == [0, 1, 0]
+    assert p1.direction_cosine(Point3D(0, 0, pi)) == [0, 0, 1]
+
+    assert p1.direction_cosine(Point3D(5, 0, 0)) == [1, 0, 0]
+    assert p1.direction_cosine(Point3D(0, sqrt(3), 0)) == [0, 1, 0]
+    assert p1.direction_cosine(Point3D(0, 0, 5)) == [0, 0, 1]
+
+    assert p1.direction_cosine(Point3D(2.4, 2.4, 0)) == [sqrt(2)/2, sqrt(2)/2, 0]
+    assert p1.direction_cosine(Point3D(1, 1, 1)) == [sqrt(3) / 3, sqrt(3) / 3, sqrt(3) / 3]
+    assert p1.direction_cosine(Point3D(-12, 0 -15)) == [-4*sqrt(41)/41, -5*sqrt(41)/41, 0]
+
+    assert p2.direction_cosine(Point3D(0, 0, 0)) == [-sqrt(3) / 3, -sqrt(3) / 3, -sqrt(3) / 3]
+    assert p2.direction_cosine(Point3D(1, 1, 12)) == [0, 0, 1]
+    assert p2.direction_cosine(Point3D(12, 1, 12)) == [sqrt(2) / 2, 0, sqrt(2) / 2]
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_polygon.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_polygon.py
new file mode 100644
index 0000000000000000000000000000000000000000..520023349f363bdb12146465305c2a5650c80934
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_polygon.py
@@ -0,0 +1,676 @@
+from sympy.core.numbers import (Float, Rational, oo, pi)
+from sympy.core.singleton import S
+from sympy.core.symbol import (Symbol, symbols)
+from sympy.functions.elementary.complexes import Abs
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.functions.elementary.trigonometric import (acos, cos, sin)
+from sympy.functions.elementary.trigonometric import tan
+from sympy.geometry import (Circle, Ellipse, GeometryError, Point, Point2D,
+                            Polygon, Ray, RegularPolygon, Segment, Triangle,
+                            are_similar, convex_hull, intersection, Line, Ray2D)
+from sympy.testing.pytest import raises, slow, warns
+from sympy.core.random import verify_numerically
+from sympy.geometry.polygon import rad, deg
+from sympy.integrals.integrals import integrate
+from sympy.utilities.iterables import rotate_left
+
+
+def feq(a, b):
+    """Test if two floating point values are 'equal'."""
+    t_float = Float("1.0E-10")
+    return -t_float < a - b < t_float
+
+@slow
+def test_polygon():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    q = Symbol('q', real=True)
+    u = Symbol('u', real=True)
+    v = Symbol('v', real=True)
+    w = Symbol('w', real=True)
+    x1 = Symbol('x1', real=True)
+    half = S.Half
+    a, b, c = Point(0, 0), Point(2, 0), Point(3, 3)
+    t = Triangle(a, b, c)
+    assert Polygon(Point(0, 0)) == Point(0, 0)
+    assert Polygon(a, Point(1, 0), b, c) == t
+    assert Polygon(Point(1, 0), b, c, a) == t
+    assert Polygon(b, c, a, Point(1, 0)) == t
+    # 2 "remove folded" tests
+    assert Polygon(a, Point(3, 0), b, c) == t
+    assert Polygon(a, b, Point(3, -1), b, c) == t
+    # remove multiple collinear points
+    assert Polygon(Point(-4, 15), Point(-11, 15), Point(-15, 15),
+        Point(-15, 33/5), Point(-15, -87/10), Point(-15, -15),
+        Point(-42/5, -15), Point(-2, -15), Point(7, -15), Point(15, -15),
+        Point(15, -3), Point(15, 10), Point(15, 15)) == \
+        Polygon(Point(-15, -15), Point(15, -15), Point(15, 15), Point(-15, 15))
+
+    p1 = Polygon(
+        Point(0, 0), Point(3, -1),
+        Point(6, 0), Point(4, 5),
+        Point(2, 3), Point(0, 3))
+    p2 = Polygon(
+        Point(6, 0), Point(3, -1),
+        Point(0, 0), Point(0, 3),
+        Point(2, 3), Point(4, 5))
+    p3 = Polygon(
+        Point(0, 0), Point(3, 0),
+        Point(5, 2), Point(4, 4))
+    p4 = Polygon(
+        Point(0, 0), Point(4, 4),
+        Point(5, 2), Point(3, 0))
+    p5 = Polygon(
+        Point(0, 0), Point(4, 4),
+        Point(0, 4))
+    p6 = Polygon(
+        Point(-11, 1), Point(-9, 6.6),
+        Point(-4, -3), Point(-8.4, -8.7))
+    p7 = Polygon(
+        Point(x, y), Point(q, u),
+        Point(v, w))
+    p8 = Polygon(
+        Point(x, y), Point(v, w),
+        Point(q, u))
+    p9 = Polygon(
+        Point(0, 0), Point(4, 4),
+        Point(3, 0), Point(5, 2))
+    p10 = Polygon(
+        Point(0, 2), Point(2, 2),
+        Point(0, 0), Point(2, 0))
+    p11 = Polygon(Point(0, 0), 1, n=3)
+    p12 = Polygon(Point(0, 0), 1, 0, n=3)
+    p13 = Polygon(
+        Point(0, 0),Point(8, 8),
+        Point(23, 20),Point(0, 20))
+    p14 = Polygon(*rotate_left(p13.args, 1))
+
+
+    r = Ray(Point(-9, 6.6), Point(-9, 5.5))
+    #
+    # General polygon
+    #
+    assert p1 == p2
+    assert len(p1.args) == 6
+    assert len(p1.sides) == 6
+    assert p1.perimeter == 5 + 2*sqrt(10) + sqrt(29) + sqrt(8)
+    assert p1.area == 22
+    assert not p1.is_convex()
+    assert Polygon((-1, 1), (2, -1), (2, 1), (-1, -1), (3, 0)
+        ).is_convex() is False
+    # ensure convex for both CW and CCW point specification
+    assert p3.is_convex()
+    assert p4.is_convex()
+    dict5 = p5.angles
+    assert dict5[Point(0, 0)] == pi / 4
+    assert dict5[Point(0, 4)] == pi / 2
+    assert p5.encloses_point(Point(x, y)) is None
+    assert p5.encloses_point(Point(1, 3))
+    assert p5.encloses_point(Point(0, 0)) is False
+    assert p5.encloses_point(Point(4, 0)) is False
+    assert p1.encloses(Circle(Point(2.5, 2.5), 5)) is False
+    assert p1.encloses(Ellipse(Point(2.5, 2), 5, 6)) is False
+    assert p5.plot_interval('x') == [x, 0, 1]
+    assert p5.distance(
+        Polygon(Point(10, 10), Point(14, 14), Point(10, 14))) == 6 * sqrt(2)
+    assert p5.distance(
+        Polygon(Point(1, 8), Point(5, 8), Point(8, 12), Point(1, 12))) == 4
+    with warns(UserWarning, \
+               match="Polygons may intersect producing erroneous output"):
+        Polygon(Point(0, 0), Point(1, 0), Point(1, 1)).distance(
+                Polygon(Point(0, 0), Point(0, 1), Point(1, 1)))
+    assert hash(p5) == hash(Polygon(Point(0, 0), Point(4, 4), Point(0, 4)))
+    assert hash(p1) == hash(p2)
+    assert hash(p7) == hash(p8)
+    assert hash(p3) != hash(p9)
+    assert p5 == Polygon(Point(4, 4), Point(0, 4), Point(0, 0))
+    assert Polygon(Point(4, 4), Point(0, 4), Point(0, 0)) in p5
+    assert p5 != Point(0, 4)
+    assert Point(0, 1) in p5
+    assert p5.arbitrary_point('t').subs(Symbol('t', real=True), 0) == \
+        Point(0, 0)
+    raises(ValueError, lambda: Polygon(
+        Point(x, 0), Point(0, y), Point(x, y)).arbitrary_point('x'))
+    assert p6.intersection(r) == [Point(-9, Rational(-84, 13)), Point(-9, Rational(33, 5))]
+    assert p10.area == 0
+    assert p11 == RegularPolygon(Point(0, 0), 1, 3, 0)
+    assert p11 == p12
+    assert p11.vertices[0] == Point(1, 0)
+    assert p11.args[0] == Point(0, 0)
+    p11.spin(pi/2)
+    assert p11.vertices[0] == Point(0, 1)
+    #
+    # Regular polygon
+    #
+    p1 = RegularPolygon(Point(0, 0), 10, 5)
+    p2 = RegularPolygon(Point(0, 0), 5, 5)
+    raises(GeometryError, lambda: RegularPolygon(Point(0, 0), Point(0,
+           1), Point(1, 1)))
+    raises(GeometryError, lambda: RegularPolygon(Point(0, 0), 1, 2))
+    raises(ValueError, lambda: RegularPolygon(Point(0, 0), 1, 2.5))
+
+    assert p1 != p2
+    assert p1.interior_angle == pi*Rational(3, 5)
+    assert p1.exterior_angle == pi*Rational(2, 5)
+    assert p2.apothem == 5*cos(pi/5)
+    assert p2.circumcenter == p1.circumcenter == Point(0, 0)
+    assert p1.circumradius == p1.radius == 10
+    assert p2.circumcircle == Circle(Point(0, 0), 5)
+    assert p2.incircle == Circle(Point(0, 0), p2.apothem)
+    assert p2.inradius == p2.apothem == (5 * (1 + sqrt(5)) / 4)
+    p2.spin(pi / 10)
+    dict1 = p2.angles
+    assert dict1[Point(0, 5)] == 3 * pi / 5
+    assert p1.is_convex()
+    assert p1.rotation == 0
+    assert p1.encloses_point(Point(0, 0))
+    assert p1.encloses_point(Point(11, 0)) is False
+    assert p2.encloses_point(Point(0, 4.9))
+    p1.spin(pi/3)
+    assert p1.rotation == pi/3
+    assert p1.vertices[0] == Point(5, 5*sqrt(3))
+    for var in p1.args:
+        if isinstance(var, Point):
+            assert var == Point(0, 0)
+        else:
+            assert var in (5, 10, pi / 3)
+    assert p1 != Point(0, 0)
+    assert p1 != p5
+
+    # while spin works in place (notice that rotation is 2pi/3 below)
+    # rotate returns a new object
+    p1_old = p1
+    assert p1.rotate(pi/3) == RegularPolygon(Point(0, 0), 10, 5, pi*Rational(2, 3))
+    assert p1 == p1_old
+
+    assert p1.area == (-250*sqrt(5) + 1250)/(4*tan(pi/5))
+    assert p1.length == 20*sqrt(-sqrt(5)/8 + Rational(5, 8))
+    assert p1.scale(2, 2) == \
+        RegularPolygon(p1.center, p1.radius*2, p1._n, p1.rotation)
+    assert RegularPolygon((0, 0), 1, 4).scale(2, 3) == \
+        Polygon(Point(2, 0), Point(0, 3), Point(-2, 0), Point(0, -3))
+
+    assert repr(p1) == str(p1)
+
+    #
+    # Angles
+    #
+    angles = p4.angles
+    assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+    assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+    assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+    assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+    angles = p3.angles
+    assert feq(angles[Point(0, 0)].evalf(), Float("0.7853981633974483"))
+    assert feq(angles[Point(4, 4)].evalf(), Float("1.2490457723982544"))
+    assert feq(angles[Point(5, 2)].evalf(), Float("1.8925468811915388"))
+    assert feq(angles[Point(3, 0)].evalf(), Float("2.3561944901923449"))
+
+    # https://github.com/sympy/sympy/issues/24885
+    interior_angles_sum = sum(p13.angles.values())
+    assert feq(interior_angles_sum, (len(p13.angles) - 2)*pi )
+    interior_angles_sum = sum(p14.angles.values())
+    assert feq(interior_angles_sum, (len(p14.angles) - 2)*pi )
+
+    #
+    # Triangle
+    #
+    p1 = Point(0, 0)
+    p2 = Point(5, 0)
+    p3 = Point(0, 5)
+    t1 = Triangle(p1, p2, p3)
+    t2 = Triangle(p1, p2, Point(Rational(5, 2), sqrt(Rational(75, 4))))
+    t3 = Triangle(p1, Point(x1, 0), Point(0, x1))
+    s1 = t1.sides
+    assert Triangle(p1, p2, p1) == Polygon(p1, p2, p1) == Segment(p1, p2)
+    raises(GeometryError, lambda: Triangle(Point(0, 0)))
+
+    # Basic stuff
+    assert Triangle(p1, p1, p1) == p1
+    assert Triangle(p2, p2*2, p2*3) == Segment(p2, p2*3)
+    assert t1.area == Rational(25, 2)
+    assert t1.is_right()
+    assert t2.is_right() is False
+    assert t3.is_right()
+    assert p1 in t1
+    assert t1.sides[0] in t1
+    assert Segment((0, 0), (1, 0)) in t1
+    assert Point(5, 5) not in t2
+    assert t1.is_convex()
+    assert feq(t1.angles[p1].evalf(), pi.evalf()/2)
+
+    assert t1.is_equilateral() is False
+    assert t2.is_equilateral()
+    assert t3.is_equilateral() is False
+    assert are_similar(t1, t2) is False
+    assert are_similar(t1, t3)
+    assert are_similar(t2, t3) is False
+    assert t1.is_similar(Point(0, 0)) is False
+    assert t1.is_similar(t2) is False
+
+    # Bisectors
+    bisectors = t1.bisectors()
+    assert bisectors[p1] == Segment(
+        p1, Point(Rational(5, 2), Rational(5, 2)))
+    assert t2.bisectors()[p2] == Segment(
+        Point(5, 0), Point(Rational(5, 4), 5*sqrt(3)/4))
+    p4 = Point(0, x1)
+    assert t3.bisectors()[p4] == Segment(p4, Point(x1*(sqrt(2) - 1), 0))
+    ic = (250 - 125*sqrt(2))/50
+    assert t1.incenter == Point(ic, ic)
+
+    # Inradius
+    assert t1.inradius == t1.incircle.radius == 5 - 5*sqrt(2)/2
+    assert t2.inradius == t2.incircle.radius == 5*sqrt(3)/6
+    assert t3.inradius == t3.incircle.radius == x1**2/((2 + sqrt(2))*Abs(x1))
+
+    # Exradius
+    assert t1.exradii[t1.sides[2]] == 5*sqrt(2)/2
+
+    # Excenters
+    assert t1.excenters[t1.sides[2]] == Point2D(25*sqrt(2), -5*sqrt(2)/2)
+
+    # Circumcircle
+    assert t1.circumcircle.center == Point(2.5, 2.5)
+
+    # Medians + Centroid
+    m = t1.medians
+    assert t1.centroid == Point(Rational(5, 3), Rational(5, 3))
+    assert m[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+    assert t3.medians[p1] == Segment(p1, Point(x1/2, x1/2))
+    assert intersection(m[p1], m[p2], m[p3]) == [t1.centroid]
+    assert t1.medial == Triangle(Point(2.5, 0), Point(0, 2.5), Point(2.5, 2.5))
+
+    # Nine-point circle
+    assert t1.nine_point_circle == Circle(Point(2.5, 0),
+                                          Point(0, 2.5), Point(2.5, 2.5))
+    assert t1.nine_point_circle == Circle(Point(0, 0),
+                                          Point(0, 2.5), Point(2.5, 2.5))
+
+    # Perpendicular
+    altitudes = t1.altitudes
+    assert altitudes[p1] == Segment(p1, Point(Rational(5, 2), Rational(5, 2)))
+    assert altitudes[p2].equals(s1[0])
+    assert altitudes[p3] == s1[2]
+    assert t1.orthocenter == p1
+    t = S('''Triangle(
+    Point(100080156402737/5000000000000, 79782624633431/500000000000),
+    Point(39223884078253/2000000000000, 156345163124289/1000000000000),
+    Point(31241359188437/1250000000000, 338338270939941/1000000000000000))''')
+    assert t.orthocenter == S('''Point(-780660869050599840216997'''
+    '''79471538701955848721853/80368430960602242240789074233100000000000000,'''
+    '''20151573611150265741278060334545897615974257/16073686192120448448157'''
+    '''8148466200000000000)''')
+
+    # Ensure
+    assert len(intersection(*bisectors.values())) == 1
+    assert len(intersection(*altitudes.values())) == 1
+    assert len(intersection(*m.values())) == 1
+
+    # Distance
+    p1 = Polygon(
+        Point(0, 0), Point(1, 0),
+        Point(1, 1), Point(0, 1))
+    p2 = Polygon(
+        Point(0, Rational(5)/4), Point(1, Rational(5)/4),
+        Point(1, Rational(9)/4), Point(0, Rational(9)/4))
+    p3 = Polygon(
+        Point(1, 2), Point(2, 2),
+        Point(2, 1))
+    p4 = Polygon(
+        Point(1, 1), Point(Rational(6)/5, 1),
+        Point(1, Rational(6)/5))
+    pt1 = Point(half, half)
+    pt2 = Point(1, 1)
+
+    '''Polygon to Point'''
+    assert p1.distance(pt1) == half
+    assert p1.distance(pt2) == 0
+    assert p2.distance(pt1) == Rational(3)/4
+    assert p3.distance(pt2) == sqrt(2)/2
+
+    '''Polygon to Polygon'''
+    # p1.distance(p2) emits a warning
+    with warns(UserWarning, \
+               match="Polygons may intersect producing erroneous output"):
+        assert p1.distance(p2) == half/2
+
+    assert p1.distance(p3) == sqrt(2)/2
+
+    # p3.distance(p4) emits a warning
+    with warns(UserWarning, \
+               match="Polygons may intersect producing erroneous output"):
+        assert p3.distance(p4) == (sqrt(2)/2 - sqrt(Rational(2)/25)/2)
+
+
+def test_convex_hull():
+    p = [Point(-5, -1), Point(-2, 1), Point(-2, -1), Point(-1, -3), \
+         Point(0, 0), Point(1, 1), Point(2, 2), Point(2, -1), Point(3, 1), \
+         Point(4, -1), Point(6, 2)]
+    ch = Polygon(p[0], p[3], p[9], p[10], p[6], p[1])
+    #test handling of duplicate points
+    p.append(p[3])
+
+    #more than 3 collinear points
+    another_p = [Point(-45, -85), Point(-45, 85), Point(-45, 26), \
+                 Point(-45, -24)]
+    ch2 = Segment(another_p[0], another_p[1])
+
+    assert convex_hull(*another_p) == ch2
+    assert convex_hull(*p) == ch
+    assert convex_hull(p[0]) == p[0]
+    assert convex_hull(p[0], p[1]) == Segment(p[0], p[1])
+
+    # no unique points
+    assert convex_hull(*[p[-1]]*3) == p[-1]
+
+    # collection of items
+    assert convex_hull(*[Point(0, 0), \
+                        Segment(Point(1, 0), Point(1, 1)), \
+                        RegularPolygon(Point(2, 0), 2, 4)]) == \
+        Polygon(Point(0, 0), Point(2, -2), Point(4, 0), Point(2, 2))
+
+
+def test_encloses():
+    # square with a dimpled left side
+    s = Polygon(Point(0, 0), Point(1, 0), Point(1, 1), Point(0, 1), \
+        Point(S.Half, S.Half))
+    # the following is True if the polygon isn't treated as closing on itself
+    assert s.encloses(Point(0, S.Half)) is False
+    assert s.encloses(Point(S.Half, S.Half)) is False  # it's a vertex
+    assert s.encloses(Point(Rational(3, 4), S.Half)) is True
+
+
+def test_triangle_kwargs():
+    assert Triangle(sss=(3, 4, 5)) == \
+        Triangle(Point(0, 0), Point(3, 0), Point(3, 4))
+    assert Triangle(asa=(30, 2, 30)) == \
+        Triangle(Point(0, 0), Point(2, 0), Point(1, sqrt(3)/3))
+    assert Triangle(sas=(1, 45, 2)) == \
+        Triangle(Point(0, 0), Point(2, 0), Point(sqrt(2)/2, sqrt(2)/2))
+    assert Triangle(sss=(1, 2, 5)) is None
+    assert deg(rad(180)) == 180
+
+
+def test_transform():
+    pts = [Point(0, 0), Point(S.Half, Rational(1, 4)), Point(1, 1)]
+    pts_out = [Point(-4, -10), Point(-3, Rational(-37, 4)), Point(-2, -7)]
+    assert Triangle(*pts).scale(2, 3, (4, 5)) == Triangle(*pts_out)
+    assert RegularPolygon((0, 0), 1, 4).scale(2, 3, (4, 5)) == \
+        Polygon(Point(-2, -10), Point(-4, -7), Point(-6, -10), Point(-4, -13))
+    # Checks for symmetric scaling
+    assert RegularPolygon((0, 0), 1, 4).scale(2, 2) == \
+        RegularPolygon(Point2D(0, 0), 2, 4, 0)
+
+def test_reflect():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    b = Symbol('b')
+    m = Symbol('m')
+    l = Line((0, b), slope=m)
+    p = Point(x, y)
+    r = p.reflect(l)
+    dp = l.perpendicular_segment(p).length
+    dr = l.perpendicular_segment(r).length
+
+    assert verify_numerically(dp, dr)
+
+    assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=oo)) \
+        == Triangle(Point(5, 0), Point(4, 0), Point(4, 2))
+    assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=oo)) \
+        == Triangle(Point(-1, 0), Point(-2, 0), Point(-2, 2))
+    assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((0, 3), slope=0)) \
+        == Triangle(Point(1, 6), Point(2, 6), Point(2, 4))
+    assert Polygon((1, 0), (2, 0), (2, 2)).reflect(Line((3, 0), slope=0)) \
+        == Triangle(Point(1, 0), Point(2, 0), Point(2, -2))
+
+def test_bisectors():
+    p1, p2, p3 = Point(0, 0), Point(1, 0), Point(0, 1)
+    p = Polygon(Point(0, 0), Point(2, 0), Point(1, 1), Point(0, 3))
+    q = Polygon(Point(1, 0), Point(2, 0), Point(3, 3), Point(-1, 5))
+    poly = Polygon(Point(3, 4), Point(0, 0), Point(8, 7), Point(-1, 1), Point(19, -19))
+    t = Triangle(p1, p2, p3)
+    assert t.bisectors()[p2] == Segment(Point(1, 0), Point(0, sqrt(2) - 1))
+    assert p.bisectors()[Point2D(0, 3)] == Ray2D(Point2D(0, 3), \
+        Point2D(sin(acos(2*sqrt(5)/5)/2), 3 - cos(acos(2*sqrt(5)/5)/2)))
+    assert q.bisectors()[Point2D(-1, 5)] == \
+        Ray2D(Point2D(-1, 5), Point2D(-1 + sqrt(29)*(5*sin(acos(9*sqrt(145)/145)/2) + \
+        2*cos(acos(9*sqrt(145)/145)/2))/29, sqrt(29)*(-5*cos(acos(9*sqrt(145)/145)/2) + \
+        2*sin(acos(9*sqrt(145)/145)/2))/29 + 5))
+    assert poly.bisectors()[Point2D(-1, 1)] == Ray2D(Point2D(-1, 1), \
+        Point2D(-1 + sin(acos(sqrt(26)/26)/2 + pi/4), 1 - sin(-acos(sqrt(26)/26)/2 + pi/4)))
+
+def test_incenter():
+    assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).incenter \
+        == Point(1 - sqrt(2)/2, 1 - sqrt(2)/2)
+
+def test_inradius():
+    assert Triangle(Point(0, 0), Point(4, 0), Point(0, 3)).inradius == 1
+
+def test_incircle():
+    assert Triangle(Point(0, 0), Point(2, 0), Point(0, 2)).incircle \
+        == Circle(Point(2 - sqrt(2), 2 - sqrt(2)), 2 - sqrt(2))
+
+def test_exradii():
+    t = Triangle(Point(0, 0), Point(6, 0), Point(0, 2))
+    assert t.exradii[t.sides[2]] == (-2 + sqrt(10))
+
+def test_medians():
+    t = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+    assert t.medians[Point(0, 0)] == Segment(Point(0, 0), Point(S.Half, S.Half))
+
+def test_medial():
+    assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).medial \
+        == Triangle(Point(S.Half, 0), Point(S.Half, S.Half), Point(0, S.Half))
+
+def test_nine_point_circle():
+    assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).nine_point_circle \
+        == Circle(Point2D(Rational(1, 4), Rational(1, 4)), sqrt(2)/4)
+
+def test_eulerline():
+    assert Triangle(Point(0, 0), Point(1, 0), Point(0, 1)).eulerline \
+        == Line(Point2D(0, 0), Point2D(S.Half, S.Half))
+    assert Triangle(Point(0, 0), Point(10, 0), Point(5, 5*sqrt(3))).eulerline \
+        == Point2D(5, 5*sqrt(3)/3)
+    assert Triangle(Point(4, -6), Point(4, -1), Point(-3, 3)).eulerline \
+        == Line(Point2D(Rational(64, 7), 3), Point2D(Rational(-29, 14), Rational(-7, 2)))
+
+def test_intersection():
+    poly1 = Triangle(Point(0, 0), Point(1, 0), Point(0, 1))
+    poly2 = Polygon(Point(0, 1), Point(-5, 0),
+                    Point(0, -4), Point(0, Rational(1, 5)),
+                    Point(S.Half, -0.1), Point(1, 0), Point(0, 1))
+
+    assert poly1.intersection(poly2) == [Point2D(Rational(1, 3), 0),
+        Segment(Point(0, Rational(1, 5)), Point(0, 0)),
+        Segment(Point(1, 0), Point(0, 1))]
+    assert poly2.intersection(poly1) == [Point(Rational(1, 3), 0),
+        Segment(Point(0, 0), Point(0, Rational(1, 5))),
+        Segment(Point(1, 0), Point(0, 1))]
+    assert poly1.intersection(Point(0, 0)) == [Point(0, 0)]
+    assert poly1.intersection(Point(-12,  -43)) == []
+    assert poly2.intersection(Line((-12, 0), (12, 0))) == [Point(-5, 0),
+        Point(0, 0), Point(Rational(1, 3), 0), Point(1, 0)]
+    assert poly2.intersection(Line((-12, 12), (12, 12))) == []
+    assert poly2.intersection(Ray((-3, 4), (1, 0))) == [Segment(Point(1, 0),
+        Point(0, 1))]
+    assert poly2.intersection(Circle((0, -1), 1)) == [Point(0, -2),
+        Point(0, 0)]
+    assert poly1.intersection(poly1) == [Segment(Point(0, 0), Point(1, 0)),
+        Segment(Point(0, 1), Point(0, 0)), Segment(Point(1, 0), Point(0, 1))]
+    assert poly2.intersection(poly2) == [Segment(Point(-5, 0), Point(0, -4)),
+        Segment(Point(0, -4), Point(0, Rational(1, 5))),
+        Segment(Point(0, Rational(1, 5)), Point(S.Half, Rational(-1, 10))),
+        Segment(Point(0, 1), Point(-5, 0)),
+        Segment(Point(S.Half, Rational(-1, 10)), Point(1, 0)),
+        Segment(Point(1, 0), Point(0, 1))]
+    assert poly2.intersection(Triangle(Point(0, 1), Point(1, 0), Point(-1, 1))) \
+        == [Point(Rational(-5, 7), Rational(6, 7)), Segment(Point2D(0, 1), Point(1, 0))]
+    assert poly1.intersection(RegularPolygon((-12, -15), 3, 3)) == []
+
+
+def test_parameter_value():
+    t = Symbol('t')
+    sq = Polygon((0, 0), (0, 1), (1, 1), (1, 0))
+    assert sq.parameter_value((0.5, 1), t) == {t: Rational(3, 8)}
+    q = Polygon((0, 0), (2, 1), (2, 4), (4, 0))
+    assert q.parameter_value((4, 0), t) == {t: -6 + 3*sqrt(5)} # ~= 0.708
+
+    raises(ValueError, lambda: sq.parameter_value((5, 6), t))
+    raises(ValueError, lambda: sq.parameter_value(Circle(Point(0, 0), 1), t))
+
+
+def test_issue_12966():
+    poly = Polygon(Point(0, 0), Point(0, 10), Point(5, 10), Point(5, 5),
+        Point(10, 5), Point(10, 0))
+    t = Symbol('t')
+    pt = poly.arbitrary_point(t)
+    DELTA = 5/poly.perimeter
+    assert [pt.subs(t, DELTA*i) for i in range(int(1/DELTA))] == [
+        Point(0, 0), Point(0, 5), Point(0, 10), Point(5, 10),
+        Point(5, 5), Point(10, 5), Point(10, 0), Point(5, 0)]
+
+
+def test_second_moment_of_area():
+    x, y = symbols('x, y')
+    # triangle
+    p1, p2, p3 = [(0, 0), (4, 0), (0, 2)]
+    p = (0, 0)
+    # equation of hypotenuse
+    eq_y = (1-x/4)*2
+    I_yy = integrate((x**2) * (integrate(1, (y, 0, eq_y))), (x, 0, 4))
+    I_xx = integrate(1 * (integrate(y**2, (y, 0, eq_y))), (x, 0, 4))
+    I_xy = integrate(x * (integrate(y, (y, 0, eq_y))), (x, 0, 4))
+
+    triangle = Polygon(p1, p2, p3)
+
+    assert (I_xx - triangle.second_moment_of_area(p)[0]) == 0
+    assert (I_yy - triangle.second_moment_of_area(p)[1]) == 0
+    assert (I_xy - triangle.second_moment_of_area(p)[2]) == 0
+
+    # rectangle
+    p1, p2, p3, p4=[(0, 0), (4, 0), (4, 2), (0, 2)]
+    I_yy = integrate((x**2) * integrate(1, (y, 0, 2)), (x, 0, 4))
+    I_xx = integrate(1 * integrate(y**2, (y, 0, 2)), (x, 0, 4))
+    I_xy = integrate(x * integrate(y, (y, 0, 2)), (x, 0, 4))
+
+    rectangle = Polygon(p1, p2, p3, p4)
+
+    assert (I_xx - rectangle.second_moment_of_area(p)[0]) == 0
+    assert (I_yy - rectangle.second_moment_of_area(p)[1]) == 0
+    assert (I_xy - rectangle.second_moment_of_area(p)[2]) == 0
+
+
+    r = RegularPolygon(Point(0, 0), 5, 3)
+    assert r.second_moment_of_area() == (1875*sqrt(3)/S(32), 1875*sqrt(3)/S(32), 0)
+
+
+def test_first_moment():
+    a, b  = symbols('a, b', positive=True)
+    # rectangle
+    p1 = Polygon((0, 0), (a, 0), (a, b), (0, b))
+    assert p1.first_moment_of_area() == (a*b**2/8, a**2*b/8)
+    assert p1.first_moment_of_area((a/3, b/4)) == (-3*a*b**2/32, -a**2*b/9)
+
+    p1 = Polygon((0, 0), (40, 0), (40, 30), (0, 30))
+    assert p1.first_moment_of_area() == (4500, 6000)
+
+    # triangle
+    p2 = Polygon((0, 0), (a, 0), (a/2, b))
+    assert p2.first_moment_of_area() == (4*a*b**2/81, a**2*b/24)
+    assert p2.first_moment_of_area((a/8, b/6)) == (-25*a*b**2/648, -5*a**2*b/768)
+
+    p2 = Polygon((0, 0), (12, 0), (12, 30))
+    assert p2.first_moment_of_area() == (S(1600)/3, -S(640)/3)
+
+
+def test_section_modulus_and_polar_second_moment_of_area():
+    a, b = symbols('a, b', positive=True)
+    x, y = symbols('x, y')
+    rectangle = Polygon((0, b), (0, 0), (a, 0), (a, b))
+    assert rectangle.section_modulus(Point(x, y)) == (a*b**3/12/(-b/2 + y), a**3*b/12/(-a/2 + x))
+    assert rectangle.polar_second_moment_of_area() == a**3*b/12 + a*b**3/12
+
+    convex = RegularPolygon((0, 0), 1, 6)
+    assert convex.section_modulus() == (Rational(5, 8), sqrt(3)*Rational(5, 16))
+    assert convex.polar_second_moment_of_area() == 5*sqrt(3)/S(8)
+
+    concave = Polygon((0, 0), (1, 8), (3, 4), (4, 6), (7, 1))
+    assert concave.section_modulus() == (Rational(-6371, 429), Rational(-9778, 519))
+    assert concave.polar_second_moment_of_area() == Rational(-38669, 252)
+
+
+def test_cut_section():
+    # concave polygon
+    p = Polygon((-1, -1), (1, Rational(5, 2)), (2, 1), (3, Rational(5, 2)), (4, 2), (5, 3), (-1, 3))
+    l = Line((0, 0), (Rational(9, 2), 3))
+    p1 = p.cut_section(l)[0]
+    p2 = p.cut_section(l)[1]
+    assert p1 == Polygon(
+        Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(1, Rational(5, 2)), Point2D(Rational(24, 13), Rational(16, 13)),
+        Point2D(Rational(12, 5), Rational(8, 5)), Point2D(3, Rational(5, 2)), Point2D(Rational(24, 7), Rational(16, 7)),
+        Point2D(Rational(9, 2), 3), Point2D(-1, 3), Point2D(-1, Rational(-2, 3)))
+    assert p2 == Polygon(Point2D(-1, -1), Point2D(Rational(-9, 13), Rational(-6, 13)), Point2D(Rational(24, 13), Rational(16, 13)),
+        Point2D(2, 1), Point2D(Rational(12, 5), Rational(8, 5)), Point2D(Rational(24, 7), Rational(16, 7)), Point2D(4, 2), Point2D(5, 3),
+        Point2D(Rational(9, 2), 3), Point2D(-1, Rational(-2, 3)))
+
+    # convex polygon
+    p = RegularPolygon(Point2D(0, 0), 6, 6)
+    s = p.cut_section(Line((0, 0), slope=1))
+    assert s[0] == Polygon(Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9), Point2D(3, 3*sqrt(3)),
+        Point2D(-3, 3*sqrt(3)), Point2D(-6, 0), Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)))
+    assert s[1] == Polygon(Point2D(6, 0), Point2D(-3*sqrt(3) + 9, -3*sqrt(3) + 9),
+        Point2D(-9 + 3*sqrt(3), -9 + 3*sqrt(3)), Point2D(-3, -3*sqrt(3)), Point2D(3, -3*sqrt(3)))
+
+    # case where line does not intersects but coincides with the edge of polygon
+    a, b = 20, 10
+    t1, t2, t3, t4 = [(0, b), (0, 0), (a, 0), (a, b)]
+    p = Polygon(t1, t2, t3, t4)
+    p1, p2 = p.cut_section(Line((0, b), slope=0))
+    assert p1 == None
+    assert p2 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+
+    p3, p4 = p.cut_section(Line((0, 0), slope=0))
+    assert p3 == Polygon(Point2D(0, 10), Point2D(0, 0), Point2D(20, 0), Point2D(20, 10))
+    assert p4 == None
+
+    # case where the line does not intersect with a polygon at all
+    raises(ValueError, lambda: p.cut_section(Line((0, a), slope=0)))
+
+def test_type_of_triangle():
+    # Isoceles triangle
+    p1 = Polygon(Point(0, 0), Point(5, 0), Point(2, 4))
+    assert p1.is_isosceles() == True
+    assert p1.is_scalene() == False
+    assert p1.is_equilateral() == False
+
+    # Scalene triangle
+    p2 = Polygon (Point(0, 0), Point(0, 2), Point(4, 0))
+    assert p2.is_isosceles() == False
+    assert p2.is_scalene() == True
+    assert p2.is_equilateral() == False
+
+    # Equilateral triangle
+    p3 = Polygon(Point(0, 0), Point(6, 0), Point(3, sqrt(27)))
+    assert p3.is_isosceles() == True
+    assert p3.is_scalene() == False
+    assert p3.is_equilateral() == True
+
+def test_do_poly_distance():
+    # Non-intersecting polygons
+    square1 = Polygon (Point(0, 0), Point(0, 1), Point(1, 1), Point(1, 0))
+    triangle1 = Polygon(Point(1, 2), Point(2, 2), Point(2, 1))
+    assert square1._do_poly_distance(triangle1) == sqrt(2)/2
+
+    # Polygons which sides intersect
+    square2 = Polygon(Point(1, 0), Point(2, 0), Point(2, 1), Point(1, 1))
+    with warns(UserWarning, \
+               match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+        assert square1._do_poly_distance(square2) == 0
+
+    # Polygons which bodies intersect
+    triangle2 = Polygon(Point(0, -1), Point(2, -1), Point(S.Half, S.Half))
+    with warns(UserWarning, \
+               match="Polygons may intersect producing erroneous output", test_stacklevel=False):
+        assert triangle2._do_poly_distance(square1) == 0
diff --git a/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_util.py b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..da52a795a9383c6438ca06303e8ae6506dccdc65
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/sympy/geometry/tests/test_util.py
@@ -0,0 +1,170 @@
+import pytest
+from sympy.core.numbers import Float
+from sympy.core.function import (Derivative, Function)
+from sympy.core.singleton import S
+from sympy.core.symbol import Symbol
+from sympy.functions import exp, cos, sin, tan, cosh, sinh
+from sympy.functions.elementary.miscellaneous import sqrt
+from sympy.geometry import Point, Point2D, Line, Polygon, Segment, convex_hull,\
+    intersection, centroid, Point3D, Line3D, Ray, Ellipse
+from sympy.geometry.util import idiff, closest_points, farthest_points, _ordered_points, are_coplanar
+from sympy.solvers.solvers import solve
+from sympy.testing.pytest import raises
+
+
+def test_idiff():
+    x = Symbol('x', real=True)
+    y = Symbol('y', real=True)
+    t = Symbol('t', real=True)
+    f = Function('f')
+    g = Function('g')
+    # the use of idiff in ellipse also provides coverage
+    circ = x**2 + y**2 - 4
+    ans = -3*x*(x**2/y**2 + 1)/y**3
+    assert ans == idiff(circ, y, x, 3), idiff(circ, y, x, 3)
+    assert ans == idiff(circ, [y], x, 3)
+    assert idiff(circ, y, x, 3) == ans
+    explicit  = 12*x/sqrt(-x**2 + 4)**5
+    assert ans.subs(y, solve(circ, y)[0]).equals(explicit)
+    assert True in [sol.diff(x, 3).equals(explicit) for sol in solve(circ, y)]
+    assert idiff(x + t + y, [y, t], x) == -Derivative(t, x) - 1
+    assert idiff(f(x) * exp(f(x)) - x * exp(x), f(x), x) == (x + 1)*exp(x)*exp(-f(x))/(f(x) + 1)
+    assert idiff(f(x) - y * exp(x), [f(x), y], x) == (y + Derivative(y, x))*exp(x)
+    assert idiff(f(x) - y * exp(x), [y, f(x)], x) == -y + Derivative(f(x), x)*exp(-x)
+    assert idiff(f(x) - g(x), [f(x), g(x)], x) == Derivative(g(x), x)
+    # this should be fast
+    fxy = y - (-10*(-sin(x) + 1/x)**2 + tan(x)**2 + 2*cosh(x/10))
+    assert idiff(fxy, y, x) == -20*sin(x)*cos(x) + 2*tan(x)**3 + \
+        2*tan(x) + sinh(x/10)/5 + 20*cos(x)/x - 20*sin(x)/x**2 + 20/x**3
+
+
+def test_intersection():
+    assert intersection(Point(0, 0)) == []
+    raises(TypeError, lambda: intersection(Point(0, 0), 3))
+    assert intersection(
+            Segment((0, 0), (2, 0)),
+            Segment((-1, 0), (1, 0)),
+            Line((0, 0), (0, 1)), pairwise=True) == [
+        Point(0, 0), Segment((0, 0), (1, 0))]
+    assert intersection(
+            Line((0, 0), (0, 1)),
+            Segment((0, 0), (2, 0)),
+            Segment((-1, 0), (1, 0)), pairwise=True) == [
+        Point(0, 0), Segment((0, 0), (1, 0))]
+    assert intersection(
+            Line((0, 0), (0, 1)),
+            Segment((0, 0), (2, 0)),
+            Segment((-1, 0), (1, 0)),
+            Line((0, 0), slope=1), pairwise=True) == [
+        Point(0, 0), Segment((0, 0), (1, 0))]
+    R = 4.0
+    c = intersection(
+            Ray(Point2D(0.001, -1),
+            Point2D(0.0008, -1.7)),
+            Ellipse(center=Point2D(0, 0), hradius=R, vradius=2.0), pairwise=True)[0].coordinates
+    assert c == pytest.approx(
+            Point2D(0.000714285723396502, -1.99999996811224, evaluate=False).coordinates)
+    # check this is responds to a lower precision parameter
+    R = Float(4, 5)
+    c2 = intersection(
+            Ray(Point2D(0.001, -1),
+            Point2D(0.0008, -1.7)),
+            Ellipse(center=Point2D(0, 0), hradius=R, vradius=2.0), pairwise=True)[0].coordinates
+    assert c2 == pytest.approx(
+            Point2D(0.000714285723396502, -1.99999996811224, evaluate=False).coordinates)
+    assert c[0]._prec == 53
+    assert c2[0]._prec == 20
+
+
+def test_convex_hull():
+    raises(TypeError, lambda: convex_hull(Point(0, 0), 3))
+    points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+    assert convex_hull(*points, **{"polygon": False}) == (
+        [Point2D(-5, -2), Point2D(1, -1), Point2D(3, -1), Point2D(15, -4)],
+        [Point2D(-5, -2), Point2D(15, -4)])
+
+
+def test_centroid():
+    p = Polygon((0, 0), (10, 0), (10, 10))
+    q = p.translate(0, 20)
+    assert centroid(p, q) == Point(20, 40)/3
+    p = Segment((0, 0), (2, 0))
+    q = Segment((0, 0), (2, 2))
+    assert centroid(p, q) == Point(1, -sqrt(2) + 2)
+    assert centroid(Point(0, 0), Point(2, 0)) == Point(2, 0)/2
+    assert centroid(Point(0, 0), Point(0, 0), Point(2, 0)) == Point(2, 0)/3
+
+
+def test_farthest_points_closest_points():
+    from sympy.core.random import randint
+    from sympy.utilities.iterables import subsets
+
+    for how in (min, max):
+        if how == min:
+            func = closest_points
+        else:
+            func = farthest_points
+
+        raises(ValueError, lambda: func(Point2D(0, 0), Point2D(0, 0)))
+
+        # 3rd pt dx is close and pt is closer to 1st pt
+        p1 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 1)]
+        # 3rd pt dx is close and pt is closer to 2nd pt
+        p2 = [Point2D(0, 0), Point2D(3, 0), Point2D(2, 1)]
+        # 3rd pt dx is close and but pt is not closer
+        p3 = [Point2D(0, 0), Point2D(3, 0), Point2D(1, 10)]
+        # 3rd pt dx is not closer and it's closer to 2nd pt
+        p4 = [Point2D(0, 0), Point2D(3, 0), Point2D(4, 0)]
+        # 3rd pt dx is not closer and it's closer to 1st pt
+        p5 = [Point2D(0, 0), Point2D(3, 0), Point2D(-1, 0)]
+        # duplicate point doesn't affect outcome
+        dup = [Point2D(0, 0), Point2D(3, 0), Point2D(3, 0), Point2D(-1, 0)]
+        # symbolic
+        x = Symbol('x', positive=True)
+        s = [Point2D(a) for a in ((x, 1), (x + 3, 2), (x + 2, 2))]
+
+        for points in (p1, p2, p3, p4, p5, dup, s):
+            d = how(i.distance(j) for i, j in subsets(set(points), 2))
+            ans = a, b = list(func(*points))[0]
+            assert a.distance(b) == d
+            assert ans == _ordered_points(ans)
+
+        # if the following ever fails, the above tests were not sufficient
+        # and the logical error in the routine should be fixed
+        points = set()
+        while len(points) != 7:
+            points.add(Point2D(randint(1, 100), randint(1, 100)))
+        points = list(points)
+        d = how(i.distance(j) for i, j in subsets(points, 2))
+        ans = a, b = list(func(*points))[0]
+        assert a.distance(b) == d
+        assert ans == _ordered_points(ans)
+
+    # equidistant points
+    a, b, c = (
+        Point2D(0, 0), Point2D(1, 0), Point2D(S.Half, sqrt(3)/2))
+    ans = {_ordered_points((i, j))
+        for i, j in subsets((a, b, c), 2)}
+    assert closest_points(b, c, a) == ans
+    assert farthest_points(b, c, a) == ans
+
+    # unique to farthest
+    points = [(1, 1), (1, 2), (3, 1), (-5, 2), (15, 4)]
+    assert farthest_points(*points) == {
+        (Point2D(-5, 2), Point2D(15, 4))}
+    points = [(1, -1), (1, -2), (3, -1), (-5, -2), (15, -4)]
+    assert farthest_points(*points) == {
+        (Point2D(-5, -2), Point2D(15, -4))}
+    assert farthest_points((1, 1), (0, 0)) == {
+        (Point2D(0, 0), Point2D(1, 1))}
+    raises(ValueError, lambda: farthest_points((1, 1)))
+
+
+def test_are_coplanar():
+    a = Line3D(Point3D(5, 0, 0), Point3D(1, -1, 1))
+    b = Line3D(Point3D(0, -2, 0), Point3D(3, 1, 1))
+    c = Line3D(Point3D(0, -1, 0), Point3D(5, -1, 9))
+    d = Line(Point2D(0, 3), Point2D(1, 5))
+
+    assert are_coplanar(a, b, c) == False
+    assert are_coplanar(a, d) == False


+  

+    
+      
+    
+  

+
+

+
+[notebooks](https://github.com/roboflow/notebooks) | [inference](https://github.com/roboflow/inference) | [autodistill](https://github.com/autodistill/autodistill) | [maestro](https://github.com/roboflow/multimodal-maestro)
+
+

+
+[![version](https://badge.fury.io/py/supervision.svg)](https://badge.fury.io/py/supervision) [![downloads](https://img.shields.io/pypi/dm/supervision)](https://pypistats.org/packages/supervision) [![license](https://img.shields.io/pypi/l/supervision)](LICENSE.md) [![python-version](https://img.shields.io/pypi/pyversions/supervision)](https://badge.fury.io/py/supervision) [![codecov](https://codecov.io/gh/roboflow/supervision/graph/badge.svg?token=HMNJ5FVZ36)](https://codecov.io/gh/roboflow/supervision)
+
+[![Snyk Security](https://img.shields.io/badge/Snyk-Security-4C4A73?logo=snyk)](https://security.snyk.io/package/pip/supervision) [![colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/roboflow/supervision/blob/main/demo.ipynb) [![gradio](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/Roboflow/Annotators) [![discord](https://img.shields.io/discord/1159501506232451173?logo=discord&label=discord&labelColor=fff&color=5865f2&link=https%3A%2F%2Fdiscord.gg%2FGbfgXGJ8Bk)](https://discord.gg/GbfgXGJ8Bk)
+
+

+    roboflow%2Fsupervision | Trendshift
+  

+
+